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