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

NOMBRE

       rpc - rutinas de biblioteca para llamadas a procedimientos remotos

SINOPSIS Y DESCRIPCI'ON

       Estas  rutinas  permiten  a  los  programas  en  C  realizar llamadas a
       procedimientos en otras maquinas a  traves  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
       atencion  que realiza el servicio solicitado, y a continuacion envia de
       vuelta una respuesta.  Finalmente, la llamada al procedimiento  termina
       y vuelve al cliente.

       Las  rutinas  que  se  usan  para  RPC  seguro  (autenticacion  DES) se
       describen en rpc_secure(3).  RPC seguro  solo  se  puede  usar  si  hay
       disponible cifrado DES.

       #include <rpc/rpc.h>

       void
       auth_destroy(auth)
       AUTH *auth;

              Una  macro que destruye la informacion de autenticacion asociada
              a auth.  La  destruccion  usalmente  implica  la  liberacion  de
              estructuras de datos privadas. El uso de auth es indefinido tras
              llamar a auth_destroy().

       AUTH *
       authnone_create()

              Crea y devuelve una asa (handle) de autenticacion RPC  que  pasa
              informacion  de  autenticacion  inservible  en  cada  llamada  a
              procedimientos remotos. Esta es  la  autenticacion  por  omision
              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  autenticacion  RPC que contiene
              informacion de autenticacion.  El parametro host es el nombre de
              la  maquina en la que se ha creado la informacion.  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 facil hacerse pasar por un usuario.

       AUTH *
       authunix_create_default()

              Llama a authunix_create() con los parametros 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 maquina host.  El parametro in es la direccion del
              (los) argumento(s) del procedimiento,  y  out  es  la  direccion
              donde  colocar  el  (los)  resultado(s).   inproc  se  usa  para
              codificar los parametros del procedimiento,  y  outproc  se  usa
              para  decodificar los resultados del procedimiento.  Esta rutina
              devuelve cero en caso de extio 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
              autenticacion 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 difusion 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 alli.  addr
              apunta  a  la  direccion  de  la  maquina  que  ha  devuelto los
              resultados.  Si  eachresult()  devuelve  cero,  clnt_broadcast()
              espera  mas  respuestas.  En  otro  caso,  termina con un estado
              apropiado.

              Cuidado: los conectores de difusion estan limitados en tamano  a
              la  unidad  de  transferencia  maxima  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
              creacion de clientes RPC tal como clnt_create().   El  parametro
              in  es  la direccion del (los) argumento(s) del procedimiento, y
              out es la direccion donde colocar el (los) resultado(s).  inproc
              se  usa  para  codificar  los  parametros  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  destruccion
              usualmente   implica  la  liberacion  de  estructuras  de  datos
              privadas,  incluyendo  el  propio  clnt.   El  uso  de  clnt  es
              indefinido  tras  llamar a clnt_destroy().  Si la biblioteca RPC
              abrio el conector asociado, tambien lo cerrara.  En  otro  caso,
              el conector permanece abierto.

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

              Rutina  generica  para la creacion de clientes.  host identifica
              el nombre del anfitrion remoto donde se encuentra  el  servidor.
              proto  indica que clase de protocolo de transporte se usara. Los
              valores actualmente soportados  para  este  campo  son  "udp"  y
              "tcp".   Se  establecen los plazos de tiempo por omision, aunque
              se pueden modificar usando clnt_control().

              Cuidado: el uso de UDP tiene sus defectos. Ya que  los  mensajes
              RPC  basados en UDP solo 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 informacion diversa sobre
              un objeto cliente.  req indica el tipo de operacion e info es un
              puntero a la informacion. 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
              parametro de plazo de tiempo pasado a clnt_call() se ignorara en
              todas las llamadas futuras.

              CLGET_SERVER_ADDR   struct sockaddr_in  obtiene la direccion
                                                      del servidor

              Las siguientes operaciones solo son validas 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 peticion.

       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
              parametro out es la direccion de los resultados, y outproc es la
              rutina XDR que describe los resultados.   Esta  rutina  devuelve
              uno  si los resultados se han liberado con exito, 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 direccion errp.

       void
       clnt_pcreateerror(s)
       char *s;

              Muestra  un mensaje en la salida estandar de error indicando por
              que no se ha podido crear una asa RPC de cliente.  El mensaje es
              preterminado  con  la cadena s y un caracter 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  estandar
              correspondiente a la condicion indicada por stat.  Se  usa  tras
              un callrpc().

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

              Muestra  un mensaje en la salida de error estandar indicando por
              que ha fallado una llamada RPC.  clnt es la asa usada para hacer
              la  llamada.   El  mensaje  es preterminado con la cadena s y un
              caracter 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 informacion en la salida estandar de error.

              Fallos:   devuelve   un   puntero   a  datos  estaticos  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 estandar indicando por
              que ha fallado una llamada RPC, devuelve un puntero a una cadena
              que  contiene  el  mensaje.  La  cadena  termina con un caracter
              NEWLINE (nueva linea).

              clnt_sperrno() se usa en lugar de clnt_perrno() si  el  programa
              no tiene una salida de error estandar (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
              estaticos pero el resultado no se sobrescribira 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
              estandar de error.

              Fallos:   devuelve   un   puntero   a  datos  estaticos  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  version  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  deberia  residir  en  el  mismo
              espacio  de  direcciones.  Vea svcraw_create().  Esto permite la
              simulacion de RPCs y la estimacion de sobrecargas RPC, tal  como
              el tiempo de ida y vuelta, sin ninguna interferencia del nucleo.
              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  version  versnum.   El cliente usa TCP/IP como protocolo de
              transporte. El programa remoto se encuentra en la  direccion  de
              Internet  *addr.   Si  addr->sin_port  es  cero,  entonces se le
              asigna el puerto  real  por  el  que  el  programa  remoto  esta
              escuchando   (para  obtener  esta  informacion  se  consulta  el
              servicio portmap remoto). El parametro 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 tamano de los buffers
              de envio y recepcion con los parametros sendsz  y  recvsz.   Los
              valores  cero hacen que se elijan valores por omision 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  version  versnum.   El cliente usa UDP/IP como protocolo de
              transporte. El programa remoto se encuentra en la  direccion  de
              Internet addr.  Si addr->sin_port es cero, entonces se le asigna
              el puerto real por el que el  programa  remoto  esta  escuchando
              (para  obtener  esta informacion se consulta el servicio portmap
              remoto). El parametro sockp es un conector. Si vale RPC_ANYSOCK,
              esta  rutina  abre  uno  nuevo  y  se  lo  asigna  a  sockp.  El
              transporte UDP reenvia 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 solo 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  version  versnum.   El cliente usa UDP/IP como protocolo de
              transporte. El programa remoto se encuentra en la  direccion  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  informacion  se  consulta  el servicio portmap remoto). El
              parametro sockp es un conector. Si vale RPC_ANYSOCK, esta rutina
              abre  uno  nuevo  y  se  lo  asigna  a  sockp.   El protocolo de
              transporte UDP reenvia 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 tamano maximo de paquete
              para enviar y recibir mensajes RPC basados en UDP.

       void
       get_myaddress(addr)
       struct sockaddr_in *addr;

              Rellena *addr con la direccion IP de la  maquina  sin  consultar
              las  rutinas  de  biblioteca  que  tratan  con /etc/hosts.  Como
              numero 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 maquina que se encuentra en  la  direccion  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
              numero  de  puerto  en  el que espera un servicio que soporta el
              numero de programa prognum, con  version  versnum,  y  habla  el
              protocolo  de  transporte  asociado  con protocol.  El valor mas
              probable de  protocol  es  IPPROTO_UDP  o  IPPROTO_TCP.   Si  se
              devuelve  un  valor cero significa que no existe la asociacion o
              que el sistema RPC ha  fallado  al  intentar  contactar  con  el
              servicio portmap remoto. En este ultimo 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  maquina  de  direccion IP *addr que realice una
              llamada RPC en su nombre a un procedimiento en esa maquina.   Al
              parametro *portp se le asignara el numero de puerto del programa
              si el procedimiento tiene exito. Las definiciones de  los  otros
              parametros   se  discuten  en  callrpc()  y  clnt_call().   Este
              procedimiento se deberia  usar  para  "ping"  y  nada  mas.  Vea
              tambien 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  maquina.  El valor mas
              probable de protocol es IPPROTO_UDP o IPPROTO_TCP.  Esta  rutina
              devuelve  uno  si  tiene  exito  y cero en caso contrario. Hecho
              automaticamente 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  maquina.  Esta  rutina
              devuelve uno si tiene exito 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  peticion  para  el  programa  prognum,  con
              version  versnum,  y  procedimiento procnum, se llama a procname
              con un puntero a su(s) parametro(s).  progname deberia  devolver
              un puntero a su(s) resultado(s) estatico(s).  inproc se usa para
              decodificar los parametros mientras  que  outproc  se  usa  para
              codificar  los  resultados.   Esta  rutina  devuelve  cero si el
              registro tiene extio 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  creacion  de clientes RPC que no tiene exito. Use la
              rutina clnt_pcreateerror() para mostrar el por que.

       svc_destroy(xprt)
       SVCXPRT *
       xprt;

              Una macro que destruye la asa de transporte de un servicio  RPC,
              xprt.   La  destruccion  usualmente  implica  la  liberacion  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  mascara  de bits de los
              descriptores de ficheros de lectura del lado del  servicio  RPC.
              Esta  variable  es  adecuada  como  parametro  de  la llamada al
              sistema select.  Solo es  de  interes  si  un  implementador  de
              servicios  no  llama  a  svc_run(), sino que mas bien realiza su
              propio procesamiento de eventos asincronos.  Esta variable es de
              solo-lectura  (ino  pase  su  direccion a select!), aunque puede
              cambiar tras llamar a svc_getreqset() o a  cualquier  rutina  de
              creacion.

       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  decodifico los argumentos a un procedimiento de
              servicio usando svc_getargs().  Esta rutina devuelve  1  si  los
              resultados se han liberado con exito 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 peticion RPC
              asociada con la asa de transporte de un servicio RPC  xprt.   El
              parametro  in es la direccion donde se colocaran los argumentos.
              inproc es la rutina XDR usada para decodificar  los  argumentos.
              Esta  rutina  devuelve 1 si la decodificacion tiene exito y cero
              en caso contrario.

       struct sockaddr_in *
       svc_getcaller(xprt)
       SVCXPRT *xprt;

              La manera permitida de obtener la direccion 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 solo es de interes si un implementador de  servicios
              no  llama  a  svc_run(),  sino  que  en  su  lugar implementa un
              procesamiento de eventos  asincronos  a  su  medida.   Se  llama
              cuando  la  llamada  al  sistema  select  ha  determinado que ha
              llegado una peticion RPC en algun conector  RPC.   rdfds  es  la
              mascara  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  atencion  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 exito 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 esta  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  atencion  de un servicio RPC para
              enviar los resultados de una llamada a un procedimiento  remoto.
              El  parametro  xprt  es  la  asa  de  transporte  asociada de la
              peticion.  outproc es la rutina XDR que se  usa  para  codificar
              los  resultados.  Y out es la direccion de los resultados.  Esta
              rutina devuelve uno si tiene exito 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 atencion, y entre la terna
              [prognum,versnum,*] y el numero de puerto.

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

              Llamada por una rutina de  atencion  de  servicios  que  rechaza
              realizar una llamada a un procedimiento remoto debido a un error
              de autenticacion.

       void
       svcerr_decode(xprt)
       SVCXPRT *xprt;

              Llamada por una rutina de atencion de  servicios  que  no  puede
              decodificar con exito sus parametros. Vea tambien svc_getargs().

       void
       svcerr_noproc(xprt)
       SVCXPRT *xprt;

              Llamada  por una rutina de atencion de servicios que no implanta
              el numero de procedimiento que solicita el invocador.

       void
       svcerr_noprog(xprt)
       SVCXPRT *xprt;

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

       void
       svcerr_progvers(xprt)
       SVCXPRT *xprt;

              Llamada cuando  la  version  deseada  de  un  programa  no  esta
              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 atencion de servicios  cuando  detecta
              un error de sistema no cubierto por ningun 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  atencion de servicios que rechaza
              realizar  una  llamada  a  un  procedimiento  remoto  debido   a
              insuficientes  parametros  de  autenticacion.  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.
              Tipicamente,  este  descriptor  es un conector conectado para un
              protocolo  orientado  a  conexion  tal  como  TCP.   sendsize  y
              recvsize  indican  los  tamanos  para  los  buffers  de  envio y
              recepcion.  Si  son  cero,  se  eligen   valores   por   omision
              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  deberia
              residir    en    el    mismo   espacio   de   direcciones.   Vea
              clntraw_create().  Esta rutina permite la simulacion de  RPCs  y
              la  estimacion  de  sobrecargas RPC (tal como el tiempo de ida y
              vuelta), sin ninguna  interferencia  del  nucleo.   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 numero 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  tamano  de  los
              buffers.  Los  valores cero hacen que se seleccionen valores por
              omision 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 esta 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  numero  de  puerto del medio de transporte.  Esta rutina
              devuelve NULL si falla.

              Esta rutina permite al usuario especificar el tamano de  paquete
              maximo 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
              algun tamano SZ por omision.

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

              Usada para codificar mensajes de respuesta RPC.  Esta rutina  es
              util  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  util
              para aquellos usuarios que desean generar estas credenciales sin
              usar el paquete de autenticacion 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  util 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
              util  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 informacion  de  autenticacion
              RPC.   Esta  rutina  es  util  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 parametros de  diversos
              procedimientos  de  portmap.   Esta rutina es util para aquellos
              usuarios  que  desean  generar  estos  parametros  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  util  para  aquellos
              usuarios  que  desean  generar  estos  parametros  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
              util  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
              util  para  aquellos  usuarios  que  desean  generar mensajes al
              estilo RPC sin usar el paquete RPC.

       void
       xprt_register(xprt)
       SVCXPRT *xprt;

              Despues de que se creen las asas de transporte del servicio RPC,
              deben  registrarse  a  si 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 si 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'EASE TAMBI'EN

       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)