Updated to fedora-glibc-20071212T1051
[kopensolaris-gnu/glibc.git] / nscd / pwdcache.c
index 82a26ef..bc1b6ba 100644 (file)
-/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Cache handling for passwd lookup.
+   Copyright (C) 1998-2005, 2006, 2007 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
-   Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1998.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
 
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public License as
-   published by the Free Software Foundation; either version 2 of the
-   License, or (at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published
+   by the Free Software Foundation; version 2 of the License, or
+   (at your option) any later version.
 
-   The GNU C Library is distributed in the hope that it will be useful,
+   This program 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
-   Library General Public License for more details.
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-   You should have received a copy of the GNU Library General Public
-   License along with the GNU C Library; see the file COPYING.LIB.  If not,
-   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA. */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software Foundation,
+   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
+#include <alloca.h>
+#include <assert.h>
 #include <errno.h>
-#include <malloc.h>
-#include <pthread.h>
+#include <error.h>
+#include <libintl.h>
 #include <pwd.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <rpcsvc/nis.h>
-#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <stackinfo.h>
 
-#include "dbg_log.h"
 #include "nscd.h"
+#include "dbg_log.h"
+#ifdef HAVE_SENDFILE
+# include <kernel-features.h>
+#endif
 
-static unsigned long int modulo = 211;
-static unsigned long int postimeout = 600;
-static unsigned long int negtimeout = 20;
-
-static unsigned long int poshit = 0;
-static unsigned long int posmiss = 0;
-static unsigned long int neghit = 0;
-static unsigned long int negmiss = 0;
-
-struct pwdhash
-{
-  time_t create;
-  struct pwdhash *next;
-  struct passwd *pwd;
-};
-typedef struct pwdhash pwdhash;
-
-struct uidhash
+/* This is the standard reply in case the service is disabled.  */
+static const pw_response_header disabled =
 {
-  struct uidhash *next;
-  struct pwdhash *pwptr;
+  .version = NSCD_VERSION,
+  .found = -1,
+  .pw_name_len = 0,
+  .pw_passwd_len = 0,
+  .pw_uid = -1,
+  .pw_gid = -1,
+  .pw_gecos_len = 0,
+  .pw_dir_len = 0,
+  .pw_shell_len = 0
 };
-typedef struct uidhash uidhash;
 
-struct neghash
+/* This is the struct describing how to write this record.  */
+const struct iovec pwd_iov_disabled =
 {
-  time_t create;
-  struct neghash *next;
-  char *key;
+  .iov_base = (void *) &disabled,
+  .iov_len = sizeof (disabled)
 };
-typedef struct neghash neghash;
-
-static pwdhash *pwdtbl;
-static uidhash *uidtbl;
-static neghash *negtbl;
 
-static pthread_rwlock_t pwdlock = PTHREAD_RWLOCK_INITIALIZER;
-static pthread_rwlock_t neglock = PTHREAD_RWLOCK_INITIALIZER;
 
-static void *pwdtable_update (void *);
-static void *negtable_update (void *);
-
-void
-get_pw_stat (stat_response_header *stat)
+/* This is the standard reply in case we haven't found the dataset.  */
+static const pw_response_header notfound =
 {
-  stat->pw_poshit = poshit;
-  stat->pw_posmiss = posmiss;
-  stat->pw_neghit = neghit;
-  stat->pw_negmiss = negmiss;
-  stat->pw_size = modulo;
-  stat->pw_posttl = postimeout;
-  stat->pw_negttl = negtimeout;
-}
+  .version = NSCD_VERSION,
+  .found = 0,
+  .pw_name_len = 0,
+  .pw_passwd_len = 0,
+  .pw_uid = -1,
+  .pw_gid = -1,
+  .pw_gecos_len = 0,
+  .pw_dir_len = 0,
+  .pw_shell_len = 0
+};
 
-void
-set_pwd_modulo (unsigned long int mod)
-{
-  modulo = mod;
-}
 
-void
-set_pos_pwd_ttl (unsigned long int ttl)
-{
-  postimeout = ttl;
-}
-
-void
-set_neg_pwd_ttl (unsigned long int ttl)
-{
-  negtimeout = ttl;
-}
-
-int
-cache_pwdinit ()
+static void
+cache_addpw (struct database_dyn *db, int fd, request_header *req,
+            const void *key, struct passwd *pwd, uid_t owner,
+            struct hashentry *he, struct datahead *dh, int errval)
 {
-  pthread_attr_t attr;
-  pthread_t thread;
+  ssize_t total;
+  ssize_t written;
+  time_t t = time (NULL);
+
+  /* We allocate all data in one memory block: the iov vector,
+     the response header and the dataset itself.  */
+  struct dataset
+  {
+    struct datahead head;
+    pw_response_header resp;
+    char strdata[0];
+  } *dataset;
+
+  assert (offsetof (struct dataset, resp) == offsetof (struct datahead, data));
+
+  if (pwd == NULL)
+    {
+      if (he != NULL && errval == 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;
+
+         written = total = 0;
+       }
+      else
+       {
+         /* We have no data.  This means we send the standard reply for this
+            case.  */
+         written = total = sizeof (notfound);
 
-  pwdtbl = calloc (modulo, sizeof (pwdhash));
-  if (pwdtbl == NULL)
-    return -1;
-  uidtbl = calloc (modulo, sizeof (pwdhash));
-  if (uidtbl == NULL)
-    return -1;
-  negtbl = calloc (modulo, sizeof (neghash));
-  if (negtbl == NULL)
-    return -1;
+         if (fd != -1)
+           written = TEMP_FAILURE_RETRY (send (fd, &notfound, total,
+                                               MSG_NOSIGNAL));
 
-  pthread_attr_init (&attr);
-  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+         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;
 
-  pthread_create (&thread, NULL, pwdtable_update, &attr);
-  pthread_create (&thread, NULL, negtable_update, &attr);
+             /* Compute the timeout time.  */
+             dataset->head.timeout = t + db->negtimeout;
 
-  pthread_attr_destroy (&attr);
+             /* This is the reply.  */
+             memcpy (&dataset->resp, &notfound, total);
 
-  return 0;
-}
+             /* Copy the key data.  */
+             char *key_copy = memcpy (dataset->strdata, key, req->key_len);
 
-static struct passwd *
-save_pwd (struct passwd *src)
-{
-  struct passwd *dest;
-
-  dest = calloc (1, sizeof (struct passwd));
-  dest->pw_name = strdup (src->pw_name);
-  dest->pw_passwd = strdup (src->pw_passwd);
-  dest->pw_uid = src->pw_uid;
-  dest->pw_gid = src->pw_gid;
-  dest->pw_gecos = strdup (src->pw_gecos);
-  dest->pw_dir = strdup (src->pw_dir);
-  dest->pw_shell = strdup (src->pw_shell);
-
-  return dest;
-}
+             /* 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)
+                        + sizeof (struct dataset) + req->key_len, MS_ASYNC);
+               }
 
-static void
-free_pwd (struct passwd *src)
-{
-  free (src->pw_name);
-  free (src->pw_passwd);
-  free (src->pw_gecos);
-  free (src->pw_dir);
-  free (src->pw_shell);
-  free (src);
-}
+             /* Now get the lock to safely insert the records.  */
+             pthread_rwlock_rdlock (&db->lock);
 
-static int
-add_cache (struct passwd *pwd)
-{
-  pwdhash *work;
-  unsigned long int hash = __nis_hash (pwd->pw_name,
-                                      strlen (pwd->pw_name)) % modulo;
+             if (cache_add (req->type, key_copy, req->key_len,
+                            &dataset->head, true, db, owner) < 0)
+               /* Ensure the data can be recovered.  */
+               dataset->head.usable = false;
 
-  if (debug_flag)
-    dbg_log (_("add_cache (%s)"), pwd->pw_name);
 
-  work = &pwdtbl[hash];
+             pthread_rwlock_unlock (&db->lock);
 
-  if (pwdtbl[hash].pwd == NULL)
-    pwdtbl[hash].pwd = save_pwd (pwd);
+             /* Mark the old entry as obsolete.  */
+             if (dh != NULL)
+               dh->usable = false;
+           }
+         else
+           ++db->head->addfailed;
+       }
+    }
   else
     {
-      while (work->next != NULL)
-       work = work->next;
-
-      work->next = calloc (1, sizeof (pwdhash));
-      work->next->pwd = save_pwd (pwd);
-      work = work->next;
-    }
-  /* Set a pointer from the pwuid hash table to the pwname hash table */
-  time (&work->create);
-  uidtbl[pwd->pw_uid % modulo].pwptr = work;
-
-  return 0;
-}
+      /* Determine the I/O structure.  */
+      size_t pw_name_len = strlen (pwd->pw_name) + 1;
+      size_t pw_passwd_len = strlen (pwd->pw_passwd) + 1;
+      size_t pw_gecos_len = strlen (pwd->pw_gecos) + 1;
+      size_t pw_dir_len = strlen (pwd->pw_dir) + 1;
+      size_t pw_shell_len = strlen (pwd->pw_shell) + 1;
+      char *cp;
+      const size_t key_len = strlen (key);
+      const size_t buf_len = 3 * sizeof (pwd->pw_uid) + key_len + 1;
+      char *buf = alloca (buf_len);
+      ssize_t n;
+
+      /* We need this to insert the `byuid' entry.  */
+      int key_offset;
+      n = snprintf (buf, buf_len, "%d%c%n%s", pwd->pw_uid, '\0',
+                   &key_offset, (char *) key) + 1;
+
+      written = total = (sizeof (struct dataset) + pw_name_len + pw_passwd_len
+                        + pw_gecos_len + pw_dir_len + pw_shell_len);
+
+      /* If we refill the cache, first assume the reconrd did not
+        change.  Allocate memory on the cache since it is likely
+        discarded anyway.  If it turns out to be necessary to have a
+        new record we can still allocate real memory.  */
+      bool alloca_used = false;
+      dataset = NULL;
+
+      if (he == NULL)
+       {
+         dataset = (struct dataset *) mempool_alloc (db, total + n);
+         if (dataset == NULL)
+           ++db->head->addfailed;
+       }
 
-static struct passwd *
-cache_search_name (const char *name)
-{
-  pwdhash *work;
-  unsigned long int hash = __nis_hash (name, strlen (name)) % modulo;
+      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 + n);
 
-  work = &pwdtbl[hash];
+         /* We cannot add this record to the permanent database.  */
+         alloca_used = true;
+       }
 
-  while (work->pwd != NULL)
-    {
-      if (strcmp (work->pwd->pw_name, name) == 0)
-       return work->pwd;
-      if (work->next != NULL)
-       work = work->next;
-      else
-       return NULL;
-    }
-  return NULL;
-}
+      dataset->head.allocsize = total + n;
+      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 = t + db->postimeout;
+
+      dataset->resp.version = NSCD_VERSION;
+      dataset->resp.found = 1;
+      dataset->resp.pw_name_len = pw_name_len;
+      dataset->resp.pw_passwd_len = pw_passwd_len;
+      dataset->resp.pw_uid = pwd->pw_uid;
+      dataset->resp.pw_gid = pwd->pw_gid;
+      dataset->resp.pw_gecos_len = pw_gecos_len;
+      dataset->resp.pw_dir_len = pw_dir_len;
+      dataset->resp.pw_shell_len = pw_shell_len;
+
+      cp = dataset->strdata;
+
+      /* Copy the strings over into the buffer.  */
+      cp = mempcpy (cp, pwd->pw_name, pw_name_len);
+      cp = mempcpy (cp, pwd->pw_passwd, pw_passwd_len);
+      cp = mempcpy (cp, pwd->pw_gecos, pw_gecos_len);
+      cp = mempcpy (cp, pwd->pw_dir, pw_dir_len);
+      cp = mempcpy (cp, pwd->pw_shell, pw_shell_len);
+
+      /* Finally the stringified UID value.  */
+      memcpy (cp, buf, n);
+      char *key_copy = cp + key_offset;
+      assert (key_copy == (char *) rawmemchr (cp, '\0') + 1);
+
+      /* Now we can determine whether on refill we have to create a new
+        record or not.  */
+      if (he != NULL)
+       {
+         assert (fd == -1);
 
-static struct passwd *
-cache_search_uid (uid_t uid)
-{
-  uidhash *work;
+         if (total + n == 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 + n);
+             if (newp != NULL)
+               {
+                 /* Adjust pointer into the memory block.  */
+                 cp = (char *) newp + (cp - (char *) dataset);
+                 key_copy = (char *) newp + (key_copy - (char *) dataset);
 
-  work = &uidtbl[uid % modulo];
+                 dataset = memcpy (newp, dataset, total + n);
+                 alloca_used = false;
+               }
+             else
+               ++db->head->addfailed;
 
-  while (work->pwptr != NULL)
-    {
-      if (work->pwptr->pwd->pw_uid == uid)
-       return work->pwptr->pwd;
-      if (work->next != NULL)
-       work = work->next;
+             /* Mark the old record as obsolete.  */
+             dh->usable = false;
+           }
+       }
       else
-       return NULL;
-    }
-  return NULL;
-}
+       {
+         /* 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);
 
-static int
-add_negcache (char *key)
-{
-  neghash *work;
-  unsigned long int hash = __nis_hash (key, strlen (key)) % modulo;
+#ifdef HAVE_SENDFILE
+         if (__builtin_expect (db->mmap_used, 1) && !alloca_used)
+           {
+             assert (db->wr_fd != -1);
+             assert ((char *) &dataset->resp > (char *) db->data);
+             assert ((char *) &dataset->resp - (char *) db->head
+                     + total
+                     <= (sizeof (struct database_pers_head)
+                          + db->head->module * sizeof (ref_t)
+                          + db->head->data_size));
+             written = sendfileall (fd, db->wr_fd,
+                                    (char *) &dataset->resp
+                                    - (char *) db->head, total);
+# ifndef __ASSUME_SENDFILE
+             if (written == -1 && errno == ENOSYS)
+               goto use_write;
+# endif
+           }
+         else
+# ifndef __ASSUME_SENDFILE
+         use_write:
+# endif
+#endif
+           written = writeall (fd, &dataset->resp, total);
+       }
 
-  if (debug_flag)
-    dbg_log (_("add_netgache (%s|%ld)"), key, hash);
 
-  work = &negtbl[hash];
+      /* Add the record to the database.  But only if it has not been
+        stored on the stack.  */
+      if (! 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 + n,
+                    MS_ASYNC);
+           }
 
-  if (negtbl[hash].key == NULL)
-    {
-      negtbl[hash].key = strdup (key);
-      negtbl[hash].next = NULL;
-    }
-  else
-    {
-      while (work->next != NULL)
-       work = work->next;
+         /* Now get the lock to safely insert the records.  */
+         pthread_rwlock_rdlock (&db->lock);
 
-      work->next = calloc (1, sizeof (neghash));
-      work->next->key = strdup (key);
-      work = work->next;
-    }
-  /* Set a pointer from the pwuid hash table to the pwname hash table */
-  time (&work->create);
+         /* NB: in the following code we always must add the entry
+            marked with FIRST first.  Otherwise we end up with
+            dangling "pointers" in case a latter hash entry cannot be
+            added.  */
+         bool first = true;
 
-  return 0;
-}
+         /* If the request was by UID, add that entry first.  */
+         if (req->type == GETPWBYUID)
+           {
+             if (cache_add (GETPWBYUID, cp, key_offset, &dataset->head, true,
+                            db, owner) < 0)
+               {
+                 /* Could not allocate memory.  Make sure the data gets
+                    discarded.  */
+                 dataset->head.usable = false;
+                 goto out;
+               }
 
-static int
-cache_search_neg (const char *key)
-{
-  neghash *work;
-  unsigned long int hash = __nis_hash (key, strlen (key)) % modulo;
+             first = false;
+           }
+         /* If the key is different from the name add a separate entry.  */
+         else if (strcmp (key_copy, dataset->strdata) != 0)
+           {
+             if (cache_add (GETPWBYNAME, key_copy, key_len + 1,
+                            &dataset->head, true, db, owner) < 0)
+               {
+                 /* Could not allocate memory.  Make sure the data gets
+                    discarded.  */
+                 dataset->head.usable = false;
+                 goto out;
+               }
 
-  work = &negtbl[hash];
+             first = false;
+           }
 
-  if (debug_flag)
-    dbg_log (_("cache_search_neg (%s|%ld)"), key, hash);
+         /* We have to add the value for both, byname and byuid.  */
+         if ((req->type == GETPWBYNAME || db->propagate)
+             && __builtin_expect (cache_add (GETPWBYNAME, dataset->strdata,
+                                             pw_name_len, &dataset->head,
+                                             first, db, owner) == 0, 1))
+           {
+             if (req->type == GETPWBYNAME && db->propagate)
+               (void) cache_add (GETPWBYUID, cp, key_offset, &dataset->head,
+                                 req->type != GETPWBYNAME, db, owner);
+           }
+         else if (first)
+           /* Could not allocate memory.  Make sure the data gets
+              discarded.  */
+           dataset->head.usable = false;
 
-  while (work->key != NULL)
+       out:
+         pthread_rwlock_unlock (&db->lock);
+       }
+    }
+
+  if (__builtin_expect (written != total, 0) && debug_level > 0)
     {
-      if (strcmp (work->key, key) == 0)
-       return 1;
-      if (work->next != NULL)
-       work = work->next;
-      else
-       return 0;
+      char buf[256];
+      dbg_log (_("short write in %s: %s"),  __FUNCTION__,
+              strerror_r (errno, buf, sizeof (buf)));
     }
-  return 0;
 }
 
-void *
-cache_getpwnam (void *v_param)
+
+union keytype
 {
-  param_t *param = (param_t *)v_param;
-  struct passwd *pwd, resultbuf;
+  void *v;
+  uid_t u;
+};
 
-  pthread_rwlock_rdlock (&pwdlock);
-  pwd = cache_search_name (param->key);
 
-  /* I don't like it to hold the read only lock longer, but it is
-     necessary to avoid to much malloc/free/strcpy.  */
+static int
+lookup (int type, union keytype key, struct passwd *resultbufp, char *buffer,
+       size_t buflen, struct passwd **pwd)
+{
+  if (type == GETPWBYNAME)
+    return __getpwnam_r (key.v, resultbufp, buffer, buflen, pwd);
+  else
+    return __getpwuid_r (key.u, resultbufp, buffer, buflen, pwd);
+}
 
-  if (pwd != NULL)
-    {
-      if (debug_flag)
-       dbg_log (_("Found \"%s\" in cache !"), param->key);
 
-      ++poshit;
-      pw_send_answer (param->conn, pwd);
-      close_socket (param->conn);
+static void
+addpwbyX (struct database_dyn *db, int fd, request_header *req,
+         union keytype key, const char *keystr, uid_t c_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.  */
+  size_t buflen = 1024;
+  char *buffer = (char *) alloca (buflen);
+  struct passwd resultbuf;
+  struct passwd *pwd;
+  bool use_malloc = false;
+  int errval = 0;
 
-      pthread_rwlock_unlock (&pwdlock);
-      pwd = &resultbuf;
-    }
-  else
+  if (__builtin_expect (debug_level > 0, 0))
     {
-      int status;
-      int buflen = 1024;
-      char *buffer = malloc (buflen);
-
-      if (debug_flag)
-       dbg_log (_("Doesn't found \"%s\" in cache !"), param->key);
-
-      pthread_rwlock_unlock (&pwdlock);
+      if (he == NULL)
+       dbg_log (_("Haven't found \"%s\" in password cache!"), keystr);
+      else
+       dbg_log (_("Reloading \"%s\" in password cache!"), keystr);
+    }
 
-      pthread_rwlock_rdlock (&neglock);
-      status = cache_search_neg (param->key);
-      pthread_rwlock_unlock (&neglock);
+  while (lookup (req->type, key, &resultbuf, buffer, buflen, &pwd) != 0
+        && (errval = errno) == ERANGE)
+    {
+      errno = 0;
 
-      if (status == 0)
+      if (__builtin_expect (buflen > 32768, 0))
        {
-         while (buffer != NULL
-                && (getpwnam_r (param->key, &resultbuf, buffer, buflen, &pwd)
-                    != 0)
-                && errno == ERANGE)
-           {
-             errno = 0;
-             buflen += 1024;
-             buffer = realloc (buffer, buflen);
-           }
-
-         if (buffer != NULL && pwd != NULL)
+         char *old_buffer = buffer;
+         buflen *= 2;
+         buffer = (char *) realloc (use_malloc ? buffer : NULL, buflen);
+         if (buffer == NULL)
            {
-             struct passwd *tmp;
-
-             ++posmiss;
-             pthread_rwlock_wrlock (&pwdlock);
-             /* While we are waiting on the lock, somebody else could
-                add this entry.  */
-             tmp = cache_search_name (param->key);
-             if (tmp == NULL)
-               add_cache (pwd);
-             pthread_rwlock_unlock (&pwdlock);
-           }
-         else
-           {
-             ++negmiss;
-             pthread_rwlock_wrlock (&neglock);
-             add_negcache (param->key);
-             pthread_rwlock_unlock (&neglock);
+             /* We ran out of memory.  We cannot do anything but
+                sending a negative response.  In reality this should
+                never happen.  */
+             pwd = NULL;
+             buffer = old_buffer;
+
+             /* 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.  */
+             errval = EAGAIN;
+             break;
            }
+         use_malloc = true;
        }
       else
-       ++neghit;
-      pw_send_answer (param->conn, pwd);
-      close_socket (param->conn);
-      if (buffer != NULL)
-       free (buffer);
+       /* Allocate a new buffer on the stack.  If possible combine it
+          with the previously allocated buffer.  */
+       buffer = (char *) extend_alloca (buffer, buflen, 2 * buflen);
     }
-  free (param->key);
-  free (param);
-  return NULL;
-}
 
