perkamon - en to fr translation catalogue (215 entries)

note: type: TH
en: 2008-08-19
fr: 19 août 2008

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: getrpcent, getrpcbyname, getrpcbynumber, setrpcent, endrpcent - get RPC entry
fr: getrpcent, getrpcbyname, getrpcbynumber, setrpcent, endrpcent - Lire une entrée RPC

note: type: Plain text
en: The B<getrpcent>(), B<getrpcbyname>(), and B<getrpcbynumber>()  functions each return a pointer to an object with the following structure containing the broken-out fields of an entry in the RPC program number data base.
fr: Les fonctions B<getrpcent>(), B<getrpcbyname>() et B<getrpcbynumber>() renvoient chacune un pointeur sur un objet ayant la structure suivante et contenant les champs d'une entrée de la base de données d'un programme RPC.

note: type: Plain text
en: struct rpcent {
        char  *r_name;     /* name of server for this RPC program */
        char **r_aliases;  /* alias list */
        long   r_number;   /* RPC program number */
    };
fr: struct rpcent {
        char  *r_name;     /* nom du serveur pour ce programme RPC */
        char **r_aliases;  /* liste d'alias */
        long   r_number;   /* numéro de programme RPC */
    };

note: type: Plain text
en: The members of this structure are:
fr: Les membres de cette structure sont\ :

note: type: Plain text
en: The name of the server for this RPC program.
fr: Le nom du serveur pour ce programme RPC.

note: type: Plain text
en: A NULL-terminated list of alternate names for the RPC program.
fr: Une liste, terminée par NULL, d'alternatives pour le programme RPC.

note: type: Plain text
en: The RPC program number for this service.
fr: Le numéro de programme RPC pour ce service.

note: type: Plain text
en: The B<getrpcent>()  function reads the next entry from the database.  A connection is opened to the database if necessary.
fr: La fonction B<getrpcent>() lit l'entrée suivante de la base. Une connexion est créée si nécessaire.

note: type: Plain text
en: The B<setrpcent>()  function opens a connection to the database, and sets the next entry to the first entry.  If I<stayopen> is nonzero, then the connection to the database will not be closed between calls to one of the B<getrpc*>()  functions.
fr: La fonction B<setrpcent>() ouvre une connexion à une base de données et définit l'entrée suivante avec la première entrée. Si I<stayopen> est non nul, alors la connexion à la base n'est pas fermée entre deux appels aux fonctions B<getrpc*>().

note: type: Plain text
en: The B<endrpcent>()  function closes the connection to the database.
fr: B<endrpcent>() ferme la connexion à la base..

note: type: Plain text
en: The B<getrpcbyname>()  and B<getrpcbynumber>()  functions sequentially search from the beginning of the file until a matching RPC program name or program number is found, or until end-of-file is encountered.
fr: Les fonctions B<getrpcbyname>() et B<getrpcbynumber>() recherchent séquentiellement depuis le début du fichier un nom ou un numéro de programme RPC correspondant jusqu'à la fin du fichier.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: On success, B<getrpcent>(), B<getrpcbyname>(), and B<getrpcbynumber>()  return a pointer to a statically allocated I<rpcent> structure.  NULL is returned on EOF or error.
fr: En cas de succès, B<getrpcent>(), B<getrpcbyname>() et B<getrpcbynumber>() renvoient un pointeur vers une structure statiquement allouée I<rpcent>. Un pointeur NULL est renvoyé si une erreur se produit ou si la fin de fichier est atteinte.

note: type: SH
en: FILES
fr: FICHIERS

note: type: Plain text
en: RPC program number database.
fr: Base de données des numéros de programme RPC.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: Not in POSIX.1-2001.  Present on the BSDs, Solaris, and many other systems.
fr: Absent de POSIX.1-2001. Présent sur les systèmes BSD, Solaris et beaucoup d'autres.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: All information is contained in a static area so it must be copied if it is to be saved.
fr: Toutes les informations sont stockées dans une zone statique et doivent donc être copiées si on désire les conserver.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2010-09-10
fr: 10 septembre 2010

note: type: Plain text
en: getrpcent_r, getrpcbyname_r, getrpcbynumber_r - get RPC entry (reentrant)
fr: getrpcent_r, getrpcbyname_r, getrpcbynumber_r - Lire une entrée RPC (version réentrante)

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<getrpcent_r>(), B<getrpcbyname_r>(), B<getrpcbynumber_r>():
fr: B<getrpcent_r>(), B<getrpcbyname_r>(), B<getrpcbynumber_r>() :

note: type: Plain text
en: The B<getrpcent_r>(), B<getrpcbyname_r>(), and B<getrpcbynumber_r>()  functions are the reentrant equivalents of, respectively, B<getrpcent>(3), B<getrpcbyname>(3), and B<getrpcbynumber>(3).  They differ in the way that the I<rpcent> structure is returned, and in the function calling signature and return value.  This manual page describes just the differences from the nonreentrant functions.
fr: B<getrpcent_r>(), B<getrpcbyname_r>(), et B<getrpcbynumber_r>() sont les versions réentrantes, respectivement, de B<getrpcent>(3), B<getrpcbyname>(3), et B<getrpcbynumber>(3). Leurs signatures sont différentes et elles renvoient une structure I<rpcent>. Cette page de manuel décrit seulement les différences avec les versions non réentrantes.

note: type: Plain text
en: Instead of returning a pointer to a statically allocated I<rpcent> structure as the function result, these functions copy the structure into the location pointed to by I<result_buf>.
fr: Au lieu de renvoyer un pointeur vers une structure I<rpcent> statiquement allouée, ces fonctions copient la structure à l'adresse pointée par I<result_buf>.

note: I can find no information on the required/recommended buffer size; the nonreentrant functions use a 1024 byte buffer -- mtk. type: Plain text
en: The I<buf> array is used to store the string fields pointed to by the returned I<rpcent> structure.  (The nonreentrant functions allocate these strings in static storage.)  The size of this array is specified in I<buflen>.  If I<buf> is too small, the call fails with the error B<ERANGE>, and the caller must try again with a larger buffer.  (A buffer of length 1024 bytes should be sufficient for most applications.)
fr: Le tableau I<buf> est utilisé pour sauvegarder les champs de la chaîne pointée par la structure I<rpcent> renvoyée (les fonctions non réentrantes allouent ces chaînes de façon statique). La taille du tableau est spécifiée avec I<buflen>. Si I<buf> est trop petit, l'appel échoue avec l'erreur B<ERANGE>, et l'appelant doit essayer de nouveau avec un tableau plus grand (un tableau de 1024 octets est en général suffisant).

note: type: Plain text
en: If the function call successfully obtains an RPC record, then I<*result> is set pointing to I<result_buf>; otherwise, I<*result> is set to NULL.
fr: Si l'appel réussi à obtenir un enregistrement RPC, alors I<*result> pointe vers I<result_buf>, sinon I<*result> est défini à NULL.

note: type: Plain text
en: On success, these functions return 0.  On error, they return one of the positive error numbers listed in ERRORS.
fr: En cas de succès, ces fonctions renvoient zéro. En cas d'erreur, une valeur d'erreur positive listée dans ERREURS est renvoyée.

note: type: Plain text
en: On error, record not found (B<getrpcbyname_r>(), B<getrpcbynumber_r>()), or end of input (B<getrpcent_r>())  I<result> is set to NULL.
fr: En cas d'erreur, «\ enregistrement non trouvé\ » (B<getrpcbyname_r>(),B<getrpcbynumber_r>()) ou «\ fin de l'entrée\ » (B<getrpcent_r>()),I<result> est défini à NULL.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: (B<getrpcent_r>())  No more records in database.
fr: (B<getrpcent_r>()) Plus d'enregistrement dans la base.

note: type: Plain text
en: I<buf> is too small.  Try again with a larger buffer (and increased I<buflen>).
fr: I<buf> est trop petit. Ré-essayer avec un tampon plus grand (et augmentez I<buflen>).

note: type: Plain text
en: These functions are GNU extensions.  Functions with similar names exist on some other systems, though typically with different calling signatures.
fr: Ces fonctions sont des extensions GNU. Des fonctions avec des noms similaires existent sur d'autres systèmes, bien que en général avec des signatures d'appels différent.

note: type: TH
en: 2007-12-23
fr: 23 décembre 2007

note: type: Plain text
en: getrpcport - get RPC port number
fr: getrpcport - Renvoyer un numéro de port RPC

note: type: Plain text
en: B<getrpcport>()  returns the port number for version I<versnum> of the RPC program I<prognum> running on I<host> and using protocol I<proto>.  It returns 0 if it cannot contact the portmapper, or if I<prognum> is not registered.  If I<prognum> is registered but not with version I<versnum>, it will still return a port number (for some version of the program)  indicating that the program is indeed registered.  The version mismatch will be detected upon the first call to the service.
fr: B<getrpcport>() renvoie le numéro de port pour la version I<versnum> du programme RPC I<prognum> qui fonctionne sur la machine I<host> et utilisant le protocole I<proto>. Elle renvoie 0 s'il n'est pas possible de contacter le «\ portmapper\ », ou si I<prognum> n'est pas déclaré. Si I<prognum> est déclaré mais la version I<versnum> n'est pas celle employée, un numéro de port sera bien renvoyé (pour certaines versions du programme), indiquant que le programme est bien enregistré. L'erreur de version ne sera détectée qu'au premier appel à ce service.

