RPC
Section : Manuel du programmeur Linux (
3)
Mise à jour de la version anglaise : 30 décembre 2007
Index
Menu principal
NOM
rpc - Bibliothèque de fonctions pour les appels de procédures à distance
SYNOPSIS ET DESCRIPTION
Ndt : RPC = Remote Procedure Call.
Ces routines permettent à des programmes C de faire des appels
de procé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 serveur.
À la réception du paquet, le serveur appelle une routine de distribution
pour exécuter le service demandé, et renvoyer une réponse.
Finalement, l'appel de procédure revient au client.
Pour utiliser ces routines, incluez le fichier d'entête
<rpc/rpc.h>.
Les prototypes plus loin utilisent 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);
Voir les fichiers d'entête pour la déclaration 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
transmettant avec chaque appel de procédure une information
d'authentification nulle.
C'est le comportement par défaut pour les RPC.
AUTH *authunix_create(char *host, int uid, int gid,
int len, int *aup_gids);
-
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, 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
outproc
à décoder les résultats de la procédure.
Cette routine renvoie zéro si elle réussit, ou la valeur de
enum clnt_stat
transposé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, voir
clntudp_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,
char *in, char *out,
xdrproc_t inproc, xdrproc_t outproc,
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 envoyé le résultat.
Si
eachresult()
renvoie zéro,
clnt_broadcast()
attend d'autres réponses.
Sinon elle revient avec le code de retour 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, xdrproc_t outproc,
char *in, 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'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
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 implique généralement la libération
de structures de données privé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(char *host, unsigned long prog,
unsigned long vers, 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 fixez le délai avec
clnt_control(),
le dernier 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 // fixer 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'argument
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(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 inséré.
À utiliser lorsque les appels
clnt_create(),
clntraw_create(),
clnttcp_create()
ou
clntudp_create()
échouent.
void clnt_perrno(enum clnt_stat stat);
-
Affiche un message sur la sortie d'erreur standard,
correspondant à la condition indiquée par
stat.
À utiliser après
callrpc().
clnt_perror(CLIENT *clnt, 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(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'envoyer un message sur la sortie d'erreur standard
indiquant pourquoi 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_spcreaterror(),
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, 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 distant
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 espace d'adresse.
Voir
svcraw_create().
Cela permet de simuler 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
prognum,
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 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 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 optimales.
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
prognum,
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 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 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
prognum,
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 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 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 maximale
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 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 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'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 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, char *in, char *out,
xdrproc_t inproc, xdrproc_t outproc,
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 utilisée
pour faire un « ping » et rien d'autre.
Voir 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 é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 renvoie 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 routine 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 requête arrive pour le programme
prognum,
de version
versnum,
et pour la procédure
procnum,
procname
sera appelée avec un pointeur 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.
Voir
svcudp_create()
pour ses restrictions.
struct rpc_createerr rpc_createerr;
-
Une variable globale dont la valeur est fixée par toute routine RPC
de création de client qui échoue.
Utilisez la routine
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 descripteurs de fichier en lecture du côté serveur RPC.
Elle est utilisable avec l'appel système
select(2).
Ce n'est intéressant que si l'implémentation d'un service n'appelle pas
svc_run(),
mais assure son propre traitement d'événements asynchrones.
Cette variable est en lecture seule (ne passez pas son adresse à
select(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.
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 service avec
svc_getargs().
Cette routine renvoie 1 si les arguments 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 revient 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.
Cette interface est rendue obsolète 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 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'association 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
IPPROTO_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 requê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 envoyer le résultat d'un appel de procédure distante.
L'argument
xprt
est le descripteur de transport associé à la requête,
outproc
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.
Voir 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);
-
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
svcerr_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 ces descripteurs sont des sockets pour un protocole connecté
comme TCP.
sendsize
et
recvsize
indiquent 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 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 résider dans le même espace d'adresse.
Voir
clntraw_create().
Cela permet de simuler 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.
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 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 TCP
local, cette routine l'associe à un port quelconque.
Après réussite,
xprt->xp_sock
est le descripteur de la socket de transport, et
xprt->xp_port
est le numéro de port.
Cette routine renvoie NULL si elle échoue.
Comme les RPC basées sur TCP
utilisent des entrées-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 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éussite,
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.
-
Elle permet à l'utilisateur de préciser la taille maximale d'un paquet
en émission ou en 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 messages 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 entêtes de message 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_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 engendrer 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
portmap.
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 messages 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.
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
Ce document est une traduction réalisée par Christophe Blaess
<http://www.blaess.fr/christophe/> le 31 août 2000
et révisée le 17 juillet 2008.
L'équipe de traduction a fait le maximum pour réaliser une adaptation
française de qualité. La version anglaise la plus à jour de ce document est
toujours consultable via la commande : « LANG=C man 3 rpc ».
N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute
erreur dans cette page de manuel.
Index
- NOM
-
- SYNOPSIS ET DESCRIPTION
-
- VOIR AUSSI
-
- TRADUCTION
-
Dernière mise à jour : 17 juillet 2008