Provided by: manpages-ro-dev_4.27.0-1_all bug

NUME

       getservent_r, getservbyname_r, getservbyport_r - obține intrarea serviciului (reentrant)

BIBLIOTECA

       Biblioteca C standard (libc, -lc)

SINOPSIS

       #include <netdb.h>

       int getservent_r(struct servent *restrict result_buf,
                        char buf[restrict .buflen], size_t buflen,
                        struct servent **restrict result);
       int getservbyname_r(const char *restrict name,
                        const char *restrict proto,
                        struct servent *restrict result_buf,
                        char buf[restrict .buflen], size_t buflen,
                        struct servent **restrict result);
       int getservbyport_r(int port,
                        const char *restrict proto,
                        struct servent *restrict result_buf,
                        char buf[restrict .buflen], size_t buflen,
                        struct servent **restrict result);

   Cerințe pentru macrocomenzi de testare a caracteristicilor pentru glibc (consultați feature_test_macros(7)):

       getservent_r(), getservbyname_r(), getservbyport_r():
           Începând cu glibc 2.19:
               _DEFAULT_SOURCE
           glibc 2.19 și versiunile anterioare:
               _BSD_SOURCE || _SVID_SOURCE

DESCRIERE

       Funcțiile  getservent_r(),  getservbyname_r()  și  getservbyport_r()  sunt  echivalentele  reentrante ale
       funcțiilor getservent(3), getservbyname(3) și getservbyport(3).  Ele  diferă  prin  modul  în  care  este
       returnată  structura  servent,  precum  și prin semnătura de apelare a funcției și valoarea de returnare.
       Această pagină de manual descrie doar diferențele față de funcțiile ne reentrante.

       În loc să returneze un indicator la o structură servent alocată static ca rezultat  al  funcției,  aceste
       funcții copiază structura în locația indicată de result_buf.

       Matricea buf este utilizată pentru a stoca câmpurile de șiruri de caractere indicate de structura servent
       returnată;  (funcțiile  nereturnante  alocă  aceste  șiruri de caractere în memoria statică). Dimensiunea
       acestei matrice este specificată în buflen. Dacă buf este prea mică, apelul eșuează  cu  eroarea  ERANGE,
       iar  apelantul  trebuie  să încerce din nou cu o memorie tampon mai mare; (un buffer cu o lungime de 1024
       octeți ar trebui să fie suficient pentru majoritatea aplicațiilor).

       Dacă apelul funcției obține cu  succes  o  evidență  a  serviciului,  atunci  *result  este  stabilit  la
       result_buf; în caz contrar, *result este stabilit la NULL.

VALOAREA RETURNATĂ

       În  caz de succes, aceste funcții returnează 0. În caz de eroare, acestea returnează unul dintre numerele
       pozitive de eroare enumerate în secțiunea ERORI-IEȘIRE.

       În caz de eroare,  înregistrare  nedescoperită  (getservbyname_r(),  getservbyport_r())  sau  sfârșit  de
       intrare (getservent_r()), result este stabilit la NULL.

ERORI-IEȘIRE

       ENOENT (getservent_r()) Nu mai există înregistrări în baza de date.

       ERANGE buf este prea mic. Încercați din nou cu o memorie tampon mai mare (și cu buflen mărit).

ATRIBUTE

       Pentru o explicație a termenilor folosiți în această secțiune, a se vedea attributes(7).
       ┌──────────────────────────────────────────────────────────────────┬───────────────────┬────────────────┐
       │ InterfațăAtributValoare        │
       ├──────────────────────────────────────────────────────────────────┼───────────────────┼────────────────┤
       │ getservent_r(), getservbyname_r(), getservbyport_r()             │ Siguranța firelor │ MT-Safe locale │
       └──────────────────────────────────────────────────────────────────┴───────────────────┴────────────────┘

VERSIUNI

       Funcții cu nume similare există și pe alte sisteme, deși, de obicei, cu semnături de apelare diferite.

STANDARDE

       GNU.

EXEMPLE

       Programul de mai jos utilizează getservbyport_r() pentru a prelua înregistrarea serviciului pentru portul
       și protocolul menționate în primul său argument de linie de comandă. În cazul în care se furnizează un al
       treilea  argument  de  linie  de  comandă (număr întreg), acesta este utilizat ca valoare inițială pentru
       buflen; dacă getservbyport_r() eșuează cu eroarea ERANGE, programul încearcă din nou  cu  dimensiuni  mai
       mari ale memoriei tampon. Următoarea sesiune shell prezintă câteva exemple de execuție:

           $ ./a.out 7 tcp 1
           ERANGE! Se reîncearcă cu o memorie tampon mai mare
           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)
           Apel eșuat/înregistrarea nu a fost găsită

   Sursa programului

       #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, port, s;
           struct servent result_buf;
           struct servent *result;
           char buf[MAX_BUF];
           char *protop;

           if (argc < 3) {
               printf("Utilizare: %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("Limita memoriei tampon a fost depășită (%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! Se reîncearcă cu o memorie tampon mai mare\n");
                   erange_cnt++;

                   /* Incrementăm câte un octet pe rând ca să vedem exact
                      ce dimensiune a fost necesară pentru memoria tampon. */

                   buflen++;

                   if (buflen > MAX_BUF) {
                       printf("Limita memoriei tampon a fost depășită (%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("Apel eșuat/înregistrarea nu a fost găsită\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 (char **p = result_buf.s_aliases; *p != NULL; p++)
               printf("%s ", *p);
           printf("\n");

           exit(EXIT_SUCCESS);
       }

CONSULTAȚI ȘI

       getservent(3), services(5)

TRADUCERE

       Traducerea    în   limba   română   a   acestui   manual   a   fost   făcută   de   Remus-Gabriel   Chelu
       <remusgabriel.chelu@disroot.org>

       Această traducere este  documentație  gratuită;  citiți  Licența publică generală GNU Versiunea 3  sau  o
       versiune   ulterioară   cu  privire  la  condiții  privind  drepturile  de  autor.   NU  se  asumă  NICIO
       RESPONSABILITATE.

       Dacă găsiți erori în traducerea acestui manual, vă rugăm să  trimiteți  un  e-mail  la  translation-team-
       ro@lists.sourceforge.net.

Pagini de manual de Linux 6.9.1                   15 iunie 2024                                  getservent_r(3)