RPC(3N)

NOME
rpc - rotinas de biblioteca para chamadas de procedimentos remotos

SINÓPSE E DESCRIÇÃO
Estas rotinas possibilitam programas C a fazerem chamadas de procedimento sobre outras máquinas através da rede. Primeiro, o cliente chama um procedimento para enviar um pacote de dados ao servidor. Ao recebimento do pacote, o servidor chama uma rotina de encaminhamento para realizar o serviço solicitado, e então envia de volta uma resposta. Finalmente, a chamada de procedimento retorna para o cliente.

Rotinas que são utilizadas para RPC seguro (autenticação DES) são descritas em rpc_secure(3N). O 'Secure RPC' pode ser utilizado apenas se criptografia DES estiver disponível.

#include <rpc/rpc.h>

void
auth_destroy(auth)
AUTH *auth;

    Uma macro que destrói a informação de autenticação associada com auth. A destruição geralmente envolve desalocação de estruturas de dados privativas. O uso de auth é indefinido depois de se chamar auth_destroy().

AUTH *
authnone_create()

    Cria e retorna um manipulador de autenticação RPC que passa informação de autenticação não usável com cada chamada de procedimento remoto. Essa é a autenticação padrão utilizada por RPC.

AUTH *
authunix_create(host, uid, gid, len, aup_gids)
char *host;
int uid, gid, len, *aup.gids;

    Cria e retorna um handle de autenticação RPC que contém informação de autenticação. O parâmetro host é o nome da máquina na qual a informação foi criada; uid é a ID do usuário ; gid é a ID do grupo do usuário atual ; len e aup_gids se referem a um vetor contado de grupos aos quais o usuário pertence. É fácil de personificar um usuário.

AUTH *
authunix_create_default()

    Chama authunix_create() com os parâmetros adequados.

callrpc(host, prognum, versnum, procnum, inproc, in, outproc, out)
char *host;
u_long prognum, versnum, procnum;
char *in, *out;
xdrproc_t inproc, outproc;

    Chama o procedimento remoto associado com prognum, versnum, e procnum na máquina host. O parâmetro in é o endereço do(s) argumento(s) do procedimento e out é o endereço de onde colocar o(s) resultado(s); inproc é utilizado para codificar os parâmetros do procedimento e outproc é utilizado para decodificar os resultados do procedimento. Essa rotina retorna zero em caso de sucesso, ou o valor de enum clnt_stat adaptado para um inteiro se ela falhar. A rotina clnt_perrno() é conveniente para traduzir estados de falha para mensagens.

    Aviso: chamar procedimentos remotos com esta rotina utilza UDP/IP como transporte; veja clntudp_create() para as restrições. Você não possui controle de tempo de expiração ou autenticação utilizando esta rotina.

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;

    Semelhante a callrpc(), exceto que a mensagem de chamada é difundida para todas as redes de difusão conectadas localmente. Cada vez que ela recebe uma resposta, esta rotina chama eachresult(), cuja forma é:

    eachresult(out, addr)
    char *out;
    struct sockaddr_in *addr;

    onde out é o mesmo que out passado para clnt_broadcast(), exceto que a saída do procedimento remoto é decodificada lá; addr aponta para o endereço da máquina que enviou os resultados. Se eachresult() retornar zero, clnt_broadcast() espera por mais respostas; caso contrário, ela retorna com o status adequado.

    Aviso: sockets de difusão são limitados em tamanho para a máxima unidade de transferência da linha de dados. Para ethernet, esse valor é 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;

    Uma macro que chama o procedimento remoto procnum associado com o handle de cliente clnt, que é obtido com uma rotina de criação de cliente RPC tal como clnt_create(). O parâmetro in é o endereço do(s) argumento(s) do procedimento e out é o endereço de onde se colocar o(s) resultado(s); inproc é utilizado para codificar os parâmetros do procedimento e outproc é utilizado para decodificar os resultados do procedimento; tout é o tempo permitido para que os resultados voltem.

clnt_destroy(clnt)
CLIENT *clnt;

    Uma macro que destrói o handle RPC do cliente. A destruição geralmente envolve desalocação de estruturas de dados privativas, incluindo o clnt em si. O uso de clnt é indefinido após se chamar clnt_destroy(). Se a biblioteca RPC abriu o socket associado, ela o fechará também. Caso contrário, o socket permanece aberto.

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

    Rotina genérica de criação de cliente. host identifica o nome do host remoto onde o servidor está localizado. proto indica que tipo de protocolo de transporte utilizar. Os valores atualmente suportados para esse campo são “udp” e “tcp”. Os tempos de expiração padrão são definidos, mas podem ser modificados usando-se clnt_control().

    Aviso: utilizar UDP possui suas deficiências. Já que mensagens RPC baseadas em UDP podem conter apenas até 8 Kbytes de dados codificados, esse transporte não pode ser utilizado para procedimentos que tomam argumentos extensos ou retornam grandes resultados.

bool_t
clnt_control(cl, req, info)
CLIENT *cl;
char *info;

    Uma macro utilizada para alterar ou recuperar informações variadas sobre um objeto de cliente. req indica o tipo de operação e info é um ponteiro para a informação. Para ambos UDP e TCP, os valores suportados de req e seus tipos de argumentos, e o que eles fazem, são:

    CLSET_TIMEOUT struct timeval define tempo de expiração total
    CLGET_TIMEOUT struct timeval obtém tempo de expiração total

    Nota: se você definir o tempo de expiração utilizando clnt_control(), o parâmetro de tempo de expiração passado para clnt_call() será ignorado em todas as chamadas futuras.

    CLGET_SERVER_ADDR struct sockaddr_in obtém endereço do servidor

    As seguintes operações são válidas para UDP apenas:

    CLSET_RETRY_TIMEOUT struct timeval define tempo de expiração para repetição
    CLGET_RETRY_TIMEOUT struct timeval obtém tempo de expiração para repetição

    O tempo de expiração para repetição é o tempo que UDP RPC espera para que o servidor responda antes de retransmitir o pedido.

clnt_freeres(clnt, outproc, out)
CLIENT *clnt;
xdrproc_t outproc;
char *out;

    Uma macro que libera qualquer dado alocado pelo sistema RPC/XDR quando ele decodificou os resultados de uma chamada RPC . O parâmetro out é o endereço dos resultados e outproc é a rotina XDR descrevendo os resultados. Essa rotina retorna um se os resultados foram liberados com sucesso e zero caso contrário.

void
clnt_geterr(clnt, errp)
CLIENT *clnt;
struct rpc_err *errp;

    Uma macro que copia a estrutura de erro do handle de cliente para a estrutura no endereço errp.

void
clnt_pcreateerror(s)
char *s;

    Exibe uma mensagem no dispositivo de erro padrão indicando por que um handle de cliente RPC não pôde ser criado. A mensagem é prefixada com a string s e um sinal de dois pontos. Utilizada quando uma chamada clnt_create(), clntraw_create(), clnttcp_create() ou clntudp_create() falha.

void
clnt_perrno(stat)
enum clnt_stat stat;

    Exibe uma mensagem no dispositivo de erro padrão correspondente à condição indicada por stat. Utilizada após callrpc().

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

    Exibe uma mensagem no dispositivo de erro padrão indicando por que uma chamada RPC falhou; clnt é o handle utilizado para se fazer a chamada. A mensagem é prefixada com a string s e um sinal de dois pontos. Utilizada após clnt_call().

char *
clnt_spcreateerror
char *s;

    Semelhante a clnt_pcreateerror(), exceto que ela retorna uma string em vez de imprimir para o dispositivo de erro padrão.

    Bugs: retorna ponteiro para dado estático que é sobrescrito a cada chamada.

