.\" -*- coding: UTF-8 -*-
.\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)
.\"
.\" %%%LICENSE_START(BSD_ONELINE_CDROM)
.\" This page was taken from the 4.4BSD-Lite CDROM (BSD license)
.\" %%%LICENSE_END
.\"
.\" @(#)rpc.3n	2.4 88/08/08 4.0 RPCSRC; from 1.19 88/06/24 SMI
.\"
.\" 2007-12-30, mtk, Convert function prototypes to modern C syntax
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH RPC 3 "1 Noviembre 2020" "" "Manual del Programador de Linux"
.SH NOMBRE
rpc \- rutinas de biblioteca para llamadas a procedimientos remotos
.SH "SINOPSIS Y DESCRIPCIÓN"
.\" .LP
.\" We don't have an rpc_secure.3 page at the moment -- MTK, 19 Sep 05
.\" Routines that are used for Secure RPC (DES authentication) are described in
.\" .BR rpc_secure (3).
.\" Secure RPC can be used only if DES encryption is available.
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.
.PP
To take use of these routines, include the header file
\fI<rpc/rpc.h>\fP.

The prototypes below make use of the following types:
.PP
.RS 4
.EX
\fBtypedef int \fP\fIbool_t\fP\fB;\fP
.PP
\fBtypedef bool_t (*\fP\fIxdrproc_t\fP\fB) (XDR *, void *, ...);\fP
.PP
\fBtypedef bool_t (*\fP\fIresultproc_t\fP\fB) (caddr_t \fP\fIresp\fP\fB,\fP
\fB                                struct sockaddr_in *\fP\fIraddr\fP\fB);\fP
.EE
.RE
.PP
See the header files for the declarations of the \fIAUTH\fP, \fICLIENT\fP,
\fISVCXPRT\fP, and \fIXDR\fP types.
.PP
.nf
\fBvoid auth_destroy(AUTH *\fP\fIauth\fP\fB);\fP
.fi
.IP
Una macro que destruye la información de autenticación asociada a \fIauth\fP.
La destrucción usalmente implica la liberación de estructuras de datos
privadas. El uso de \fIauth\fP es indefinido trás llamar a \fBauth_destroy\fP().
.PP
.nf
\fBAUTH *authnone_create(void);\fP
.fi
.IP
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.
.PP
.nf
\fBAUTH *authunix_create(char *\fP\fIhost\fP\fB, int \fP\fIuid\fP\fB, int \fP\fIgid\fP\fB,\fP
\fB                      int \fP\fIlen\fP\fB, int *\fP\fIaup_gids\fP\fB);\fP
.fi
.IP
Create and return an RPC authentication handle that contains authentication
information.  The parameter \fIhost\fP is the name of the machine on which the
information was created; \fIuid\fP is the user's user ID; \fIgid\fP is the user's
current group ID; \fIlen\fP and \fIaup_gids\fP refer to a counted array of groups
to which the user belongs.  It is easy to impersonate a user.
.PP
.nf
\fBAUTH *authunix_create_default(void);\fP
.fi
.IP
Llama a \fBauthunix_create\fP() con los parámetros apropiados.
.PP
.nf
\fBint callrpc(char *\fP\fIhost\fP\fB, unsigned long \fP\fIprognum\fP\fB,\fP
\fB            unsigned long \fP\fIversnum\fP\fB, unsigned long \fP\fIprocnum\fP\fB,\fP
\fB            xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP
\fB            xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB);\fP
.fi
.IP
Llama al procedimiento remoto asociado a \fIprognum\fP, \fIversnum\fP y \fIprocnum\fP
de la máquina \fIhost\fP.  El parámetro \fIin\fP es la dirección del (los)
argumento(s) del procedimiento, y \fIout\fP es la dirección donde colocar el
(los) resultado(s).  \fIinproc\fP se usa para codificar los parámetros del
procedimiento, y \fIoutproc\fP se usa para decodificar los resultados del
procedimiento.  Esta rutina devuelve cero en caso de éxtio o el valor de
\fBenum clnt_stat\fP convertido a un entero, en caso de de fallo.  La rutina
\fBclnt_perrno\fP() es adecuada para traducir estados de fallo a mensajes.
.IP
Cuidado: la llamada a procedimientos con esta rutina usa UDP/IP como
protocolo de transporte. Vea \fBclntudp_create\fP() para restricciones.  No
tiene control de plazos de tiempo o autenticación usando esta rutina.
.PP
.nf
\fBenum clnt_stat clnt_broadcast(unsigned long \fP\fIprognum\fP\fB,\fP
\fB                     unsigned long \fP\fIversnum\fP\fB, unsigned long \fP\fIprocnum\fP\fB,\fP
\fB                     xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP
\fB                     xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB,\fP
\fB                     resultproc_t \fP\fIeachresult\fP\fB);\fP
.fi
.IP
Como \fBcallrpc\fP(), 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 \fBeachresult\fP(), cuyo formato es:
.IP
.in +4n
.EX
\fBeachresult(char *\fP\fIout\fP\fB, struct sockaddr_in *\fP\fIaddr\fP\fB);\fP
.EE
.in
.IP
donde \fIout\fP es lo mimo que el \fIout\fP pasado a \fBclnt_broadcast\fP(), salvo
que la salida del procedimiento remoto se decodifica allí.  \fIaddr\fP apunta a
la dirección de la máquina que ha devuelto los resultados.  Si
\fBeachresult\fP() devuelve cero, \fBclnt_broadcast\fP() espera más respuestas. En
otro caso, termina con un estado apropiado.
.IP
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.
.PP
.nf
\fBenum clnt_stat clnt_call(CLIENT *\fP\fIclnt\fP\fB, unsigned long \fP\fIprocnum\fP\fB,\fP
\fB                    xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP
\fB                    xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB,\fP
\fB                    struct timeval \fP\fItout\fP\fB);\fP
.fi
.IP
Una macro que llama al procedimiento remoto \fIprocnum\fP asociado a la asa de
cliente \fIclnt\fP, que se obtiene con una rutina de creación de clientes RPC
tal como \fBclnt_create\fP().  El parámetro \fIin\fP es la dirección del (los)
argumento(s) del procedimiento, y \fIout\fP es la dirección donde colocar el
(los) resultado(s).  \fIinproc\fP se usa para codificar los parámetros del
procedimiento, y \fIoutproc\fP se usa para decodificar los resultados del
procedimiento.  \fItout\fP es el plazo de tiempo permitido para que los
resultados lleguen.
.PP
.nf
\fBclnt_destroy(CLIENT *\fP\fIclnt\fP\fB);\fP
.fi
.IP
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
\fIclnt\fP.  El uso de \fIclnt\fP es indefinido tras llamar a \fBclnt_destroy\fP().
Si la biblioteca RPC abrió el conector asociado, también lo cerrará.  En
otro caso, el conector permanece abierto.
.PP
.nf
\fBCLIENT *clnt_create(char *\fP\fIhost\fP\fB, unsigned long \fP\fIprog\fP\fB,\fP
\fB                    unsigned long \fP\fIvers\fP\fB, char *\fP\fIproto\fP\fB);\fP
.fi
.IP
Rutina genérica para la creación de clientes.  \fIhost\fP identifica el nombre
del anfitrión remoto donde se encuentra el servidor.  \fIproto\fP indica qué
clase de protocolo de transporte se usará. Los valores actualmente
soportados para este campo son \(lqudp\(rq y \(lqtcp\(rq.  Se establecen los
plazos de tiempo por omisión, aunque se pueden modificar usando
\fBclnt_control\fP().
.IP
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.
.PP
.nf
\fBbool_t clnt_control(CLIENT *\fP\fIcl\fP\fB, int \fP\fIreq\fP\fB, char *\fP\fIinfo\fP\fB);\fP
.fi
.IP
Una macro usada para cambiar u obtener información diversa sobre un objeto
cliente.  \fIreq\fP indica el tipo de operación e \fIinfo\fP es un puntero a la
información. Tanto para UDP como para TCP, los valores soportados de \fIreq\fP,
y sus tipos de argumento y lo que hacen los mismos, son:
.IP
.in +4n
.EX
\fBCLSET_TIMEOUT\fP  \fIstruct timeval\fP // set total timeout
\fBCLGET_TIMEOUT\fP  \fIstruct timeval\fP // get total timeout
.EE
.in
.IP
Nota: si establece el plazo de tiempo usando \fBclnt_control\fP(), el parámetro
de plazo de tiempo pasado a \fBclnt_call\fP() se ignorará en todas las llamadas
futuras.
.IP
.in +4n
.EX
\fBCLGET_SERVER_ADDR\fP  \fIstruct sockaddr_in \fP // get server\(aqs address
.EE
.in
.IP
Las siguientes operaciones sólo son válidas para UDP:
.IP
.in +4n
.EX
\fBCLSET_RETRY_TIMEOUT\fP  \fIstruct timeval\fP // establece el plazo para reintento
\fBCLGET_RETRY_TIMEOUT\fP  \fIstruct timeval\fP // obtiene el plazo de reintento
.EE
.in
.IP
El plazo de reintento es el tiempo que la "RPC UDP" espera a que el servidor
responda antes de retransmitir la petición.
.PP
.nf
\fBclnt_freeres(CLIENT * \fP\fIclnt\fP\fB, xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB);\fP
.fi
.IP
Una macro que libera cualquier dato reservado por el sistema RPC/XDR cuando
decodifica los resultados de una llamada RPC. El parámetro \fIout\fP es la
dirección de los resultados, y \fIoutproc\fP 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.
.PP
.nf
\fBvoid clnt_geterr(CLIENT *\fP\fIclnt\fP\fB, struct rpc_err *\fP\fIerrp\fP\fB);\fP
.fi
.IP
Una macro que copia la estructura de error de la asa del cliente a la
estructura en la dirección \fIerrp\fP.
.PP
.nf
\fBvoid clnt_pcreateerror(char *\fP\fIs\fP\fB);\fP
.fi
.IP
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 \fIs\fP y un carácter dos puntos.  Se usa cuando una llamada a
\fBclnt_create\fP(), \fBclntraw_create\fP(), \fBclnttcp_create\fP() o
\fBclntudp_create\fP() falla.
.PP
.nf
\fBvoid clnt_perrno(enum clnt_stat \fP\fIstat\fP\fB);\fP
.fi
.IP
Muestra un mensaje en la salida de error estándar correspondiente a la
condición indicada por \fIstat\fP.  Se usa tras un \fBcallrpc\fP().
.PP
.nf
\fBclnt_perror(CLIENT *\fP\fIclnt\fP\fB, char *\fP\fIs\fP\fB);\fP
.fi
.IP
Muestra un mensaje en la salida de error estándar indicando por qué ha
fallado una llamada RPC. \fIclnt\fP es la asa usada para hacer la llamada.  El
mensaje es preterminado con la cadena \fIs\fP y un carácter dos puntos.  Se usa
tras un \fBclnt_call\fP().
.PP
.nf
\fBchar *clnt_spcreateerror(char *\fP\fIs\fP\fB);\fP
.fi
.IP
Como \fBclnt_pcreateerror\fP(), excepto que devuelve una cadena en lugar de
mostrar la información en la salida estándar de error.
.IP
Fallos: devuelve un puntero a datos estáticos que se sobrescriben en cada
llamada.
.PP
.nf
\fBchar *clnt_sperrno(enum clnt_stat \fP\fIstat\fP\fB);\fP
.fi
.IP
Toma los mismos argumentos que \fBclnt_perrno\fP(), 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).
.IP
\fBclnt_sperrno\fP() se usa en lugar de \fBclnt_perrno\fP() 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 \fBprintf\fP(3), o si se va a usar un formato de mensaje diferente
del soportado por \fBclnt_perrno\fP().  Nota: a diferencia de \fBclnt_sperror\fP()
y \fBclnt_spcreaterror\fP(), \fBclnt_sperrno\fP() devuelve un puntero a datos
estáticos pero el resultado no se sobrescribirá en cada llamada.
.PP
.nf
\fBchar *clnt_sperror(CLIENT *\fP\fIrpch\fP\fB, char *\fP\fIs\fP\fB);\fP
.fi
.IP
Igual que \fBclnt_perror\fP(), salvo que (como \fBclnt_sperrno\fP())  devuelve una
cadena en lugar de mostrar el mensaje por la salida estándar de error.
.IP
Fallos: devuelve un puntero a datos estáticos que se sobrescriben en cada
llamada.
.PP
.nf
\fBCLIENT *clntraw_create(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB);\fP
.fi
.IP
Esta rutina crea un cliente RPC de juguete (de mentira) para el programa
remoto \fIprognum\fP, con versión \fIversnum\fP.  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 \fBsvcraw_create\fP().  Esto
permite la simulación de RPC 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.
.PP
.nf
\fBCLIENT *clnttcp_create(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP
\fB                unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB                int *\fP\fIsockp\fP\fB, unsigned int \fP\fIsendsz\fP\fB, unsigned int \fP\fIrecvsz\fP\fB);\fP
.fi
.IP
.\"The following inline font conversion is necessary for the hyphen indicator
Esta rutina crea un cliente RPC para el programa remoto \fIprognum\fP, con
versión \fIversnum\fP.  El cliente usa TCP/IP como protocolo de transporte. El
programa remoto se encuentra en la dirección de Internet \fI*addr\fP.  Si
\fBaddr\->sin_port\fP 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 \fBportmap\fP remoto). El parámetro \fIsockp\fP es un
conector. Si vale \fBRPC_ANYSOCK\fP, entonces esta rutina abre uno nuevo y se
lo asigna a \fIsockp\fP.  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 \fIsendsz\fP y \fIrecvsz\fP.  Los valores cero hacen que se
elijan valores por omisión adecuados.  Esta rutina devuelve NULL si falla.
.PP
.nf
\fBCLIENT *clntudp_create(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP
\fB                unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB                struct timeval \fP\fIwait\fP\fB, int *\fP\fIsockp\fP\fB);\fP
.fi
.IP
Esta rutina crea un cliente RPC para el programa remoto \fIprognum\fP, con
versión \fIversnum\fP.  El cliente usa
.SM UDP/IP
como protocolo de
transporte. El programa remoto se encuentra en la dirección de Internet
\fIaddr\fP.  Si \fBaddr\->sin_port\fP 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 \fBportmap\fP remoto). El parámetro
\fIsockp\fP es un conector. Si vale \fBRPC_ANYSOCK\fP, esta rutina abre uno nuevo
y se lo asigna a \fIsockp\fP.  El transporte UDP reenvía los mensajes de
llamada a intervalos de tiempo \fIwait\fP 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 \fBclnt_call\fP().
.IP
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.
.PP
.nf
\fBCLIENT *clntudp_bufcreate(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP
\fB            unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB            struct timeval \fP\fIwait\fP\fB, int *\fP\fIsockp\fP\fB,\fP
\fB            unsigned int \fP\fIsendsize\fP\fB, unsigned int \fP\fIrecosize\fP\fB);\fP
.fi
.IP
Esta rutina crea un cliente RPC para el programa remoto \fIprognum\fP, con
versión \fIversnum\fP.  El cliente usa UDP/IP como protocolo de transporte. El
programa remoto se encuentra en la dirección de Internet \fIaddr\fP.  Si
\fBaddr\->sin_port\fP es cero, se le asigna el puerto real por le que
escucha el programa remoto (para obtener esta información se consulta el
servicio \fBportmap\fP remoto). El parámetro \fIsockp\fP es un conector. Si vale
\fBRPC_ANYSOCK\fP, esta rutina abre uno nuevo y se lo asigna a \fIsockp\fP.  El
protocolo de transporte UDP reenvía el mensaje de llamada a intervalos de
tiempo \fIwait\fP 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 \fBclnt_call\fP().
.IP
Esta rutina permite al usuario especificar el tamaño de paquete máximo para
enviar y recibir mensajes RPC basados en UDP.
.PP
.nf
\fBvoid get_myaddress(struct sockaddr_in *\fP\fIaddr\fP\fB);\fP
.fi
.IP
Rellena \fI*addr\fP con la dirección IP de la máquina sin consultar las rutinas
de biblioteca que tratan con \fI/etc/hosts\fP.  Como número de puerto siempre
se asigna \fBhtons(PMAPPORT)\fP.
.PP
.nf
\fBstruct pmaplist *pmap_getmaps(struct sockaddr_in *\fP\fIaddr\fP\fB);\fP
.fi
.IP
Una interfaz de usuario para el servicio \fBportmap\fP que devuelve una lista
de las asociaciones "programa RPC\-puerto" actuales de la máquina que se
encuentra en la dirección IP \fI*addr\fP.  Esta rutina puede devolver NULL. La
orden \fIrpcinfo\ \-p\fP usa esta rutina.
.PP
.nf
\fBunsigned short pmap_getport(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP
\fB                    unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB                    unsigned int \fP\fIprotocol\fP\fB);\fP
.fi
.IP
Una interfaz de usuario para el servicio \fBportmap\fP que devuelve el número
de puerto en el que espera un servicio que soporta el número de programa
\fIprognum\fP, con versión \fIversnum\fP, y habla el protocolo de transporte
asociado con \fIprotocol\fP.  El valor más probable de \fIprotocol\fP es
\fBIPPROTO_UDP\fP o \fBIPPROTO_TCP\fP.  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 \fBportmap\fP remoto. En este último caso, la
variable global \fIrpc_createerr()\fP contiene el estado de la RPC.
.PP
.nf
\fBenum clnt_stat pmap_rmtcall(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP
\fB                    unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB                    unsigned long \fP\fIprocnum\fP\fB,\fP
\fB                    xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP
\fB                    xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB,\fP
\fB                    struct timeval \fP\fItout\fP\fB, unsigned long *\fP\fIportp\fP\fB);\fP
.fi
.IP
Una interfaz de usuario para el servicio \fBportmap\fP que ordena al \fBportmap\fP
de la máquina de dirección IP \fI*addr\fP que realice una llamada RPC en su
nombre a un procedimiento en esa máquina.  Al parámetro \fI*portp\fP 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 \fBcallrpc\fP()
y \fBclnt_call\fP().  Este procedimiento se debería usar para \(lqping\(rq y
nada más. Vea también \fBclnt_broadcast\fP().
.PP
.nf
\fBbool_t pmap_set(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB                unsigned int \fP\fIprotocol\fP\fB, unsigned short \fP\fIport\fP\fB);\fP
.fi
.IP
Una interfaz de usuario para el servicio \fBportmap\fP que establece una
correspondencia entre la terna [\fIprognum\fP,\fIversnum\fP,\fIprotocol\fP] y
\fIport\fP, en el servicio \fBportmap\fP de la máquina. El valor más probable de
\fIprotocol\fP es \fBIPPROTO_UDP\fP o \fBIPPROTO_TCP\fP.  Esta rutina devuelve uno si
tiene éxito y cero en caso contrario. Hecho automáticamente por
\fBsvc_register\fP().
.PP
.nf
\fBbool_t pmap_unset(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB);\fP
.fi
.IP
Una interfaz de usuario para el servicio \fBportmap\fP que destruye todas las
correspondencias entre la terna [\fIprognum\fP,\fIversnum\fP,\fI*\fP] y los \fBports\fP
del servicio \fBportmap\fP de la máquina. Esta rutina devuelve uno si tiene
éxito y cero en caso contrario.
.PP
.nf
\fBint registerrpc(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP
\fB                unsigned long \fP\fIprocnum\fP\fB, char *(*\fP\fIprocname\fP\fB)(char *),\fP
\fB                xdrproc_t \fP\fIinproc\fP\fB, xdrproc_t \fP\fIoutproc\fP\fB);\fP
.fi
.IP
Registra el procedimiento \fIprocname\fP en el paquete de servicios RPC. Si
llega una petición para el programa \fIprognum\fP, con versión \fIversnum\fP, y
procedimiento \fIprocnum\fP, se llama a \fIprocname\fP con un puntero a su(s)
parámetro(s).  \fIprocname\fP debería devolver un puntero a su(s) resultado(s)
estático(s).  \fIinproc\fP se usa para decodificar los parámetros mientras que
\fIoutproc\fP se usa para codificar los resultados.  Esta rutina devuelve cero
si el registro tiene éxtio y \-1 en caso contrario.
.IP
Cuidado: se accede a los procedimientos remotos registrados de esta forma
usando el protocolo de transporte UDP/IP. Vea \fBsvcudp_create\fP() para
restricciones.
.PP
.nf
\fBstruct rpc_createerr \fP\fIrpc_createerr\fP\fB;\fP
.fi
.IP
Una variable global cuyo valor es establecido por cualquier rutina de
creación de clientes RPC que no tiene éxito. Use la rutina
\fBclnt_pcreateerror\fP() para mostrar el por qué.
.PP
.nf
\fBvoid svc_destroy(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
Una macro que destruye la asa de transporte de un servicio RPC, \fIxprt\fP.  La
destrucción usualmente implica la liberación de estructuras de datos
privadas, incluyendo el propio \fIxprt\fP.  El uso de \fIxprt\fP es indefinido
tras llamar a esta rutina.
.PP
.nf
\fBfd_set \fP\fIsvc_fdset\fP\fB;\fP
.fi
.IP
A global variable reflecting the RPC service side's read file descriptor bit
mask; it is suitable as a parameter to the \fBselect\fP(2)  system call.  This
is of interest only if a service implementor does their own asynchronous
event processing, instead of calling \fBsvc_run\fP().  This variable is
read\-only (do not pass its address to \fBselect\fP(2)!), yet it may change
after calls to \fBsvc_getreqset\fP()  or any creation routines.
.PP
.nf
\fBint \fP\fIsvc_fds\fP\fB;\fP
.fi
.IP
Similar to \fBsvc_fdset\fP, but limited to 32 file descriptors.  This interface
is obsoleted by \fBsvc_fdset\fP.
.PP
.nf
\fBsvc_freeargs(SVCXPRT *\fP\fIxprt\fP\fB, xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB);\fP
.fi
.IP
Una macro que libera cualquier dato reservado por el sistema RPC/XDR cuando
decodificó los argumentos a un procedimiento de servicio usando
\fBsvc_getargs\fP().  Esta rutina devuelve 1 si los resultados se han liberado
con éxito y cero en caso contrario.
.PP
.nf
\fBsvc_getargs(SVCXPRT *\fP\fIxprt\fP\fB, xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB);\fP
.fi
.IP
Una macro que decodifica los argumentos de una petición RPC asociada con la
asa de transporte de un servicio RPC \fIxprt\fP.  El parámetro \fIin\fP es la
dirección donde se colocarán los argumentos.  \fIinproc\fP es la rutina XDR
usada para decodificar los argumentos. Esta rutina devuelve 1 si la
decodificación tiene éxito y cero en caso contrario.
.PP
.nf
\fBstruct sockaddr_in *svc_getcaller(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
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, \fIxprt\fP.
.PP
.nf
\fBvoid svc_getreqset(fd_set *\fP\fIrdfds\fP\fB);\fP
.fi
.IP
Esta rutina sólo es de interés si un implementador de servicios no llama a
\fBsvc_run\fP(), sino que en su lugar implementa un procesamiento de eventos
asíncronos a su medida.  Se llama cuando la llamada al sistema \fBselect\fP(2)
ha determinado que ha llegado una petición RPC en algún conector
RPC. \fIrdfds\fP 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 \fIrdfds\fP.
.PP
.nf
\fBvoid svc_getreq(int \fP\fIrdfds\fP\fB);\fP
.fi
.IP
Similar to \fBsvc_getreqset\fP(), but limited to 32 file descriptors.  This
interface is obsoleted by \fBsvc_getreqset\fP().
.PP
.nf
\fBbool_t svc_register(SVCXPRT *\fP\fIxprt\fP\fB, unsigned long \fP\fIprognum\fP\fB,\fP
\fB                    unsigned long \fP\fIversnum\fP\fB,\fP
\fB                    void (*\fP\fIdispatch\fP\fB)(svc_req *, SVCXPRT *),\fP
\fB                    unsigned long \fP\fIprotocol\fP\fB);\fP
.fi
.IP
Asocia \fIprognum\fP y \fIversnum\fP con el procedimiento de atención de servicio,
\fIdispatch\fP.  Si \fIprotocol\fP es cero, el servicio no se registra con el
servicio \fBportmap\fP.  Si \fIprotocol\fP no es cero, se establece una
correspondencia entre la terna [\fIprognum\fP,\fIversnum\fP,\fIprotocol\fP] y
\fBxprt\->xp_port\fP con el servicio \fBportmap\fP local (generalmente
\fIprotocol\fP es cero, \fBIPPROTO_UDP\fP o \fBIPPROTO_TCP\fP). El procedimiento
\fIdispatch\fP tiene el siguiente formato:
.IP
.in +4n
.EX
dispatch(struct svc_req *request, SVCXPRT *xprt);
.EE
.in
.IP
La rutina \fBsvc_register\fP() devuelve uno en caso de éxito y cero en caso
contrario.
.PP
.nf
\fBvoid svc_run(void);\fP
.fi
.IP
Esta rutina nunca regresa. Espera la llegada de peticiones RPC y llama al
procedimiento de servicio apropiado usando \fBsvc_getreq\fP() cuando llega
una. Usualmente, este procedimiento está esperando a que termine una llamada
al sistema \fBselect\fP(2).
.PP
.nf
\fBbool_t svc_sendreply(SVCXPRT *\fP\fIxprt\fP\fB, xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB);\fP
.fi
.IP
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 \fIxprt\fP es
la asa de transporte asociada de la petición.  \fIoutproc\fP es la rutina XDR
que se usa para codificar los resultados. Y \fIout\fP es la dirección de los
resultados.  Esta rutina devuelve uno si tiene éxito y cero en caso
contrario.
.PP
.nf
\fBvoid svc_unregister(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB);\fP
.fi
.IP
Elimina todas las correspondencias entre el par [\fIprognum\fP,\fIversnum\fP] y
las rutinas de atención, y entre la terna [\fIprognum\fP,\fIversnum\fP,\fI*\fP] y el
número de puerto.
.PP
.nf
\fBvoid svcerr_auth(SVCXPRT *\fP\fIxprt\fP\fB, enum auth_stat \fP\fIwhy\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBvoid svcerr_decode(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
Llamada por una rutina de atención de servicios que no puede decodificar con
éxito sus parámetros. Vea también \fBsvc_getargs\fP().
.PP
.nf
\fBvoid svcerr_noproc(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
Llamada por una rutina de atención de servicios que no implanta el número de
procedimiento que solicita el invocador.
.PP
.nf
\fBvoid svcerr_noprog(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
Llamada cuando el programa deseado no está registrado en el paquete
RPC. Usualmente, los implementadores de servicios no necesitan esta rutina.
.PP
.nf
\fBvoid svcerr_progvers(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBvoid svcerr_systemerr(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBvoid svcerr_weakauth(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
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 \fBsvcerr_auth(xprt, AUTH_TOOWEAK\fP.
.PP
.nf
\fBSVCXPRT *svcfd_create(int \fP\fIfd\fP\fB, unsigned int \fP\fIsendsize\fP\fB,\fP
\fB                      unsigned int \fP\fIrecvsize\fP\fB);\fP
.fi
.IP
Create a service on top of any open file descriptor.  Typically, this file
descriptor is a connected socket for a stream protocol such as TCP.
\fIsendsize\fP and \fIrecvsize\fP indicate sizes for the send and receive
buffers.  If they are zero, a reasonable default is chosen.
.PP
.nf
\fBSVCXPRT *svcraw_create(void);\fP
.fi
.IP
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
\fBclntraw_create\fP().  Esta rutina permite la simulación de RPC 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.
.PP
.nf
\fBSVCXPRT *svctcp_create(int \fP\fIsock\fP\fB, unsigned int \fP\fIsend_buf_size\fP\fB,\fP
\fB                       unsigned int \fP\fIrecv_buf_size\fP\fB);\fP
.fi
.IP
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 \fIsock\fP, que puede ser \fBRPC_ANYSOCK\fP, 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, \fBxprt\->xp_sock\fP
es el descriptor del conector del medio de transporte y \fBxprt\->xp_port\fP
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.
.PP
.nf
\fBSVCXPRT *svcudp_bufcreate(int \fP\fIsock\fP\fB, unsigned int \fP\fIsendsize\fP\fB,\fP
\fB                          unsigned int \fP\fIrecosize\fP\fB);\fP
.fi
.IP
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 \fIsock\fP, que puede ser \fBRPC_ANYSOCK\fP, 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, \fBxprt\->xp_sock\fP
es el descriptor del conector del medio de transporte y \fBxprt\->xp_port\fP
es el número de puerto del medio de transporte.  Esta rutina devuelve NULL
si falla.
.IP
Esta rutina permite al usuario especificar el tamaño de paquete máximo para
enviar y recibir mensajes RPC basados en UDP.
.PP
.nf
\fBSVCXPRT *svcudp_create(int \fP\fIsock\fP\fB);\fP
.fi
.IP
Esta llamada es equivalente a \fIsvcudp_bufcreate(sock,SZ,SZ)\fP para algún
tamaño \fISZ\fP por omisión.
.PP
.nf
\fBbool_t xdr_accepted_reply(XDR *\fP\fIxdrs\fP\fB, struct accepted_reply *\fP\fIar\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBbool_t xdr_authunix_parms(XDR *\fP\fIxdrs\fP\fB, struct authunix_parms *\fP\fIaupp\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBvoid xdr_callhdr(XDR *\fP\fIxdrs\fP\fB, struct rpc_msg *\fP\fIchdr\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBbool_t xdr_callmsg(XDR *\fP\fIxdrs\fP\fB, struct rpc_msg *\fP\fIcmsg\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBbool_t xdr_opaque_auth(XDR *\fP\fIxdrs\fP\fB, struct opaque_auth *\fP\fIap\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBbool_t xdr_pmap(XDR *\fP\fIxdrs\fP\fB, struct pmap *\fP\fIregs\fP\fB);\fP
.fi
.IP
Se usa para describir, externamente, los parámetros de diversos
procedimientos de \fBportmap\fP.  Esta rutina es útil para aquellos usuarios
que desean generar estos parámetros sin usar la interfaz \fBpmap\fP.
.PP
.nf
\fBbool_t xdr_pmaplist(XDR *\fP\fIxdrs\fP\fB, struct pmaplist **\fP\fIrp\fP\fB);\fP
.fi
.IP
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 \fBpmap\fP.
.PP
.nf
\fBbool_t xdr_rejected_reply(XDR *\fP\fIxdrs\fP\fB, struct rejected_reply *\fP\fIrr\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBbool_t xdr_replymsg(XDR *\fP\fIxdrs\fP\fB, struct rpc_msg *\fP\fIrmsg\fP\fB);\fP
.fi
.IP
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.
.PP
.nf
\fBvoid xprt_register(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
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 \fBsvc_fds\fP().  Usualmente, los implementadores de
servicios no necesitan esta rutina.
.PP
.nf
\fBvoid xprt_unregister(SVCXPRT *\fP\fIxprt\fP\fB);\fP
.fi
.IP
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 \fBsvc_fds\fP().  Usualmente, los constructores de servicios no
necesitan esta rutina.
.SH ATRIBUTOS
Para obtener una explicación de los términos usados en esta sección, véase
\fBattributes\fP(7).
.ad l
.TS
allbox;
lbw35 lb lb
l l l.
Interfaz	Atributo	Valor
T{
\fBauth_destroy\fP(),
\fBauthnone_create\fP(),
.br
\fBauthunix_create\fP(),
.br
\fBauthunix_create_default\fP(),
.br
\fBcallrpc\fP(),
\fBclnt_broadcast\fP(),
.br
\fBclnt_call\fP(),
\fBclnt_destroy\fP(),
.br
\fBclnt_create\fP(),
\fBclnt_control\fP(),
.br
\fBclnt_freeres\fP(),
\fBclnt_geterr\fP(),
.br
\fBclnt_pcreateerror\fP(),
\fBclnt_perrno\fP(),
.br
\fBclnt_perror\fP(),
.br
\fBclnt_spcreateerror\fP(),
.br
\fBclnt_sperrno\fP(),
\fBclnt_sperror\fP(),
.br
\fBclntraw_create\fP(),
\fBclnttcp_create\fP(),
.br
\fBclntudp_create\fP(),
.br
\fBclntudp_bufcreate\fP(),
.br
\fBget_myaddress\fP(),
\fBpmap_getmaps\fP(),
.br
\fBpmap_getport\fP(),
\fBpmap_rmtcall\fP(),
.br
\fBpmap_set\fP(),
\fBpmap_unset\fP(),
.br
\fBregisterrpc\fP(),
\fBsvc_destroy\fP(),
.br
\fBsvc_freeargs\fP(),
\fBsvc_getargs\fP(),
.br
\fBsvc_getcaller\fP(),
\fBsvc_getreqset\fP(),
.br
\fBsvc_getreq\fP(),
\fBsvc_register\fP(),
.br
\fBsvc_run\fP(),
\fBsvc_sendreply\fP(),
.br
\fBsvc_unregister\fP(),
\fBsvcerr_auth\fP(),
.br
\fBsvcerr_decode\fP(),
\fBsvcerr_noproc\fP(),
.br
\fBsvcerr_noprog\fP(),
\fBsvcerr_progvers\fP(),
.br
\fBsvcerr_systemerr\fP(),
\fBsvcerr_weakauth\fP(),
.br
\fBsvcfd_create\fP(),
\fBsvcraw_create\fP(),
.br
\fBsvctcp_create\fP(),
.br
\fBsvcudp_bufcreate\fP(),
.br
\fBsvcudp_create\fP(),
\fBxdr_accepted_reply\fP(),
.br
\fBxdr_authunix_parms\fP(),
.br
\fBxdr_callhdr\fP(),
.br
\fBxdr_callmsg\fP(),
\fBxdr_opaque_auth\fP(),
.br
\fBxdr_pmap\fP(),
\fBxdr_pmaplist\fP(),
.br
\fBxdr_rejected_reply\fP(),
.br
\fBxdr_replymsg\fP(),
.br
\fBxprt_register\fP(),
\fBxprt_unregister\fP()
T}	Seguridad del hilo	Multi\-hilo seguro
.TE
.ad
.SH "VÉASE TAMBIÉN"
.\" We don't have an rpc_secure.3 page in the set at the moment -- MTK, 19 Sep 05
.\" .BR rpc_secure (3),
\fBxdr\fP(3)
.PP
Los siguientes manuales:
.RS
Remote Procedure Calls: Protocol Specification
.br
Remote Procedure Call Programming Guide
.br
rpcgen Programming Guide
.br
.RE
.PP
\fIRPC: Remote Procedure Call Protocol Specification\fP, RFC\ 1050, Sun
Microsystems, Inc., USC\-ISI.
.SH COLOFÓN
Esta página es parte de la versión 5.10 del proyecto Linux
\fIman\-pages\fP. Puede encontrar una descripción del proyecto, información
sobre cómo informar errores y la última versión de esta página en
\%https://www.kernel.org/doc/man\-pages/.

.SH TRADUCCIÓN
La traducción al español de esta página del manual fue creada por
Juan Piernas <piernas@ditec.um.es>
.

Esta traducción es documentación libre; lea la
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License Version 3
.UE
o posterior con respecto a las condiciones de copyright.
No existe NINGUNA RESPONSABILIDAD.

Si encuentra algún error en la traducción de esta página del manual, envíe un
correo electrónico a
.MT
debian-l10n-spanish@lists.debian.org>.
.ME .