diff options
Diffstat (limited to 'nscd')
| -rw-r--r-- | nscd/Makefile | 4 | ||||
| -rw-r--r-- | nscd/aicache.c | 428 | ||||
| -rw-r--r-- | nscd/cache.c | 4 | ||||
| -rw-r--r-- | nscd/connections.c | 13 | ||||
| -rw-r--r-- | nscd/nscd-client.h | 32 | ||||
| -rw-r--r-- | nscd/nscd.c | 11 | ||||
| -rw-r--r-- | nscd/nscd.h | 5 | ||||
| -rw-r--r-- | nscd/nscd_getai.c | 164 |
8 files changed, 654 insertions, 7 deletions
diff --git a/nscd/Makefile b/nscd/Makefile index 7d0a9e38f1..a6a08a3ab8 100644 --- a/nscd/Makefile +++ b/nscd/Makefile @@ -21,7 +21,7 @@ # subdir := nscd -routines := nscd_getpw_r nscd_getgr_r nscd_gethst_r +routines := nscd_getpw_r nscd_getgr_r nscd_gethst_r nscd_getai aux := nscd_helper include ../Makeconfig @@ -32,7 +32,7 @@ vpath %.c ../locale/programs nscd-modules := nscd connections pwdcache getpwnam_r getpwuid_r grpcache \ getgrnam_r getgrgid_r hstcache gethstbyad_r gethstbynm2_r \ dbg_log nscd_conf nscd_stat cache mem nscd_setup_thread \ - xmalloc xstrdup + xmalloc xstrdup aicache ifeq ($(have-thread-library),yes) diff --git a/nscd/aicache.c b/nscd/aicache.c new file mode 100644 index 0000000000..e7489065d4 --- /dev/null +++ b/nscd/aicache.c @@ -0,0 +1,428 @@ +/* Cache handling for host lookup. + Copyright (C) 2004 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper <drepper@redhat.com>, 2004. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include <assert.h> +#include <errno.h> +#include <libintl.h> +#include <netdb.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <sys/mman.h> +#include <dbg_log.h> +#include <nscd.h> + + +typedef enum nss_status (*nss_gethostbyname2_r) + (const char *name, int af, struct hostent *host, + char *buffer, size_t buflen, int *errnop, + int *h_errnop); +typedef enum nss_status (*nss_getcanonname_r) + (const char *name, char *buffer, size_t buflen, char **result, + int *errnop, int *h_errnop); + + +static const ai_response_header notfound = +{ + .version = NSCD_VERSION, + .found = 0, + .naddrs = 0, + .addrslen = 0, + .canonlen = 0, + .error = 0 +}; + + +static void +addhstaiX (struct database_dyn *db, int fd, request_header *req, + void *key, uid_t uid, struct hashentry *he, struct datahead *dh) +{ + /* Search for the entry matching the key. Please note that we don't + look again in the table whether the dataset is now available. We + simply insert it. It does not matter if it is in there twice. The + pruning function only will look at the timestamp. */ + uid_t oldeuid = 0; + + /* We allocate all data in one memory block: the iov vector, + the response header and the dataset itself. */ + struct dataset + { + struct datahead head; + ai_response_header resp; + char strdata[0]; + } *dataset = NULL; + + if (__builtin_expect (debug_level > 0, 0)) + { + if (he == NULL) + dbg_log (_("Haven't found \"%s\" in hosts cache!"), (char *) key); + else + dbg_log (_("Reloading \"%s\" in hosts cache!"), (char *) key); + } + + if (db->secure) + { + oldeuid = geteuid (); + seteuid (uid); + } + + static service_user *hosts_database; + service_user *nip = NULL; + int no_more; + int rc6 = 0; + int rc4 = 0; + int herrno = 0; + + if (hosts_database != NULL) + { + nip = hosts_database; + no_more = 0; + } + else + no_more = __nss_database_lookup ("hosts", NULL, + "dns [!UNAVAIL=return] files", &nip); + + if (__res_maybe_init (&_res, 0) == -1) + no_more = 1; + + /* If we are looking for both IPv4 and IPv6 address we don't want + the lookup functions to automatically promote IPv4 addresses to + IPv6 addresses. Currently this is decided by setting the + RES_USE_INET6 bit in _res.options. */ + int old_res_options = _res.options; + _res.options &= ~RES_USE_INET6; + + size_t tmpbuf6len = 512; + char *tmpbuf6 = alloca (tmpbuf6len); + size_t tmpbuf4len = 0; + char *tmpbuf4 = NULL; + char *canon = NULL; + ssize_t total = 0; + char *key_copy = NULL; + bool alloca_used = false; + + while (!no_more) + { + nss_gethostbyname2_r fct = __nss_lookup_function (nip, + "gethostbyname2_r"); + int status[2] = { NSS_STATUS_UNAVAIL, NSS_STATUS_UNAVAIL }; + + if (fct != NULL) + { + printf("fct=%p\n",fct); + struct hostent th[2]; + + /* Collect IPv6 information first. */ + while (1) + { + rc6 = 0; + status[0] = DL_CALL_FCT (fct, (key, AF_INET6, &th[0], tmpbuf6, + tmpbuf6len, &rc6, &herrno)); + if (rc6 != ERANGE || herrno != NETDB_INTERNAL) + break; + tmpbuf6 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len); + } + + if (rc6 != 0 && herrno == NETDB_INTERNAL) + goto out; + + /* If the IPv6 lookup has been successful do not use the + buffer used in that lookup, use a new one. */ + if (status[0] == NSS_STATUS_SUCCESS && rc6 == 0) + { + tmpbuf4len = 512; + tmpbuf4 = alloca (tmpbuf4len); + } + else + { + tmpbuf4len = tmpbuf6len; + tmpbuf4 = tmpbuf6; + } + + /* Next collect IPv4 information first. */ + while (1) + { + rc4 = 0; + status[1] = DL_CALL_FCT (fct, (key, AF_INET, &th[1], tmpbuf4, + tmpbuf4len, &rc4, &herrno)); + if (rc4 != ERANGE || herrno != NETDB_INTERNAL) + break; + tmpbuf4 = extend_alloca (tmpbuf6, tmpbuf6len, 2 * tmpbuf6len); + } + + if (rc4 != 0 || herrno == NETDB_INTERNAL) + goto out; + + if (status[0] == NSS_STATUS_SUCCESS + || status[1] == NSS_STATUS_SUCCESS) + { + /* We found the data. Count the addresses and the size. */ + int naddrs = 0; + size_t addrslen = 0; + for (int j = 0; j < 2; ++j) + if (status[j] == NSS_STATUS_SUCCESS) + for (int i = 0; th[j].h_addr_list[i] != NULL; ++i) + { + ++naddrs; + addrslen += th[j].h_length; + } + + /* Determine the canonical name. */ + nss_getcanonname_r cfct; + cfct = __nss_lookup_function (nip, "getcanonname_r"); + if (cfct != NULL) + { + const size_t max_fqdn_len = 256; + char *buf = alloca (max_fqdn_len); + char *s; + int rc; + + if (DL_CALL_FCT (cfct, (key, buf, max_fqdn_len, &s, &rc, + &herrno)) == NSS_STATUS_SUCCESS) + canon = s; + else + /* Set to name now to avoid using gethostbyaddr. */ + canon = key; + } + else + { + // XXX use gethostbyaddr + } + size_t canonlen = canon == NULL ? 0 : (strlen (canon) + 1); + + total = sizeof (*dataset) + naddrs + addrslen + canonlen; + + /* Now we can allocate the data structure. */ + if (he == NULL) + { + dataset = (struct dataset *) mempool_alloc (db, + total + + req->key_len); + if (dataset == NULL) + ++db->head->addfailed; + } + + if (dataset == NULL) + { + /* We cannot permanently add the result in the moment. But + we can provide the result as is. Store the data in some + temporary memory. */ + dataset = (struct dataset *) alloca (total + req->key_len); + + /* We cannot add this record to the permanent database. */ + alloca_used = true; + } + + dataset->head.allocsize = total + req->key_len; + dataset->head.recsize = total - offsetof (struct dataset, resp); + dataset->head.notfound = false; + dataset->head.nreloads = he == NULL ? 0 : (dh->nreloads + 1); + dataset->head.usable = true; + + /* Compute the timeout time. */ + dataset->head.timeout = time (NULL) + db->postimeout; + + dataset->resp.version = NSCD_VERSION; + dataset->resp.found = 1; + dataset->resp.naddrs = naddrs; + dataset->resp.addrslen = addrslen; + dataset->resp.canonlen = canonlen; + dataset->resp.error = NETDB_SUCCESS; + + char *addrs = (char *) (&dataset->resp + 1); + uint8_t *family = (uint8_t *) (addrs + addrslen); + + for (int j = 0; j < 2; ++j) + if (status[j] == NSS_STATUS_SUCCESS) + for (int i = 0; th[j].h_addr_list[i] != NULL; ++i) + { + addrs = mempcpy (addrs, th[j].h_addr_list[i], + th[j].h_length); + *family++ = th[j].h_addrtype; + } + + char *cp = family; + if (canon != NULL) + cp = mempcpy (cp, canon, canonlen); + + key_copy = memcpy (cp, key, req->key_len); + + /* Now we can determine whether on refill we have to + create a new record or not. */ + if (he != NULL) + { + assert (fd == -1); + + if (total + req->key_len == dh->allocsize + && total - offsetof (struct dataset, resp) == dh->recsize + && memcmp (&dataset->resp, dh->data, + dh->allocsize + - offsetof (struct dataset, resp)) == 0) + { + /* The data has not changed. We will just bump the + timeout value. Note that the new record has been + allocated on the stack and need not be freed. */ + dh->timeout = dataset->head.timeout; + ++dh->nreloads; + } + else + { + /* We have to create a new record. Just allocate + appropriate memory and copy it. */ + struct dataset *newp + = (struct dataset *) mempool_alloc (db, + total + + req->key_len); + if (newp != NULL) + { + /* Adjust pointer into the memory block. */ + key_copy = (char *) newp + (key_copy + - (char *) dataset); + + dataset = memcpy (newp, dataset, + total + req->key_len); + alloca_used = false; + } + + /* Mark the old record as obsolete. */ + dh->usable = false; + } + } + else + { + /* We write the dataset before inserting it to the + database since while inserting this thread might + block and so would unnecessarily let the receiver + wait. */ + assert (fd != -1); + + TEMP_FAILURE_RETRY (write (fd, &dataset->resp, total)); + } + + goto out; + } + + } + + if (nss_next_action (nip, status[1]) == NSS_ACTION_RETURN) + break; + + if (nip->next == NULL) + no_more = -1; + else + nip = nip->next; + } + + /* No result found. Create a negative result record. */ + if (he != NULL && rc4 == EAGAIN) + { + /* If we have an old record available but cannot find one now + because the service is not available we keep the old record + and make sure it does not get removed. */ + if (reload_count != UINT_MAX && dh->nreloads == reload_count) + /* Do not reset the value if we never not reload the record. */ + dh->nreloads = reload_count - 1; + } + else + { + /* We have no data. This means we send the standard reply for + this case. */ + total = sizeof (notfound); + + if (fd != -1) + TEMP_FAILURE_RETRY (write (fd, ¬found, total)); + + dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len); + /* If we cannot permanently store the result, so be it. */ + if (dataset != NULL) + { + dataset->head.allocsize = sizeof (struct dataset) + req->key_len; + dataset->head.recsize = total; + dataset->head.notfound = true; + dataset->head.nreloads = 0; + dataset->head.usable = true; + + /* Compute the timeout time. */ + dataset->head.timeout = time (NULL) + db->negtimeout; + + /* This is the reply. */ + memcpy (&dataset->resp, ¬found, total); + + /* Copy the key data. */ + key_copy = memcpy (dataset->strdata, key, req->key_len); + } + else + ++db->head->addfailed; + } + + out: + _res.options = old_res_options; + + if (db->secure) + seteuid (oldeuid); + + if (dataset != NULL && !alloca_used) + { + /* If necessary, we also propagate the data to disk. */ + if (db->persistent) + { + // XXX async OK? + uintptr_t pval = (uintptr_t) dataset & ~pagesize_m1; + msync ((void *) pval, + ((uintptr_t) dataset & pagesize_m1) + total + req->key_len, + MS_ASYNC); + } + + /* Now get the lock to safely insert the records. */ + pthread_rwlock_rdlock (&db->lock); + + if (cache_add (req->type, key_copy, req->key_len, &dataset->head, true, + db, uid) < 0) + /* Ensure the data can be recovered. */ + dataset->head.usable = false; + + pthread_rwlock_unlock (&db->lock); + + /* Mark the old entry as obsolete. */ + if (dh != NULL) + dh->usable = false; + } +} + + +void +addhstai (struct database_dyn *db, int fd, request_header *req, void *key, + uid_t uid) +{ + addhstaiX (db, fd, req, key, uid, NULL, NULL); +} + + +void +readdhstai (struct database_dyn *db, struct hashentry *he, struct datahead *dh) +{ + request_header req = + { + .type = GETAI, + .key_len = he->len + }; + + addhstaiX (db, -1, &req, db->data + he->key, he->owner, he, dh); +} diff --git a/nscd/cache.c b/nscd/cache.c index 69c2efb4de..468b8d272a 100644 --- a/nscd/cache.c +++ b/nscd/cache.c @@ -313,6 +313,10 @@ prune_cache (struct database_dyn *table, time_t now) readdhstbyaddrv6 (table, runp, dh); break; + case GETAI: + readdhstai (table, runp, dh); + break; + default: assert (! "should never happen"); } diff --git a/nscd/connections.c b/nscd/connections.c index b95ab05b3a..fe33c76bcf 100644 --- a/nscd/connections.c +++ b/nscd/connections.c @@ -83,7 +83,8 @@ const char *serv2str[LASTREQ] = [INVALIDATE] = "INVALIDATE", [GETFDPW] = "GETFDPW", [GETFDGR] = "GETFDGR", - [GETFDHST] = "GETFDHST" + [GETFDHST] = "GETFDHST", + [GETAI] = "GETAI" }; /* The control data structures for the services. */ @@ -151,6 +152,7 @@ static struct database_dyn *const serv2db[LASTREQ] = [GETFDPW] = &dbs[pwddb], [GETFDGR] = &dbs[grpdb], [GETFDHST] = &dbs[hstdb], + [GETAI] = &dbs[hstdb], }; @@ -592,8 +594,9 @@ cannot handle old request version %d; current version is %d"), struct database_dyn *db = serv2db[req->type]; - if (__builtin_expect (req->type, GETPWBYNAME) >= GETPWBYNAME - && __builtin_expect (req->type, LASTDBREQ) <= LASTDBREQ) + if ((__builtin_expect (req->type, GETPWBYNAME) >= GETPWBYNAME + && __builtin_expect (req->type, LASTDBREQ) <= LASTDBREQ) + || req->type == GETAI) { if (__builtin_expect (debug_level, 0) > 0) { @@ -702,6 +705,10 @@ cannot handle old request version %d; current version is %d"), addhstbyaddrv6 (db, fd, req, key, uid); break; + case GETAI: + addhstai (db, fd, req, key, uid); + break; + case GETSTAT: case SHUTDOWN: case INVALIDATE: diff --git a/nscd/nscd-client.h b/nscd/nscd-client.h index 8f3f3a11d7..1a0dd732db 100644 --- a/nscd/nscd-client.h +++ b/nscd/nscd-client.h @@ -61,6 +61,7 @@ typedef enum GETFDPW, GETFDGR, GETFDHST, + GETAI, LASTREQ } request_type; @@ -118,6 +119,28 @@ typedef struct } hst_response_header; +/* Structure sent in reply to addrinfo query. Note that this struct is + sent also if the service is disabled or there is no record found. */ +typedef struct +{ + int32_t version; + int32_t found; + nscd_ssize_t naddrs; + nscd_ssize_t addrslen; + nscd_ssize_t canonlen; + int32_t error; +} ai_response_header; + +/* Structure filled in by __nscd_getai. */ +struct nscd_ai_result +{ + int naddrs; + char *canon; + uint8_t *family; + char *addrs; +}; + + /* Type for offsets in data part of database. */ typedef uint32_t ref_t; /* Value for invalid/no reference. */ @@ -136,9 +159,9 @@ struct datahead nscd_ssize_t allocsize; /* Allocated Bytes. */ nscd_ssize_t recsize; /* Size of the record. */ nscd_time_t timeout; /* Time when this entry becomes invalid. */ - bool notfound; /* Nonzero if data has not been found. */ + uint8_t notfound; /* Nonzero if data has not been found. */ uint8_t nreloads; /* Reloads without use. */ - bool usable; /* False if the entry must be ignored. */ + uint8_t usable; /* False if the entry must be ignored. */ uint64_t :40; /* Alignment. */ /* We need to have the following element aligned for the response @@ -149,6 +172,7 @@ struct datahead pw_response_header pwdata; gr_response_header grdata; hst_response_header hstdata; + ai_response_header aidata; nscd_ssize_t align1; nscd_time_t align2; } data[0]; @@ -270,4 +294,8 @@ extern const struct datahead *__nscd_cache_search (request_type type, size_t keylen, const struct mapped_database *mapped); +/* Look up in addrinfo cache. */ +extern int __nscd_getai (const char *key, struct nscd_ai_result **result, + int *h_errnop); + #endif /* nscd.h */ diff --git a/nscd/nscd.c b/nscd/nscd.c index 5c5c15598b..facea5ecdb 100644 --- a/nscd/nscd.c +++ b/nscd/nscd.c @@ -465,3 +465,14 @@ write_pid (const char *file) return 0; } + + +/* This is an ugly hack which prevents getaddrinfo from being dragged + into nscd. There currently is no special getaddrinfo version for + use in nscd. In case it should be necessary such a version must be + created and this dummy version should be removed. */ +void +getaddrinfo (void) +{ + abort (); +} diff --git a/nscd/nscd.h b/nscd/nscd.h index d32f5fed47..01c8ca11e0 100644 --- a/nscd/nscd.h +++ b/nscd/nscd.h @@ -193,6 +193,11 @@ extern void readdhstbynamev6 (struct database_dyn *db, struct hashentry *he, extern void readdhstbyaddrv6 (struct database_dyn *db, struct hashentry *he, struct datahead *dh); +/* aicache.c */ +extern void addhstai (struct database_dyn *db, int fd, request_header *req, + void *key, uid_t uid); +extern void readdhstai (struct database_dyn *db, struct hashentry *he, + struct datahead *dh); /* mem.c */ extern void *mempool_alloc (struct database_dyn *db, size_t len); diff --git a/nscd/nscd_getai.c b/nscd/nscd_getai.c new file mode 100644 index 0000000000..453f459425 --- /dev/null +++ b/nscd/nscd_getai.c @@ -0,0 +1,164 @@ +/* Copyright (C) 2004 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper <drepper@redhat.com>, 2004. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include <assert.h> +#include <errno.h> +#include <netdb.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <sys/mman.h> +#include <not-cancel.h> + +#include "nscd-client.h" + + +/* Define in nscd_gethst_r.c. */ +extern int __nss_not_use_nscd_hosts; + + +libc_locked_map_ptr (map_handle); +/* Note that we only free the structure if necessary. The memory + mapping is not removed since it is not visible to the malloc + handling. */ +libc_freeres_fn (gr_map_free) +{ + + if (map_handle.mapped != NO_MAPPING) + free (map_handle.mapped); +} + + +int +__nscd_getai (const char *key, struct nscd_ai_result **result, int *h_errnop) +{ + size_t keylen = strlen (key) + 1; + const ai_response_header *ai_resp = NULL; + struct nscd_ai_result *resultbuf = NULL; + const char *recend = (const char *) ~UINTMAX_C (0); + char *respdata = NULL; + int retval = -1; + int sock = -1; + int gc_cycle; + + /* If the mapping is available, try to search there instead of + communicating with the nscd. */ + struct mapped_database *mapped = __nscd_get_map_ref (GETFDHST, "hosts", + &map_handle, &gc_cycle); + retry: + if (mapped != MAP_FAILED) + { + const struct datahead *found = __nscd_cache_search (GETAI, key, keylen, + mapped); + if (found != NULL) + { + ai_resp = &found->data[0].aidata; + respdata = (char *) (ai_resp + 1); + recend = (const char *) found->data + found->recsize; + } + } + + /* If we do not have the cache mapped, try to get the data over the + socket. */ + ai_response_header ai_resp_mem; + if (ai_resp == NULL) + { + sock = __nscd_open_socket (key, keylen, GETAI, &ai_resp_mem, + sizeof (ai_resp_mem)); + if (sock == -1) + { + /* nscd not running or wrong version or hosts caching disabled. */ + __nss_not_use_nscd_hosts = 1; + goto out;; + } + + ai_resp = &ai_resp_mem; + } + + if (ai_resp->found == 1) + { + size_t datalen = ai_resp->naddrs + ai_resp->addrslen + ai_resp->canonlen; + + /* This check is really only affects the case where the data + comes from the mapped cache. */ + if ((char *) (ai_resp + 1) + datalen > recend) + { + assert (sock == -1); + goto out; + } + + /* Create result. */ + resultbuf = (struct nscd_ai_result *) malloc (sizeof (*resultbuf) + + datalen); + if (resultbuf == NULL) + { + *h_errnop = NETDB_INTERNAL; + return -1; + } + + /* Set up the data structure, including pointers. */ + resultbuf->naddrs = ai_resp->naddrs; + resultbuf->addrs = (char *) (resultbuf + 1); + resultbuf->family = (uint8_t *) (resultbuf->addrs + ai_resp->addrslen); + if (ai_resp->canonlen != 0) + resultbuf->canon = (char *) (resultbuf->family + resultbuf->naddrs); + else + resultbuf->canon = NULL; + + if (respdata == NULL) + { + /* Read the data from the socket. */ + if ((size_t) TEMP_FAILURE_RETRY (__read (sock, resultbuf + 1, + datalen)) == datalen) + { + retval = 0; + *result = resultbuf; + } + } + else + { + /* Copy the data in the block. */ + memcpy (resultbuf + 1, respdata, datalen); + + retval = 0; + *result = resultbuf; + } + } + else + { + /* Store the error number. */ + *h_errnop = ai_resp->error; + + /* The `errno' to some value != ERANGE. */ + __set_errno (ENOENT); + /* Even though we have not found anything, the result is zero. */ + retval = 0; + } + + if (sock != -1) + close_not_cancel_no_status (sock); + out: + if (__nscd_drop_map_ref (mapped, gc_cycle) != 0) + /* When we come here this means there has been a GC cycle while we + were looking for the data. This means the data might have been + inconsistent. Retry. */ + goto retry; + + return retval; +} |