note: type: TH
en: 2002-07-18
fr: 18 juillet 2002

note: type: Plain text
en: key_decryptsession, key_encryptsession, key_setsecret, key_gendes, key_secretkey_is_set - interfaces to rpc keyserver daemon
fr: key_decryptsession, key_encryptsession, key_setsecret, key_gendes, key_secretkey_is_set - Interface pour le démon générateur de clé RPC.

note: type: Plain text
en: B<int key_decryptsession(const char *>I<remotename>B<,> B<des_block *>I<deskey>B<);>
fr: B<int key_decryptsession(const char *>I<nom_distant>B<,> B<des_block *>I<cle_des>B<);>

note: type: Plain text
en: B<int key_encryptsession(const char *>I<remotename>B<,> B<des_block *>I<deskey>B<);>
fr: B<int key_encryptsession(const char *>I<nom_distant>B<,> B<des_block *>I<cle_des>B<);>

note: type: Plain text
en: B<int key_gendes(des_block *>I<deskey>B<);>
fr: B<int key_gendes(des_block *>I<cle_des>B<);>

note: type: Plain text
en: B<int key_setsecret(const char *>I<key>B<);>
fr: B<int key_setsecret(const char *>I<cle>B<);>

note: type: Plain text
en: The functions here are used within the RPC's secure authentication mechanism (AUTH_DES).  There should be no need for user programs to use this functions.
fr: Ces fonctions sont utilisées dans le mécanisme d'authentification des RPC sécurisées (AUTH_DES). Les programmes utilisateurs ne devraient pas en avoir besoin.

note: type: Plain text
en: The function B<key_decryptsession>()  uses the (remote) server netname and takes the DES key for decrypting.  It uses the public key of the server and the secret key associated with the effective UID of the calling process.
fr: La fonction B<key_decryptsession>() utilise le nom du serveur (distant) et effectue un décodage avec la clé DES transmise. Elle utilise la clé publique du serveur et la clé privée associée avec l'UID effectif du processus appelant.

note: type: Plain text
en: The function B<key_encryptsession>()  is the inverse of B<key_decryptsession>().  It encrypts the DES keys with the public key of the server and the secret key associated with the effective UID of the calling process.
fr: La fonction B<key_encryptsession>() est l'inverse de B<key_decryptsession>(). Elle crypte les clés DES avec la clé publique du serveur et la clé secrète associée à l'UID effectif du processus appelant.

note: type: Plain text
en: The function B<key_gendes>()  is used to ask the keyserver for a secure conversation key.
fr: La fonction B<key_gendes>() est utilisée pour demander à un serveur une clé de session sécurisée.

note: type: Plain text
en: The function B<key_setsecret>()  is used to set the key for the effective UID of the calling process.
fr: La fonction B<key_setsecret>() définit la clé associée à l'UID effectif du processus appelant.

note: type: Plain text
en: The function B<key_secretkey_is_set>()  can be used to determine whether a key has been set for the effective UID of the calling process.
fr: La fonction B<key_secretkey_is_set>() sert à savoir su une clé a été enregistrée pour l'UID effectif du processus appelant.

note: type: Plain text
en: These functions return 1 on success and 0 on failure.
fr: Ces fonctions renvoient 1 si elles réussissent et zéro si elles échouent.

note: type: Plain text
en: Note that we talk about two types of encryption here.  One is asymmetric using a public and secret key.  The other is symmetric, the 64-bit DES.
fr: Notez bien qu'il y a deux types de cryptage ici\ : l'un est asymétrique, avec une clé publique et une clé secrète. L'autre est symétrique, avec la clé DES 64-bits.

note: type: Plain text
en: These routines were part of the Linux/Doors-project, abandoned by now.
fr: Ces routines faisaient partie du projet Linux/Doors, à présent abandonné.

note: type: TH
en: 2013-09-26
fr: 26 septembre 2013

note: type: Plain text
en: rpc - library routines for remote procedure calls
fr: rpc - Bibliothèque de fonctions pour les appels de procédures à distance

note: type: SH
en: SYNOPSIS AND DESCRIPTION
fr: SYNOPSIS ET DESCRIPTION

note: .LP 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. type: Plain text
en: These routines allow C programs to make procedure calls on other machines across the network.  First, the client calls a procedure to send a data packet to the server.  Upon receipt of the packet, the server calls a dispatch routine to perform the requested service, and then sends back a reply.  Finally, the procedure call returns to the client.
fr: 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.

note: type: Plain text
en: To take use of these routines, include the header file I<E<lt>rpc/rpc.hE<gt>>.
fr: Pour utiliser ces routines, il faut inclure le fichier d'en-têtes I<E<lt>rpc/rpc.hE<gt>>.

note: type: Plain text
en: The prototypes below make use of the following types:
fr: Le prototype ci-dessous utilise les types suivants :

note: type: Plain text
en: See the header files for the declarations of the I<AUTH>, I<CLIENT>, I<SVCXPRT>, and I<XDR> types.
fr: Consultez les fichiers d'en-tête pour les déclarations des types I<AUTH>, I<CLIENT>, I<SVCXPRT> et I<XDR>.

note: type: Plain text
en: A macro that destroys the authentication information associated with I<auth>.  Destruction usually involves deallocation of private data structures.  The use of I<auth> is undefined after calling B<auth_destroy>().
fr: Cette macro détruit les informations d'authentification associée avec I<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 I<auth> après avoir invoqué B<auth_destroy>().

note: type: Plain text
en: Create and return an RPC authentication handle that passes nonusable authentication information with each remote procedure call.  This is the default authentication used by RPC.
fr: 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.

note: type: Plain text
en: Create and return an RPC authentication handle that contains authentication information.  The parameter I<host> is the name of the machine on which the information was created; I<uid> is the user's user ID; I<gid> is the user's current group ID; I<len> and I<aup_gids> refer to a counted array of groups to which the user belongs.  It is easy to impersonate a user.
fr: Crée et renvoie un descripteur d'authentification RPC UNIX, contenant des informations d'identification. L'argument I<host> est le nom de la machine sur laquelle l'information est créée. I<uid> est l'identification de l'utilisateur. I<gid> est l'identification du groupe de l'utilisateur. I<len> et I<aup_gids> concernent la table des groupes supplémentaires auxquels l'utilisateur appartient. On peut facilement se faire passer pour quelqu'un d'autre.

note: type: Plain text
en: Calls B<authunix_create>()  with the appropriate parameters.
fr: Appelle B<authunix_create>() avec les arguments appropriés.

note: type: Plain text
en: Call the remote procedure associated with I<prognum>, I<versnum>, and I<procnum> on the machine, I<host>.  The parameter I<in> is the address of the procedure's argument(s), and I<out> is the address of where to place the result(s); I<inproc> is used to encode the procedure's parameters, and I<outproc> is used to decode the procedure's results.  This routine returns zero if it succeeds, or the value of B<enum clnt_stat> cast to an integer if it fails.  The routine B<clnt_perrno>()  is handy for translating failure statuses into messages.
fr: Appelle la procédure distante associée aux arguments I<prognum>, I<versnum>, et I<procnum> sur la machine, I<host>. L'argument I<in> est l'adresse du ou des arguments d'entrée de la procédure, I<out> celle de l'emplacement où stocker le ou les résultats, I<inproc> sert à encoder les paramètres d'entrée de la procédure, et I<outproc> à décoder les résultats de la procédure. Cette routine renvoie zéro si elle réussit, ou la valeur de B<enum clnt_stat> transposée en un nombre entier si elle échoue La routine B<clnt_perrno>() permet de traduire les codes d'échec en messages.

note: type: Plain text
en: Warning: calling remote procedures with this routine uses UDP/IP as a transport; see B<clntudp_create>()  for restrictions.  You do not have control of timeouts or authentication using this routine.
fr: Attention\ : l'appel d'une procédure distante avec cette routine emploie le protocole UDP/IP pour le transport, consultez B<clntudp_create>() pour certaines restrictions. Vous n'avez aucun contrôle sur le délai maximal ou sur l'authentification avec cette routine.

note: type: Plain text
en: Like B<callrpc>(), except the call message is broadcast to all locally connected broadcast nets.  Each time it receives a response, this routine calls B<eachresult>(), whose form is:
fr: Comme B<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 B<eachresult>(), dont la forme est\ :

note: type: Plain text
en: where I<out> is the same as I<out> passed to B<clnt_broadcast>(), except that the remote procedure's output is decoded there; I<addr> points to the address of the machine that sent the results.  If B<eachresult>()  returns zero, B<clnt_broadcast>()  waits for more replies; otherwise it returns with appropriate status.
fr: où I<out> est du même type que le I<out> passé à B<clnt_broadcast>(), avec la différence que la sortie de la procédure distante est décodée ici. I<addr> pointe vers l'adresse de la machine qui a envoyé le résultat. Si B<eachresult>() renvoie zéro, B<clnt_broadcast>() attend d'autres réponses. Sinon elle revient avec le code de retour approprié.

note: type: Plain text
en: Warning: broadcast sockets are limited in size to the maximum transfer unit of the data link.  For ethernet, this value is 1500 bytes.
fr: 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.

note: type: Plain text
en: A macro that calls the remote procedure I<procnum> associated with the client handle, I<clnt>, which is obtained with an RPC client creation routine such as B<clnt_create>().  The parameter I<in> is the address of the procedure's argument(s), and I<out> is the address of where to place the result(s); I<inproc> is used to encode the procedure's parameters, and I<outproc> is used to decode the procedure's results; I<tout> is the time allowed for results to come back.
fr: Une macro qui appelle la procédure distante I<procnum> associée avec le descripteur de client I<clnt>, qui est obtenu grâce à une routine de création de client RPC comme B<clnt_create>(). L'argument I<in> est l'adresse du ou des arguments d'entrée de la procédure, I<out> celle de l'emplacement où stocker le ou les résultats, I<inproc> sert à encoder les paramètres d'entrée de la procédure, et I<outproc> à décoder les résultats de la procédure. I<tout> est le délai maximal accordé pour la réalisation de la procédure.

note: type: Plain text
en: A macro that destroys the client's RPC handle.  Destruction usually involves deallocation of private data structures, including I<clnt> itself.  Use of I<clnt> is undefined after calling B<clnt_destroy>().  If the RPC library opened the associated socket, it will close it also.  Otherwise, the socket remains open.
fr: 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 I<clnt> lui-même. Le comportement est indéfini si on tente d'utiliser I<clnt> après avoir appelé B<clnt_destroy>(). Si la bibliothèque RPC avait ouvert la socket associée, elle sera également fermée. Sinon, la socket reste ouverte.

