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. 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 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, 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
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, consultez
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,
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 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, 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'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(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 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 // 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'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(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 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, 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'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, 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 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. Consultez 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,
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 utilisé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 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.
Consultez svcudp_create() pour ses restrictions.
struct rpc_createerr rpc_createerr;
- Une variable globale dont la valeur est définie par toute routine
SM 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 assure son
propre traitement d'événements asynchrones, au lieu
d'appeler svc_run(). 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 de fichier. 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 de fichier. Cette interface est rendue
obsolète 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 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. 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
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 ce descripteur de fichier est un socket connecté pour
un protocole de flux 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. Consultez
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ée sur TCP
utilisent des entrées-sorties avec tampon, les utilisateurs peuvent
définir 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.
- 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.
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 en-tê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.