if (written != total && debug_level > 0)
if (__builtin_expect (written != total, 0) && debug_level > 0)
cache_addpw (struct database *db, int fd, request_header *req, void *key,	     struct passwd *pwd, uid_t owner){  ssize_t total;  ssize_t written;  time_t t = time (NULL);  if (pwd == NULL)    {      /* We have no data.  This means we send the standard reply for this	 case.  */      void *copy;      total = sizeof (notfound);      written = writev (fd, &iov_notfound, 1);      copy = malloc (req->key_len);      if (copy == NULL)	error (EXIT_FAILURE, errno, _("while allocating key copy"));      memcpy (copy, key, req->key_len);      /* Compute the timeout time.  */      t += db->negtimeout;      /* Now get the lock to safely insert the records.  */      pthread_rwlock_rdlock (&db->lock);      cache_add (req->type, copy, req->key_len, &notfound,		 sizeof (notfound), (void *) -1, 0, t, db, owner);      pthread_rwlock_unlock (&db->lock);    }  else    {      /* Determine the I/O structure.  */      struct passwddata *data;      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;      char buf[12];      ssize_t n;      /* We need this to insert the `byuid' entry.  */      n = snprintf (buf, sizeof (buf), "%d", pwd->pw_uid) + 1;      /* We allocate all data in one memory block: the iov vector,	 the response header and the dataset itself.  */      total = (sizeof (struct passwddata) + pw_name_len + pw_passwd_len	       + pw_gecos_len + pw_dir_len + pw_shell_len);      data = (struct passwddata *) malloc (total + n);      if (data == NULL)	/* There is no reason to go on.  */	error (EXIT_FAILURE, errno, _("while allocating cache entry"));      data->resp.found = 1;      data->resp.pw_name_len = pw_name_len;      data->resp.pw_passwd_len = pw_passwd_len;      data->resp.pw_uid = pwd->pw_uid;      data->resp.pw_gid = pwd->pw_gid;      data->resp.pw_gecos_len = pw_gecos_len;      data->resp.pw_dir_len = pw_dir_len;      data->resp.pw_shell_len = pw_shell_len;      cp = data->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);      /* 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.  */      written = write (fd, &data->resp, total);      /* Compute the timeout time.  */      t += db->postimeout;      /* Now get the lock to safely insert the records.  */      pthread_rwlock_rdlock (&db->lock);      /* We have to add the value for both, byname and byuid.  */      cache_add (GETPWBYNAME, data->strdata, pw_name_len, data,		 total, data, 0, t, db, owner);      cache_add (GETPWBYUID, cp, n, data, total, data, 1, t, db, owner);      pthread_rwlock_unlock (&db->lock);    }  if (written != total && debug_level > 0)    {      char buf[256];      dbg_log (_("short write in %s: %s"),  __FUNCTION__,	       strerror_r (errno, buf, sizeof (buf)));    }}