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:

    gai_suspend

    
    
    
    

    SYNOPSIS

           #define _GNU_SOURCE         /* See feature_test_macros(7) */
           #include <netdb.h>
    
           int getaddrinfo_a(int mode, struct gaicb *list[],
                           int nitems, struct sigevent *sevp);
    
           int gai_suspend(struct gaicb *list[], int nitems,
                           struct timespec *timeout);
    
           int gai_error(struct gaicb *req);
    
           int gai_cancel(struct gaicb *req);
    
           Link with -lanl.
    
    
    

    DESCRIPTION

           The getaddrinfo_a() function performs the same task as  getaddrinfo(3),
           but  allows multiple name look-ups to be performed asynchronously, with
           optional notification on completion of look-up operations.
    
           The mode argument has one of the following values:
    
           GAI_WAIT
                  Perform the look-ups synchronously.  The call blocks  until  the
                  look-ups have completed.
    
           GAI_NOWAIT
                  Perform  the  look-ups asynchronously.  The call returns immedi-
                  ately, and the requests are resolved in the background.  See the
                  discussion of the sevp argument below.
    
           The  array  list specifies the look-up requests to process.  The nitems
           argument specifies the number of elements in list.  The requested look-
           up  operations  are  started  in  parallel.   NULL elements in list are
           ignored.  Each request is described by a gaicb  structure,  defined  as
           follows:
    
               struct gaicb {
                   const char            *ar_name;
                   const char            *ar_service;
                   const struct addrinfo *ar_request;
                   struct addrinfo       *ar_result;
               };
    
           The  elements  of  this structure correspond to the arguments of getad-
           drinfo(3).  Thus, ar_name corresponds to the node argument and  ar_ser-
           vice  to  the service argument, identifying an Internet host and a ser-
           vice.  The ar_request element corresponds to the hints argument, speci-
           fying  the  criteria  for  selecting the returned socket address struc-
           tures.  Finally, ar_result corresponds to the res argument; you do  not
                  When  a  look-up  completes, generate the signal sigev_signo for
                  the process.  See sigevent(7) for general details.  The  si_code
                  field of the siginfo_t structure will be set to SI_ASYNCNL.
    
           SIGEV_THREAD
                  When  a look-up completes, invoke sigev_notify_function as if it
                  were the start function of a new thread.   See  sigevent(7)  for
                  details.
    
           For   SIGEV_SIGNAL   and  SIGEV_THREAD,  it  may  be  useful  to  point
           sevp->sigev_value.sival_ptr to list.
    
           The gai_suspend() function suspends execution of  the  calling  thread,
           waiting  for  the completion of one or more requests in the array list.
           The nitems argument specifies the size of the  array  list.   The  call
           blocks until one of the following occurs:
    
           *  One or more of the operations in list completes.
    
           *  The call is interrupted by a signal that is caught.
    
           *  The time interval specified in timeout elapses.  This argument spec-
              ifies a timeout in seconds plus nanoseconds  (see  nanosleep(2)  for
              details  of  the  timespec structure).  If timeout is NULL, then the
              call blocks indefinitely (until one of the events above occurs).
    
           No explicit indication of which request was  completed  is  given;  you
           must  determine  which  request(s)  have  completed  by  iterating with
           gai_error() over the list of requests.
    
           The gai_error() function returns the status of the request req:  either
           EAI_INPROGRESS  if  the request was not completed yet, 0 if it was han-
           dled successfully, or an  error  code  if  the  request  could  not  be
           resolved.
    
           The  gai_cancel() function cancels the request req.  If the request has
           been canceled successfully, the error status of the request will be set
           to  EAI_CANCELLED  and  normal  asynchronous  notification will be per-
           formed.  The request cannot be canceled if it is currently  being  pro-
           cessed;  in  that case, it will be handled as if gai_cancel() has never
           been called.  If req is NULL, an attempt is made  to  cancel  all  out-
           standing requests that the process has made.
    
    
    

    RETURN VALUE

           The getaddrinfo_a() function returns 0 if all of the requests have been
           enqueued successfully, or one of the following nonzero error codes:
    
           EAI_AGAIN
                  The resources necessary to enqueue the look-up requests were not
                  available.   The  application may check the error status of each
                  request to determine which ones failed.
    
           EAI_ALLDONE
                  There were no actual requests given to the function.
    
           EAI_INTR
                  A signal has interrupted the function.  Note that this interrup-
                  tion might have been caused by signal notification of some  com-
                  pleted look-up request.
    
           The  gai_error()  function  can return EAI_INPROGRESS for an unfinished
           look-up request, 0 for a successfully completed look-up  (as  described
           above),  one  of  the  error  codes  that  could  be returned by getad-
           drinfo(3), or the error code EAI_CANCELLED if the request has been can-
           celed explicitly before it could be finished.
    
           The gai_cancel() function can return one of these values:
    
           EAI_CANCELLED
                  The request has been canceled successfully.
    
           EAI_NOTCANCELLED
                  The request has not been canceled.
    
           EAI_ALLDONE
                  The request has already completed.
    
           The  gai_strerror(3)  function  translates these error codes to a human
           readable string, suitable for error reporting.
    
    
    

    CONFORMING TO

           These functions are GNU extensions; they first  appeared  in  glibc  in
           version 2.2.3.
    
    
    

    NOTES

           The  interface  of  getaddrinfo_a() was modeled after the lio_listio(3)
           interface.
    
    
    

    EXAMPLE

           Two examples are provided:  a  simple  example  that  resolves  several
           requests  in parallel synchronously, and a complex example showing some
           of the asynchronous capabilities.
    
       Synchronous example
           The program below simply resolves several hostnames in parallel, giving
           a  speed-up  compared  to  resolving  the  hostnames sequentially using
           getaddrinfo(3).  The program might be used like this:
    
               $ ./a.out ftp.us.kernel.org enoent.linuxfoundation.org gnu.cz
               ftp.us.kernel.org: 128.30.2.36
               enoent.linuxfoundation.org: Name or service not known
               gnu.cz: 87.236.197.13
    
           Here is the program source code
    
               if (argc < 2) {
                   fprintf(stderr, "Usage: %s HOST...\n", argv[0]);
                   exit(EXIT_FAILURE);
               }
    
               for (i = 0; i < argc - 1; i++) {
                   reqs[i] = malloc(sizeof(*reqs[0]));
                   if (reqs[i] == NULL) {
                       perror("malloc");
                       exit(EXIT_FAILURE);
                   }
                   memset(reqs[i], 0, sizeof(*reqs[0]));
                   reqs[i]->ar_name = argv[i + 1];
               }
    
               ret = getaddrinfo_a(GAI_WAIT, reqs, argc - 1, NULL);
               if (ret != 0) {
                   fprintf(stderr, "getaddrinfo_a() failed: %s\n",
                           gai_strerror(ret));
                   exit(EXIT_FAILURE);
               }
    
               for (i = 0; i < argc - 1; i++) {
                   printf("%s: ", reqs[i]->ar_name);
                   ret = gai_error(reqs[i]);
                   if (ret == 0) {
                       res = reqs[i]->ar_result;
    
                       ret = getnameinfo(res->ai_addr, res->ai_addrlen,
                               host, sizeof(host),
                               NULL, 0, NI_NUMERICHOST);
                       if (ret != 0) {
                           fprintf(stderr, "getnameinfo() failed: %s\n",
                                   gai_strerror(ret));
                           exit(EXIT_FAILURE);
                       }
                       puts(host);
    
                   } else {
                       puts(gai_strerror(ret));
                   }
               }
               exit(EXIT_SUCCESS);
           }
    
       Asynchronous example
           This example shows a simple interactive getaddrinfo_a() front-end.  The
           notification facility is not demonstrated.
    
           An example session might look like this:
    
    
           The program source is as follows:
    
           #define _GNU_SOURCE
           #include <netdb.h>
           #include <stdio.h>
           #include <stdlib.h>
           #include <string.h>
    
           static struct gaicb **reqs = NULL;
           static int nreqs = 0;
    
           static char *
           getcmd(void)
           {
               static char buf[256];
    
               fputs("> ", stdout); fflush(stdout);
               if (fgets(buf, sizeof(buf), stdin) == NULL)
                   return NULL;
    
               if (buf[strlen(buf) - 1] == '\n')
                   buf[strlen(buf) - 1] = 0;
    
               return buf;
           }
    
           /* Add requests for specified hostnames */
           static void
           add_requests(void)
           {
               int nreqs_base = nreqs;
               char *host;
               int ret;
    
               while ((host = strtok(NULL, " "))) {
                   nreqs++;
                   reqs = realloc(reqs, nreqs * sizeof(reqs[0]));
    
                   reqs[nreqs - 1] = calloc(1, sizeof(*reqs[0]));
                   reqs[nreqs - 1]->ar_name = strdup(host);
               }
    
               /* Queue nreqs_base..nreqs requests. */
    
               ret = getaddrinfo_a(GAI_NOWAIT, &reqs[nreqs_base],
                                   nreqs - nreqs_base, NULL);
               if (ret) {
                   fprintf(stderr, "getaddrinfo_a() failed: %s\n",
                           gai_strerror(ret));
                   exit(EXIT_FAILURE);
               }
                   if (n >= nreqs) {
                       printf("Bad request number: %s\n", id);
                       return;
                   }
    
                   wait_reqs[n] = reqs[n];
               }
    
               ret = gai_suspend(wait_reqs, nreqs, NULL);
               if (ret) {
                   printf("gai_suspend(): %s\n", gai_strerror(ret));
                   return;
               }
    
               for (i = 0; i < nreqs; i++) {
                   if (wait_reqs[i] == NULL)
                       continue;
    
                   ret = gai_error(reqs[i]);
                   if (ret == EAI_INPROGRESS)
                       continue;
    
                   printf("[%02d] %s: %s\n", i, reqs[i]->ar_name,
                          ret == 0 ? "Finished" : gai_strerror(ret));
               }
           }
    
           /* Cancel specified requests */
           static void
           cancel_requests(void)
           {
               char *id;
               int ret, n;
    
               while ((id = strtok(NULL, " ")) != NULL) {
                   n = atoi(id);
    
                   if (n >= nreqs) {
                       printf("Bad request number: %s\n", id);
                       return;
                   }
    
                   ret = gai_cancel(reqs[n]);
                   printf("[%s] %s: %s\n", id, reqs[atoi(id)]->ar_name,
                          gai_strerror(ret));
               }
           }
    
           /* List all requests */
           static void
           list_requests(void)
           {
                       if (ret) {
                           fprintf(stderr, "getnameinfo() failed: %s\n",
                                   gai_strerror(ret));
                           exit(EXIT_FAILURE);
                       }
                       puts(host);
                   } else {
                       puts(gai_strerror(ret));
                   }
               }
           }
    
           int
           main(int argc, char *argv[])
           {
               char *cmdline;
               char *cmd;
    
               while ((cmdline = getcmd()) != NULL) {
                   cmd = strtok(cmdline, " ");
    
                   if (cmd == NULL) {
                       list_requests();
                   } else {
                       switch (cmd[0]) {
                       case 'a':
                           add_requests();
                           break;
                       case 'w':
                           wait_requests();
                           break;
                       case 'c':
                           cancel_requests();
                           break;
                       case 'l':
                           list_requests();
                           break;
                       default:
                           fprintf(stderr, "Bad command: %c\n", cmd[0]);
                           break;
                       }
                   }
               }
               exit(EXIT_SUCCESS);
           }
    
    
    

    SEE ALSO

           getaddrinfo(3), inet(3), lio_listio(3), hostname(7), ip(7), sigevent(7)
    
    
    

    GNU 2010-09-27 GETADDRINFO_A(3)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

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