nscd/nscd_gethst_r.c

   1 /* Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <errno.h>
  21 #include <netdb.h>
  22 #include <resolv.h>
  23 #include <stdint.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <arpa/nameser.h>
  29 #include <sys/socket.h>
  30 #include <sys/uio.h>
  31 #include <sys/un.h>
  32
  33 #include "nscd-client.h"
  34 #include "nscd_proto.h"
  35
  36 int __nss_not_use_nscd_hosts;
  37
  38 static int nscd_gethst_r (const char *key, size_t keylen, request_type type,
  39                           struct hostent *resultbuf, char *buffer,
  40                           size_t buflen, int *h_errnop) internal_function;
  41
  42
  43 int
  44 __nscd_gethostbyname_r (const char *name, struct hostent *resultbuf,
  45                         char *buffer, size_t buflen, int *h_errnop)
  46 {
  47   request_type reqtype;
  48
  49   reqtype = (_res.options & RES_USE_INET6) ? GETHOSTBYNAMEv6 : GETHOSTBYNAME;
  50
  51   return nscd_gethst_r (name, strlen (name) + 1, reqtype, resultbuf,
  52                         buffer, buflen, h_errnop);
  53 }
  54
  55
  56 int
  57 __nscd_gethostbyname2_r (const char *name, int af, struct hostent *resultbuf,
  58                          char *buffer, size_t buflen, int *h_errnop)
  59 {
  60   request_type reqtype;
  61
  62   reqtype = af == AF_INET6 ? GETHOSTBYNAMEv6 : GETHOSTBYNAME;
  63
  64   return nscd_gethst_r (name, strlen (name) + 1, reqtype, resultbuf,
  65                         buffer, buflen, h_errnop);
  66 }
  67
  68
  69 int
  70 __nscd_gethostbyaddr_r (const void *addr, socklen_t len, int type,
  71                         struct hostent *resultbuf, char *buffer, size_t buflen,
  72                         int *h_errnop)
  73 {
  74   request_type reqtype;
  75
  76   if (!((len == INADDRSZ && type == AF_INET)
  77         || (len == IN6ADDRSZ && type == AF_INET6)))
  78     /* LEN and TYPE do not match.  */
  79     return -1;
  80
  81   reqtype = type == AF_INET6 ? GETHOSTBYADDRv6 : GETHOSTBYADDR;
  82
  83   return nscd_gethst_r (addr, len, reqtype, resultbuf, buffer, buflen,
  84                         h_errnop);
  85 }
  86
  87
  88 /* Create a socket connected to a name. */
  89 static int
  90 open_socket (void)
  91 {
  92   struct sockaddr_un addr;
  93   int sock;
  94   int saved_errno = errno;
  95
  96   sock = __socket (PF_UNIX, SOCK_STREAM, 0);
  97   if (sock < 0)
  98     {
  99       __set_errno (saved_errno);
 100       return -1;
 101     }
 102
 103   addr.sun_family = AF_UNIX;
 104   strcpy (addr.sun_path, _PATH_NSCDSOCKET);
 105   if (__connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
 106     {
 107       __close (sock);
 108       __set_errno (saved_errno);
 109       return -1;
 110     }
 111
 112   return sock;
 113 }
 114
 115
 116 static int
 117 internal_function
 118 nscd_gethst_r (const char *key, size_t keylen, request_type type,
 119                struct hostent *resultbuf, char *buffer, size_t buflen,
 120                int *h_errnop)
 121 {
 122   int sock = open_socket ();
 123   hst_response_header hst_resp;
 124   request_header req;
 125   ssize_t nbytes;
 126
 127   if (sock == -1)
 128     {
 129       __nss_not_use_nscd_group = 1;
 130       return -1;
 131     }
 132
 133   req.version = NSCD_VERSION;
 134   req.type = type;
 135   req.key_len = keylen;
 136   nbytes = __write (sock, &req, sizeof (request_header));
 137   if (nbytes != sizeof (request_header))
 138     {
 139       __close (sock);
 140       return -1;
 141     }
 142
 143   nbytes = __write (sock, key, req.key_len);
 144   if (nbytes != req.key_len)
 145     {
 146       __close (sock);
 147       return -1;
 148     }
 149
 150   nbytes = __read (sock, &hst_resp, sizeof (hst_response_header));
 151   if (nbytes != sizeof (hst_response_header))
 152     {
 153       __close (sock);
 154       return -1;
 155     }
 156
 157   if (hst_resp.found == -1)
 158     {
 159       /* The daemon does not cache this database.  */
 160       __close (sock);
 161       __nss_not_use_nscd_hosts = 1;
 162       return -1;
 163     }
 164
 165   if (hst_resp.found == 1)
 166     {
 167       struct iovec vec[4];
 168       uint32_t *aliases_len;
 169       char *cp = buffer;
 170       uintptr_t align1;
 171       uintptr_t align2;
 172       size_t total_len;
 173       ssize_t cnt;
 174       char *ignore;
 175       int n;
 176
 177       /* A first check whether the buffer is sufficiently large is possible.  */
 178       /* Now allocate the buffer the array for the group members.  We must
 179          align the pointer and the base of the h_addr_list pointers.  */
 180       align1 = ((__alignof__ (char *) - (cp - ((char *) 0)))
 181                 & (__alignof__ (char *) - 1));
 182       align2 = ((__alignof__ (char *) - ((cp + align1 + hst_resp.h_name_len)
 183                                          - ((char *) 0)))
 184                 & (__alignof__ (char *) - 1));
 185       if (buflen < (align1 + hst_resp.h_name_len + align2
 186                     + ((hst_resp.h_aliases_cnt + hst_resp.h_addr_list_cnt + 2)
 187                        * sizeof (char *))
 188                     + hst_resp.h_addr_list_cnt * (type == AF_INET
 189                                                   ? INADDRSZ : IN6ADDRSZ)))
 190         {
 191         no_room:
 192           __set_errno (ERANGE);
 193           __close (sock);
 194           return ERANGE;
 195         }
 196       cp += align1;
 197
 198       /* Prepare the result as far as we can.  */
 199       resultbuf->h_aliases = (char **) cp;
 200       cp += (hst_resp.h_aliases_cnt + 1) * sizeof (char *);
 201       resultbuf->h_addr_list = (char **) cp;
 202       cp += (hst_resp.h_addr_list_cnt + 1) * sizeof (char *);
 203
 204       resultbuf->h_name = cp;
 205       cp += hst_resp.h_name_len + align2;
 206       vec[0].iov_base = resultbuf->h_name;
 207       vec[0].iov_len = hst_resp.h_name_len;
 208
 209       aliases_len = alloca (hst_resp.h_aliases_cnt * sizeof (uint32_t));
 210       vec[1].iov_base = aliases_len;
 211       vec[1].iov_len = hst_resp.h_aliases_cnt * sizeof (uint32_t);
 212
 213       total_len = (hst_resp.h_name_len
 214                    + hst_resp.h_aliases_cnt * sizeof (uint32_t));
 215
 216       n = 2;
 217       if (type == GETHOSTBYADDR || type == GETHOSTBYNAME)
 218         {
 219           vec[2].iov_base = cp;
 220           vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;
 221
 222           ignore = alloca (hst_resp.h_addr_list_cnt * IN6ADDRSZ);
 223           vec[3].iov_base = ignore;
 224           vec[3].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;
 225
 226           for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)
 227             {
 228               resultbuf->h_addr_list[cnt] = cp;
 229               cp += INADDRSZ;
 230             }
 231
 232           resultbuf->h_addrtype = AF_INET;
 233           resultbuf->h_length = INADDRSZ;
 234
 235           total_len += hst_resp.h_addr_list_cnt * (INADDRSZ + IN6ADDRSZ);
 236
 237           n = 4;
 238         }
 239       else
 240         {
 241           if (hst_resp.h_length == INADDRSZ)
 242             {
 243               ignore = alloca (hst_resp.h_addr_list_cnt * INADDRSZ);
 244               vec[2].iov_base = ignore;
 245               vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;
 246
 247               total_len += hst_resp.h_addr_list_cnt * INADDRSZ;
 248
 249               n = 3;
 250             }
 251
 252           vec[n].iov_base = cp;
 253           vec[n].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;
 254
 255           for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)
 256             {
 257               resultbuf->h_addr_list[cnt] = cp;
 258               cp += IN6ADDRSZ;
 259             }
 260
 261           resultbuf->h_addrtype = AF_INET6;
 262           resultbuf->h_length = IN6ADDRSZ;
 263
 264           total_len += hst_resp.h_addr_list_cnt * IN6ADDRSZ;
 265
 266           ++n;
 267         }
 268       resultbuf->h_addr_list[cnt] = NULL;
 269
 270       if (__readv (sock, vec, n) != total_len)
 271         {
 272           __close (sock);
 273           return -1;
 274         }
 275
 276       /*  Now we also can read the aliases.  */
 277       total_len = 0;
 278       for (cnt = 0; cnt < hst_resp.h_aliases_cnt; ++cnt)
 279         {
 280           resultbuf->h_aliases[cnt] = cp;
 281           cp += aliases_len[cnt];
 282           total_len += aliases_len[cnt];
 283         }
 284       resultbuf->h_aliases[cnt] = NULL;
 285
 286       /* See whether this would exceed the buffer capacity.  */
 287       if (cp > buffer + buflen)
 288         goto no_room;
 289
 290       /* And finally read the aliases.  */
 291       if (__read (sock, resultbuf->h_aliases[0], total_len) != total_len)
 292         {
 293           __close (sock);
 294           return -1;
 295         }
 296
 297       __close (sock);
 298       return 0;
 299     }
 300   else
 301     {
 302       /* Store the error number.  */
 303       *h_errnop = hst_resp.error;
 304
 305       __close (sock);
 306       /* The `errno' to some value != ERANGE.  */
 307       __set_errno (ENOENT);
 308       return ENOENT;
 309     }
 310 }