plugins/getaddrinfo.c

   1 /*
   2  *  This file is part of libESMTP, a library for submission of RFC 2822
   3  *  formatted electronic mail messages using the SMTP protocol described
   4  *  in RFC 2821.
   5  *  Modified by Jeremy T. Bouse for use in Nagios plugins
   6  *
   7  *  Copyright (C) 2001,2002  Brian Stafford  <brian@stafford.uklinux.net>
   8  *
   9  *  This library is free software; you can redistribute it and/or
  10  *  modify it under the terms of the GNU Lesser General Public
  11  *  License as published by the Free Software Foundation; either
  12  *  version 2.1 of the License, or (at your option) any later version.
  13  *
  14  *  This library is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  Lesser General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU Lesser General Public
  20  *  License along with this library; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 /* An emulation of the RFC 2553 / Posix getaddrinfo resolver interface.
  25  *
  26  * $Id$
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include <config.h>
  31 #endif
  32
  33 /* Need to turn off Posix features in glibc to build this */
  34 #undef _POSIX_C_SOURCE
  35 #undef _XOPEN_SOURCE
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <ctype.h>
  40 #include <errno.h>
  41
  42 #include <sys/socket.h>
  43 #include <netinet/in.h>
  44 #include <arpa/inet.h>
  45
  46 #include <netdb.h>
  47
  48 #include "gethostbyname.h"
  49 #include "getaddrinfo.h"
  50
  51 static struct addrinfo *
  52 dup_addrinfo (struct addrinfo *info, void *addr, size_t addrlen)
  53 {
  54   struct addrinfo *ret;
  55
  56   ret = malloc (sizeof (struct addrinfo));
  57   if (ret == NULL)
  58     return NULL;
  59   memcpy (ret, info, sizeof (struct addrinfo));
  60   ret->ai_addr = malloc (addrlen);
  61   if (ret->ai_addr == NULL)
  62     {
  63       free (ret);
  64       return NULL;
  65     }
  66   memcpy (ret->ai_addr, addr, addrlen);
  67   ret->ai_addrlen = addrlen;
  68   return ret;
  69 }
  70
  71 int
  72 getaddrinfo (const char *nodename, const char *servname,
  73              const struct addrinfo *hints, struct addrinfo **res)
  74 {
  75   struct hostent *hp;
  76   struct servent *servent;
  77   const char *socktype;
  78   int port;
  79   struct addrinfo hint, result;
  80   struct addrinfo *ai, *sai, *eai;
  81   struct ghbnctx ghbnctx;
  82   char **addrs;
  83   int code;
  84
  85   memset (&result, 0, sizeof result);
  86
  87   /* default for hints */
  88   if (hints == NULL)
  89     {
  90       memset (&hint, 0, sizeof hint);
  91       hint.ai_family = PF_UNSPEC;
  92       hints = &hint;
  93     }
  94
  95   result.ai_socktype = hints->ai_socktype;
  96
  97   /* Note: maintain port in host byte order to make debugging easier */
  98   if (servname != NULL) {
  99     if (isdigit (*servname))
 100       port = strtol (servname, NULL, 10);
 101     else if ((servent = getservbyname (servname, socktype)) != NULL)
 102       port = ntohs (servent->s_port);
 103     else
 104       return EAI_NONAME;
 105   }
 106
 107   /* if nodename == NULL refer to the local host for a client or any
 108      for a server */
 109   if (nodename == NULL)
 110     {
 111       struct sockaddr_in sin;
 112
 113       /* check protocol family is PF_UNSPEC or PF_INET - could try harder
 114          for IPv6 but that's more code than I'm prepared to write */
 115       if (hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET)
 116         result.ai_family = AF_INET;
 117       else
 118         return EAI_FAMILY;
 119
 120       sin.sin_family = result.ai_family;
 121       sin.sin_port = htons (port);
 122       if (hints->ai_flags & AI_PASSIVE)
 123         sin.sin_addr.s_addr = htonl (INADDR_ANY);
 124       else
 125         sin.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
 126       /* Duplicate result and addr and return */
 127       *res = dup_addrinfo (&result, &sin, sizeof sin);
 128       return (*res == NULL) ? EAI_MEMORY : 0;
 129     }
 130
 131   /* If AI_NUMERIC is specified, use inet_addr to translate numbers and
 132      dots notation. */
 133   if (hints->ai_flags & AI_NUMERICHOST)
 134     {
 135       struct sockaddr_in sin;
 136
 137       /* check protocol family is PF_UNSPEC or PF_INET */
 138       if (hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET)
 139         result.ai_family = AF_INET;
 140       else
 141         return EAI_FAMILY;
 142
 143       sin.sin_family = result.ai_family;
 144       sin.sin_port = htons (port);
 145       sin.sin_addr.s_addr = inet_addr (nodename);
 146       /* Duplicate result and addr and return */
 147       *res = dup_addrinfo (&result, &sin, sizeof sin);
 148       return (*res == NULL) ? EAI_MEMORY : 0;
 149     }
 150
 151   errno = 0;
 152   hp = gethostbyname_ctx (nodename, &ghbnctx);
 153   if (hp == NULL)
 154     {
 155       if (errno != 0)
 156         {
 157           free_ghbnctx (&ghbnctx);
 158           return EAI_SYSTEM;
 159         }
 160       code = h_error_ctx (&ghbnctx);
 161       switch (code)
 162         {
 163         case HOST_NOT_FOUND: code = EAI_NODATA; break;
 164         case NO_DATA: code = EAI_NODATA; break;
 165 #if defined(NO_ADDRESS) && NO_ADDRESS != NO_DATA
 166         case NO_ADDRESS: code = EAI_NODATA; break;
 167 #endif
 168         case NO_RECOVERY: code = EAI_FAIL; break;
 169         case TRY_AGAIN: code = EAI_AGAIN; break;
 170         default: code = EAI_FAIL; break;
 171         }
 172       free_ghbnctx (&ghbnctx);
 173       return code;
 174     }
 175
 176   /* Check that the address family is acceptable.
 177    */
 178   switch (hp->h_addrtype)
 179     {
 180     case AF_INET:
 181       if (!(hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET))
 182         goto eai_family;
 183       break;
 184 #ifdef USE_IPV6
 185     case AF_INET6:
 186       if (!(hints->ai_family == PF_UNSPEC || hints->ai_family == PF_INET6))
 187         goto eai_family;
 188       break;
 189 #endif
 190     default:
 191     eai_family:
 192       free_ghbnctx (&ghbnctx);
 193       return EAI_FAMILY;
 194     }
 195
 196   /* For each element pointed to by hp, create an element in the
 197      result linked list. */
 198   sai = eai = NULL;
 199   for (addrs = hp->h_addr_list; *addrs != NULL; addrs++)
 200     {
 201       struct sockaddr sa;
 202       size_t addrlen;
 203
 204       sa.sa_family = hp->h_addrtype;
 205       switch (hp->h_addrtype)
 206         {
 207         case AF_INET:
 208           ((struct sockaddr_in *) &sa)->sin_port = htons (port);
 209           memcpy (&((struct sockaddr_in *) &sa)->sin_addr,
 210                   *addrs, hp->h_length);
 211           addrlen = sizeof (struct sockaddr_in);
 212           break;
 213 #ifdef USE_IPV6
 214         case AF_INET6:
 215 # if SIN6_LEN
 216           ((struct sockaddr_in6 *) &sa)->sin6_len = hp->h_length;
 217 # endif
 218           ((struct sockaddr_in6 *) &sa)->sin6_port = htons (port);
 219           memcpy (&((struct sockaddr_in6 *) &sa)->sin6_addr,
 220                   *addrs, hp->h_length);
 221           addrlen = sizeof (struct sockaddr_in6);
 222           break;
 223 #endif
 224         default:
 225           continue;
 226         }
 227
 228       result.ai_family = hp->h_addrtype;
 229       ai = dup_addrinfo (&result, &sa, addrlen);
 230       if (ai == NULL)
 231         {
 232           free_ghbnctx (&ghbnctx);
 233           freeaddrinfo (sai);
 234           return EAI_MEMORY;
 235         }
 236       if (sai == NULL)
 237         sai = ai;
 238       else
 239         eai->ai_next = ai;
 240       eai = ai;
 241     }
 242
 243   if (sai == NULL)
 244     {
 245       free_ghbnctx (&ghbnctx);
 246       return EAI_NODATA;
 247     }
 248
 249   if (hints->ai_flags & AI_CANONNAME)
 250     {
 251       sai->ai_canonname = malloc (strlen (hp->h_name) + 1);
 252       if (sai->ai_canonname == NULL)
 253         {
 254           free_ghbnctx (&ghbnctx);
 255           freeaddrinfo (sai);
 256           return EAI_MEMORY;
 257         }
 258       strcpy (sai->ai_canonname, hp->h_name);
 259     }
 260
 261   free_ghbnctx (&ghbnctx);
 262   *res = sai;
 263   return 0;
 264 }
 265
 266 void
 267 freeaddrinfo (struct addrinfo *ai)
 268 {
 269   struct addrinfo *next;
 270
 271   while (ai != NULL)
 272     {
 273       next = ai->ai_next;
 274       if (ai->ai_canonname != NULL)
 275         free (ai->ai_canonname);
 276       if (ai->ai_addr != NULL)
 277         free (ai->ai_addr);
 278       free (ai);
 279       ai = next;
 280     }
 281 }
 282
 283 const char *
 284 gai_strerror (int ecode)
 285 {
 286   static const char *eai_descr[] =
 287     {
 288       "no error",
 289       "address family for nodename not supported",      /* EAI_ADDRFAMILY */
 290       "temporary failure in name resolution",           /* EAI_AGAIN */
 291       "invalid value for ai_flags",                     /* EAI_BADFLAGS */
 292       "non-recoverable failure in name resolution",     /* EAI_FAIL */
 293       "ai_family not supported",                        /* EAI_FAMILY */
 294       "memory allocation failure",                      /* EAI_MEMORY */
 295       "no address associated with nodename",            /* EAI_NODATA */
 296       "nodename nor servname provided, or not known",   /* EAI_NONAME */
 297       "servname not supported for ai_socktype",         /* EAI_SERVICE */
 298       "ai_socktype not supported",                      /* EAI_SOCKTYPE */
 299       "system error returned in errno",                 /* EAI_SYSTEM */
 300     };
 301
 302   if (ecode < 0 || ecode > (int) (sizeof eai_descr/ sizeof eai_descr[0]))
 303     return "unknown error";
 304   return eai_descr[ecode];
 305 }