rpc(3) Library Functions Manual rpc(3)
NOM
rpc - Bibliothèque de fonctions pour les appels de procédures à dis-
tance
BIBLIOTHÈQUE
Bibliothèque C standard (libc, -lc)
SYNOPSIS ET DESCRIPTION
Ces routines permettent à des programmes C de faire des appels de pro-
cédures vers d'autres machines à travers le réseau. D'abord, le client
invoque une procédure pour envoyer un paquet de données vers le ser-
veur. À la réception du paquet, le serveur appelle une routine de dis-
tribution pour exécuter le service demandé, et renvoyer une réponse.
Enfin, l'appel de procédure revient au client.
Pour utiliser ces routines, il faut inclure le fichier d'en-têtes
<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-tête pour les déclarations des types AUTH,
CLIENT, SVCXPRT et XDR.
void auth_destroy(AUTH *auth);
Cette macro détruit les informations d'authentification associée
avec auth. La destruction implique généralement la désallocation
de données privées. Le comportement est indéfini si on essaye
d'utiliser auth après avoir invoqué auth_destroy().
AUTH *authnone_create(void);
Crée et renvoie un descripteur d'authentification RPC transmet-
tant avec chaque appel de procédure une information d'authenti-
fication nulle. C'est le comportement par défaut pour les RPC.
AUTH *authunix_create(char *host, uid_t uid, gid_t gid,
int len, gid_t aup_gids[.len]);
Crée 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 créée. 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 supplémentaires 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 appropriés.
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 procédure distante associée aux arguments prognum,
versnum, et procnum sur la machine, host. L'argument in est
l'adresse du ou des arguments d'entrée de la procédure, out
celle de l'emplacement où stocker le ou les résultats, inproc
sert à encoder les paramètres d'entrée de la procédure, et out-
proc à décoder les résultats de la procédure. Cette routine ren-
voie zéro si elle réussit, ou la valeur de enum clnt_stat trans-
posée en un nombre entier si elle échoue La routine
clnt_perrno() permet de traduire les codes d'échec en messages.
Attention : l'appel d'une procédure distante avec cette routine
emploie le protocole UDP/IP pour le transport, consultez cln-
tudp_create() pour certaines restrictions. Vous n'avez aucun
contrôle sur le délai 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 diffusé sur
tous les réseaux connectés. À chaque réception d'une réponse,
cette routine appelle la fonction eachresult(), dont la forme
est :
eachresult(char *out, struct sockaddr_in *addr);
où out est du même type que le out passé à clnt_broadcast(),
avec la différence que la sortie de la procédure distante est
décodée ici. addr pointe vers l'adresse de la machine qui a en-
voyé le résultat. Si eachresult() renvoie zéro, clnt_broadcast()
attend d'autres réponses. Sinon elle revient avec le code de re-
tour approprié.
Attention : les sockets broadcast sont limitées en ce qui
concerne la taille maximale des données. 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 procédure distante procnum associée
avec le descripteur de client clnt, qui est obtenu grâce à une
routine de création de client RPC comme clnt_create(). L'argu-
ment in est l'adresse du ou des arguments d'entrée de la procé-
dure, out celle de l'emplacement où stocker le ou les résultats,
inproc sert à encoder les paramètres d'entrée de la procédure,
et outproc à décoder les résultats de la procédure. tout est le
délai maximal accordé pour la réalisation de la procédure.
clnt_destroy(CLIENT *clnt);
Une macro qui détruit le descripteur de client RPC ce qui im-
plique généralement la libération de structures de données pri-
vées, y compris clnt lui-même. Le comportement est indéfini si
on tente d'utiliser clnt après avoir appelé clnt_destroy(). Si
la bibliothèque RPC avait ouvert la socket associée, elle sera
également fermée. Sinon, la socket reste ouverte.
CLIENT *clnt_create(const char *host, unsigned long prog,
unsigned long vers, const char *proto);
Routine générique de création de client. host identifie le nom
de l'hôte distant où se trouve le serveur. proto indique le type
de protocole de transport à employer. Les valeurs actuellement
supportées pour ce champ sont « udp » et « tcp ». Des valeurs
par défaut sont configurées pour les délais, mais peuvent être
modifiées à l'aide de clnt_control().
Attention : l'utilisation du protocole UDP a des inconvénients.
Comme les messages RPC basés sur UDP ne peuvent contenir que
8 Ko de données encodées, ce protocole ne peut pas être utilisé
pour des procédures nécessitant de gros arguments ou renvoyant
d'énormes résultats.
bool_t clnt_control(CLIENT *cl, int req, char *info);
Une macro employée pour modifier ou récupérer des informations
diverses à propos d'un objet client. req indique le type d'opé-
ration, et info est un pointeur sur l'information. Pour UDP
comme pour TCP, les valeurs autorisées pour req et le type des
arguments sont :
CLSET_TIMEOUT struct timeval // définir le délai total
CLGET_TIMEOUT struct timeval // lire le délai total
Note : Si vous définissez le délai avec clnt_control(), le der-
nier argument de clnt_call() sera ignoré lors des appels ulté-
rieurs.
CLGET_SERVER_ADDR struct sockaddr_in
// lire l'adresse du serveur
Les opérations suivantes sont valides pour le protocole UDP
seulement :
CLSET_RETRY_TIMEOUT struct timeval // définir le délai de répétition
CLGET_RETRY_TIMEOUT struct timeval // lire le délai de répétition
Le délai de répétition est le temps pendant lequel les "RPC UDP"
attendent une réponse du serveur avant retransmettre la requête.
clnt_freeres(CLIENT * clnt, xdrproc_t outproc, char *out);
Une macro qui libère toutes les données allouées par le système
RPC/XDR lorsqu'il a décodé les résultats d'un appel RPC L'argu-
ment out est l'adresse des résultats, et outproc est la routine
XDR décodant les résultats. Cette fonction renvoie 1 si les ré-
sultats ont été correctement libérés, et zéro 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 à 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 être créé. Ce
message est préfixé avec la chaîne s et un deux-points est in-
séré. À utiliser lorsque les appels clnt_create(), cln-
traw_create(), clnttcp_create() ou clntudp_create() échouent.
void clnt_perrno(enum clnt_stat stat);
Affiche un message sur la sortie d'erreur standard, correspon-
dant à la condition indiquée par stat. À utiliser après
callrpc().
clnt_perror(CLIENT *clnt, const char *s);
Affiche un message sur la sortie d'erreur standard indiquant
pourquoi un appel RPC a échoué. clnt est le descripteur utilisé
pour l'appel. Ce message est préfixé avec la chaîne s et un
deux-points est inséré. À utiliser après clnt_call().
char *clnt_spcreateerror(const char *s);
Comme clnt_pcreateerror(), sauf qu'il renvoie une chaîne au lieu
d'écrire sur la sortie d'erreur standard.
Danger : renvoie un pointeur vers une zone de donnée statique,
écrasée à chaque appel.
char *clnt_sperrno(enum clnt_stat stat);
Emploie les même arguments que clnt_perrno(), mais au lieu d'en-
voyer un message sur la sortie d'erreur standard indiquant pour-
quoi un appel RPC a échoué, renvoie un pointeur sur une chaîne
contenant le message. La chaîne se termine par un NEWLINE.
clnt_sperrno() est utilisée à la place de clnt_perrno() si le
programme n'a pas de sortie d'erreur standard (un serveur par
exemple n'en a généralement pas), ou si le programmeur ne veut
pas que le message soit affiché avec printf(3), ou si un format
de message différent de celui fourni par clnt_perrno() doit être
utilisé. Note : contrairement à clnt_sperror() et clnt_spcrea-
terror(), clnt_sperrno() renvoie un pointeur sur une zone de
donnée statique, mais le résultat ne sera pas écrasé à chaque
appel.
char *clnt_sperror(CLIENT *rpch, const char *s);
Comme clnt_perror(), sauf que (comme clnt_sperrno()) il renvoie
une chaîne au lieu d'écrire sur la sortie d'erreur standard.
Danger : renvoie un pointeur vers une zone de donnée statique,
écrasée à chaque appel.
CLIENT *clntraw_create(unsigned long prognum, unsigned long versnum);
Cette routine crée un simili client RPC pour le programme dis-
tant prognum, de version versnum. Le mécanisme de transport pour
les messages est en réalité un tampon dans l'espace d'adresse du
processus, ainsi le serveur RPC doit se trouver dans le même es-
pace d'adresse. Consultez svcraw_create(). Cela permet de simu-
ler une RPC et de mesurer la surcharge des procédures RPC comme
les temps d'aller-retour sans interférence due au noyau. Cette
routine renvoie NULL si elle échoue.
CLIENT *clnttcp_create(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
int *sockp, unsigned int sendsz, unsigned int recvsz);
Cette routine crée un client RPC pour le programme distant pro-
gnum, de version versnum ; Le client utilise TCP/IP pour le
transport. Le programme distant se trouve à l'adresse Internet
*addr. Si addr->sin_port vaut zéro, alors il est rempli avec le
numéro de port sur lequel le programme distant est en écoute (on
consulte le service portmap distant pour obtenir cette informa-
tion). L'argument sockp est une socket; si c'est RPC_ANYSOCK,
alors la routine ouvre une nouvelle socket et remplit sockp.
Comme les RPC basées sur TCP utilisent des entrées-sorties avec
tampons, l'utilisateur peut spécifier la taille des tampons
d'entrée et de sortie avec les paramètres sendsz et recvsz. Des
valeurs nulles réclament l'utilisation de tampons de tailles op-
timales. Cette routine renvoie NULL si elle échoue.
CLIENT *clntudp_create(struct sockaddr_in *addr,
unsigned long prognum, unsigned long versnum,
struct timeval wait, int *sockp);
Cette routine crée un client RPC pour le programme distant pro-
gnum, de version versnum ; Le client utilise UDP/IP pour le
transport. Le programme distant se trouve à l'adresse Internet
addr. Si addr->sin_port vaut zéro, alors il est rempli avec le
numéro de port sur lequel le programme distant est en écoute (on
consulte le service portmap distant pour obtenir cette informa-
tion). 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 indiqué par wait() jusqu'à la réception
d'une réponse ou jusqu'au dépassement du temps maximal. Ce délai
total pour l'appel est spécifié par la fonction clnt_call().
Attention : comme les messages des RPC basées sur UDP ne peuvent
contenir que 8 Ko de données encodées, ce protocole ne peut pas
être utilisé pour des procédures nécessitant de gros arguments,
ou renvoyant d'énormes résultats.
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 crée un client RPC pour le programme distant pro-
gnum, de version versnum ; Le client utilise UDP/IP pour le
transport. Le programme distant se trouve à l'adresse Internet
addr. Si addr->sin_port vaut zéro, alors il est rempli avec le
numéro de port sur lequel le programme distant est en écoute (on
consulte le service portmap distant pour obtenir cette informa-
tion). 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 indiqué par wait() jusqu'à la réception
d'une réponse ou jusqu'au dépassement du temps maximal. Ce délai
total pour l'appel est spécifié par la fonction clnt_call().
Cette routine permet au programmeur de préciser la taille maxi-
male des tampons en émission et réception pour les messages RPC
basés 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 bibliothèques qui manipulent
/etc/hosts. Le numéro 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'hôte situé à l'adresse IP indiquée dans *addr. Cette rou-
tine 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
numéro de port sur lequel est en écoute le service associé au
programme numéro prognum, de version versnum, en utilisant le
protocole de transport associé avec protocol. La valeur de l'ar-
gument protocol est normalement IPPROTO_UDP ou IPPROTO_TCP. Une
valeur de retour nulle signifie qu'aucune association n'existe
ou qu'une erreur du système 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'hôte se trouvant à l'adresse IP indiquée
dans *addr de faire en notre nom un appel RPC pour une procédure
se trouvant sur cet hôte. Le paramètre *portp sera modifié pour
contenir le numéro de port du programme si la procédure réussit.
Les définitions des autres arguments sont présentées à propos de
callrpc() et de clnt_call(). Cette procédure devrait être utili-
sée 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 établit
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 ren-
voie 1 si elle réussit, et zéro sinon. Elle est automatiquement
invoquée par svc_register().
bool_t pmap_unset(unsigned long prognum, unsigned long versnum);
Une interface utilisateur vers le service portmap qui détruit
toute association entre le triplet [prognum, versnum, *] et les
ports de la machine où se trouve le service portmap. Cette rou-
tine renvoie 1 si elle réussit, et zéro sinon.
int registerrpc(unsigned long prognum, unsigned long versnum,
unsigned long procnum, char *(*procname)(char *),
xdrproc_t inproc, xdrproc_t outproc);
Enregistre la procédure procname avec le service RPC. Si une re-
quête arrive pour le programme prognum, de version versnum, et
pour la procédure procnum, procname sera appelée avec un poin-
teur vers ses paramètres d'entrée. progname doit renvoyer un
pointeur vers ses résultats statiques. inproc est utilisée pour
décoder les paramètres d'entrée alors que outproc sert à encode
les résultats. Cette routine renvoie zéro si l'enregistrement à
réussi, et -1 sinon.
Attention : les procédures enregistrées de cette manière sont
accessibles avec le protocole de transport UDP/IP. Consultez sv-
cudp_create() pour ses restrictions.
struct rpc_createerr rpc_createerr;
Une variable globale dont la valeur est définie par toute rou-
tine SM RPC de création de client qui échoue. Utilisez la rou-
tine clnt_pcreateerror() pour afficher la raison de l'échec.
void svc_destroy(SVCXPRT *xprt);
Une macro qui détruit le descripteur de transport RPC xprt. La
destruction implique normalement la libération de structures de
données privées, y compris xprt lui-même. Le comportement est
indéfini si on essaye d'utiliser xprt après avoir appelé cette
routine.
fd_set svc_fdset;
Une variable globale représentant le masque de bits des descrip-
teurs de fichier en lecture du côté serveur RPC. Elle est utili-
sable avec l'appel système select(2). Ce n'est intéressant que
si l'implémentation d'un service assure son propre traitement
d'événements asynchrones, au lieu d'appeler svc_run(). Cette va-
riable est en lecture seule (ne passez pas son adresse à se-
lect(2) !), et elle peut changer après un appel svc_getreqset()
ou une routine de création.
int svc_fds;
Similaire à svc_fdset, mais limitée à 32 descripteurs de fi-
chier. Cette interface est rendue obsolète par svc_fdset.
svc_freeargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
Une macro qui libère toutes les données allouées par le système
RPC/XDR lorsqu'il décode les arguments d'une procédure de ser-
vice avec svc_getargs(). Cette routine renvoie 1 si les argu-
ments ont été correctement libérés, et zéro sinon.
svc_getargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);
Une macro qui décode les arguments d'une requête RPC associée
avec le descripteur de transport RPC xprt. L'argument in est
l'adresse où les arguments seront stockés, inproc est la routine
XDR pour décoder les arguments. Cette routine renvoie 1 si le
décodage réussit, et zéro sinon.
struct sockaddr_in *svc_getcaller(SVCXPRT *xprt);
La manière correcte d'obtenir l'adresse réseau de l'appelant
d'une procédure associée avec le descripteur de transport RPC
xprt.
void svc_getreqset(fd_set *rdfds);
Cette routine n'est intéressante que si l'implémentation d'un
service n'appelle pas svc_run(), mais emploie à la place un
traitement personnalisé des événements asynchrones. On l'invoque
lorsque l'appel système select(2) a déterminé qu'une requête RPC
est arrivée sur l'une des sockets RPC. rdfds est le masque de
bits des descripteurs de fichier en résultant. La routine re-
vient lorsque toutes les sockets associées avec les valeurs de
rdfds ont été servies.
void svc_getreq(int rdfds);
Similaire à svc_getreqset(), mais limitée à 32 descripteurs de
fichier. Cette interface est rendue obsolète par svc_getreq-
set().
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 procédure de distribution
dispatch. Si protocol vaut zéro, le service n'est pas enregistré
avec le service portmap. Si protocol est non-nul, alors l'asso-
ciation entre le triplet [prognum,versnum,protocol] et
xprt->xp_port est établie par l'intermédiaire du service portmap
local (en général protocol vaut zéro, IPPROTO_UDP ou IP-
PROTO_TCP). La procédure dispatch a la forme suivante
dispatch(struct svc_req *request, SVCXPRT *xprt);
La routine svc_register() renvoie 1 si elle réussit et 0 sinon.
void svc_run(void);
Cette routine ne revient jamais. Elle attend l'arrivée de re-
quêtes RPC et appelle les procédures de service appropriées en
utilisant svc_getreq(). Cette procédure est la plupart du temps
en attente autour d'un appel système select(2).
bool_t svc_sendreply(SVCXPRT *xprt, xdrproc_t outproc, char *out);
Appelée par une routine de distribution de services RPC pour en-
voyer le résultat d'un appel de procédure distante. L'argument
xprt est le descripteur de transport associé à la requête, out-
proc est la routine XDR utilisée pour encoder les résultats, et
out est l'adresse des résultats. Cette routine renvoie 1 si elle
réussit, 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 numéro de port.
void svcerr_auth(SVCXPRT *xprt, enum auth_stat why);
Appelée par une routine de distribution de service qui refuse
d'exécuter un appel de procédure distante à cause d'une erreur
d'authentification.
void svcerr_decode(SVCXPRT *xprt);
Appelée par une routine de distribution de service qui n'arrive
pas à décoder ses arguments. Consultez aussi svc_getargs().
void svcerr_noproc(SVCXPRT *xprt);
Appelée par une routine de distribution de service qui n'implé-
mente pas le numéro de procédure que l'appelant réclame.
void svcerr_noprog(SVCXPRT *xprt);
Appelée quand le programme désiré n'est pas enregistré dans le
service RPC. L'implémentation d'un service n'a normalement pas
besoin de cette routine.
void svcerr_progvers(SVCXPRT *xprt, unsigned long low_vers,
unsigned long high_vers);
Appelée quand le numéro de version du programme désiré n'est pas
enregistré dans le service RPC. L'implémentation d'un service
n'a normalement pas besoin de cette routine.
void svcerr_systemerr(SVCXPRT *xprt);
Appelée par une routine de distribution de service lorsqu'elle
détecte une erreur système 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);
Appelée par une routine de distribution de service qui refuse
d'exécuter un appel de procédure distante à cause d'un manque de
paramètres d'authentification. La routine appelle sv-
cerr_auth(xprt, AUTH_TOOWEAK).
SVCXPRT *svcfd_create(int fd, unsigned int sendsize,
unsigned int recvsize);
Créer un service au-dessus de n'importe quel descripteur ouvert.
Typiquement ce descripteur de fichier est un socket connecté
pour un protocole de flux comme TCP. sendsize et recvsize in-
diquent les tailles pour les tampons d'émission et de réception.
Si ces tailles valent zéro, une valeur optimale est choisie.
SVCXPRT *svcraw_create(void);
Cette routine crée un simili transport de service RPC vers le-
quel il renvoie un pointeur. Le transport est en fait un tampon
au sein de l'espace d'adressage du processus. Le client RPC cor-
respondant doit donc résider dans le même espace d'adresse.
Consultez clntraw_create(). Cela permet de simuler une RPC et de
mesurer la surcharge des procédures RPC comme les temps d'al-
ler-retour sans interférence due au noyau. Cette routine renvoie
NULL si elle échoue.
SVCXPRT *svctcp_create(int sock, unsigned int send_buf_size,
unsigned int recv_buf_size);
Cette routine crée un transport de service RPC basé sur TCP/IP
sur lequel elle renvoie un pointeur. Il est associé avec la so-
cket sock, qui peut être RPC_ANYSOCK, auquel cas une nouvelle
socket est créée. Si la socket n'est pas associée à un port TCP
local, cette routine l'associe à un port quelconque. Après réus-
site, xprt->xp_sock est le descripteur de la socket de trans-
port, et xprt->xp_port est le numéro de port. Cette routine ren-
voie NULL si elle échoue. Comme les RPC basée sur TCP utilisent
des entrées-sorties avec tampon, les utilisateurs peuvent défi-
nir la taille des tampons. Une taille nulle implique l'alloca-
tion automatique de tampons de tailles optimales.
SVCXPRT *svcudp_bufcreate(int sock, unsigned int sendsize,
unsigned int recosize);
Cette routine crée un transport de service RPC basé sur UDP/IP
et renvoie un pointeur dessus. Le transport est associé avec la
socket sock, qui peut être RPC_ANYSOCK, auquel cas une nouvelle
socket est créée. Si la socket n'est pas associée à un port UDP
local, cette routine l'associe à un port quelconque. Après réus-
site, xprt->xp_sock est le descripteur de transport, et
xprt->xp_port est le numéro de port. Cette routine renvoie NULL
si elle échoue.
Cette routine permet au programmeur de préciser la taille maxi-
male des tampons en émission et réception pour les messages RPC
basés sur UDP.
SVCXPRT *svcudp_create(int sock);
Cet appel est équivalent à svcudp_bufcreate(sock,SZ,SZ) avec une
taille SZ par défaut.
bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);
Utilisée pour encoder les messages de réponse RPC. Cette routine
est utile pour les programmeurs qui désirent engendrer des mes-
sages de style RPC sans employer le service RPC complet.
bool_t xdr_authunix_parms(XDR *xdrs, struct authunix_parms *aupp);
Utilisée pour décrire les identités UNIX. Cette routine est
utile pour les programmeurs qui veulent engendrer ces identités
sans utiliser le système RPC d'authentification.
void xdr_callhdr(XDR *xdrs, struct rpc_msg *chdr);
Utilisée pour créer les en-têtes de message RPC. Cette routine
est utile pour les programmeurs qui désirent engendrer des mes-
sages de style RPC sans employer le service RPC complet.
bool_t xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);
Utilisée pour créer les messages d'appel RPC. Cette routine est
utile pour les programmeurs qui désirent engendrer des messages
de style RPC sans employer le service RPC complet.
bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
Utilisée pour créer les informations d'authentification RPC.
Cette routine est utile pour les programmeurs qui désirent en-
gendrer des messages de style RPC sans employer le service RPC
complet.
bool_t xdr_pmap(XDR *xdrs, struct pmap *regs);
Utilisée pour créer les paramètres des divers procédures port-
map. Cette routine est utile pour les programmeurs qui désirent
créer ces paramètres sans utiliser l'interface pmap.
bool_t xdr_pmaplist(XDR *xdrs, struct pmaplist **rp);
Utilisée pour créer la liste des associations des ports. Cette
routine est utile pour les programmeurs qui désirent créer ces
paramètres sans utiliser l'interface pmap.
bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);
Utilisée pour créer les messages de rejet RPC. Cette routine est
utile pour les programmeurs qui désirent engendrer des messages
de style RPC sans employer le service RPC complet.
bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);
Utilisée pour créer les messages de réponse RPC. Cette routine
est utile pour les programmeurs qui désirent engendrer des mes-
sages de style RPC sans employer le service RPC complet.
void xprt_register(SVCXPRT *xprt);
Après la création d'un descripteur RPC de transport, il doit
être enregistré dans le service RPC. Cette routine modifie la
variable globale svc_fds. L'implémentation d'un service ne né-
cessite pas cette routine habituellement.
void xprt_unregister(SVCXPRT *xprt);
Avant qu'un descripteur RPC de transport soit détruit, il doit
se désinscrire du service RPC. Cette routine modifie la variable
globale svc_fds. L'implémentation d'un service ne nécessite pas
cette routine habituellement.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter
attributes(7).
┌─────────────────────────────────────┬──────────────────────┬─────────┐
│Interface │ Attribut │ Valeur │
├─────────────────────────────────────┼──────────────────────┼─────────┤
│auth_destroy(), authnone_create(), │ Sécurité des threads │ MT-Safe │
│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 Micro-
systems, Inc., USC-ISI.
TRADUCTION
La traduction française de cette page de manuel a été créée par Chris-
tophe Blaess <https://www.blaess.fr/christophe/>, Stéphan Rafin <ste-
phan.rafin@laposte.net>, Thierry Vignaud <tvignaud@mandriva.com>, Fran-
çois Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Gué-
rard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-luc.cou-
lon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux
<thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centra-
liens.net>, Florentin Duneau <fduneau@gmail.com>, Simon Paillard <si-
mon.paillard@resel.enst-bretagne.fr>, Denis Barbier <barbier@de-
bian.org>, David Prévot <david@tilapin.org> et Jean-Pierre Giraud
<jean-pierregiraud@neuf.fr>
Cette traduction est une documentation libre ; veuillez vous reporter à
la GNU General Public License version 3
⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les conditions
de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel,
veuillez envoyer un message à ⟨debian-l10n-french@lists.debian.org⟩.
Pages du manuel de Linux 6.03 5 février 2023 rpc(3)
Generated by dwww version 1.15 on Sat Jun 29 00:26:23 CEST 2024.