-void *
-cache_pw_disabled (void *v_param)
-{
-  param_t *param = (param_t *)v_param;
+  /* Add the entry to the cache.  */
+  cache_addpw (db, fd, req, keystr, pwd, c_uid, he, dh, errval);
 
-  pw_send_disabled (param->conn);
-  return NULL;
+  if (use_malloc)
+    free (buffer);
 }
 
-void *
-cache_getpwuid (void *v_param)
-{
-  param_t *param = (param_t *)v_param;
-  struct passwd *pwd, resultbuf;
-  uid_t uid = strtol (param->key, NULL, 10);
 
-  pthread_rwlock_rdlock (&pwdlock);
-  pwd = cache_search_uid (uid);
-
-  /* I don't like it to hold the read only lock longer, but it is
-     necessary to avoid to much malloc/free/strcpy.  */
+void
+addpwbyname (struct database_dyn *db, int fd, request_header *req,
+            void *key, uid_t c_uid)
+{
+  union keytype u = { .v = key };
 
-  if (pwd != NULL)
-    {
-      if (debug_flag)
-       dbg_log (_("Found \"%d\" in cache !"), uid);
+  addpwbyX (db, fd, req, u, key, c_uid, NULL, NULL);
+}
 
-      ++poshit;
-      pw_send_answer (param->conn, pwd);
-      close_socket (param->conn);
 
-      pthread_rwlock_unlock (&pwdlock);
-    }
-  else
+void
+readdpwbyname (struct database_dyn *db, struct hashentry *he,
+              struct datahead *dh)
+{
+  request_header req =
     {
-      int buflen = 1024;
-      char *buffer = malloc (buflen);
-      int status;
-
-      if (debug_flag)
-       dbg_log (_("Doesn't found \"%d\" in cache !"), uid);
-
-      pthread_rwlock_unlock (&pwdlock);
-
-      pthread_rwlock_rdlock (&neglock);
-      status = cache_search_neg (param->key);
-      pthread_rwlock_unlock (&neglock);
-
-      if (status == 0)
-        {
-         while (buffer != NULL
-                && (getpwuid_r (uid, &resultbuf, buffer, buflen, &pwd) != 0)
-                && errno == ERANGE)
-           {
-             errno = 0;
-             buflen += 1024;
-             buffer = realloc (buffer, buflen);
-           }
-
-         if (buffer != NULL && pwd != NULL)
-           {
-             struct passwd *tmp;
-
-             ++posmiss;
-             pthread_rwlock_wrlock (&pwdlock);
-             /* While we are waiting on the lock, somebody else could
-                add this entry.  */
-             tmp = cache_search_uid (uid);
-             if (tmp == NULL)
-               add_cache (pwd);
-             pthread_rwlock_unlock (&pwdlock);
-           }
-         else
-           {
-             ++negmiss;
-             pthread_rwlock_wrlock (&neglock);
-             add_negcache (param->key);
-             pthread_rwlock_unlock (&neglock);
-           }
-       }
-      else
-       ++neghit;
+      .type = GETPWBYNAME,
+      .key_len = he->len
+    };
+  union keytype u = { .v = db->data + he->key };
 
-      pw_send_answer (param->conn, pwd);
-      close_socket (param->conn);
-      if (buffer != NULL)
-       free (buffer);
-    }
-  free (param->key);
-  free (param);
-  return NULL;
+  addpwbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
 }
 
