1: /* Cache handling for host lookup.
    2:    Copyright (C) 1998-2005, 2006, 2007 Free Software Foundation, Inc.
    3:    This file is part of the GNU C Library.
    4:    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
    5: 
    6:    This program is free software; you can redistribute it and/or modify
    7:    it under the terms of the GNU General Public License as published
    8:    by the Free Software Foundation; version 2 of the License, or
    9:    (at your option) any later version.
   10: 
   11:    This program is distributed in the hope that it will be useful,
   12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   14:    GNU General Public License for more details.
   15: 
   16:    You should have received a copy of the GNU General Public License
   17:    along with this program; if not, write to the Free Software Foundation,
   18:    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
   19: 
   20: #include <alloca.h>
   21: #include <assert.h>
   22: #include <errno.h>
   23: #include <error.h>
   24: #include <libintl.h>
   25: #include <netdb.h>
   26: #include <stdbool.h>
   27: #include <stddef.h>
   28: #include <stdio.h>
   29: #include <stdlib.h>
   30: #include <string.h>
   31: #include <time.h>
   32: #include <unistd.h>
   33: #include <arpa/inet.h>
   34: #include <arpa/nameser.h>
   35: #include <sys/mman.h>
   36: #include <stackinfo.h>
   37: 
   38: #include "nscd.h"
   39: #include "dbg_log.h"
   40: #ifdef HAVE_SENDFILE
   41: # include <kernel-features.h>
   42: #endif
   43: 
   44: 
   45: /* This is the standard reply in case the service is disabled.  */
   46: static const hst_response_header disabled =
   47: {
   48:   .version = NSCD_VERSION,
   49:   .found = -1,
   50:   .h_name_len = 0,
   51:   .h_aliases_cnt = 0,
   52:   .h_addrtype = -1,
   53:   .h_length = -1,
   54:   .h_addr_list_cnt = 0,
   55:   .error = NETDB_INTERNAL
   56: };
   57: 
   58: /* This is the struct describing how to write this record.  */
   59: const struct iovec hst_iov_disabled =
   60: {
   61:   .iov_base = (void *) &disabled,
   62:   .iov_len = sizeof (disabled)
   63: };
   64: 
   65: 
   66: /* This is the standard reply in case we haven't found the dataset.  */
   67: static const hst_response_header notfound =
   68: {
   69:   .version = NSCD_VERSION,
   70:   .found = 0,
   71:   .h_name_len = 0,
   72:   .h_aliases_cnt = 0,
   73:   .h_addrtype = -1,
   74:   .h_length = -1,
   75:   .h_addr_list_cnt = 0,
   76:   .error = HOST_NOT_FOUND
   77: };
   78: 
   79: 
   80: static void
   81: cache_addhst (struct database_dyn *db, int fd, request_header *req,
   82:               const void *key, struct hostent *hst, uid_t owner,
   83:               struct hashentry *he, struct datahead *dh, int errval)
   84: {
   85:   ssize_t total;
   86:   ssize_t written;
   87:   time_t t = time (NULL);
   88: 
   89:   /* We allocate all data in one memory block: the iov vector,
   90:      the response header and the dataset itself.  */
   91:   struct dataset
   92:   {
   93:     struct datahead head;
   94:     hst_response_header resp;
   95:     char strdata[0];
   96:   } *dataset;
   97: 
   98:   assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
   99: 
  100:   if (hst == NULL)
  101:     {
  102:       if (he != NULL && errval == EAGAIN)
  103:         {
  104:           /* If we have an old record available but cannot find one
  105:              now because the service is not available we keep the old
  106:              record and make sure it does not get removed.  */
  107:           if (reload_count != UINT_MAX)
  108:             /* Do not reset the value if we never not reload the record.  */
  109:             dh->nreloads = reload_count - 1;
  110: 
  111:           written = total = 0;
  112:         }
  113:       else
  114:         {
  115:           /* We have no data.  This means we send the standard reply for this
  116:              case.  */
  117:           written = total = sizeof (notfound);
  118: 
  119:           if (fd != -1)
  120:             written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
  121:                                                 MSG_NOSIGNAL));
  122: 
  123:           dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len);
  124:           /* If we cannot permanently store the result, so be it.  */
  125:           if (dataset != NULL)
  126:             {
  127:               dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
  128:               dataset->head.recsize = total;
  129:               dataset->head.notfound = true;
  130:               dataset->head.nreloads = 0;
  131:               dataset->head.usable = true;
  132: 
  133:               /* Compute the timeout time.  */
  134:               dataset->head.timeout = t + db->negtimeout;
  135: 
  136:               /* This is the reply.  */
  137:               memcpy (&dataset->resp, &notfound, total);
  138: 
  139:               /* Copy the key data.  */
  140:               memcpy (dataset->strdata, key, req->key_len);
  141: 
  142:               /* If necessary, we also propagate the data to disk.  */
  143:               if (db->persistent)
  144:                 {
  145:                   // XXX async OK?
  146:                   uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
  147:                   msync ((void *) pval,
  148:                          ((uintptr_t) dataset & pagesize_m1)
  149:                          + sizeof (struct dataset) + req->key_len, MS_ASYNC);
  150:                 }
  151: 
  152:               /* Now get the lock to safely insert the records.  */
  153:               pthread_rwlock_rdlock (&db->lock);
  154: 
  155:               if (cache_add (req->type, &dataset->strdata, req->key_len,
  156:                              &dataset->head, true, db, owner) < 0)
  157:                 /* Ensure the data can be recovered.  */
  158:                 dataset->head.usable = false;
  159: 
  160:               pthread_rwlock_unlock (&db->lock);
  161: 
  162:               /* Mark the old entry as obsolete.  */
  163:               if (dh != NULL)
  164:                 dh->usable = false;
  165:             }
  166:           else
  167:             ++db->head->addfailed;
  168:         }
  169:     }
  170:   else
  171:     {
  172:       /* Determine the I/O structure.  */
  173:       size_t h_name_len = strlen (hst->h_name) + 1;
  174:       size_t h_aliases_cnt;
  175:       uint32_t *h_aliases_len;
  176:       size_t h_addr_list_cnt;
  177:       int addr_list_type;
  178:       char *addresses;
  179:       char *aliases;
  180:       char *key_copy = NULL;
  181:       char *cp;
  182:       size_t cnt;
  183: 
  184:       /* Determine the number of aliases.  */
  185:       h_aliases_cnt = 0;
  186:       for (cnt = 0; hst->h_aliases[cnt] != NULL; ++cnt)
  187:         ++h_aliases_cnt;
  188:       /* Determine the length of all aliases.  */
  189:       h_aliases_len = (uint32_t *) alloca (h_aliases_cnt * sizeof (uint32_t));
  190:       total = 0;
  191:       for (cnt = 0; cnt < h_aliases_cnt; ++cnt)
  192:         {
  193:           h_aliases_len[cnt] = strlen (hst->h_aliases[cnt]) + 1;
  194:           total += h_aliases_len[cnt];
  195:         }
  196: 
  197:       /* Determine the number of addresses.  */
  198:       h_addr_list_cnt = 0;
  199:       while (hst->h_addr_list[h_addr_list_cnt] != NULL)
  200:         ++h_addr_list_cnt;
  201: 
  202:       if (h_addr_list_cnt == 0)
  203:         /* Invalid entry.  */
  204:         return;
  205: 
  206:       total += (sizeof (struct dataset)
  207:                 + h_name_len
  208:                 + h_aliases_cnt * sizeof (uint32_t)
  209:                 + h_addr_list_cnt * hst->h_length);
  210:       written = total;
  211: 
  212:       /* If we refill the cache, first assume the reconrd did not
  213:          change.  Allocate memory on the cache since it is likely
  214:          discarded anyway.  If it turns out to be necessary to have a
  215:          new record we can still allocate real memory.  */
  216:       bool alloca_used = false;
  217:       dataset = NULL;
  218: 
  219:       /* If the record contains more than one IP address (used for
  220:          load balancing etc) don't cache the entry.  This is something
  221:          the current cache handling cannot handle and it is more than
  222:          questionable whether it is worthwhile complicating the cache
  223:          handling just for handling such a special case. */
  224:       if (he == NULL && h_addr_list_cnt == 1)
  225:         {
  226:           dataset = (struct dataset *) mempool_alloc (db,
  227:                                                       total + req->key_len);
  228:           if (dataset == NULL)
  229:             ++db->head->addfailed;
  230:         }
  231: 
  232:       if (dataset == NULL)
  233:         {
  234:           /* We cannot permanently add the result in the moment.  But
  235:              we can provide the result as is.  Store the data in some
  236:              temporary memory.  */
  237:           dataset = (struct dataset *) alloca (total + req->key_len);
  238: 
  239:           /* We cannot add this record to the permanent database.  */
  240:           alloca_used = true;
  241:         }
  242: 
  243:       dataset->head.allocsize = total + req->key_len;
  244:       dataset->head.recsize = total - offsetof (struct dataset, resp);
  245:       dataset->head.notfound = false;
  246:       dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
  247:       dataset->head.usable = true;
  248: 
  249:       /* Compute the timeout time.  */
  250:       dataset->head.timeout = t + db->postimeout;
  251: 
  252:       dataset->resp.version = NSCD_VERSION;
  253:       dataset->resp.found = 1;
  254:       dataset->resp.h_name_len = h_name_len;
  255:       dataset->resp.h_aliases_cnt = h_aliases_cnt;
  256:       dataset->resp.h_addrtype = hst->h_addrtype;
  257:       dataset->resp.h_length = hst->h_length;
  258:       dataset->resp.h_addr_list_cnt = h_addr_list_cnt;
  259:       dataset->resp.error = NETDB_SUCCESS;
  260: 
  261:       cp = dataset->strdata;
  262: 
  263:       cp = mempcpy (cp, hst->h_name, h_name_len);
  264:       cp = mempcpy (cp, h_aliases_len, h_aliases_cnt * sizeof (uint32_t));
  265: 
  266:       /* The normal addresses first.  */
  267:       addresses = cp;
  268:       for (cnt = 0; cnt < h_addr_list_cnt; ++cnt)
  269:         cp = mempcpy (cp, hst->h_addr_list[cnt], hst->h_length);
  270: 
  271:       /* Then the aliases.  */
  272:       aliases = cp;
  273:       for (cnt = 0; cnt < h_aliases_cnt; ++cnt)
  274:         cp = mempcpy (cp, hst->h_aliases[cnt], h_aliases_len[cnt]);
  275: 
  276:       assert (cp
  277:               == dataset->strdata + total - offsetof (struct dataset,
  278:                                                       strdata));
  279: 
  280:       /* If we are adding a GETHOSTBYNAME{,v6} entry we must be prepared
  281:          that the answer we get from the NSS does not contain the key
  282:          itself.  This is the case if the resolver is used and the name
  283:          is extended by the domainnames from /etc/resolv.conf.  Therefore
  284:          we explicitly add the name here.  */
  285:       key_copy = memcpy (cp, key, req->key_len);
  286: 
  287:       /* Now we can determine whether on refill we have to create a new
  288:          record or not.  */
  289:       if (he != NULL)
  290:         {
  291:           assert (fd == -1);
  292: 
  293:           if (total + req->key_len == dh->allocsize
  294:               && total - offsetof (struct dataset, resp) == dh->recsize
  295:               && memcmp (&dataset->resp, dh->data,
  296:                          dh->allocsize - offsetof (struct dataset, resp)) == 0)
  297:             {
  298:               /* The data has not changed.  We will just bump the
  299:                  timeout value.  Note that the new record has been
  300:                  allocated on the stack and need not be freed.  */
  301:               assert (h_addr_list_cnt == 1);
  302:               dh->timeout = dataset->head.timeout;
  303:               ++dh->nreloads;
  304:             }
  305:           else
  306:             {
  307:               if (h_addr_list_cnt == 1)
  308:                 {
  309:                   /* We have to create a new record.  Just allocate
  310:                      appropriate memory and copy it.  */
  311:                   struct dataset *newp
  312:                     = (struct dataset *) mempool_alloc (db,
  313:                                                         total + req->key_len);
  314:                   if (newp != NULL)
  315:                     {
  316:                       /* Adjust pointers into the memory block.  */
  317:                       addresses = (char *) newp + (addresses
  318:                                                    - (char *) dataset);
  319:                       aliases = (char *) newp + (aliases - (char *) dataset);
  320:                       assert (key_copy != NULL);
  321:                       key_copy = (char *) newp + (key_copy - (char *) dataset);
  322: 
  323:                       dataset = memcpy (newp, dataset, total + req->key_len);
  324:                       alloca_used = false;
  325:                     }
  326:                 }
  327: 
  328:               /* Mark the old record as obsolete.  */
  329:               dh->usable = false;
  330:             }
  331:         }
  332:       else
  333:         {
  334:           /* We write the dataset before inserting it to the database
  335:              since while inserting this thread might block and so would
  336:              unnecessarily keep the receiver waiting.  */
  337:           assert (fd != -1);
  338: 
  339: #ifdef HAVE_SENDFILE
  340:           if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
  341:             {
  342:               assert (db->wr_fd != -1);
  343:               assert ((char *) &dataset->resp > (char *) db->data);
  344:               assert ((char *) &dataset->resp - (char *) db->head
  345:                       + total
  346:                       <= (sizeof (struct database_pers_head)
  347:                           + db->head->module * sizeof (ref_t)
  348:                           + db->head->data_size));
  349:               written = sendfileall (fd, db->wr_fd,
  350:                                      (char *) &dataset->resp
  351:                                      - (char *) db->head, total);
  352: # ifndef __ASSUME_SENDFILE
  353:               if (written == -1 && errno == ENOSYS)
  354:                 goto use_write;
  355: # endif
  356:             }
  357:           else
  358: # ifndef __ASSUME_SENDFILE
  359:           use_write:
  360: # endif
  361: #endif
  362:             written = writeall (fd, &dataset->resp, total);
  363:         }
  364: 
  365:       /* Add the record to the database.  But only if it has not been
  366:          stored on the stack.
  367: 
  368:          If the record contains more than one IP address (used for
  369:          load balancing etc) don't cache the entry.  This is something
  370:          the current cache handling cannot handle and it is more than
  371:          questionable whether it is worthwhile complicating the cache
  372:          handling just for handling such a special case. */
  373:       if (! alloca_used)
  374:         {
  375:           /* If necessary, we also propagate the data to disk.  */
  376:           if (db->persistent)
  377:             {
  378:               // XXX async OK?
  379:               uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
  380:               msync ((void *) pval,
  381:                      ((uintptr_t) dataset & pagesize_m1)
  382:                      + total + req->key_len, MS_ASYNC);
  383:             }
  384: 
  385:           addr_list_type = (hst->h_length == NS_INADDRSZ
  386:                             ? GETHOSTBYADDR : GETHOSTBYADDRv6);
  387: 
  388:           /* Now get the lock to safely insert the records.  */
  389:           pthread_rwlock_rdlock (&db->lock);
  390: 
  391:           /* NB: the following code is really complicated.  It has
  392:              seemlingly duplicated code paths which do the same.  The
  393:              problem is that we always must add the hash table entry
  394:              with the FIRST flag set first.  Otherwise we get dangling
  395:              pointers in case memory allocation fails.  */
  396:           assert (hst->h_addr_list[1] == NULL);
  397: 
  398:           /* Avoid adding names if more than one address is available.  See
  399:              above for more info.  */
  400:           assert (req->type == GETHOSTBYNAME
  401:                   || req->type == GETHOSTBYNAMEv6
  402:                   || req->type == GETHOSTBYADDR
  403:                   || req->type == GETHOSTBYADDRv6);
  404: 
  405:           if (cache_add (req->type, key_copy, req->key_len,
  406:                          &dataset->head, true, db, owner) < 0)
  407:             /* Could not allocate memory.  Make sure the
  408:                data gets discarded.  */
  409:             dataset->head.usable = false;
  410: 
  411:           pthread_rwlock_unlock (&db->lock);
  412:         }
  413:     }
  414: 
  415:   if (__builtin_expect (written != total, 0) && debug_level > 0)
  416:     {
  417:       char buf[256];
  418:       dbg_log (_("short write in %s: %s"),  __FUNCTION__,
  419:                strerror_r (errno, buf, sizeof (buf)));
  420:     }
  421: }
  422: 
  423: 
  424: static int
  425: lookup (int type, void *key, struct hostent *resultbufp, char *buffer,
  426:         size_t buflen, struct hostent **hst)
  427: {
  428:   if (type == GETHOSTBYNAME)
  429:     return __gethostbyname2_r (key, AF_INET, resultbufp, buffer, buflen, hst,
  430:                                &h_errno);
  431:   if (type == GETHOSTBYNAMEv6)
  432:     return __gethostbyname2_r (key, AF_INET6, resultbufp, buffer, buflen, hst,
  433:                                &h_errno);
  434:   if (type == GETHOSTBYADDR)
  435:     return __gethostbyaddr_r (key, NS_INADDRSZ, AF_INET, resultbufp, buffer,
  436:                               buflen, hst, &h_errno);
  437:   return __gethostbyaddr_r (key, NS_IN6ADDRSZ, AF_INET6, resultbufp, buffer,
  438:                             buflen, hst, &h_errno);
  439: }
  440: 
  441: 
  442: static void
  443: addhstbyX (struct database_dyn *db, int fd, request_header *req,
  444:            void *key, uid_t uid, struct hashentry *he, struct datahead *dh)
  445: {
  446:   /* Search for the entry matching the key.  Please note that we don't
  447:      look again in the table whether the dataset is now available.  We
  448:      simply insert it.  It does not matter if it is in there twice.  The
  449:      pruning function only will look at the timestamp.  */
  450:   int buflen = 1024;
  451:   char *buffer = (char *) alloca (buflen);
  452:   struct hostent resultbuf;
  453:   struct hostent *hst;
  454:   bool use_malloc = false;
  455:   int errval = 0;
  456: 
  457:   if (__builtin_expect (debug_level > 0, 0))
  458:     {
  459:       const char *str;
  460:       char buf[INET6_ADDRSTRLEN + 1];
  461:       if (req->type == GETHOSTBYNAME || req->type == GETHOSTBYNAMEv6)
  462:         str = key;
  463:       else
  464:         str = inet_ntop (req->type == GETHOSTBYADDR ? AF_INET : AF_INET6,
  465:                          key, buf, sizeof (buf));
  466: 
  467:       if (he == NULL)
  468:         dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) str);
  469:       else
  470:         dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) str);
  471:     }
  472: 
  473:   while (lookup (req->type, key, &resultbuf, buffer, buflen, &hst) != 0
  474:          && h_errno == NETDB_INTERNAL
  475:          && (errval = errno) == ERANGE)
  476:     {
  477:       errno = 0;
  478: 
  479:       if (__builtin_expect (buflen > 32768, 0))
  480:         {
  481:           char *old_buffer = buffer;
  482:           buflen *= 2;
  483:           buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
  484:           if (buffer == NULL)
  485:             {
  486:               /* We ran out of memory.  We cannot do anything but
  487:                  sending a negative response.  In reality this should
  488:                  never happen.  */
  489:               hst = NULL;
  490:               buffer = old_buffer;
  491: 
  492:               /* We set the error to indicate this is (possibly) a
  493:                  temporary error and that it does not mean the entry
  494:                  is not available at all.  */
  495:               errval = EAGAIN;
  496:               break;
  497:             }
  498:           use_malloc = true;
  499:         }
  500:       else
  501:         /* Allocate a new buffer on the stack.  If possible combine it
  502:            with the previously allocated buffer.  */
  503:         buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
  504:     }
  505: 
  506:   cache_addhst (db, fd, req, key, hst, uid, he, dh,
  507:                 h_errno == TRY_AGAIN ? errval : 0);
  508: 
  509:   if (use_malloc)
  510:     free (buffer);
  511: }
  512: 
  513: 
  514: void
  515: addhstbyname (struct database_dyn *db, int fd, request_header *req,
  516:               void *key, uid_t uid)
  517: {
  518:   addhstbyX (db, fd, req, key, uid, NULL, NULL);
  519: }
  520: 
  521: 
  522: void
  523: readdhstbyname (struct database_dyn *db, struct hashentry *he,
  524:                 struct datahead *dh)
  525: {
  526:   request_header req =
  527:     {
  528:       .type = GETHOSTBYNAME,
  529:       .key_len = he->len
  530:     };
  531: 
  532:   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
  533: }
  534: 
  535: 
  536: void
  537: addhstbyaddr (struct database_dyn *db, int fd, request_header *req,
  538:               void *key, uid_t uid)
  539: {
  540:   addhstbyX (db, fd, req, key, uid, NULL, NULL);
  541: }
  542: 
  543: 
  544: void
  545: readdhstbyaddr (struct database_dyn *db, struct hashentry *he,
  546:                 struct datahead *dh)
  547: {
  548:   request_header req =
  549:     {
  550:       .type = GETHOSTBYADDR,
  551:       .key_len = he->len
  552:     };
  553: 
  554:   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
  555: }
  556: 
  557: 
  558: void
  559: addhstbynamev6 (struct database_dyn *db, int fd,