char *
clnt_sperrno(stat)
enum clnt_stat stat;

    Toma os mesmos argumentos que clnt_perrno(), mas em vez de enviar uma mensagem ao dispositivo de erro padrão indicando por que uma chamada RPC falhou, retorna um ponteiro para uma string que contém a mensagem. A string termina com um NOVA LINHA.

    clnt_sperrno() é utilizada em vez de clnt_perrno() se o programa não possuir um dispositivo de erro padrão (como um programa rodando como um servidor costuma não ter), ou se o programador não deseje que a mensagem seja exibida com printf, ou se um formato de mensagem diferente daquele suportado por clnt_perrno() deve ser usado. Nota: ao contrário de clnt_sperror() e clnt_spcreaterror(), clnt_sperrno() retorna um ponteiro para dado estático, mas o resultado não será sobrescrito a cada chamada.

char *
clnt_sperror(rpch, s)
CLIENT *rpch;
char *s;

    Semelhante a clnt_perror(), exceto que (como clnt_sperrno()) ela retorna uma string em vez de imprimir para o dispositivo de erro padrão.

    Bugs: retorna ponteiro para dado estático que é sobrescrito a cada chamada.

CLIENT *
clntraw_create(prognum, versnum)
u_long prognum, versnum;

    Essa rotina cria um cliente RPC de brinquedo para o programa remoto prognum, versão versnum. O transporte utilizado para enviar mensagens ao serviço é na verdade um 'buffer' dentro do espaço de endereçamento do processo, de modo que o servidor RPC correspondente deve estar no mesmo espaço de endereçamento; veja svcraw_create(). Isso permite a simulação de RPC e obtenção de overheads RPC, tais como tempos de ida e volta, sem qualquer interferência do kernel. Esta rotina retorna NULL se ela falhar.

CLIENT *
clnttcp_create(addr, prognum, versnum, sockp, sendsz, recvsz)
struct sockaddr_in *addr;
u_long prognum, versnum;
int *sockp;
u_int sendsz, recvsz;

    Essa rotina cria um cliente RPC para o programa remoto prognum, versão versnum; o cliente utiliza TCP/IP como transporte. O programa remoto está localizado no endereço de Internet *addr. Se addr->sin_port para 0, então ele é definido para a verdadeira porta na qual o programa remoto está atendendo (o serviço remoto portmap é consultado para essa informação). O parâmetro sockp é um socket; se ele for RPC_ANYSOCK, então esta rotina abre um novo e define sockp. Já que RPC baseado em TCP utiliza E/S baseada em 'buffer', o usuário pode especificar o tamanho dos buffers de envio e recebimento com os parâmetros sendsz e recvsz; valores zero escolhem padrões razoáveis. Esta rotina retorna NULO se ela falhar.

CLIENT *
clntudp_create(addr, prognum, versnum, wait, sockp)
struct sockaddr_in *addr;
u_long prognum, versnum;
struct timeval wait;
int *sockp;

    Essa rotina cria um cliente RPC para o programa remoto prognum, versão versnum; o cliente utiliza UDP/IP como transporte. O programa remoto está localizado no endereço de Internet addr. Se addr->sin_port for zero, então ele é definido para a verdadeira porta na qual o programa remoto está atendendo (o serviço remoto portmap é consultado para esta informação). O parâmetro sockp é um socket; se ele for RPC_ANYSOCK, então esta rotina abre um novo e define sockp. O transporte UDP reenvia a mensagem de chamada em intervalos de tempo com período wait até que uma resposta seja recebida ou até que a chamada expire. O tempo total para que a chamada expire é especificado por clnt_call().

    Aviso: já que mensagens RPC baseadas em UDP podem conter apenas até 8 Kbytes de dados codificados, esse transporte não pode ser utilizado para procedimentos que tomam argumentos extensos ou retornam resultados grandes.

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;

    Essa rotina cria um cliente RPC para o programa remoto prognum, em versnum; o cliente utiliza UDP/IP como transporte. O programa remoto está localizado no endereço de Internet addr. Se addr->sin_port for zero, então ele é definido para a verdadeira porta na qual o programa remoto está atendendo (o serviço remoto portmap é consultado para essa informação). O parâmetro sockp é um socket; se ele for RPC_ANYSOCK, então esta rotina abre um novo e define sockp. O transporte UDP reenvia a mensagem de chamada em intervalos de tempo de período wait até que uma mensagem seja recebida ou até que a chamada expire. O tempo total para que a chamada expire é especificado por clnt_call().

    Isso permite que o usuário especifique o máximo tamanho de pacote para enviar e receber mensagens RPC baseadas em UDP.

