uk_UA: Add alternative month names (bug 10871).
[glibc.git] / nscd / aicache.c
blob6f7b038021746e22e39eb6f96688a27ef5c61b9a
1 /* Cache handling for host lookup.
2 Copyright (C) 2004-2018 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/resolv-internal.h>
29 #include <resolv/resolv_context.h>
30 #include <resolv/res_use_inet6.h>
32 #include "dbg_log.h"
33 #include "nscd.h"
34 #ifdef HAVE_SENDFILE
35 # include <kernel-features.h>
36 #endif
39 typedef 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);
43 typedef 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 **);
47 typedef enum nss_status (*nss_getcanonname_r)
48 (const char *name, char *buffer, size_t buflen, char **result,
49 int *errnop, int *h_errnop);
52 static const ai_response_header notfound =
54 .version = NSCD_VERSION,
55 .found = 0,
56 .naddrs = 0,
57 .addrslen = 0,
58 .canonlen = 0,
59 .error = 0
63 static time_t
64 addhstaiX (struct database_dyn *db, int fd, request_header *req,
65 void *key, uid_t uid, struct hashentry *const he,
66 struct datahead *dh)
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. */
73 /* We allocate all data in one memory block: the iov vector,
74 the response header and the dataset itself. */
75 struct dataset
77 struct datahead head;
78 ai_response_header resp;
79 char strdata[0];
80 } *dataset = NULL;
82 if (__glibc_unlikely (debug_level > 0))
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);
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;
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;
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;
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;
124 while (!no_more)
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;
133 nss_gethostbyname4_r fct4 = __nss_lookup_function (nip,
134 "gethostbyname4_r");
135 if (fct4 != NULL)
137 struct gaih_addrtuple atmem;
138 struct gaih_addrtuple *at;
139 while (1)
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);
152 if (rc6 != 0 && herrno == NETDB_INTERNAL)
153 goto out;
155 if (status[1] != NSS_STATUS_SUCCESS)
156 goto next_nip;
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)
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;
171 canon = at->name;
172 canonlen = strlen (canon) + 1;
174 total = sizeof (*dataset) + naddrs + addrslen + canonlen;
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);
182 if (dataset == NULL)
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);
189 /* We cannot add this record to the permanent database. */
190 alloca_used = true;
193 /* Fill in the address and address families. */
194 char *addrs = dataset->strdata;
195 uint8_t *family = (uint8_t *) (addrs + addrslen);
197 for (const struct gaih_addrtuple *at2 = at; at2 != NULL;
198 at2 = at2->next)
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);
207 cp = family;
209 else
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");
218 if (fct == NULL)
219 goto next_nip;
221 struct hostent th[2];
223 /* Collect IPv6 information first. */
224 while (1)
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);
235 if (rc6 != 0 && herrno == NETDB_INTERNAL)
236 goto out;
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)
242 tmpbuf4len = 512;
243 tmpbuf4 = alloca (tmpbuf4len);
245 else
247 tmpbuf4len = tmpbuf6len;
248 tmpbuf4 = tmpbuf6;
251 /* Next collect IPv4 information. */
252 while (1)
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);
264 if (rc4 != 0 && herrno == NETDB_INTERNAL)
265 goto out;
267 if (status[0] != NSS_STATUS_SUCCESS
268 && status[1] != NSS_STATUS_SUCCESS)
269 goto next_nip;
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)
276 ++naddrs;
277 addrslen += th[j].h_length;
280 if (canon == NULL)
282 /* Determine the canonical name. */
283 nss_getcanonname_r cfct;
284 cfct = __nss_lookup_function (nip, "getcanonname_r");
285 if (cfct != NULL)
287 const size_t max_fqdn_len = 256;
288 char *buf = alloca (max_fqdn_len);
289 char *s;
290 int rc;
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;
300 else
302 struct hostent *hstent = NULL;
303 int herrno;
304 struct hostent hstent_mem;
305 void *addr;
306 size_t addrlen;
307 int addrfamily;
309 if (status[1] == NSS_STATUS_SUCCESS)
311 addr = th[1].h_addr_list[0];
312 addrlen = sizeof (struct in_addr);
313 addrfamily = AF_INET;
315 else
317 addr = th[0].h_addr_list[0];
318 addrlen = sizeof (struct in6_addr);
319 addrfamily = AF_INET6;
322 size_t tmpbuflen = 512;
323 char *tmpbuf = alloca (tmpbuflen);
324 int rc;
325 while (1)
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);
336 if (rc == 0)
338 if (hstent != NULL)
339 canon = hstent->h_name;
340 else
341 canon = key;
346 canonlen = canon == NULL ? 0 : (strlen (canon) + 1);
348 total = sizeof (*dataset) + naddrs + addrslen + canonlen;
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);
357 if (dataset == NULL)
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);
364 /* We cannot add this record to the permanent database. */
365 alloca_used = true;
368 /* Fill in the address and address families. */
369 char *addrs = dataset->strdata;
370 uint8_t *family = (uint8_t *) (addrs + addrslen);
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)
376 addrs = mempcpy (addrs, th[j].h_addr_list[i],
377 th[j].h_length);
378 *family++ = th[j].h_addrtype;
381 cp = family;
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);
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;
397 if (canon != NULL)
398 cp = mempcpy (cp, canon, canonlen);
400 key_copy = memcpy (cp, key, req->key_len);
402 assert (cp == (char *) dataset + total);
404 /* Now we can determine whether on refill we have to create a
405 new record or not. */
406 if (he != NULL)
408 assert (fd == -1);
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)
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;
423 else
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,
430 if (__glibc_likely (newp != NULL))
432 /* Adjust pointer into the memory block. */
433 key_copy = (char *) newp + (key_copy - (char *) dataset);
435 dataset = memcpy (newp, dataset, total + req->key_len);
436 alloca_used = false;
439 /* Mark the old record as obsolete. */
440 dh->usable = false;
443 else
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);
450 #ifdef HAVE_SENDFILE
451 if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
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
470 else
471 # ifndef __ASSUME_SENDFILE
472 use_write:
473 # endif
474 #endif
475 writeall (fd, &dataset->resp, dataset->head.recsize);
478 goto out;
480 next_nip:
481 if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN)
482 break;
484 if (nip->next == NULL)
485 no_more = -1;
486 else
487 nip = nip->next;
490 /* No result found. Create a negative result record. */
491 if (he != NULL && rc4 == EAGAIN)
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;
500 /* Reload with the same time-to-live value. */
501 timeout = dh->timeout = time (NULL) + dh->ttl;
503 else
505 /* We have no data. This means we send the standard reply for
506 this case. */
507 total = sizeof (notfound);
509 if (fd != -1)
510 TEMP_FAILURE_RETRY (send (fd, &notfound, total, MSG_NOSIGNAL));
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))
516 /* Mark the old entry as obsolete. */
517 if (dh != NULL)
518 dh->usable = false;
519 dataset = NULL;
521 else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
522 + req->key_len), 1)) != NULL)
524 timeout = datahead_init_neg (&dataset->head,
525 sizeof (struct dataset) + req->key_len,
526 total, db->negtimeout);
528 /* This is the reply. */
529 memcpy (&dataset->resp, &notfound, total);
531 /* Copy the key data. */
532 key_copy = memcpy (dataset->strdata, key, req->key_len);
536 out:
537 __resolv_context_enable_inet6 (ctx, enable_inet6);
538 __resolv_context_put (ctx);
540 if (dataset != NULL && !alloca_used)
542 /* If necessary, we also propagate the data to disk. */
543 if (db->persistent)
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);
552 (void) cache_add (req->type, key_copy, req->key_len, &dataset->head,
553 true, db, uid, he == NULL);
555 pthread_rwlock_unlock (&db->lock);
557 /* Mark the old entry as obsolete. */
558 if (dh != NULL)
559 dh->usable = false;
562 return timeout;
566 void
567 addhstai (struct database_dyn *db, int fd, request_header *req, void *key,
568 uid_t uid)
570 addhstaiX (db, fd, req, key, uid, NULL, NULL);
574 time_t
575 readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh)
577 request_header req =
579 .type = GETAI,
580 .key_len = he->len
583 return addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh);