1 /* Cache handling for host lookup.
2 Copyright (C) 2004-2016 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/>. */
28 #include <resolv/res_hconf.h>
33 # include <kernel-features.h>
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
,
62 addhstaiX (struct database_dyn
*db
, int fd
, request_header
*req
,
63 void *key
, uid_t uid
, struct hashentry
*const he
,
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. */
76 ai_response_header resp
;
80 if (__glibc_unlikely (debug_level
> 0))
83 dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key
);
85 dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key
);
88 static service_user
*hosts_database
;
95 if (hosts_database
== NULL
)
96 no_more
= __nss_database_lookup ("hosts", NULL
,
97 "dns [!UNAVAIL=return] files",
101 nip
= hosts_database
;
103 /* Initialize configurations. */
105 if (__res_maybe_init (&_res
, 0) == -1)
108 /* If we are looking for both IPv4 and IPv6 address we don't want
109 the lookup functions to automatically promote IPv4 addresses to
110 IPv6 addresses. Currently this is decided by setting the
111 RES_USE_INET6 bit in _res.options. */
112 int old_res_options
= _res
.options
;
113 _res
.options
&= ~RES_USE_INET6
;
115 size_t tmpbuf6len
= 1024;
116 char *tmpbuf6
= alloca (tmpbuf6len
);
117 size_t tmpbuf4len
= 0;
118 char *tmpbuf4
= NULL
;
119 int32_t ttl
= INT32_MAX
;
121 char *key_copy
= NULL
;
122 bool alloca_used
= false;
123 time_t timeout
= MAX_TIMEOUT_VALUE
;
128 int status
[2] = { NSS_STATUS_UNAVAIL
, NSS_STATUS_UNAVAIL
};
134 nss_gethostbyname4_r fct4
= __nss_lookup_function (nip
,
138 struct gaih_addrtuple atmem
;
139 struct gaih_addrtuple
*at
;
145 status
[1] = DL_CALL_FCT (fct4
, (key
, &at
, tmpbuf6
, tmpbuf6len
,
146 &rc6
, &herrno
, &ttl
));
147 if (rc6
!= ERANGE
|| (herrno
!= NETDB_INTERNAL
148 && herrno
!= TRY_AGAIN
))
150 tmpbuf6
= extend_alloca (tmpbuf6
, tmpbuf6len
, 2 * tmpbuf6len
);
153 if (rc6
!= 0 && herrno
== NETDB_INTERNAL
)
156 if (status
[1] != NSS_STATUS_SUCCESS
)
159 /* We found the data. Count the addresses and the size. */
160 for (const struct gaih_addrtuple
*at2
= at
= &atmem
; at2
!= NULL
;
164 /* We do not handle anything other than IPv4 and IPv6
165 addresses. The getaddrinfo implementation does not
166 either so it is not worth trying to do more. */
167 if (at2
->family
== AF_INET
)
168 addrslen
+= INADDRSZ
;
169 else if (at2
->family
== AF_INET6
)
170 addrslen
+= IN6ADDRSZ
;
173 canonlen
= strlen (canon
) + 1;
175 total
= sizeof (*dataset
) + naddrs
+ addrslen
+ canonlen
;
177 /* Now we can allocate the data structure. If the TTL of the
178 entry is reported as zero do not cache the entry at all. */
179 if (ttl
!= 0 && he
== NULL
)
180 dataset
= (struct dataset
*) mempool_alloc (db
, total
185 /* We cannot permanently add the result in the moment. But
186 we can provide the result as is. Store the data in some
188 dataset
= (struct dataset
*) alloca (total
+ req
->key_len
);
190 /* We cannot add this record to the permanent database. */
194 /* Fill in the address and address families. */
195 char *addrs
= dataset
->strdata
;
196 uint8_t *family
= (uint8_t *) (addrs
+ addrslen
);
198 for (const struct gaih_addrtuple
*at2
= at
; at2
!= NULL
;
201 *family
++ = at2
->family
;
202 if (at2
->family
== AF_INET
)
203 addrs
= mempcpy (addrs
, at2
->addr
, INADDRSZ
);
204 else if (at2
->family
== AF_INET6
)
205 addrs
= mempcpy (addrs
, at2
->addr
, IN6ADDRSZ
);
212 /* Prefer the function which also returns the TTL and
214 nss_gethostbyname3_r fct
= __nss_lookup_function (nip
,
217 fct
= __nss_lookup_function (nip
, "gethostbyname2_r");
222 struct hostent th
[2];
224 /* Collect IPv6 information first. */
228 status
[0] = DL_CALL_FCT (fct
, (key
, AF_INET6
, &th
[0], tmpbuf6
,
229 tmpbuf6len
, &rc6
, &herrno
, &ttl
,
231 if (rc6
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
233 tmpbuf6
= extend_alloca (tmpbuf6
, tmpbuf6len
, 2 * tmpbuf6len
);
236 if (rc6
!= 0 && herrno
== NETDB_INTERNAL
)
239 /* If the IPv6 lookup has been successful do not use the
240 buffer used in that lookup, use a new one. */
241 if (status
[0] == NSS_STATUS_SUCCESS
&& rc6
== 0)
244 tmpbuf4
= alloca (tmpbuf4len
);
248 tmpbuf4len
= tmpbuf6len
;
252 /* Next collect IPv4 information. */
256 status
[1] = DL_CALL_FCT (fct
, (key
, AF_INET
, &th
[1], tmpbuf4
,
257 tmpbuf4len
, &rc4
, &herrno
,
258 ttl
== INT32_MAX
? &ttl
: NULL
,
259 canon
== NULL
? &canon
: NULL
));
260 if (rc4
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
262 tmpbuf4
= extend_alloca (tmpbuf4
, tmpbuf4len
, 2 * tmpbuf4len
);
265 if (rc4
!= 0 && herrno
== NETDB_INTERNAL
)
268 if (status
[0] != NSS_STATUS_SUCCESS
269 && status
[1] != NSS_STATUS_SUCCESS
)
272 /* We found the data. Count the addresses and the size. */
273 for (int j
= 0; j
< 2; ++j
)
274 if (status
[j
] == NSS_STATUS_SUCCESS
)
275 for (int i
= 0; th
[j
].h_addr_list
[i
] != NULL
; ++i
)
278 addrslen
+= th
[j
].h_length
;
283 /* Determine the canonical name. */
284 nss_getcanonname_r cfct
;
285 cfct
= __nss_lookup_function (nip
, "getcanonname_r");
288 const size_t max_fqdn_len
= 256;
289 char *buf
= alloca (max_fqdn_len
);
293 if (DL_CALL_FCT (cfct
, (key
, buf
, max_fqdn_len
, &s
,
295 == NSS_STATUS_SUCCESS
)
298 /* Set to name now to avoid using gethostbyaddr. */
303 struct hostent
*hstent
= NULL
;
305 struct hostent hstent_mem
;
310 if (status
[1] == NSS_STATUS_SUCCESS
)
312 addr
= th
[1].h_addr_list
[0];
313 addrlen
= sizeof (struct in_addr
);
314 addrfamily
= AF_INET
;
318 addr
= th
[0].h_addr_list
[0];
319 addrlen
= sizeof (struct in6_addr
);
320 addrfamily
= AF_INET6
;
323 size_t tmpbuflen
= 512;
324 char *tmpbuf
= alloca (tmpbuflen
);
328 rc
= __gethostbyaddr2_r (addr
, addrlen
, addrfamily
,
329 &hstent_mem
, tmpbuf
, tmpbuflen
,
330 &hstent
, &herrno
, NULL
);
331 if (rc
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
333 tmpbuf
= extend_alloca (tmpbuf
, tmpbuflen
,
340 canon
= hstent
->h_name
;
347 canonlen
= canon
== NULL
? 0 : (strlen (canon
) + 1);
349 total
= sizeof (*dataset
) + naddrs
+ addrslen
+ canonlen
;
352 /* Now we can allocate the data structure. If the TTL of the
353 entry is reported as zero do not cache the entry at all. */
354 if (ttl
!= 0 && he
== NULL
)
355 dataset
= (struct dataset
*) mempool_alloc (db
, total
360 /* We cannot permanently add the result in the moment. But
361 we can provide the result as is. Store the data in some
363 dataset
= (struct dataset
*) alloca (total
+ req
->key_len
);
365 /* We cannot add this record to the permanent database. */
369 /* Fill in the address and address families. */
370 char *addrs
= dataset
->strdata
;
371 uint8_t *family
= (uint8_t *) (addrs
+ addrslen
);
373 for (int j
= 0; j
< 2; ++j
)
374 if (status
[j
] == NSS_STATUS_SUCCESS
)
375 for (int i
= 0; th
[j
].h_addr_list
[i
] != NULL
; ++i
)
377 addrs
= mempcpy (addrs
, th
[j
].h_addr_list
[i
],
379 *family
++ = th
[j
].h_addrtype
;
385 timeout
= datahead_init_pos (&dataset
->head
, total
+ req
->key_len
,
386 total
- offsetof (struct dataset
, resp
),
387 he
== NULL
? 0 : dh
->nreloads
+ 1,
388 ttl
== INT32_MAX
? db
->postimeout
: ttl
);
390 /* Fill in the rest of the dataset. */
391 dataset
->resp
.version
= NSCD_VERSION
;
392 dataset
->resp
.found
= 1;
393 dataset
->resp
.naddrs
= naddrs
;
394 dataset
->resp
.addrslen
= addrslen
;
395 dataset
->resp
.canonlen
= canonlen
;
396 dataset
->resp
.error
= NETDB_SUCCESS
;
399 cp
= mempcpy (cp
, canon
, canonlen
);
401 key_copy
= memcpy (cp
, key
, req
->key_len
);
403 assert (cp
== (char *) dataset
+ total
);
405 /* Now we can determine whether on refill we have to create a
406 new record or not. */
411 if (total
+ req
->key_len
== dh
->allocsize
412 && total
- offsetof (struct dataset
, resp
) == dh
->recsize
413 && memcmp (&dataset
->resp
, dh
->data
,
414 dh
->allocsize
- offsetof (struct dataset
,
417 /* The data has not changed. We will just bump the
418 timeout value. Note that the new record has been
419 allocated on the stack and need not be freed. */
420 dh
->timeout
= dataset
->head
.timeout
;
421 dh
->ttl
= dataset
->head
.ttl
;
426 /* We have to create a new record. Just allocate
427 appropriate memory and copy it. */
429 = (struct dataset
*) mempool_alloc (db
, total
+ req
->key_len
,
431 if (__glibc_likely (newp
!= NULL
))
433 /* Adjust pointer into the memory block. */
434 key_copy
= (char *) newp
+ (key_copy
- (char *) dataset
);
436 dataset
= memcpy (newp
, dataset
, total
+ req
->key_len
);
440 /* Mark the old record as obsolete. */
446 /* We write the dataset before inserting it to the database
447 since while inserting this thread might block and so
448 would unnecessarily let the receiver wait. */
452 if (__builtin_expect (db
->mmap_used
, 1) && !alloca_used
)
454 assert (db
->wr_fd
!= -1);
455 assert ((char *) &dataset
->resp
> (char *) db
->data
);
456 assert ((char *) dataset
- (char *) db
->head
+ total
457 <= (sizeof (struct database_pers_head
)
458 + db
->head
->module
* sizeof (ref_t
)
459 + db
->head
->data_size
));
460 # ifndef __ASSUME_SENDFILE
464 sendfileall (fd
, db
->wr_fd
, (char *) &dataset
->resp
465 - (char *) db
->head
, dataset
->head
.recsize
);
466 # ifndef __ASSUME_SENDFILE
467 if (written
== -1 && errno
== ENOSYS
)
472 # ifndef __ASSUME_SENDFILE
476 writeall (fd
, &dataset
->resp
, dataset
->head
.recsize
);
482 if (nss_next_action (nip
, status
[1]) == NSS_ACTION_RETURN
)
485 if (nip
->next
== NULL
)
491 /* No result found. Create a negative result record. */
492 if (he
!= NULL
&& rc4
== EAGAIN
)
494 /* If we have an old record available but cannot find one now
495 because the service is not available we keep the old record
496 and make sure it does not get removed. */
497 if (reload_count
!= UINT_MAX
&& dh
->nreloads
== reload_count
)
498 /* Do not reset the value if we never not reload the record. */
499 dh
->nreloads
= reload_count
- 1;
501 /* Reload with the same time-to-live value. */
502 timeout
= dh
->timeout
= time (NULL
) + dh
->ttl
;
506 /* We have no data. This means we send the standard reply for
508 total
= sizeof (notfound
);
511 TEMP_FAILURE_RETRY (send (fd
, ¬found
, total
, MSG_NOSIGNAL
));
513 /* If we have a transient error or cannot permanently store the
515 if (rc4
== EAGAIN
|| __builtin_expect (db
->negtimeout
== 0, 0))
517 /* Mark the old entry as obsolete. */
522 else if ((dataset
= mempool_alloc (db
, (sizeof (struct dataset
)
523 + req
->key_len
), 1)) != NULL
)
525 timeout
= datahead_init_neg (&dataset
->head
,
526 sizeof (struct dataset
) + req
->key_len
,
527 total
, db
->negtimeout
);
529 /* This is the reply. */
530 memcpy (&dataset
->resp
, ¬found
, total
);
532 /* Copy the key data. */
533 key_copy
= memcpy (dataset
->strdata
, key
, req
->key_len
);
538 _res
.options
|= old_res_options
& RES_USE_INET6
;
540 if (dataset
!= NULL
&& !alloca_used
)
542 /* If necessary, we also propagate the data to disk. */
546 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
547 msync ((void *) pval
,
548 ((uintptr_t) dataset
& pagesize_m1
) + total
+ req
->key_len
,
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. */
567 addhstai (struct database_dyn
*db
, int fd
, request_header
*req
, void *key
,
570 addhstaiX (db
, fd
, req
, key
, uid
, NULL
, NULL
);
575 readdhstai (struct database_dyn
*db
, struct hashentry
*he
, struct datahead
*dh
)
583 return addhstaiX (db
, -1, &req
, db
->data
+ he
->key
, he
->owner
, he
, dh
);