auth_destroy

RPC(3)                     Library Functions Manual                     RPC(3)



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.

       #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;

              où out est du même type que le out passé à clnt_broadcast(),
              avec la différence que la sortie de la procédure distante est
              décodée ici. addr pointe vers l'adresse de la machine qui a
              envoyé le résultat. Si eachresult()  renvoie zéro,
              clnt_broadcast()  attend d'autres réponses. Sinon elle revient
              avec le code de retour approprié.

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

       enum clnt_stat
       clnt_call(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é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(cl, req, info)
       CLIENT *cl;
       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(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 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(), 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 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(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 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(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 tampons 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 tampons 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
              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(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 tampon, les utilisateurs
              peuvent fixer la taille des tampons. Une taille nulle implique
              l'allocation automatique de tampons 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
       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.

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



                               16 février 1988                         RPC(3)