1 /* Cache handling for host lookup.
2 Copyright (C) 2004, 2005, 2006, 2007, 2008 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, write to the Free Software Foundation,
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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
*he
, struct datahead
*dh
)
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 (__builtin_expect (debug_level
> 0, 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
;
88 service_user
*nip
= NULL
;
94 if (hosts_database
!= NULL
)
100 no_more
= __nss_database_lookup ("hosts", NULL
,
101 "dns [!UNAVAIL=return] files", &nip
);
103 if (__res_maybe_init (&_res
, 0) == -1)
106 /* If we are looking for both IPv4 and IPv6 address we don't want
107 the lookup functions to automatically promote IPv4 addresses to
108 IPv6 addresses. Currently this is decided by setting the
109 RES_USE_INET6 bit in _res.options. */
110 int old_res_options
= _res
.options
;
111 _res
.options
&= ~RES_USE_INET6
;
113 size_t tmpbuf6len
= 512;
114 char *tmpbuf6
= alloca (tmpbuf6len
);
115 size_t tmpbuf4len
= 0;
116 char *tmpbuf4
= NULL
;
117 int32_t ttl
= INT32_MAX
;
119 char *key_copy
= NULL
;
120 bool alloca_used
= false;
125 int status
[2] = { NSS_STATUS_UNAVAIL
, NSS_STATUS_UNAVAIL
};
131 nss_gethostbyname4_r fct4
= __nss_lookup_function (nip
,
135 struct gaih_addrtuple
*at
= NULL
;
140 status
[1] = DL_CALL_FCT (fct4
, (key
, &at
, tmpbuf6
, tmpbuf6len
,
141 &rc6
, &herrno
, &ttl
));
142 if (rc6
!= ERANGE
|| (herrno
!= NETDB_INTERNAL
143 && herrno
!= TRY_AGAIN
))
145 tmpbuf6
= extend_alloca (tmpbuf6
, tmpbuf6len
, 2 * tmpbuf6len
);
148 if (rc6
!= 0 && herrno
== NETDB_INTERNAL
)
151 if (status
[1] != NSS_STATUS_SUCCESS
)
154 /* We found the data. Count the addresses and the size. */
155 for (const struct gaih_addrtuple
*at2
= at
; at2
!= NULL
;
159 /* We do not handle anything other than IPv4 and IPv6
160 addresses. The getaddrinfo implementation does not
161 either so it is not worth trying to do more. */
162 if (at2
->family
== AF_INET
)
163 addrslen
+= INADDRSZ
;
164 else if (at2
->family
== AF_INET6
)
165 addrslen
+= IN6ADDRSZ
;
168 canonlen
= strlen (canon
) + 1;
170 total
= sizeof (*dataset
) + naddrs
+ addrslen
+ canonlen
;
172 /* Now we can allocate the data structure. If the TTL of the
173 entry is reported as zero do not cache the entry at all. */
174 if (ttl
!= 0 && he
== NULL
)
176 dataset
= (struct dataset
*) mempool_alloc (db
, total
180 ++db
->head
->addfailed
;
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
*he
= NULL
;
305 struct hostent he_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 &he_mem
, tmpbuf
, tmpbuflen
,
331 if (rc
!= ERANGE
|| herrno
!= NETDB_INTERNAL
)
333 tmpbuf
= extend_alloca (tmpbuf
, tmpbuflen
,
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
)
356 dataset
= (struct dataset
*) mempool_alloc (db
, total
360 ++db
->head
->addfailed
;
365 /* We cannot permanently add the result in the moment. But
366 we can provide the result as is. Store the data in some
368 dataset
= (struct dataset
*) alloca (total
+ req
->key_len
);
370 /* We cannot add this record to the permanent database. */
374 /* Fill in the address and address families. */
375 char *addrs
= dataset
->strdata
;
376 uint8_t *family
= (uint8_t *) (addrs
+ addrslen
);
378 for (int j
= 0; j
< 2; ++j
)
379 if (status
[j
] == NSS_STATUS_SUCCESS
)
380 for (int i
= 0; th
[j
].h_addr_list
[i
] != NULL
; ++i
)
382 addrs
= mempcpy (addrs
, th
[j
].h_addr_list
[i
],
384 *family
++ = th
[j
].h_addrtype
;
390 /* Fill in the rest of the dataset. */
391 dataset
->head
.allocsize
= total
+ req
->key_len
;
392 dataset
->head
.recsize
= total
- offsetof (struct dataset
, resp
);
393 dataset
->head
.notfound
= false;
394 dataset
->head
.nreloads
= he
== NULL
? 0 : (dh
->nreloads
+ 1);
395 dataset
->head
.usable
= true;
397 /* Compute the timeout time. */
398 dataset
->head
.timeout
= time (NULL
) + (ttl
== INT32_MAX
399 ? db
->postimeout
: ttl
);
401 dataset
->resp
.version
= NSCD_VERSION
;
402 dataset
->resp
.found
= 1;
403 dataset
->resp
.naddrs
= naddrs
;
404 dataset
->resp
.addrslen
= addrslen
;
405 dataset
->resp
.canonlen
= canonlen
;
406 dataset
->resp
.error
= NETDB_SUCCESS
;
409 cp
= mempcpy (cp
, canon
, canonlen
);
411 key_copy
= memcpy (cp
, key
, req
->key_len
);
413 assert (cp
== (char *) dataset
+ total
);
415 /* Now we can determine whether on refill we have to create a
416 new record or not. */
421 if (total
+ req
->key_len
== dh
->allocsize
422 && total
- offsetof (struct dataset
, resp
) == dh
->recsize
423 && memcmp (&dataset
->resp
, dh
->data
,
424 dh
->allocsize
- offsetof (struct dataset
,
427 /* The data has not changed. We will just bump the
428 timeout value. Note that the new record has been
429 allocated on the stack and need not be freed. */
430 dh
->timeout
= dataset
->head
.timeout
;
435 /* We have to create a new record. Just allocate
436 appropriate memory and copy it. */
438 = (struct dataset
*) mempool_alloc (db
, total
+ req
->key_len
,
440 if (__builtin_expect (newp
!= NULL
, 1))
442 /* Adjust pointer into the memory block. */
443 key_copy
= (char *) newp
+ (key_copy
- (char *) dataset
);
445 dataset
= memcpy (newp
, dataset
, total
+ req
->key_len
);
449 ++db
->head
->addfailed
;
451 /* Mark the old record as obsolete. */
457 /* We write the dataset before inserting it to the database
458 since while inserting this thread might block and so
459 would unnecessarily let the receiver wait. */
463 if (__builtin_expect (db
->mmap_used
, 1) && !alloca_used
)
465 assert (db
->wr_fd
!= -1);
466 assert ((char *) &dataset
->resp
> (char *) db
->data
);
467 assert ((char *) &dataset
->resp
- (char *) db
->head
+ total
468 <= (sizeof (struct database_pers_head
)
469 + db
->head
->module
* sizeof (ref_t
)
470 + db
->head
->data_size
));
472 written
= sendfileall (fd
, db
->wr_fd
, (char *) &dataset
->resp
473 - (char *) db
->head
, total
);
474 # ifndef __ASSUME_SENDFILE
475 if (written
== -1 && errno
== ENOSYS
)
480 # ifndef __ASSUME_SENDFILE
484 writeall (fd
, &dataset
->resp
, total
);
490 if (nss_next_action (nip
, status
[1]) == NSS_ACTION_RETURN
)
493 if (nip
->next
== NULL
)
499 /* No result found. Create a negative result record. */
500 if (he
!= NULL
&& rc4
== EAGAIN
)
502 /* If we have an old record available but cannot find one now
503 because the service is not available we keep the old record
504 and make sure it does not get removed. */
505 if (reload_count
!= UINT_MAX
&& dh
->nreloads
== reload_count
)
506 /* Do not reset the value if we never not reload the record. */
507 dh
->nreloads
= reload_count
- 1;
511 /* We have no data. This means we send the standard reply for
513 total
= sizeof (notfound
);
516 TEMP_FAILURE_RETRY (send (fd
, ¬found
, total
, MSG_NOSIGNAL
));
518 dataset
= mempool_alloc (db
, sizeof (struct dataset
) + req
->key_len
,
520 /* If we cannot permanently store the result, so be it. */
523 dataset
->head
.allocsize
= sizeof (struct dataset
) + req
->key_len
;
524 dataset
->head
.recsize
= total
;
525 dataset
->head
.notfound
= true;
526 dataset
->head
.nreloads
= 0;
527 dataset
->head
.usable
= true;
529 /* Compute the timeout time. */
530 dataset
->head
.timeout
= time (NULL
) + db
->negtimeout
;
532 /* This is the reply. */
533 memcpy (&dataset
->resp
, ¬found
, total
);
535 /* Copy the key data. */
536 key_copy
= memcpy (dataset
->strdata
, key
, req
->key_len
);
539 ++db
->head
->addfailed
;
543 _res
.options
= old_res_options
;
545 if (dataset
!= NULL
&& !alloca_used
)
547 /* If necessary, we also propagate the data to disk. */
551 uintptr_t pval
= (uintptr_t) dataset
& ~pagesize_m1
;
552 msync ((void *) pval
,
553 ((uintptr_t) dataset
& pagesize_m1
) + total
+ req
->key_len
,
557 /* Now get the lock to safely insert the records. */
558 pthread_rwlock_rdlock (&db
->lock
);
560 (void) cache_add (req
->type
, key_copy
, req
->key_len
, &dataset
->head
,
561 true, db
, uid
, he
== NULL
);
563 pthread_rwlock_unlock (&db
->lock
);
565 /* Mark the old entry as obsolete. */
573 addhstai (struct database_dyn
*db
, int fd
, request_header
*req
, void *key
,
576 addhstaiX (db
, fd
, req
, key
, uid
, NULL
, NULL
);
581 readdhstai (struct database_dyn
*db
, struct hashentry
*he
, struct datahead
*dh
)
589 addhstaiX (db
, -1, &req
, db
->data
+ he
->key
, he
->owner
, he
, dh
);