Provided by:
manpages-fr-dev_3.27fr1.4-1_all 
NOM
rpc - Bibliotheque de fonctions pour les appels de procedures a
distance
SYNOPSIS ET DESCRIPTION
Ces routines permettent a des programmes C de faire des appels de
procedures vers d'autres machines a travers le reseau. D'abord, le
client invoque une procedure pour envoyer un paquet de donnees vers le
serveur. A la reception du paquet, le serveur appelle une routine de
distribution pour executer le service demande, et renvoyer une reponse.
Enfin, l'appel de procedure revient au client.
Pour utiliser ces routines, il faut inclure le fichier d'en-tetes
<rpc/rpc.h>.
Le prototype ci-dessous utilise les types suivants :
typedef int bool_t;
typedef bool_t (*xdrproc_t) (XDR *, void *,...);
typedef bool_t (*resultproc_t) (caddr_t resp,
struct sockaddr_in *raddr);
Consultez les fichiers d'en-tete pour les declarations des types AUTH,
CLIENT, SVCXPRT et XDR.
void auth_destroy(AUTH *auth);
Cette macro detruit les informations d'authentification associee
avec auth. La destruction implique generalement la desallocation
de donnees privees. Le comportement est indefini si on essaye
d'utiliser auth apres avoir invoque auth_destroy().
AUTH *authnone_create(void);
Cree et renvoie un descripteur d'authentification RPC
transmettant avec chaque appel de procedure une information
d'authentification nulle. C'est le comportement par defaut pour
les RPC.
AUTH *authunix_create(char *host, int uid, int gid,
int len, int *aup_gids);
Cree et renvoie un descripteur d'authentification RPC Unix,
contenant des informations d'identification. L'argument host est
le nom de la machine sur laquelle l'information est creee. uid
est l'identification de l'utilisateur. gid est l'identification
du groupe de l'utilisateur. len et aup_gids concernent la table
des groupes supplementaires auxquels l'utilisateur appartient.
On peut facilement se faire passer pour quelqu'un d'autre.
AUTH *authunix_create_default(void);
Appelle authunix_create() avec les arguments appropries.
int callrpc(char *host, unsigned long prognum,
unsigned long versnum, unsigned long procnum,
xdrproc_t inproc, char *in,
xdrproc_t outproc, char *out);
Appelle la procedure distante associee aux arguments prognum,
versnum, et procnum sur la machine, host. L'argument in est
l'adresse du ou des arguments d'entree de la procedure, out
celle de l'emplacement ou stocker le ou les resultats, inproc
sert a encoder les parametres d'entree de la procedure, et
outproc a decoder les resultats de la procedure. Cette routine
renvoie zero si elle reussit, ou la valeur de enum clnt_stat
transposee en un nombre entier si elle echoue La routine
clnt_perrno() permet de traduire les codes d'echec en messages.
Attention : l'appel d'une procedure distante avec cette routine
emploie le protocole UDP/IP pour le transport, consultez
clntudp_create() pour certaines restrictions. Vous n'avez aucun
controle sur le delai maximal ou sur l'authentification avec
cette routine.
enum clnt_stat clnt_broadcast(unsigned long prognum,
unsigned long versnum, unsigned long procnum,
xdrproc_t inproc, char *in,
xdrproc_t outproc, char *out,
resultproc_t eachresult);
Comme callrpc(), sauf que le message d'appel est diffuse sur
tous les reseaux connectes. A chaque reception d'une reponse,
cette routine appelle la fonction eachresult(), dont la forme
est :
eachresult(char *out, struct sockaddr_in *addr);
ou out est du meme type que le out passe a clnt_broadcast(),
avec la difference que la sortie de la procedure distante est
decodee ici. addr pointe vers l'adresse de la machine qui a
envoye le resultat. Si eachresult() renvoie zero,
clnt_broadcast() attend d'autres reponses. Sinon elle revient
avec le code de retour approprie.
Attention : les sockets broadcast sont limitees en ce qui
concerne la taille maximale des donnees. Pour l'Ethernet, cette
valeur (MTU) vaut 1500 octets.
enum clnt_stat clnt_call(CLIENT *clnt, unsigned long procnum,
xdrproc_t inproc, char *in,
xdrproc_t outproc, char *out,
struct timeval tout);
Une macro qui appelle la procedure distante procnum associee
avec le descripteur de client clnt, qui est obtenu grace a une
routine de creation de client RPC comme clnt_create().
L'argument in est l'adresse du ou des arguments d'entree de la
procedure, out celle de l'emplacement ou stocker le ou les
resultats, inproc sert a encoder les parametres d'entree de la
procedure, et outproc a decoder les resultats de la procedure.
tout est le delai maximal accorde pour la realisation de la
procedure.
clnt_destroy(CLIENT *clnt);
Une macro qui detruit le descripteur de client RPC ce qui
implique generalement la liberation de structures de donnees
privees, y compris clnt lui meme. Le comportement est indefini
si on tente d'utiliser clnt apres avoir appele clnt_destroy().
Si la bibliotheque RPC avait ouvert la socket associee, elle
sera egalement fermee. Sinon, la socket reste ouverte.
CLIENT *clnt_create(char *host, unsigned long prog,
unsigned long vers, char *proto);
Routine generique de creation de client. host identifie le nom
de l'hote distant ou se trouve le serveur. proto indique le type
de protocole de transport a employer. Les valeurs actuellement
supportees pour ce champ sont << udp >> et << tcp >>. Des
valeurs par defaut sont configurees pour les delais, mais
peuvent etre modifiees a l'aide de clnt_control().
Attention : l'utilisation du protocole UDP a des inconvenients.
Comme les messages RPC bases sur UDP ne peuvent contenir que
8 Ko de donnees encodees, ce protocole ne peut pas etre utilise
pour des procedures necessitant de gros arguments, ou renvoyant
d'enormes resultats.
bool_t clnt_control(CLIENT *cl, int req, char *info);
Une macro employee pour modifier ou recuperer des informations
diverses a propos d'un objet client. req indique le type
d'operation, et info est un pointeur sur l'information. Pour UDP
comme pour TCP, les valeurs autorisees pour req et le type des
arguments sont :
CLSET_TIMEOUT struct timeval // fixer le delai total
CLGET_TIMEOUT struct timeval // lire le delai total
Note : Si vous fixez le delai avec clnt_control(), le dernier
argument de clnt_call() sera ignore lors des appels ulterieurs.
CLGET_SERVER_ADDR struct sockaddr_in // lire l'adresse du serveur
Les operations suivantes sont valides pour le protocole UDP
seulement :
CLSET_RETRY_TIMEOUT struct timeval // fixer le delai de repetition
CLGET_RETRY_TIMEOUT struct timeval // lire le delai de repetition
Le delai de repetition est le temps pendant lequel les "RPC UDP"
attendent une reponse du serveur avant retransmettre la requete.
clnt_freeres(CLIENT * clnt, xdrproc_t outproc, char *out);
Une macro qui libere toutes les donnees allouees par le systeme
RPC/XDR lorsqu'il a decode les resultats d'un appel RPC
L'argument out est l'adresse des resultats, et outproc est la
routine XDR decodant les resultats. Cette fonction renvoie 1 si
les resultats ont ete correctement liberes, et zero sinon.
void clnt_geterr(CLIENT *clnt, struct rpc_err *errp);
Une macro qui copie la structure d'erreur depuis le descripteur
de client vers la structure se trouvant a l'adresse errp.
void clnt_pcreateerror(char *s);
Affiche un message sur la sortie d'erreur standard, indiquant
pourquoi un descripteur de client RPC ne peut pas etre cree. Ce
message est prefixe avec la chaine s et un deux-points est
insere. A utiliser lorsque les appels clnt_create(),
clntraw_create(), clnttcp_create() ou clntudp_create() echouent.
void clnt_perrno(enum clnt_stat stat);
Affiche un message sur la sortie d'erreur standard,
correspondant a la condition indiquee par stat. A utiliser apres
callrpc().
clnt_perror(CLIENT *clnt, char *s);
Affiche un message sur la sortie d'erreur standard indiquant
pourquoi un appel RPC a echoue. clnt est le descripteur utilise
pour l'appel. Ce message est prefixe avec la chaine s et un
deux-points est insere. A utiliser apres clnt_call().
char *clnt_spcreateerror(char *s);
Comme clnt_pcreateerror(), sauf qu'il renvoie une chaine au lieu
d'ecrire sur la sortie d'erreur standard.
Danger : renvoie un pointeur vers une zone de donnee statique,
ecrasee a chaque appel.
char *clnt_sperrno(enum clnt_stat stat);
Emploie les meme arguments que clnt_perrno(), mais au lieu
d'envoyer un message sur la sortie d'erreur standard indiquant
pourquoi un appel RPC a echoue, renvoie un pointeur sur une
chaine contenant le message. La chaine se termine par un
NEWLINE.
clnt_sperrno() est utilisee a la place de clnt_perrno() si le
programme n'a pas de sortie d'erreur standard (un serveur par
exemple n'en a generalement pas), ou si le programmeur ne veut
pas que le message soit affiche avec printf(3), ou si un format
de message different de celui fourni par clnt_perrno() doit etre
utilise. Note : contrairement a clnt_sperror() et
clnt_spcreaterror(), clnt_sperrno() renvoie un pointeur sur une
zone de donnee statique, mais le resultat ne sera pas ecrase a
chaque appel.
char *clnt_sperror(CLIENT *rpch, char *s);
Comme clnt_perror(), sauf que (comme clnt_sperrno()) il renvoie
une chaine au lieu d'ecrire sur la sortie d'erreur standard.
Danger : renvoie un pointeur vers une zone de donnee statique,
ecrasee a chaque appel.
CLIENT *clntraw_create(unsigned long prognum, unsigned long versnum);
Cette routine cree un simili client RPC pour le programme
distant prognum, de version versnum. Le mecanisme de transport
pour les messages est en realite un tampon dans l'espace
d'adresse du processus, ainsi le serveur RPC doit se trouver
dans le meme espace d'adresse. Consultez svcraw_create(). Cela
permet de simuler une RPC et de mesurer la surcharge des
procedures RPC comme les temps d'aller-retour sans interference
due au noyau. Cette routine renvoie NULL si elle echoue.
CLIENT *clnttcp_create(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
int *sockp, unsigned int sendsz, unsigned int recvsz);
Cette routine cree un client RPC pour le programme distant
prognum, de version versnum ; Le client utilise TCP/IP pour le
transport. Le programme distant se trouve a l'adresse Internet
*addr. Si addr->sin_port vaut zero, alors il est rempli avec le
numero de port sur lequel le programme distant est en ecoute (on
consulte le service portmap distant pour obtenir cette
information). L'argument sockp est une socket; si c'est
RPC_ANYSOCK, alors la routine ouvre une nouvelle socket et
remplit sockp. Comme les RPC basees sur TCP utilisent des
entrees-sorties avec tampons, l'utilisateur peut specifier la
taille des tampons d'entree et de sortie avec les parametres
sendsz et recvsz. Des valeurs nulles reclament l'utilisation de
tampons de tailles optimales. Cette routine renvoie NULL si elle
echoue.
CLIENT *clntudp_create(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
struct timeval wait, int *sockp);
Cette routine cree un client RPC pour le programme distant
prognum, de version versnum ; Le client utilise UDP/IP pour le
transport. Le programme distant se trouve a l'adresse Internet
addr. Si addr->sin_port vaut zero, alors il est rempli avec le
numero de port sur lequel le programme distant est en ecoute (on
consulte le service portmap distant pour obtenir cette
information). L'argument sockp est une socket; si c'est
RPC_ANYSOCK, alors la routine ouvre une nouvelle socket et
remplit sockp. Le protocole de transport UDP renvoie le message
d'appel avec un intervalle de temps indique par wait() jusqu'a
la reception d'une reponse ou jusqu'au depassement du temps
maximal. Ce delai total pour l'appel est specifie par la
fonction clnt_call().
Attention : comme les messages des RPC basees sur UDP ne peuvent
contenir que 8 Ko de donnees encodees, ce protocole ne peut pas
etre utilise pour des procedures necessitant de gros arguments,
ou renvoyant d'enormes resultats.
CLIENT *clntudp_bufcreate(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
struct timeval wait, int *sockp,
unsigned int sendsize, unsigned int recosize);
Cette routine cree un client RPC pour le programme distant
prognum, de version versnum ; Le client utilise UDP/IP pour le
transport. Le programme distant se trouve a l'adresse Internet
addr. Si addr->sin_port vaut zero, alors il est rempli avec le
numero de port sur lequel le programme distant est en ecoute (on
consulte le service portmap distant pour obtenir cette
information). L'argument sockp est une socket; si c'est
RPC_ANYSOCK, alors la routine ouvre une nouvelle socket et
remplit sockp. Le protocole de transport UDP renvoie le message
d'appel avec un intervalle de temps indique par wait() jusqu'a
la reception d'une reponse ou jusqu'au depassement du temps
maximal. Ce delai total pour l'appel est specifie par la
fonction clnt_call().
Cette routine permet au programmeur de preciser la taille
maximale des tampons en emission et reception pour les messages
RPC bases sur UDP.
void get_myaddress(struct sockaddr_in *addr);
Fournit l'adresse IP de la machine dans la structure *addr, sans
consulter les routines de bibliotheques qui manipulent
/etc/hosts. Le numero de port est toujours rempli avec
htons(PMAPPORT).
struct pmaplist *pmap_getmaps(struct sockaddr_in *addr);
Une interface utilisateur pour le service portmap renvoyant une
liste des associations en cours entre programmes RPC et ports
sur l'hote situe a l'adresse IP indiquee dans *addr. Cette
routine peut renvoyer NULL. La commande << rpcinfo -p >> utilise
cette fonction
unsigned short pmap_getport(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
unsigned int protocol);
Une interface utilisateur pour le service portmap qui renvoie le
numero de port sur lequel est en ecoute le service associe au
programme numero prognum, de version versnum, en utilisant le
protocole de transport associe avec protocol. La valeur de
l'argument protocol est normalement IPPROTO_UDP ou IPPROTO_TCP.
Une valeur de retour nulle signifie qu'aucune association
n'existe ou qu'une erreur du systeme RPC s'est produite en
tentant de contacter le service portmap distant. Dans ce cas, la
variable globale rpc_createerr contient le code RPC de l'erreur.
enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
unsigned long procnum,
xdrproc_t inproc, char *in,
xdrproc_t outproc, char *out,
struct timeval tout, unsigned long *portp);
Une interface utilisateur pour le service portmap qui demande au
programme portmap sur l'hote se trouvant a l'adresse IP indiquee
dans *addr de faire en notre nom un appel RPC pour une procedure
se trouvant sur cet hote. Le parametre *portp sera modifie pour
contenir le numero de port du programme si la procedure reussit.
Les definitions des autres arguments sont presentees a propos de
callrpc() et de clnt_call(). Cette procedure devrait etre
utilisee pour faire un << ping >> et rien d'autre. Consultez
aussi clnt_broadcast().
bool_t pmap_set(unsigned long prognum, unsigned long versnum,
unsigned int protocol, unsigned short port);
Une interface utilisateur pour le service portmap qui etablit
une association entre le triplet [prognum, versnum, protocol] et
le port sur la machine du service portmap La valeur du protocol
est normalement IPPROTO_UDP ou IPPROTO_TCP. Cette routine
renvoie 1 si elle reussit, et zero sinon. Elle est
automatiquement invoquee par svc_register().
bool_t pmap_unset(unsigned long prognum, unsigned long versnum);
Une interface utilisateur vers le service portmap qui detruit
toute association entre le triplet [prognum, versnum, *] et les
ports de la machine ou se trouve le service portmap. Cette
routine renvoie 1 si elle reussit, et zero sinon.
int registerrpc(unsigned long prognum, unsigned long versnum,
unsigned long procnum, char *(*procname)(char *),
xdrproc_t inproc, xdrproc_t outproc);
Enregistre la procedure procname avec le service RPC. Si une
requete arrive pour le programme prognum, de version versnum, et
pour la procedure procnum, procname sera appelee avec un
pointeur vers ses parametres d'entree. progname doit renvoyer un
pointeur vers ses resultats statiques. inproc est utilisee pour
decoder les parametres d'entree alors que outproc sert a encode
les resultats. Cette routine renvoie zero si l'enregistrement a
reussi, et -1 sinon.
Attention : les procedures enregistrees de cette maniere sont
accessibles avec le protocole de transport UDP/IP. Consultez
svcudp_create() pour ses restrictions.
struct rpc_createerr rpc_createerr;
Une variable globale dont la valeur est fixee par toute routine
SM RPC de creation de client qui echoue. Utilisez la routine
clnt_pcreateerror() pour afficher la raison de l'echec.
void svc_destroy(SVCXPRT *xprt);
Une macro qui detruit le descripteur de transport RPC xprt. La
destruction implique normalement la liberation de structures de
donnees privees, y compris xprt lui-meme. Le comportement est
indefini si on essaye d'utiliser xprt apres avoir appele cette
routine.
fd_set svc_fdset;
Une variable globale representant le masque de bits des
descripteurs de fichier en lecture du cote serveur RPC. Elle est
utilisable avec l'appel systeme select(2). Ce n'est interessant
que si l'implementation d'un service n'appelle pas svc_run(),
mais assure son propre traitement d'evenements asynchrones.
Cette variable est en lecture seule (ne passez pas son adresse a
select(2) !), et elle peut changer apres un appel
svc_getreqset() ou une routine de creation.
int svc_fds;
Similaire a svc_fdset, mais limitee a 32 descripteurs. Cette
interface est rendue obsolete par svc_fdset.
svc_freeargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
Une macro qui libere toutes les donnees allouees par le systeme
RPC/XDR lorsqu'il decode les arguments d'une procedure de
service avec svc_getargs(). Cette routine renvoie 1 si les
arguments ont ete correctement liberes, et zero sinon.
svc_getargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
Une macro qui decode les arguments d'une requete RPC associee
avec le descripteur de transport RPC xprt. L'argument in est
l'adresse ou les arguments seront stockes, inproc est la routine
XDR pour decoder les arguments. Cette routine renvoie 1 si le
decodage reussit, et zero sinon.
struct sockaddr_in *svc_getcaller(SVCXPRT *xprt);
La maniere correcte d'obtenir l'adresse reseau de l'appelant
d'une procedure associee avec le descripteur de transport RPC
xprt.
void svc_getreqset(fd_set *rdfds);
Cette routine n'est interessante que si l'implementation d'un
service n'appelle pas svc_run(), mais emploie a la place un
traitement personnalise des evenements asynchrones. On l'invoque
lorsque l'appel systeme select(2) a determine qu'une requete RPC
est arrivee sur l'une des sockets RPC. rdfds est le masque de
bits des descripteurs de fichier en resultant. La routine
revient lorsque toutes les sockets associees avec les valeurs de
rdfds ont ete servies.
void svc_getreq(int rdfds);
Similaire a svc_getreqset(), mais limitee a 32 descripteurs.
Cette interface est rendue obsolete par svc_getreqset().
bool_t svc_register(SVCXPRT *xprt, unsigned long prognum,
unsigned long versnum,
void (*dispatch)(svc_req *, SVCXPRT *),
unsigned long protocol);
Associer prognum et versnum avec la procedure de distribution
dispatch. Si protocol vaut zero, le service n'est pas enregistre
avec le service portmap. Si protocol est non-nul, alors
l'association entre le triplet [prognum,versnum,protocol] et
xprt->xp_port est etablie par l'intermediaire du service portmap
local (en general protocol vaut zero, IPPROTO_UDP ou
IPPROTO_TCP). La procedure dispatch a la forme suivante
dispatch(struct svc_req *request, SVCXPRT *xprt);
La routine svc_register() renvoie 1 si elle reussit et 0 sinon.
void svc_run(void);
Cette routine ne revient jamais. Elle attend l'arrivee de
requetes RPC et appelle les procedures de service appropriees en
utilisant svc_getreq(). Cette procedure est la plupart du temps
en attente autour d'un appel systeme select(2).
bool_t svc_sendreply(SVCXPRT *xprt, xdrproc_t outproc, char *out);
Appelee par une routine de distribution de services RPC pour
envoyer le resultat d'un appel de procedure distante. L'argument
xprt est le descripteur de transport associe a la requete,
outproc est la routine XDR utilisee pour encoder les resultats,
et out est l'adresse des resultats. Cette routine renvoie 1 si
elle reussit, et 0 sinon.
void svc_unregister(unsigned long prognum, unsigned long versnum);
Supprimer toute association du doublet [prognum, versnum] vers
les routines de distribution, et du triplet [prognum, versnum,
*] vers le numero de port.
void svcerr_auth(SVCXPRT *xprt, enum auth_stat why);
Appelee par une routine de distribution de service qui refuse
d'executer un appel de procedure distante a cause d'une erreur
d'authentification.
void svcerr_decode(SVCXPRT *xprt);
Appelee par une routine de distribution de service qui n'arrive
pas a decoder ses arguments. Consultez aussi svc_getargs().
void svcerr_noproc(SVCXPRT *xprt);
Appelee par une routine de distribution de service qui
n'implemente pas le numero de procedure que l'appelant reclame.
void svcerr_noprog(SVCXPRT *xprt);
Appelee quand le programme desire n'est pas enregistre dans le
service RPC. L'implementation d'un service n'a normalement pas
besoin de cette routine.
void svcerr_progvers(SVCXPRT *xprt);
Appelee quand le numero de version du programme desire n'est pas
enregistre dans le service RPC. L'implementation d'un service
n'a normalement pas besoin de cette routine.
void svcerr_systemerr(SVCXPRT *xprt);
Appelee par une routine de distribution de service lorsqu'elle
detecte une erreur systeme non couverte par un protocole. Par
exemple, si un service ne peut plus allouer de place, il peut
appeler cette routine.
void svcerr_weakauth(SVCXPRT *xprt);
Appelee par une routine de distribution de service qui refuse
d'executer un appel de procedure distante a cause d'un manque de
parametres d'authentification. La routine appelle
svcerr_auth(xprt, AUTH_TOOWEAK).
SVCXPRT *svcfd_create(int fd, unsigned int sendsize,
unsigned int recvsize);
Creer un service au-dessus de n'importe quel descripteur ouvert.
Typiquement ces descripteurs sont des sockets pour un protocole
connecte comme TCP. sendsize et recvsize indiquent les tailles
pour les tampons d'emission et de reception. Si ces tailles
valent zero, une valeur optimale est choisie.
SVCXPRT *svcraw_create(void);
Cette routine cree un simili transport de service RPC vers
lequel il renvoie un pointeur. Le transport est en fait un
tampon au sein de l'espace d'adressage du processus. Le client
RPC correspondant doit donc resider dans le meme espace
d'adresse. Consultez clntraw_create(). Cela permet de simuler
une RPC et de mesurer la surcharge des procedures RPC comme les
temps d'aller-retour sans interference due au noyau. Cette
routine renvoie NULL si elle echoue.
SVCXPRT *svctcp_create(int sock, unsigned int send_buf_size,
unsigned int recv_buf_size);
Cette routine cree un transport de service RPC base sur TCP/IP
sur lequel elle renvoie un pointeur. Il est associe avec la
socket sock, qui peut etre RPC_ANYSOCK, auquel cas une nouvelle
socket est creee. Si la socket n'est pas associee a un port TCP
local, cette routine l'associe a un port quelconque. Apres
reussite, xprt->xp_sock est le descripteur de la socket de
transport, et xprt->xp_port est le numero de port. Cette routine
renvoie NULL si elle echoue. Comme les RPC basee sur TCP
utilisent des entrees-sorties avec tampon, les utilisateurs
peuvent fixer la taille des tampons. Une taille nulle implique
l'allocation automatique de tampons de tailles optimales.
SVCXPRT *svcudp_bufcreate(int sock, unsigned int sendsize,
unsigned int recosize);
Cette routine cree un transport de service RPC base sur UDP/IP
et renvoie un pointeur dessus. Le transport est associe avec la
socket sock, qui peut etre RPC_ANYSOCK, auquel cas une nouvelle
socket est creee. Si la socket n'est pas associee a un port UDP
local, cette routine l'associe a un port quelconque. Apres
reussite, xprt->xp_sock est le descripteur de transport, et
xprt->xp_port est le numero de port. Cette routine renvoie NULL
si elle echoue.
Cette routine permet au programmeur de preciser la taille
maximale des tampons en emission et reception pour les messages
RPC bases sur UDP.
SVCXPRT *svcudp_create(int sock);
Cet appel est equivalent a svcudp_bufcreate(sock,SZ,SZ) avec une
taille SZ par defaut.
bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);
Utilisee pour encoder les messages de reponse RPC. Cette routine
est utile pour les programmeurs qui desirent engendrer des
messages de style RPC sans employer le service RPC complet.
bool_t xdr_authunix_parms(XDR *xdrs, struct authunix_parms *aupp);
Utilisee pour decrire les identites Unix. Cette routine est
utile pour les programmeurs qui veulent engendrer ces identites
sans utiliser le systeme RPC d'authentification.
void xdr_callhdr(XDR *xdrs, struct rpc_msg *chdr);
Utilisee pour creer les entetes de message RPC. Cette routine
est utile pour les programmeurs qui desirent engendrer des
messages de style RPC sans employer le service RPC complet.
bool_t xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);
Utilisee pour creer les messages d'appel RPC. Cette routine est
utile pour les programmeurs qui desirent engendrer des messages
de style RPC sans employer le service RPC complet.
bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
Utilisee pour creer les informations d'authentification RPC.
Cette routine est utile pour les programmeurs qui desirent
engendrer des messages de style RPC sans employer le service RPC
complet.
bool_t xdr_pmap(XDR *xdrs, struct pmap *regs);
Utilisee pour creer les parametres des divers procedures
portmap. Cette routine est utile pour les programmeurs qui
desirent creer ces parametres sans utiliser l'interface pmap.
bool_t xdr_pmaplist(XDR *xdrs, struct pmaplist **rp);
Utilisee pour creer la liste des associations des ports. Cette
routine est utile pour les programmeurs qui desirent creer ces
parametres sans utiliser l'interface pmap.
bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);
Utilisee pour creer les messages de rejet RPC. Cette routine est
utile pour les programmeurs qui desirent engendrer des messages
de style RPC sans employer le service RPC complet.
bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);
Utilisee pour creer les messages de reponse RPC. Cette routine
est utile pour les programmeurs qui desirent engendrer des
messages de style RPC sans employer le service RPC complet.
void xprt_register(SVCXPRT *xprt);
Apres la creation d'un descripteur RPC de transport, il doit
etre enregistre dans le service RPC. Cette routine modifie la
variable globale svc_fds. L'implementation d'un service ne
necessite pas cette routine habituellement.
void xprt_unregister(SVCXPRT *xprt);
Avant qu'un descripteur RPC de transport soit detruit, il doit
se desinscrire du service RPC. Cette routine modifie la variable
globale svc_fds. L'implementation d'un service ne necessite pas
cette routine habituellement.
VOIR AUSSI
xdr(3)
Les manuels suivants :
Remote Procedure Calls: Protocol Specification
Remote Procedure Call Programming Guide
rpcgen Programming Guide
RPC: Remote Procedure Call Protocol Specification, RFC 1050, Sun
Microsystems, Inc., USC-ISI.
COLOPHON
Cette page fait partie de la publication 3.27 du projet man-pages
Linux. Une description du projet et des instructions pour signaler des
anomalies peuvent etre trouvees a l'adresse
<URL:http://www.kernel.org/doc/man-pages/>.
TRADUCTION
Depuis 2010, cette traduction est maintenue a l'aide de l'outil po4a
<URL:http://po4a.alioth.debian.org/> par l'equipe de traduction
francophone au sein du projet perkamon
<URL:http://perkamon.alioth.debian.org/>.
Christophe Blaess <URL:http://www.blaess.fr/christophe/> (1996-2003),
Alain Portal <URL:http://manpagesfr.free.fr/> (2003-2006). Nicolas
Francois et l'equipe francophone de traduction de Debian (2006-2009).
Veuillez signaler toute erreur de traduction en ecrivant a
<debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
paquet manpages-fr.
Vous pouvez toujours avoir acces a la version anglaise de ce document
en utilisant la commande << man -L C <section> <page_de_man> >>.
17 juillet 2008 RPC(3)