nscd/nscd_getai.c

   1 /* Copyright (C) 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <netdb.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26 #include <not-cancel.h>
  27
  28 #include "nscd-client.h"
  29 #include "nscd_proto.h"
  30
  31
  32 /* Define in nscd_gethst_r.c.  */
  33 extern int __nss_not_use_nscd_hosts;
  34
  35
  36 /* We use the mapping from nscd_gethst.  */
  37 libc_locked_map_ptr (extern, __hst_map_handle);
  38
  39
  40 int
  41 __nscd_getai (const char *key, struct nscd_ai_result **result, int *h_errnop)
  42 {
  43   size_t keylen = strlen (key) + 1;
  44   int gc_cycle;
  45
  46   /* If the mapping is available, try to search there instead of
  47      communicating with the nscd.  */
  48   struct mapped_database *mapped;
  49   mapped = __nscd_get_map_ref (GETFDHST, "hosts", &__hst_map_handle,
  50                                &gc_cycle);
  51
  52  retry:;
  53   const ai_response_header *ai_resp = NULL;
  54   struct nscd_ai_result *resultbuf = NULL;
  55   const char *recend = (const char *) ~UINTMAX_C (0);
  56   char *respdata = NULL;
  57   int retval = -1;
  58   int sock = -1;
  59
  60   if (mapped != NO_MAPPING)
  61     {
  62       const struct datahead *found = __nscd_cache_search (GETAI, key, keylen,
  63                                                           mapped);
  64       if (found != NULL)
  65         {
  66           ai_resp = &found->data[0].aidata;
  67           respdata = (char *) (ai_resp + 1);
  68           recend = (const char *) found->data + found->recsize;
  69         }
  70     }
  71
  72   /* If we do not have the cache mapped, try to get the data over the
  73      socket.  */
  74   ai_response_header ai_resp_mem;
  75   if (ai_resp == NULL)
  76     {
  77       sock = __nscd_open_socket (key, keylen, GETAI, &ai_resp_mem,
  78                                  sizeof (ai_resp_mem));
  79       if (sock == -1)
  80         {
  81           /* nscd not running or wrong version or hosts caching disabled.  */
  82           __nss_not_use_nscd_hosts = 1;
  83           goto out;
  84         }
  85
  86       ai_resp = &ai_resp_mem;
  87     }
  88
  89   if (ai_resp->found == 1)
  90     {
  91       size_t datalen = ai_resp->naddrs + ai_resp->addrslen + ai_resp->canonlen;
  92
  93       /* This check is really only affects the case where the data
  94          comes from the mapped cache.  */
  95       if ((char *) (ai_resp + 1) + datalen > recend)
  96         {
  97           assert (sock == -1);
  98           goto out;
  99         }
 100
 101       /* Create result.  */
 102       resultbuf = (struct nscd_ai_result *) malloc (sizeof (*resultbuf)
 103                                                     + datalen);
 104       if (resultbuf == NULL)
 105         {
 106           *h_errnop = NETDB_INTERNAL;
 107           goto out_close;
 108         }
 109
 110       /* Set up the data structure, including pointers.  */
 111       resultbuf->naddrs = ai_resp->naddrs;
 112       resultbuf->addrs = (char *) (resultbuf + 1);
 113       resultbuf->family = (uint8_t *) (resultbuf->addrs + ai_resp->addrslen);
 114       if (ai_resp->canonlen != 0)
 115         resultbuf->canon = (char *) (resultbuf->family + resultbuf->naddrs);
 116       else
 117         resultbuf->canon = NULL;
 118
 119       if (respdata == NULL)
 120         {
 121           /* Read the data from the socket.  */
 122           if ((size_t) TEMP_FAILURE_RETRY (__read (sock, resultbuf + 1,
 123                                                    datalen)) == datalen)
 124             {
 125               retval = 0;
 126               *result = resultbuf;
 127             }
 128           else
 129             {
 130               free (resultbuf);
 131               *h_errnop = NETDB_INTERNAL;
 132             }
 133         }
 134       else
 135         {
 136           /* Copy the data in the block.  */
 137           memcpy (resultbuf + 1, respdata, datalen);
 138
 139           /* Try to detect corrupt databases.  */
 140           if (resultbuf->canon != NULL
 141               && resultbuf->canon[ai_resp->canonlen - 1] != '\0')
 142             /* We cannot use the database.  */
 143             {
 144               free (resultbuf);
 145               goto out_close;
 146             }
 147
 148           retval = 0;
 149           *result = resultbuf;
 150         }
 151     }
 152   else
 153     {
 154       /* Store the error number.  */
 155       *h_errnop = ai_resp->error;
 156
 157       /* The `errno' to some value != ERANGE.  */
 158       __set_errno (ENOENT);
 159       /* Even though we have not found anything, the result is zero.  */
 160       retval = 0;
 161     }
 162
 163  out_close:
 164   if (sock != -1)
 165     close_not_cancel_no_status (sock);
 166  out:
 167   if (__nscd_drop_map_ref (mapped, &gc_cycle) != 0 && retval != -1)
 168     {
 169       /* When we come here this means there has been a GC cycle while we
 170          were looking for the data.  This means the data might have been
 171          inconsistent.  Retry if possible.  */
 172       if ((gc_cycle & 1) != 0)
 173         {
 174           /* nscd is just running gc now.  Disable using the mapping.  */
 175           __nscd_unmap (mapped);
 176           mapped = NO_MAPPING;
 177         }
 178
 179       *result = NULL;
 180       free (resultbuf);
 181
 182       goto retry;
 183     }
 184
 185   return retval;
 186 }