note: type: Plain text
en: Generic client creation routine.  I<host> identifies the name of the remote host where the server is located.  I<proto> indicates which kind of transport protocol to use.  The currently supported values for this field are \(lqudp\(rq and \(lqtcp\(rq.  Default timeouts are set, but can be modified using B<clnt_control>().
fr: Routine générique de création de client. I<host> identifie le nom de l'hôte distant où se trouve le serveur. I<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 B<clnt_control>().

note: type: Plain text
en: Warning: Using UDP has its shortcomings.  Since UDP-based RPC messages can hold only up to 8 Kbytes of encoded data, this transport cannot be used for procedures that take large arguments or return huge results.
fr: 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.

note: type: Plain text
en: A macro used to change or retrieve various information about a client object.  I<req> indicates the type of operation, and I<info> is a pointer to the information.  For both UDP and TCP, the supported values of I<req> and their argument types and what they do are:
fr: Une macro employée pour modifier ou récupérer des informations diverses à propos d'un objet client. I<req> indique le type d'opération, et I<info> est un pointeur sur l'information. Pour UDP comme pour TCP, les valeurs autorisées pour I<req> et le type des arguments sont\ :

note: type: Plain text
en: B<CLSET_TIMEOUT>  I<struct timeval> // set total timeout
    B<CLGET_TIMEOUT>  I<struct timeval> // get total timeout
fr: B<CLSET_TIMEOUT>  I<struct timeval> // définir le délai total
    B<CLGET_TIMEOUT>  I<struct timeval> // lire le délai total

note: type: Plain text
en: Note: if you set the timeout using B<clnt_control>(), the timeout parameter passed to B<clnt_call>()  will be ignored in all future calls.
fr: Note\ : Si vous définissez le délai avec B<clnt_control>(), le dernier argument de B<clnt_call>() sera ignoré lors des appels ultérieurs.

note: type: Plain text
en: B<CLGET_SERVER_ADDR>  I<struct sockaddr_in > // get server's address
fr: B<CLGET_SERVER_ADDR>  I<struct sockaddr_in > // lire l'adresse du serveur

note: type: Plain text
en: The following operations are valid for UDP only:
fr: Les opérations suivantes sont valides pour le protocole UDP seulement\ :

note: type: Plain text
en: B<CLSET_RETRY_TIMEOUT>  I<struct timeval> // set the retry timeout
    B<CLGET_RETRY_TIMEOUT>  I<struct timeval> // get the retry timeout
fr: B<CLSET_RETRY_TIMEOUT>  I<struct timeval> // définir le délai de répétition
    B<CLGET_RETRY_TIMEOUT>  I<struct timeval> // lire le délai de répétition

note: type: Plain text
en: The retry timeout is the time that "UDP RPC" waits for the server to reply before retransmitting the request.
fr: 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.

note: type: Plain text
en: A macro that frees any data allocated by the RPC/XDR system when it decoded the results of an RPC call.  The parameter I<out> is the address of the results, and I<outproc> is the XDR routine describing the results.  This routine returns one if the results were successfully freed, and zero otherwise.
fr: 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 I<out> est l'adresse des résultats, et I<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.

note: type: Plain text
en: A macro that copies the error structure out of the client handle to the structure at address I<errp>.
fr: Une macro qui copie la structure d'erreur depuis le descripteur de client vers la structure se trouvant à l'adresse I<errp>.

note: type: Plain text
en: Print a message to standard error indicating why a client RPC handle could not be created.  The message is prepended with string I<s> and a colon.  Used when a B<clnt_create>(), B<clntraw_create>(), B<clnttcp_create>(), or B<clntudp_create>()  call fails.
fr: 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 I<s> et un deux-points est inséré. À utiliser lorsque les appels B<clnt_create>(), B<clntraw_create>(), B<clnttcp_create>() ou B<clntudp_create>() échouent.

note: type: Plain text
en: Print a message to standard error corresponding to the condition indicated by I<stat>.  Used after B<callrpc>().
fr: Affiche un message sur la sortie d'erreur standard, correspondant à la condition indiquée par I<stat>. À utiliser après B<callrpc>().

note: type: Plain text
en: Print a message to standard error indicating why an RPC call failed; I<clnt> is the handle used to do the call.  The message is prepended with string I<s> and a colon.  Used after B<clnt_call>().
fr: Affiche un message sur la sortie d'erreur standard indiquant pourquoi un appel RPC a échoué. I<clnt> est le descripteur utilisé pour l'appel. Ce message est préfixé avec la chaîne I<s> et un deux-points est inséré. À utiliser après B<clnt_call>().

note: type: Plain text
en: Like B<clnt_pcreateerror>(), except that it returns a string instead of printing to the standard error.
fr: Comme B<clnt_pcreateerror>(), sauf qu'il renvoie une chaîne au lieu d'écrire sur la sortie d'erreur standard.

note: type: Plain text
en: Bugs: returns pointer to static data that is overwritten on each call.
fr: Danger\ : renvoie un pointeur vers une zone de donnée statique, écrasée à chaque appel.

note: type: Plain text
en: Take the same arguments as B<clnt_perrno>(), but instead of sending a message to the standard error indicating why an RPC call failed, return a pointer to a string which contains the message.  The string ends with a NEWLINE.
fr: Emploie les même arguments que B<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.

note: type: Plain text
en: B<clnt_sperrno>()  is used instead of B<clnt_perrno>()  if the program does not have a standard error (as a program running as a server quite likely does not), or if the programmer does not want the message to be output with B<printf>(3), or if a message format different than that supported by B<clnt_perrno>()  is to be used.  Note: unlike B<clnt_sperror>()  and B<clnt_spcreaterror>(), B<clnt_sperrno>()  returns pointer to static data, but the result will not get overwritten on each call.
fr: B<clnt_sperrno>() est utilisée à la place de B<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 B<printf>(3), ou si un format de message différent de celui fourni par B<clnt_perrno>() doit être utilisé. Note\ : contrairement à B<clnt_sperror>() et B<clnt_spcreaterror>(), B<clnt_sperrno>() renvoie un pointeur sur une zone de donnée statique, mais le résultat ne sera pas écrasé à chaque appel.

note: type: Plain text
en: Like B<clnt_perror>(), except that (like B<clnt_sperrno>())  it returns a string instead of printing to standard error.
fr: Comme B<clnt_perror>(), sauf que (comme B<clnt_sperrno>()) il renvoie une chaîne au lieu d'écrire sur la sortie d'erreur standard.

note: type: Plain text
en: This routine creates a toy RPC client for the remote program I<prognum>, version I<versnum>.  The transport used to pass messages to the service is actually a buffer within the process's address space, so the corresponding RPC server should live in the same address space; see B<svcraw_create>().  This allows simulation of RPC and acquisition of RPC overheads, such as round trip times, without any kernel interference.  This routine returns NULL if it fails.
fr: Cette routine crée un simili client RPC pour le programme distant I<prognum>, de version I<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. Consultez B<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.

note: The following inline font conversion is necessary for the hyphen indicator type: Plain text
en: This routine creates an RPC client for the remote program I<prognum>, version I<versnum>; the client uses TCP/IP as a transport.  The remote program is located at Internet address I<*addr>.  If I<addr-E<gt>sin_port> is zero, then it is set to the actual port that the remote program is listening on (the remote B<portmap> service is consulted for this information).  The parameter I<sockp> is a socket; if it is B<RPC_ANYSOCK>, then this routine opens a new one and sets I<sockp>.  Since TCP-based RPC uses buffered I/O, the user may specify the size of the send and receive buffers with the parameters I<sendsz> and I<recvsz>; values of zero choose suitable defaults.  This routine returns NULL if it fails.
fr: Cette routine crée un client RPC pour le programme distant I<prognum>, de version I<versnum>\ ; Le client utilise TCP/IP pour le transport. Le programme distant se trouve à l'adresse Internet I<*addr>. Si I<addr-E<gt>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 B<portmap> distant pour obtenir cette information). L'argument I<sockp> est une socket; si c'est B<RPC_ANYSOCK>, alors la routine ouvre une nouvelle socket et remplit I<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 I<sendsz> et I<recvsz>. Des valeurs nulles réclament l'utilisation de tampons de tailles optimales. Cette routine renvoie NULL si elle échoue.

note: type: Plain text
en: This routine creates an RPC client for the remote program I<prognum>, version I<versnum>; the client uses use UDP/IP as a transport.  The remote program is located at Internet address I<addr>.  If I<addr-E<gt>sin_port> is zero, then it is set to actual port that the remote program is listening on (the remote B<portmap> service is consulted for this information).  The parameter I<sockp> is a socket; if it is B<RPC_ANYSOCK>, then this routine opens a new one and sets I<sockp>.  The UDP transport resends the call message in intervals of I<wait> time until a response is received or until the call times out.  The total time for the call to time out is specified by B<clnt_call>().
fr: Cette routine crée un client RPC pour le programme distant I<prognum>, de version I<versnum>\ ; Le client utilise UDP/IP pour le transport. Le programme distant se trouve à l'adresse Internet I<addr>. Si I<addr-E<gt>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 B<portmap> distant pour obtenir cette information). L'argument I<sockp> est une socket; si c'est B<RPC_ANYSOCK>, alors la routine ouvre une nouvelle socket et remplit I<sockp>. Le protocole de transport UDP renvoie le message d'appel avec un intervalle de temps indiqué par B<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 B<clnt_call>().

note: type: Plain text
en: Warning: since UDP-based RPC messages can hold only up to 8 Kbytes of encoded data, this transport cannot be used for procedures that take large arguments or return huge results.
fr: 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.

note: type: Plain text
en: This routine creates an RPC client for the remote program I<prognum>, on I<versnum>; the client uses use UDP/IP as a transport.  The remote program is located at Internet address I<addr>.  If I<addr-E<gt>sin_port> is zero, then it is set to actual port that the remote program is listening on (the remote B<portmap> service is consulted for this information).  The parameter I<sockp> is a socket; if it is B<RPC_ANYSOCK>, then this routine opens a new one and sets I<sockp>.  The UDP transport resends the call message in intervals of I<wait> time until a response is received or until the call times out.  The total time for the call to time out is specified by B<clnt_call>().
fr: Cette routine crée un client RPC pour le programme distant I<prognum>, de version I<versnum>\ ; Le client utilise UDP/IP pour le transport. Le programme distant se trouve à l'adresse Internet I<addr>. Si I<addr-E<gt>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 B<portmap> distant pour obtenir cette information). L'argument I<sockp> est une socket; si c'est B<RPC_ANYSOCK>, alors la routine ouvre une nouvelle socket et remplit I<sockp>. Le protocole de transport UDP renvoie le message d'appel avec un intervalle de temps indiqué par B<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 B<clnt_call>().

note: type: Plain text
en: This allows the user to specify the maximum packet size for sending and receiving UDP-based RPC messages.
fr: 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.

note: type: Plain text
en: Stuff the machine's IP address into I<*addr>, without consulting the library routines that deal with I</etc/hosts>.  The port number is always set to B<htons(PMAPPORT)>.
fr: Fournit l'adresse IP de la machine dans la structure I<*addr>, sans consulter les routines de bibliothèques qui manipulent I</etc/hosts>. Le numéro de port est toujours rempli avec B<htons(PMAPPORT)>.

note: type: Plain text
en: A user interface to the B<portmap> service, which returns a list of the current RPC program-to-port mappings on the host located at IP address I<*addr>.  This routine can return NULL.  The command I<rpcinfo\ -p> uses this routine.
fr: Une interface utilisateur pour le service B<portmap> renvoyant une liste des associations en cours entre programmes RPC et ports sur l'hôte situé à l'adresse IP indiquée dans I<*addr>. Cette routine peut renvoyer NULL. La commande «\ B<rpcinfo -p>\ » utilise cette fonction

note: type: Plain text
en: A user interface to the B<portmap> service, which returns the port number on which waits a service that supports program number I<prognum>, version I<versnum>, and speaks the transport protocol associated with I<protocol>.  The value of I<protocol> is most likely B<IPPROTO_UDP> or B<IPPROTO_TCP>.  A return value of zero means that the mapping does not exist or that the RPC system failed to contact the remote B<portmap> service.  In the latter case, the global variable I<rpc_createerr> contains the RPC status.
fr: Une interface utilisateur pour le service B<portmap> qui renvoie le numéro de port sur lequel est en écoute le service associé au programme numéro I<prognum>, de version I<versnum>, en utilisant le protocole de transport associé avec I<protocol>. La valeur de l'argument I<protocol> est normalement B<IPPROTO_UDP> ou B<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 B<portmap> distant. Dans ce cas, la variable globale I<rpc_createerr> contient le code RPC de l'erreur.

note: type: Plain text
en: A user interface to the B<portmap> service, which instructs B<portmap> on the host at IP address I<*addr> to make an RPC call on your behalf to a procedure on that host.  The parameter I<*portp> will be modified to the program's port number if the procedure succeeds.  The definitions of other parameters are discussed in B<callrpc>()  and B<clnt_call>().  This procedure should be used for a \(lqping\(rq and nothing else.  See also B<clnt_broadcast>().
fr: Une interface utilisateur pour le service B<portmap> qui demande au programme B<portmap> sur l'hôte se trouvant à l'adresse IP indiquée dans I<*addr> de faire en notre nom un appel RPC pour une procédure se trouvant sur cet hôte. Le paramètre I<*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 B<callrpc>() et de B<clnt_call>(). Cette procédure devrait être utilisée pour faire un «\ ping\ » et rien d'autre. Consultez aussi B<clnt_broadcast>().

note: type: Plain text
en: A user interface to the B<portmap> service, which establishes a mapping between the triple [I<prognum>,I<versnum>,I<protocol>] and I<port> on the machine's B<portmap> service.  The value of I<protocol> is most likely B<IPPROTO_UDP> or B<IPPROTO_TCP>.  This routine returns one if it succeeds, zero otherwise.  Automatically done by B<svc_register>().
fr: Une interface utilisateur pour le service B<portmap> qui établit une association entre le triplet [I<prognum>, I<versnum>, I<protocol>] et le I<port> sur la machine du service B<portmap> La valeur du I<protocol> est normalement B<IPPROTO_UDP> ou B<IPPROTO_TCP>. Cette routine renvoie 1 si elle réussit, et zéro sinon. Elle est automatiquement invoquée par B<svc_register>().

note: type: Plain text
en: A user interface to the B<portmap> service, which destroys all mapping between the triple [I<prognum>,I<versnum>,I<*>] and B<ports> on the machine's B<portmap> service.  This routine returns one if it succeeds, zero otherwise.
fr: Une interface utilisateur vers le service B<portmap> qui détruit toute association entre le triplet [I<prognum>, I<versnum>, I<*>] et les B<ports> de la machine où se trouve le service B<portmap>. Cette routine renvoie 1 si elle réussit, et zéro sinon.

note: type: Plain text
en: Register procedure I<procname> with the RPC service package.  If a request arrives for program I<prognum>, version I<versnum>, and procedure I<procnum>, I<procname> is called with a pointer to its parameter(s); I<progname> should return a pointer to its static result(s); I<inproc> is used to decode the parameters while I<outproc> is used to encode the results.  This routine returns zero if the registration succeeded, -1 otherwise.
fr: Enregistre la procédure I<procname> avec le service RPC. Si une requête arrive pour le programme I<prognum>, de version I<versnum>, et pour la procédure I<procnum>, I<procname> sera appelée avec un pointeur vers ses paramètres d'entrée. I<progname> doit renvoyer un pointeur vers ses résultats statiques. I<inproc> est utilisée pour décoder les paramètres d'entrée alors que I<outproc> sert à encode les résultats. Cette routine renvoie zéro si l'enregistrement à réussi, et -1 sinon.

note: type: Plain text
en: Warning: remote procedures registered in this form are accessed using the UDP/IP transport; see B<svcudp_create>()  for restrictions.
fr: Attention\ : les procédures enregistrées de cette manière sont accessibles avec le protocole de transport UDP/IP. Consultez B<svcudp_create>() pour ses restrictions.

note: type: Plain text
en: A global variable whose value is set by any RPC client creation routine that does not succeed.  Use the routine B<clnt_pcreateerror>()  to print the reason why.
fr: Une variable globale dont la valeur est définie par toute routine SM RPC de création de client qui échoue. Utilisez la routine B<clnt_pcreateerror>() pour afficher la raison de l'échec.

note: type: Plain text
en: A macro that destroys the RPC service transport handle, I<xprt>.  Destruction usually involves deallocation of private data structures, including I<xprt> itself.  Use of I<xprt> is undefined after calling this routine.
fr: Une macro qui détruit le descripteur de transport RPC I<xprt>. La destruction implique normalement la libération de structures de données privées, y compris I<xprt> lui-même. Le comportement est indéfini si on essaye d'utiliser I<xprt> après avoir appelé cette routine.

note: type: Plain text
en: A global variable reflecting the RPC service side's read file descriptor bit mask; it is suitable as a parameter to the B<select>(2)  system call.  This is of interest only if a service implementor does their own asynchronous event processing, instead of calling B<svc_run>().  This variable is read-only (do not pass its address to B<select>(2)!), yet it may change after calls to B<svc_getreqset>()  or any creation routines.
fr: 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 B<select>(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 B<svc_run>(). Cette variable est en lecture seule (ne passez pas son adresse à B<select>(2) !), et elle peut changer après un appel B<svc_getreqset>() ou une routine de création.

note: type: Plain text
en: Similar to B<svc_fdset>, but limited to 32 descriptors.  This interface is obsoleted by B<svc_fdset>.
fr: Similaire à B<svc_fdset>, mais limitée à 32 descripteurs. Cette interface est rendue obsolète par B<svc_fdset>.

note: type: Plain text
en: A macro that frees any data allocated by the RPC/XDR system when it decoded the arguments to a service procedure using B<svc_getargs>().  This routine returns 1 if the results were successfully freed, and zero otherwise.
fr: 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 B<svc_getargs>(). Cette routine renvoie 1 si les arguments ont été correctement libérés, et zéro sinon.

note: type: Plain text
en: A macro that decodes the arguments of an RPC request associated with the RPC service transport handle, I<xprt>.  The parameter I<in> is the address where the arguments will be placed; I<inproc> is the XDR routine used to decode the arguments.  This routine returns one if decoding succeeds, and zero otherwise.
fr: Une macro qui décode les arguments d'une requête RPC associée avec le descripteur de transport RPC I<xprt>. L'argument I<in> est l'adresse où les arguments seront stockés, I<inproc> est la routine XDR pour décoder les arguments. Cette routine renvoie 1 si le décodage réussit, et zéro sinon.

note: type: Plain text
en: The approved way of getting the network address of the caller of a procedure associated with the RPC service transport handle, I<xprt>.
fr: 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 I<xprt>.

note: type: Plain text
en: This routine is of interest only if a service implementor does not call B<svc_run>(), but instead implements custom asynchronous event processing.  It is called when the B<select>(2)  system call has determined that an RPC request has arrived on some RPC socket(s); I<rdfds> is the resultant read file descriptor bit mask.  The routine returns when all sockets associated with the value of I<rdfds> have been serviced.
fr: Cette routine n'est intéressante que si l'implémentation d'un service n'appelle pas B<svc_run>(), mais emploie à la place un traitement personnalisé des événements asynchrones. On l'invoque lorsque l'appel système B<select>(2) a déterminé qu'une requête RPC est arrivée sur l'une des sockets RPC. I<rdfds> est le masque de bits des descripteurs de fichier en résultant. La routine revient lorsque toutes les sockets associées avec les valeurs de I<rdfds> ont été servies.

note: type: Plain text
en: Similar to B<svc_getreqset>(), but limited to 32 descriptors.  This interface is obsoleted by B<svc_getreqset>().
fr: Similaire à B<svc_getreqset>(), mais limitée à 32 descripteurs. Cette interface est rendue obsolète par B<svc_getreqset>().

note: type: Plain text
en: Associates I<prognum> and I<versnum> with the service dispatch procedure, I<dispatch>.  If I<protocol> is zero, the service is not registered with the B<portmap> service.  If I<protocol> is nonzero, then a mapping of the triple [I<prognum>,I<versnum>,I<protocol>] to I<xprt-E<gt>xp_port> is established with the local B<portmap> service (generally I<protocol> is zero, B<IPPROTO_UDP> or B<IPPROTO_TCP>).  The procedure I<dispatch> has the following form:
fr: Associer I<prognum> et I<versnum> avec la procédure de distribution I<dispatch>. Si I<protocol> vaut zéro, le service n'est pas enregistré avec le service B<portmap>. Si I<protocol> est non-nul, alors l'association entre le triplet [I<prognum>,I<versnum>,I<protocol>] et I<xprt-E<gt>xp_port> est établie par l'intermédiaire du service B<portmap> local (en général I<protocol> vaut zéro, B<IPPROTO_UDP> ou B<IPPROTO_TCP>). La procédure I<dispatch> a la forme suivante

note: type: Plain text
en: The B<svc_register>()  routine returns one if it succeeds, and zero otherwise.
fr: La routine B<svc_register>() renvoie 1 si elle réussit et 0 sinon.

note: type: Plain text
en: This routine never returns.  It waits for RPC requests to arrive, and calls the appropriate service procedure using B<svc_getreq>()  when one arrives.  This procedure is usually waiting for a B<select>(2)  system call to return.
fr: 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 B<svc_getreq>(). Cette procédure est la plupart du temps en attente autour d'un appel système B<select>(2).

note: type: Plain text
en: Called by an RPC service's dispatch routine to send the results of a remote procedure call.  The parameter I<xprt> is the request's associated transport handle; I<outproc> is the XDR routine which is used to encode the results; and I<out> is the address of the results.  This routine returns one if it succeeds, zero otherwise.
fr: Appelée par une routine de distribution de services RPC pour envoyer le résultat d'un appel de procédure distante. L'argument I<xprt> est le descripteur de transport associé à la requête, I<outproc> est la routine XDR utilisée pour encoder les résultats, et I<out> est l'adresse des résultats. Cette routine renvoie 1 si elle réussit, et 0 sinon.

note: type: Plain text
en: Remove all mapping of the double [I<prognum>,I<versnum>] to dispatch routines, and of the triple [I<prognum>,I<versnum>,I<*>] to port number.
fr: Supprimer toute association du doublet [I<prognum>, I<versnum>] vers les routines de distribution, et du triplet [I<prognum>, I<versnum>, I<*>] vers le numéro de port.

note: type: Plain text
en: Called by a service dispatch routine that refuses to perform a remote procedure call due to an authentication error.
fr: 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.

note: type: Plain text
en: Called by a service dispatch routine that cannot successfully decode its parameters.  See also B<svc_getargs>().
fr: Appelée par une routine de distribution de service qui n'arrive pas à décoder ses arguments. Consultez aussi B<svc_getargs>().

note: type: Plain text
en: Called by a service dispatch routine that does not implement the procedure number that the caller requests.
fr: 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.

note: type: Plain text
en: Called when the desired program is not registered with the RPC package.  Service implementors usually do not need this routine.
fr: 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.

note: type: Plain text
en: Called when the desired version of a program is not registered with the RPC package.  Service implementors usually do not need this routine.
fr: 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.

note: type: Plain text
en: Called by a service dispatch routine when it detects a system error not covered by any particular protocol.  For example, if a service can no longer allocate storage, it may call this routine.
fr: 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.

note: type: Plain text
en: Called by a service dispatch routine that refuses to perform a remote procedure call due to insufficient authentication parameters.  The routine calls B<svcerr_auth(xprt, AUTH_TOOWEAK)>.
fr: 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 B<svcerr_auth(xprt, AUTH_TOOWEAK)>.

note: type: Plain text
en: Create a service on top of any open descriptor.  Typically, this descriptor is a connected socket for a stream protocol such as TCP.  I<sendsize> and I<recvsize> indicate sizes for the send and receive buffers.  If they are zero, a reasonable default is chosen.
fr: Créer un service au-dessus de n'importe quel descripteur ouvert. Typiquement ces descripteurs sont des sockets pour un protocole connecté comme TCP. I<sendsize> et I<recvsize> indiquent les tailles pour les tampons d'émission et de réception. Si ces tailles valent zéro, une valeur optimale est choisie.

note: type: Plain text
en: This routine creates a toy RPC service transport, to which it returns a pointer.  The transport is really a buffer within the process's address space, so the corresponding RPC client should live in the same address space; see B<clntraw_create>().  This routine allows simulation of RPC and acquisition of RPC overheads (such as round trip times), without any kernel interference.  This routine returns NULL if it fails.
fr: 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 B<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.

note: type: Plain text
en: This routine creates a TCP/IP-based RPC service transport, to which it returns a pointer.  The transport is associated with the socket I<sock>, which may be B<RPC_ANYSOCK>, in which case a new socket is created.  If the socket is not bound to a local TCP port, then this routine binds it to an arbitrary port.  Upon completion, I<xprt-E<gt>xp_sock> is the transport's socket descriptor, and I<xprt-E<gt>xp_port> is the transport's port number.  This routine returns NULL if it fails.  Since TCP-based RPC uses buffered I/O, users may specify the size of buffers; values of zero choose suitable defaults.
fr: 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 I<sock>, qui peut être B<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, I<xprt-E<gt>xp_sock> est le descripteur de la socket de transport, et I<xprt-E<gt>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 définir la taille des tampons. Une taille nulle implique l'allocation automatique de tampons de tailles optimales.

note: type: Plain text
en: This routine creates a UDP/IP-based RPC service transport, to which it returns a pointer.  The transport is associated with the socket I<sock>, which may be B<RPC_ANYSOCK>, in which case a new socket is created.  If the socket is not bound to a local UDP port, then this routine binds it to an arbitrary port.  Upon completion, I<xprt-E<gt>xp_sock> is the transport's socket descriptor, and I<xprt-E<gt>xp_port> is the transport's port number.  This routine returns NULL if it fails.
fr: 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 I<sock>, qui peut être B<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, I<xprt-E<gt>xp_sock> est le descripteur de transport, et I<xprt-E<gt>xp_port> est le numéro de port. Cette routine renvoie NULL si elle échoue.

note: type: Plain text
en: This call is equivalent to I<svcudp_bufcreate(sock,SZ,SZ)> for some default size I<SZ>.
fr: Cet appel est équivalent à I<svcudp_bufcreate(sock,SZ,SZ)> avec une taille I<SZ> par défaut.

note: type: Plain text
en: Used for encoding RPC reply messages.  This routine is useful for users who wish to generate RPC-style messages without using the RPC package.
fr: 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.

note: type: Plain text
en: Used for describing UNIX credentials.  This routine is useful for users who wish to generate these credentials without using the RPC authentication package.
fr: 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.

note: type: Plain text
en: Used for describing RPC call header messages.  This routine is useful for users who wish to generate RPC-style messages without using the RPC package.
fr: 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.

note: type: Plain text
en: Used for describing RPC call messages.  This routine is useful for users who wish to generate RPC-style messages without using the RPC package.
fr: 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.

note: type: Plain text
en: Used for describing RPC authentication information messages.  This routine is useful for users who wish to generate RPC-style messages without using the RPC package.
fr: 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.

note: type: Plain text
en: Used for describing parameters to various B<portmap> procedures, externally.  This routine is useful for users who wish to generate these parameters without using the B<pmap> interface.
fr: Utilisée pour créer les paramètres des divers procédures B<portmap>. Cette routine est utile pour les programmeurs qui désirent créer ces paramètres sans utiliser l'interface B<pmap>.

note: type: Plain text
en: Used for describing a list of port mappings, externally.  This routine is useful for users who wish to generate these parameters without using the B<pmap> interface.
fr: 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 B<pmap>.

note: type: Plain text
en: Used for describing RPC reply messages.  This routine is useful for users who wish to generate RPC-style messages without using the RPC package.
fr: 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.

note: type: Plain text
en: Used for describing RPC reply messages.  This routine is useful for users who wish to generate RPC style messages without using the RPC package.
fr: 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.

note: type: Plain text
en: After RPC service transport handles are created, they should register themselves with the RPC service package.  This routine modifies the global variable I<svc_fds>.  Service implementors usually do not need this routine.
fr: 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 I<svc_fds>. L'implémentation d'un service ne nécessite pas cette routine habituellement.

note: type: Plain text
en: Before an RPC service transport handle is destroyed, it should unregister itself with the RPC service package.  This routine modifies the global variable I<svc_fds>.  Service implementors usually do not need this routine.
fr: Avant qu'un descripteur RPC de transport soit détruit, il doit se désinscrire du service RPC. Cette routine modifie la variable globale I<svc_fds>. L'implémentation d'un service ne nécessite pas cette routine habituellement.

note: type: Plain text
en: The following manuals:
fr: Les manuels suivants\ :

note: type: TH
en: 1985-09-26
fr: 26 septembre 1985

note: type: Plain text
en: rpc - RPC program number data base
fr: rpc - Base de données des numéros de programmes RPC

note: type: Plain text
en: The I<rpc> file contains user readable names that can be used in place of RPC program numbers.  Each line has the following information:
fr: Le fichier I<rpc> contient une liste de noms lisibles par tous les utilisateurs pouvant être employés à la place des numéros de programmes RPC. Chaque ligne contient les informations suivantes\ :

note: type: Plain text
en: name of server for the RPC program
fr: nom du serveur pour le programme RPC

note: type: Plain text
en: RPC program number
fr: numéro du programme RPC

note: type: Plain text
en: aliases
fr: alias

note: type: Plain text
en: Items are separated by any number of blanks and/or tab characters.  A \(aq#\(aq indicates the beginning of a comment; characters from the \(aq#\(aq to the end of the line are not interpreted by routines which search the file.
fr: Les champs sont séparés par n'importe quel nombre de blancs et/ou de tabulations. Un «\ #\ » indique le début d'un commentaire\ ; les caractères suivants jusqu'à la fin de la ligne ne seront pas interprétés par les routines chargées d'analyser ce fichier.

note: type: Plain text
en: Here is an example of the I</etc/rpc> file from the Sun RPC Source distribution.
fr: Voici un exemple du fichier I</etc/rpc> venant de la distribution RPC de Sun.

note: type: Plain text
en: RPC program number data base
fr: Base de données des numéros de programmes RPC.

note: type: TH
en: 2014-01-05
fr: 5 janvier 2014

note: type: Plain text
en: rtime - get time from a remote machine
fr: rtime - Lire l'heure sur un serveur distant

note: type: Plain text
en: This function uses the Time Server Protocol as described in RFC\ 868 to obtain the time from a remote machine.
fr: Cette fonction utilise le protocole Time Serveur décrit dans la RFC\ 868 pour lire l'heure sur une machine distante.

note: type: Plain text
en: The Time Server Protocol gives the time in seconds since 00:00:00 UTC, 1 Jan 1900, and this function subtracts the appropriate constant in order to convert the result to seconds since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: Le protocole Time Serveur donne l'heure en secondes écoulées depuis le 1er janvier 1900 à 00:00:00 UTC, et cette fonction soustrait la constante nécessaire pour convertir le résultat en secondes écoulées depuis l'époque, 1er\ janvier 1970 à\ 00:00:00 (UTC).

note: type: Plain text
en: When I<timeout> is non-NULL, the udp/time socket (port 37) is used.  Otherwise, the tcp/time socket (port 37) is used.
fr: Si I<timeout> est non NULL, le port UDP/time (37) est utilisé, sinon le port TCP/time (37) est utilisé.

note: type: Plain text
en: On success, 0 is returned, and the obtained 32-bit time value is stored in I<timep-E<gt>tv_sec>.  In case of error -1 is returned, and I<errno> is set appropriately.
fr: Si elle réussit, cette fonction renvoie zéro et la valeur 32\ bits obtenue est stockée dans I<timep-E<gt>tv_sec>. En cas d'échec, elle renvoie -1 et I<errno> contient le code d'erreur.

note: type: Plain text
en: All errors for underlying functions (B<sendto>(2), B<poll>(2), B<recvfrom>(2), B<connect>(2), B<read>(2))  can occur.  Moreover:
fr: Toutes les erreurs pour les fonctions sous-jacentes (B<sendto>(2), B<poll>(2), B<recvfrom>(2), B<connect>(2), B<read>(2)) peuvent se produire, avec en outre\ :

note: type: Plain text
en: The number of returned bytes is not 4.
fr: Le nombre d'octets reçus n'est pas 4.

note: type: Plain text
en: The waiting time as defined in timeout has expired.
fr: Le délai indiqué en second argument a expiré.

note: type: Plain text
en: Only IPv4 is supported.
fr: Seul IPv4 est supporté.

note: type: Plain text
en: Some I<in.timed> versions support only TCP.  Try the example program with I<use_tcp> set to 1.
fr: Certaines versions de I<in.timed> supportent uniquement TCP. Essayez le programme d'exemple avec I<use_tcp> définie à 1.

note: type: Plain text
en: Libc5 uses the prototype
fr: La libc5 utilise le prototype

note: type: Plain text
en: and requires I<E<lt>sys/time.hE<gt>> instead of I<E<lt>rpc/auth_des.hE<gt>>.
fr: et requiert I<E<lt>sys/time.hE<gt>> à la place de I<E<lt>rpc/auth_des.hE<gt>>.

note: type: Plain text
en: B<rtime>()  in glibc 2.2.5 and earlier does not work properly on 64-bit machines.
fr: B<rtime>() dans la glibc 2.2.5 et les précédentes ne fonctionne pas correctement sur les machines 64\ bits.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: This example requires that port 37 is up and open.  You may check that the time entry within I</etc/inetd.conf> is not commented out.
fr: Cet exemple demande que le port 37 soit ouvert et actif. Vérifiez que l'entrée time dans I</etc/inetd.conf> ne soit pas commentée.

note: type: Plain text
en: The program connects to a computer called "linux".  Using "localhost" does not work.  The result is the localtime of the computer "linux".
fr: Le programme se connecte sur un hôte nommé «\ linux\ ». Utiliser «\ localhost\ » ne fonctionne pas. Le résultat est l'heure locale de l'ordinateur «\ linux\ ».

note: type: TH
en: 2007-12-30
fr: 30 décembre 2007

note: type: Plain text
en: xdr - library routines for external data representation
fr: xdr - Bibliothèque de fonctions pour transmission externe de données

note: type: Plain text
en: These routines allow C programmers to describe arbitrary data structures in a machine-independent fashion.  Data for remote procedure calls are transmitted using these routines.
fr: Ces routines permettent aux programmeurs C de décrire des structures de données arbitraires de manière indépendante de la machine. Les données pour les appels de routines distantes (B<RPC>) sont transmises de cette manière.

note: type: Plain text
en: The prototypes below are declared in I<E<lt>rpc/xdr.hE<gt>> and make use of the following types:
fr: Les prototypes ci-dessous sont déclarés dans I<E<lt>rpc/xdr.hE<gt>> et utilisent les types suivants :

note: type: Plain text
en: For the declaration of the I<XDR> type, see I<E<lt>rpc/xdr.hE<gt>>.
fr: Pour la déclaration du type I<XDR>, consultez I<E<lt>rpc/xdr.hE<gt>>.

note: type: Plain text
en: A filter primitive that translates between variable-length arrays and their corresponding external representations.  The argument I<arrp> is the address of the pointer to the array, while I<sizep> is the address of the element count of the array; this element count cannot exceed I<maxsize>.  The argument I<elsize> is the I<sizeof> each of the array's elements, and I<elproc> is an XDR filter that translates between the array elements' C form, and their external representation.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage qui traduit les tables de longueur variable en leur représentations externes correspondantes. Le paramètre I<arrp> est l'adresse d'un pointeur sur la chaîne, tandis que I<sizep> est l'adresse du nombre d'éléments dans la table. Ce nombre d'éléments ne peut pas excéder I<maxsize>. Le paramètre I<elsize> est la taille (I<sizeof>) de chaque élément de la table, et I<elproc> est un filtre XDR de traduction entre la forme C des éléments de la table, et sa représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between booleans (C integers)  and their external representations.  When encoding data, this filter produces values of either one or zero.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les booléens (entiers C) et leur représentation externe. Durant l'encodage des données, ce filtre produit soit un 1 soit un 0. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between counted byte strings and their external representations.  The argument I<sp> is the address of the string pointer.  The length of the string is located at address I<sizep>; strings cannot be longer than I<maxsize>.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre des tables caractères de longueurs données et leur représentation externe. Le paramètre I<sp> est l'adresse du pointeur sur la chaîne. La longueur de la chaîne est située à l'adresse I<sizep>. Les chaînes ne peuvent pas être plus longues que I<maxsize>. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C characters and their external representations.  This routine returns one if it succeeds, zero otherwise.  Note: encoded characters are not packed, and occupy 4 bytes each.  For arrays of characters, it is worthwhile to consider B<xdr_bytes>(), B<xdr_opaque>()  or B<xdr_string>().
fr: Une primitive de filtrage assurant la traduction entre les caractères C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon. Note\ : les caractères encodés ne sont pas accolés, et occupent quatre octets chacun. Pour les tables de caractères, il vaut mieux se tourner vers B<xdr_bytes>(), B<xdr_opaque>() ou B<xdr_string>().

note: type: Plain text
en: A macro that invokes the destroy routine associated with the XDR stream, I<xdrs>.  Destruction usually involves freeing private data structures associated with the stream.  Using I<xdrs> after invoking B<xdr_destroy>()  is undefined.
fr: Une macro invoquant la routine de destruction associée avec le flux XDR, I<xdrs>. La destruction entraîne habituellement la libération de structures de données privées associées avec le flux. Le comportement est indéfini si on essaye d'utiliser I<xdrs> après avoir invoqué B<xdr_destroy>().

note: type: Plain text
en: A filter primitive that translates between C I<double> precision numbers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les nombres C en I<double> précision et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C I<enum>s (actually integers) and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les énumérés C I<enum> (en réalité des entiers) et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C I<float>s and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les nombres I<float> C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: Generic freeing routine.  The first argument is the XDR routine for the object being freed.  The second argument is a pointer to the object itself.  Note: the pointer passed to this routine is I<not> freed, but what it points to I<is> freed (recursively).
fr: Routine générique de libération. Le premier argument est la routine XDR de l'objet à libérer. Le second argument est un pointeur vers l'objet lui-même. Note\ : le pointeur transmis à cette routine n'est I<pas> libéré, mais l'endroit où il pointe I<est> libéré (récursivement).

note: type: Plain text
en: A macro that invokes the get-position routine associated with the XDR stream, I<xdrs>.  The routine returns an unsigned integer, which indicates the position of the XDR byte stream.  A desirable feature of XDR streams is that simple arithmetic works with this number, although the XDR stream instances need not guarantee this.
fr: Une macro invoquant la routine de lecture de position associée avec le flux XDR, I<xdrs>. Cette fonction renvoie un entier non signé, qui indique la position dans le flux XDR. Une fonctionnalité appréciable serait que l'arithmétique usuelle fonctionne avec ce nombre, mais tous les flux XDR ne le garantissent pas.

note: type: Plain text
en: A macro that invokes the inline routine associated with the XDR stream, I<xdrs>.  The routine returns a pointer to a contiguous piece of the stream's buffer; I<len> is the byte length of the desired buffer.  Note: pointer is cast to I<long\ *>.
fr: Une macro qui invoque la routine en ligne associée avec le flux XDR I<xdrs>. Cette routine renvoie un pointeur vers une portion continue du tampon du flux. I<len> est la longueur en octets du tampon désiré. Note\ : le pointeur est converti en I<long\ *>.

note: type: Plain text
en: Warning: B<xdr_inline>()  may return NULL (0)  if it cannot allocate a contiguous piece of a buffer.  Therefore the behavior may vary among stream instances; it exists for the sake of efficiency.
fr: Attention\ : B<xdr_inline>() peut renvoyer NULL (0) si elle ne peut allouer une portion continue de tampon de la taille réclamée. Ce comportement peut néanmoins varier d'une instance de flux à l'autre\ ; elle existe par souci d'efficacité.

note: type: Plain text
en: A filter primitive that translates between C integers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les entiers C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C I<long> integers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les entiers I<long> C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: This routine initializes the XDR stream object pointed to by I<xdrs>.  The stream's data is written to, or read from, a chunk of memory at location I<addr> whose length is no more than I<size> bytes long.  The I<op> determines the direction of the XDR stream (either B<XDR_ENCODE>, B<XDR_DECODE>, or B<XDR_FREE>).
fr: Cette routine initialise l'objet flux XDR pointé par I<xdrs>. Les données du flux sont lues ou écrites dans le bloc mémoire situé en I<addr> et dont la longueur ne dépasse pas I<size> octets. L'argument I<op> détermine la direction du flux XDR (B<XDR_ENCODE>, B<XDR_DECODE> ou B<XDR_FREE>).

note: type: Plain text
en: A filter primitive that translates between fixed size opaque data and its external representation.  The argument I<cp> is the address of the opaque object, and I<cnt> is its size in bytes.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre des données opaques de taille fixe et leur représentation externe. Le paramètre I<cp> est l'adresse de l'objet opaque, et I<cnt> est sa taille en octets. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: Like B<xdr_reference>()  except that it serializes null pointers, whereas B<xdr_reference>()  does not.  Thus, B<xdr_pointer>()  can represent recursive data structures, such as binary trees or linked lists.
fr: Comme B<xdr_reference>() sauf qu'elle met bout à bout les pointeurs NULL alors que B<xdr_reference>() ne le fait pas. Ainsi B<xdr_pointer>() peut représenter des structures de données récursives, comme les arbres binaires ou les listes chaînées.

note: type: Plain text
en: This routine initializes the XDR stream object pointed to by I<xdrs>.  The stream's data is written to a buffer of size I<sendsize>; a value of zero indicates the system should use a suitable default.  The stream's data is read from a buffer of size I<recvsize>; it too can be set to a suitable default by passing a zero value.  When a stream's output buffer is full, I<writeit> is called.  Similarly, when a stream's input buffer is empty, I<readit> is called.  The behavior of these two routines is similar to the system calls B<read>(2)  and B<write>(2), except that I<handle> is passed to the former routines as the first argument.  Note: the XDR stream's I<op> field must be set by the caller.
fr: Cette routine initialise le flux XDR pointé par I<xdrs>. Les données du flux sont écrites dans un tampon de taille I<sendsize>. Une valeur nulle indique que le système choisira une taille adéquate. Les données du flux sont lues depuis un tampon de taille I<recvsize>. De même le système choisira une taille adéquate en transmettant une valeur nulle. Lorsque le tampon de sortie du flux est plein, la fonction I<writeit> est appelé. Symétriquement, lorsque le tampon d'entrée est vide, la fonction I<readit> est invoquée. Le comportement de ces routines est similaire aux deux appels système B<read>(2) et B<write>(2), sauf que le descripteur I<handle> est passé aux routines en tant que premier paramètre. Note\ : l'attribut I<op> du flux XDR doit être défini par l'appelant.

note: type: Plain text
en: Warning: this XDR stream implements an intermediate record stream.  Therefore there are additional bytes in the stream to provide record boundary information.
fr: Attention\ : ce flux XDR implémente un flux d'enregistrement intermédiaire. Il y a donc des octets supplémentaires dans le flux afin de séparer les enregistrements.

note: type: Plain text
en: This routine can be invoked only on streams created by B<xdrrec_create>().  The data in the output buffer is marked as a completed record, and the output buffer is optionally written out if I<sendnow> is nonzero.  This routine returns one if it succeeds, zero otherwise.
fr: Cette routine ne peut être invoquée que sur des flux créé par B<xdrrec_create>(). Les données dans le tampon de sortie sont considérées comme un enregistrement complet, et le tampon de sortie est éventuellement écrit si I<sendnow> est non nul. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: This routine can be invoked only on streams created by B<xdrrec_create>().  After consuming the rest of the current record in the stream, this routine returns one if the stream has no more input, zero otherwise.
fr: Cette routine ne peut être invoqué que sur des flux créés par B<xdrrec_create>(). Après avoir rempli le reste de l'enregistrement avec les données du flux, cette routine renvoie 1 si le flux n'a plus de données d'entrée, et 0 sinon.

note: type: Plain text
en: This routine can be invoked only on streams created by B<xdrrec_create>().  It tells the XDR implementation that the rest of the current record in the stream's input buffer should be discarded.  This routine returns one if it succeeds, zero otherwise.
fr: Cette routine ne peut être invoqué que sur des flux créés par B<xdrrec_create>(). Elle indique à l'implémentation XDR que le reste de l'enregistrement en cours dans le tampon d'entrée doit être éliminé. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A primitive that provides pointer chasing within structures.  The argument I<pp> is the address of the pointer; I<size> is the I<sizeof> the structure that I<*pp> points to; and I<proc> is an XDR procedure that filters the structure between its C form and its external representation.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive qui gère les pointeurs sur les structures. Le paramètre I<pp> est l'adresse du pointeur, I<size> est la taille (I<sizeof>) de la structure pointée par I<*pp>, et I<proc> est la procédure XDR qui filtre la structure entre sa forme C et sa représentation externe. Cette routine renvoie 1 si elle réussit, et 0 sinon.

note: type: Plain text
en: Warning: this routine does not understand null pointers.  Use B<xdr_pointer>()  instead.
fr: Attention\ : cette routine ne comprend pas les pointeurs NULL. Utilisez B<xdr_pointer>() à sa place.

note: type: Plain text
en: A macro that invokes the set position routine associated with the XDR stream I<xdrs>.  The argument I<pos> is a position value obtained from B<xdr_getpos>().  This routine returns one if the XDR stream could be repositioned, and zero otherwise.
fr: Une macro qui invoque la routine de positionnement associée au flux XDR I<xdrs>. Le paramètre I<pos> est une valeur de position obtenue avec B<xdr_getpos>(). Cette routine renvoie 1 si le flux XDR peut être repositionné, et zéro sinon.

note: type: Plain text
en: Warning: it is difficult to reposition some types of XDR streams, so this routine may fail with one type of stream and succeed with another.
fr: Attention\ : il est difficile de repositionner certains types de flux XDR ce qui peut faire échouer cette routine avec certains flux, et réussir avec d'autres.

note: type: Plain text
en: A filter primitive that translates between C I<short> integers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les entiers I<short> et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: This routine initializes the XDR stream object pointed to by I<xdrs>.  The XDR stream data is written to, or read from, the I<stdio> stream I<file>.  The argument I<op> determines the direction of the XDR stream (either B<XDR_ENCODE>, B<XDR_DECODE>, or B<XDR_FREE>).
fr: Cette routine initialise l'objet flux XDR pointé par I<xdrs>. Les données du flux XDR sont écrites dans - ou lues depuis - le flux d'entrée-sortie standard I<file>. Le paramètre I<op> détermine la direction du flux XDR (B<XDR_ENCODE>, B<XDR_DECODE> ou B<XDR_FREE>).

note: type: Plain text
en: Warning: the destroy routine associated with such XDR streams calls B<fflush>(3)  on the I<file> stream, but never B<fclose>(3).
fr: Attention\ : la routine de destruction associée avec un tel flux XDR appelle B<fflush>(3) sur le flux I<file>, mais pas B<fclose>(3).

note: type: Plain text
en: A filter primitive that translates between C strings and their corresponding external representations.  Strings cannot be longer than I<maxsize>.  Note: I<sp> is the address of the string's pointer.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les chaînes de caractères C et leur représentation externe. Les chaînes ne peuvent pas être plus longues que I<maxsize>. Note\ : I<sp> est l'adresse du pointeur sur la chaîne. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between I<unsigned> C characters and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les caractères I<unsigned> du C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C I<unsigned> integers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les entiers I<unsigned> du C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C I<unsigned long> integers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les entiers I<unsigned long> du C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between C I<unsigned short> integers and their external representations.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les entiers I<unsigned short> du C et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: B<bool_t xdr_union(XDR *>I<xdrs>B<, int *>I<dscmp>B<, char *>I<unp>B<,>
    B<                 struct xdr_discrim *>I<choices>B<,>
    B<                 xdrproc_t >I<defaultarm>B<);     /* may equal NULL */>
fr: B<bool_t xdr_union(XDR *>I<xdrs>B<, int *>I<dscmp>B<, char *>I<unp>B<,>
    B<                 struct xdr_discrim *>I<choices>B<,>
    B<                 xdrproc_t >I<defaultarm>B<);     /* peut être NULL */>

note: type: Plain text
en: A filter primitive that translates between a discriminated C I<union> and its corresponding external representation.  It first translates the discriminant of the union located at I<dscmp>.  This discriminant is always an I<enum_t>.  Next the union located at I<unp> is translated.  The argument I<choices> is a pointer to an array of B<xdr_discrim>()  structures.  Each structure contains an ordered pair of [I<value>,I<proc>].  If the union's discriminant is equal to the associated I<value>, then the I<proc> is called to translate the union.  The end of the B<xdr_discrim>()  structure array is denoted by a routine of value NULL.  If the discriminant is not found in the I<choices> array, then the I<defaultarm> procedure is called (if it is not NULL).  Returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre une I<union> C avec discriminant et la représentation externe correspondante. Elle traduit d'abord le discriminant de l'union, situé en I<dscmp>. Le discriminant doit toujours être du type I<enum_t>. Ensuite, l'union située en I<unp> est traduite. Le paramètre I<choices> est un pointeur sur une table de structures B<xdr_discrim>(). Chaque structure contient une paire ordonnée [I<valeur>, I<procédure>]. Si le discriminant de l'union est égal à une I<valeur>, alors la I<procédure> associée est invoquée pour traduire l'union. La fin de la table de structures B<xdr_discrim>() est indiquée par une routine de valeur NULL. Si le discriminant n'est pas trouvé dans la table I<choices>, alors la procédure I<defaultarm> est invoquée (si elle ne vaut pas NULL). Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: A filter primitive that translates between fixed-length arrays and their corresponding external representations.  The argument I<arrp> is the address of the pointer to the array, while I<size> is the element count of the array.  The argument I<elsize> is the I<sizeof> each of the array's elements, and I<elproc> is an XDR filter that translates between the array elements' C form, and their external representation.  This routine returns one if it succeeds, zero otherwise.
fr: Une primitive de filtrage assurant la traduction entre les tables de longueur fixe, et leur représentation externe. Le paramètre I<arrp> est l'adresse du pointeur sur la table, tandis que I<size> est le nombre d'éléments dans la table. Le paramètre I<elsize> est la taille (I<sizeof>) d'un élément de la table, et I<elproc> est un filtre XDR assurant la traduction entre la forme C des éléments de la table et leur représentation externe. Cette routine renvoie 1 si elle réussit, 0 sinon.

note: type: Plain text
en: This routine always returns one.  It may be passed to RPC routines that require a function argument, where nothing is to be done.
fr: Cette routine renvoie toujours 1. Elle peut être passée aux routines RPC qui ont besoin d'une fonction en paramètre alors que rien ne doit être fait.

note: type: Plain text
en: A primitive that calls B<xdr_string(xdrs, sp,MAXUN.UNSIGNED );> where B<MAXUN.UNSIGNED> is the maximum value of an unsigned integer.  B<xdr_wrapstring>()  is handy because the RPC package passes a maximum of two XDR routines as arguments, and B<xdr_string>(), one of the most frequently used primitives, requires three.  Returns one if it succeeds, zero otherwise.
fr: Une primitive qui appelle B<xdr_string(xdrs, sp, MAXUN.UNSIGNED);> où B<MAXUN.UNSIGNED> est la valeur maximale d'un entier non signé. B<xdr_wrapstring>() est pratique car la bibliothèque RPC passe un maximum de deux routines XDR comme paramètres, et B<xdr_string>(), l'une des primitives les plus fréquemment utilisées en requiert trois. Cette routine renvoie 1 si elle réussit, 0 sinon.
