getprotoent_r(3)           Library Functions Manual           getprotoent_r(3)

NUME
       getprotoent_r, getprotobyname_r, getprotobynumber_r - ob<?>ine intrarea
       protocolului (reentrante)

BIBLIOTECA
       Biblioteca C standard (libc, -lc)

SINOPSIS
       #include <netdb.h>

       int getprotoent_r(struct protoent *restrict result_buf,
                         char buf[restrict .buflen], size_t buflen,
                         struct protoent **restrict result);
       int getprotobyname_r(const char *restrict name,
                         struct protoent *restrict result_buf,
                         char buf[restrict .buflen], size_t buflen,
                         struct protoent **restrict result);
       int getprotobynumber_r(int proto,
                         struct protoent *restrict result_buf,
                         char buf[restrict .buflen], size_t buflen,
                         struct protoent **restrict result);

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

       getprotoent_r(), getprotobyname_r(), getprotobynumber_r():
           Incepand cu glibc 2.19:
               _DEFAULT_SOURCE
           glibc 2.19 <?>i versiunile anterioare:
               _BSD_SOURCE || _SVID_SOURCE

DESCRIERE
       Func<?>iile getprotoent_r(), getprotobyname_r() <?>i
       getprotobynumber_r() sunt echivalentele reentrante ale func<?>iilor
       getprotoent(3), getprotobyname(3) <?>i getprotobynumber(3). Ele difera
       prin modul in care este returnata structura protoent, precum <?>i prin
       semnatura de apelare a func<?>iei <?>i valoarea de returnare. Aceasta
       pagina de manual descrie doar diferen<?>ele fa<?>a de func<?>iile
       nereentrante.

       In loc sa returneze un indicator la o structura protoent alocata static
       ca rezultat al func<?>iei, aceste func<?>ii copiaza structura in
       loca<?>ia indicata de result_buf.

       Matricea buf este utilizata pentru a stoca campurile de <?>iruri de
       caractere indicate de structura protoent returnata; (func<?>iile
       nereentrante aloca aceste <?>iruri de caractere in memoria statica).
       Dimensiunea acestei matrice este specificata in buflen. Daca buf este
       prea mica, apelul e<?>ueaza cu eroarea ERANGE, iar apelantul trebuie sa
       incerce din nou cu o memorie tampon mai mare; (o memorie tampon cu o
       lungime de 1024 octe<?>i ar trebui sa fie suficienta pentru majoritatea
       aplica<?>iilor).

       Daca apelul func<?>iei ob<?>ine cu succes o inregistrare de protocol,
       atunci *result este stabilit la result_buf; in caz contrar, *result
       este stabilit la NULL.

VALOAREA RETURNATA
       In caz de succes, aceste func<?>ii returneaza 0. In caz de eroare,
       acestea returneaza unul dintre numerele pozitive de eroare enumerate in
       ERORI.

       In caz de eroare, inregistrare nedescoperita (getprotobyname_r(),
       getprotobynumber_r()), sau sfar<?>it de intrare (getprotoent_r())
       result este stabilit la NULL.

ERORI-IE<?>IRE
       ENOENT (getprotoent_r()) Nu mai exista inregistrari in baza de date.

       ERANGE buf este prea mic. Incerca<?>i din nou cu o memorie tampon mai
              mare (<?>i cu buflen marit).

ATRIBUTE
       Pentru o explica<?>ie a termenilor folosi<?>i in aceasta sec<?>iune, a
       se vedea attributes(7).

       +-------------------------------+---------------------+----------------+
       |Interfa<?>a                    | Atribut             | Valoare        |
       +-------------------------------+---------------------+----------------+
       |getprotoent_r(),               | Siguran<?>a firelor | MT-Safe locale |
       |getprotobyname_r(),            |                     |                |
       |getprotobynumber_r()           |                     |                |
       +-------------------------------+---------------------+----------------+
VERSIUNI
       Func<?>ii cu nume similare exista <?>i pe alte sisteme, de<?>i, de
       obicei, cu semnaturi de apelare diferite.

STANDARDE
       GNU.

EXEMPLE
       Programul de mai jos utilizeaza getprotobyname_r() pentru a prelua
       inregistrarea protocolului pentru protocolul numit in primul sau
       argument de linie de comanda. In cazul in care se furnizeaza un al
       doilea argument de linie de comanda (intreg), acesta este utilizat ca
       valoare ini<?>iala pentru buflen; daca getprotobyname_r() e<?>ueaza cu
       eroarea ERANGE, programul incearca din nou cu dimensiuni mai mari ale
       memoriei tampon. Urmatoarea sesiune shell prezinta cateva exemple de
       execu<?>ie:

           $ ./a.out tcp 1
           ERANGE! Reincercare cu o memorie tampon mai mare
           getprotobyname_r() returned: 0 (success)  (buflen=78)
           p_name=tcp; p_proto=6; aliases=TCP
           $ ./a.out xxx 1
           ERANGE! Reincercare cu o memorie tampon mai mare
           getprotobyname_r() returned: 0 (success)  (buflen=100)
           Apel e<?>uat/inregistrarea nu a fost gasita

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

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

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

           if (buflen > MAX_BUF) {
               printf("Limita memoriei tampon a fost depa<?>ita (%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! Reincercare cu o memorie tampon mai mare\n");
                   erange_cnt++;

                   /* Incrementam cate un octet pe rand, ca sa putem vedea exact
                      ce dimensiune a fost necesara pentru memoria tampon. */

                   buflen++;

                   if (buflen > MAX_BUF) {
                       printf("Limita memoriei tampon a fost depa<?>ita (%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("Apel e<?>uat/inregistrarea nu a fost gasita\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);
       }

CONSULTA<?>I <?>I
       getprotoent(3), protocols(5)

TRADUCERE
       Traducerea in limba romana a acestui manual a fost facuta de Remus-
       Gabriel Chelu <remusgabriel.chelu@disroot.org>

       Aceasta traducere este documenta<?>ie gratuita; citi<?>i Licen<?>a
       publica generala GNU Versiunea 3
       <https://www.gnu.org/licenses/gpl-3.0.html> sau o versiune ulterioara
       cu privire la condi<?>ii privind drepturile de autor.  NU se asuma
       NICIO RESPONSABILITATE.

       Daca gasi<?>i erori in traducerea acestui manual, va rugam sa
       trimite<?>i un e-mail la <translation-team-ro@lists.sourceforge.net>.

Pagini de manual de Linux 6.8     2 mai 2024                  getprotoent_r(3)