1/* Cache handling for host lookup.
2 Copyright (C) 2004-2017 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@redhat.com>, 2004.
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, see <http://www.gnu.org/licenses/>. */
18
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/resolv-internal.h>
29#include <resolv/resolv_context.h>
30#include <resolv/res_use_inet6.h>
31
32#include "dbg_log.h"
33#include "nscd.h"
34#ifdef HAVE_SENDFILE
35# include <kernel-features.h>
36#endif
37
38
39typedef enum nss_status (*nss_gethostbyname4_r)
40 (const char *name, struct gaih_addrtuple **pat,
41 char *buffer, size_t buflen, int *errnop,
42 int *h_errnop, int32_t *ttlp);
43typedef enum nss_status (*nss_gethostbyname3_r)
44 (const char *name, int af, struct hostent *host,
45 char *buffer, size_t buflen, int *errnop,
46 int *h_errnop, int32_t *, char **);
47typedef enum nss_status (*nss_getcanonname_r)
48 (const char *name, char *buffer, size_t buflen, char **result,
49 int *errnop, int *h_errnop);
50
51
52static const ai_response_header notfound =
53{
54 .version = NSCD_VERSION,
55 .found = 0,
56 .naddrs = 0,
57 .addrslen = 0,
58 .canonlen = 0,
59 .error = 0
60};
61
62
63static time_t
64addhstaiX (struct database_dyn *db, int fd, request_header *req,
65 void *key, uid_t uid, struct hashentry *const he,
66 struct datahead *dh)
67{
68 /* Search for the entry matching the key. Please note that we don't
69 look again in the table whether the dataset is now available. We
70 simply insert it. It does not matter if it is in there twice. The
71 pruning function only will look at the timestamp. */
72
73 /* We allocate all data in one memory block: the iov vector,
74 the response header and the dataset itself. */
75 struct dataset
76 {
77 struct datahead head;
78 ai_response_header resp;
79 char strdata[0];
80 } *dataset = NULL;
81
82 if (__glibc_unlikely (debug_level > 0))
83 {
84 if (he == NULL)
85 dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key);
86 else
87 dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key);
88 }
89
90 static service_user *hosts_database;
91 service_user *nip;
92 int no_more;
93 int rc6 = 0;
94 int rc4 = 0;
95 int herrno = 0;
96
97 if (hosts_database == NULL)
98 no_more = __nss_database_lookup ("hosts", NULL,
99 "dns [!UNAVAIL=return] files",
100 &hosts_database);
101 else
102 no_more = 0;
103 nip = hosts_database;
104
105 /* Initialize configurations. If we are looking for both IPv4 and
106 IPv6 address we don't want the lookup functions to automatically
107 promote IPv4 addresses to IPv6 addresses. Therefore, use the
108 _no_inet6 variant. */
109 struct resolv_context *ctx = __resolv_context_get ();
110 bool enable_inet6 = __resolv_context_disable_inet6 (ctx);
111 if (ctx == NULL)
112 no_more = 1;
113
114 size_t tmpbuf6len = 1024;
115 char *tmpbuf6 = alloca (tmpbuf6len);
116 size_t tmpbuf4len = 0;
117 char *tmpbuf4 = NULL;
118 int32_t ttl = INT32_MAX;
119 ssize_t total = 0;
120 char *key_copy = NULL;
121 bool alloca_used = false;
122 time_t timeout = MAX_TIMEOUT_VALUE;
123
124 while (!no_more)
125 {
126 void *cp;
127 int status[2] = { NSS_STATUS_UNAVAIL, NSS_STATUS_UNAVAIL };
128 int naddrs = 0;
129 size_t addrslen = 0;
130 char *canon = NULL;
131 size_t canonlen;
132
133 nss_gethostbyname4_r fct4 = __nss_lookup_function (nip,
134 "gethostbyname4_r");
135 if (fct4 != NULL)
136 {
137 struct gaih_addrtuple atmem;
138 struct gaih_addrtuple *at;
139 while (1)
140 {
141 at = &atmem;
142 rc6 = 0;
143 herrno = 0;
144 status[1] = DL_CALL_FCT (fct4, (key, &at, tmpbuf6, tmpbuf6len,
145 &rc6, &herrno, &ttl));
146 if (rc6 != ERANGE || (herrno != NETDB_INTERNAL
147 && herrno != TRY_AGAIN))
148 break;
149 tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
150 }
151
152 if (rc6 != 0 && herrno == NETDB_INTERNAL)
153 goto out;
154
155 if (status[1] != NSS_STATUS_SUCCESS)
156 goto next_nip;
157
158 /* We found the data. Count the addresses and the size. */
159 for (const struct gaih_addrtuple *at2 = at = &atmem; at2 != NULL;
160 at2 = at2->next)
161 {
162 ++naddrs;
163 /* We do not handle anything other than IPv4 and IPv6
164 addresses. The getaddrinfo implementation does not
165 either so it is not worth trying to do more. */
166 if (at2->family == AF_INET)
167 addrslen += INADDRSZ;
168 else if (at2->family == AF_INET6)
169 addrslen += IN6ADDRSZ;
170 }
171 canon = at->name;
172 canonlen = strlen (canon) + 1;
173
174 total = sizeof (*dataset) + naddrs + addrslen + canonlen;
175
176 /* Now we can allocate the data structure. If the TTL of the
177 entry is reported as zero do not cache the entry at all. */
178 if (ttl != 0 && he == NULL)
179 dataset = (struct dataset *) mempool_alloc (db, total
180 + req->key_len, 1);
181
182 if (dataset == NULL)
183 {
184 /* We cannot permanently add the result in the moment. But
185 we can provide the result as is. Store the data in some
186 temporary memory. */
187 dataset = (struct dataset *) alloca (total + req->key_len);
188
189 /* We cannot add this record to the permanent database. */
190 alloca_used = true;
191 }
192
193 /* Fill in the address and address families. */
194 char *addrs = dataset->strdata;
195 uint8_t *family = (uint8_t *) (addrs + addrslen);
196
197 for (const struct gaih_addrtuple *at2 = at; at2 != NULL;
198 at2 = at2->next)
199 {
200 *family++ = at2->family;
201 if (at2->family == AF_INET)
202 addrs = mempcpy (addrs, at2->addr, INADDRSZ);
203 else if (at2->family == AF_INET6)
204 addrs = mempcpy (addrs, at2->addr, IN6ADDRSZ);
205 }
206
207 cp = family;
208 }
209 else
210 {
211 /* Prefer the function which also returns the TTL and
212 canonical name. */
213 nss_gethostbyname3_r fct = __nss_lookup_function (nip,
214 "gethostbyname3_r");
215 if (fct == NULL)
216 fct = __nss_lookup_function (nip, "gethostbyname2_r");
217
218 if (fct == NULL)
219 goto next_nip;
220
221 struct hostent th[2];
222
223 /* Collect IPv6 information first. */
224 while (1)
225 {
226 rc6 = 0;
227 status[0] = DL_CALL_FCT (fct, (key, AF_INET6, &th[0], tmpbuf6,
228 tmpbuf6len, &rc6, &herrno, &ttl,
229 &canon));
230 if (rc6 != ERANGE || herrno != NETDB_INTERNAL)
231 break;
232 tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len);
233 }
234
235 if (rc6 != 0 && herrno == NETDB_INTERNAL)
236 goto out;
237
238 /* If the IPv6 lookup has been successful do not use the
239 buffer used in that lookup, use a new one. */
240 if (status[0] == NSS_STATUS_SUCCESS && rc6 == 0)
241 {
242 tmpbuf4len = 512;
243 tmpbuf4 = alloca (tmpbuf4len);
244 }
245 else
246 {
247 tmpbuf4len = tmpbuf6len;
248 tmpbuf4 = tmpbuf6;
249 }
250
251 /* Next collect IPv4 information. */
252 while (1)
253 {
254 rc4 = 0;
255 status[1] = DL_CALL_FCT (fct, (key, AF_INET, &th[1], tmpbuf4,
256 tmpbuf4len, &rc4, &herrno,
257 ttl == INT32_MAX ? &ttl : NULL,
258 canon == NULL ? &canon : NULL));
259 if (rc4 != ERANGE || herrno != NETDB_INTERNAL)
260 break;
261 tmpbuf4 = extend_alloca (tmpbuf4, tmpbuf4len, 2 * tmpbuf4len);
262 }
263
264 if (rc4 != 0 && herrno == NETDB_INTERNAL)
265 goto out;
266
267 if (status[0] != NSS_STATUS_SUCCESS
268 && status[1] != NSS_STATUS_SUCCESS)
269 goto next_nip;
270
271 /* We found the data. Count the addresses and the size. */
272 for (int j = 0; j < 2; ++j)
273 if (status[j] == NSS_STATUS_SUCCESS)
274 for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
275 {
276 ++naddrs;
277 addrslen += th[j].h_length;
278 }
279
280 if (canon == NULL)
281 {
282 /* Determine the canonical name. */
283 nss_getcanonname_r cfct;
284 cfct = __nss_lookup_function (nip, "getcanonname_r");
285 if (cfct != NULL)
286 {
287 const size_t max_fqdn_len = 256;
288 char *buf = alloca (max_fqdn_len);
289 char *s;
290 int rc;
291
292 if (DL_CALL_FCT (cfct, (key, buf, max_fqdn_len, &s,
293 &rc, &herrno))
294 == NSS_STATUS_SUCCESS)
295 canon = s;
296 else
297 /* Set to name now to avoid using gethostbyaddr. */
298 canon = key;
299 }
300 else
301 {
302 struct hostent *hstent = NULL;
303 int herrno;
304 struct hostent hstent_mem;
305 void *addr;
306 size_t addrlen;
307 int addrfamily;
308
309 if (status[1] == NSS_STATUS_SUCCESS)
310 {
311 addr = th[1].h_addr_list[0];
312 addrlen = sizeof (struct in_addr);
313 addrfamily = AF_INET;
314 }
315 else
316 {
317 addr = th[0].h_addr_list[0];
318 addrlen = sizeof (struct in6_addr);
319 addrfamily = AF_INET6;
320 }
321
322 size_t tmpbuflen = 512;
323 char *tmpbuf = alloca (tmpbuflen);
324 int rc;
325 while (1)
326 {
327 rc = __gethostbyaddr2_r (addr, addrlen, addrfamily,
328 &hstent_mem, tmpbuf, tmpbuflen,
329 &hstent, &herrno, NULL);
330 if (rc != ERANGE || herrno != NETDB_INTERNAL)
331 break;
332 tmpbuf = extend_alloca (tmpbuf, tmpbuflen,
333 tmpbuflen * 2);
334 }
335
336 if (rc == 0)
337 {
338 if (hstent != NULL)
339 canon = hstent->h_name;
340 else
341 canon = key;
342 }
343 }
344 }
345
346 canonlen = canon == NULL ? 0 : (strlen (canon) + 1);
347
348 total = sizeof (*dataset) + naddrs + addrslen + canonlen;
349
350
351 /* Now we can allocate the data structure. If the TTL of the
352 entry is reported as zero do not cache the entry at all. */
353 if (ttl != 0 && he == NULL)
354 dataset = (struct dataset *) mempool_alloc (db, total
355 + req->key_len, 1);
356
357 if (dataset == NULL)
358 {
359 /* We cannot permanently add the result in the moment. But
360 we can provide the result as is. Store the data in some
361 temporary memory. */
362 dataset = (struct dataset *) alloca (total + req->key_len);
363
364 /* We cannot add this record to the permanent database. */
365 alloca_used = true;
366 }
367
368 /* Fill in the address and address families. */
369 char *addrs = dataset->strdata;
370 uint8_t *family = (uint8_t *) (addrs + addrslen);
371
372 for (int j = 0; j < 2; ++j)
373 if (status[j] == NSS_STATUS_SUCCESS)
374 for (int i = 0; th[j].h_addr_list[i] != NULL; ++i)
375 {
376 addrs = mempcpy (addrs, th[j].h_addr_list[i],
377 th[j].h_length);
378 *family++ = th[j].h_addrtype;
379 }
380
381 cp = family;
382 }
383
384 timeout = datahead_init_pos (&dataset->head, total + req->key_len,
385 total - offsetof (struct dataset, resp),
386 he == NULL ? 0 : dh->nreloads + 1,
387 ttl == INT32_MAX ? db->postimeout : ttl);
388
389 /* Fill in the rest of the dataset. */
390 dataset->resp.version = NSCD_VERSION;
391 dataset->resp.found = 1;
392 dataset->resp.naddrs = naddrs;
393 dataset->resp.addrslen = addrslen;
394 dataset->resp.canonlen = canonlen;
395 dataset->resp.error = NETDB_SUCCESS;
396
397 if (canon != NULL)
398 cp = mempcpy (cp, canon, canonlen);
399
400 key_copy = memcpy (cp, key, req->key_len);
401
402 assert (cp == (char *) dataset + total);
403
404 /* Now we can determine whether on refill we have to create a
405 new record or not. */
406 if (he != NULL)
407 {
408 assert (fd == -1);
409
410 if (total + req->key_len == dh->allocsize
411 && total - offsetof (struct dataset, resp) == dh->recsize
412 && memcmp (&dataset->resp, dh->data,
413 dh->allocsize - offsetof (struct dataset,
414 resp)) == 0)
415 {
416 /* The data has not changed. We will just bump the
417 timeout value. Note that the new record has been
418 allocated on the stack and need not be freed. */
419 dh->timeout = dataset->head.timeout;
420 dh->ttl = dataset->head.ttl;
421 ++dh->nreloads;
422 }
423 else
424 {
425 /* We have to create a new record. Just allocate
426 appropriate memory and copy it. */
427 struct dataset *newp
428 = (struct dataset *) mempool_alloc (db, total + req->key_len,
429 1);
430 if (__glibc_likely (newp != NULL))
431 {
432 /* Adjust pointer into the memory block. */
433 key_copy = (char *) newp + (key_copy - (char *) dataset);
434
435 dataset = memcpy (newp, dataset, total + req->key_len);
436 alloca_used = false;
437 }
438
439 /* Mark the old record as obsolete. */
440 dh->usable = false;
441 }
442 }
443 else
444 {
445 /* We write the dataset before inserting it to the database
446 since while inserting this thread might block and so
447 would unnecessarily let the receiver wait. */
448 assert (fd != -1);
449
450#ifdef HAVE_SENDFILE
451 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
452 {
453 assert (db->wr_fd != -1);
454 assert ((char *) &dataset->resp > (char *) db->data);
455 assert ((char *) dataset - (char *) db->head + total
456 <= (sizeof (struct database_pers_head)
457 + db->head->module * sizeof (ref_t)
458 + db->head->data_size));
459# ifndef __ASSUME_SENDFILE
460 ssize_t written;
461 written =
462# endif
463 sendfileall (fd, db->wr_fd, (char *) &dataset->resp
464 - (char *) db->head, dataset->head.recsize);
465# ifndef __ASSUME_SENDFILE
466 if (written == -1 && errno == ENOSYS)
467 goto use_write;
468# endif
469 }
470 else
471# ifndef __ASSUME_SENDFILE
472 use_write:
473# endif
474#endif
475 writeall (fd, &dataset->resp, dataset->head.recsize);
476 }
477
478 goto out;
479
480next_nip:
481 if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
482 break;
483
484 if (nip->next == NULL)
485 no_more = -1;
486 else
487 nip = nip->next;
488 }
489
490 /* No result found. Create a negative result record. */
491 if (he != NULL && rc4 == EAGAIN)
492 {
493 /* If we have an old record available but cannot find one now
494 because the service is not available we keep the old record
495 and make sure it does not get removed. */
496 if (reload_count != UINT_MAX && dh->nreloads == reload_count)
497 /* Do not reset the value if we never not reload the record. */
498 dh->nreloads = reload_count - 1;
499
500 /* Reload with the same time-to-live value. */
501 timeout = dh->timeout = time (NULL) + dh->ttl;
502 }
503 else
504 {
505 /* We have no data. This means we send the standard reply for
506 this case. */
507 total = sizeof (notfound);
508
509 if (fd != -1)
510 TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
511
512 /* If we have a transient error or cannot permanently store the
513 result, so be it. */
514 if (rc4 == EAGAIN || __builtin_expect (db->negtimeout == 0, 0))
515 {
516 /* Mark the old entry as obsolete. */
517 if (dh != NULL)
518 dh->usable = false;
519 dataset = NULL;
520 }
521 else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
522 + req->key_len), 1)) != NULL)
523 {
524 timeout = datahead_init_neg (&dataset->head,
525 sizeof (struct dataset) + req->key_len,
526 total, db->negtimeout);
527
528 /* This is the reply. */
529 memcpy (&dataset->resp, &notfound, total);
530
531 /* Copy the key data. */
532 key_copy = memcpy (dataset->strdata, key, req->key_len);
533 }
534 }
535
536 out:
537 __resolv_context_enable_inet6 (ctx, enable_inet6);
538 __resolv_context_put (ctx);
539
540 if (dataset != NULL && !alloca_used)
541 {
542 /* If necessary, we also propagate the data to disk. */
543 if (db->persistent)
544 {
545 // XXX async OK?
546 uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1;
547 msync ((void *) pval,
548 ((uintptr_t) dataset & pagesize_m1) + total + req->key_len,
549 MS_ASYNC);
550 }
551
552 (void) cache_add (req->type, key_copy, req->key_len, &dataset->head,
553 true, db, uid, he == NULL);
554
555 pthread_rwlock_unlock (&db->lock);
556
557 /* Mark the old entry as obsolete. */
558 if (dh != NULL)
559 dh->usable = false;
560 }
561
562 return timeout;
563}
564
565
566void
567addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
568 uid_t uid)
569{
570 addhstaiX (db, fd, req, key, uid, NULL, NULL);
571}
572
573
574time_t
575readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
576{
577 request_header req =
578 {
579 .type = GETAI,
580 .key_len = he->len
581 };
582
583 return addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);
584}
585