nscd/nscd_gethst_r.c

   1 /* Copyright (C) 1998, 1999 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);
  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 char *addr, int 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 nscd_gethst_r (const char *key, size_t keylen, request_type type,
 118                struct hostent *resultbuf, char *buffer, size_t buflen,
 119                int *h_errnop)
 120 {
 121   int sock = open_socket ();
 122   hst_response_header hst_resp;
 123   request_header req;
 124   ssize_t nbytes;
 125
 126   if (sock == -1)
 127     {
 128       __nss_not_use_nscd_group = 1;
 129       return 1;
 130     }
 131
 132   req.version = NSCD_VERSION;
 133   req.type = type;
 134   req.key_len = keylen;
 135   nbytes = __write (sock, &req, sizeof (request_header));
 136   if (nbytes != sizeof (request_header))
 137     {
 138       __close (sock);
 139       return 1;
 140     }
 141
 142   nbytes = __write (sock, key, req.key_len);
 143   if (nbytes != req.key_len)
 144     {
 145       __close (sock);
 146       return 1;
 147     }
 148
 149   nbytes = __read (sock, &hst_resp, sizeof (hst_response_header));
 150   if (nbytes != sizeof (hst_response_header))
 151     {
 152       __close (sock);
 153       return 1;
 154     }
 155
 156   if (hst_resp.found == -1)
 157     {
 158       /* The daemon does not cache this database.  */
 159       __close (sock);
 160       __nss_not_use_nscd_hosts = 1;
 161       return 1;
 162     }
 163
 164   if (hst_resp.found == 1)
 165     {
 166       struct iovec vec[4];
 167       size_t *aliases_len;
 168       char *cp = buffer;
 169       uintptr_t align;
 170       size_t total_len;
 171       ssize_t cnt;
 172       char *ignore;
 173       int n;
 174
 175       /* A first check whether the buffer is sufficently large is possible.  */
 176       /* Now allocate the buffer the array for the group members.  We must
 177          align the pointer.  */
 178       align = ((__alignof__ (char *) - (cp - ((char *) 0)))
 179                & (__alignof__ (char *) - 1));
 180       if (buflen < (align + hst_resp.h_name_len
 181                     + ((hst_resp.h_aliases_cnt + hst_resp.h_addr_list_cnt + 2)
 182                        * sizeof (char *))
 183                     + hst_resp.h_addr_list_cnt * (type == AF_INET
 184                                                   ? INADDRSZ : IN6ADDRSZ)))
 185         {
 186         no_room:
 187           __set_errno (ERANGE);
 188           __close (sock);
 189           return -1;
 190         }
 191       cp += align;
 192
 193       /* Prepare the result as far as we can.  */
 194       resultbuf->h_aliases = (char **) cp;
 195       cp += (hst_resp.h_aliases_cnt + 1) * sizeof (char *);
 196       resultbuf->h_addr_list = (char **) cp;
 197       cp += (hst_resp.h_addr_list_cnt + 1) * sizeof (char *);
 198
 199       resultbuf->h_name = cp;
 200       cp += hst_resp.h_name_len;
 201       vec[0].iov_base = resultbuf->h_name;
 202       vec[0].iov_len = hst_resp.h_name_len;
 203
 204       aliases_len = alloca (hst_resp.h_aliases_cnt * sizeof (size_t));
 205       vec[1].iov_base = aliases_len;
 206       vec[1].iov_len = hst_resp.h_aliases_cnt * sizeof (size_t);
 207
 208       total_len = (hst_resp.h_name_len
 209                    + hst_resp.h_aliases_cnt * sizeof (size_t));
 210
 211       n = 2;
 212       if (type == GETHOSTBYADDR || type == GETHOSTBYNAME)
 213         {
 214           vec[2].iov_base = cp;
 215           vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;
 216
 217           ignore = alloca (hst_resp.h_addr_list_cnt * IN6ADDRSZ);
 218           vec[3].iov_base = ignore;
 219           vec[3].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;
 220
 221           for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)
 222             {
 223               resultbuf->h_addr_list[cnt] = cp;
 224               cp += INADDRSZ;
 225             }
 226
 227           resultbuf->h_addrtype = AF_INET;
 228           resultbuf->h_length = INADDRSZ;
 229
 230           total_len += hst_resp.h_addr_list_cnt * (INADDRSZ + IN6ADDRSZ);
 231
 232           n = 4;
 233         }
 234       else
 235         {
 236           if (hst_resp.h_length == INADDRSZ)
 237             {
 238               ignore = alloca (hst_resp.h_addr_list_cnt * INADDRSZ);
 239               vec[2].iov_base = ignore;
 240               vec[2].iov_len = hst_resp.h_addr_list_cnt * INADDRSZ;
 241
 242               total_len += hst_resp.h_addr_list_cnt * INADDRSZ;
 243
 244               n = 3;
 245             }
 246
 247           vec[n].iov_base = cp;
 248           vec[n].iov_len = hst_resp.h_addr_list_cnt * IN6ADDRSZ;
 249
 250           for (cnt = 0; cnt < hst_resp.h_addr_list_cnt; ++cnt)
 251             {
 252               resultbuf->h_addr_list[cnt] = cp;
 253               cp += IN6ADDRSZ;
 254             }
 255
 256           resultbuf->h_addrtype = AF_INET6;
 257           resultbuf->h_length = IN6ADDRSZ;
 258
 259           total_len += hst_resp.h_addr_list_cnt * IN6ADDRSZ;
 260
 261           ++n;
 262         }
 263       resultbuf->h_addr_list[cnt] = NULL;
 264
 265       if (__readv (sock, vec, n) != total_len)
 266         {
 267           __close (sock);
 268           return 1;
 269         }
 270
 271       /*  Now we also can read the aliases.  */
 272       total_len = 0;
 273       for (cnt = 0; cnt < hst_resp.h_aliases_cnt; ++cnt)
 274         {
 275           resultbuf->h_aliases[cnt] = cp;
 276           cp += aliases_len[cnt];
 277           total_len += aliases_len[cnt];
 278         }
 279       resultbuf->h_aliases[cnt] = NULL;
 280
 281       /* See whether this would exceed the buffer capacity.  */
 282       if (cp > buffer + buflen)
 283         goto no_room;
 284
 285       /* And finally read the aliases.  */
 286       if (__read (sock, resultbuf->h_aliases[0], total_len) != total_len)
 287         {
 288           __close (sock);
 289           return 1;
 290         }
 291
 292       __close (sock);
 293       return 0;
 294     }
 295   else
 296     {
 297       /* Store the error number.  */
 298       *h_errnop = hst_resp.error;
 299
 300       __close (sock);
 301       return -1;
 302     }
 303 }