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)