-void *
-pwdtable_update (void *v)
-{
-  time_t now;
-  int i;
 
-  sleep (20);
+void
+addpwbyuid (struct database_dyn *db, int fd, request_header *req,
+           void *key, uid_t c_uid)
+{
+  char *ep;
+  uid_t uid = strtoul ((char *) key, &ep, 10);
 
-  while (!do_shutdown)
+  if (*(char *) key == '\0' || *ep != '\0')  /* invalid numeric uid */
     {
-      if (debug_flag > 2)
-       dbg_log (_("(pwdtable_update) Wait for write lock!"));
+      if (debug_level > 0)
+        dbg_log (_("Invalid numeric uid \"%s\"!"), (char *) key);
 
-      pthread_rwlock_wrlock (&pwdlock);
-
-      if (debug_flag > 2)
-       dbg_log (_("(pwdtable_update) Have write lock"));
+      errno = EINVAL;
+      return;
+    }
 
-      time (&now);
-      for (i = 0; i < modulo; ++i)
-       {
-         pwdhash *work = &pwdtbl[i];
+  union keytype u = { .u = uid };
 
-         while (work && work->pwd)
-           {
-             if ((now - work->create) >= postimeout)
-               {
-                 uidhash *uh = &uidtbl[work->pwd->pw_uid % modulo];
-
-                 if (debug_flag)
-                   dbg_log (_("Give \"%s\" free"), work->pwd->pw_name);
-
-                 while (uh != NULL && uh->pwptr)
-                   {
-                     if (uh->pwptr->pwd->pw_uid == work->pwd->pw_uid)
-                       {
-                         if (debug_flag)
-                           dbg_log (_("Give uid for \"%s\" free"),
-                                    work->pwd->pw_name);
-                         if (uh->next != NULL)
-                           {
-                             uidhash *tmp = uh->next;
-                             uh->pwptr = tmp->pwptr;
-                             uh->next = tmp->next;
-                             free (tmp);
-                           }
-                         else
-                           uh->pwptr = NULL;
-                       }
-                     uh = uh->next;
-                   }
-
-                 free_pwd (work->pwd);
-                 if (work->next != NULL)
-                   {
-                     pwdhash *tmp = work->next;
-                     work->create = tmp->create;
-                     work->next = tmp->next;
-                     work->pwd = tmp->pwd;
-                     free (tmp);
-                   }
-                 else
-                   work->pwd = NULL;
-               }
-             work = work->next;
-           }
-       }
-      if (debug_flag > 2)
-       dbg_log (_("(pwdtable_update) Release wait lock"));
-      pthread_rwlock_unlock (&pwdlock);
-      sleep (20);
-    }
-  return NULL;
+  addpwbyX (db, fd, req, u, key, c_uid, NULL, NULL);
 }
 
-void *
-negtable_update (void *v)
+
+void
+readdpwbyuid (struct database_dyn *db, struct hashentry *he,
+             struct datahead *dh)
 {
-  time_t now;
-  int i;
+  char *ep;
+  uid_t uid = strtoul (db->data + he->key, &ep, 10);
 
-  sleep (30);
+  /* Since the key has been added before it must be OK.  */
+  assert (*(db->data + he->key) != '\0' && *ep == '\0');
 
-  while (!do_shutdown)
+  request_header req =
     {
-      if (debug_flag > 2)
-       dbg_log (_("(negtable_update) Wait for write lock!"));
+      .type = GETPWBYUID,
+      .key_len = he->len
+    };
+  union keytype u = { .u = uid };
 
-      pthread_rwlock_wrlock (&neglock);
-
-      if (debug_flag)
-       dbg_log (_("(negtable_update) Have write lock"));
-
-      time (&now);
-      for (i = 0; i < modulo; ++i)
-       {
-         neghash *work = &negtbl[i];
-
-         while (work && work->key)
-           {
-             if ((now - work->create) >= negtimeout)
-               {
-                 if (debug_flag)
-                   dbg_log (_("Give \"%s\" free"), work->key);
-
-                 free (work->key);
-
-                 if (work->next != NULL)
-                   {
-                     neghash *tmp = work->next;
-                     work->create = tmp->create;
-                     work->next = tmp->next;
-                     work->key = tmp->key;
-                     free (tmp);
-                   }
-                 else
-                   work->key = NULL;
-               }
-             work = work->next;
-           }
-       }
-      if (debug_flag)
-       dbg_log (_("(negtable_update) Release wait lock"));
-
-      pthread_rwlock_unlock (&neglock);
-      sleep (10);
-    }
-  return NULL;
+  addpwbyX (db, -1, &req, u, db->data + he->key, he->owner, he, dh);
 }