lib/getaddrinfo.c

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