rpc(3) Library Functions Manual rpc(3) NOM rpc - Bibliotheque de fonctions pour les appels de procedures a distance BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) 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 . 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, uid_t uid, gid_t gid, int len, gid_t aup_gids[.len]); 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, const 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 limites 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 le socket associe, il sera egalement ferme. Sinon, le socket reste ouvert. CLIENT *clnt_create(const char *host, unsigned long prog, unsigned long vers, const 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 // definir le delai total CLGET_TIMEOUT struct timeval // lire le delai total Note : Si vous definissez 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 // definir 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(const 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, const 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(const 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, const 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 un socket ; si c'est RPC_ANYSOCK, alors la routine ouvre un nouveau 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 un socket ; si c'est RPC_ANYSOCK, alors la routine ouvre un nouveau 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 un socket ; si c'est RPC_ANYSOCK, alors la routine ouvre une nouveau 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, 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 definie 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 assure son propre traitement d'evenements asynchrones, au lieu d'appeler svc_run(). 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 de fichier. 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 tous les sockets associes avec les valeurs de rdfds ont ete servis. void svc_getreq(int rdfds); Similaire a svc_getreqset(), mais limitee a 32 descripteurs de fichier. Cette interface est rendue obsolete par svc_getreqset(). bool_t svc_register(SVCXPRT *xprt, unsigned long prognum, unsigned long versnum, void (*dispatch)(struct 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, unsigned long low_vers, unsigned long high_vers); 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 ce descripteur de fichier est un socket connecte pour un protocole de flux 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 le socket sock, qui peut etre RPC_ANYSOCK, auquel cas un nouveau socket est cree. Si le socket n'est pas associe a un port TCP local, cette routine l'associe a un port quelconque. Apres reussite, xprt->xp_sock est le descripteur du 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 definir 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 le socket sock, qui peut etre RPC_ANYSOCK, auquel cas un nouveau socket est cree. Si le socket n'est pas associe 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 en-tetes 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. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |auth_destroy(), | Securite des threads | MT-Safe | |authnone_create(), | | | |authunix_create(), | | | |authunix_create_default(), | | | |callrpc(), clnt_broadcast(), | | | |clnt_call(), clnt_destroy(), | | | |clnt_create(), clnt_control(), | | | |clnt_freeres(), clnt_geterr(), | | | |clnt_pcreateerror(), | | | |clnt_perrno(), clnt_perror(), | | | |clnt_spcreateerror(), | | | |clnt_sperrno(), clnt_sperror(), | | | |clntraw_create(), | | | |clnttcp_create(), | | | |clntudp_create(), | | | |clntudp_bufcreate(), | | | |get_myaddress(), pmap_getmaps(), | | | |pmap_getport(), pmap_rmtcall(), | | | |pmap_set(), pmap_unset(), | | | |registerrpc(), svc_destroy(), | | | |svc_freeargs(), svc_getargs(), | | | |svc_getcaller(), | | | |svc_getreqset(), svc_getreq(), | | | |svc_register(), svc_run(), | | | |svc_sendreply(), | | | |svc_unregister(), svcerr_auth(), | | | |svcerr_decode(), | | | |svcerr_noproc(), | | | |svcerr_noprog(), | | | |svcerr_progvers(), | | | |svcerr_systemerr(), | | | |svcerr_weakauth(), | | | |svcfd_create(), svcraw_create(), | | | |svctcp_create(), | | | |svcudp_bufcreate(), | | | |svcudp_create(), | | | |xdr_accepted_reply(), | | | |xdr_authunix_parms(), | | | |xdr_callhdr(), xdr_callmsg(), | | | |xdr_opaque_auth(), xdr_pmap(), | | | |xdr_pmaplist(), | | | |xdr_rejected_reply(), | | | |xdr_replymsg(), xprt_register(), | | | |xprt_unregister() | | | +---------------------------------+--------------------------+---------+ 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. TRADUCTION La traduction francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Jean-Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 rpc(3)