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