LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    getprotoent_r

    
    
    
    

    SYNOPSIS

           #include <netdb.h>
    
           int getprotoent_r(struct protoent *result_buf, char *buf,
                           size_t buflen, struct protoent **result);
    
           int getprotobyname_r(const char *name,
                           struct protoent *result_buf, char *buf,
                           size_t buflen, struct protoent **result);
    
           int getprotobynumber_r(int proto,
                           struct protoent *result_buf, char *buf,
                           size_t buflen, struct protoent **result);
    
       Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
    
           getprotoent_r(), getprotobyname_r(), getprotobynumber_r():
               _BSD_SOURCE || _SVID_SOURCE
    
    
    

    DESCRIPTION

           The getprotoent_r(), getprotobyname_r(), and getprotobynumber_r() func-
           tions  are  the reentrant equivalents of, respectively, getprotoent(3),
           getprotobyname(3), and getprotobynumber(3).  They  differ  in  the  way
           that  the  protoent  structure is returned, and in the function calling
           signature and return value.  This manual page describes just  the  dif-
           ferences from the nonreentrant functions.
    
           Instead  of  returning  a  pointer  to  a statically allocated protoent
           structure as the function result, these functions  copy  the  structure
           into the location pointed to by result_buf.
    
           The  buf  array  is  used  to store the string fields pointed to by the
           returned protoent  structure.   (The  nonreentrant  functions  allocate
           these  strings in static storage.)  The size of this array is specified
           in buflen.  If buf is too small, the call fails with the error  ERANGE,
           and  the  caller  must  try  again  with a larger buffer.  (A buffer of
           length 1024 bytes should be sufficient for most applications.)
    
           If the function call  successfully  obtains  a  protocol  record,  then
           *result  is  set  pointing  to result_buf; otherwise, *result is set to
           NULL.
    
    
    

    RETURN VALUE

           On success, these functions return 0.  On error, they return one of the
           positive error numbers listed in ERRORS.
    
           On  error, record not found (getprotobyname_r(), getprotobynumber_r()),
           or end of input (getprotoent_r()) result is set to NULL.
    
    
    

    ERRORS

           ENOENT (getprotoent_r()) No more records in database.
           ERANGE,  the  program  retries with larger buffer sizes.  The following
           shell session shows a couple of sample runs:
    
               $ ./a.out tcp 1
               ERANGE! Retrying with larger buffer
               getprotobyname_r() returned: 0 (success)  (buflen=78)
               p_name=tcp; p_proto=6; aliases=TCP
               $ ./a.out xxx 1
               ERANGE! Retrying with larger buffer
               getprotobyname_r() returned: 0 (success)  (buflen=100)
               Call failed/record not found
    
       Program source
    
           #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, s;
               struct protoent result_buf;
               struct protoent *result;
               char buf[MAX_BUF];
               char **p;
    
               if (argc < 2) {
                   printf("Usage: %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) {
    
               } 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("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 (p = result_buf.p_aliases; *p != NULL; p++)
                   printf("%s ", *p);
               printf("\n");
    
               exit(EXIT_SUCCESS);
           }
    
    
    

    SEE ALSO

           getprotoent(3), protocols(5)
    
    
    

    GNU 2010-09-10 GETPROTOENT_R(3)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz