1 /* Cache handling for host lookup.
2 Copyright (C) 2004-2019 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/resolv-internal.h>
29 #include <resolv/resolv_context.h>
30 #include <scratch_buffer.h>
36 typedef enum nss_status (*nss_gethostbyname4_r
)
37 (const char *name
, struct gaih_addrtuple
**pat
,
38 char *buffer
, size_t buflen
, int *errnop
,
39 int *h_errnop
, int32_t *ttlp
);
40 typedef enum nss_status (*nss_gethostbyname3_r
)
41 (const char *name
, int af
, struct hostent
*host
,
42 char *buffer
, size_t buflen
, int *errnop
,
43 int *h_errnop
, int32_t *, char **);
44 typedef enum nss_status (*nss_getcanonname_r
)
45 (const char *name
, char *buffer
, size_t buflen
, char **result
,
46 int *errnop
, int *h_errnop
);
49 static const ai_response_header notfound
=
51 .version
= NSCD_VERSION
,
61 addhstaiX (struct database_dyn
*db
, int fd
, request_header
*req
,
62 void *key
, uid_t uid
, struct hashentry
*const he
,
65 /* Search for the entry matching the key. Please note that we don't
66 look again in the table whether the dataset is now available. We
67 simply insert it. It does not matter if it is in there twice. The
68 pruning function only will look at the timestamp. */
70 /* We allocate all data in one memory block: the iov vector,
71 the response header and the dataset itself. */
75 ai_response_header resp
;
79 if (__glibc_unlikely (debug_level
> 0))
82 dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key
);
84 dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key
);
87 static service_user
*hosts_database
;
94 if (hosts_database
== NULL
)
95 no_more
= __nss_database_lookup2 ("hosts", NULL
,
96 "dns [!UNAVAIL=return] files",
100 nip
= hosts_database
;
102 /* Initialize configurations. */
103 struct resolv_context
*ctx
= __resolv_context_get ();
107 struct scratch_buffer tmpbuf6
;
108 scratch_buffer_init (&tmpbuf6
);
109 struct scratch_buffer tmpbuf4
;
110 scratch_buffer_init (&tmpbuf4
);
111 struct scratch_buffer canonbuf
;
112 scratch_buffer_init (&canonbuf
);
114 int32_t ttl
= INT32_MAX
;
116 char *key_copy
= NULL
;
117 bool alloca_used
= false;
118 time_t timeout
= MAX_TIMEOUT_VALUE
;
123 int status
[2] = { NSS_STATUS_UNAVAIL
, NSS_STATUS_UNAVAIL
};
130 nss_gethostbyname4_r fct4
= __nss_lookup_function (nip
,
134 struct gaih_addrtuple atmem
;
135 struct gaih_addrtuple
*at
;
141 status
[1] = DL_CALL_FCT (fct4
, (key
, &at
,
142 tmpbuf6
.data
, tmpbuf6
.length
,
143 &rc6
, &herrno
, &ttl
));
144 if (rc6
!= ERANGE
|| (herrno
!= NETDB_INTERNAL
145 && herrno
!= TRY_AGAIN
))
147 if (!scratch_buffer_grow (&tmpbuf6
))
154 if (rc6
!= 0 && herrno
== NETDB_INTERNAL
)
157 if (status
[1] != NSS_STATUS_SUCCESS
)
160 /* We found the data. Count the addresses and the size. */
161 for (const struct gaih_addrtuple
*at2
= at
= &atmem
; at2
!= NULL
;
165 /* We do not handle anything other than IPv4 and IPv6
166 addresses. The getaddrinfo implementation does not
167 either so it is not worth trying to do more. */
168 if (at2
->family
== AF_INET
)
169 addrslen
+= INADDRSZ
;
170 else if (at2
->family
== AF_INET6
)
171 addrslen
+= IN6ADDRSZ
;
174 canonlen
= strlen (canon
) + 1;
176 total
= sizeof (*dataset
) + naddrs
+ addrslen
+ canonlen
;
178 /* Now we can allocate the data structure. If the TTL of the
179 entry is reported as zero do not cache the entry at all. */
180 if (ttl
!= 0 && he
== NULL
)
181 dataset
= (struct dataset
*) mempool_alloc (db
, total
186 /* We cannot permanently add the result in the moment. But
187 we can provide the result as is. Store the data in some
189 dataset
= (struct dataset
*) alloca (total
+ req
->key_len
);
191 /* We cannot add this record to the permanent database. */
195 /* Fill in the address and address families. */
196 char *addrs
= dataset
->strdata
;
197 uint8_t *family
= (uint8_t *) (addrs
+ addrslen
);
199 for (const struct gaih_addrtuple
*at2
= at
; at2
!= NULL
;
202 *family
++ = at2
->family
;
203 if (at2
->family
== AF_INET
)
204 addrs
= mempcpy (addrs
, at2
->addr
, INADDRSZ
);
205 else if (at2
->family
== AF_INET6
)
206 addrs
= mempcpy (addrs
, at2
->addr
, IN6ADDRSZ
);
213 /* Prefer the function which also returns the TTL and
215 nss_gethostbyname3_r fct
= __nss_lookup_function (nip
,
218 fct
= __nss_lookup_function (nip
, "gethostbyname2_r");
223 struct hostent th
[2];
225 /* Collect IPv6 information first. */
229 status
[0] = DL_CALL_FCT (fct
, (key
, AF_INET6
, &th
[0],
230 tmpbuf6
.data
, tmpbuf6
.length
,
233 if (rc6
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
235 if (!scratch_buffer_grow (&tmpbuf6
))
242 if (rc6
!= 0 && herrno
== NETDB_INTERNAL
)
245 /* Next collect IPv4 information. */
249 status
[1] = DL_CALL_FCT (fct
, (key
, AF_INET
, &th
[1],
250 tmpbuf4
.data
, tmpbuf4
.length
,
252 ttl
== INT32_MAX
? &ttl
: NULL
,
253 canon
== NULL
? &canon
: NULL
));
254 if (rc4
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
256 if (!scratch_buffer_grow (&tmpbuf4
))
263 if (rc4
!= 0 && herrno
== NETDB_INTERNAL
)
266 if (status
[0] != NSS_STATUS_SUCCESS
267 && status
[1] != NSS_STATUS_SUCCESS
)
270 /* We found the data. Count the addresses and the size. */
271 for (int j
= 0; j
< 2; ++j
)
272 if (status
[j
] == NSS_STATUS_SUCCESS
)
273 for (int i
= 0; th
[j
].h_addr_list
[i
] != NULL
; ++i
)
276 addrslen
+= th
[j
].h_length
;
281 /* Determine the canonical name. */
282 nss_getcanonname_r cfct
;
283 cfct
= __nss_lookup_function (nip
, "getcanonname_r");
289 if (DL_CALL_FCT (cfct
, (key
, canonbuf
.data
, canonbuf
.length
,
291 == NSS_STATUS_SUCCESS
)
294 /* Set to name now to avoid using gethostbyaddr. */
299 struct hostent
*hstent
= NULL
;
301 struct hostent hstent_mem
;
306 if (status
[1] == NSS_STATUS_SUCCESS
)
308 addr
= th
[1].h_addr_list
[0];
309 addrlen
= sizeof (struct in_addr
);
310 addrfamily
= AF_INET
;
314 addr
= th
[0].h_addr_list
[0];
315 addrlen
= sizeof (struct in6_addr
);
316 addrfamily
= AF_INET6
;
322 rc
= __gethostbyaddr2_r (addr
, addrlen
, addrfamily
,
324 canonbuf
.data
, canonbuf
.length
,
325 &hstent
, &herrno
, NULL
);
326 if (rc
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
328 if (!scratch_buffer_grow (&canonbuf
))
338 canon
= hstent
->h_name
;
345 canonlen
= canon
== NULL
? 0 : (strlen (canon
) + 1);
347 total
= sizeof (*dataset
) + naddrs
+ addrslen
+ canonlen
;
350 /* Now we can allocate the data structure. If the TTL of the
351 entry is reported as zero do not cache the entry at all. */
352 if (ttl
!= 0 && he
== NULL
)
353 dataset
= (struct dataset
*) mempool_alloc (db
, total
358 /* We cannot permanently add the result in the moment. But
359 we can provide the result as is. Store the data in some
361 dataset
= (struct dataset
*) alloca (total
+ req
->key_len
);
363 /* We cannot add this record to the permanent database. */
367 /* Fill in the address and address families. */
368 char *addrs
= dataset
->strdata
;
369 uint8_t *family
= (uint8_t *) (addrs
+ addrslen
);
371 for (int j
= 0; j
< 2; ++j
)
372 if (status
[j
] == NSS_STATUS_SUCCESS
)
373 for (int i
= 0; th
[j
].h_addr_list
[i
] != NULL
; ++i
)
375 addrs
= mempcpy (addrs
, th
[j
].h_addr_list
[i
],
377 *family
++ = th
[j
].h_addrtype
;
383 timeout
= datahead_init_pos (&dataset
->head
, total
+ req
->key_len
,
384 total
- offsetof (struct dataset
, resp
),
385 he
== NULL
? 0 : dh
->nreloads
+ 1,
386 ttl
== INT32_MAX
? db
->postimeout
: ttl
);
388 /* Fill in the rest of the dataset. */
389 dataset
->resp
.version
= NSCD_VERSION
;
390 dataset
->resp
.found
= 1;
391 dataset
->resp
.naddrs
= naddrs
;
392 dataset
->resp
.addrslen
= addrslen
;
393 dataset
->resp
.canonlen
= canonlen
;
394 dataset
->resp
.error
= NETDB_SUCCESS
;
397 cp
= mempcpy (cp
, canon
, canonlen
);
399 key_copy
= memcpy (cp
, key
, req
->key_len
);
401 assert (cp
== (char *) dataset
+ total
);
403 /* Now we can determine whether on refill we have to create a
404 new record or not. */
409 if (total
+ req
->key_len
== dh
->allocsize
410 && total
- offsetof (struct dataset
, resp
) == dh
->recsize
411 && memcmp (&dataset
->resp
, dh
->data
,
412 dh
->allocsize
- offsetof (struct dataset
,
415 /* The data has not changed. We will just bump the
416 timeout value. Note that the new record has been
417 allocated on the stack and need not be freed. */
418 dh
->timeout
= dataset
->head
.timeout
;
419 dh
->ttl
= dataset
->head
.ttl
;
424 /* We have to create a new record. Just allocate
425 appropriate memory and copy it. */
427 = (struct dataset
*) mempool_alloc (db
, total
+ req
->key_len
,
429 if (__glibc_likely (newp
!= NULL
))
431 /* Adjust pointer into the memory block. */
432 key_copy
= (char *) newp
+ (key_copy
- (char *) dataset
);
434 dataset
= memcpy (newp
, dataset
, total
+ req
->key_len
);
438 /* Mark the old record as obsolete. */
444 /* We write the dataset before inserting it to the database
445 since while inserting this thread might block and so
446 would unnecessarily let the receiver wait. */
449 writeall (fd
, &dataset
->resp
, dataset
->head
.recsize
);
455 if (nss_next_action (nip
, status
[1]) == NSS_ACTION_RETURN
)
458 if (nip
->next
== NULL
)
464 /* No result found. Create a negative result record. */
465 if (he
!= NULL
&& rc4
== EAGAIN
)
467 /* If we have an old record available but cannot find one now
468 because the service is not available we keep the old record
469 and make sure it does not get removed. */
470 if (reload_count
!= UINT_MAX
&& dh
->nreloads
== reload_count
)
471 /* Do not reset the value if we never not reload the record. */
472 dh
->nreloads
= reload_count
- 1;
474 /* Reload with the same time-to-live value. */
475 timeout
= dh
->timeout
= time (NULL
) + dh
->ttl
;
479 /* We have no data. This means we send the standard reply for
481 total
= sizeof (notfound
);
484 TEMP_FAILURE_RETRY (send (fd
, ¬found
, total
, MSG_NOSIGNAL
));
486 /* If we have a transient error or cannot permanently store the
488 if (rc4
== EAGAIN
|| __builtin_expect (db
->negtimeout
== 0, 0))
490 /* Mark the old entry as obsolete. */
495 else if ((dataset
= mempool_alloc (db
, (sizeof (struct dataset
)
496 + req
->key_len
), 1)) != NULL
)
498 timeout
= datahead_init_neg (&dataset
->head
,
499 sizeof (struct dataset
) + req
->key_len
,
500 total
, db
->negtimeout
);
502 /* This is the reply. */
503 memcpy (&dataset
->resp
, ¬found
, total
);
505 /* Copy the key data. */
506 key_copy
= memcpy (dataset
->strdata
, key
, req
->key_len
);
511 __resolv_context_put (ctx
);
513 if (dataset
!= NULL
&& !alloca_used
)
515 /* If necessary, we also propagate the data to disk. */
519 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
520 msync ((void *) pval
,
521 ((uintptr_t) dataset
& pagesize_m1
) + total
+ req
->key_len
,
525 (void) cache_add (req
->type
, key_copy
, req
->key_len
, &dataset
->head
,
526 true, db
, uid
, he
== NULL
);
528 pthread_rwlock_unlock (&db
->lock
);
530 /* Mark the old entry as obsolete. */
535 scratch_buffer_free (&tmpbuf6
);
536 scratch_buffer_free (&tmpbuf4
);
537 scratch_buffer_free (&canonbuf
);
544 addhstai (struct database_dyn
*db
, int fd
, request_header
*req
, void *key
,
547 addhstaiX (db
, fd
, req
, key
, uid
, NULL
, NULL
);
552 readdhstai (struct database_dyn
*db
, struct hashentry
*he
, struct datahead
*dh
)
560 return addhstaiX (db
, -1, &req
, db
->data
+ he
->key
, he
->owner
, he
, dh
);