Back to index

glibc  2.9
Classes | Functions
getaddrinfo_a.c File Reference
#include <errno.h>
#include <netdb.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <gai_misc.h>

Go to the source code of this file.

Classes

struct  async_waitlist

Functions

int getaddrinfo_a (int mode, struct gaicb *list[], int ent, struct sigevent *sig)

Class Documentation

struct async_waitlist

Definition at line 30 of file getaddrinfo_a.c.

Class Members
int counter

Function Documentation

int getaddrinfo_a ( int  mode,
struct gaicb *  list[],
int  ent,
struct sigevent *  sig 
)

Definition at line 39 of file getaddrinfo_a.c.

{
  struct sigevent defsigev;
  struct requestlist *requests[ent];
  int cnt;
  volatile int total = 0;
  int result = 0;

  /* Check arguments.  */
  if (mode != GAI_WAIT && mode != GAI_NOWAIT)
    {
      __set_errno (EINVAL);
      return EAI_SYSTEM;
    }

  if (sig == NULL)
    {
      defsigev.sigev_notify = SIGEV_NONE;
      sig = &defsigev;
    }

  /* Request the mutex.  */
  pthread_mutex_lock (&__gai_requests_mutex);

  /* Now we can enqueue all requests.  Since we already acquired the
     mutex the enqueue function need not do this.  */
  for (cnt = 0; cnt < ent; ++cnt)
    if (list[cnt] != NULL)
      {
       requests[cnt] = __gai_enqueue_request (list[cnt]);

       if (requests[cnt] != NULL)
         /* Successfully enqueued.  */
         ++total;
       else
         /* Signal that we've seen an error.  `errno' and the error code
            of the gaicb will tell more.  */
         result = EAI_SYSTEM;
      }
    else
      requests[cnt] = NULL;

  if (total == 0)
    {
      /* We don't have anything to do except signalling if we work
        asynchronously.  */

      /* Release the mutex.  We do this before raising a signal since the
        signal handler might do a `siglongjmp' and then the mutex is
        locked forever.  */
      pthread_mutex_unlock (&__gai_requests_mutex);

      if (mode == GAI_NOWAIT)
       __gai_notify_only (sig,
                        sig->sigev_notify == SIGEV_SIGNAL ? getpid () : 0);

      return result;
    }
  else if (mode == GAI_WAIT)
    {
#ifndef DONT_NEED_GAI_MISC_COND
      pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
#endif
      struct waitlist waitlist[ent];
      int oldstate;

      total = 0;
      for (cnt = 0; cnt < ent; ++cnt)
       if (requests[cnt] != NULL)
         {
#ifndef DONT_NEED_GAI_MISC_COND
           waitlist[cnt].cond = &cond;
#endif
           waitlist[cnt].next = requests[cnt]->waiting;
           waitlist[cnt].counterp = &total;
           waitlist[cnt].sigevp = NULL;
           waitlist[cnt].caller_pid = 0;  /* Not needed.  */
           requests[cnt]->waiting = &waitlist[cnt];
           ++total;
         }

      /* Since `pthread_cond_wait'/`pthread_cond_timedwait' are cancelation
        points we must be careful.  We added entries to the waiting lists
        which we must remove.  So defer cancelation for now.  */
      pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &oldstate);

      while (total > 0)
       {
#ifdef DONT_NEED_GAI_MISC_COND
         int result;
         GAI_MISC_WAIT (result, total, NULL, 1);
#else
         pthread_cond_wait (&cond, &__gai_requests_mutex);
#endif
       }

      /* Now it's time to restore the cancelation state.  */
      pthread_setcancelstate (oldstate, NULL);

#ifndef DONT_NEED_GAI_MISC_COND
      /* Release the conditional variable.  */
      if (pthread_cond_destroy (&cond) != 0)
       /* This must never happen.  */
       abort ();
#endif
    }
  else
    {
      struct async_waitlist *waitlist;

      waitlist = (struct async_waitlist *)
       malloc (sizeof (struct async_waitlist)
              + (ent * sizeof (struct waitlist)));

      if (waitlist == NULL)
       result = EAI_AGAIN;
      else
       {
         pid_t caller_pid = sig->sigev_notify == SIGEV_SIGNAL ? getpid () : 0;
         total = 0;

         for (cnt = 0; cnt < ent; ++cnt)
           if (requests[cnt] != NULL)
             {
#ifndef DONT_NEED_GAI_MISC_COND
              waitlist->list[cnt].cond = NULL;
#endif
              waitlist->list[cnt].next = requests[cnt]->waiting;
              waitlist->list[cnt].counterp = &waitlist->counter;
              waitlist->list[cnt].sigevp = &waitlist->sigev;
              waitlist->list[cnt].caller_pid = caller_pid;
              requests[cnt]->waiting = &waitlist->list[cnt];
              ++total;
             }

         waitlist->counter = total;
         waitlist->sigev = *sig;
       }
    }

  /* Release the mutex.  */
  pthread_mutex_unlock (&__gai_requests_mutex);

  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function: