.\" -*- coding: UTF-8 -*- '\" t .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license) .\" .\" %%%LICENSE_START(BSD_ONELINE_CDROM) .\" This page was taken from the 4.4BSD-Lite CDROM (BSD license) .\" %%%LICENSE_END .\" .\" @(#)rpc.3n 2.4 88/08/08 4.0 RPCSRC; from 1.19 88/06/24 SMI .\" .\" 2007-12-30, mtk, Convert function prototypes to modern C syntax .\" .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH rpc 3 "2 mai 2024" "Pages du manuel de Linux 6.8" .SH NOM rpc \- Bibliothèque de fonctions pour les appels de procédures à distance .SH BIBLIOTHÈQUE Bibliothèque C standard (\fIlibc\fP, \fI\-lc\fP) .SH "SYNOPSIS ET DESCRIPTION" .\" .P .\" We don't have an rpc_secure.3 page at the moment -- MTK, 19 Sep 05 .\" Routines that are used for Secure RPC (DES authentication) are described in .\" .BR rpc_secure (3). .\" Secure RPC can be used only if DES encryption is available. 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. .P Pour utiliser ces routines, il faut inclure le fichier d'en\-têtes \fI\fP. .P Le prototype ci\-dessous utilise les types suivants : .P .RS 4 .EX \fBtypedef int \fP\fIbool_t\fP\fB;\fP .P \fBtypedef bool_t (*\fP\fIxdrproc_t\fP\fB)(XDR *, void *, ...);\fP .P \fBtypedef bool_t (*\fP\fIresultproc_t\fP\fB)(caddr_t \fP\fIresp\fP\fB,\fP \fB struct sockaddr_in *\fP\fIraddr\fP\fB);\fP .EE .RE .P Consultez les fichiers d'en\-tête pour les déclarations des types \fIAUTH\fP, \fICLIENT\fP, \fISVCXPRT\fP et \fIXDR\fP. .P .nf \fBvoid auth_destroy(AUTH *\fP\fIauth\fP\fB);\fP .fi .IP Cette macro détruit les informations d'authentification associée avec \fIauth\fP. La destruction implique généralement la désallocation de données privées. Le comportement est indéfini si on essaye d'utiliser \fIauth\fP après avoir invoqué \fBauth_destroy\fP(). .P .nf \fBAUTH *authnone_create(void);\fP .fi .IP 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. .P .nf \fBAUTH *authunix_create(char *\fP\fIhost\fP\fB, uid_t \fP\fIuid\fP\fB, gid_t \fP\fIgid\fP\fB,\fP \fB int \fP\fIlen\fP\fB, gid_t \fP\fIaup_gids\fP\fB[.\fP\fIlen\fP\fB]);\fP .fi .IP Crée et renvoie un descripteur d'authentification RPC UNIX, contenant des informations d'identification. L'argument \fIhost\fP est le nom de la machine sur laquelle l'information est créée. \fIuid\fP est l'identification de l'utilisateur. \fIgid\fP est l'identification du groupe de l'utilisateur. \fIlen\fP et \fIaup_gids\fP concernent la table des groupes supplémentaires auxquels l'utilisateur appartient. On peut facilement se faire passer pour quelqu'un d'autre. .P .nf \fBAUTH *authunix_create_default(void);\fP .fi .IP Appelle \fBauthunix_create\fP() avec les arguments appropriés. .P .nf \fBint callrpc(char *\fP\fIhost\fP\fB, unsigned long \fP\fIprognum\fP\fB,\fP \fB unsigned long \fP\fIversnum\fP\fB, unsigned long \fP\fIprocnum\fP\fB,\fP \fB xdrproc_t \fP\fIinproc\fP\fB, const char *\fP\fIin\fP\fB,\fP \fB xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB);\fP .fi .IP Appelle la procédure distante associée aux arguments \fIprognum\fP, \fIversnum\fP, et \fIprocnum\fP sur la machine, \fIhost\fP. L'argument \fIin\fP est l'adresse du ou des arguments d'entrée de la procédure, \fIout\fP celle de l'emplacement où stocker le ou les résultats, \fIinproc\fP sert à encoder les paramètres d'entrée de la procédure, et \fIoutproc\fP à décoder les résultats de la procédure. Cette routine renvoie zéro si elle réussit, ou la valeur de \fBenum clnt_stat\fP transposée en un nombre entier si elle échoue La routine \fBclnt_perrno\fP() permet de traduire les codes d'échec en messages. .IP Attention\ : l'appel d'une procédure distante avec cette routine emploie le protocole UDP/IP pour le transport, consultez \fBclntudp_create\fP() pour certaines restrictions. Vous n'avez aucun contrôle sur le délai maximal ou sur l'authentification avec cette routine. .P .nf \fBenum clnt_stat clnt_broadcast(unsigned long \fP\fIprognum\fP\fB,\fP \fB unsigned long \fP\fIversnum\fP\fB, unsigned long \fP\fIprocnum\fP\fB,\fP \fB xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP \fB xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB,\fP \fB resultproc_t \fP\fIeachresult\fP\fB);\fP .fi .IP Comme \fBcallrpc\fP(), 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 \fBeachresult\fP(), dont la forme est\ : .IP .in +4n .EX \fBeachresult(char *\fP\fIout\fP\fB, struct sockaddr_in *\fP\fIaddr\fP\fB);\fP .EE .in .IP où \fIout\fP est du même type que le \fIout\fP passé à \fBclnt_broadcast\fP(), avec la différence que la sortie de la procédure distante est décodée ici. \fIaddr\fP pointe vers l'adresse de la machine qui a envoyé le résultat. Si \fBeachresult\fP() renvoie zéro, \fBclnt_broadcast\fP() attend d'autres réponses. Sinon elle revient avec le code de retour approprié. .IP Attention\ : les sockets broadcast sont limités en ce qui concerne la taille maximale des données. Pour l'Ethernet, cette valeur (MTU) vaut 1500 octets. .P .nf \fBenum clnt_stat clnt_call(CLIENT *\fP\fIclnt\fP\fB, unsigned long \fP\fIprocnum\fP\fB,\fP \fB xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP \fB xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB,\fP \fB struct timeval \fP\fItout\fP\fB);\fP .fi .IP Une macro qui appelle la procédure distante \fIprocnum\fP associée avec le descripteur de client \fIclnt\fP, qui est obtenu grâce à une routine de création de client RPC comme \fBclnt_create\fP(). L'argument \fIin\fP est l'adresse du ou des arguments d'entrée de la procédure, \fIout\fP celle de l'emplacement où stocker le ou les résultats, \fIinproc\fP sert à encoder les paramètres d'entrée de la procédure, et \fIoutproc\fP à décoder les résultats de la procédure. \fItout\fP est le délai maximal accordé pour la réalisation de la procédure. .P .nf \fBclnt_destroy(CLIENT *\fP\fIclnt\fP\fB);\fP .fi .IP 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 \fIclnt\fP lui\-même. Le comportement est indéfini si on tente d'utiliser \fIclnt\fP après avoir appelé \fBclnt_destroy\fP(). Si la bibliothèque RPC avait ouvert le socket associé, il sera également fermé. Sinon, le socket reste ouvert. .P .nf \fBCLIENT *clnt_create(const char *\fP\fIhost\fP\fB, unsigned long \fP\fIprog\fP\fB,\fP \fB unsigned long \fP\fIvers\fP\fB, const char *\fP\fIproto\fP\fB);\fP .fi .IP Routine générique de création de client. \fIhost\fP identifie le nom de l'hôte distant où se trouve le serveur. \fIproto\fP 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 \fBclnt_control\fP(). .IP 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. .P .nf \fBbool_t clnt_control(CLIENT *\fP\fIcl\fP\fB, int \fP\fIreq\fP\fB, char *\fP\fIinfo\fP\fB);\fP .fi .IP Une macro employée pour modifier ou récupérer des informations diverses à propos d'un objet client. \fIreq\fP indique le type d'opération, et \fIinfo\fP est un pointeur sur l'information. Pour UDP comme pour TCP, les valeurs autorisées pour \fIreq\fP et le type des arguments sont\ : .IP .in +4n .EX \fBCLSET_TIMEOUT\fP \fIstruct timeval\fP // définir le délai total \fBCLGET_TIMEOUT\fP \fIstruct timeval\fP // lire le délai total .EE .in .IP Note\ : Si vous définissez le délai avec \fBclnt_control\fP(), le dernier argument de \fBclnt_call\fP() sera ignoré lors des appels ultérieurs. .IP .in +4n .EX \fBCLGET_SERVER_ADDR\fP \fIstruct sockaddr_in\fP // lire l'adresse du serveur .EE .in .IP Les opérations suivantes sont valides pour le protocole UDP seulement\ : .IP .in +4n .EX \fBCLSET_RETRY_TIMEOUT\fP \fIstruct timeval\fP // définir le délai de répétition \fBCLGET_RETRY_TIMEOUT\fP \fIstruct timeval\fP // lire le délai de répétition .EE .in .IP 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. .P .nf \fBclnt_freeres(CLIENT * \fP\fIclnt\fP\fB, xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB);\fP .fi .IP 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 \fIout\fP est l'adresse des résultats, et \fIoutproc\fP 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. .P .nf \fBvoid clnt_geterr(CLIENT *\fP\fIclnt\fP\fB, struct rpc_err *\fP\fIerrp\fP\fB);\fP .fi .IP Une macro qui copie la structure d'erreur depuis le descripteur de client vers la structure se trouvant à l'adresse \fIerrp\fP. .P .nf \fBvoid clnt_pcreateerror(const char *\fP\fIs\fP\fB);\fP .fi .IP 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 \fIs\fP et un deux\-points est inséré. À utiliser lorsque les appels \fBclnt_create\fP(), \fBclntraw_create\fP(), \fBclnttcp_create\fP() ou \fBclntudp_create\fP() échouent. .P .nf \fBvoid clnt_perrno(enum clnt_stat \fP\fIstat\fP\fB);\fP .fi .IP Affiche un message sur la sortie d'erreur standard, correspondant à la condition indiquée par \fIstat\fP. À utiliser après \fBcallrpc\fP(). .P .nf \fBclnt_perror(CLIENT *\fP\fIclnt\fP\fB, const char *\fP\fIs\fP\fB);\fP .fi .IP Affiche un message sur la sortie d'erreur standard indiquant pourquoi un appel RPC a échoué. \fIclnt\fP est le descripteur utilisé pour l'appel. Ce message est préfixé avec la chaîne \fIs\fP et un deux\-points est inséré. À utiliser après \fBclnt_call\fP(). .P .nf \fBchar *clnt_spcreateerror(const char *\fP\fIs\fP\fB);\fP .fi .IP Comme \fBclnt_pcreateerror\fP(), sauf qu'il renvoie une chaîne au lieu d'écrire sur la sortie d'erreur standard. .IP Danger\ : renvoie un pointeur vers une zone de donnée statique, écrasée à chaque appel. .P .nf \fBchar *clnt_sperrno(enum clnt_stat \fP\fIstat\fP\fB);\fP .fi .IP Emploie les même arguments que \fBclnt_perrno\fP(), 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. .IP \fBclnt_sperrno\fP() est utilisée à la place de \fBclnt_perrno\fP() 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 \fBprintf\fP(3), ou si un format de message différent de celui fourni par \fBclnt_perrno\fP() doit être utilisé. Note\ : contrairement à \fBclnt_sperror\fP() et \fBclnt_spcreaterror\fP(), \fBclnt_sperrno\fP() renvoie un pointeur sur une zone de donnée statique, mais le résultat ne sera pas écrasé à chaque appel. .P .nf \fBchar *clnt_sperror(CLIENT *\fP\fIrpch\fP\fB, const char *\fP\fIs\fP\fB);\fP .fi .IP Comme \fBclnt_perror\fP(), sauf que (comme \fBclnt_sperrno\fP()) il renvoie une chaîne au lieu d'écrire sur la sortie d'erreur standard. .IP Danger\ : renvoie un pointeur vers une zone de donnée statique, écrasée à chaque appel. .P .nf \fBCLIENT *clntraw_create(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB);\fP .fi .IP Cette routine crée un simili client RPC pour le programme distant \fIprognum\fP, de version \fIversnum\fP. Le mécanisme de transport pour les messages est en réalité un tampon dans l'espace d'adresse du processus, ainsi le serveur RPC doit se trouver dans le même espace d'adresse. Consultez \fBsvcraw_create\fP(). 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. .P .nf \fBCLIENT *clnttcp_create(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP \fB unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB int *\fP\fIsockp\fP\fB, unsigned int \fP\fIsendsz\fP\fB, unsigned int \fP\fIrecvsz\fP\fB);\fP .fi .IP .\"The following inline font conversion is necessary for the hyphen indicator Cette routine crée un client RPC pour le programme distant \fIprognum\fP, de version \fIversnum\fP\ ; Le client utilise TCP/IP pour le transport. Le programme distant se trouve à l'adresse Internet \fI*addr\fP. Si \fIaddr\->sin_port\fP 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 \fBportmap\fP distant pour obtenir cette information). L'argument \fIsockp\fP est un socket ; si c'est \fBRPC_ANYSOCK\fP, alors la routine ouvre un nouveau socket et remplit \fIsockp\fP. 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 \fIsendsz\fP et \fIrecvsz\fP. Des valeurs nulles réclament l'utilisation de tampons de tailles optimales. Cette routine renvoie NULL si elle échoue. .P .nf \fBCLIENT *clntudp_create(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP \fB unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB struct timeval \fP\fIwait\fP\fB, int *\fP\fIsockp\fP\fB);\fP .fi .IP Cette routine crée un client RPC pour le programme distant \fIprognum\fP, de version \fIversnum\fP\ ; Le client utilise UDP/IP pour le transport. Le programme distant se trouve à l'adresse Internet \fIaddr\fP. Si \fIaddr\->sin_port\fP 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 \fBportmap\fP distant pour obtenir cette information). L'argument \fIsockp\fP est un socket ; si c'est \fBRPC_ANYSOCK\fP, alors la routine ouvre un nouveau socket et remplit \fIsockp\fP. Le protocole de transport UDP renvoie le message d'appel avec un intervalle de temps indiqué par \fBwait\fP() 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 \fBclnt_call\fP(). .IP 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. .P .nf \fBCLIENT *clntudp_bufcreate(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP \fB unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB struct timeval \fP\fIwait\fP\fB, int *\fP\fIsockp\fP\fB,\fP \fB unsigned int \fP\fIsendsize\fP\fB, unsigned int \fP\fIrecosize\fP\fB);\fP .fi .IP Cette routine crée un client RPC pour le programme distant \fIprognum\fP, de version \fIversnum\fP\ ; Le client utilise UDP/IP pour le transport. Le programme distant se trouve à l'adresse Internet \fIaddr\fP. Si \fIaddr\->sin_port\fP 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 \fBportmap\fP distant pour obtenir cette information). L'argument \fIsockp\fP est un socket ; si c'est \fBRPC_ANYSOCK\fP, alors la routine ouvre une nouveau socket et remplit \fIsockp\fP. Le protocole de transport UDP renvoie le message d'appel avec un intervalle de temps indiqué par \fBwait\fP() 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 \fBclnt_call\fP(). .IP 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. .P .nf \fBvoid get_myaddress(struct sockaddr_in *\fP\fIaddr\fP\fB);\fP .fi .IP Fournit l'adresse IP de la machine dans la structure \fI*addr\fP, sans consulter les routines de bibliothèques qui manipulent \fI/etc/hosts\fP. Le numéro de port est toujours rempli avec \fBhtons(PMAPPORT)\fP. .P .nf \fBstruct pmaplist *pmap_getmaps(struct sockaddr_in *\fP\fIaddr\fP\fB);\fP .fi .IP Une interface utilisateur pour le service \fBportmap\fP renvoyant une liste des associations en cours entre programmes RPC et ports sur l'hôte situé à l'adresse IP indiquée dans \fI*addr\fP. Cette routine peut renvoyer NULL. La commande «\ \fBrpcinfo\ \-p\fP\ » utilise cette fonction .P .nf \fBunsigned short pmap_getport(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP \fB unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB unsigned int \fP\fIprotocol\fP\fB);\fP .fi .IP Une interface utilisateur pour le service \fBportmap\fP qui renvoie le numéro de port sur lequel est en écoute le service associé au programme numéro \fIprognum\fP, de version \fIversnum\fP, en utilisant le protocole de transport associé avec \fIprotocol\fP. La valeur de l'argument \fIprotocol\fP est normalement \fBIPPROTO_UDP\fP ou \fBIPPROTO_TCP\fP. 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 \fBportmap\fP distant. Dans ce cas, la variable globale \fIrpc_createerr\fP contient le code RPC de l'erreur. .P .nf \fBenum clnt_stat pmap_rmtcall(struct sockaddr_in *\fP\fIaddr\fP\fB,\fP \fB unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB unsigned long \fP\fIprocnum\fP\fB,\fP \fB xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB,\fP \fB xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB,\fP \fB struct timeval \fP\fItout\fP\fB, unsigned long *\fP\fIportp\fP\fB);\fP .fi .IP Une interface utilisateur pour le service \fBportmap\fP qui demande au programme \fBportmap\fP sur l'hôte se trouvant à l'adresse IP indiquée dans \fI*addr\fP de faire en notre nom un appel RPC pour une procédure se trouvant sur cet hôte. Le paramètre \fI*portp\fP 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 \fBcallrpc\fP() et de \fBclnt_call\fP(). Cette procédure devrait être utilisée pour faire un «\ ping\ » et rien d'autre. Consultez aussi \fBclnt_broadcast\fP(). .P .nf \fBbool_t pmap_set(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB int \fP\fIprotocol\fP\fB, unsigned short \fP\fIport\fP\fB);\fP .fi .IP Une interface utilisateur pour le service \fBportmap\fP qui établit une association entre le triplet [\fIprognum\fP, \fIversnum\fP, \fIprotocol\fP] et le \fIport\fP sur la machine du service \fBportmap\fP La valeur du \fIprotocol\fP est normalement \fBIPPROTO_UDP\fP ou \fBIPPROTO_TCP\fP. Cette routine renvoie 1 si elle réussit, et zéro sinon. Elle est automatiquement invoquée par \fBsvc_register\fP(). .P .nf \fBbool_t pmap_unset(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB);\fP .fi .IP Une interface utilisateur vers le service \fBportmap\fP qui détruit toute association entre le triplet [\fIprognum\fP, \fIversnum\fP, \fI*\fP] et les \fBports\fP de la machine où se trouve le service \fBportmap\fP. Cette routine renvoie 1 si elle réussit, et zéro sinon. .P .nf \fBint registerrpc(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB,\fP \fB unsigned long \fP\fIprocnum\fP\fB, char *(*\fP\fIprocname\fP\fB)(char *),\fP \fB xdrproc_t \fP\fIinproc\fP\fB, xdrproc_t \fP\fIoutproc\fP\fB);\fP .fi .IP Enregistre la procédure \fIprocname\fP avec le service RPC. Si une requête arrive pour le programme \fIprognum\fP, de version \fIversnum\fP, et pour la procédure \fIprocnum\fP, \fIprocname\fP sera appelée avec un pointeur vers ses paramètres d'entrée. \fIprogname\fP doit renvoyer un pointeur vers ses résultats statiques. \fIinproc\fP est utilisée pour décoder les paramètres d'entrée alors que \fIoutproc\fP sert à encode les résultats. Cette routine renvoie zéro si l'enregistrement à réussi, et \fB\-1\fP sinon. .IP Attention\ : les procédures enregistrées de cette manière sont accessibles avec le protocole de transport UDP/IP. Consultez \fBsvcudp_create\fP() pour ses restrictions. .P .nf \fBstruct rpc_createerr \fP\fIrpc_createerr\fP\fB;\fP .fi .IP Une variable globale dont la valeur est définie par toute routine SM RPC de création de client qui échoue. Utilisez la routine \fBclnt_pcreateerror\fP() pour afficher la raison de l'échec. .P .nf \fBvoid svc_destroy(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP Une macro qui détruit le descripteur de transport RPC \fIxprt\fP. La destruction implique normalement la libération de structures de données privées, y compris \fIxprt\fP lui\-même. Le comportement est indéfini si on essaye d'utiliser \fIxprt\fP après avoir appelé cette routine. .P .nf \fBfd_set \fP\fIsvc_fdset\fP\fB;\fP .fi .IP 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 \fBselect\fP(2). Ce n'est intéressant que si l'implémentation d'un service assure son propre traitement d'événements asynchrones, au lieu d'appeler \fBsvc_run\fP(). Cette variable est en lecture seule (ne passez pas son adresse à \fBselect\fP(2) !), et elle peut changer après un appel \fBsvc_getreqset\fP() ou une routine de création. .P .nf \fBint \fP\fIsvc_fds\fP\fB;\fP .fi .IP Similaire à \fBsvc_fdset\fP, mais limitée à 32 descripteurs de fichier. Cette interface est rendue obsolète par \fBsvc_fdset\fP. .P .nf \fBsvc_freeargs(SVCXPRT *\fP\fIxprt\fP\fB, xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB);\fP .fi .IP 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 \fBsvc_getargs\fP(). Cette routine renvoie 1 si les arguments ont été correctement libérés, et zéro sinon. .P .nf \fBsvc_getargs(SVCXPRT *\fP\fIxprt\fP\fB, xdrproc_t \fP\fIinproc\fP\fB, char *\fP\fIin\fP\fB);\fP .fi .IP Une macro qui décode les arguments d'une requête RPC associée avec le descripteur de transport RPC \fIxprt\fP. L'argument \fIin\fP est l'adresse où les arguments seront stockés, \fIinproc\fP est la routine XDR pour décoder les arguments. Cette routine renvoie 1 si le décodage réussit, et zéro sinon. .P .nf \fBstruct sockaddr_in *svc_getcaller(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP 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 \fIxprt\fP. .P .nf \fBvoid svc_getreqset(fd_set *\fP\fIrdfds\fP\fB);\fP .fi .IP Cette routine n'est intéressante que si l'implémentation d'un service n'appelle pas \fBsvc_run\fP(), mais emploie à la place un traitement personnalisé des événements asynchrones. On l'invoque lorsque l'appel système \fBselect\fP(2) a déterminé qu'une requête RPC est arrivée sur l'une des sockets RPC. \fIrdfds\fP est le masque de bits des descripteurs de fichier en résultant. La routine revient lorsque tous les sockets associés avec les valeurs de \fIrdfds\fP ont été servis. .P .nf \fBvoid svc_getreq(int \fP\fIrdfds\fP\fB);\fP .fi .IP Similaire à \fBsvc_getreqset\fP(), mais limitée à 32 descripteurs de fichier. Cette interface est rendue obsolète par \fBsvc_getreqset\fP(). .P .nf \fBbool_t svc_register(SVCXPRT *\fP\fIxprt\fP\fB, unsigned long \fP\fIprognum\fP\fB,\fP \fB unsigned long \fP\fIversnum\fP\fB,\fP \fB void (*\fP\fIdispatch\fP\fB)(struct svc_req *, SVCXPRT *),\fP \fB unsigned long \fP\fIprotocol\fP\fB);\fP .fi .IP Associer \fIprognum\fP et \fIversnum\fP avec la procédure de distribution \fIdispatch\fP. Si \fIprotocol\fP vaut zéro, le service n'est pas enregistré avec le service \fBportmap\fP. Si \fIprotocol\fP est non\-nul, alors l'association entre le triplet [\fIprognum\fP,\fIversnum\fP,\fIprotocol\fP] et \fIxprt\->xp_port\fP est établie par l'intermédiaire du service \fBportmap\fP local (en général \fIprotocol\fP vaut zéro, \fBIPPROTO_UDP\fP ou \fBIPPROTO_TCP\fP). La procédure \fIdispatch\fP a la forme suivante .IP .in +4n .EX dispatch(struct svc_req *request, SVCXPRT *xprt); .EE .in .IP La routine \fBsvc_register\fP() renvoie 1 si elle réussit et 0 sinon. .P .nf \fBvoid svc_run(void);\fP .fi .IP 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 \fBsvc_getreq\fP(). Cette procédure est la plupart du temps en attente autour d'un appel système \fBselect\fP(2). .P .nf \fBbool_t svc_sendreply(SVCXPRT *\fP\fIxprt\fP\fB, xdrproc_t \fP\fIoutproc\fP\fB, char *\fP\fIout\fP\fB);\fP .fi .IP Appelée par une routine de distribution de services RPC pour envoyer le résultat d'un appel de procédure distante. L'argument \fIxprt\fP est le descripteur de transport associé à la requête, \fIoutproc\fP est la routine XDR utilisée pour encoder les résultats, et \fIout\fP est l'adresse des résultats. Cette routine renvoie 1 si elle réussit, et 0 sinon. .P .nf \fBvoid svc_unregister(unsigned long \fP\fIprognum\fP\fB, unsigned long \fP\fIversnum\fP\fB);\fP .fi .IP Supprimer toute association du doublet [\fIprognum\fP, \fIversnum\fP] vers les routines de distribution, et du triplet [\fIprognum\fP, \fIversnum\fP, \fI*\fP] vers le numéro de port. .P .nf \fBvoid svcerr_auth(SVCXPRT *\fP\fIxprt\fP\fB, enum auth_stat \fP\fIwhy\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid svcerr_decode(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP Appelée par une routine de distribution de service qui n'arrive pas à décoder ses arguments. Consultez aussi \fBsvc_getargs\fP(). .P .nf \fBvoid svcerr_noproc(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid svcerr_noprog(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid svcerr_progvers(SVCXPRT *\fP\fIxprt\fP\fB, unsigned long \fP\fIlow_vers\fP\fB,\fP \fB unsigned long \fP\fIhigh_vers\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid svcerr_systemerr(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid svcerr_weakauth(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP 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 \fBsvcerr_auth(xprt, AUTH_TOOWEAK)\fP. .P .nf \fBSVCXPRT *svcfd_create(int \fP\fIfd\fP\fB, unsigned int \fP\fIsendsize\fP\fB,\fP \fB unsigned int \fP\fIrecvsize\fP\fB);\fP .fi .IP Créer un service au\-dessus de n'importe quel descripteur ouvert. Typiquement ce descripteur de fichier est un socket connecté pour un protocole de flux comme TCP. \fIsendsize\fP et \fIrecvsize\fP indiquent les tailles pour les tampons d'émission et de réception. Si ces tailles valent zéro, une valeur optimale est choisie. .P .nf \fBSVCXPRT *svcraw_create(void);\fP .fi .IP Cette routine crée un simili transport de service RPC vers lequel il renvoie un pointeur. Le transport est en fait un tampon au sein de l'espace d'adressage du processus. Le client RPC correspondant doit donc résider dans le même espace d'adresse. Consultez \fBclntraw_create\fP(). 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. .P .nf \fBSVCXPRT *svctcp_create(int \fP\fIsock\fP\fB, unsigned int \fP\fIsend_buf_size\fP\fB,\fP \fB unsigned int \fP\fIrecv_buf_size\fP\fB);\fP .fi .IP Cette routine crée un transport de service RPC basé sur TCP/IP sur lequel elle renvoie un pointeur. Il est associé avec le socket \fIsock\fP, qui peut être \fBRPC_ANYSOCK\fP, auquel cas un nouveau socket est créé. Si le socket n'est pas associé à un port TCP local, cette routine l'associe à un port quelconque. Après réussite, \fIxprt\->xp_sock\fP est le descripteur du socket de transport, et \fIxprt\->xp_port\fP 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 définir la taille des tampons. Une taille nulle implique l'allocation automatique de tampons de tailles optimales. .P .nf \fBSVCXPRT *svcudp_bufcreate(int \fP\fIsock\fP\fB, unsigned int \fP\fIsendsize\fP\fB,\fP \fB unsigned int \fP\fIrecosize\fP\fB);\fP .fi .IP Cette routine crée un transport de service RPC basé sur UDP/IP et renvoie un pointeur dessus. Le transport est associé avec le socket \fIsock\fP, qui peut être \fBRPC_ANYSOCK\fP, auquel cas un nouveau socket est créé. Si le socket n'est pas associé à un port UDP local, cette routine l'associe à un port quelconque. Après réussite, \fIxprt\->xp_sock\fP est le descripteur de transport, et \fIxprt\->xp_port\fP est le numéro de port. Cette routine renvoie NULL si elle échoue. .IP 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. .P .nf \fBSVCXPRT *svcudp_create(int \fP\fIsock\fP\fB);\fP .fi .IP Cet appel est équivalent à \fIsvcudp_bufcreate(sock,SZ,SZ)\fP avec une taille \fISZ\fP par défaut. .P .nf \fBbool_t xdr_accepted_reply(XDR *\fP\fIxdrs\fP\fB, struct accepted_reply *\fP\fIar\fP\fB);\fP .fi .IP 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. .P .nf \fBbool_t xdr_authunix_parms(XDR *\fP\fIxdrs\fP\fB, struct authunix_parms *\fP\fIaupp\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid xdr_callhdr(XDR *\fP\fIxdrs\fP\fB, struct rpc_msg *\fP\fIchdr\fP\fB);\fP .fi .IP Utilisée pour créer les en\-tê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. .P .nf \fBbool_t xdr_callmsg(XDR *\fP\fIxdrs\fP\fB, struct rpc_msg *\fP\fIcmsg\fP\fB);\fP .fi .IP 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. .P .nf \fBbool_t xdr_opaque_auth(XDR *\fP\fIxdrs\fP\fB, struct opaque_auth *\fP\fIap\fP\fB);\fP .fi .IP 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. .P .nf \fBbool_t xdr_pmap(XDR *\fP\fIxdrs\fP\fB, struct pmap *\fP\fIregs\fP\fB);\fP .fi .IP Utilisée pour créer les paramètres des divers procédures \fBportmap\fP. Cette routine est utile pour les programmeurs qui désirent créer ces paramètres sans utiliser l'interface \fBpmap\fP. .P .nf \fBbool_t xdr_pmaplist(XDR *\fP\fIxdrs\fP\fB, struct pmaplist **\fP\fIrp\fP\fB);\fP .fi .IP 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 \fBpmap\fP. .P .nf \fBbool_t xdr_rejected_reply(XDR *\fP\fIxdrs\fP\fB, struct rejected_reply *\fP\fIrr\fP\fB);\fP .fi .IP 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. .P .nf \fBbool_t xdr_replymsg(XDR *\fP\fIxdrs\fP\fB, struct rpc_msg *\fP\fIrmsg\fP\fB);\fP .fi .IP 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. .P .nf \fBvoid xprt_register(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP 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 \fIsvc_fds\fP. L'implémentation d'un service ne nécessite pas cette routine habituellement. .P .nf \fBvoid xprt_unregister(SVCXPRT *\fP\fIxprt\fP\fB);\fP .fi .IP Avant qu'un descripteur RPC de transport soit détruit, il doit se désinscrire du service RPC. Cette routine modifie la variable globale \fIsvc_fds\fP. L'implémentation d'un service ne nécessite pas cette routine habituellement. .SH ATTRIBUTS Pour une explication des termes utilisés dans cette section, consulter \fBattributes\fP(7). .TS allbox; lbx lb lb l l l. Interface Attribut Valeur T{ .na .nh \fBauth_destroy\fP(), \fBauthnone_create\fP(), \fBauthunix_create\fP(), \fBauthunix_create_default\fP(), \fBcallrpc\fP(), \fBclnt_broadcast\fP(), \fBclnt_call\fP(), \fBclnt_destroy\fP(), \fBclnt_create\fP(), \fBclnt_control\fP(), \fBclnt_freeres\fP(), \fBclnt_geterr\fP(), \fBclnt_pcreateerror\fP(), \fBclnt_perrno\fP(), \fBclnt_perror\fP(), \fBclnt_spcreateerror\fP(), \fBclnt_sperrno\fP(), \fBclnt_sperror\fP(), \fBclntraw_create\fP(), \fBclnttcp_create\fP(), \fBclntudp_create\fP(), \fBclntudp_bufcreate\fP(), \fBget_myaddress\fP(), \fBpmap_getmaps\fP(), \fBpmap_getport\fP(), \fBpmap_rmtcall\fP(), \fBpmap_set\fP(), \fBpmap_unset\fP(), \fBregisterrpc\fP(), \fBsvc_destroy\fP(), \fBsvc_freeargs\fP(), \fBsvc_getargs\fP(), \fBsvc_getcaller\fP(), \fBsvc_getreqset\fP(), \fBsvc_getreq\fP(), \fBsvc_register\fP(), \fBsvc_run\fP(), \fBsvc_sendreply\fP(), \fBsvc_unregister\fP(), \fBsvcerr_auth\fP(), \fBsvcerr_decode\fP(), \fBsvcerr_noproc\fP(), \fBsvcerr_noprog\fP(), \fBsvcerr_progvers\fP(), \fBsvcerr_systemerr\fP(), \fBsvcerr_weakauth\fP(), \fBsvcfd_create\fP(), \fBsvcraw_create\fP(), \fBsvctcp_create\fP(), \fBsvcudp_bufcreate\fP(), \fBsvcudp_create\fP(), \fBxdr_accepted_reply\fP(), \fBxdr_authunix_parms\fP(), \fBxdr_callhdr\fP(), \fBxdr_callmsg\fP(), \fBxdr_opaque_auth\fP(), \fBxdr_pmap\fP(), \fBxdr_pmaplist\fP(), \fBxdr_rejected_reply\fP(), \fBxdr_replymsg\fP(), \fBxprt_register\fP(), \fBxprt_unregister\fP() T} Sécurité des threads MT\-Safe .TE .SH "VOIR AUSSI" .\" We don't have an rpc_secure.3 page in the set at the moment -- MTK, 19 Sep 05 .\" .BR rpc_secure (3), \fBxdr\fP(3) .P Les manuels suivants\ : .RS Remote Procedure Calls: Protocol Specification .br Remote Procedure Call Programming Guide .br rpcgen Programming Guide .br .RE .P \fIRPC: Remote Procedure Call Protocol Specification\fP, RFC\ 1050, Sun Microsystems, Inc., USC\-ISI. .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Christophe Blaess , Stéphan Rafin , Thierry Vignaud , François Micaux, Alain Portal , Jean-Philippe Guérard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas François , Florentin Duneau , Simon Paillard , Denis Barbier , David Prévot et Jean-Pierre Giraud . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .