Provided by: manpages-fr-dev_4.21.0-2_all bug

NOM

       getprotoent_r,  getprotobyname_r,  getprotobynumber_r  —  Lire  une  entrée  de  protocole
       (version réentrante)

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <netdb.h>

       int getprotoent_r(struct protoent *restrict tampon_resultat,
                         char tampon[restrict .taille_tampon], size_t taille_tampon,
                         struct protoent **restrict resultat);
       int getprotobyname_r(const char *restrict nom,
                         struct protoent *restrict tampon_resultat,
                         char tampon[restrict .taille_tampon], size_t taille_tampon,
                         struct protoent **restrict resultat);
       int getprotobynumber_r(int proto,
                         struct protoent *restrict tampon_resultat,
                         char tampon[restrict .taille_tampon], size_t taille_tampon,
                         struct protoent **restrict resultat);

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

       getprotoent_r(), getprotobyname_r(), getprotobynumber_r() :
           Depuis la glibc 2.19 :
               _DEFAULT_SOURCE
           glibc 2.19 et antérieures :
               _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  en  diffèrent  car elles renvoient une structure protoent, et
       leur signature ainsi que leur valeur de retour  sont  aussi  différentes.  Cette  page  de
       manuel décrit juste les différences avec les fonctions non réentrantes.

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

       Le tableau tampon 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 indiquée avec taille_tampon. Si tampon 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  protocole,  alors  *resultat  pointe  vers
       tampon_resultat sinon *resultat est défini à NULL.

VALEUR RENVOYÉE

       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.

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

ERREURS

       ENOENT (getprotoent_r()) Plus d'autres enregistrements dans la base de données.

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

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌─────────────────────────────────────────────────┬──────────────────────┬────────────────┐
       │InterfaceAttributValeur         │
       ├─────────────────────────────────────────────────┼──────────────────────┼────────────────┤
       │getprotoent_r(), getprotobyname_r(),             │ Sécurité des threads │ MT-Safe locale │
       │getprotobynumber_r()                             │                      │                │
       └─────────────────────────────────────────────────┴──────────────────────┴────────────────┘

STANDARDS

       Ces fonctions sont des extensions GNU. Des fonctions avec des noms similaires existent sur
       d'autres systèmes, bien qu’en général avec des signatures d'appel différentes.

EXEMPLES

       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
       taille_tampon.  Si getprotobyname_r() échoue avec l'erreur ERANGE, le programme recommence
       avec une taille de tampon plus grande.  La  session  d'interpréteur  suivante  montre  des
       exemples d'exécution :

           $ ./a.out tcp 1
           ERANGE! Nouvelle tentative avec un tampon plus grand
           getprotobyname_r() a renvoyé : 0 (success)  (buflen=78)
           p_name=tcp; p_proto=6; aliases=TCP
           $ ./a.out xxx 1
           ERANGE! Nouvelle tentative avec un tampon plus grand
           getprotobyname_r() a renvoyé : 0 (success)  (buflen=100)
           Call failed/record not found

   Source du programme

       #define _GNU_SOURCE
       #include <ctype.h>
       #include <errno.h>
       #include <netdb.h>
       #include <stdio.h>
       #include <stdlib.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];

           if (argc < 2) {
               printf("Utilisation : %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 ! Réessayez avec un tampon plus grand\n");
                   erange_cnt++;

                   /* Incrémenter un octet à la fois pour pouvoir voir exactement
                      la taille du tampon nécessaire. */

                   buflen++;

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

           printf("getprotobyname_r() a renvoyé : %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 (char **p = result_buf.p_aliases; *p != NULL; p++)
               printf("%s ", *p);
           printf("\n");

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       getprotoent(3), protocols(5)

TRADUCTION

       La  traduction  française  de  cette  page  de  manuel  a  été créée par Christophe Blaess
       <https://www.blaess.fr/christophe/>, Stéphan  Rafin  <stephan.rafin@laposte.net>,  Thierry
       Vignaud  <tvignaud@mandriva.com>,  François Micaux, Alain Portal <aportal@univ-montp2.fr>,
       Jean-Philippe   Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)    <jean-
       luc.coulon@wanadoo.fr>,    Julien    Cristau    <jcristau@debian.org>,    Thomas   Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau  <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis
       Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>  et  Jean-Philippe  MENGUAL
       <jpmengual@debian.org>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General
       Public  License  version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   concernant   les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.