Provided by: manpages-fr-dev_3.17.1-1_all bug

NOM

       getprotoent_r,   getprotobyname_r,  getprotobynumber_r  -  Accéder  aux
       protocoles (version ré-entrante)

SYNOPSIS

       #include <netdb.h>

       int getprotoent_r(struct protoent *result_buf, char *buf,
                       size_t buflen, struct protoent **result);

       int getprotobyname_r(const char *name,
                       struct protoent *result_buf, char *buf,
                       size_t buflen, struct protoent **result);

       int getprotobynumber_r(int proto,
                       struct protoent *result_buf, char *buf,
                       size_t buflen, struct protoent **result);

   Exigences de  macros  de  test  de  fonctionnalités  pour  la  glibc  (voir
   feature_test_macros(7)) :

       getprotoent_r(), getprotobyname_r(), getprotobynumber_r() : _BSD_SOURCE
       || _SVID_SOURCE

DESCRIPTION

       getprotoent_r(),  getprotobyname_r(),  et   getprotobynumber_r()   sont
       respectivement, les versions ré-entrantes des fonctions getprotoent(3),
       getprotobyname(3),  et  getprotobynumber(3).  Elles  diffèrent  car  la
       structure  protoent  est  renvoyée,  et  leur  signature ainsi que leur
       valeur de retour sont aussi différentes. Cette page  de  manuel  décrit
       juste les différences depuis les fonctions non ré-entrantes.

       Au   lieu   de  retourner  un  pointeur  vers  une  structure  protoent
       statiquement allouée, ces fonctions copient la  structure  à  l’adresse
       pointée par result_buf.

       Le  tableau  buf  est  utilisé pour sauvegarder les champs de la chaîne
       pointés  par  la  structure  protoent  renvoyée  (les   fonctions   non
       ré-entrantes  allouent  ces  chaînes  de  façon statique). La taille du
       tableau est spécifiée avec buflen.  Si  buf  est  trop  petit,  l’appel
       échoue avec l’erreur ERANGE, et l’appelant doit essayer de nouveau avec
       un tableau plus grand  (un  tableau  de  1024  octets  est  en  général
       suffisant).

       Si  la  fonction  obtient  un enregistrement de protocol, alors *result
       pointe vers result_buf sinon *result est défini à NULL.

VALEUR RENVOYÉE

       En cas de succès, ces fonctions ré-entrantes  renvoient  zéro.  En  cas
       d’échec, une valeur d’erreur positive est renvoyée.

       Dans    le    cas    des   erreurs,   « enregistrement   non   trouvé »
       (getprotobyname_r(),  getprotobynumber_r())  ou  « fin  de   l’entrée »
       (getprotoent_r()), result est défini à NULL.

ERREURS

       ENOENT (getprotoent_r()) Plus d’autre enregistrement dans la base.

       ERANGE buf  est  trop  petit.  Ré-essayer avec un tampon plus grand (et
              augmentez buflen).

CONFORMITÉ

       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.

EXEMPLE

       Le  programme  ci-dessous  utilise  getprotobyname_r()  pour  récupérer
       l’enregistrement  de  protocole  du  protocole  nommé  dans  le premier
       argument de sa ligne de commande. Si un second argument (un entier) est
       fourni,   il   est   utilisé  comme  valeur  initiale  de  bufflen.  Si
       getprotobyname_r() échoue avec l’erreur ERANGE, le programme recommence
       avec une taille de tampon plus grande. La session shell suivante montre
       des exemples d’utilisation.

           $ ./a.out tcp 1
           ERANGE! Retrying with larger buffer
           getprotobyname_r() returned: 0 (success)  (buflen=78)
           p_name=tcp; p_proto=6; aliases=TCP
           $ ./a.out xxx 1
           ERANGE! Retrying with larger buffer
           getprotobyname_r() returned: 0 (success)  (buflen=100)
           Call failed/record not found

   Source du programme

       #define _GNU_SOURCE
       #include <ctype.h>
       #include <netdb.h>
       #include <stdlib.h>
       #include <stdio.h>
       #include <errno.h>
       #include <string.h>

       #define MAX_BUF 10000

       int
       main(int argc, char *argv[])
       {
           int buflen, erange_cnt, s;
           struct protoent result_buf;
           struct protoent *result;
           char buf[MAX_BUF];
           char **p;

           if (argc < 2) {
               printf("Usage: %s proto-name [buflen]\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           buflen = 1024;
           if (argc > 2)
               buflen = atoi(argv[2]);

           if (buflen > MAX_BUF) {
               printf("Exceeded buffer limit (%d)\n", MAX_BUF);
               exit(EXIT_FAILURE);
           }

           erange_cnt = 0;
           do {
               s = getprotobyname_r(argv[1], &result_buf,
                            buf, buflen, &result);
               if (s == ERANGE) {
                   if (erange_cnt == 0)
                       printf("ERANGE! Retrying with larger buffer\n");
                   erange_cnt++;

                   /* Increment a byte at a time so we can see exactly
                      what size buffer was required */

                   buflen++;

                   if (buflen > MAX_BUF) {
                       printf("Exceeded buffer limit (%d)\n", MAX_BUF);
                       exit(EXIT_FAILURE);
                   }
               }
           } while (s == ERANGE);

           printf("getprotobyname_r() returned: %s  (buflen=%d)\n",
                   (s == 0) ? "0 (success)" : (s == ENOENT) ? "ENOENT" :
                   strerror(s), buflen);

           if (s != 0 || result == NULL) {
               printf("Call failed/record not found\n");
               exit(EXIT_FAILURE);
           }

           printf("p_name=%s; p_proto=%d; aliases=",
                       result_buf.p_name, result_buf.p_proto);
           for (p = result_buf.p_aliases; *p != NULL; p++)
               printf("%s ", *p);
           printf("\n");

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       getprotoent(3), protocols(5)

COLOPHON

       Cette page fait partie de  la  publication  3.17  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été traduite et est maintenue par Florentin
       Duneau <fduneau AT gmail DOT com> et l’équipe francophone de traduction
       de Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».