Provided by: manpages-fr_1.67.0-1_all bug

NOM

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

SYNOPSIS ET DESCRIPTION

       [NDT] RPC = Remote Procedure Call.

       Ces routines permettent à des programmes  C  de  faire  des  appels  de
       procédures  vers  d’autres  machines  à  travers le réseau.  D’abord le
       client invoque une procédure pour envoyer un paquet de données vers  le
       serveur.   À  la réception du paquet, le serveur appelle une routine de
       distribution pour exécuter le service demandé, et renvoyer une réponse.
       Finalement, l’appel de procédure revient au client.

       Les  routines  qui  utilisent les RPC sécurisées (authentification DES)
       sont  décrites  dans  rpc_secure(3N).   Les  RPC  sécurisées  ne   sont
       possibles que si le cryptage DES est disponible.

       #include <rpc/rpc.h>

       void
       auth_destroy(auth)
       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()

              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(host, uid, gid, len, aup_gids)
       char *host;
       int uid, gid, len, *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()

              Appelle authunix_create() avec les arguments appropriés.

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

              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(prognum, versnum, procnum, inproc, in, outproc, out, eachresult)
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       resultproc_t eachresult;

              Comme callrpc(), sauf que le message  d’appel  est  diffusé  sur
              tous  les  réseaux  connectés. À chaque réception d’une réponse,
              cette routine appelle la fonction eachresult(),  dont  la  forme
              est :

                 eachresult(out, addr)
                 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  socket  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(clnt, procnum, inproc, in, outproc, out, tout)
       CLIENT *clnt;
       u_long
       procnum;
       xdrproc_t inproc, outproc;
       char *in, *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(clnt)
       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(host, prog, vers, proto)
       char *host;
       u_long prog, 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ée à 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(cl, req, info)
       CLIENT *cl;
       char *info;

              Une macro employée pour modifier ou récupérer  des  informations
              diverses  à  propose  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  get servers address

              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(clnt, outproc, out)
       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(clnt, errp)
       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(s)
       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(stat)
       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(clnt, s)
       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(stat)
       enum clnt_stat stat;

              Emploie les même  arguments  que  clnt_perrno(),  mais  au  lien
              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é à 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, 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(rpch, s)
       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(prognum, versnum)
       u_long prognum, versnum;

              Cette routine crée  un  simili  client  RPC  pour  le  programme
              distant  prognum, de version versnum.  Le mécanisme de transport
              pour  les  message  est  en  réalité  un  buffer  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(addr, prognum, versnum, sockp, sendsz, recvsz)
       struct sockaddr_in *addr;
       u_long prognum, versnum;
       int *sockp;
       u_int sendsz, 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 buffers, l’utilisateur  peut  spécifier  la
              taille  des  buffers  d’entrée  et de sortie avec les paramètres
              sendsz et recvsz.  Des valeurs nulles réclament l’utilisation de
              buffers  de  tailles  optimales.   Cette routine renvoie NULL si
              elle échoue.

       CLIENT *
       clntudp_create(addr, prognum, versnum, wait, sockp)
       struct sockaddr_in *addr;
       u_long prognum, 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(addr, prognum, versnum, wait, sockp, sendsize, recosize)
       struct sockaddr_in *addr;
       u_long prognum, 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 buffers en émission et réception pour les  messages
              RPC basés sur UDP.

       void
       get_myaddress(addr)
       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(addr)
       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

       u_short
       pmap_getport(addr, prognum, versnum, protocol)
       struct sockaddr_in *addr;
       u_long prognum, versnum, 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(addr, prognum, versnum, procnum, inproc, in, outproc, out, tout, portp)
       struct sockaddr_in *addr;
       u_long prognum, versnum, procnum;
       char *in, *out;
       xdrproc_t inproc, outproc;
       struct timeval tout;
       u_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().

       pmap_set(prognum, versnum, protocol, port)
       u_long prognum, versnum, protocol;
       u_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().

       pmap_unset(prognum, versnum)
       u_long prognum, 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.

       registerrpc(prognum, versnum, procnum, procname, inproc, outproc)
       u_long prognum, versnum, procnum;
       char *(*procname) () ;
       xdrproc_t inproc, outproc;

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

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

       struct rpc_createerr     rpc_createerr;

              Une variable globale dont la valeur est fixée par toute  routine
              RPC  de  création  de  client  qui  échoue.  Utilisez la routine
              clnt_pcreateerror() pour afficher la raison de l’échec.

       svc_destroy(xprt)
       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.    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() !), 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(xprt, inproc, in)
       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(xprt, inproc, in)
       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(xprt)
       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.

       svc_getreqset(rdfds)
       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  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  fichiers  en  résultant.  La
              routine  revient  lorsque  toutes les sockets associées avec les
              valeurs de rdfds ont été servies.

       svc_getreq(rdfds)
       int rdfds;

              Similaire à svc_getreqset(), mais  limitée  à  32  descripteurs.
              Cette interface est rendue obsolète par svc_getreqset().

       svc_register(xprt, prognum, versnum, dispatch, protocol)
       SVCXPRT *xprt;
       u_long prognum, versnum;
       void (*dispatch) ();
       u_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(request, xprt)
                 struct svc_req *request;
                 SVCXPRT *xprt;

              La  routine svc_register() renvoie 1 si elle réussit et 0 sinon.

       svc_run()

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

       svc_sendreply(xprt, outproc, out)
       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(prognum, versnum)
       u_long prognum, 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(xprt, why)
       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(xprt)
       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(xprt)
       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(xprt)
       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(xprt)
       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(xprt)
       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(xprt)
       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(fd, sendsize, recvsize)
       int fd;
       u_int sendsize;
       u_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 buffers d’émission et de  réception.   Si  ces  tailles
              valent zéro, une valeur optimale est choisie.

       SVCXPRT *
       svcraw_create()

              Cette  routine  crée  un  simili  transport  de service RPC vers
              lequel il renvoie un pointeur.  Le  transport  est  en  fait  un
              buffer  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(sock, send_buf_size, recv_buf_size)
       int sock;
       u_int send_buf_size, 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  buffer,  les  utilisateurs
              peuvent  fixer  la taille des buffers. Une taille nulle implique
              l’allocation automatique de buffers de tailles optimales.

       SVCXPRT *
       svcudp_bufcreate(sock, sendsize, recosize)
       int sock;

              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.

              Ceci  permet à l’utilisateur de préciser la taille maximale d’un
              paquet UDP en émission ou en réception de messages RPC.

       SVCXPRT *
       svcudp_create(sock)
       int sock;

              Cet appel est équivalent à svcudp_bufcreate(sock,SZ,SZ) avec une
              taille SZ par défaut.

       xdr_accepted_reply(xdrs, ar)
       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.

       xdr_authunix_parms(xdrs, aupp)
       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(xdrs, chdr)
       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.

       xdr_callmsg(xdrs, cmsg)
       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.

       xdr_opaque_auth(xdrs, ap)
       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.

       xdr_pmap(xdrs, regs)
       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.

       xdr_pmaplist(xdrs, rp)
       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.

       xdr_rejected_reply(xdrs, rr)
       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.

       xdr_replymsg(xdrs, rmsg)
       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(xprt)
       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(xprt)
       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

       rpc_secure(3N), xdr(3N)
       Les manuels suivants :
              Remote Procedure Calls: Protocol Specification
              Remote Procedure Call Programming Guide
              rpcgen Programming Guide
       RPC:   Remote  Procedure  Call  Protocol  Specification,  RFC1050,  Sun
       Microsystems, Inc., USC-ISI.

TRADUCTION

       Christophe Blaess, 2000-2003.