Replace lll_private_futex_* (*) with lll_futex_* (*, LLL_PRIVATE).
[kopensolaris-gnu/glibc.git] / nscd / hstcache.c
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       for (cnt = 0; hst->h_addr_list[cnt]; ++cnt)
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 && hst->h_addr_list[1] == NULL)
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               dh->timeout = dataset->head.timeout;
302               ++dh->nreloads;
303             }
304           else
305             {
306               /* We have to create a new record.  Just allocate
307                  appropriate memory and copy it.  */
308               struct dataset *newp
309                 = (struct dataset *) mempool_alloc (db, total + req->key_len);
310               if (newp != NULL)
311                 {
312                   /* Adjust pointers into the memory block.  */
313                   addresses = (char *) newp + (addresses - (char *) dataset);
314                   aliases = (char *) newp + (aliases - (char *) dataset);
315                   assert (key_copy != NULL);
316                   key_copy = (char *) newp + (key_copy - (char *) dataset);
317
318                   dataset = memcpy (newp, dataset, total + req->key_len);
319                   alloca_used = false;
320                 }
321
322               /* Mark the old record as obsolete.  */
323               dh->usable = false;
324             }
325         }
326       else
327         {
328           /* We write the dataset before inserting it to the database
329              since while inserting this thread might block and so would
330              unnecessarily keep the receiver waiting.  */
331           assert (fd != -1);
332
333 #ifdef HAVE_SENDFILE
334           if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
335             {
336               assert (db->wr_fd != -1);
337               assert ((char *) &dataset->resp > (char *) db->data);
338               assert ((char *) &dataset->resp - (char *) db->head
339                       + total
340                       <= (sizeof (struct database_pers_head)
341                           + db->head->module * sizeof (ref_t)
342                           + db->head->data_size));
343               written = sendfileall (fd, db->wr_fd,
344                                      (char *) &dataset->resp
345                                      - (char *) db->head, total);
346 # ifndef __ASSUME_SENDFILE
347               if (written == -1 && errno == ENOSYS)
348                 goto use_write;
349 # endif
350             }
351           else
352 # ifndef __ASSUME_SENDFILE
353           use_write:
354 # endif
355 #endif
356             written = writeall (fd, &dataset->resp, total);
357         }
358
359       /* Add the record to the database.  But only if it has not been
360          stored on the stack.
361
362          If the record contains more than one IP address (used for
363          load balancing etc) don't cache the entry.  This is something
364          the current cache handling cannot handle and it is more than
365          questionable whether it is worthwhile complicating the cache
366          handling just for handling such a special case. */
367       if (! alloca_used)
368         {
369           /* If necessary, we also propagate the data to disk.  */
370           if (db->persistent)
371             {
372               // XXX async OK?
373               uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
374               msync ((void *) pval,
375                      ((uintptr_t) dataset & pagesize_m1)
376                      + total + req->key_len, MS_ASYNC);
377             }
378
379           addr_list_type = (hst->h_length == NS_INADDRSZ
380                             ? GETHOSTBYADDR : GETHOSTBYADDRv6);
381
382           /* Now get the lock to safely insert the records.  */
383           pthread_rwlock_rdlock (&db->lock);
384
385           /* NB: the following code is really complicated.  It has
386              seemlingly duplicated code paths which do the same.  The
387              problem is that we always must add the hash table entry
388              with the FIRST flag set first.  Otherwise we get dangling
389              pointers in case memory allocation fails.  */
390           assert (hst->h_addr_list[1] == NULL);
391
392           /* Avoid adding names if more than one address is available.  See
393              above for more info.  */
394           assert (req->type == GETHOSTBYNAME
395                   || req->type == GETHOSTBYNAMEv6
396                   || req->type == GETHOSTBYADDR
397                   || req->type == GETHOSTBYADDRv6);
398
399           if (cache_add (req->type, key_copy, req->key_len,
400                          &dataset->head, true, db, owner) < 0)
401             /* Could not allocate memory.  Make sure the
402                data gets discarded.  */
403             dataset->head.usable = false;
404
405           pthread_rwlock_unlock (&db->lock);
406         }
407     }
408
409   if (__builtin_expect (written != total, 0) && debug_level > 0)
410     {
411       char buf[256];
412       dbg_log (_("short write in %s: %s"),  __FUNCTION__,
413                strerror_r (errno, buf, sizeof (buf)));
414     }
415 }
416
417
418 static int
419 lookup (int type, void *key, struct hostent *resultbufp, char *buffer,
420         size_t buflen, struct hostent **hst)
421 {
422   if (type == GETHOSTBYNAME)
423     return __gethostbyname2_r (key, AF_INET, resultbufp, buffer, buflen, hst,
424                                &h_errno);
425   if (type == GETHOSTBYNAMEv6)
426     return __gethostbyname2_r (key, AF_INET6, resultbufp, buffer, buflen, hst,
427                                &h_errno);
428   if (type == GETHOSTBYADDR)
429     return __gethostbyaddr_r (key, NS_INADDRSZ, AF_INET, resultbufp, buffer,
430                               buflen, hst, &h_errno);
431   return __gethostbyaddr_r (key, NS_IN6ADDRSZ, AF_INET6, resultbufp, buffer,
432                             buflen, hst, &h_errno);
433 }
434
435
436 static void
437 addhstbyX (struct database_dyn *db, int fd, request_header *req,
438            void *key, uid_t uid, struct hashentry *he, struct datahead *dh)
439 {
440   /* Search for the entry matching the key.  Please note that we don't
441      look again in the table whether the dataset is now available.  We
442      simply insert it.  It does not matter if it is in there twice.  The
443      pruning function only will look at the timestamp.  */
444   int buflen = 1024;
445   char *buffer = (char *) alloca (buflen);
446   struct hostent resultbuf;
447   struct hostent *hst;
448   bool use_malloc = false;
449   int errval = 0;
450
451   if (__builtin_expect (debug_level > 0, 0))
452     {
453       const char *str;
454       char buf[INET6_ADDRSTRLEN + 1];
455       if (req->type == GETHOSTBYNAME || req->type == GETHOSTBYNAMEv6)
456         str = key;
457       else
458         str = inet_ntop (req->type == GETHOSTBYADDR ? AF_INET : AF_INET6,
459                          key, buf, sizeof (buf));
460
461       if (he == NULL)
462         dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) str);
463       else
464         dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) str);
465     }
466
467   while (lookup (req->type, key, &resultbuf, buffer, buflen, &hst) != 0
468          && h_errno == NETDB_INTERNAL
469          && (errval = errno) == ERANGE)
470     {
471       errno = 0;
472
473       if (__builtin_expect (buflen > 32768, 0))
474         {
475           char *old_buffer = buffer;
476           buflen *= 2;
477           buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
478           if (buffer == NULL)
479             {
480               /* We ran out of memory.  We cannot do anything but
481                  sending a negative response.  In reality this should
482                  never happen.  */
483               hst = NULL;
484               buffer = old_buffer;
485
486               /* We set the error to indicate this is (possibly) a
487                  temporary error and that it does not mean the entry
488                  is not available at all.  */
489               errval = EAGAIN;
490               break;
491             }
492           use_malloc = true;
493         }
494       else
495         /* Allocate a new buffer on the stack.  If possible combine it
496            with the previously allocated buffer.  */
497         buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
498     }
499
500   cache_addhst (db, fd, req, key, hst, uid, he, dh,
501                 h_errno == TRY_AGAIN ? errval : 0);
502
503   if (use_malloc)
504     free (buffer);
505 }
506
507
508 void
509 addhstbyname (struct database_dyn *db, int fd, request_header *req,
510               void *key, uid_t uid)
511 {
512   addhstbyX (db, fd, req, key, uid, NULL, NULL);
513 }
514
515
516 void
517 readdhstbyname (struct database_dyn *db, struct hashentry *he,
518                 struct datahead *dh)
519 {
520   request_header req =
521     {
522       .type = GETHOSTBYNAME,
523       .key_len = he->len
524     };
525
526   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
527 }
528
529
530 void
531 addhstbyaddr (struct database_dyn *db, int fd, request_header *req,
532               void *key, uid_t uid)
533 {
534   addhstbyX (db, fd, req, key, uid, NULL, NULL);
535 }
536
537
538 void
539 readdhstbyaddr (struct database_dyn *db, struct hashentry *he,
540                 struct datahead *dh)
541 {
542   request_header req =
543     {
544       .type = GETHOSTBYADDR,
545       .key_len = he->len
546     };
547
548   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
549 }
550
551
552 void
553 addhstbynamev6 (struct database_dyn *db, int fd, request_header *req,
554                 void *key, uid_t uid)
555 {
556   addhstbyX (db, fd, req, key, uid, NULL, NULL);
557 }
558
559
560 void
561 readdhstbynamev6 (struct database_dyn *db, struct hashentry *he,
562                   struct datahead *dh)
563 {
564   request_header req =
565     {
566       .type = GETHOSTBYNAMEv6,
567       .key_len = he->len
568     };
569
570   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
571 }
572
573
574 void
575 addhstbyaddrv6 (struct database_dyn *db, int fd, request_header *req,
576                 void *key, uid_t uid)
577 {
578   addhstbyX (db, fd, req, key, uid, NULL, NULL);
579 }
580
581
582 void
583 readdhstbyaddrv6 (struct database_dyn *db, struct hashentry *he,
584                   struct datahead *dh)
585 {
586   request_header req =
587     {
588       .type = GETHOSTBYADDRv6,
589       .key_len = he->len
590     };
591
592   addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
593 }