Provided by: manpages-fr-dev_3.32d0.2p4-1_all bug

NOM

       rpc - Bibliothèque de fonctions pour les appels de procédures à distance

SYNOPSIS ET DESCRIPTION

       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, 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,  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);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(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 // fixer 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. 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,
                       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. Consultez svcudp_create() pour ses restrictions.

       struct rpc_createerr rpc_createerr;

              Une variable globale dont la valeur est fixée 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 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. 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);

              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. 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 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.

              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 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.

COLOPHON

       Cette  page  fait partie de la publication 3.32 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis    2010,    cette   traduction   est   maintenue   à   l'aide   de   l'outil   po4a
       <URL:http://po4a.alioth.debian.org/> par l'équipe de traduction  francophone  au  sein  du
       projet perkamon <URL:http://perkamon.alioth.debian.org/>.

       Christophe   Blaess   <URL:http://www.blaess.fr/christophe/>   (1996-2003),  Alain  Portal
       <URL:http://manpagesfr.free.fr/> (2003-2006). Nicolas François et l'équipe francophone  de
       traduction de Debian (2006-2009).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>  ou  par  un  rapport  de  bogue   sur   le   paquet
       manpages-fr.

       Vous  pouvez  toujours  avoir  accès  à la version anglaise de ce document en utilisant la
       commande « man -L C <section> <page_de_man> ».

                                         17 juillet 2008                                   RPC(3)