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 Lesser 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 #ifdef HAVE_ARPA_INET_H
  34 #include <arpa/inet.h>
  35 #endif
  36
  37 #define _NI_MASK (NI_NUMERICHOST|NI_NUMERICSERV|NI_NOFQDN|NI_NAMEREQD|\
  38                   NI_DGRAM)
  39 /*
  40  * getnameinfo() non-thread-safe IPv4-only implementation,
  41  * Address-family-independent address to hostname translation
  42  * (reverse DNS lookup in case of IPv4).
  43  *
  44  * This is meant for use on old IP-enabled systems that are not IPv6-aware,
  45  * and probably do not have getnameinfo(), but have the old gethostbyaddr()
  46  * function.
  47  */
  48 int
  49 getnameinfo (const struct sockaddr *sa, socklen_t salen,
  50                  char *host, int hostlen, char *serv, int servlen, int flags)
  51 {
  52     if (((size_t)salen < sizeof (struct sockaddr_in))
  53      || (sa->sa_family != AF_INET))
  54         return EAI_FAMILY;
  55     else if (flags & (~_NI_MASK))
  56         return EAI_BADFLAGS;
  57     else
  58     {
  59         const struct sockaddr_in *addr;
  60
  61         addr = (const struct sockaddr_in *)sa;
  62
  63         if (host != NULL)
  64         {
  65             /* host name resolution */
  66             if (!(flags & NI_NUMERICHOST))
  67             {
  68                 if (flags & NI_NAMEREQD)
  69                     return EAI_NONAME;
  70             }
  71
  72             /* inet_ntoa() is not thread-safe, do not use it */
  73             uint32_t ipv4 = ntohl (addr->sin_addr.s_addr);
  74
  75             if (snprintf (host, hostlen, "%u.%u.%u.%u", ipv4 >> 24,
  76                           (ipv4 >> 16) & 0xff, (ipv4 >> 8) & 0xff,
  77                           ipv4 & 0xff) >= (int)hostlen)
  78                 return EAI_OVERFLOW;
  79         }
  80
  81         if (serv != NULL)
  82         {
  83             if (snprintf (serv, servlen, "%u",
  84                           (unsigned int)ntohs (addr->sin_port)) >= (int)servlen)
  85                 return EAI_OVERFLOW;
  86         }
  87     }
  88     return 0;
  89 }
  90
  91 #define _AI_MASK (AI_PASSIVE|AI_CANONNAME|AI_NUMERICHOST)
  92 /*
  93  * Converts the current herrno error value into an EAI_* error code.
  94  * That error code is normally returned by getnameinfo() or getaddrinfo().
  95  */
  96 static int
  97 gai_error_from_herrno (void)
  98 {
  99     switch (h_errno)
 100     {
 101         case HOST_NOT_FOUND:
 102             return EAI_NONAME;
 103
 104         case NO_ADDRESS:
 105 # if (NO_ADDRESS != NO_DATA)
 106         case NO_DATA:
 107 # endif
 108             return EAI_NODATA;
 109
 110         case NO_RECOVERY:
 111             return EAI_FAIL;
 112
 113         case TRY_AGAIN:
 114             return EAI_AGAIN;
 115     }
 116     return EAI_SYSTEM;
 117 }
 118
 119 /*
 120  * Internal function that builds an addrinfo struct.
 121  */
 122 static struct addrinfo *
 123 makeaddrinfo (int af, int type, int proto,
 124               const struct sockaddr *addr, size_t addrlen,
 125               const char *canonname)
 126 {
 127     struct addrinfo *res;
 128
 129     res = (struct addrinfo *)malloc (sizeof (struct addrinfo));
 130     if (res != NULL)
 131     {
 132         res->ai_flags = 0;
 133         res->ai_family = af;
 134         res->ai_socktype = type;
 135         res->ai_protocol = proto;
 136         res->ai_addrlen = addrlen;
 137         res->ai_addr = malloc (addrlen);
 138         res->ai_canonname = NULL;
 139         res->ai_next = NULL;
 140
 141         if (res->ai_addr != NULL)
 142         {
 143             memcpy (res->ai_addr, addr, addrlen);
 144
 145             if (canonname != NULL)
 146             {
 147                 res->ai_canonname = strdup (canonname);
 148                 if (res->ai_canonname != NULL)
 149                     return res; /* success ! */
 150             }
 151             else
 152                 return res;
 153         }
 154     }
 155     /* failsafe */
 156     freeaddrinfo (res);
 157     return NULL;
 158 }
 159
 160 static struct addrinfo *
 161 makeipv4info (int type, int proto, u_long ip, u_short port, const char *name)
 162 {
 163     struct sockaddr_in addr;
 164
 165     memset (&addr, 0, sizeof (addr));
 166     addr.sin_family = AF_INET;
 167 # ifdef HAVE_SA_LEN
 168     addr.sin_len = sizeof (addr);
 169 # endif
 170     addr.sin_port = port;
 171     addr.sin_addr.s_addr = ip;
 172
 173     return makeaddrinfo (AF_INET, type, proto,
 174                          (struct sockaddr*)&addr, sizeof (addr), name);
 175 }
 176
 177 /*
 178  * getaddrinfo() non-thread-safe IPv4-only implementation
 179  * Address-family-independent hostname to address resolution.
 180  *
 181  * This is meant for IPv6-unaware systems that do probably not provide
 182  * getaddrinfo(), but still have old function gethostbyname().
 183  *
 184  * Only UDP and TCP over IPv4 are supported here.
 185  */
 186 int
 187 getaddrinfo (const char *node, const char *service,
 188              const struct addrinfo *hints, struct addrinfo **res)
 189 {
 190     struct addrinfo *info;
 191     u_long ip;
 192     u_short port;
 193     int protocol = 0, flags = 0;
 194     const char *name = NULL;
 195
 196     if (hints != NULL)
 197     {
 198         flags = hints->ai_flags;
 199
 200         if (flags & ~_AI_MASK)
 201             return EAI_BADFLAGS;
 202         /* only accept AF_INET and AF_UNSPEC */
 203         if (hints->ai_family && (hints->ai_family != AF_INET))
 204             return EAI_FAMILY;
 205
 206         /* protocol sanity check */
 207         switch (hints->ai_socktype)
 208         {
 209             case SOCK_STREAM:
 210                 protocol = IPPROTO_TCP;
 211                 break;
 212
 213             case SOCK_DGRAM:
 214                 protocol = IPPROTO_UDP;
 215                 break;
 216
 217 #ifdef SOCK_RAW
 218             case SOCK_RAW:
 219 #endif
 220             case 0:
 221                 break;
 222
 223             default:
 224                 return EAI_SOCKTYPE;
 225         }
 226         if (hints->ai_protocol && protocol
 227          && (protocol != hints->ai_protocol))
 228             return EAI_SERVICE;
 229     }
 230
 231     *res = NULL;
 232
 233     /* default values */
 234     if (node == NULL)
 235     {
 236         if (flags & AI_PASSIVE)
 237             ip = htonl (INADDR_ANY);
 238         else
 239             ip = htonl (INADDR_LOOPBACK);
 240     }
 241     else
 242     if ((ip = inet_addr (node)) == INADDR_NONE)
 243     {
 244         struct hostent *entry = NULL;
 245
 246         /* hostname resolution */
 247         if (!(flags & AI_NUMERICHOST))
 248             entry = gethostbyname (node);
 249
 250         if (entry == NULL)
 251             return gai_error_from_herrno ();
 252
 253         if ((entry->h_length != 4) || (entry->h_addrtype != AF_INET))
 254             return EAI_FAMILY;
 255
 256         ip = *((u_long *) entry->h_addr);
 257         if (flags & AI_CANONNAME)
 258             name = entry->h_name;
 259     }
 260
 261     if ((flags & AI_CANONNAME) && (name == NULL))
 262         name = node;
 263
 264     /* service resolution */
 265     if (service == NULL)
 266         port = 0;
 267     else
 268     {
 269         unsigned long d;
 270         char *end;
 271
 272         d = strtoul (service, &end, 0);
 273         if (end[0] || (d > 65535u))
 274             return EAI_SERVICE;
 275
 276         port = htons ((u_short)d);
 277     }
 278
 279     /* building results... */
 280     if ((!protocol) || (protocol == IPPROTO_UDP))
 281     {
 282         info = makeipv4info (SOCK_DGRAM, IPPROTO_UDP, ip, port, name);
 283         if (info == NULL)
 284         {
 285             errno = ENOMEM;
 286             return EAI_SYSTEM;
 287         }
 288         if (flags & AI_PASSIVE)
 289             info->ai_flags |= AI_PASSIVE;
 290         *res = info;
 291     }
 292     if ((!protocol) || (protocol == IPPROTO_TCP))
 293     {
 294         info = makeipv4info (SOCK_STREAM, IPPROTO_TCP, ip, port, name);
 295         if (info == NULL)
 296         {
 297             errno = ENOMEM;
 298             return EAI_SYSTEM;
 299         }
 300         info->ai_next = *res;
 301         if (flags & AI_PASSIVE)
 302             info->ai_flags |= AI_PASSIVE;
 303         *res = info;
 304     }
 305
 306     return 0;
 307 }