lib/getaddrinfo.c

   1 /* Get address information (partial implementation).
   2    Copyright (C) 1997, 2001, 2002, 2004, 2005, 2006, 2007 Free Software
   3    Foundation, Inc.
   4    Contributed by Simon Josefsson <simon@josefsson.org>.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 #include <config.h>
  21
  22 #include "getaddrinfo.h"
  23
  24 #if HAVE_NETINET_IN_H
  25 # include <netinet/in.h>
  26 #endif
  27
  28 /* Get calloc. */
  29 #include <stdlib.h>
  30
  31 /* Get memcpy, strdup. */
  32 #include <string.h>
  33
  34 #include <stdbool.h>
  35
  36 #include "gettext.h"
  37 #define _(String) gettext (String)
  38 #define N_(String) String
  39
  40 #include "inet_ntop.h"
  41 #include "snprintf.h"
  42
  43 /* BeOS has AF_INET, but not PF_INET.  */
  44 #ifndef PF_INET
  45 # define PF_INET AF_INET
  46 #endif
  47 /* BeOS also lacks PF_UNSPEC.  */
  48 #ifndef PF_UNSPEC
  49 # define PF_UNSPEC 0
  50 #endif
  51
  52 #if defined _WIN32 || defined __WIN32__
  53 # define WIN32_NATIVE
  54 #endif
  55
  56 #ifdef WIN32_NATIVE
  57 typedef int (WSAAPI *getaddrinfo_func) (const char*, const char*,
  58                                         const struct addrinfo*,
  59                                         struct addrinfo**);
  60 typedef void (WSAAPI *freeaddrinfo_func) (struct addrinfo*);
  61 typedef int (WSAAPI *getnameinfo_func) (const struct sockaddr*,
  62                                         socklen_t, char*, DWORD,
  63                                         char*, DWORD, int);
  64
  65 static getaddrinfo_func getaddrinfo_ptr = NULL;
  66 static freeaddrinfo_func freeaddrinfo_ptr = NULL;
  67 static getnameinfo_func getnameinfo_ptr = NULL;
  68
  69 static int
  70 use_win32_p (void)
  71 {
  72   static int done = 0;
  73   HMODULE h;
  74
  75   if (done)
  76     return getaddrinfo_ptr ? 1 : 0;
  77
  78   done = 1;
  79
  80   h = GetModuleHandle ("ws2_32.dll");
  81
  82   if (h)
  83     {
  84       getaddrinfo_ptr = (getaddrinfo_func) GetProcAddress (h, "getaddrinfo");
  85       freeaddrinfo_ptr = (freeaddrinfo_func) GetProcAddress (h, "freeaddrinfo");
  86       getnameinfo_ptr = (getnameinfo_func) GetProcAddress (h, "getnameinfo");
  87     }
  88
  89   /* If either is missing, something is odd. */
  90   if (!getaddrinfo_ptr || !freeaddrinfo_ptr || !getnameinfo_ptr)
  91     {
  92       getaddrinfo_ptr = NULL;
  93       freeaddrinfo_ptr = NULL;
  94       getnameinfo_ptr = NULL;
  95       return 0;
  96     }
  97
  98   return 1;
  99 }
 100 #endif
 101
 102 static inline bool
 103 validate_family (int family)
 104 {
 105   /* FIXME: Support more families. */
 106 #if HAVE_IPV4
 107      if (family == PF_INET)
 108        return true;
 109 #endif
 110 #if HAVE_IPV6
 111      if (family == PF_INET6)
 112        return true;
 113 #endif
 114      if (family == PF_UNSPEC)
 115        return true;
 116      return false;
 117 }
 118
 119 /* Translate name of a service location and/or a service name to set of
 120    socket addresses. */
 121 int
 122 getaddrinfo (const char *restrict nodename,
 123              const char *restrict servname,
 124              const struct addrinfo *restrict hints,
 125              struct addrinfo **restrict res)
 126 {
 127   struct addrinfo *tmp;
 128   int port = 0;
 129   struct hostent *he;
 130   void *storage;
 131   size_t size;
 132 #if HAVE_IPV6
 133   struct v6_pair {
 134     struct addrinfo addrinfo;
 135     struct sockaddr_in6 sockaddr_in6;
 136   };
 137 #endif
 138 #if HAVE_IPV4
 139   struct v4_pair {
 140     struct addrinfo addrinfo;
 141     struct sockaddr_in sockaddr_in;
 142   };
 143 #endif
 144
 145 #ifdef WIN32_NATIVE
 146   if (use_win32_p ())
 147     return getaddrinfo_ptr (nodename, servname, hints, res);
 148 #endif
 149
 150   if (hints && (hints->ai_flags & ~(AI_CANONNAME|AI_PASSIVE)))
 151     /* FIXME: Support more flags. */
 152     return EAI_BADFLAGS;
 153
 154   if (hints && !validate_family (hints->ai_family))
 155     return EAI_FAMILY;
 156
 157   if (hints &&
 158       hints->ai_socktype != SOCK_STREAM && hints->ai_socktype != SOCK_DGRAM)
 159     /* FIXME: Support other socktype. */
 160     return EAI_SOCKTYPE; /* FIXME: Better return code? */
 161
 162   if (!nodename)
 163     {
 164       if (!(hints->ai_flags & AI_PASSIVE))
 165         return EAI_NONAME;
 166
 167 #ifdef HAVE_IPV6
 168       nodename = (hints->ai_family == AF_INET6) ? "::" : "0.0.0.0";
 169 #else
 170       nodename = "0.0.0.0";
 171 #endif
 172     }
 173
 174   if (servname)
 175     {
 176       struct servent *se = NULL;
 177       const char *proto =
 178         (hints && hints->ai_socktype == SOCK_DGRAM) ? "udp" : "tcp";
 179
 180       if (!(hints->ai_flags & AI_NUMERICSERV))
 181         /* FIXME: Use getservbyname_r if available. */
 182         se = getservbyname (servname, proto);
 183
 184       if (!se)
 185         {
 186           char *c;
 187           if (!(*servname >= '0' && *servname <= '9'))
 188             return EAI_NONAME;
 189           port = strtoul (servname, &c, 10);
 190           if (*c || port > 0xffff)
 191             return EAI_NONAME;
 192           port = htons (port);
 193         }
 194       else
 195         port = se->s_port;
 196     }
 197
 198   /* FIXME: Use gethostbyname_r if available. */
 199   he = gethostbyname (nodename);
 200   if (!he || he->h_addr_list[0] == NULL)
 201     return EAI_NONAME;
 202
 203   switch (he->h_addrtype)
 204     {
 205 #if HAVE_IPV6
 206     case PF_INET6:
 207       size = sizeof (struct v6_pair);
 208       break;
 209 #endif
 210
 211 #if HAVE_IPV4
 212     case PF_INET:
 213       size = sizeof (struct v4_pair);
 214       break;
 215 #endif
 216
 217     default:
 218       return EAI_NODATA;
 219     }
 220
 221   storage = calloc (1, size);
 222   if (!storage)
 223     return EAI_MEMORY;
 224
 225   switch (he->h_addrtype)
 226     {
 227 #if HAVE_IPV6
 228     case PF_INET6:
 229       {
 230         struct v6_pair *p = storage;
 231         struct sockaddr_in6 *sinp = &p->sockaddr_in6;
 232         tmp = &p->addrinfo;
 233
 234         if (port)
 235           sinp->sin6_port = port;
 236
 237         if (he->h_length != sizeof (sinp->sin6_addr))
 238           {
 239             free (storage);
 240             return EAI_SYSTEM; /* FIXME: Better return code?  Set errno? */
 241           }
 242
 243         memcpy (&sinp->sin6_addr, he->h_addr_list[0], sizeof sinp->sin6_addr);
 244
 245         tmp->ai_addr = (struct sockaddr *) sinp;
 246         tmp->ai_addrlen = sizeof *sinp;
 247       }
 248       break;
 249 #endif
 250
 251 #if HAVE_IPV4
 252     case PF_INET:
 253       {
 254         struct v4_pair *p = storage;
 255         struct sockaddr_in *sinp = &p->sockaddr_in;
 256         tmp = &p->addrinfo;
 257
 258         if (port)
 259           sinp->sin_port = port;
 260
 261         if (he->h_length != sizeof (sinp->sin_addr))
 262           {
 263             free (storage);
 264             return EAI_SYSTEM; /* FIXME: Better return code?  Set errno? */
 265           }
 266
 267         memcpy (&sinp->sin_addr, he->h_addr_list[0], sizeof sinp->sin_addr);
 268
 269         tmp->ai_addr = (struct sockaddr *) sinp;
 270         tmp->ai_addrlen = sizeof *sinp;
 271       }
 272       break;
 273 #endif
 274
 275     default:
 276       free (storage);
 277       return EAI_NODATA;
 278     }
 279
 280   if (hints && hints->ai_flags & AI_CANONNAME)
 281     {
 282       const char *cn;
 283       if (he->h_name)
 284         cn = he->h_name;
 285       else
 286         cn = nodename;
 287
 288       tmp->ai_canonname = strdup (cn);
 289       if (!tmp->ai_canonname)
 290         {
 291           free (storage);
 292           return EAI_MEMORY;
 293         }
 294     }
 295
 296   tmp->ai_protocol = (hints) ? hints->ai_protocol : 0;
 297   tmp->ai_socktype = (hints) ? hints->ai_socktype : 0;
 298   tmp->ai_addr->sa_family = he->h_addrtype;
 299   tmp->ai_family = he->h_addrtype;
 300
 301   /* FIXME: If more than one address, create linked list of addrinfo's. */
 302
 303   *res = tmp;
 304
 305   return 0;
 306 }
 307
 308 /* Free `addrinfo' structure AI including associated storage.  */
 309 void
 310 freeaddrinfo (struct addrinfo *ai)
 311 {
 312 #ifdef WIN32_NATIVE
 313   if (use_win32_p ())
 314     {
 315       freeaddrinfo_ptr (ai);
 316       return;
 317     }
 318 #endif
 319
 320   while (ai)
 321     {
 322       struct addrinfo *cur;
 323
 324       cur = ai;
 325       ai = ai->ai_next;
 326
 327       if (cur->ai_canonname) free (cur->ai_canonname);
 328       free (cur);
 329     }
 330 }
 331
 332 int getnameinfo(const struct sockaddr *restrict sa, socklen_t salen,
 333                 char *restrict node, socklen_t nodelen,
 334                 char *restrict service, socklen_t servicelen,
 335                 int flags)
 336 {
 337 #ifdef WIN32_NATIVE
 338   if (use_win32_p ())
 339     return getnameinfo_ptr (sa, salen, node, nodelen,
 340                             service, servicelen, flags);
 341 #endif
 342
 343   /* FIXME: Support other flags. */
 344   if ((node && nodelen > 0 && !(flags & NI_NUMERICHOST)) ||
 345       (service && servicelen > 0 && !(flags & NI_NUMERICHOST)) ||
 346       (flags & ~(NI_NUMERICHOST|NI_NUMERICSERV)))
 347     return EAI_BADFLAGS;
 348
 349   if (sa == NULL || salen < sizeof (sa->sa_family))
 350     return EAI_FAMILY;
 351
 352   switch (sa->sa_family)
 353     {
 354 #if HAVE_IPV4
 355     case AF_INET:
 356       if (salen < sizeof (struct sockaddr_in))
 357         return EAI_FAMILY;
 358       break;
 359 #endif
 360 #if HAVE_IPV6
 361     case AF_INET6:
 362       if (salen < sizeof (struct sockaddr_in6))
 363         return EAI_FAMILY;
 364       break;
 365 #endif
 366     default:
 367       return EAI_FAMILY;
 368     }
 369
 370   if (node && nodelen > 0 && flags & NI_NUMERICHOST)
 371     {
 372       switch (sa->sa_family)
 373         {
 374 #if HAVE_IPV4
 375         case AF_INET:
 376           if (!inet_ntop (AF_INET,
 377                           &(((const struct sockaddr_in *) sa)->sin_addr),
 378                           node, nodelen))
 379             return EAI_SYSTEM;
 380           break;
 381 #endif
 382
 383 #if HAVE_IPV6
 384         case AF_INET6:
 385           if (!inet_ntop (AF_INET6,
 386                           &(((const struct sockaddr_in6 *) sa)->sin6_addr),
 387                           node, nodelen))
 388             return EAI_SYSTEM;
 389           break;
 390 #endif
 391
 392         default:
 393           return EAI_FAMILY;
 394         }
 395     }
 396
 397   if (service && servicelen > 0 && flags & NI_NUMERICSERV)
 398     switch (sa->sa_family)
 399       {
 400 #if HAVE_IPV4
 401       case AF_INET:
 402 #endif
 403 #if HAVE_IPV6
 404       case AF_INET6:
 405 #endif
 406         {
 407           unsigned short int port
 408             = ntohs (((const struct sockaddr_in *) sa)->sin_port);
 409           if (servicelen <= snprintf (service, servicelen, "%u", port))
 410             return EAI_OVERFLOW;
 411         }
 412         break;
 413       }
 414
 415   return 0;
 416 }