Provided by: manpages-fr-dev_3.17.1-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,  voir
              clntudp_create() pour certaines restrictions. Vous n’avez  aucun
              contrôle  sur  le  délai  maximal ou sur l’authentification avec
              cette routine.

       enum clnt_stat clnt_broadcast(unsigned long prognum,
                            unsigned long versnum, unsigned long procnum,
                            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. Voir svcraw_create(). Cela permet
              de simuler une RPC et de mesurer la surcharge des procédures RPC
              comme les temps d’aller-retour sans interférence due  au  noyau.
              Cette routine renvoie NULL si elle échoue.

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

              Cette  routine  crée  un  client  RPC  pour le programme distant
              prognum, de version versnum ; Le client utilise TCP/IP  pour  le
              transport.  Le  programme distant se trouve à l’adresse Internet
              *addr. Si addr->sin_port vaut zéro, alors il est rempli avec  le
              numéro de port sur lequel le programme distant est en écoute (on
              consulte  le  service  portmap  distant   pour   obtenir   cette
              information).   L’argument   sockp  est  une  socket;  si  c’est
              RPC_ANYSOCK, alors la  routine  ouvre  une  nouvelle  socket  et
              remplit  sockp.  Comme  les  RPC  basées  sur  TCP utilisent des
              entrées-sorties avec tampons, l’utilisateur  peut  spécifier  la
              taille  des  tampons  d’entrée  et de sortie avec les paramètres
              sendsz et recvsz. Des valeurs nulles réclament l’utilisation  de
              tampons de tailles optimales. Cette routine renvoie NULL si elle
              échoue.

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

              Cette routine crée un  client  RPC  pour  le  programme  distant
              prognum,  de  version versnum ; Le client utilise UDP/IP pour le
              transport. Le programme distant se trouve à  l’adresse  Internet
              addr.  Si  addr->sin_port vaut zéro, alors il est rempli avec le
              numéro de port sur lequel le programme distant est en écoute (on
              consulte   le   service   portmap  distant  pour  obtenir  cette
              information).  L’argument  sockp  est  une  socket;   si   c’est
              RPC_ANYSOCK,  alors  la  routine  ouvre  une  nouvelle socket et
              remplit sockp. Le protocole de transport UDP renvoie le  message
              d’appel  avec  un intervalle de temps indiqué par wait() jusqu’à
              la réception d’une réponse  ou  jusqu’au  dépassement  du  temps
              maximal.  Ce  délai  total  pour  l’appel  est  spécifié  par la
              fonction clnt_call().

              Attention : comme les messages des RPC basées sur UDP ne peuvent
              contenir  que 8 Ko de données encodées, ce protocole ne peut pas
              être utilisé pour des procédures nécessitant de gros  arguments,
              ou renvoyant d’énormes résultats.

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

              Cette  routine  crée  un  client  RPC  pour le programme distant
              prognum, de version versnum ; Le client utilise UDP/IP  pour  le
              transport.  Le  programme distant se trouve à l’adresse Internet
              addr. Si addr->sin_port vaut zéro, alors il est rempli  avec  le
              numéro de port sur lequel le programme distant est en écoute (on
              consulte  le  service  portmap  distant   pour   obtenir   cette
              information).   L’argument   sockp  est  une  socket;  si  c’est
              RPC_ANYSOCK, alors la  routine  ouvre  une  nouvelle  socket  et
              remplit  sockp. Le protocole de transport UDP renvoie le message
              d’appel avec un intervalle de temps indiqué par  wait()  jusqu’à
              la  réception  d’une  réponse  ou  jusqu’au dépassement du temps
              maximal. Ce  délai  total  pour  l’appel  est  spécifié  par  la
              fonction clnt_call().

              Cette  routine  permet  au  programmeur  de  préciser  la taille
              maximale des tampons en émission et réception pour les  messages
              RPC basés sur UDP.

       void get_myaddress(struct sockaddr_in *addr);

              Fournit l’adresse IP de la machine dans la structure *addr, sans
              consulter  les  routines   de   bibliothèques   qui   manipulent
              /etc/hosts.   Le   numéro  de  port  est  toujours  rempli  avec
              htons(PMAPPORT).

       struct pmaplist *pmap_getmaps(struct sockaddr_in *addr);

              Une interface utilisateur pour le service portmap renvoyant  une
              liste  des  associations  en cours entre programmes RPC et ports
              sur l’hôte situé à  l’adresse  IP  indiquée  dans  *addr.  Cette
              routine  peut  renvoyer NULL. La commande « rpcinfo -p » utilise
              cette fonction

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

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

       enum clnt_stat pmap_rmtcall(struct sockaddr_in *addr,
                           unsigned long prognum, unsigned long versnum,
                           unsigned long procnum,
                           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.  Voir  aussi
              clnt_broadcast().

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

              Une  interface  utilisateur  pour le service portmap qui établit
              une association entre le triplet [prognum, versnum, protocol] et
              le  port sur la machine du service portmap La valeur du protocol
              est  normalement  IPPROTO_UDP  ou  IPPROTO_TCP.  Cette   routine
              renvoie   1   si   elle   réussit,   et  zéro  sinon.  Elle  est
              automatiquement invoquée par svc_register().

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

              Une interface utilisateur vers le service  portmap  qui  détruit
              toute  association entre le triplet [prognum, versnum, *] et les
              ports de la machine où  se  trouve  le  service  portmap.  Cette
              routine renvoie 1 si elle réussit, et zéro sinon.

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

              Enregistre  la  procédure  procname  avec le service RPC. Si une
              requête arrive pour le programme prognum, de version versnum, et
              pour  la  procédure  procnum,  procname  sera  appelée  avec  un
              pointeur vers ses paramètres d’entrée. progname doit renvoyer un
              pointeur  vers ses résultats statiques. inproc est utilisée pour
              décoder les paramètres d’entrée alors que outproc sert à  encode
              les  résultats. Cette routine renvoie zéro si l’enregistrement à
              réussi, et -1 sinon.

              Attention : les procédures enregistrées de  cette  manière  sont
              accessibles   avec   le  protocole  de  transport  UDP/IP.  Voir
              svcudp_create() pour ses restrictions.

       struct rpc_createerr rpc_createerr;

              Une variable globale dont la valeur est fixée par toute  routine
              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. Voir aussi svc_getargs().

       void svcerr_noproc(SVCXPRT *xprt);

              Appelée   par   une  routine  de  distribution  de  service  qui
              n’implémente pas le numéro de procédure que l’appelant  réclame.

       void svcerr_noprog(SVCXPRT *xprt);

              Appelée  quand  le programme désiré n’est pas enregistré dans le
              service RPC. L’implémentation d’un service n’a  normalement  pas
              besoin de cette routine.

       void svcerr_progvers(SVCXPRT *xprt);

              Appelée quand le numéro de version du programme désiré n’est pas
              enregistré dans le service RPC.  L’implémentation  d’un  service
              n’a normalement pas besoin de cette routine.

       void svcerr_systemerr(SVCXPRT *xprt);

              Appelée  par  une routine de distribution de service lorsqu’elle
              détecte une erreur système non couverte par  un  protocole.  Par
              exemple,  si  un  service ne peut plus allouer de place, il peut
              appeler cette routine.

       void svcerr_weakauth(SVCXPRT *xprt);

              Appelée par une routine de distribution de  service  qui  refuse
              d’exécuter un appel de procédure distante à cause d’un manque de
              paramètres    d’authentification.     La     routine     appelle
              svcerr_auth(xprt, AUTH_TOOWEAK).

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

              Créer un service au-dessus de n’importe quel descripteur ouvert.
              Typiquement ces descripteurs sont des sockets pour un  protocole
              connecté  comme  TCP. sendsize et recvsize indiquent les tailles
              pour les tampons d’émission et  de  réception.  Si  ces  tailles
              valent zéro, une valeur optimale est choisie.

       SVCXPRT *svcraw_create(void);

              Cette  routine  crée  un  simili  transport  de service RPC vers
              lequel il renvoie un pointeur.  Le  transport  est  en  fait  un
              tampon  au  sein de l’espace d’adressage du processus. Le client
              RPC  correspondant  doit  donc  résider  dans  le  même   espace
              d’adresse. Voir clntraw_create(). Cela permet de simuler une RPC
              et de mesurer la surcharge des procédures RPC  comme  les  temps
              d’aller-retour  sans  interférence  due  au noyau. Cette routine
              renvoie NULL si elle échoue.

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

              Cette routine crée un transport de service RPC basé  sur  TCP/IP
              sur  lequel  elle  renvoie  un  pointeur. Il est associé avec la
              socket sock, qui peut être RPC_ANYSOCK, auquel cas une  nouvelle
              socket  est créée. Si la socket n’est pas associée à un port TCP
              local, cette routine  l’associe  à  un  port  quelconque.  Après
              réussite,  xprt->xp_sock  est  le  descripteur  de  la socket de
              transport, et xprt->xp_port est le numéro de port. Cette routine
              renvoie  NULL  si  elle  échoue.  Comme  les  RPC  basé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.17  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement         gérées         par         Nicolas         François
       <nicolas.francois@centraliens.net>   et   l’équipe    francophone    de
       traduction de Debian.

       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)