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

NOM

       getservent_r,    getservbyname_r,   getservbyport_r   -   Accéder   aux
       informations sur les services (version ré-entrante)

SYNOPSIS

       #include <netdb.h>

       int getservent_r(struct servent *result_buf, char *buf,
                       size_t buflen, struct servent **result);

       int getservbyname_r(const char *name, const char *proto,
                       struct servent *result_buf, char *buf,
                       size_t buflen, struct servent **result);

       int getservbyport_r(int port, const char *proto,
                       struct servent *result_buf, char *buf,
                       size_t buflen, struct servent **result);

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

       getservent_r(), getservbyname_r(), getservbyport_r() : _BSD_SOURCE ||
       _SVID_SOURCE

DESCRIPTION

       getservent_r(),    getservbyname_r()    et    getservbyport_r()    sont
       respectivement    les    versions    ré-entrantes   de   getservent(3),
       getservbyname(3) et getservbyport(3). Elles diffèrent car la  structure
       servent  est  renvoyée, les signatures et la valeur renvoyée sont aussi
       différentes. Cette page de manuel décrit juste les  différences  depuis
       les versions non ré-entrantes.

       Au lieu de renvoyer un pointeur vers une structure servent 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ée  par  la  structure  servent  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  réussie à obtenir un enregistrement de service, 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.

       En  cas  d’erreur,  « enregistrement  non  trouvé » (getservbyname_r(),
       getservbyport_r()) ou « fin de l’entrée » (getservent_r()), result  est
       défini à NULL.

ERREURS

       ENOENT (getservent_r())  Plus d’enregistrement dans la base de données.

       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  getservbyport_r()  pour  récupérer
       l’enregistrement du port et du protocole nommé dans les  deux  premiers
       arguments de sa ligne de commande. Si un troisième argument (un entier)
       est fourni, il  est  utilisé  comme  valeur  initiale  de  bufflen.  Si
       getservbyport_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 7 tcp 1
           ERANGE! Retrying with larger buffer
           getservbyport_r() returned: 0 (success)  (buflen=87)
           s_name=echo; s_proto=tcp; s_port=7; aliases=
           $ ./a.out 77777 tcp
           getservbyport_r() returned: 0 (success)  (buflen=1024)
           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, port, s;
           struct servent result_buf;
           struct servent *result;
           char buf[MAX_BUF];
           char *protop;
           char **p;

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

           port = htons(atoi(argv[1]));
           protop = (strcmp(argv[2], "null") == 0 ||
                  strcmp(argv[2], "NULL") == 0) ?  NULL : argv[2];

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

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

           erange_cnt = 0;
           do {
               s = getservbyport_r(port, protop, &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("getservbyport_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("s_name=%s; s_proto=%s; s_port=%d; aliases=",
                       result_buf.s_name, result_buf.s_proto,
                       ntohs(result_buf.s_port));
           for (p = result_buf.s_aliases; *p != NULL; p++)
               printf("%s ", *p);
           printf("\n");

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       getservent(3), services(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> ».