src/os2/getaddrinfo.c

   1 /*****************************************************************************
   2  * getaddrinfo.c: getaddrinfo/getnameinfo replacement functions
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * Copyright (C) 2002-2007 Rémi Denis-Courmont
   6  * Copyright (C) 2011 KO Myung-Hun
   7  *
   8  * Authors: KO Myung-Hun <komh@chollian.net>
   9  *          Rémi Denis-Courmont <rem # videolan.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30 #include <vlc_common.h>
  31 #include <vlc_network.h>
  32
  33 #include <arpa/inet.h>
  34
  35 static const struct
  36 {
  37     int        code;
  38     const char msg[41];
  39 } gai_errlist[] =
  40 {
  41     { 0,              "Error 0" },
  42     { EAI_BADFLAGS,   "Invalid flag used" },
  43     { EAI_NONAME,     "Host or service not found" },
  44     { EAI_AGAIN,      "Temporary name service failure" },
  45     { EAI_FAIL,       "Non-recoverable name service failure" },
  46     { EAI_NODATA,     "No data for host name" },
  47     { EAI_FAMILY,     "Unsupported address family" },
  48     { EAI_SOCKTYPE,   "Unsupported socket type" },
  49     { EAI_SERVICE,    "Incompatible service for socket type" },
  50     { EAI_ADDRFAMILY, "Unavailable address family for host name" },
  51     { EAI_MEMORY,     "Memory allocation failure" },
  52     { EAI_OVERFLOW,   "Buffer overflow" },
  53     { EAI_SYSTEM,     "System error" },
  54     { 0,              "" },
  55 };
  56
  57 static const char gai_unknownerr[] = "Unrecognized error number";
  58
  59 /****************************************************************************
  60  * Converts an EAI_* error code into human readable english text.
  61  ****************************************************************************/
  62 const char *gai_strerror (int errnum)
  63 {
  64     for (unsigned i = 0; *gai_errlist[i].msg; i++)
  65         if (errnum == gai_errlist[i].code)
  66             return gai_errlist[i].msg;
  67
  68     return gai_unknownerr;
  69 }
  70
  71 #define _NI_MASK (NI_NUMERICHOST|NI_NUMERICSERV|NI_NOFQDN|NI_NAMEREQD|\
  72                   NI_DGRAM)
  73 /*
  74  * getnameinfo() non-thread-safe IPv4-only implementation,
  75  * Address-family-independent address to hostname translation
  76  * (reverse DNS lookup in case of IPv4).
  77  *
  78  * This is meant for use on old IP-enabled systems that are not IPv6-aware,
  79  * and probably do not have getnameinfo(), but have the old gethostbyaddr()
  80  * function.
  81  */
  82 int
  83 getnameinfo (const struct sockaddr *sa, socklen_t salen,
  84                  char *host, int hostlen, char *serv, int servlen, int flags)
  85 {
  86     if (((size_t)salen < sizeof (struct sockaddr_in))
  87      || (sa->sa_family != AF_INET))
  88         return EAI_FAMILY;
  89     else if (flags & (~_NI_MASK))
  90         return EAI_BADFLAGS;
  91     else
  92     {
  93         const struct sockaddr_in *addr;
  94
  95         addr = (const struct sockaddr_in *)sa;
  96
  97         if (host != NULL)
  98         {
  99             /* host name resolution */
 100             if (!(flags & NI_NUMERICHOST))
 101             {
 102                 if (flags & NI_NAMEREQD)
 103                     return EAI_NONAME;
 104             }
 105
 106             /* inet_ntoa() is not thread-safe, do not use it */
 107             uint32_t ipv4 = ntohl (addr->sin_addr.s_addr);
 108
 109             if (snprintf (host, hostlen, "%u.%u.%u.%u", ipv4 >> 24,
 110                           (ipv4 >> 16) & 0xff, (ipv4 >> 8) & 0xff,
 111                           ipv4 & 0xff) >= (int)hostlen)
 112                 return EAI_OVERFLOW;
 113         }
 114
 115         if (serv != NULL)
 116         {
 117             if (snprintf (serv, servlen, "%u",
 118                           (unsigned int)ntohs (addr->sin_port)) >= (int)servlen)
 119                 return EAI_OVERFLOW;
 120         }
 121     }
 122     return 0;
 123 }
 124
 125 #define _AI_MASK (AI_PASSIVE|AI_CANONNAME|AI_NUMERICHOST)
 126 /*
 127  * Converts the current herrno error value into an EAI_* error code.
 128  * That error code is normally returned by getnameinfo() or getaddrinfo().
 129  */
 130 static int
 131 gai_error_from_herrno (void)
 132 {
 133     switch (h_errno)
 134     {
 135         case HOST_NOT_FOUND:
 136             return EAI_NONAME;
 137
 138         case NO_ADDRESS:
 139 # if (NO_ADDRESS != NO_DATA)
 140         case NO_DATA:
 141 # endif
 142             return EAI_NODATA;
 143
 144         case NO_RECOVERY:
 145             return EAI_FAIL;
 146
 147         case TRY_AGAIN:
 148             return EAI_AGAIN;
 149     }
 150     return EAI_SYSTEM;
 151 }
 152
 153 /*
 154  * This functions must be used to free the memory allocated by getaddrinfo().
 155  */
 156 void freeaddrinfo (struct addrinfo *res)
 157 {
 158     if (res == NULL)
 159         return;
 160     free (res->ai_canonname);
 161     free (res->ai_addr);
 162     free (res->ai_next);
 163     free (res);
 164 }
 165
 166 /*
 167  * Internal function that builds an addrinfo struct.
 168  */
 169 static struct addrinfo *
 170 makeaddrinfo (int af, int type, int proto,
 171               const struct sockaddr *addr, size_t addrlen,
 172               const char *canonname)
 173 {
 174     struct addrinfo *res;
 175
 176     res = (struct addrinfo *)malloc (sizeof (struct addrinfo));
 177     if (res != NULL)
 178     {
 179         res->ai_flags = 0;
 180         res->ai_family = af;
 181         res->ai_socktype = type;
 182         res->ai_protocol = proto;
 183         res->ai_addrlen = addrlen;
 184         res->ai_addr = malloc (addrlen);
 185         res->ai_canonname = NULL;
 186         res->ai_next = NULL;
 187
 188         if (res->ai_addr != NULL)
 189         {
 190             memcpy (res->ai_addr, addr, addrlen);
 191
 192             if (canonname != NULL)
 193             {
 194                 res->ai_canonname = strdup (canonname);
 195                 if (res->ai_canonname != NULL)
 196                     return res; /* success ! */
 197             }
 198             else
 199                 return res;
 200         }
 201     }
 202     /* failsafe */
 203     freeaddrinfo (res);
 204     return NULL;
 205 }
 206
 207 static struct addrinfo *
 208 makeipv4info (int type, int proto, u_long ip, u_short port, const char *name)
 209 {
 210     struct sockaddr_in addr;
 211
 212     memset (&addr, 0, sizeof (addr));
 213     addr.sin_family = AF_INET;
 214 # ifdef HAVE_SA_LEN
 215     addr.sin_len = sizeof (addr);
 216 # endif
 217     addr.sin_port = port;
 218     addr.sin_addr.s_addr = ip;
 219
 220     return makeaddrinfo (AF_INET, type, proto,
 221                          (struct sockaddr*)&addr, sizeof (addr), name);
 222 }
 223
 224 /*
 225  * getaddrinfo() non-thread-safe IPv4-only implementation
 226  * Address-family-independent hostname to address resolution.
 227  *
 228  * This is meant for IPv6-unaware systems that do probably not provide
 229  * getaddrinfo(), but still have old function gethostbyname().
 230  *
 231  * Only UDP and TCP over IPv4 are supported here.
 232  */
 233 int
 234 getaddrinfo (const char *node, const char *service,
 235              const struct addrinfo *hints, struct addrinfo **res)
 236 {
 237     struct addrinfo *info;
 238     u_long ip;
 239     u_short port;
 240     int protocol = 0, flags = 0;
 241     const char *name = NULL;
 242
 243     if (hints != NULL)
 244     {
 245         flags = hints->ai_flags;
 246
 247         if (flags & ~_AI_MASK)
 248             return EAI_BADFLAGS;
 249         /* only accept AF_INET and AF_UNSPEC */
 250         if (hints->ai_family && (hints->ai_family != AF_INET))
 251             return EAI_FAMILY;
 252
 253         /* protocol sanity check */
 254         switch (hints->ai_socktype)
 255         {
 256             case SOCK_STREAM:
 257                 protocol = IPPROTO_TCP;
 258                 break;
 259
 260             case SOCK_DGRAM:
 261                 protocol = IPPROTO_UDP;
 262                 break;
 263
 264 #ifndef SOCK_RAW
 265             case SOCK_RAW:
 266 #endif
 267             case 0:
 268                 break;
 269
 270             default:
 271                 return EAI_SOCKTYPE;
 272         }
 273         if (hints->ai_protocol && protocol
 274          && (protocol != hints->ai_protocol))
 275             return EAI_SERVICE;
 276     }
 277
 278     *res = NULL;
 279
 280     /* default values */
 281     if (node == NULL)
 282     {
 283         if (flags & AI_PASSIVE)
 284             ip = htonl (INADDR_ANY);
 285         else
 286             ip = htonl (INADDR_LOOPBACK);
 287     }
 288     else
 289     if ((ip = inet_addr (node)) == INADDR_NONE)
 290     {
 291         struct hostent *entry = NULL;
 292
 293         /* hostname resolution */
 294         if (!(flags & AI_NUMERICHOST))
 295             entry = gethostbyname (node);
 296
 297         if (entry == NULL)
 298             return gai_error_from_herrno ();
 299
 300         if ((entry->h_length != 4) || (entry->h_addrtype != AF_INET))
 301             return EAI_FAMILY;
 302
 303         ip = *((u_long *) entry->h_addr);
 304         if (flags & AI_CANONNAME)
 305             name = entry->h_name;
 306     }
 307
 308     if ((flags & AI_CANONNAME) && (name == NULL))
 309         name = node;
 310
 311     /* service resolution */
 312     if (service == NULL)
 313         port = 0;
 314     else
 315     {
 316         unsigned long d;
 317         char *end;
 318
 319         d = strtoul (service, &end, 0);
 320         if (end[0] || (d > 65535u))
 321             return EAI_SERVICE;
 322
 323         port = htons ((u_short)d);
 324     }
 325
 326     /* building results... */
 327     if ((!protocol) || (protocol == IPPROTO_UDP))
 328     {
 329         info = makeipv4info (SOCK_DGRAM, IPPROTO_UDP, ip, port, name);
 330         if (info == NULL)
 331         {
 332             errno = ENOMEM;
 333             return EAI_SYSTEM;
 334         }
 335         if (flags & AI_PASSIVE)
 336             info->ai_flags |= AI_PASSIVE;
 337         *res = info;
 338     }
 339     if ((!protocol) || (protocol == IPPROTO_TCP))
 340     {
 341         info = makeipv4info (SOCK_STREAM, IPPROTO_TCP, ip, port, name);
 342         if (info == NULL)
 343         {
 344             errno = ENOMEM;
 345             return EAI_SYSTEM;
 346         }
 347         info->ai_next = *res;
 348         if (flags & AI_PASSIVE)
 349             info->ai_flags |= AI_PASSIVE;
 350         *res = info;
 351     }
 352
 353     return 0;
 354 }