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