/* Cache handling for host lookup.
- Copyright (C) 1998-2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 1998-2008, 2009, 2011 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
};
-static void
+/* This is the standard reply in case there are temporary problems. */
+static const hst_response_header tryagain =
+{
+ .version = NSCD_VERSION,
+ .found = 0,
+ .h_name_len = 0,
+ .h_aliases_cnt = 0,
+ .h_addrtype = -1,
+ .h_length = -1,
+ .h_addr_list_cnt = 0,
+ .error = TRY_AGAIN
+};
+
+
+static time_t
cache_addhst (struct database_dyn *db, int fd, request_header *req,
const void *key, struct hostent *hst, uid_t owner,
- struct hashentry *he, struct datahead *dh, int errval,
+ struct hashentry *const he, struct datahead *dh, int errval,
int32_t ttl)
{
bool all_written = true;
assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
+ time_t timeout = MAX_TIMEOUT_VALUE;
if (hst == NULL)
{
if (he != NULL && errval == EAGAIN)
if (reload_count != UINT_MAX)
/* Do not reset the value if we never not reload the record. */
dh->nreloads = reload_count - 1;
+
+ /* Reload with the same time-to-live value. */
+ timeout = dh->timeout = t + dh->ttl;
}
else
{
/* We have no data. This means we send the standard reply for this
- case. */
+ case. Possibly this is only temporary. */
ssize_t total = sizeof (notfound);
+ assert (sizeof (notfound) == sizeof (tryagain));
+
+ const hst_response_header *resp = (errval == EAGAIN
+ ? &tryagain : ¬found);
if (fd != -1 &&
- TEMP_FAILURE_RETRY (send (fd, ¬found, total,
+ TEMP_FAILURE_RETRY (send (fd, resp, total,
MSG_NOSIGNAL)) != total)
all_written = false;
- dataset = mempool_alloc (db, sizeof (struct dataset) + req->key_len,
- IDX_result_data);
/* If we cannot permanently store the result, so be it. */
- if (dataset != NULL)
+ if (__builtin_expect (db->negtimeout == 0, 0))
+ {
+ /* Mark the old entry as obsolete. */
+ if (dh != NULL)
+ dh->usable = false;
+ }
+ else if ((dataset = mempool_alloc (db, (sizeof (struct dataset)
+ + req->key_len), 1)) != NULL)
{
dataset->head.allocsize = sizeof (struct dataset) + req->key_len;
dataset->head.recsize = total;
dataset->head.usable = true;
/* Compute the timeout time. */
- dataset->head.timeout = t + (ttl == INT32_MAX
- ? db->negtimeout : ttl);
+ dataset->head.ttl = ttl == INT32_MAX ? db->negtimeout : ttl;
+ timeout = dataset->head.timeout = t + dataset->head.ttl;
/* This is the reply. */
- memcpy (&dataset->resp, ¬found, total);
+ memcpy (&dataset->resp, resp, total);
/* Copy the key data. */
memcpy (dataset->strdata, key, req->key_len);
+ sizeof (struct dataset) + req->key_len, MS_ASYNC);
}
- /* Now get the lock to safely insert the records. */
- pthread_rwlock_rdlock (&db->lock);
-
(void) cache_add (req->type, &dataset->strdata, req->key_len,
&dataset->head, true, db, owner, he == NULL);
if (dh != NULL)
dh->usable = false;
}
- else
- ++db->head->addfailed;
}
}
else
size_t h_aliases_cnt;
uint32_t *h_aliases_len;
size_t h_addr_list_cnt;
- int addr_list_type;
char *addresses;
char *aliases;
char *key_copy = NULL;
if (h_addr_list_cnt == 0)
/* Invalid entry. */
- return;
+ return MAX_TIMEOUT_VALUE;
total += (sizeof (struct dataset)
+ h_name_len
questionable whether it is worthwhile complicating the cache
handling just for handling such a special case. */
if (he == NULL && h_addr_list_cnt == 1)
- {
- dataset = (struct dataset *) mempool_alloc (db,
- total + req->key_len,
- IDX_result_data);
- if (dataset == NULL)
- ++db->head->addfailed;
- }
+ dataset = (struct dataset *) mempool_alloc (db, total + req->key_len,
+ 1);
if (dataset == NULL)
{
dataset->head.usable = true;
/* Compute the timeout time. */
- dataset->head.timeout = t + (ttl == INT32_MAX ? db->postimeout : ttl);
+ dataset->head.ttl = ttl == INT32_MAX ? db->postimeout : ttl;
+ timeout = dataset->head.timeout = t + dataset->head.ttl;
dataset->resp.version = NSCD_VERSION;
dataset->resp.found = 1;
timeout value. Note that the new record has been
allocated on the stack and need not be freed. */
assert (h_addr_list_cnt == 1);
+ dh->ttl = dataset->head.ttl;
dh->timeout = dataset->head.timeout;
++dh->nreloads;
}
struct dataset *newp
= (struct dataset *) mempool_alloc (db,
total + req->key_len,
- IDX_result_data);
+ 1);
if (newp != NULL)
{
/* Adjust pointers into the memory block. */
dataset = memcpy (newp, dataset, total + req->key_len);
alloca_used = false;
}
- else
- ++db->head->addfailed;
}
/* Mark the old record as obsolete. */
{
assert (db->wr_fd != -1);
assert ((char *) &dataset->resp > (char *) db->data);
- assert ((char *) &dataset->resp - (char *) db->head
+ assert ((char *) dataset - (char *) db->head
+ total
<= (sizeof (struct database_pers_head)
+ db->head->module * sizeof (ref_t)
+ total + req->key_len, MS_ASYNC);
}
- addr_list_type = (hst->h_length == NS_INADDRSZ
- ? GETHOSTBYADDR : GETHOSTBYADDRv6);
-
- /* Now get the lock to safely insert the records. */
- pthread_rwlock_rdlock (&db->lock);
-
/* NB: the following code is really complicated. It has
seemlingly duplicated code paths which do the same. The
problem is that we always must add the hash table entry
dbg_log (_("short write in %s: %s"), __FUNCTION__,
strerror_r (errno, buf, sizeof (buf)));
}
+
+ return timeout;
}
}
-static void
+static time_t
addhstbyX (struct database_dyn *db, int fd, request_header *req,
void *key, uid_t uid, struct hashentry *he, struct datahead *dh)
{
/* We set the error to indicate this is (possibly) a
temporary error and that it does not mean the entry
is not available at all. */
+ h_errno = TRY_AGAIN;
errval = EAGAIN;
break;
}
buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
}
- cache_addhst (db, fd, req, key, hst, uid, he, dh,
- h_errno == TRY_AGAIN ? errval : 0, ttl);
+ time_t timeout = cache_addhst (db, fd, req, key, hst, uid, he, dh,
+ h_errno == TRY_AGAIN ? errval : 0, ttl);
if (use_malloc)
free (buffer);
+
+ return timeout;
}
}
-void
+time_t
readdhstbyname (struct database_dyn *db, struct hashentry *he,
struct datahead *dh)
{
.key_len = he->len
};
- addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
+ return addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
}
}
-void
+time_t
readdhstbyaddr (struct database_dyn *db, struct hashentry *he,
struct datahead *dh)
{
.key_len = he->len
};
- addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
+ return addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
}
}
-void
+time_t
readdhstbynamev6 (struct database_dyn *db, struct hashentry *he,
struct datahead *dh)
{
.key_len = he->len
};
- addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
+ return addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
}
}
-void
+time_t
readdhstbyaddrv6 (struct database_dyn *db, struct hashentry *he,
struct datahead *dh)
{
.key_len = he->len
};
- addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
+ return addhstbyX (db, -1, &req, db->data + he->key, he->owner, he, dh);
}
projects / platform / upstream / glibc.git / blobdiff