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