git.sesse.net Git - vlc/blob - src/network/getaddrinfo.c

   1 /*****************************************************************************
   2  * getaddrinfo.c: getaddrinfo/getnameinfo replacement functions
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * Copyright (C) 2002-2004 Rémi Denis-Courmont
   6  * $Id$
   7  *
   8  * Author: Rémi Denis-Courmont <rem # videolan.org>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 #include <vlc/vlc.h>
  26
  27 #include <stddef.h> /* size_t */
  28 #include <string.h> /* strlen(), memcpy(), memset(), strchr() */
  29 #include <stdlib.h> /* malloc(), free(), strtoul() */
  30 #include <errno.h>
  31
  32 #ifdef HAVE_SYS_TYPES_H
  33 #   include <sys/types.h>
  34 #endif
  35 #ifdef HAVE_ARPA_INET_H
  36 #   include <arpa/inet.h>
  37 #endif
  38 #ifdef HAVE_NETINET_IN_H
  39 #   include <netinet/in.h>
  40 #endif
  41 #ifdef HAVE_UNISTD_H
  42 #   include <unistd.h>
  43 #endif
  44
  45 #include <vlc_network.h>
  46
  47 #ifndef NO_ADDRESS
  48 #   define NO_ADDRESS  NO_DATA
  49 #endif
  50 #ifndef INADDR_NONE
  51 #   define INADDR_NONE 0xFFFFFFFF
  52 #endif
  53 #ifndef AF_UNSPEC
  54 #   define AF_UNSPEC   0
  55 #endif
  56 #ifndef EAI_OVERFLOW
  57 #   define EAI_OVERFLOW -12   /* Argument buffer overflow.  */
  58 #endif
  59
  60 #define _NI_MASK (NI_NUMERICHOST|NI_NUMERICSERV|NI_NOFQDN|NI_NAMEREQD|\
  61                   NI_DGRAM)
  62 #define _AI_MASK (AI_PASSIVE|AI_CANONNAME|AI_NUMERICHOST)
  63
  64
  65 #ifndef HAVE_GAI_STRERROR
  66 static struct
  67 {
  68     int code;
  69     const char *msg;
  70 } const __gai_errlist[] =
  71 {
  72     { 0,              "Error 0" },
  73     { EAI_BADFLAGS,   "Invalid flag used" },
  74     { EAI_NONAME,     "Host or service not found" },
  75     { EAI_AGAIN,      "Temporary name service failure" },
  76     { EAI_FAIL,       "Non-recoverable name service failure" },
  77     { EAI_NODATA,     "No data for host name" },
  78     { EAI_FAMILY,     "Unsupported address family" },
  79     { EAI_SOCKTYPE,   "Unsupported socket type" },
  80     { EAI_SERVICE,    "Incompatible service for socket type" },
  81     { EAI_ADDRFAMILY, "Unavailable address family for host name" },
  82     { EAI_MEMORY,     "Memory allocation failure" },
  83     { EAI_SYSTEM,     "System error" },
  84     { 0,              NULL }
  85 };
  86
  87 static const char *__gai_unknownerr = "Unrecognized error number";
  88
  89 /****************************************************************************
  90  * Converts an EAI_* error code into human readable english text.
  91  ****************************************************************************/
  92 const char *vlc_gai_strerror( int errnum )
  93 {
  94     int i;
  95
  96     for (i = 0; __gai_errlist[i].msg != NULL; i++)
  97         if (errnum == __gai_errlist[i].code)
  98             return __gai_errlist[i].msg;
  99
 100     return __gai_unknownerr;
 101 }
 102 # undef _EAI_POSITIVE_MAX
 103 #else /* ifndef HAVE_GAI_STRERROR */
 104 const char *vlc_gai_strerror( int errnum )
 105 {
 106     return gai_strerror( errnum );
 107 }
 108 #endif
 109
 110 #if !(defined (HAVE_GETNAMEINFO) && defined (HAVE_GETADDRINFO))
 111 /*
 112  * Converts the current herrno error value into an EAI_* error code.
 113  * That error code is normally returned by getnameinfo() or getaddrinfo().
 114  */
 115 static int
 116 gai_error_from_herrno( void )
 117 {
 118     switch(h_errno)
 119     {
 120         case HOST_NOT_FOUND:
 121             return EAI_NONAME;
 122
 123         case NO_ADDRESS:
 124 # if (NO_ADDRESS != NO_DATA)
 125         case NO_DATA:
 126 # endif
 127             return EAI_NODATA;
 128
 129         case NO_RECOVERY:
 130             return EAI_FAIL;
 131
 132         case TRY_AGAIN:
 133             return EAI_AGAIN;
 134     }
 135     return EAI_SYSTEM;
 136 }
 137 #endif /* if !(HAVE_GETNAMEINFO && HAVE_GETADDRINFO) */
 138
 139 #ifndef HAVE_GETNAMEINFO
 140 /*
 141  * getnameinfo() non-thread-safe IPv4-only implementation,
 142  * Address-family-independant address to hostname translation
 143  * (reverse DNS lookup in case of IPv4).
 144  *
 145  * This is meant for use on old IP-enabled systems that are not IPv6-aware,
 146  * and probably do not have getnameinfo(), but have the old gethostbyaddr()
 147  * function.
 148  *
 149  * GNU C library 2.0.x is known to lack this function, even though it defines
 150  * getaddrinfo().
 151  */
 152 static int
 153 __getnameinfo( const struct sockaddr *sa, socklen_t salen,
 154                char *host, int hostlen, char *serv, int servlen, int flags )
 155 {
 156     if (((unsigned)salen < sizeof (struct sockaddr_in))
 157      || (sa->sa_family != AF_INET))
 158         return EAI_FAMILY;
 159     else if (flags & (~_NI_MASK))
 160         return EAI_BADFLAGS;
 161     else
 162     {
 163         const struct sockaddr_in *addr;
 164
 165         addr = (const struct sockaddr_in *)sa;
 166
 167         if (host != NULL)
 168         {
 169             /* host name resolution */
 170             if (!(flags & NI_NUMERICHOST))
 171             {
 172                 if (flags & NI_NAMEREQD)
 173                     return EAI_NONAME;
 174             }
 175
 176             /* inet_ntoa() is not thread-safe, do not use it */
 177             uint32_t ipv4 = ntohl (addr->sin_addr.s_addr);
 178
 179             if (snprintf (host, hostlen, "%u.%u.%u.%u", ipv4 >> 24,
 180                           (ipv4 >> 16) & 0xff, (ipv4 >> 8) & 0xff,
 181                           ipv4 & 0xff) >= hostlen)
 182                 return EAI_OVERFLOW;
 183         }
 184
 185         if (serv != NULL)
 186         {
 187             if (snprintf (serv, servlen, "%u",
 188                           (unsigned int)ntohs (addr->sin_port)) >= servlen)
 189                 return EAI_OVERFLOW;
 190         }
 191     }
 192     return 0;
 193 }
 194
 195 #endif /* if !HAVE_GETNAMEINFO */
 196
 197 #if defined( WIN32 ) && !defined( UNDER_CE )
 198     /*
 199      * Here is the kind of kludge you need to keep binary compatibility among
 200      * varying OS versions...
 201      */
 202 typedef int (CALLBACK * GETNAMEINFO) ( const struct sockaddr*, socklen_t,
 203                                            char*, DWORD, char*, DWORD, int );
 204 typedef int (CALLBACK * GETADDRINFO) (const char *, const char *,
 205                                           const struct addrinfo *,
 206                                           struct addrinfo **);
 207
 208 typedef void (CALLBACK * FREEADDRINFO) ( struct addrinfo * );
 209
 210
 211 static WINAPI int _ws2_getnameinfo_bind( const struct sockaddr *sa, socklen_t salen,
 212                char *host, DWORD hostlen, char *serv, DWORD servlen, int flags );
 213
 214 static WINAPI int _ws2_getaddrinfo_bind(const char *node, const char *service,
 215                const struct addrinfo *hints, struct addrinfo **res);
 216
 217 static WINAPI void _ws2_freeaddrinfo_bind( struct addrinfo *infos );
 218
 219 static GETNAMEINFO ws2_getnameinfo = _ws2_getnameinfo_bind;
 220 static GETADDRINFO ws2_getaddrinfo = _ws2_getaddrinfo_bind;
 221 static FREEADDRINFO ws2_freeaddrinfo = _ws2_freeaddrinfo_bind;
 222
 223 static int _ws2_find_ipv6_api(void)
 224 {
 225     /* For Windows XP and above, IPv6 stack is in WS2_32.DLL */
 226     HINSTANCE module = LoadLibrary( "ws2_32.dll" );
 227     if( module != NULL )
 228     {
 229         ws2_getnameinfo = (GETNAMEINFO)GetProcAddress( module, "getnameinfo" );
 230         ws2_getaddrinfo = (GETADDRINFO)GetProcAddress( module, "getaddrinfo" );
 231         ws2_freeaddrinfo = (FREEADDRINFO)GetProcAddress( module, "freeaddrinfo" );
 232         if( ws2_getnameinfo && ws2_getaddrinfo && ws2_freeaddrinfo )
 233         {
 234             /* got them */
 235             return 1;
 236         }
 237         FreeLibrary( module );
 238
 239         /* For Windows 2000 and below, try IPv6 stack in in WSHIP6.DLL */
 240         module = LoadLibrary( "wship6.dll" );
 241         if( module != NULL )
 242         {
 243             ws2_getnameinfo = (GETNAMEINFO)GetProcAddress( module, "getnameinfo" );
 244             ws2_getaddrinfo = (GETADDRINFO)GetProcAddress( module, "getaddrinfo" );
 245             ws2_freeaddrinfo = (FREEADDRINFO)GetProcAddress( module, "freeaddrinfo" );
 246             if( ws2_getnameinfo && ws2_getaddrinfo && ws2_freeaddrinfo )
 247             {
 248                 /* got them */
 249                 return 1;
 250             }
 251             FreeLibrary( module );
 252         }
 253     }
 254     /* no API */
 255     return 0;
 256 }
 257
 258 static WINAPI int _ws2_getnameinfo_bind( const struct sockaddr *sa, socklen_t salen,
 259                char *host, DWORD hostlen, char *serv, DWORD servlen, int flags )
 260 {
 261     if( _ws2_find_ipv6_api() )
 262     {
 263         return ws2_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
 264     }
 265     /* return a possible error if API is not found */
 266     WSASetLastError(WSAHOST_NOT_FOUND);
 267     return WSAHOST_NOT_FOUND;
 268 }
 269
 270 static WINAPI int _ws2_getaddrinfo_bind(const char *node, const char *service,
 271                const struct addrinfo *hints, struct addrinfo **res)
 272 {
 273     if( _ws2_find_ipv6_api() )
 274     {
 275         return ws2_getaddrinfo(node, service, hints, res);
 276     }
 277     /* return a possible error if API is not found */
 278     WSASetLastError(WSAHOST_NOT_FOUND);
 279     return WSAHOST_NOT_FOUND;
 280 }
 281
 282 static WINAPI void _ws2_freeaddrinfo_bind( struct addrinfo *infos )
 283 {
 284     if( _ws2_find_ipv6_api() )
 285     {
 286         ws2_freeaddrinfo(infos);
 287     }
 288 }
 289
 290 #endif
 291
 292 #ifndef HAVE_GETADDRINFO
 293 /*
 294  * This functions must be used to free the memory allocated by getaddrinfo().
 295  */
 296 static void
 297 __freeaddrinfo (struct addrinfo *res)
 298 {
 299     if (res != NULL)
 300     {
 301         if (res->ai_canonname != NULL)
 302             free (res->ai_canonname);
 303         if (res->ai_addr != NULL)
 304             free (res->ai_addr);
 305         if (res->ai_next != NULL)
 306             free (res->ai_next);
 307         free (res);
 308     }
 309 }
 310
 311
 312 /*
 313  * Internal function that builds an addrinfo struct.
 314  */
 315 static struct addrinfo *
 316 makeaddrinfo (int af, int type, int proto,
 317               const struct sockaddr *addr, size_t addrlen,
 318               const char *canonname)
 319 {
 320     struct addrinfo *res;
 321
 322     res = (struct addrinfo *)malloc (sizeof (struct addrinfo));
 323     if (res != NULL)
 324     {
 325         res->ai_flags = 0;
 326         res->ai_family = af;
 327         res->ai_socktype = type;
 328         res->ai_protocol = proto;
 329         res->ai_addrlen = addrlen;
 330         res->ai_addr = malloc (addrlen);
 331         res->ai_canonname = NULL;
 332         res->ai_next = NULL;
 333
 334         if (res->ai_addr != NULL)
 335         {
 336             memcpy (res->ai_addr, addr, addrlen);
 337
 338             if (canonname != NULL)
 339             {
 340                 res->ai_canonname = strdup (canonname);
 341                 if (res->ai_canonname != NULL)
 342                     return res; /* success ! */
 343             }
 344             else
 345                 return res;
 346         }
 347     }
 348     /* failsafe */
 349     vlc_freeaddrinfo (res);
 350     return NULL;
 351 }
 352
 353
 354 static struct addrinfo *
 355 makeipv4info (int type, int proto, u_long ip, u_short port, const char *name)
 356 {
 357     struct sockaddr_in addr;
 358
 359     memset (&addr, 0, sizeof (addr));
 360     addr.sin_family = AF_INET;
 361 # ifdef HAVE_SA_LEN
 362     addr.sin_len = sizeof (addr);
 363 # endif
 364     addr.sin_port = port;
 365     addr.sin_addr.s_addr = ip;
 366
 367     return makeaddrinfo (AF_INET, type, proto,
 368                          (struct sockaddr*)&addr, sizeof (addr), name);
 369 }
 370
 371
 372 /*
 373  * getaddrinfo() non-thread-safe IPv4-only implementation
 374  * Address-family-independant hostname to address resolution.
 375  *
 376  * This is meant for IPv6-unaware systems that do probably not provide
 377  * getaddrinfo(), but still have old function gethostbyname().
 378  *
 379  * Only UDP and TCP over IPv4 are supported here.
 380  */
 381 static int
 382 __getaddrinfo (const char *node, const char *service,
 383                const struct addrinfo *hints, struct addrinfo **res)
 384 {
 385     struct addrinfo *info;
 386     u_long ip;
 387     u_short port;
 388     int protocol = 0, flags = 0;
 389     const char *name = NULL;
 390
 391 #ifdef WIN32
 392     /*
 393      * Maybe you knew already that Winsock does not handle TCP/RST packets
 394      * properly, so that when a TCP connection fails, it will wait until it
 395      * times out even if the remote host did return a TCP/RST. However, it
 396      * still sees the TCP/RST as the error code is 10061 instead of 10060.
 397      * Basically, we have the stupid brainfucked behavior with DNS queries...
 398      * When the recursive DNS server returns an error, Winsock waits about
 399      * 2 seconds before it returns to the callers, even though it should know
 400      * that is pointless. I'd like to know how come this hasn't been fixed
 401      * for the past decade, or maybe not.
 402      *
 403      * Anyway, this is causing a severe delay when the SAP listener tries
 404      * to resolve more than ten IPv6 numeric addresses. Modern systems will
 405      * eventually realize that it is an IPv6 address, and won't try to resolve
 406      * it as a IPv4 address via the Domain Name Service. Old systems
 407      * (including Windows XP without the IPv6 stack) will not. It is normally
 408      * not an issue as the DNS server usually returns an error very quickly.
 409      * But it IS a severe issue on Windows, given the bug explained above.
 410      * So here comes one more bug-to-bug Windows compatibility fix.
 411      */
 412     if ((node != NULL) && (strchr (node, ':') != NULL))
 413        return EAI_NONAME;
 414 #endif
 415
 416     if (hints != NULL)
 417     {
 418         flags = hints->ai_flags;
 419
 420         if (flags & ~_AI_MASK)
 421             return EAI_BADFLAGS;
 422         /* only accept AF_INET and AF_UNSPEC */
 423         if (hints->ai_family && (hints->ai_family != AF_INET))
 424             return EAI_FAMILY;
 425
 426         /* protocol sanity check */
 427         switch (hints->ai_socktype)
 428         {
 429             case SOCK_STREAM:
 430                 protocol = IPPROTO_TCP;
 431                 break;
 432
 433             case SOCK_DGRAM:
 434                 protocol = IPPROTO_UDP;
 435                 break;
 436
 437 #ifndef SOCK_RAW
 438             case SOCK_RAW:
 439 #endif
 440             case 0:
 441                 break;
 442
 443             default:
 444                 return EAI_SOCKTYPE;
 445         }
 446         if (hints->ai_protocol && protocol
 447          && (protocol != hints->ai_protocol))
 448             return EAI_SERVICE;
 449     }
 450
 451     *res = NULL;
 452
 453     /* default values */
 454     if (node == NULL)
 455     {
 456         if (flags & AI_PASSIVE)
 457             ip = htonl (INADDR_ANY);
 458         else
 459             ip = htonl (INADDR_LOOPBACK);
 460     }
 461     else
 462     if ((ip = inet_addr (node)) == INADDR_NONE)
 463     {
 464         struct hostent *entry = NULL;
 465
 466         /* hostname resolution */
 467         if (!(flags & AI_NUMERICHOST))
 468             entry = gethostbyname (node);
 469
 470         if (entry == NULL)
 471             return EAI_NONAME;
 472
 473         if ((entry->h_length != 4) || (entry->h_addrtype != AF_INET))
 474             return EAI_FAMILY;
 475
 476         ip = *((u_long *) entry->h_addr);
 477         if (flags & AI_CANONNAME)
 478             name = entry->h_name;
 479     }
 480
 481     if ((flags & AI_CANONNAME) && (name == NULL))
 482         name = node;
 483
 484     /* service resolution */
 485     if (service == NULL)
 486         port = 0;
 487     else
 488     {
 489         long d;
 490         char *end;
 491
 492         d = strtoul (service, &end, 0);
 493         if (end[0] /* service is not a number */
 494          || (d > 65535))
 495         {
 496             struct servent *entry;
 497             const char *protoname;
 498
 499             switch (protocol)
 500             {
 501                 case IPPROTO_TCP:
 502                     protoname = "tcp";
 503                     break;
 504
 505                 case IPPROTO_UDP:
 506                     protoname = "udp";
 507                     break;
 508
 509                 default:
 510                     protoname = NULL;
 511             }
 512
 513             entry = getservbyname (service, protoname);
 514             if (entry == NULL)
 515                 return EAI_SERVICE;
 516
 517             port = entry->s_port;
 518         }
 519         else
 520             port = htons ((u_short)d);
 521     }
 522
 523     /* building results... */
 524     if ((!protocol) || (protocol == IPPROTO_UDP))
 525     {
 526         info = makeipv4info (SOCK_DGRAM, IPPROTO_UDP, ip, port, name);
 527         if (info == NULL)
 528         {
 529             errno = ENOMEM;
 530             return EAI_SYSTEM;
 531         }
 532         if (flags & AI_PASSIVE)
 533             info->ai_flags |= AI_PASSIVE;
 534         *res = info;
 535     }
 536     if ((!protocol) || (protocol == IPPROTO_TCP))
 537     {
 538         info = makeipv4info (SOCK_STREAM, IPPROTO_TCP, ip, port, name);
 539         if (info == NULL)
 540         {
 541             errno = ENOMEM;
 542             return EAI_SYSTEM;
 543         }
 544         info->ai_next = *res;
 545         if (flags & AI_PASSIVE)
 546             info->ai_flags |= AI_PASSIVE;
 547         *res = info;
 548     }
 549
 550     return 0;
 551 }
 552 #endif /* if !HAVE_GETADDRINFO */
 553
 554
 555 int vlc_getnameinfo( const struct sockaddr *sa, int salen,
 556                      char *host, int hostlen, int *portnum, int flags )
 557 {
 558     char psz_servbuf[6], *psz_serv;
 559     int i_servlen, i_val;
 560
 561     flags |= NI_NUMERICSERV;
 562     if( portnum != NULL )
 563     {
 564         psz_serv = psz_servbuf;
 565         i_servlen = sizeof( psz_servbuf );
 566     }
 567     else
 568     {
 569         psz_serv = NULL;
 570         i_servlen = 0;
 571     }
 572 #if defined( WIN32 ) && !defined( UNDER_CE )
 573     i_val = ws2_getnameinfo( sa, salen, host, hostlen, psz_serv,
 574                                  i_servlen, flags );
 575 #endif
 576 #if defined( HAVE_GETNAMEINFO ) || defined( UNDER_CE )
 577     i_val = getnameinfo(sa, salen, host, hostlen, psz_serv, i_servlen, flags);
 578 #else
 579     {
 580 # ifdef HAVE_USABLE_MUTEX_THAT_DONT_NEED_LIBVLC_POINTER
 581         static vlc_value_t lock;
 582
 583         /* my getnameinfo implementation is not thread-safe as it uses
 584          * gethostbyaddr and the likes */
 585         vlc_mutex_lock( lock.p_address );
 586 #else
 587 # warning FIXME : This is not thread-safe!
 588 #endif
 589         i_val = __getnameinfo( sa, salen, host, hostlen, psz_serv, i_servlen,
 590                                flags );
 591 # ifdef HAVE_USABLE_MUTEX_THAT_DONT_NEED_LIBVLC_POINTER
 592         vlc_mutex_unlock( lock.p_address );
 593 # endif
 594     }
 595 #endif
 596
 597     if( portnum != NULL )
 598         *portnum = atoi( psz_serv );
 599
 600     return i_val;
 601 }
 602
 603
 604 /* TODO: support for setting sin6_scope_id */
 605 int vlc_getaddrinfo( vlc_object_t *p_this, const char *node,
 606                      int i_port, const struct addrinfo *p_hints,
 607                      struct addrinfo **res )
 608 {
 609     struct addrinfo hints;
 610     char psz_buf[NI_MAXHOST], *psz_node, psz_service[6];
 611
 612     /*
 613      * In VLC, we always use port number as integer rather than strings
 614      * for historical reasons (and portability).
 615      */
 616     if( ( i_port > 65535 ) || ( i_port < 0 ) )
 617     {
 618         msg_Err( p_this, "invalid port number %d specified", i_port );
 619         return EAI_SERVICE;
 620     }
 621
 622     /* cannot overflow */
 623     snprintf( psz_service, 6, "%d", i_port );
 624
 625     /* Check if we have to force ipv4 or ipv6 */
 626     if( p_hints == NULL )
 627         memset( &hints, 0, sizeof( hints ) );
 628     else
 629         memcpy( &hints, p_hints, sizeof( hints ) );
 630
 631     if( hints.ai_family == AF_UNSPEC )
 632     {
 633         vlc_value_t val;
 634
 635         var_Create( p_this, "ipv4", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 636         var_Get( p_this, "ipv4", &val );
 637         if( val.b_bool )
 638             hints.ai_family = AF_INET;
 639
 640 #ifdef AF_INET6
 641         var_Create( p_this, "ipv6", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
 642         var_Get( p_this, "ipv6", &val );
 643         if( val.b_bool )
 644             hints.ai_family = AF_INET6;
 645 #endif
 646     }
 647
 648     /*
 649      * VLC extensions :
 650      * - accept "" as NULL
 651      * - ignore square brackets
 652      */
 653     if( ( node == NULL ) || (node[0] == '\0' ) )
 654     {
 655         psz_node = NULL;
 656     }
 657     else
 658     {
 659         strlcpy( psz_buf, node, NI_MAXHOST );
 660
 661         psz_node = psz_buf;
 662
 663         if( psz_buf[0] == '[' )
 664         {
 665             char *ptr;
 666
 667             ptr = strrchr( psz_buf, ']' );
 668             if( ( ptr != NULL ) && (ptr[1] == '\0' ) )
 669             {
 670                 *ptr = '\0';
 671                 psz_node++;
 672             }
 673         }
 674     }
 675
 676 #if defined( WIN32 ) && !defined( UNDER_CE )
 677     /*
 678      * Winsock tries to resolve numerical IPv4 addresses as AAAA
 679      * and IPv6 addresses as A... There comes the work around.
 680      */
 681     if ((hints.ai_flags & AI_NUMERICHOST) == 0)
 682     {
 683         hints.ai_flags |= AI_NUMERICHOST;
 684
 685         if (ws2_getaddrinfo (psz_node, psz_service, &hints, res) == 0)
 686             return 0;
 687
 688         hints.ai_flags &= ~AI_NUMERICHOST;
 689     }
 690
 691     return ws2_getaddrinfo (psz_node, psz_service, &hints, res);
 692 #endif
 693 #if defined( HAVE_GETADDRINFO ) || defined( UNDER_CE )
 694 # ifdef AI_IDN
 695     /* Run-time I18n Domain Names support */
 696     {
 697         static vlc_bool_t i_idn = VLC_TRUE; /* beware of thread-safety */
 698
 699         if( i_idn )
 700         {
 701             int i_ret;
 702
 703             hints.ai_flags |= AI_IDN;
 704             i_ret = getaddrinfo( psz_node, psz_service, &hints, res );
 705
 706             if( i_ret != EAI_BADFLAGS )
 707                 return i_ret;
 708
 709             /* libidn not available: disable and retry without it */
 710
 711             /* NOTE: Using i_idn here would not be thread-safe */
 712             hints.ai_flags &= ~AI_IDN;
 713             i_idn = VLC_FALSE;
 714             msg_Dbg( p_this, "International Domain Names not supported - " \
 715                 "disabled" );
 716         }
 717     }
 718 # endif
 719     return getaddrinfo( psz_node, psz_service, &hints, res );
 720 #else
 721 {
 722     int i_ret;
 723
 724     vlc_value_t lock;
 725
 726     var_Create( p_this->p_libvlc, "getaddrinfo_mutex", VLC_VAR_MUTEX );
 727     var_Get( p_this->p_libvlc, "getaddrinfo_mutex", &lock );
 728     vlc_mutex_lock( lock.p_address );
 729
 730     i_ret = __getaddrinfo( psz_node, psz_service, &hints, res );
 731     vlc_mutex_unlock( lock.p_address );
 732     return i_ret;
 733 }
 734 #endif
 735 }
 736
 737
 738 void vlc_freeaddrinfo( struct addrinfo *infos )
 739 {
 740 #if defined( WIN32 ) && !defined( UNDER_CE )
 741     ws2_freeaddrinfo( infos );
 742 #endif
 743 #if defined( HAVE_GETADDRINFO ) || defined( UNDER_CE )
 744     freeaddrinfo( infos );
 745 #else
 746     __freeaddrinfo( infos );
 747 #endif
 748 }