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