return -1;
return ENOENT;
nscd_gethst_r (const char *key, size_t keylen, request_type type,	       struct hostent *resultbuf, char *buffer, size_t buflen,	       int *h_errnop){  int sock = open_socket ();  hst_response_header hst_resp;  request_header req;  ssize_t nbytes;  if (sock == -1)    {      __nss_not_use_nscd_group = 1;      return 1;    }  req.version = NSCD_VERSION;  req.type = type;  req.key_len = keylen;  nbytes = __write (sock, &req, sizeof (request_header));  if (nbytes != sizeof (request_header))    {      __close (sock);      return 1;    }  nbytes = __write (sock, key, req.key_len);  if (nbytes != req.key_len)    {      __close (sock);      return 1;    }  nbytes = __read (sock, &hst_resp, sizeof (hst_response_header));  if (nbytes != sizeof (hst_response_header))    {      __close (sock);      return 1;    }  if (hst_resp.found == -1)    {      /* The daemon does not cache this database.  */      __close (sock);      __nss_not_use_nscd_hosts = 1;      return 1;    }  if (hst_resp.found == 1)    {      struct iovec vec[4];      size_t *aliases_len;      char *cp = buffer;      uintptr_t align1;      uintptr_t align2;      size_t total_len;      ssize_t cnt;      char *ignore;      int n;      /* A first check whether the buffer is sufficently large is possible.  */      /* Now allocate the buffer the array for the group members.  We must	 align the pointer and the base of the h_addr_list pointers.  */      align1 = ((__alignof__ (char *) - (cp - ((char *) 0)))		& (__alignof__ (char *) - 1));      align2 = ((__alignof__ (char *) - ((cp + align1 + hst_resp.h_name_len)					 - ((char *) 0)))		& (__alignof__ (char *) - 1));      if (buflen < (align1 + hst_resp.h_name_len + align2 +		    + ((hst_resp.h_aliases_cnt + hst_resp.h_addr_list_cnt + 2)		       * sizeof (char *))		    + hst_resp.h_addr_list_cnt * (type == AF_INET						  ? INADDRSZ : IN6ADDRSZ)))	{	no_room:	  __set_errno (ERANGE);	  __close (sock);	  return -1;	}      cp += align1;      /* Prepare the result as far as we can.  */      resultbuf->h_aliases = (char **) cp;      cp += (hst_resp.h_aliases_cnt + 1) * sizeof (char *);      resultbuf->h_addr_list = (char **) cp;      cp += (hst_resp.h_addr_list_cnt + 1) * sizeof (char *);      resultbuf->h_name = cp;      cp += hst_resp.h_name_len + align2;      vec[0].iov_base = resultbuf->h_name;      vec[0].iov_len = hst_resp.h_name_len;      aliases_len = alloca (hst_resp.h_aliases_cnt * sizeof (size_t));      vec[1].iov_base = aliases_len;      vec[1].iov_len = hst_resp.h_aliases_cnt * sizeof (size_t);      total_len = (hst_resp.h_name_len		   + hst_resp.h_aliases_cnt * sizeof (size_t));      n = 2;      if (type == GETHOSTBYADDR || type == GETHOSTBYNAME)	{	  vec[2].iov_base = cp;	  vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;	  ignore = alloca (hst_resp.h_addr_list_cnt * IN6ADDRSZ);	  vec[3].iov_base = ignore;	  vec[3].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;	  for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)	    {	      resultbuf->h_addr_list[cnt] = cp;	      cp += INADDRSZ;	    }	  resultbuf->h_addrtype = AF_INET;	  resultbuf->h_length = INADDRSZ;	  total_len += hst_resp.h_addr_list_cnt * (INADDRSZ + IN6ADDRSZ);	  n = 4;	}      else	{	  if (hst_resp.h_length == INADDRSZ)	    {	      ignore = alloca (hst_resp.h_addr_list_cnt * INADDRSZ);	      vec[2].iov_base = ignore;	      vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;	      total_len += hst_resp.h_addr_list_cnt * INADDRSZ;	      n = 3;	    }	  vec[n].iov_base = cp;	  vec[n].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;	  for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)	    {	      resultbuf->h_addr_list[cnt] = cp;	      cp += IN6ADDRSZ;	    }	  resultbuf->h_addrtype = AF_INET6;	  resultbuf->h_length = IN6ADDRSZ;	  total_len += hst_resp.h_addr_list_cnt * IN6ADDRSZ;	  ++n;	}      resultbuf->h_addr_list[cnt] = NULL;      if (__readv (sock, vec, n) != total_len)	{	  __close (sock);	  return 1;	}      /*  Now we also can read the aliases.  */      total_len = 0;      for (cnt = 0; cnt < hst_resp.h_aliases_cnt; ++cnt)	{	  resultbuf->h_aliases[cnt] = cp;	  cp += aliases_len[cnt];	  total_len += aliases_len[cnt];	}      resultbuf->h_aliases[cnt] = NULL;      /* See whether this would exceed the buffer capacity.  */      if (cp > buffer + buflen)	goto no_room;      /* And finally read the aliases.  */      if (__read (sock, resultbuf->h_aliases[0], total_len) != total_len)	{	  __close (sock);	  return 1;	}      __close (sock);      return 0;    }  else    {      /* Store the error number.  */      *h_errnop = hst_resp.error;      __close (sock);      /* The `errno' to some value != ERANGE.  */      __set_errno (ENOENT);      return -1;    }}