d4dd51f11aff7c2ee17526c1388c8f33674e3268
[kopensolaris-gnu/glibc.git] / nscd / hstcache.c
1 /* Cache handling for host lookup.
2    Copyright (C) 1998-2005, 2006, 2007, 2008 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               int32_t ttl)
85 {
86   ssize_t total;
87   ssize_t written;
88   time_t t = time (NULL);
89
90   /* We allocate all data in one memory block: the iov vector,
91      the response header and the dataset itself.  */
92   struct dataset
93   {
94     struct datahead head;
95     hst_response_header resp;
96     char strdata[0];
97   } *dataset;
98
99   assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
100
101   if (hst == NULL)
102     {
103       if (he != NULL && errval == EAGAIN)
104         {
105           /* If we have an old record available but cannot find one
106              now because the service is not available we keep the old
107              record and make sure it does not get removed.  */
108           if (reload_count != UINT_MAX)
109             /* Do not reset the value if we never not reload the record.  */
110             dh->nreloads = reload_count - 1;
111
112           written = total = 0;
113         }
114       else
115         {
116           /* We have no data.  This means we send the standard reply for this
117              case.  */
118           written = total = sizeof (notfound);
119
120           if (fd != -1)
121             written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
122                                                 MSG_NOSIGNAL));
123
124           dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len,
125                                    IDX_result_data);
126           /* If we cannot permanently store the result, so be it.  */
127           if (dataset != NULL)
128             {
129               dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
130               dataset->head.recsize = total;
131               dataset->head.notfound = true;
132               dataset->head.nreloads = 0;
133               dataset->head.usable = true;
134
135               /* Compute the timeout time.  */
136               dataset->head.timeout = t + (ttl == INT32_MAX
137                                            ? db->negtimeout : ttl);
138
139               /* This is the reply.  */
140               memcpy (&dataset->resp, &notfound, total);
141
142               /* Copy the key data.  */
143               memcpy (dataset->strdata, key, req->key_len);
144
145               /* If necessary, we also propagate the data to disk.  */
146               if (db->persistent)
147                 {
148                   // XXX async OK?
149                   uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
150                   msync ((void *) pval,
151                          ((uintptr_t) dataset & pagesize_m1)
152                          + sizeof (struct dataset) + req->key_len, MS_ASYNC);
153                 }
154
155               /* Now get the lock to safely insert the records.  */
156               pthread_rwlock_rdlock (&db->lock);
157
158               (void) cache_add (req->type, &dataset->strdata, req->key_len,
159                                 &dataset->head, true, db, owner, he == NULL);
160
161               pthread_rwlock_unlock (&db->lock);
162
163               /* Mark the old entry as obsolete.  */
164               if (dh != NULL)
165                 dh->usable = false;
166             }
167           else
168             ++db->head->addfailed;
169         }
170     }
171   else
172     {
173       /* Determine the I/O structure.  */
174       size_t h_name_len = strlen (hst->h_name) + 1;
175       size_t h_aliases_cnt;
176       uint32_t *h_aliases_len;
177       size_t h_addr_list_cnt;
178       int addr_list_type;
179       char *addresses;
180       char *aliases;
181       char *key_copy = NULL;
182       char *cp;
183       size_t cnt;
184
185       /* Determine the number of aliases.  */
186       h_aliases_cnt = 0;
187       for (cnt = 0; hst->h_aliases[cnt] != NULL; ++cnt)
188         ++h_aliases_cnt;
189       /* Determine the length of all aliases.  */
190       h_aliases_len = (uint32_t *) alloca (h_aliases_cnt * sizeof (uint32_t));
191       total = 0;
192       for (cnt = 0; cnt < h_aliases_cnt; ++cnt)
193         {
194           h_aliases_len[cnt] = strlen (hst->h_aliases[cnt]) + 1;
195           total += h_aliases_len[cnt];
196         }
197
198       /* Determine the number of addresses.  */
199       h_addr_list_cnt = 0;
200       while (hst->h_addr_list[h_addr_list_cnt] != NULL)
201         ++h_addr_list_cnt;
202
203       if (h_addr_list_cnt == 0)
204         /* Invalid entry.  */
205         return;
206
207       total += (sizeof (struct dataset)
208                 + h_name_len
209                 + h_aliases_cnt * sizeof (uint32_t)
210                 + h_addr_list_cnt * hst->h_length);
211       written = total;
212
213       /* If we refill the cache, first assume the reconrd did not
214          change.  Allocate memory on the cache since it is likely
215          discarded anyway.  If it turns out to be necessary to have a
216          new record we can still allocate real memory.  */
217       bool alloca_used = false;
218       dataset = NULL;
219
220       /* If the record contains more than one IP address (used for
221          load balancing etc) don't cache the entry.  This is something
222          the current cache handling cannot handle and it is more than
223          questionable whether it is worthwhile complicating the cache
224          handling just for handling such a special case. */
225       if (he == NULL && h_addr_list_cnt == 1)
226         {
227           dataset = (struct dataset *) mempool_alloc (db,
228                                                       total + req->key_len,
229                                                       IDX_result_data);
230           if (dataset == NULL)
231             ++db->head->addfailed;
232         }
233
234       if (dataset == NULL)
235         {
236           /* We cannot permanently add the result in the moment.  But
237              we can provide the result as is.  Store the data in some
238              temporary memory.  */
239           dataset = (struct dataset *) alloca (total + req->key_len);
240
241           /* We cannot add this record to the permanent database.  */
242           alloca_used = true;
243         }
244
245       dataset->head.allocsize = total + req->key_len;
246       dataset->head.recsize = total - offsetof (struct dataset, resp);
247       dataset->head.notfound = false;
248       dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1);
249       dataset->head.usable = true;
250
251       /* Compute the timeout time.  */
252       dataset->head.timeout = t + (ttl == INT32_MAX ? db->postimeout : ttl);
253
254       dataset->resp.version = NSCD_VERSION;
255       dataset->resp.found = 1;
256       dataset->resp.h_name_len = h_name_len;
257       dataset->resp.h_aliases_cnt = h_aliases_cnt;
258       dataset->resp.h_addrtype = hst->h_addrtype;
259       dataset->resp.h_length = hst->h_length;
260       dataset->resp.h_addr_list_cnt = h_addr_list_cnt;
261       dataset->resp.error = NETDB_SUCCESS;
262
263       cp = dataset->strdata;
264
265       cp = mempcpy (cp, hst->h_name, h_name_len);
266       cp = mempcpy (cp, h_aliases_len, h_aliases_cnt * sizeof (uint32_t));
267
268       /* The normal addresses first.  */
269       addresses = cp;
270       for (cnt = 0; cnt < h_addr_list_cnt; ++cnt)
271         cp = mempcpy (cp, hst->h_addr_list[cnt], hst->h_length);
272
273       /* Then the aliases.  */
274       aliases = cp;
275       for (cnt = 0; cnt < h_aliases_cnt; ++cnt)
276         cp = mempcpy (cp, hst->h_aliases[cnt], h_aliases_len[cnt]);
277
278       assert (cp
279               == dataset->strdata + total - offsetof (struct dataset,
280                                                       strdata));
281
282       /* If we are adding a GETHOSTBYNAME{,v6} entry we must be prepared
283          that the answer we get from the NSS does not contain the key
284          itself.  This is the case if the resolver is used and the name
285          is extended by the domainnames from /etc/resolv.conf.  Therefore
286          we explicitly add the name here.  */
287       key_copy = memcpy (cp, key, req->key_len);
288
289       /* Now we can determine whether on refill we have to create a new
290          record or not.  */
291       if (he != NULL)
292         {
293           assert (fd == -1);
294
295           if (total + req->key_len == dh->allocsize
296               && total - offsetof (struct dataset, resp) == dh->recsize
297               && memcmp (&dataset->resp, dh->data,
298                          dh->allocsize - offsetof (struct dataset, resp)) == 0)
299             {
300               /* The data has not changed.  We will just bump the
301                  timeout value.  Note that the new record has been
302                  allocated on the stack and need not be freed.  */
303               assert (h_addr_list_cnt == 1);
304               dh->timeout = dataset->head.timeout;
305               ++dh->nreloads;
306             }
307           else
308             {
309               if (h_addr_list_cnt == 1)
310                 {
311                   /* We have to create a new record.  Just allocate
312                      appropriate memory and copy it.  */
313                   struct dataset *newp
314                     = (struct dataset *) mempool_alloc (db,
315                                                         total + req->key_len,
316                                                         IDX_result_data);
317                   if (newp != NULL)
318                     {
319                       /* Adjust pointers into the memory block.  */
320                       addresses = (char *) newp + (addresses
321                                                    - (char *) dataset);
322                       aliases = (char *) newp + (aliases - (char *) dataset);
323                       assert (key_copy != NULL);
324                       key_copy = (char *) newp + (key_copy - (char *) dataset);
325
326                       dataset = memcpy (newp, dataset, total + req->key_len);
327                       alloca_used = false;
328                     }
329                   else
330                     ++db->head->addfailed;
331                 }
332
333               /* Mark the old record as obsolete.  */
334               dh->usable = false;
335             }
336         }
337       else
338         {
339           /* We write the dataset before inserting it to the database
340              since while inserting this thread might block and so would
341              unnecessarily keep the receiver waiting.  */
342           assert (fd != -1);
343
344 #ifdef HAVE_SENDFILE
345           if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
346             {
347               assert (db->wr_fd != -1);
348               assert ((char *) &dataset->resp > (char *) db->data);
349               assert ((char *) &dataset->resp - (char *) db->head
350                       + total
351                       <= (sizeof (struct database_pers_head)
352                           + db->head->module * sizeof (ref_t)
353                           + db->head->data_size));
354               written = sendfileall (fd, db->wr_fd,
355                                      (char *) &dataset->resp
356                                      - (char *) db->head, total);
357 # ifndef __ASSUME_SENDFILE
358               if (written == -1 && errno == ENOSYS)
359                 goto use_write;
360 # endif
361             }
362           else
363 # ifndef __ASSUME_SENDFILE
364           use_write:
365 # endif
366 #endif
367             written = writeall (fd, &dataset->resp, total);
368         }
369
370       /* Add the record to the database.  But only if it has not been
371          stored on the stack.
372
373          If the record contains more than one IP address (used for
374          load balancing etc) don't cache the entry.  This is something
375          the current cache handling cannot handle and it is more than
376          questionable whether it is worthwhile complicating the cache
377          handling just for handling such a special case. */
378       if (! alloca_used)
379         {
380           /* If necessary, we also propagate the data to disk.  */
381           if (db->persistent)
382             {
383               // XXX async OK?
384               uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
385               msync ((void *) pval,
386                      ((uintptr_t) dataset & pagesize_m1)
387                      + total + req->key_len, MS_ASYNC);
388             }
389
390           addr_list_type = (hst->h_length == NS_INADDRSZ
391                             ? GETHOSTBYADDR : GETHOSTBYADDRv6);
392
393           /* Now get the lock to safely insert the records.  */
394           pthread_rwlock_rdlock (&db->lock);
395
396           /* NB: the following code is really complicated.  It has
397              seemlingly duplicated code paths which do the same.  The
398              problem is that we always must add the hash table entry
399              with the FIRST flag set first.  Otherwise we get dangling
400              pointers in case memory allocation fails.  */
401           assert (hst->h_addr_list[1] == NULL);
402
403           /* Avoid adding names if more than one address is available.  See
404              above for more info.  */
405           assert (req->type == GETHOSTBYNAME
406                   || req->type == GETHOSTBYNAMEv6
407                   || req->type == GETHOSTBYADDR
408                   || req->type == GETHOSTBYADDRv6);
409
410           (void) cache_add (req->type, key_copy, req->key_len,
411                             &dataset->head, true, db, owner, he == NULL);
412
413           pthread_rwlock_unlock (&db->lock);
414         }
415     }
416
417   if (__builtin_expect (written != total, 0) && debug_level > 0)
418     {
419       char buf[256];
420       dbg_log (_("short write in %s: %s"),  __FUNCTION__,
421                strerror_r (errno, buf, sizeof (buf)));
422     }
423 }
424
425
426 static int
427 lookup (int type, void *key, struct hostent *resultbufp, char *buffer,
428         size_t buflen, struct hostent **hst, int32_t *ttlp)
429 {
430   if (type == GETHOSTBYNAME)
431     return __gethostbyname3_r (key, AF_INET, resultbufp, buffer, buflen, hst,
432                                &h_errno, ttlp, NULL);
433   if (type == GETHOSTBYNAMEv6)
434     return __gethostbyname3_r (key, AF_INET6, resultbufp, buffer, buflen, hst,
435                                &h_errno, ttlp, NULL);
436   if (type == GETHOSTBYADDR)
437     return __gethostbyaddr2_r (key, NS_INADDRSZ, AF_INET, resultbufp, buffer,
438                                buflen, hst, &h_errno, ttlp);
439   return __gethostbyaddr2_r (key, NS_IN6ADDRSZ, AF_INET6, resultbufp, buffer,
440                              buflen, hst, &h_errno, ttlp);
441 }
442
443
444 static void
445 addhstbyX (struct database_dyn *db, int fd, request_header *req,
446            void *key, uid_t uid, struct hashentry *he, struct datahead *dh)
447 {
448   /* Search for the entry matching the key.  Please note that we don't
449      look again in the table whether the dataset is now available.  We
450      simply insert it.  It does not matter if it is in there twice.  The
451      pruning function only will look at the timestamp.  */
452   int buflen = 1024;
453   char *buffer = (char *) alloca (buflen);
454   struct hostent resultbuf;
455   struct hostent *hst;
456   bool use_malloc = false;
457   int errval = 0;
458   int32_t ttl = INT32_MAX;
459
460   if (__builtin_expect (debug_level > 0, 0))
461     {
462       const char *str;
463       char buf[INET6_ADDRSTRLEN + 1];
464       if (req->type == GETHOSTBYNAME || req->type == GETHOSTBYNAMEv6)
465         str = key;
466       else
467         str = inet_ntop (req->type == GETHOSTBYADDR ? AF_INET : AF_INET6,
468                          key, buf, sizeof (buf));
469
470       if (he == NULL)
471         dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) str);
472       else
473         dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) str);
474     }
475
476   while (lookup (req->type, key, &resultbuf, buffer, buflen, &hst, &ttl) != 0
477          && h_errno == NETDB_INTERNAL
478          && (errval = errno) == ERANGE)
479     {
480       errno = 0;
481
482       if (__builtin_expect (buflen > 32768, 0))
483         {
484           char *old_buffer = buffer;
485           buflen *= 2;
486           buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
487           if (buffer == NULL)
488             {
489               /* We ran out of memory.  We cannot do anything but
490                  sending a negative response.  In reality this should
491                  never happen.  */
492               hst = NULL;
493               buffer = old_buffer;
494
495               /* We set the error to indicate this is (possibly) a
496                  temporary error and that it does not mean the entry
497                  is not available at all.  */
498               errval = EAGAIN;
499               break;
500             }
501           use_malloc = true;
502         }
503       else
504         /* Allocate a new buffer on the stack.  If possible combine it
505            with the previously allocated buffer.  */
506         buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
507     }
508
509   cache_addhst (db, fd, req, key, hst, uid, he, dh,
510                 h_errno == TRY_AGAIN ? errval : 0, ttl);
511
512   if (use_malloc)
513     free (buffer);
514 }
515
516
517 void
518 addhstbyname (struct database_dyn *db, int fd, request_header *req,
519               void *key, uid_t uid)
520 {
521   addhstbyX (db, fd, req, key, uid, NULL, NULL);
522 }
523
524
525 void
526 readdhstbyname (struct database_dyn *db, struct hashentry *he,
527                 struct datahead *dh)
528 {
529   request_header req =
530     {
531       .type = GETHOSTBYNAME,
532       .key_len = he->len
533     };
534
535   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
536 }
537
538
539 void
540 addhstbyaddr (struct database_dyn *db, int fd, request_header *req,
541               void *key, uid_t uid)
542 {
543   addhstbyX (db, fd, req, key, uid, NULL, NULL);
544 }
545
546
547 void
548 readdhstbyaddr (struct database_dyn *db, struct hashentry *he,
549                 struct datahead *dh)
550 {
551   request_header req =
552     {
553       .type = GETHOSTBYADDR,
554       .key_len = he->len
555     };
556
557   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
558 }
559
560
561 void
562 addhstbynamev6 (struct database_dyn *db, int fd, request_header *req,
563                 void *key, uid_t uid)
564 {
565   addhstbyX (db, fd, req, key, uid, NULL, NULL);
566 }
567
568
569 void
570 readdhstbynamev6 (struct database_dyn *db, struct hashentry *he,
571                   struct datahead *dh)
572 {
573   request_header req =
574     {
575       .type = GETHOSTBYNAMEv6,
576       .key_len = he->len
577     };
578
579   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
580 }
581
582
583 void
584 addhstbyaddrv6 (struct database_dyn *db, int fd, request_header *req,
585                 void *key, uid_t uid)
586 {
587   addhstbyX (db, fd, req, key, uid, NULL, NULL);
588 }
589
590
591 void
592 readdhstbyaddrv6 (struct database_dyn *db, struct hashentry *he,
593                   struct datahead *dh)
594 {
595   request_header req =
596     {
597       .type = GETHOSTBYADDRv6,
598       .key_len = he->len
599     };
600
601   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
602 }