Add more tests of exp, exp10, exp2, expm1.
[glibc.git] / nscd / aicache.c
blob937cb93203ccc51f4775fe1791f6e7354b627446
1 /* Cache handling for host lookup.
2 Copyright (C) 2004-2015 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
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.
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.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, see <http://www.gnu.org/licenses/>. */
19 #include <assert.h>
20 #include <errno.h>
21 #include <libintl.h>
22 #include <netdb.h>
23 #include <nss.h>
24 #include <string.h>
25 #include <time.h>
26 #include <unistd.h>
27 #include <sys/mman.h>
28 #include <resolv/res_hconf.h>
30 #include "dbg_log.h"
31 #include "nscd.h"
32 #ifdef HAVE_SENDFILE
33 # include <kernel-features.h>
34 #endif
37 typedef enum nss_status (*nss_gethostbyname4_r)
38 (const char *name, struct gaih_addrtuple **pat,
39 char *buffer, size_t buflen, int *errnop,
40 int *h_errnop, int32_t *ttlp);
41 typedef enum nss_status (*nss_gethostbyname3_r)
42 (const char *name, int af, struct hostent *host,
43 char *buffer, size_t buflen, int *errnop,
44 int *h_errnop, int32_t *, char **);
45 typedef enum nss_status (*nss_getcanonname_r)
46 (const char *name, char *buffer, size_t buflen, char **result,
47 int *errnop, int *h_errnop);
50 static const ai_response_header notfound =
52 .version = NSCD_VERSION,
53 .found = 0,
54 .naddrs = 0,
55 .addrslen = 0,
56 .canonlen = 0,
57 .error = 0
61 static time_t
62 addhstaiX (struct database_dyn *db, int fd, request_header *req,
63 void *key, uid_t uid, struct hashentry *const he,
64 struct datahead *dh)
66 /* Search for the entry matching the key. Please note that we don't
67 look again in the table whether the dataset is now available. We
68 simply insert it. It does not matter if it is in there twice. The
69 pruning function only will look at the timestamp. */
71 /* We allocate all data in one memory block: the iov vector,
72 the response header and the dataset itself. */
73 struct dataset
75 struct datahead head;
76 ai_response_header resp;
77 char strdata[0];
78 } *dataset = NULL;
80 if (__glibc_unlikely (debug_level > 0))
82 if (he == NULL)
83 dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key);
84 else
85 dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key);
88 static service_user *hosts_database;
89 service_user *nip;
90 int no_more;
91 int rc6 = 0;
92 int rc4 = 0;
93 int herrno = 0;
95 if (hosts_database == NULL)
96 no_more = __nss_database_lookup ("hosts", NULL,
97 "dns [!UNAVAIL=return] files",
98 &hosts_database);
99 else
100 no_more = 0;
101 nip = hosts_database;
103 /* Initialize configurations. */
104 if (__glibc_unlikely (!_res_hconf.initialized))
105 _res_hconf_init ();
106 if (__res_maybe_init (&_res, 0) == -1)
107 no_more = 1;
109 /* If we are looking for both IPv4 and IPv6 address we don't want
110 the lookup functions to automatically promote IPv4 addresses to
111 IPv6 addresses. Currently this is decided by setting the
112 RES_USE_INET6 bit in _res.options. */
113 int old_res_options = _res.options;
114 _res.options &= ~RES_USE_INET6;
116 size_t tmpbuf6len = 1024;
117 char *tmpbuf6 = alloca (tmpbuf6len);
118 size_t tmpbuf4len = 0;
119 char *tmpbuf4 = NULL;
120 int32_t ttl = INT32_MAX;
121 ssize_t total = 0;
122 char *key_copy = NULL;
123 bool alloca_used = false;
124 time_t timeout = MAX_TIMEOUT_VALUE;
126 while (!no_more)
128 void *cp;
129 int status[2] = { NSS_STATUS_UNAVAIL, NSS_STATUS_UNAVAIL };
130 int naddrs = 0;
131 size_t addrslen = 0;
132 char *canon = NULL;
133 size_t canonlen;
135 nss_gethostbyname4_r fct4 = __nss_lookup_function (nip,
136 "gethostbyname4_r");
137 if (fct4 != NULL)
139 struct gaih_addrtuple atmem;
140 struct gaih_addrtuple *at;
141 while (1)
143 at = &atmem;
144 rc6 = 0;
145 herrno = 0;
146 status[1] = DL_CALL_FCT (fct4, (key, &at, tmpbuf6, tmpbuf6len,
147 &rc6, &herrno, &ttl));
148 if (rc6 != ERANGE || (herrno != NETDB_INTERNAL
149 && herrno != TRY_AGAIN))
150 break;
151 tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
154 if (rc6 != 0 && herrno == NETDB_INTERNAL)
155 goto out;
157 if (status[1] != NSS_STATUS_SUCCESS)
158 goto next_nip;
160 /* We found the data. Count the addresses and the size. */
161 for (const struct gaih_addrtuple *at2 = at = &atmem; at2 != NULL;
162 at2 = at2->next)
164 ++naddrs;
165 /* We do not handle anything other than IPv4 and IPv6
166 addresses. The getaddrinfo implementation does not
167 either so it is not worth trying to do more. */
168 if (at2->family == AF_INET)
169 addrslen += INADDRSZ;
170 else if (at2->family == AF_INET6)
171 addrslen += IN6ADDRSZ;
173 canon = at->name;
174 canonlen = strlen (canon) + 1;
176 total = sizeof (*dataset) + naddrs + addrslen + canonlen;
178 /* Now we can allocate the data structure. If the TTL of the
179 entry is reported as zero do not cache the entry at all. */
180 if (ttl != 0 && he == NULL)
181 dataset = (struct dataset *) mempool_alloc (db, total
182 + req->key_len, 1);
184 if (dataset == NULL)
186 /* We cannot permanently add the result in the moment. But
187 we can provide the result as is. Store the data in some
188 temporary memory. */
189 dataset = (struct dataset *) alloca (total + req->key_len);
191 /* We cannot add this record to the permanent database. */
192 alloca_used = true;
195 /* Fill in the address and address families. */
196 char *addrs = dataset->strdata;
197 uint8_t *family = (uint8_t *) (addrs + addrslen);
199 for (const struct gaih_addrtuple *at2 = at; at2 != NULL;
200 at2 = at2->next)
202 *family++ = at2->family;
203 if (at2->family == AF_INET)
204 addrs = mempcpy (addrs, at2->addr, INADDRSZ);
205 else if (at2->family == AF_INET6)
206 addrs = mempcpy (addrs, at2->addr, IN6ADDRSZ);
209 cp = family;
211 else
213 /* Prefer the function which also returns the TTL and
214 canonical name. */
215 nss_gethostbyname3_r fct = __nss_lookup_function (nip,
216 "gethostbyname3_r");
217 if (fct == NULL)
218 fct = __nss_lookup_function (nip, "gethostbyname2_r");
220 if (fct == NULL)
221 goto next_nip;
223 struct hostent th[2];
225 /* Collect IPv6 information first. */
226 while (1)
228 rc6 = 0;
229 status[0] = DL_CALL_FCT (fct, (key, AF_INET6, &th[0], tmpbuf6,
230 tmpbuf6len, &rc6, &herrno, &ttl,
231 &canon));
232 if (rc6 != ERANGE || herrno != NETDB_INTERNAL)
233 break;
234 tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
237 if (rc6 != 0 && herrno == NETDB_INTERNAL)
238 goto out;
240 /* If the IPv6 lookup has been successful do not use the
241 buffer used in that lookup, use a new one. */
242 if (status[0] == NSS_STATUS_SUCCESS && rc6 == 0)
244 tmpbuf4len = 512;
245 tmpbuf4 = alloca (tmpbuf4len);
247 else
249 tmpbuf4len = tmpbuf6len;
250 tmpbuf4 = tmpbuf6;
253 /* Next collect IPv4 information. */
254 while (1)
256 rc4 = 0;
257 status[1] = DL_CALL_FCT (fct, (key, AF_INET, &th[1], tmpbuf4,
258 tmpbuf4len, &rc4, &herrno,
259 ttl == INT32_MAX ? &ttl : NULL,
260 canon == NULL ? &canon : NULL));
261 if (rc4 != ERANGE || herrno != NETDB_INTERNAL)
262 break;
263 tmpbuf4 = extend_alloca (tmpbuf4, tmpbuf4len, 2 * tmpbuf4len);
266 if (rc4 != 0 && herrno == NETDB_INTERNAL)
267 goto out;
269 if (status[0] != NSS_STATUS_SUCCESS
270 && status[1] != NSS_STATUS_SUCCESS)
271 goto next_nip;
273 /* We found the data. Count the addresses and the size. */
274 for (int j = 0; j < 2; ++j)
275 if (status[j] == NSS_STATUS_SUCCESS)
276 for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
278 ++naddrs;
279 addrslen += th[j].h_length;
282 if (canon == NULL)
284 /* Determine the canonical name. */
285 nss_getcanonname_r cfct;
286 cfct = __nss_lookup_function (nip, "getcanonname_r");
287 if (cfct != NULL)
289 const size_t max_fqdn_len = 256;
290 char *buf = alloca (max_fqdn_len);
291 char *s;
292 int rc;
294 if (DL_CALL_FCT (cfct, (key, buf, max_fqdn_len, &s,
295 &rc, &herrno))
296 == NSS_STATUS_SUCCESS)
297 canon = s;
298 else
299 /* Set to name now to avoid using gethostbyaddr. */
300 canon = key;
302 else
304 struct hostent *hstent = NULL;
305 int herrno;
306 struct hostent hstent_mem;
307 void *addr;
308 size_t addrlen;
309 int addrfamily;
311 if (status[1] == NSS_STATUS_SUCCESS)
313 addr = th[1].h_addr_list[0];
314 addrlen = sizeof (struct in_addr);
315 addrfamily = AF_INET;
317 else
319 addr = th[0].h_addr_list[0];
320 addrlen = sizeof (struct in6_addr);
321 addrfamily = AF_INET6;
324 size_t tmpbuflen = 512;
325 char *tmpbuf = alloca (tmpbuflen);
326 int rc;
327 while (1)
329 rc = __gethostbyaddr2_r (addr, addrlen, addrfamily,
330 &hstent_mem, tmpbuf, tmpbuflen,
331 &hstent, &herrno, NULL);
332 if (rc != ERANGE || herrno != NETDB_INTERNAL)
333 break;
334 tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
335 tmpbuflen * 2);
338 if (rc == 0)
340 if (hstent != NULL)
341 canon = hstent->h_name;
342 else
343 canon = key;
348 canonlen = canon == NULL ? 0 : (strlen (canon) + 1);
350 total = sizeof (*dataset) + naddrs + addrslen + canonlen;
353 /* Now we can allocate the data structure. If the TTL of the
354 entry is reported as zero do not cache the entry at all. */
355 if (ttl != 0 && he == NULL)
356 dataset = (struct dataset *) mempool_alloc (db, total
357 + req->key_len, 1);
359 if (dataset == NULL)
361 /* We cannot permanently add the result in the moment. But
362 we can provide the result as is. Store the data in some
363 temporary memory. */
364 dataset = (struct dataset *) alloca (total + req->key_len);
366 /* We cannot add this record to the permanent database. */
367 alloca_used = true;
370 /* Fill in the address and address families. */
371 char *addrs = dataset->strdata;
372 uint8_t *family = (uint8_t *) (addrs + addrslen);
374 for (int j = 0; j < 2; ++j)
375 if (status[j] == NSS_STATUS_SUCCESS)
376 for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
378 addrs = mempcpy (addrs, th[j].h_addr_list[i],
379 th[j].h_length);
380 *family++ = th[j].h_addrtype;
383 cp = family;
386 timeout = datahead_init_pos (&dataset->head, total + req->key_len,
387 total - offsetof (struct dataset, resp),
388 he == NULL ? 0 : dh->nreloads + 1,
389 ttl == INT32_MAX ? db->postimeout : ttl);
391 /* Fill in the rest of the dataset. */
392 dataset->resp.version = NSCD_VERSION;
393 dataset->resp.found = 1;
394 dataset->resp.naddrs = naddrs;
395 dataset->resp.addrslen = addrslen;
396 dataset->resp.canonlen = canonlen;
397 dataset->resp.error = NETDB_SUCCESS;
399 if (canon != NULL)
400 cp = mempcpy (cp, canon, canonlen);
402 key_copy = memcpy (cp, key, req->key_len);
404 assert (cp == (char *) dataset + total);
406 /* Now we can determine whether on refill we have to create a
407 new record or not. */
408 if (he != NULL)
410 assert (fd == -1);
412 if (total + req->key_len == dh->allocsize
413 && total - offsetof (struct dataset, resp) == dh->recsize
414 && memcmp (&dataset->resp, dh->data,
415 dh->allocsize - offsetof (struct dataset,
416 resp)) == 0)
418 /* The data has not changed. We will just bump the
419 timeout value. Note that the new record has been
420 allocated on the stack and need not be freed. */
421 dh->timeout = dataset->head.timeout;
422 dh->ttl = dataset->head.ttl;
423 ++dh->nreloads;
425 else
427 /* We have to create a new record. Just allocate
428 appropriate memory and copy it. */
429 struct dataset *newp
430 = (struct dataset *) mempool_alloc (db, total + req->key_len,
432 if (__glibc_likely (newp != NULL))
434 /* Adjust pointer into the memory block. */
435 key_copy = (char *) newp + (key_copy - (char *) dataset);
437 dataset = memcpy (newp, dataset, total + req->key_len);
438 alloca_used = false;
441 /* Mark the old record as obsolete. */
442 dh->usable = false;
445 else
447 /* We write the dataset before inserting it to the database
448 since while inserting this thread might block and so
449 would unnecessarily let the receiver wait. */
450 assert (fd != -1);
452 #ifdef HAVE_SENDFILE
453 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
455 assert (db->wr_fd != -1);
456 assert ((char *) &dataset->resp > (char *) db->data);
457 assert ((char *) dataset - (char *) db->head + total
458 <= (sizeof (struct database_pers_head)
459 + db->head->module * sizeof (ref_t)
460 + db->head->data_size));
461 # ifndef __ASSUME_SENDFILE
462 ssize_t written;
463 written =
464 # endif
465 sendfileall (fd, db->wr_fd, (char *) &dataset->resp
466 - (char *) db->head, dataset->head.recsize);
467 # ifndef __ASSUME_SENDFILE
468 if (written == -1 && errno == ENOSYS)
469 goto use_write;
470 # endif
472 else
473 # ifndef __ASSUME_SENDFILE
474 use_write:
475 # endif
476 #endif
477 writeall (fd, &dataset->resp, dataset->head.recsize);
480 goto out;
482 next_nip:
483 if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
484 break;
486 if (nip->next == NULL)
487 no_more = -1;
488 else
489 nip = nip->next;
492 /* No result found. Create a negative result record. */
493 if (he != NULL && rc4 == EAGAIN)
495 /* If we have an old record available but cannot find one now
496 because the service is not available we keep the old record
497 and make sure it does not get removed. */
498 if (reload_count != UINT_MAX && dh->nreloads == reload_count)
499 /* Do not reset the value if we never not reload the record. */
500 dh->nreloads = reload_count - 1;
502 /* Reload with the same time-to-live value. */
503 timeout = dh->timeout = time (NULL) + dh->ttl;
505 else
507 /* We have no data. This means we send the standard reply for
508 this case. */
509 total = sizeof (notfound);
511 if (fd != -1)
512 TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
514 /* If we have a transient error or cannot permanently store the
515 result, so be it. */
516 if (rc4 == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
518 /* Mark the old entry as obsolete. */
519 if (dh != NULL)
520 dh->usable = false;
521 dataset = NULL;
523 else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
524 + req->key_len), 1)) != NULL)
526 timeout = datahead_init_neg (&dataset->head,
527 sizeof (struct dataset) + req->key_len,
528 total, db->negtimeout);
530 /* This is the reply. */
531 memcpy (&dataset->resp, &notfound, total);
533 /* Copy the key data. */
534 key_copy = memcpy (dataset->strdata, key, req->key_len);
538 out:
539 _res.options |= old_res_options & RES_USE_INET6;
541 if (dataset != NULL && !alloca_used)
543 /* If necessary, we also propagate the data to disk. */
544 if (db->persistent)
546 // XXX async OK?
547 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
548 msync ((void *) pval,
549 ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
550 MS_ASYNC);
553 (void) cache_add (req->type, key_copy, req->key_len, &dataset->head,
554 true, db, uid, he == NULL);
556 pthread_rwlock_unlock (&db->lock);
558 /* Mark the old entry as obsolete. */
559 if (dh != NULL)
560 dh->usable = false;
563 return timeout;
567 void
568 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
569 uid_t uid)
571 addhstaiX (db, fd, req, key, uid, NULL, NULL);
575 time_t
576 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
578 request_header req =
580 .type = GETAI,
581 .key_len = he->len
584 return addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);