Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       rpc  -  Bibliotheque  de  fonctions  pour  les  appels  de procedures a
       distance

SYNOPSIS ET DESCRIPTION

       Ces routines permettent a des programmes  C  de  faire  des  appels  de
       procedures  vers  d'autres  machines  a  travers le reseau. D'abord, le
       client invoque une procedure pour envoyer un paquet de donnees vers  le
       serveur.  A  la  reception du paquet, le serveur appelle une routine de
       distribution pour executer le service demande, et renvoyer une reponse.
       Enfin, l'appel de procedure revient au client.

       Pour  utiliser  ces  routines,  il  faut  inclure le fichier d'en-tetes
       <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-tete pour les declarations des types  AUTH,
       CLIENT, SVCXPRT et XDR.

       void auth_destroy(AUTH *auth);

              Cette macro detruit les informations d'authentification associee
              avec auth. La destruction implique generalement la desallocation
              de  donnees  privees.  Le comportement est indefini si on essaye
              d'utiliser auth apres avoir invoque auth_destroy().

       AUTH *authnone_create(void);

              Cree  et   renvoie   un   descripteur   d'authentification   RPC
              transmettant  avec  chaque  appel  de  procedure une information
              d'authentification nulle. C'est le comportement par defaut  pour
              les RPC.

       AUTH *authunix_create(char *host, int uid, int gid,
                             int len, int *aup_gids);

              Cree  et  renvoie  un  descripteur  d'authentification RPC Unix,
              contenant des informations d'identification. L'argument host est
              le  nom  de la machine sur laquelle l'information est creee. uid
              est l'identification de l'utilisateur. gid est  l'identification
              du  groupe de l'utilisateur. len et aup_gids concernent la table
              des groupes supplementaires auxquels  l'utilisateur  appartient.
              On peut facilement se faire passer pour quelqu'un d'autre.

       AUTH *authunix_create_default(void);

              Appelle authunix_create() avec les arguments appropries.

       int callrpc(char *host, unsigned long prognum,
                   unsigned long versnum, unsigned long procnum,
                   xdrproc_t inproc, char *in,
                   xdrproc_t outproc, char *out);

              Appelle  la  procedure  distante associee aux arguments prognum,
              versnum, et procnum sur la  machine,  host.  L'argument  in  est
              l'adresse  du  ou  des  arguments  d'entree de la procedure, out
              celle de l'emplacement ou stocker le ou  les  resultats,  inproc
              sert  a  encoder  les  parametres  d'entree  de la procedure, et
              outproc a decoder les resultats de la procedure.  Cette  routine
              renvoie  zero  si  elle  reussit, ou la valeur de enum clnt_stat
              transposee en  un  nombre  entier  si  elle  echoue  La  routine
              clnt_perrno() permet de traduire les codes d'echec en messages.

              Attention :  l'appel d'une procedure distante avec cette routine
              emploie  le  protocole  UDP/IP  pour  le  transport,   consultez
              clntudp_create()  pour certaines restrictions. Vous n'avez aucun
              controle sur le delai maximal  ou  sur  l'authentification  avec
              cette routine.

       enum clnt_stat clnt_broadcast(unsigned long prognum,
                            unsigned long versnum, unsigned long procnum,
                            xdrproc_t inproc, char *in,
                            xdrproc_t outproc, char *out,
                            resultproc_t eachresult);

              Comme  callrpc(),  sauf  que  le message d'appel est diffuse sur
              tous les reseaux connectes. A chaque  reception  d'une  reponse,
              cette  routine  appelle  la fonction eachresult(), dont la forme
              est :

                  eachresult(char *out, struct sockaddr_in *addr);

              ou out est du meme type que le  out  passe  a  clnt_broadcast(),
              avec  la  difference  que la sortie de la procedure distante est
              decodee ici. addr pointe vers l'adresse  de  la  machine  qui  a
              envoye    le    resultat.    Si   eachresult()   renvoie   zero,
              clnt_broadcast() attend d'autres reponses.  Sinon  elle  revient
              avec le code de retour approprie.

              Attention :  les  sockets  broadcast  sont  limitees  en  ce qui
              concerne la taille maximale des donnees. Pour l'Ethernet,  cette
              valeur (MTU) vaut 1500 octets.

       enum clnt_stat clnt_call(CLIENT *clnt, unsigned long procnum,
                           xdrproc_t inproc, char *in,
                           xdrproc_t outproc, char *out,
                           struct timeval tout);

              Une  macro  qui  appelle  la procedure distante procnum associee
              avec le descripteur de client clnt, qui est obtenu grace  a  une
              routine   de   creation   de  client  RPC  comme  clnt_create().
              L'argument in est l'adresse du ou des arguments d'entree  de  la
              procedure,  out  celle  de  l'emplacement  ou  stocker le ou les
              resultats, inproc sert a encoder les parametres d'entree  de  la
              procedure,  et  outproc a decoder les resultats de la procedure.
              tout est le delai maximal accorde  pour  la  realisation  de  la
              procedure.

       clnt_destroy(CLIENT *clnt);

              Une  macro  qui  detruit  le  descripteur  de  client RPC ce qui
              implique generalement la liberation  de  structures  de  donnees
              privees,  y  compris clnt lui meme. Le comportement est indefini
              si on tente d'utiliser clnt apres avoir  appele  clnt_destroy().
              Si  la  bibliotheque  RPC  avait ouvert la socket associee, elle
              sera egalement fermee. Sinon, la socket reste ouverte.

       CLIENT *clnt_create(char *host, unsigned long prog,
                           unsigned long vers, char *proto);

              Routine generique de creation de client. host identifie  le  nom
              de l'hote distant ou se trouve le serveur. proto indique le type
              de protocole de transport a employer. Les  valeurs  actuellement
              supportees  pour  ce  champ  sont  << udp >>  et  << tcp >>. Des
              valeurs par  defaut  sont  configurees  pour  les  delais,  mais
              peuvent etre modifiees a l'aide de clnt_control().

              Attention :  l'utilisation du protocole UDP a des inconvenients.
              Comme les messages RPC bases sur UDP  ne  peuvent  contenir  que
              8 Ko  de donnees encodees, ce protocole ne peut pas etre utilise
              pour des procedures necessitant de gros arguments, ou  renvoyant
              d'enormes resultats.

       bool_t clnt_control(CLIENT *cl, int req, char *info);

              Une  macro  employee pour modifier ou recuperer des informations
              diverses a  propos  d'un  objet  client.  req  indique  le  type
              d'operation, et info est un pointeur sur l'information. Pour UDP
              comme pour TCP, les valeurs autorisees pour req et le  type  des
              arguments sont :

                  CLSET_TIMEOUT  struct timeval // fixer le delai total
                  CLGET_TIMEOUT  struct timeval // lire le delai total

              Note :  Si  vous  fixez le delai avec clnt_control(), le dernier
              argument de clnt_call() sera ignore lors des appels ulterieurs.

                  CLGET_SERVER_ADDR  struct sockaddr_in  // lire l'adresse du serveur

              Les operations suivantes sont  valides  pour  le  protocole  UDP
              seulement :

                  CLSET_RETRY_TIMEOUT  struct timeval // fixer le delai de repetition
                  CLGET_RETRY_TIMEOUT  struct timeval // lire le delai de repetition

              Le delai de repetition est le temps pendant lequel les "RPC UDP"
              attendent une reponse du serveur avant retransmettre la requete.

       clnt_freeres(CLIENT * clnt, xdrproc_t outproc, char *out);

              Une macro qui libere toutes les donnees allouees par le  systeme
              RPC/XDR   lorsqu'il  a  decode  les  resultats  d'un  appel  RPC
              L'argument out est l'adresse des resultats, et  outproc  est  la
              routine  XDR decodant les resultats. Cette fonction renvoie 1 si
              les resultats ont ete correctement liberes, et zero sinon.

       void clnt_geterr(CLIENT *clnt, struct rpc_err *errp);

              Une macro qui copie la structure d'erreur depuis le  descripteur
              de client vers la structure se trouvant a l'adresse errp.

       void clnt_pcreateerror(char *s);

              Affiche  un  message  sur la sortie d'erreur standard, indiquant
              pourquoi un descripteur de client RPC ne peut pas etre cree.  Ce
              message  est  prefixe  avec  la  chaine  s et un deux-points est
              insere.   A   utiliser   lorsque   les   appels   clnt_create(),
              clntraw_create(), clnttcp_create() ou clntudp_create() echouent.

       void clnt_perrno(enum clnt_stat stat);

              Affiche   un   message   sur   la   sortie   d'erreur  standard,
              correspondant a la condition indiquee par stat. A utiliser apres
              callrpc().

       clnt_perror(CLIENT *clnt, char *s);

              Affiche  un  message  sur  la sortie d'erreur standard indiquant
              pourquoi un appel RPC a echoue. clnt est le descripteur  utilise
              pour  l'appel.  Ce  message  est  prefixe avec la chaine s et un
              deux-points est insere. A utiliser apres clnt_call().

       char *clnt_spcreateerror(char *s);

              Comme clnt_pcreateerror(), sauf qu'il renvoie une chaine au lieu
              d'ecrire sur la sortie d'erreur standard.

              Danger :  renvoie  un pointeur vers une zone de donnee statique,
              ecrasee a chaque appel.

       char *clnt_sperrno(enum clnt_stat stat);

              Emploie les meme  arguments  que  clnt_perrno(),  mais  au  lieu
              d'envoyer  un  message sur la sortie d'erreur standard indiquant
              pourquoi un appel RPC a echoue,  renvoie  un  pointeur  sur  une
              chaine  contenant  le  message.  La  chaine  se  termine  par un
              NEWLINE.

              clnt_sperrno() est utilisee a la place de  clnt_perrno()  si  le
              programme  n'a  pas  de sortie d'erreur standard (un serveur par
              exemple n'en a generalement pas), ou si le programmeur  ne  veut
              pas  que le message soit affiche avec printf(3), ou si un format
              de message different de celui fourni par clnt_perrno() doit etre
              utilise.    Note :    contrairement    a    clnt_sperror()    et
              clnt_spcreaterror(), clnt_sperrno() renvoie un pointeur sur  une
              zone  de  donnee statique, mais le resultat ne sera pas ecrase a
              chaque appel.

       char *clnt_sperror(CLIENT *rpch, char *s);

              Comme clnt_perror(), sauf que (comme clnt_sperrno()) il  renvoie
              une chaine au lieu d'ecrire sur la sortie d'erreur standard.

              Danger :  renvoie  un pointeur vers une zone de donnee statique,
              ecrasee a chaque appel.

       CLIENT *clntraw_create(unsigned long prognum, unsigned long versnum);

              Cette routine cree  un  simili  client  RPC  pour  le  programme
              distant  prognum,  de version versnum. Le mecanisme de transport
              pour les  messages  est  en  realite  un  tampon  dans  l'espace
              d'adresse  du  processus,  ainsi  le serveur RPC doit se trouver
              dans le meme espace d'adresse. Consultez  svcraw_create().  Cela
              permet  de  simuler  une  RPC  et  de  mesurer  la surcharge des
              procedures RPC comme les temps d'aller-retour sans  interference
              due au noyau. Cette routine renvoie NULL si elle echoue.

       CLIENT *clnttcp_create(struct sockaddr_in *addr,
                       unsigned long prognum, unsigned long versnum,
                       int *sockp, unsigned int sendsz, unsigned int recvsz);

              Cette  routine  cree  un  client  RPC  pour le programme distant
              prognum, de version versnum ; Le client utilise TCP/IP  pour  le
              transport.  Le  programme distant se trouve a l'adresse Internet
              *addr. Si addr->sin_port vaut zero, alors il est rempli avec  le
              numero de port sur lequel le programme distant est en ecoute (on
              consulte  le  service  portmap  distant   pour   obtenir   cette
              information).   L'argument   sockp  est  une  socket;  si  c'est
              RPC_ANYSOCK, alors la  routine  ouvre  une  nouvelle  socket  et
              remplit  sockp.  Comme  les  RPC  basees  sur  TCP utilisent des
              entrees-sorties avec tampons, l'utilisateur  peut  specifier  la
              taille  des  tampons  d'entree  et de sortie avec les parametres
              sendsz et recvsz. Des valeurs nulles reclament l'utilisation  de
              tampons de tailles optimales. Cette routine renvoie NULL si elle
              echoue.

       CLIENT *clntudp_create(struct sockaddr_in *addr,
                       unsigned long prognum, unsigned long versnum,
                       struct timeval wait, int *sockp);

              Cette routine cree un  client  RPC  pour  le  programme  distant
              prognum,  de  version versnum ; Le client utilise UDP/IP pour le
              transport. Le programme distant se trouve a  l'adresse  Internet
              addr.  Si  addr->sin_port vaut zero, alors il est rempli avec le
              numero de port sur lequel le programme distant est en ecoute (on
              consulte   le   service   portmap  distant  pour  obtenir  cette
              information).  L'argument  sockp  est  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 indique par wait() jusqu'a
              la reception d'une reponse  ou  jusqu'au  depassement  du  temps
              maximal.  Ce  delai  total  pour  l'appel  est  specifie  par la
              fonction clnt_call().

              Attention : comme les messages des RPC basees sur UDP ne peuvent
              contenir  que 8 Ko de donnees encodees, ce protocole ne peut pas
              etre utilise pour des procedures necessitant de gros  arguments,
              ou renvoyant d'enormes resultats.

       CLIENT *clntudp_bufcreate(struct sockaddr_in *addr,
                   unsigned long prognum, unsigned long versnum,
                   struct timeval wait, int *sockp,
                   unsigned int sendsize, unsigned int recosize);

              Cette  routine  cree  un  client  RPC  pour le programme distant
              prognum, de version versnum ; Le client utilise UDP/IP  pour  le
              transport.  Le  programme distant se trouve a l'adresse Internet
              addr. Si addr->sin_port vaut zero, alors il est rempli  avec  le
              numero de port sur lequel le programme distant est en ecoute (on
              consulte  le  service  portmap  distant   pour   obtenir   cette
              information).   L'argument   sockp  est  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 indique par  wait()  jusqu'a
              la  reception  d'une  reponse  ou  jusqu'au depassement du temps
              maximal. Ce  delai  total  pour  l'appel  est  specifie  par  la
              fonction clnt_call().

              Cette  routine  permet  au  programmeur  de  preciser  la taille
              maximale des tampons en emission et reception pour les  messages
              RPC bases sur UDP.

       void get_myaddress(struct sockaddr_in *addr);

              Fournit l'adresse IP de la machine dans la structure *addr, sans
              consulter  les  routines   de   bibliotheques   qui   manipulent
              /etc/hosts.   Le   numero  de  port  est  toujours  rempli  avec
              htons(PMAPPORT).

       struct pmaplist *pmap_getmaps(struct sockaddr_in *addr);

              Une interface utilisateur pour le service portmap renvoyant  une
              liste  des  associations  en cours entre programmes RPC et ports
              sur l'hote situe a  l'adresse  IP  indiquee  dans  *addr.  Cette
              routine peut renvoyer NULL. La commande << rpcinfo -p >> utilise
              cette fonction

       unsigned short pmap_getport(struct sockaddr_in *addr,
                           unsigned long prognum, unsigned long versnum,
                           unsigned int protocol);

              Une interface utilisateur pour le service portmap qui renvoie le
              numero  de  port  sur lequel est en ecoute le service associe au
              programme numero prognum, de version versnum,  en  utilisant  le
              protocole  de  transport  associe  avec  protocol.  La valeur de
              l'argument protocol est normalement IPPROTO_UDP ou  IPPROTO_TCP.
              Une  valeur  de  retour  nulle  signifie  qu'aucune  association
              n'existe ou qu'une erreur  du  systeme  RPC  s'est  produite  en
              tentant de contacter le service portmap distant. Dans ce cas, la
              variable globale rpc_createerr contient le code RPC de l'erreur.

       enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr,
                           unsigned long prognum, unsigned long versnum,
                           unsigned long procnum,
                           xdrproc_t inproc, char *in,
                           xdrproc_t outproc, char *out,
                           struct timeval tout, unsigned long *portp);

              Une interface utilisateur pour le service portmap qui demande au
              programme portmap sur l'hote se trouvant a l'adresse IP indiquee
              dans *addr de faire en notre nom un appel RPC pour une procedure
              se  trouvant sur cet hote. Le parametre *portp sera modifie pour
              contenir le numero de port du programme si la procedure reussit.
              Les definitions des autres arguments sont presentees a propos de
              callrpc()  et  de  clnt_call().  Cette  procedure  devrait  etre
              utilisee  pour  faire  un  << ping >> et rien d'autre. Consultez
              aussi clnt_broadcast().

       bool_t pmap_set(unsigned long prognum, unsigned long versnum,
                       unsigned int protocol, unsigned short port);

              Une interface utilisateur pour le service  portmap  qui  etablit
              une association entre le triplet [prognum, versnum, protocol] et
              le port sur la machine du service portmap La valeur du  protocol
              est   normalement  IPPROTO_UDP  ou  IPPROTO_TCP.  Cette  routine
              renvoie  1  si  elle  reussit,   et   zero   sinon.   Elle   est
              automatiquement invoquee par svc_register().

       bool_t pmap_unset(unsigned long prognum, unsigned long versnum);

              Une  interface  utilisateur  vers le service portmap qui detruit
              toute association entre le triplet [prognum, versnum, *] et  les
              ports  de  la  machine  ou  se  trouve le service portmap. Cette
              routine renvoie 1 si elle reussit, et zero sinon.

       int registerrpc(unsigned long prognum, unsigned long versnum,
                       unsigned long procnum, char *(*procname)(char *),
                       xdrproc_t inproc, xdrproc_t outproc);

              Enregistre la procedure procname avec le  service  RPC.  Si  une
              requete arrive pour le programme prognum, de version versnum, et
              pour  la  procedure  procnum,  procname  sera  appelee  avec  un
              pointeur vers ses parametres d'entree. progname doit renvoyer un
              pointeur vers ses resultats statiques. inproc est utilisee  pour
              decoder  les parametres d'entree alors que outproc sert a encode
              les resultats. Cette routine renvoie zero si l'enregistrement  a
              reussi, et -1 sinon.

              Attention :  les  procedures  enregistrees de cette maniere sont
              accessibles avec le protocole  de  transport  UDP/IP.  Consultez
              svcudp_create() pour ses restrictions.

       struct rpc_createerr rpc_createerr;

              Une  variable globale dont la valeur est fixee par toute routine
              SM RPC de creation de client qui  echoue.  Utilisez  la  routine
              clnt_pcreateerror() pour afficher la raison de l'echec.

       void svc_destroy(SVCXPRT *xprt);

              Une  macro  qui detruit le descripteur de transport RPC xprt. La
              destruction implique normalement la liberation de structures  de
              donnees  privees,  y  compris xprt lui-meme. Le comportement est
              indefini si on essaye d'utiliser xprt apres avoir  appele  cette
              routine.

       fd_set svc_fdset;

              Une   variable  globale  representant  le  masque  de  bits  des
              descripteurs de fichier en lecture du cote serveur RPC. Elle est
              utilisable  avec l'appel systeme select(2). Ce n'est interessant
              que si l'implementation d'un service  n'appelle  pas  svc_run(),
              mais  assure  son  propre  traitement  d'evenements asynchrones.
              Cette variable est en lecture seule (ne passez pas son adresse a
              select(2) !),    et   elle   peut   changer   apres   un   appel
              svc_getreqset() ou une routine de creation.

       int svc_fds;

              Similaire a svc_fdset, mais limitee  a  32  descripteurs.  Cette
              interface est rendue obsolete par svc_fdset.

       svc_freeargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);

              Une  macro qui libere toutes les donnees allouees par le systeme
              RPC/XDR  lorsqu'il  decode  les  arguments  d'une  procedure  de
              service  avec  svc_getargs().  Cette  routine  renvoie  1 si les
              arguments ont ete correctement liberes, et zero sinon.

       svc_getargs(SVCXPRT *xprt, xdrproc_t inproc, char *in);

              Une macro qui decode les arguments d'une  requete  RPC  associee
              avec  le  descripteur  de  transport RPC xprt. L'argument in est
              l'adresse ou les arguments seront stockes, inproc est la routine
              XDR  pour  decoder  les arguments. Cette routine renvoie 1 si le
              decodage reussit, et zero sinon.

       struct sockaddr_in *svc_getcaller(SVCXPRT *xprt);

              La maniere correcte d'obtenir  l'adresse  reseau  de  l'appelant
              d'une  procedure  associee  avec le descripteur de transport RPC
              xprt.

       void svc_getreqset(fd_set *rdfds);

              Cette routine n'est interessante que  si  l'implementation  d'un
              service  n'appelle  pas  svc_run(),  mais  emploie a la place un
              traitement personnalise des evenements asynchrones. On l'invoque
              lorsque l'appel systeme select(2) a determine qu'une requete RPC
              est arrivee sur l'une des sockets RPC. rdfds est  le  masque  de
              bits  des  descripteurs  de  fichier  en  resultant.  La routine
              revient lorsque toutes les sockets associees avec les valeurs de
              rdfds ont ete servies.

       void svc_getreq(int rdfds);

              Similaire  a  svc_getreqset(),  mais  limitee a 32 descripteurs.
              Cette interface est rendue obsolete 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  procedure  de  distribution
              dispatch. Si protocol vaut zero, le service n'est pas enregistre
              avec  le  service  portmap.  Si  protocol  est  non-nul,   alors
              l'association  entre  le  triplet  [prognum,versnum,protocol] et
              xprt->xp_port est etablie par l'intermediaire du service portmap
              local   (en   general   protocol   vaut   zero,  IPPROTO_UDP  ou
              IPPROTO_TCP). La procedure dispatch a la forme suivante

                  dispatch(struct svc_req *request, SVCXPRT *xprt);

              La routine svc_register() renvoie 1 si elle reussit et 0 sinon.

       void svc_run(void);

              Cette routine  ne  revient  jamais.  Elle  attend  l'arrivee  de
              requetes RPC et appelle les procedures de service appropriees en
              utilisant svc_getreq(). Cette procedure est la plupart du  temps
              en attente autour d'un appel systeme select(2).

       bool_t svc_sendreply(SVCXPRT *xprt, xdrproc_t outproc, char *out);

              Appelee  par  une  routine  de distribution de services RPC pour
              envoyer le resultat d'un appel de procedure distante. L'argument
              xprt  est  le  descripteur  de  transport  associe a la requete,
              outproc est la routine XDR utilisee pour encoder les  resultats,
              et  out  est l'adresse des resultats. Cette routine renvoie 1 si
              elle reussit, et 0 sinon.

       void svc_unregister(unsigned long prognum, unsigned long versnum);

              Supprimer toute association du doublet [prognum,  versnum]  vers
              les  routines  de distribution, et du triplet [prognum, versnum,
              *] vers le numero de port.

       void svcerr_auth(SVCXPRT *xprt, enum auth_stat why);

              Appelee par une routine de distribution de  service  qui  refuse
              d'executer  un  appel de procedure distante a cause d'une erreur
              d'authentification.

       void svcerr_decode(SVCXPRT *xprt);

              Appelee par une routine de distribution de service qui  n'arrive
              pas a decoder ses arguments. Consultez aussi svc_getargs().

       void svcerr_noproc(SVCXPRT *xprt);

              Appelee   par   une  routine  de  distribution  de  service  qui
              n'implemente pas le numero de procedure que l'appelant reclame.

       void svcerr_noprog(SVCXPRT *xprt);

              Appelee quand le programme desire n'est pas enregistre  dans  le
              service  RPC.  L'implementation d'un service n'a normalement pas
              besoin de cette routine.

       void svcerr_progvers(SVCXPRT *xprt);

              Appelee quand le numero de version du programme desire n'est pas
              enregistre  dans  le  service RPC. L'implementation d'un service
              n'a normalement pas besoin de cette routine.

       void svcerr_systemerr(SVCXPRT *xprt);

              Appelee par une routine de distribution de  service  lorsqu'elle
              detecte  une  erreur  systeme non couverte par un protocole. Par
              exemple, si un service ne peut plus allouer de  place,  il  peut
              appeler cette routine.

       void svcerr_weakauth(SVCXPRT *xprt);

              Appelee  par  une  routine de distribution de service qui refuse
              d'executer un appel de procedure distante a cause d'un manque de
              parametres     d'authentification.     La     routine    appelle
              svcerr_auth(xprt, AUTH_TOOWEAK).

       SVCXPRT *svcfd_create(int fd, unsigned int sendsize,
                             unsigned int recvsize);

              Creer un service au-dessus de n'importe quel descripteur ouvert.
              Typiquement  ces descripteurs sont des sockets pour un protocole
              connecte comme TCP. sendsize et recvsize indiquent  les  tailles
              pour  les  tampons  d'emission  et  de reception. Si ces tailles
              valent zero, une valeur optimale est choisie.

       SVCXPRT *svcraw_create(void);

              Cette routine cree un  simili  transport  de  service  RPC  vers
              lequel  il  renvoie  un  pointeur.  Le  transport est en fait un
              tampon au sein de l'espace d'adressage du processus.  Le  client
              RPC   correspondant  doit  donc  resider  dans  le  meme  espace
              d'adresse. Consultez clntraw_create(). Cela  permet  de  simuler
              une  RPC et de mesurer la surcharge des procedures RPC comme les
              temps d'aller-retour  sans  interference  due  au  noyau.  Cette
              routine renvoie NULL si elle echoue.

       SVCXPRT *svctcp_create(int sock, unsigned int send_buf_size,
                              unsigned int recv_buf_size);

              Cette  routine  cree un transport de service RPC base sur TCP/IP
              sur lequel elle renvoie un pointeur.  Il  est  associe  avec  la
              socket  sock, qui peut etre RPC_ANYSOCK, auquel cas une nouvelle
              socket est creee. Si la socket n'est pas associee a un port  TCP
              local,  cette  routine  l'associe  a  un  port quelconque. Apres
              reussite, xprt->xp_sock est  le  descripteur  de  la  socket  de
              transport, et xprt->xp_port est le numero de port. Cette routine
              renvoie NULL si  elle  echoue.  Comme  les  RPC  basee  sur  TCP
              utilisent  des  entrees-sorties  avec  tampon,  les utilisateurs
              peuvent 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  cree un transport de service RPC base sur UDP/IP
              et renvoie un pointeur dessus. Le transport est associe avec  la
              socket  sock, qui peut etre RPC_ANYSOCK, auquel cas une nouvelle
              socket est creee. Si la socket n'est pas associee a un port  UDP
              local,  cette  routine  l'associe  a  un  port quelconque. Apres
              reussite, xprt->xp_sock est  le  descripteur  de  transport,  et
              xprt->xp_port  est le numero de port. Cette routine renvoie NULL
              si elle echoue.

              Cette routine  permet  au  programmeur  de  preciser  la  taille
              maximale  des tampons en emission et reception pour les messages
              RPC bases sur UDP.

       SVCXPRT *svcudp_create(int sock);

              Cet appel est equivalent a svcudp_bufcreate(sock,SZ,SZ) avec une
              taille SZ par defaut.

       bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar);

              Utilisee pour encoder les messages de reponse RPC. Cette routine
              est utile pour  les  programmeurs  qui  desirent  engendrer  des
              messages de style RPC sans employer le service RPC complet.

       bool_t xdr_authunix_parms(XDR *xdrs, struct authunix_parms *aupp);

              Utilisee  pour  decrire  les  identites  Unix. Cette routine est
              utile pour les programmeurs qui veulent engendrer ces  identites
              sans utiliser le systeme RPC d'authentification.

       void xdr_callhdr(XDR *xdrs, struct rpc_msg *chdr);

              Utilisee  pour  creer  les entetes de message RPC. Cette routine
              est utile pour  les  programmeurs  qui  desirent  engendrer  des
              messages de style RPC sans employer le service RPC complet.

       bool_t xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg);

              Utilisee  pour creer les messages d'appel RPC. Cette routine est
              utile pour les programmeurs qui desirent engendrer des  messages
              de style RPC sans employer le service RPC complet.

       bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);

              Utilisee  pour  creer  les  informations d'authentification RPC.
              Cette routine est  utile  pour  les  programmeurs  qui  desirent
              engendrer des messages de style RPC sans employer le service RPC
              complet.

       bool_t xdr_pmap(XDR *xdrs, struct pmap *regs);

              Utilisee  pour  creer  les  parametres  des  divers   procedures
              portmap.  Cette  routine  est  utile  pour  les programmeurs qui
              desirent creer ces parametres sans utiliser l'interface pmap.

       bool_t xdr_pmaplist(XDR *xdrs, struct pmaplist **rp);

              Utilisee pour creer la liste des associations des  ports.  Cette
              routine  est  utile pour les programmeurs qui desirent creer ces
              parametres sans utiliser l'interface pmap.

       bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr);

              Utilisee pour creer les messages de rejet RPC. Cette routine est
              utile  pour les programmeurs qui desirent engendrer des messages
              de style RPC sans employer le service RPC complet.

       bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg);

              Utilisee pour creer les messages de reponse RPC.  Cette  routine
              est  utile  pour  les  programmeurs  qui  desirent engendrer des
              messages de style RPC sans employer le service RPC complet.

       void xprt_register(SVCXPRT *xprt);

              Apres la creation d'un descripteur RPC  de  transport,  il  doit
              etre  enregistre  dans  le service RPC. Cette routine modifie la
              variable  globale  svc_fds.  L'implementation  d'un  service  ne
              necessite pas cette routine habituellement.

       void xprt_unregister(SVCXPRT *xprt);

              Avant  qu'un  descripteur RPC de transport soit detruit, il doit
              se desinscrire du service RPC. Cette routine modifie la variable
              globale  svc_fds. L'implementation d'un service ne necessite pas
              cette routine habituellement.

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.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   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
       Francois et l'equipe francophone de traduction de Debian (2006-2009).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.

                                17 juillet 2008                         RPC(3)