Provided by: manpages-es_1.55-10_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)