Provided by: manpages-es_1.55-3_all bug

NOMBRE

       rpc - rutinas de biblioteca para llamadas a procedimientos remotos

SINOPSIS Y DESCRIPCIÓN

       Estas  rutinas  permiten  a  los  programas  en  C  realizar llamadas a
       procedimientos en otras máquinas a  través  de  la  red.   Primero,  el
       cliente  llama  a  un  procedimiento para enviar un paquete de datos al
       servidor. A la llegada del paquete, el servidor llama a una  rutina  de
       atención  que realiza el servicio solicitado, y a continuación envía de
       vuelta una respuesta.  Finalmente, la llamada al procedimiento  termina
       y vuelve al cliente.

       Las  rutinas  que  se  usan  para  RPC  seguro  (autenticación  DES) se
       describen en rpc_secure(3).  RPC seguro  sólo  se  puede  usar  si  hay
       disponible cifrado DES.

       #include <rpc/rpc.h>

       void
       auth_destroy(auth)
       AUTH *auth;

              Una  macro que destruye la información de autenticación asociada
              a auth.  La  destrucción  usalmente  implica  la  liberación  de
              estructuras de datos privadas. El uso de auth es indefinido trás
              llamar a auth_destroy().

       AUTH *
       authnone_create()

              Crea y devuelve una asa (handle) de autenticación RPC  que  pasa
              información  de  autenticación  inservible  en  cada  llamada  a
              procedimientos remotos. Esta es  la  autenticación  por  omisión
              usada por el sistema RPC.

       AUTH *
       authunix_create(host, uid, gid, len, aup_gids)
       char *host;
       int uid, gid, len, *aup.gids;

              Crea  y  devuelve  una  asa  de  autenticación  RPC que contiene
              información de autenticación.  El parámetro host es el nombre de
              la  máquina en la que se ha creado la información.  uid es el ID
              del usuario.  gid es el ID del grupo actual del usuario.  len  y
              aup_gids  se  refieren a un array de grupos a los que el usuario
              pertenece.  Es fácil hacerse pasar por un usuario.

       AUTH *
       authunix_create_default()

              Llama a authunix_create() con los parámetros apropiados.

       callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out)
       char *host;
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;

              Llama al procedimiento remoto  asociado  a  prognum,  versnum  y
              procnum de la máquina host.  El parámetro in es la dirección del
              (los) argumento(s) del procedimiento,  y  out  es  la  dirección
              donde  colocar  el  (los)  resultado(s).   inproc  se  usa  para
              codificar los parámetros del procedimiento,  y  outproc  se  usa
              para  decodificar los resultados del procedimiento.  Esta rutina
              devuelve cero en caso de éxtio o  el  valor  de  enum  clnt_stat
              convertido  a  un  entero,  en  caso  de  de  fallo.   La rutina
              clnt_perrno() es adecuada  para  traducir  estados  de  fallo  a
              mensajes.

              Cuidado:  la llamada a procedimientos con esta rutina usa UDP/IP
              como  protocolo  de  transporte.   Vea   clntudp_create()   para
              restricciones.    No   tiene  control  de  plazos  de  tiempo  o
              autenticación usando esta rutina.

       enum clnt_stat
       clnt_broadcast(prognum, versnum, procnum, inproc, in, outproc, out, eachresult)
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       resultproc_t eachresult;

              Como callrpc(), salvo que el mensaje de llamada es  difundido  a
              todas  las redes de difusión conectadas localmente. Cada vez que
              recibe una respuesta, esta rutina  llama  a  eachresult(),  cuyo
              formato es:

                 eachresult(out, addr)
                 char *out;
                 struct sockaddr_in *addr;

              donde out es lo mimo que el out pasado a clnt_broadcast(), salvo
              que la salida del procedimiento remoto se decodifica allí.  addr
              apunta  a  la  dirección  de  la  máquina  que  ha  devuelto los
              resultados.  Si  eachresult()  devuelve  cero,  clnt_broadcast()
              espera  más  respuestas.  En  otro  caso,  termina con un estado
              apropiado.

              Cuidado: los conectores de difusión están limitados en tamaño  a
              la  unidad  de  transferencia  máxima  del enlace de datos. Para
              Ethernet, este valor es 1500 bytes.

       enum clnt_stat
       clnt_call(clnt, procnum, inproc, in, outproc, out, tout)
       CLIENT *clnt;
       u_long
       procnum;
       xdrproc_t inproc, outproc;
       char *in, *out;
       struct timeval tout;

              Una macro que llama al procedimiento remoto procnum  asociado  a
              la  asa  de  cliente  clnt,  que  se  obtiene  con una rutina de
              creación de clientes RPC tal como clnt_create().   El  parámetro
              in  es  la dirección del (los) argumento(s) del procedimiento, y
              out es la dirección donde colocar el (los) resultado(s).  inproc
              se  usa  para  codificar  los  parámetros  del  procedimiento, y
              outproc   se   usa   para   decodificar   los   resultados   del
              procedimiento.   tout  es  el plazo de tiempo permitido para que
              los resultados lleguen.

       clnt_destroy(clnt)
       CLIENT *clnt;

              Una macro que destruye la asa RPC del  cliente.  La  destrucción
              usualmente   implica  la  liberación  de  estructuras  de  datos
              privadas,  incluyendo  el  propio  clnt.   El  uso  de  clnt  es
              indefinido  tras  llamar a clnt_destroy().  Si la biblioteca RPC
              abrió el conector asociado, también lo cerrará.  En  otro  caso,
              el conector permanece abierto.

       CLIENT *
       clnt_create(host, prog, vers, proto)
       char *host;
       u_long prog, vers;
       char *proto;

              Rutina  genérica  para la creación de clientes.  host identifica
              el nombre del anfitrión remoto donde se encuentra  el  servidor.
              proto  indica qué clase de protocolo de transporte se usará. Los
              valores actualmente soportados  para  este  campo  son  “udp”  y
              “tcp”.   Se  establecen los plazos de tiempo por omisión, aunque
              se pueden modificar usando clnt_control().

              Cuidado: el uso de UDP tiene sus defectos. Ya que  los  mensajes
              RPC  basados en UDP sólo pueden contener hasta 8 Kbytes de dados
              codificados, este protocolo de transporte no se puede usar  para
              procedimientos   que   toman   grandes  argumentos  o  devuelven
              resultados enormes.

       bool_t
       clnt_control(cl, req, info)
       CLIENT *cl;
       char *info;

              Una macro usada para cambiar u obtener información diversa sobre
              un objeto cliente.  req indica el tipo de operación e info es un
              puntero a la información. Tanto para  UDP  como  para  TCP,  los
              valores  soportados  de  req,  y sus tipos de argumento y lo que
              hacen los mismos, son:

              CLSET_TIMEOUT       struct timeval      establece el plazo de
                                                      tiempo total
              CLGET_TIMEOUT       struct timeval      obtiene el plazo de
                                                      tiempo total

              Nota: si establece el plazo de tiempo usando clnt_control(),  el
              parámetro de plazo de tiempo pasado a clnt_call() se ignorará en
              todas las llamadas futuras.

              CLGET_SERVER_ADDR   struct sockaddr_in  obtiene la dirección
                                                      del servidor

              Las siguientes operaciones sólo son válidas para UDP:

              CLSET_RETRY_TIMEOUT struct timeval      establece el plazo
                                                      para reintento
              CLGET_RETRY_TIMEOUT struct timeval      obtiene el plazo
                                                      de reintento

              El plazo de reintento es el tiempo que la RPC UDP espera  a  que
              el servidor responda antes de retransmitir la petición.

       clnt_freeres(clnt, outproc, out)
       CLIENT *clnt;
       xdrproc_t outproc;
       char *out;

              Una  macro  que  libera  cualquier dato reservado por el sistema
              RPC/XDR cuando decodifica los resultados de una llamada RPC.  El
              parámetro out es la dirección de los resultados, y outproc es la
              rutina XDR que describe los resultados.   Esta  rutina  devuelve
              uno  si los resultados se han liberado con éxito, y cero en caso
              contrario.

       void
       clnt_geterr(clnt, errp)
       CLIENT *clnt;
       struct rpc_err *errp;

              Una macro que copia la estructura de error de la asa del cliente
              a la estructura en la dirección errp.

       void
       clnt_pcreateerror(s)
       char *s;

              Muestra  un mensaje en la salida estándar de error indicando por
              qué no se ha podido crear una asa RPC de cliente.  El mensaje es
              preterminado  con  la cadena s y un carácter dos puntos.  Se usa
              cuando   una   llamada   a   clnt_create(),    clntraw_create(),
              clnttcp_create() o clntudp_create() falla.

       void
       clnt_perrno(stat)
       enum clnt_stat stat;

              Muestra   un   mensaje   en   la   salida   de   error  estándar
              correspondiente a la condición indicada por stat.  Se  usa  tras
              un callrpc().

       clnt_perror(clnt, s)
       CLIENT *clnt;
       char *s;

              Muestra  un mensaje en la salida de error estándar indicando por
              qué ha fallado una llamada RPC.  clnt es la asa usada para hacer
              la  llamada.   El  mensaje  es preterminado con la cadena s y un
              carácter dos puntos.  Se usa tras un clnt_call().

       char *
       clnt_spcreateerror
       char *s;

              Como clnt_pcreateerror(), excepto que  devuelve  una  cadena  en
              lugar  de mostrar la información en la salida estándar de error.

              Fallos:  devuelve  un  puntero  a   datos   estáticos   que   se
              sobrescriben en cada llamada.

       char *
       clnt_sperrno(stat)
       enum clnt_stat stat;

              Toma  los  mismos argumentos que clnt_perrno(), pero en lugar de
              enviar un mensaje a la salida de error  estándar  indicando  por
              qué ha fallado una llamada RPC, devuelve un puntero a una cadena
              que contiene el mensaje.  La  cadena  termina  con  un  carácter
              NEWLINE (nueva línea).

              clnt_sperrno()  se  usa en lugar de clnt_perrno() si el programa
              no tiene una salida de error estándar (como es bastante probable
              en  un  programa que funciona como servidor) o si el programador
              no quiere que el mensaje sea mostrado con printf, o si se  va  a
              usar   un   formato  de  mensaje  diferente  del  soportado  por
              clnt_perrno().   Nota:  a   diferencia   de   clnt_sperror()   y
              clnt_spcreaterror(),  clnt_sperrno() devuelve un puntero a datos
              estáticos pero el resultado no se sobrescribirá en cada llamada.

       char *
       clnt_sperror(rpch, s)
       CLIENT *rpch;
       char *s;

              Igual   que   clnt_perror(),  salvo  que  (como  clnt_sperrno())
              devuelve una cadena en lugar de mostrar el mensaje por la salida
              estándar de error.

              Fallos:   devuelve   un   puntero   a  datos  estáticos  que  se
              sobrescriben en cada llamada.

       CLIENT *
       clntraw_create(prognum, versnum)
       u_long prognum, versnum;

              Esta rutina crea un cliente RPC de juguete (de mentira) para  el
              programa  remoto  prognum,  con  versión  versnum.   El medio de
              transporte usado para pasar mensajes al servicio es realmente un
              buffer dentro del espacio de direcciones del proceso, por lo que
              el servidor RPC correspondiente  debería  residir  en  el  mismo
              espacio  de  direcciones.  Vea svcraw_create().  Esto permite la
              simulación de RPCs y la estimación de sobrecargas RPC, tal  como
              el tiempo de ida y vuelta, sin ninguna interferencia del núcleo.
              Esta rutina devuelve NULL si falla.

       CLIENT *
       clnttcp_create(addr, prognum, versnum, sockp, sendsz, recvsz)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       int *sockp;
       u_int sendsz, recvsz;

              Esta rutina crea un cliente RPC para el programa remoto prognum,
              con  versión  versnum.   El cliente usa TCP/IP como protocolo de
              transporte. El programa remoto se encuentra en la  dirección  de
              Internet  *addr.   Si  addr->sin_port  es  cero,  entonces se le
              asigna el puerto  real  por  el  que  el  programa  remoto  está
              escuchando   (para  obtener  esta  información  se  consulta  el
              servicio portmap remoto). El parámetro sockp es un conector.  Si
              vale  RPC_ANYSOCK,  entonces  esta rutina abre uno nuevo y se lo
              asigna a sockp.  Ya que la RPC basada en TCP  usa  E/S  mediante
              buffers,  el ususario puede especificar el tamaño de los buffers
              de envío y recepción con los parámetros sendsz  y  recvsz.   Los
              valores  cero hacen que se elijan valores por omisión adecuados.
              Esta rutina devuelve NULL si falla.

       CLIENT *
       clntudp_create(addr, prognum, versnum, wait, sockp)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       struct timeval wait;
       int *sockp;

              Esta rutina crea un cliente RPC para el programa remoto prognum,
              con  versión  versnum.   El cliente usa UDP/IP como protocolo de
              transporte. El programa remoto se encuentra en la  dirección  de
              Internet addr.  Si addr->sin_port es cero, entonces se le asigna
              el puerto real por el que el  programa  remoto  está  escuchando
              (para  obtener  esta información se consulta el servicio portmap
              remoto). El parámetro sockp es un conector. Si vale RPC_ANYSOCK,
              esta  rutina  abre  uno  nuevo  y  se  lo  asigna  a  sockp.  El
              transporte UDP reenvía los mensajes de llamada a  intervalos  de
              tiempo  wait  hasta  que  se recibe una respuesta o hasta que la
              llamada agota su plazo de tiempo.  El plazo total de tiempo para
              la llamada se especifica en clnt_call().

              Cuidado:  ya que los mensajes RPC basados en RPC UDP sólo pueden
              contener 8  Kbytes  de  datos  codificados,  este  protocolo  de
              transporte  no  se  puede  usar  para  procedimientos  que toman
              grandes argumentos o devuelven resultados enormes.

       CLIENT *
       clntudp_bufcreate(addr, prognum, versnum, wait, sockp, sendsize, recosize)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       struct timeval wait;
       int *sockp;
       unsigned int sendsize;
       unsigned int recosize;

              Esta rutina crea un cliente RPC para el programa remoto prognum,
              con  versión  versnum.   El cliente usa UDP/IP como protocolo de
              transporte. El programa remoto se encuentra en la  dirección  de
              Internet  addr.   Si  addr->sin_port  es  cero,  se le asigna el
              puerto real por le que escucha el programa remoto (para  obtener
              esta  información  se  consulta  el servicio portmap remoto). El
              parámetro sockp es un conector. Si vale RPC_ANYSOCK, esta rutina
              abre  uno  nuevo  y  se  lo  asigna  a  sockp.   El protocolo de
              transporte UDP reenvía el mensaje de  llamada  a  intervalos  de
              tiempo  wait  hasta  que  se recibe una respuesta o hasta que la
              llamada agota su plazo de tiempo.  El plazo total de tiempo para
              la llamada viene especificado por clnt_call().

              Esta  permite al usuario especificar el tamaño máximo de paquete
              para enviar y recibir mensajes RPC basados en UDP.

       void
       get_myaddress(addr)
       struct sockaddr_in *addr;

              Rellena *addr con la dirección IP de la  máquina  sin  consultar
              las  rutinas  de  biblioteca  que  tratan  con /etc/hosts.  Como
              número de puerto siempre se asigna htons(PMAPPORT).

       struct pmaplist *
       pmap_getmaps(addr)
       struct sockaddr_in *addr;

              Una interfaz de usuario para el servicio  portmap  que  devuelve
              una  lista de las asociaciones "programa RPC-puerto" actuales de
              la máquina que se encuentra en  la  dirección  IP  *addr.   Esta
              rutina  puede  devolver  NULL  .  La orden ‘rpcinfo -p’ usa esta
              rutina.

       u_short
       pmap_getport(addr, prognum, versnum, protocol)
       struct sockaddr_in *addr;
       u_long prognum, versnum, protocol;

              Una interfaz de usuario para el servicio portmap que devuelve el
              número  de  puerto  en  el que espera un servicio que soporta el
              número de programa prognum, con  versión  versnum,  y  habla  el
              protocolo  de  transporte  asociado  con protocol.  El valor más
              probable de  protocol  es  IPPROTO_UDP  o  IPPROTO_TCP.   Si  se
              devuelve  un  valor cero significa que no existe la asociación o
              que el sistema RPC ha  fallado  al  intentar  contactar  con  el
              servicio portmap remoto. En este último caso, la variable global
              rpc_createerr() contiene el estado de la RPC.

       enum clnt_stat
       pmap_rmtcall(addr, prognum, versnum, procnum, inproc, in, outproc, out, tout, portp)
       struct sockaddr_in *addr;
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       struct timeval tout;
       u_long *portp;

              Una interfaz de usuario para el servicio portmap que  ordena  al
              portmap  de  la  máquina  de  dirección IP *addr que realice una
              llamada RPC en su nombre a un procedimiento en esa máquina.   Al
              parámetro *portp se le asignará el número de puerto del programa
              si el procedimiento tiene éxito. Las definiciones de  los  otros
              parámetros   se  discuten  en  callrpc()  y  clnt_call().   Este
              procedimiento se debería  usar  para  “ping”  y  nada  más.  Vea
              también clnt_broadcast().

       pmap_set(prognum, versnum, protocol, port)
       u_long prognum, versnum, protocol;
       u_short port;

              Una  interfaz  de usuario para el servicio portmap que establece
              una correspondencia entre la terna [prognum,versnum,protocol]  y
              port,  en  el  servicio  portmap  de  la  máquina.  El valor más
              probable de protocol es IPPROTO_UDP o IPPROTO_TCP.  Esta  rutina
              devuelve  uno  si  tiene  éxito  y cero en caso contrario. Hecho
              automáticamente por svc_register().

       pmap_unset(prognum, versnum)
       u_long prognum, versnum;

              Una interfaz de usuario para el servicio  portmap  que  destruye
              todas  las correspondencias entre la terna [prognum,versnum,*] y
              los ports del  servicio  portmap  de  la  máquina.  Esta  rutina
              devuelve uno si tiene éxito y cero en caso contrario.

       registerrpc(prognum, versnum, procnum, procname, inproc, outproc)
       u_long prognum, versnum, procnum;
       char *(*procname) () ;
       xdrproc_t inproc, outproc;

              Registra  el  procedimiento  procname en el paquete de servicios
              RPC.  Si llega  una  petición  para  el  programa  prognum,  con
              versión  versnum,  y  procedimiento procnum, se llama a procname
              con un puntero a su(s) parámetro(s).  progname debería  devolver
              un puntero a su(s) resultado(s) estático(s).  inproc se usa para
              decodificar los parámetros mientras  que  outproc  se  usa  para
              codificar  los  resultados.   Esta  rutina  devuelve  cero si el
              registro tiene éxtio y -1 en caso contrario.

              Cuidado: se accede a los procedimientos remotos  registrados  de
              esta  forma  usando  el  protocolo  de  transporte  UDP/IP.  Vea
              svcudp_create() para restricciones.

       struct rpc_createerr     rpc_createerr;

              Una variable global cuyo  valor  es  establecido  por  cualquier
              rutina  de  creación  de clientes RPC que no tiene éxito. Use la
              rutina clnt_pcreateerror() para mostrar el por qué.

       svc_destroy(xprt)
       SVCXPRT *
       xprt;

              Una macro que destruye la asa de transporte de un servicio  RPC,
              xprt.   La  destrucción  usualmente  implica  la  liberación  de
              estructuras de datos privadas, incluyendo el  propio  xprt.   El
              uso de xprt es indefinido tras llamar a esta rutina.

       fd_set svc_fdset;

              Una  variable  global  que  refleja  la  máscara  de bits de los
              descriptores de ficheros de lectura del lado del  servicio  RPC.
              Esta  variable  es  adecuada  como  parámetro  de  la llamada al
              sistema select.  Sólo es  de  interés  si  un  implementador  de
              servicios  no  llama  a  svc_run(), sino que más bien realiza su
              propio procesamiento de eventos asíncronos.  Esta variable es de
              sólo-lectura  (¡no  pase  su  dirección a select!), aunque puede
              cambiar tras llamar a svc_getreqset() o a  cualquier  rutina  de
              creación.

       int svc_fds;

              Similar  a  svc_fedset(),  pero limitada a 32 descriptores. Esta
              interfaz queda obsoleta debido a svc_fdset().

       svc_freeargs(xprt, inproc, in)
       SVCXPRT *xprt;
       xdrproc_t inproc;
       char *in;

              Una macro que libera cualquier dato  reservado  por  el  sistema
              RPC/XDR  cuando  decodificó los argumentos a un procedimiento de
              servicio usando svc_getargs().  Esta rutina devuelve  1  si  los
              resultados se han liberado con éxito y cero en caso contrario.

       svc_getargs(xprt, inproc, in)
       SVCXPRT *xprt;
       xdrproc_t inproc;
       char *in;

              Una  macro  que  decodifica  los  argumentos de una petición RPC
              asociada con la asa de transporte de un servicio RPC  xprt.   El
              parámetro  in es la dirección donde se colocarán los argumentos.
              inproc es la rutina XDR usada para decodificar  los  argumentos.
              Esta  rutina  devuelve 1 si la decodificación tiene éxito y cero
              en caso contrario.

       struct sockaddr_in *
       svc_getcaller(xprt)
       SVCXPRT *xprt;

              La manera permitida de obtener la dirección de red del invocador
              de  un  procedimiento  asociado  con  la asa de transporte de un
              servicio RPC, xprt.

       svc_getreqset(rdfds)
       fd_set *rdfds;

              Esta rutina sólo es de interés si un implementador de  servicios
              no  llama  a  svc_run(),  sino  que  en  su  lugar implementa un
              procesamiento de eventos  asíncronos  a  su  medida.   Se  llama
              cuando  la  llamada  al  sistema  select  ha  determinado que ha
              llegado una petición RPC en algún conector  RPC.   rdfds  es  la
              máscara  de  bits  resultante  de  descriptores  de  ficheros de
              lectura.  La rutina termina cuando  se  han  servido  todos  los
              conectores asociados con el valor de rdfds.

       svc_getreq(rdfds)
       int rdfds;

              Similar a svc_getreqset(), pero limitada a 32 descriptores. Esta
              interfaz queda obsoleta debido a svc_getreqset().

       svc_register(xprt, prognum, versnum, dispatch, protocol)
       SVCXPRT *xprt;
       u_long prognum, versnum;
       void (*dispatch) ();
       u_long protocol;

              Asocia prognum y versnum con el  procedimiento  de  atención  de
              servicio,  dispatch.   Si  protocol  es  cero, el servicio no se
              registra con el servicio portmap.  Si protocol no  es  cero,  se
              establece     una     correspondencia     entre     la     terna
              [prognum,versnum,protocol]  y  xprt->xp_port  con  el   servicio
              portmap  local  (generalmente  protocol  es  cero, IPPROTO_UDP o
              IPPROTO_TCP).  El  procedimiento  dispatch  tiene  el  siguiente
              formato:
                 dispatch(request, xprt)
                 struct svc_req *request;
                 SVCXPRT *xprt;

              La rutina svc_register() devuelve uno en caso de éxito y cero en
              caso contrario.

       svc_run()

              Esta rutina nunca regresa. Espera la llegada de peticiones RPC y
              llama al procedimiento de servicio apropiado usando svc_getreq()
              cuando llega una. Usualmente, este procedimiento está  esperando
              a que termine una llamada al sistema select().

       svc_sendreply(xprt, outproc, out)
       SVCXPRT *xprt;
       xdrproc_t outproc;
       char *out;

              Llamada  por  una  rutina  de  atención  de un servicio RPC para
              enviar los resultados de una llamada a un procedimiento  remoto.
              El  parámetro  xprt  es  la  asa  de  transporte  asociada de la
              petición.  outproc es la rutina XDR que se  usa  para  codificar
              los  resultados.  Y out es la dirección de los resultados.  Esta
              rutina devuelve uno si tiene éxito y cero en caso contrario.

       void
       svc_unregister(prognum, versnum)
       u_long prognum, versnum;

              Elimina   todas    las    correspondencias    entre    el    par
              [prognum,versnum]  y  las  rutinas de atención, y entre la terna
              [prognum,versnum,*] y el número de puerto.

       void
       svcerr_auth(xprt, why)
       SVCXPRT *xprt;
       enum auth_stat why;

              Llamada por una rutina de  atención  de  servicios  que  rechaza
              realizar una llamada a un procedimiento remoto debido a un error
              de autenticación.

       void
       svcerr_decode(xprt)
       SVCXPRT *xprt;

              Llamada por una rutina de atención de  servicios  que  no  puede
              decodificar con éxito sus parámetros. Vea también svc_getargs().

       void
       svcerr_noproc(xprt)
       SVCXPRT *xprt;

              Llamada por una rutina de atención de servicios que no  implanta
              el número de procedimiento que solicita el invocador.

       void
       svcerr_noprog(xprt)
       SVCXPRT *xprt;

              Llamada  cuando  el  programa  deseado  no está registrado en el
              paquete RPC.  Usualmente, los implementadores  de  servicios  no
              necesitan esta rutina.

       void
       svcerr_progvers(xprt)
       SVCXPRT *xprt;

              Llamada  cuando  la  versión  deseada  de  un  programa  no está
              registrada en el paquete RPC.  Usualmente,  los  implementadores
              de servicios no necesitan esta rutina.

       void
       svcerr_systemerr(xprt)
       SVCXPRT *xprt;

              Llamada  por  una rutina de atención de servicios cuando detecta
              un error de sistema no cubierto por ningún protocolo particular.
              Por ejemplo, si un servicio no puede ya reservar almacenamiento,
              puede llamar a esta rutina.

       void
       svcerr_weakauth(xprt)
       SVCXPRT *xprt;

              Llamada por una rutina de  atención  de  servicios  que  rechaza
              realizar   una  llamada  a  un  procedimiento  remoto  debido  a
              insuficientes parámetros de autenticación.  La  rutina  llama  a
              svcerr_auth(xprt, AUTH_TOOWEAK).

       SVCXPRT *
       svcfd_create(fd, sendsize, recvsize)
       int fd;
       u_int sendsize;
       u_int recvsize;

              Crea   un   servicio   sobre   cualquier   descriptor   abierto.
              Típicamente, este descriptor es un conector  conectado  para  un
              protocolo  orientado  a  conexión  tal  como  TCP.   sendsize  y
              recvsize indican  los  tamaños  para  los  buffers  de  envío  y
              recepción.   Si   son   cero,  se  eligen  valores  por  omisión
              razonables.

       SVCXPRT *
       svcraw_create()

              Esta rutina crea un medio  de  transporte  de  servicio  RPC  de
              juguete al que devuelve un puntero. El medio de transporte es en
              realidad  un  buffer  dentro  del  espacio  de  direcciones  del
              proceso,  por  lo  que  el  cliente  RPC correspondiente debería
              residir   en   el   mismo   espacio    de    direcciones.    Vea
              clntraw_create().   Esta  rutina permite la simulación de RPCs y
              la estimación de sobrecargas RPC (tal como el tiempo  de  ida  y
              vuelta),  sin  ninguna  interferencia  del  núcleo.  Esta rutina
              devuelve NULL cuando falla.

       SVCXPRT *
       svctcp_create(sock, send_buf_size, recv_buf_size)
       int sock;
       u_int send_buf_size, recv_buf_size;

              Esta rutina crea un medio de transporte de servicio  RPC  basado
              en   TCP/IP  devolviendo  un  puntero  al  mismo.  El  medio  de
              transporte se asociada con  el  conector  sock,  que  puede  ser
              RPC_ANYSOCK,  en  cuyo caso se crea un nuevo conector.  Si no se
              asocia el conector a un puerto TCP local, esta rutina lo  asocia
              a  un  puerto  arbitrario.  Al  terminar,  xprt->xp_sock  es  el
              descriptor del conector del medio de transporte y  xprt->xp_port
              es  el  número  de  puerto del medio de transporte.  Esta rutina
              devuelve NULL si falla. Ya que la RPC basada en TCP usa E/S  con
              buffers,  los  usuarios  pueden  especificar  el  tamaño  de los
              buffers. Los valores cero hacen que se seleccionen  valores  por
              omisión adecuados.

       SVCXPRT *
       svcudp_bufcreate(sock, sendsize, recosize)
       int sock;

              Esta  rutina  crea un medio de transporte de servicio RPC basado
              en  UDP/IP  devolviendo  un  puntero  al  mismo.   El  medio  de
              transporte  se  asocia  con  el  conector  sock,  que  puede ser
              RPC_ANYSOCK, en cuyo caso se crea  un  nuevo  conector.   Si  el
              conector  no está asociado a un puerto UDP local, esta rutina lo
              asocia a un puerto arbitrario. Al terminar, xprt->xp_sock es  el
              descriptor  del conector del medio de transporte y xprt->xp_port
              es el número de puerto del medio  de  transporte.   Esta  rutina
              devuelve NULL si falla.

              Esta  rutina permite al usuario especificar el tamaño de paquete
              máximo para enviar y recibir mensajes RPC basados en UDP.

       SVCXPRT *
       svcudp_create(sock)
       int sock;

              Esta llamada es equivalente a svcudp_bufcreate(sock,SZ,SZ)  para
              algún tamaño SZ por omisión.

       xdr_accepted_reply(xdrs, ar)
       XDR *xdrs;
       struct accepted_reply *ar;

              Usada  para codificar mensajes de respuesta RPC.  Esta rutina es
              útil para aquellos  usuarios  que  desean  generar  mensajes  al
              estilo RPC sin usar el paquete RPC.

       xdr_authunix_parms(xdrs, aupp)
       XDR *xdrs;
       struct authunix_parms *aupp;

              Se  usa  para  describir credenciales UNIX.  Esta rutina es útil
              para aquellos usuarios que desean generar estas credenciales sin
              usar el paquete de autenticación RPC.

       void
       xdr_callhdr(xdrs, chdr)
       XDR *xdrs;
       struct rpc_msg *chdr;

              Se  usa  para  describir  mensajes  de cabecera de llamadas RPC.
              Esta rutina es útil para aquellos usuarios  que  desean  generar
              mensajes al estilo RPC sin usar el paquete RPC.

       xdr_callmsg(xdrs, cmsg)
       XDR *xdrs;
       struct rpc_msg *cmsg;

              Se  usa  para describir mensajes de llamada RPC.  Esta rutina es
              útil para aquellos  usuarios  que  desean  generar  mensajes  al
              estilo RPC sin usar el paquete RPC.

       xdr_opaque_auth(xdrs, ap)
       XDR *xdrs;
       struct opaque_auth *ap;

              Se  usa  para describir mensajes de información de autenticación
              RPC.  Esta rutina es útil  para  aquellos  usuarios  que  desean
              generar mensajes al estilo RPC si usar el paquete RPC.

       xdr_pmap(xdrs, regs)
       XDR *xdrs;
       struct pmap *regs;

              Se  usa para describir, externamente, los parámetros de diversos
              procedimientos de portmap.  Esta rutina es  útil  para  aquellos
              usuarios  que  desean  generar  estos  parámetros  sin  usar  la
              interfaz pmap.

       xdr_pmaplist(xdrs, rp)
       XDR *xdrs;
       struct pmaplist **rp;

              Se   usa   para   describir,   externamente,   una   lista    de
              correspondencias  de  puerto.  Esta rutina es útil para aquellos
              usuarios  que  desean  generar  estos  parámetros  sin  usar  la
              interfaz pmap.

       xdr_rejected_reply(xdrs, rr)
       XDR *xdrs;
       struct rejected_reply *rr;

              Se usa para describir mensajes de respuesta RPC.  Esta rutina es
              útil para aquellos  usuarios  que  desean  generar  mensajes  al
              estilo RPC sin usar el paquete RPC.

       xdr_replymsg(xdrs, rmsg)
       XDR *xdrs;
       struct rpc_msg *rmsg;

              Se usa para describir mensajes de respuesta RPC.  Esta rutina es
              útil para aquellos  usuarios  que  desean  generar  mensajes  al
              estilo RPC sin usar el paquete RPC.

       void
       xprt_register(xprt)
       SVCXPRT *xprt;

              Después de que se creen las asas de transporte del servicio RPC,
              deben registrarse a sí mismas en el paquete  de  servicios  RPC.
              Esta  rutina modifica la variable global svc_fds().  Usualmente,
              los implementadores de servicios no necesitan esta rutina.

       void
       xprt_unregister(xprt)
       SVCXPRT *xprt;

              Antes de que se destruya una asa de transporte del servicio RPC,
              debe  darse  de  baja a sí misma en el paquete de servicios RPC.
              Esta rutina modifica la variable global svc_fds().   Usualmente,
              los constructores de servicios no necesitan esta rutina.

VÉASE TAMBIÉN

       rpc_secure(3), xdr(3)
       Los siguientes manuales:
              Remote Procedure Calls: Protocol Specification
              Remote Procedure Call Programming Guide
              rpcgen Programming Guide
       RPC:   Remote  Procedure  Call  Protocol  Specification,  RFC1050,  Sun
       Microsystems, Inc., USC-ISI.

                                16 febrero 1988                         RPC(3)