Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       getservent_r,    getservbyname_r,   getservbyport_r   -   Acceder   aux
       informations sur les services (version reentrante)

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 fonctionnalites  pour  la  glibc  (consultez
   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    reentrantes    de    getservent(3),
       getservbyname(3)  et getservbyport(3). Elles different car la structure
       servent est renvoyee, les signatures et la valeur renvoyee  sont  aussi
       differentes.  Cette  page de manuel decrit juste les differences depuis
       les versions non reentrantes.

       Au lieu de renvoyer un pointeur vers une structure servent statiquement
       allouee,  ces  fonctions  copient  la structure a l'adresse pointee par
       result_buf.

       Le tableau buf est utilise pour sauvegarder les  champs  de  la  chaine
       pointee   par   la   structure  servent  renvoyee  (les  fonctions  non
       reentrantes allouent ces chaines  de  facon  statique).  La  taille  du
       tableau  est  specifiee  avec  buflen.  Si  buf est trop petit, l'appel
       echoue avec l'erreur ERANGE, et l'appelant doit essayer de nouveau avec
       un  tableau  plus  grand  (un  tableau  de  1024  octets est en general
       suffisant).

       Si la fonction reussie a obtenir un enregistrement  de  service,  alors
       *result pointe vers result_buf, sinon *result est defini a NULL.

VALEUR RENVOY'EE

       En  cas  de  succes, ces fonctions renvoient zero. En cas d'erreur, une
       valeur d'erreur positive listee dans ERREURS est renvoyee.

       En cas d'erreur, << enregistrement  non  trouve >>  (getservbyname_r(),
       getservbyport_r())  ou  << fin  de l'entree >> (getservent_r()), result
       est defini a NULL.

ERREURS

       ENOENT (getservent_r()) Plus d'enregistrement dans la base de donnees.

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

CONFORMIT'E

       Ces  fonctions  sont  des  extensions  GNU. Des fonctions avec des noms
       similaires existent sur d'autres systemes, bien que en general avec des
       signatures d'appels different.

EXEMPLE

       Le   programme  ci-dessous  utilise  getservbyport_r()  pour  recuperer
       l'enregistrement du port et du protocole nomme dans les  deux  premiers
       arguments de sa ligne de commande. Si un troisieme argument (un entier)
       est fourni,  il  est  utilise  comme  valeur  initiale  de  buflen.  Si
       getservbyport_r()  echoue 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.27 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone       au       sein        du        projet        perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Florentin   Duneau   et   l'equipe   francophone   de   traduction   de
       Debian (2006-2009).

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

       Vous pouvez toujours avoir acces a la version anglaise de  ce  document
       en utilisant la commande << man -L C <section> <page_de_man> >>.