void
get_myaddress(addr)
struct sockaddr_in *addr;

    Insere o endereço IP da máquina em *addr, sem consultar as rotinas de biblioteca que lidam com /etc/hosts. O número da porta é sempre definido para htons(PMAPPORT).

struct pmaplist *
pmap_getmaps(addr)
struct sockaddr_in *addr;

    Uma interface de usuário para o serviço portmap, que retorna uma lista dos mapeamentos RPC atuais de programa para porta no 'host' localizado no endereço IP *addr. Esta rotina pode retornar NULL . O comando `rpcinfo -p' utiliza esta rotina.

u_short
pmap_getport(addr, prognum, versnum, protocol)
struct sockaddr_in *addr;
u_long prognum, versnum, protocol;

    Uma interface de usuário para o serviço portmap, que retorna o número da porta na qual espera um serviço que suporta o número de programa prognum, versão versnum, e fala o protocolo de transporte associado com protocol. O valor de protocol geralmente é IPPROTO_UDP ou IPPROTO_TCP. Um valor de retorno de zero significa que o mapeamento não existe ou que o sistema RPC falhou no contato do serviço portmap remoto. Nesse último caso, a variável global rpc_createerr() contém o status 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;

    Uma interface de usuário para o serviço portmap, que instrui portmap no host ao endereço IP *addr a fazer uma chamada RPC em seu nome para um procedimento naquele host. O parâmetro *portp será modificado para o número da porta do programa caso o procedimento seja bem sucedido. As definições de outros parâmetros são discutidas em callrpc() e clnt_call(). Este procedimento deve ser usado para um “ping” e nada mais. Veja também clnt_broadcast().

pmap_set(prognum, versnum, protocol, port)
u_long prognum, versnum, protocol;
u_short port;

    Uma interface de usuário para o serviço portmap, que estabelece um mapeamento entre a tripla [prognum,versnum,protocol] e port no serviço portmap da máquina. O valor de protocol é geralmente IPPROTO_UDP ou IPPROTO_TCP. Essa rotina retorna um se bem sucedida; zero caso contrário. Automaticamente feito por svc_register().

pmap_unset(prognum, versnum)
u_long prognum, versnum;

    Uma interface de usuário para o serviço portmap, que destrói todo o mapeamento entre a tripla [prognum,versnum,*] e ports no serviço portmap da máquina. Essa rotina retorna um se bem sucedida; zero caso contrário.

registerrpc(prognum, versnum, procnum, procname, inproc, outproc)
u_long prognum, versnum, procnum;
char *(*procname) () ;
xdrproc_t inproc, outproc;

    Registra o procedimento procname com o pacote do serviço RPC. Se uma requisição chega para o programa prognum, versão versnum, e procedimento procnum, procname é chamado com um ponteiro para seu(s) parâmetro(s); progname deve retornar um ponteiro para seu(s) resultado(s) estático(s); inproc é utilizado para decodificar os parâmetros enquanto outproc é utilizado para codificar os resultados. Essa rotina retorna zero se o registro for bem sucedido; -1 caso contrário.

    Aviso: procedimentos remotos registrados dessa forma são acessados usando-se o transporte UDP/IP ; veja svcudp_create() para restrições.

struct rpc_createerr     rpc_createerr;

    Uma variável global cujo valor é definido por qualquer rotina de criação de cliente RPC que não seja bem sucedida. Utilize a rotina clnt_pcreateerror() para exibir a razão por que.

svc_destroy(xprt)
SVCXPRT *
xprt;

    Uma macro que destrói o manipulador de transporte do serviço RPC, xprt. Destruição geralmente envolve desalocação de estruturas de dados privativas, incluindo xprt em si. O uso de xprt é indefinido depois de se chamar essa rotina.

fd_set svc_fdset;

    Uma variável global refletindo a máscara de bits do descritor de arquivo de leitura do lado do serviço RPC ; ela é apropriada como um parâmetro para a chamada de sistema select. Isso é apenas de interesse se o implementador de um serviço não chama svc_run(), mas em vez disso possui seu próprio processamento de eventos assíncronos. Esta variável é de apenas leitura (não passe seu endereço para select!), ainda que ela possa mudar após chamadas a svc_getreqset() ou qualquer rotina de criação.

int svc_fds;

    Similar a svc_fdset, mas limitada a 32 descritores. Essa interface é tornada obsoleta por svc_fdset.

svc_freeargs(xprt, inproc, in)
SVCXPRT *xprt;
xdrproc_t inproc;
char *in;

    Uma macro que libera quaisquer dados alocados pelo sistema RPC/XDR ao decodificar os argumentos para um procedimento do serviço usando svc_getargs(). Essa rotina retorna 1 se os resultados foram liberados com sucesso e zero caso contrário.

svc_getargs(xprt, inproc, in)
SVCXPRT *xprt;
xdrproc_t inproc;
char *in;

    Uma macro que decodifica os argumentos de uma requisição RPC associada com o manipulador de transporte de serviço RPC, xprt. O parâmetro in é o endereço onde os argumentos serão colocados; inproc é a rotina XDR utilizada para decodificar os argumentos. Essa rotina retorna um se a decodificação for bem sucedida; zero caso contrário.

struct sockaddr_in *
svc_getcaller(xprt)
SVCXPRT *xprt;

    O modo aprovado de obter o endereço de rede do chamador de um procedimento associado com o handle de transporte de serviço RPC, xprt.

svc_getreqset(rdfds)
fd_set *rdfds;

    Esta rotina é de interesse apenas se o implementador do serviço não chama svc_run(), mas em vez disso implementa um processamento de eventos assíncronos próprio. Ela é chamada quando a chamada de sistema select determina que uma requisição RPC chegou em algum(ns) socket(s) RPC; rdfds é a máscara de bits resultante do descritor de arquivo de leitura. A rotina retorna quando todos os sockets associados com o valor de rdfds tenham sido servidos.

svc_getreq(rdfds)
int rdfds;

    Similar a svc_getreqset(), mas limitada a 32 descritores. Esta interface é tornada obsoleta por svc_getreqset().

svc_register(xprt, prognum, versnum, dispatch, protocol)
SVCXPRT *xprt;
u_long prognum, versnum;
void (*dispatch) ();
u_long protocol;

    Associa prognum e versnum com o procedimento de encaminhamento do serviço, dispatch. Se protocol for zero, o serviço não é registrado com o serviço portmap. Se protocol for diferente de zero, então um mapeamento da tripla [prognum,versnum,protocol] para xprt->xp_port é estabelecido com o serviço portmap local (geralmente protocol é zero, IPPROTO_UDP ou IPPROTO_TCP ). O procedimento dispatch tem a seguinte forma:
    dispatch(request, xprt)
    struct svc_req *request;
    SVCXPRT *xprt;

    A rotina svc_register() retorna um se bem sucedida e zero caso contrário.

svc_run()

    Essa rotina nunca retorna. Ela espera pela chegada de requisições RPC e chama o procedimento apropriado do serviço usando svc_getreq() quando alguma chega. Esse procedimento está geralmente esperando que uma chamada de sistema select() retorne.

svc_sendreply(xprt, outproc, out)
SVCXPRT *xprt;
xdrproc_t outproc;
char *out;

    Chamada por uma rotina de encaminhamento do serviço RPC para enviar os resultados de uma chamada de procedimento remoto. O parâmetro xprt é o handle de transporte associado à requisição; outproc é a rotina XDR a ser utilizada para codificar os resultados; e out é o endereço dos resultados. Essa rotina retorna um se bem sucedida; zero caso contrário.

void
svc_unregister(prognum, versnum)
u_long prognum, versnum;

    Remove todos os mapeamentos da dupla [prognum,versnum] para rotinas de encaminhamento, da tripla [prognum,versnum,*] para número de porta.

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

    Chamada por uma rotina de encaminhamento do serviço que se recusa a efetuar uma chamada de procedimento remoto devido a um erro de autenticação.

void
svcerr_decode(xprt)
SVCXPRT *xprt;

    Chamada por uma rotina de encaminhamento do serviço que não pode decodificar seus parâmetros com sucesso. Veja também svc_getargs().

void
svcerr_noproc(xprt)
SVCXPRT *xprt;

    Chamada por uma rotina de encaminhamento do serviço que não implementa o número de procedimento que o chamador pede.

void
svcerr_noprog(xprt)
SVCXPRT *xprt;

    Chamada quando o programa desejado não está registrado com o pacote RPC. Implementadores do serviço geralmente não necessitam dessa rotina.

void
svcerr_progvers(xprt)
SVCXPRT *xprt;

    Chamada quando a versão desejada de um programa não está registrada com o pacote RPC. Implementadores do serviço geralmente não necessitam dessa rotina.

void
svcerr_systemerr(xprt)
SVCXPRT *xprt;

    Chamada por uma rotina de encaminhamento do serviço quando ela detecta um erro de sistema não coberto por qualquer protocolo em particular. Por exemplo, se um serviço não pode mais alocar armazenamento, ele poderia chamar essa rotina.

void
svcerr_weakauth(xprt)
SVCXPRT *xprt;

    Chamada por uma rotina de encaminhamento do serviço que se recusa a efetuar uma chamada de procedimento remoto devido a parâmetros de autenticação insuficientes. A rotina chama svcerr_auth(xprt, AUTH_TOOWEAK).

SVCXPRT *
svcraw_create()

    Esta rotina cria um transporte do serviço RPC de brinquedo, para a qual ela retorna um ponteiro. O transporte é na verdade um buffer dentro do espaço de endereçamento do processo, de forma que o cliente RPC correspondente deve viver no mesmo espaço de endereçamento; veja clntraw_create(). Essa rotina permite simulação de RPC e aquisição de sobrecargas RPC (tais como tempos de ida e volta), sem qualquer interferência do kernel. Essa rotina retorna NULO se falhar.

SVCXPRT *
svctcp_create(sock, send_buf_size, recv_buf_size)
int sock;
u_int send_buf_size, recv_buf_size;

    Essa rotina cria um transporte do serviço RPC baseado em TCP/IP , para o qual ela retorna um ponteiro. O transporte é associado com o socket sock, que pode ser RPC_ANYSOCK, caso no qual um novo socket é criado. Se o socket não está associado a uma porta TCP local, então esta rotina liga-o a uma porta arbitrária. Quando da conclusão, xprt->xp_sock é o descritor do socket de transporte e xprt->xp_port é o número da porta do transporte. Essa rotina retorna NULO se falhar. Sabendo que RPC baseado em TCP utiliza E/S por 'buffers', os usuários devem especificar o tamanho dos 'buffers'; valores de zero escolhem padrões razoáveis.

SVCXPRT *
svcfd_create(fd, sendsize, recvsize)
int fd;
u_int sendsize;
u_int recvsize;

    Cria um serviço no topo de qualquer descritor aberto. Tipicamente, esse descritor é um socket conectado a um protocolo de fluxo, como TCP. sendsize e recvsize indicam tamanhos para os buffers de envio e recebimento. Se eles forem zero, um valor padrão razoável é escolhido.

SVCXPRT *
svcudp_bufcreate(sock, sendsize, recosize)
int sock;

    Essa rotina cria um transporte do serviço RPC baseado em UDP/IP , para o qual ela retorna um ponteiro. O transporte é associado com o socket sock, que pode ser RPC_ANYSOCK , caso no qual um novo socket é criado. Se o socket não estiver associado a uma porta UDP local, então essa rotina liga-o a uma porta arbitrária. Quando da conclusão, xprt->xp_sock é o descritor do socket de transporte e xprt->xp_port é o número da porta do transporte. Essa rotina retorna NULO se falhar.

    Ela permite que o usuário especifique o máximo tamanho de pacote para envio e recebimento de mensagens RPC baseadas em UDP.

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

    Utilzada para codificar mensagens de resposta RPC. Essa rotina é útil para usuários que desejam gerar mensagens no estilo RPC-style sem utilizar o pacote RPC.

xdr_authunix_parms(xdrs, aupp)
XDR *xdrs;
struct authunix_parms *aupp;

    Utilizada para descrever credenciais UNIX. Essa rotina é útil para usuários que desejam gerar essas credenciais sem utilizar o pacote de autenticação RPC.

void
xdr_callhdr(xdrs, chdr)
XDR *xdrs;
struct rpc_msg *chdr;

    Utilizada para descrever mensagens de cabeçalho de chamada RPC. Essa rotina é útil para usuários que desejam gerar mensagens no estilo RPC sem utilizar o pacote RPC.

xdr_callmsg(xdrs, cmsg)
XDR *xdrs;
struct rpc_msg *cmsg;

    Utilizada para descrever mensagens de chamada RPC. Essa rotina é útil para usuários que desejam gerar mensagens no estilo RPC sem utilizar o pacote RPC.

xdr_opaque_auth(xdrs, ap)
XDR *xdrs;
struct opaque_auth *ap;

    Utilizada para descrever mensagens de informação de autenticação RPC. Essa rotina é útil para usuários que desejam gerar mensagens no estilo RPC sem utilizar o pacote RPC.

xdr_pmap(xdrs, regs)
XDR *xdrs;
struct pmap *regs;

    Utilzada para descrever parâmetros para vários procedimentos portmap, externamente. Essa rotina é útil para usuários que desejam gerar esses parâmetros sem utilizar a interface pmap.

xdr_pmaplist(xdrs, rp)
XDR *xdrs;
struct pmaplist **rp;

    Utilizada para descrever uma lista de mapeamentos de portas, externamente. Essa rotina é útil para usuários que desejam gerar esses parâmetros sem utilizar a interface pmap .

xdr_rejected_reply(xdrs, rr)
XDR *xdrs;
struct rejected_reply *rr;

    Utilizada para descrever mensagens de resposta RPC. Essa rotina é útil para usuários que desejam gerar mensagens no estilo RPC sem utilizar o pacote RPC.

xdr_replymsg(xdrs, rmsg)
XDR *xdrs;
struct rpc_msg *rmsg;

    Utilizada para descrever mensagens de resposta RPC. Essa rotina é útil para usuários que desejam gerar mensagens no estilo RPC sem utilizar o pacote RPC.

void
xprt_register(xprt)
SVCXPRT *xprt;

    Depois que os handles de transporte do serviço RPC são criados, eles devem registrar a si próprios com o pacote do serviço RPC. Essa rotina modifica a variável global svc_fds(). Implementadores do serviço geralmente não necessitam dessa rotina.

void
xprt_unregister(xprt)
SVCXPRT *xprt;

    Antes que um handle de transporte do serviço RPC seja destruído, ele deve desregistrar a si próprio com o pacote do serviço RPC. Essa rotina modifica a variável global svc_fds(). Implementadores do serviço geralmente não necessitam dessa rotina.

VEJA TAMBÉM
rpc_secure(3N), xdr(3N).
Os seguintes manuais:
    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.

TRADUZIDO POR LDP-BR em 25/07/2001.

  Tradução:
Marcelo M. de Abreu <mmabreu@terra.com.br>

  Revisão.:
Marcelo Pereira da Silva <marcelo@pereira.com>