Fix missing declaration (supposedly crash on amd64)
[vlc.git] / src / network / io.c
1 /*****************************************************************************
2  * io.c: network I/O functions
3  *****************************************************************************
4  * Copyright (C) 2004-2005, 2007 the VideoLAN team
5  * Copyright © 2005-2006 Rémi Denis-Courmont
6  * $Id$
7  *
8  * Authors: Laurent Aimar <fenrir@videolan.org>
9  *          Rémi Denis-Courmont <rem # videolan.org>
10  *          Christophe Mutricy <xtophe at videolan dot org>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 # include "config.h"
33 #endif
34
35 #include <vlc_common.h>
36
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <limits.h>
40
41 #include <errno.h>
42 #include <assert.h>
43
44 #ifdef HAVE_FCNTL_H
45 #   include <fcntl.h>
46 #endif
47 #ifdef HAVE_SYS_TIME_H
48 #    include <sys/time.h>
49 #endif
50 #ifdef HAVE_UNISTD_H
51 #   include <unistd.h>
52 #endif
53 #ifdef HAVE_POLL
54 #   include <poll.h>
55 #endif
56
57 #include <vlc_network.h>
58
59 #ifndef INADDR_ANY
60 #   define INADDR_ANY  0x00000000
61 #endif
62 #ifndef INADDR_NONE
63 #   define INADDR_NONE 0xFFFFFFFF
64 #endif
65
66 #if defined(WIN32) || defined(UNDER_CE)
67 # undef EAFNOSUPPORT
68 # define EAFNOSUPPORT WSAEAFNOSUPPORT
69 #endif
70
71 #ifdef HAVE_LINUX_DCCP_H
72 /* TODO: use glibc instead of linux-kernel headers */
73 # include <linux/dccp.h>
74 # define SOL_DCCP 269
75 #endif
76
77 #include "libvlc.h" /* vlc_object_waitpipe */
78
79 extern int rootwrap_bind (int family, int socktype, int protocol,
80                           const struct sockaddr *addr, size_t alen);
81
82 int net_SetupSocket (int fd)
83 {
84 #if defined (WIN32) || defined (UNDER_CE)
85     ioctlsocket (fd, FIONBIO, &(unsigned long){ 1 });
86 #else
87     fcntl (fd, F_SETFD, FD_CLOEXEC);
88     fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK);
89 #endif
90
91     setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof (int));
92     return 0;
93 }
94
95
96 int net_Socket (vlc_object_t *p_this, int family, int socktype,
97                 int protocol)
98 {
99     int fd = socket (family, socktype, protocol);
100     if (fd == -1)
101     {
102         if (net_errno != EAFNOSUPPORT)
103             msg_Err (p_this, "cannot create socket: %m");
104         return -1;
105     }
106
107     net_SetupSocket (fd);
108
109 #ifdef IPV6_V6ONLY
110     /*
111      * Accepts only IPv6 connections on IPv6 sockets.
112      * If possible, we should open two sockets, but it is not always possible.
113      */
114     if (family == AF_INET6)
115         setsockopt (fd, IPPROTO_IPV6, IPV6_V6ONLY, &(int){ 1 }, sizeof (int));
116 #endif
117
118 #if defined (WIN32) || defined (UNDER_CE)
119 # ifndef IPV6_PROTECTION_LEVEL
120 #  warning Please update your C library headers.
121 #  define IPV6_PROTECTION_LEVEL 23
122 #  define PROTECTION_LEVEL_UNRESTRICTED 10
123 # endif
124     if (family == AF_INET6)
125         setsockopt (fd, IPPROTO_IPV6, IPV6_PROTECTION_LEVEL,
126                     &(int){ PROTECTION_LEVEL_UNRESTRICTED }, sizeof (int));
127 #endif
128
129 #ifdef DCCP_SOCKOPT_SERVICE
130     if (socktype == SOL_DCCP)
131     {
132         char *dccps = var_CreateGetNonEmptyString (p_this, "dccp-service");
133         if (dccps != NULL)
134         {
135             setsockopt (fd, SOL_DCCP, DCCP_SOCKOPT_SERVICE, dccps,
136                         (strlen (dccps) + 3) & ~3);
137             free (dccps);
138         }
139     }
140 #endif
141
142     return fd;
143 }
144
145
146 int *net_Listen (vlc_object_t *p_this, const char *psz_host,
147                  int i_port, int protocol)
148 {
149     struct addrinfo hints, *res;
150     int socktype = SOCK_DGRAM;
151
152     switch( protocol )
153     {
154         case IPPROTO_TCP:
155             socktype = SOCK_STREAM;
156             break;
157         case 33: /* DCCP */
158 #ifdef __linux__
159 # ifndef SOCK_DCCP
160 #  define SOCK_DCCP 6
161 # endif
162             socktype = SOCK_DCCP;
163 #endif
164             break;
165     }
166
167     memset (&hints, 0, sizeof( hints ));
168     /* Since we use port numbers rather than service names, the socket type
169      * does not really matter. */
170     hints.ai_socktype = SOCK_DGRAM;
171     hints.ai_flags = AI_PASSIVE;
172
173     msg_Dbg (p_this, "net: listening to %s port %d", psz_host, i_port);
174
175     int i_val = vlc_getaddrinfo (p_this, psz_host, i_port, &hints, &res);
176     if (i_val)
177     {
178         msg_Err (p_this, "Cannot resolve %s port %d : %s", psz_host, i_port,
179                  vlc_gai_strerror (i_val));
180         return NULL;
181     }
182
183     int *sockv = NULL;
184     unsigned sockc = 0;
185
186     for (struct addrinfo *ptr = res; ptr != NULL; ptr = ptr->ai_next)
187     {
188         int fd = net_Socket (p_this, ptr->ai_family, socktype, protocol);
189         if (fd == -1)
190         {
191             msg_Dbg (p_this, "socket error: %m");
192             continue;
193         }
194
195         /* Bind the socket */
196 #if defined (WIN32) || defined (UNDER_CE)
197         /*
198          * Under Win32 and for multicasting, we bind to INADDR_ANY.
199          * This is of course a severe bug, since the socket would logically
200          * receive unicast traffic, and multicast traffic of groups subscribed
201          * to via other sockets.
202          */
203         if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen)
204          && (sizeof (struct sockaddr_storage) >= ptr->ai_addrlen))
205         {
206             // This works for IPv4 too - don't worry!
207             struct sockaddr_in6 dumb =
208             {
209                 .sin6_family = ptr->ai_addr->sa_family,
210                 .sin6_port =  ((struct sockaddr_in *)(ptr->ai_addr))->sin_port
211             };
212
213             bind (fd, (struct sockaddr *)&dumb, ptr->ai_addrlen);
214         }
215         else
216 #endif
217         if (bind (fd, ptr->ai_addr, ptr->ai_addrlen))
218         {
219             net_Close (fd);
220 #if !defined(WIN32) && !defined(UNDER_CE)
221             fd = rootwrap_bind (ptr->ai_family, socktype,
222                                 protocol ?: ptr->ai_protocol, ptr->ai_addr,
223                                 ptr->ai_addrlen);
224             if (fd != -1)
225             {
226                 msg_Dbg (p_this, "got socket %d from rootwrap", fd);
227             }
228             else
229 #endif
230             {
231                 msg_Err (p_this, "socket bind error (%m)");
232                 continue;
233             }
234         }
235
236         if (net_SockAddrIsMulticast (ptr->ai_addr, ptr->ai_addrlen))
237         {
238             if (net_Subscribe (p_this, fd, ptr->ai_addr, ptr->ai_addrlen))
239             {
240                 net_Close (fd);
241                 continue;
242             }
243         }
244
245         /* Listen */
246         switch (socktype)
247         {
248             case SOCK_STREAM:
249             case SOCK_RDM:
250             case SOCK_SEQPACKET:
251 #ifdef SOCK_DCCP
252             case SOCK_DCCP:
253 #endif
254                 if (listen (fd, INT_MAX))
255                 {
256                     msg_Err (p_this, "socket listen error (%m)");
257                     net_Close (fd);
258                     continue;
259                 }
260         }
261
262         int *nsockv = (int *)realloc (sockv, (sockc + 2) * sizeof (int));
263         if (nsockv != NULL)
264         {
265             nsockv[sockc++] = fd;
266             sockv = nsockv;
267         }
268         else
269             net_Close (fd);
270     }
271
272     vlc_freeaddrinfo (res);
273
274     if (sockv != NULL)
275         sockv[sockc] = -1;
276
277     return sockv;
278 }
279
280
281 /*****************************************************************************
282  * __net_Read:
283  *****************************************************************************
284  * Reads from a network socket.
285  * If waitall is true, then we repeat until we have read the right amount of
286  * data; in that case, a short count means EOF has been reached or the VLC
287  * object has been signaled.
288  *****************************************************************************/
289 ssize_t
290 __net_Read (vlc_object_t *restrict p_this, int fd, const v_socket_t *vs,
291             uint8_t *restrict p_buf, size_t i_buflen, bool waitall)
292 {
293     size_t i_total = 0;
294     struct pollfd ufd[2] = {
295         { .fd = fd,                           .events = POLLIN },
296         { .fd = vlc_object_waitpipe (p_this), .events = POLLIN },
297     };
298
299     if (ufd[1].fd == -1)
300         return -1; /* vlc_object_waitpipe() sets errno */
301
302     while (i_buflen > 0)
303     {
304         ufd[0].revents = ufd[1].revents = 0;
305
306         if (poll (ufd, sizeof (ufd) / sizeof (ufd[0]), -1) < 0)
307         {
308             if (errno != EINTR)
309                 goto error;
310             continue;
311         }
312
313 #ifndef POLLRDHUP /* This is nice but non-portable */
314 # define POLLRDHUP 0
315 #endif
316         if (i_total > 0)
317         {
318             /* Errors (-1) and EOF (0) will be returned on next call,
319              * otherwise we'd "hide" the error from the caller, which is a
320              * bad idea™. */
321             if (ufd[0].revents & (POLLERR|POLLNVAL|POLLRDHUP))
322                 break;
323             if (ufd[1].revents)
324                 break;
325         }
326         else
327         {
328             if (ufd[1].revents)
329             {
330                 assert (p_this->b_die);
331                 msg_Dbg (p_this, "socket %d polling interrupted", fd);
332 #if defined(WIN32) || defined(UNDER_CE)
333                 WSASetLastError (WSAEINTR);
334 #else
335                 errno = EINTR;
336 #endif
337                 goto silent;
338             }
339         }
340
341         assert (ufd[0].revents);
342
343         ssize_t n;
344         if (vs != NULL)
345         {
346             n = vs->pf_recv (vs->p_sys, p_buf, i_buflen);
347         }
348         else
349         {
350 #ifdef WIN32
351             n = recv (fd, p_buf, i_buflen, 0);
352 #else
353             n = read (fd, p_buf, i_buflen);
354 #endif
355         }
356
357         if (n == -1)
358         {
359 #if defined(WIN32) || defined(UNDER_CE)
360             switch (WSAGetLastError ())
361             {
362                 case WSAEWOULDBLOCK:
363                 /* only happens with vs != NULL (TLS) - not really an error */
364                     continue;
365
366                 case WSAEMSGSIZE:
367                 /* For UDP only */
368                 /* On Win32, recv() fails if the datagram doesn't fit inside
369                  * the passed buffer, even though the buffer will be filled
370                  * with the first part of the datagram. */
371                     msg_Err (p_this, "Receive error: "
372                                      "Increase the mtu size (--mtu option)");
373                     n = i_buflen;
374                     break;
375             }
376 #else
377             switch (errno)
378             {
379                 case EAGAIN: /* spurious wakeup or no TLS data */
380                 case EINTR:  /* asynchronous signal */
381                     continue;
382             }
383 #endif
384             goto error;
385         }
386
387         if (n == 0)
388             /* For streams, this means end of file, and there will not be any
389              * further data ever on the stream. For datagram sockets, this
390              * means empty datagram, and there could be more data coming.
391              * However, it makes no sense to set <waitall> with datagrams in the
392              * first place.
393              */
394             break; // EOF
395
396         i_total += n;
397         p_buf += n;
398         i_buflen -= n;
399
400         if (!waitall)
401             break;
402     }
403
404     return i_total;
405
406 error:
407     msg_Err (p_this, "Read error: %m");
408 silent:
409     return -1;
410 }
411
412
413 /* Write exact amount requested */
414 ssize_t __net_Write( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
415                      const uint8_t *p_data, size_t i_data )
416 {
417     size_t i_total = 0;
418     struct pollfd ufd[2] = {
419         { .fd = fd,                           .events = POLLOUT },
420         { .fd = vlc_object_waitpipe (p_this), .events = POLLIN  },
421     };
422
423     if (ufd[1].fd == -1)
424         return -1;
425
426     while( i_data > 0 )
427     {
428         ssize_t val;
429
430         ufd[0].revents = ufd[1].revents = 0;
431
432         if (poll (ufd, 1, -1) == -1)
433         {
434             if (errno == EINTR)
435                 continue;
436             msg_Err (p_this, "Polling error: %m");
437             return -1;
438         }
439
440         if (i_total > 0)
441         {   /* If POLLHUP resp. POLLERR|POLLNVAL occurs while we have already
442              * read some data, it is important that we first return the number
443              * of bytes read, and then return 0 resp. -1 on the NEXT call. */
444             if (ufd[0].revents & (POLLHUP|POLLERR|POLLNVAL))
445                 break;
446             if (ufd[1].revents) /* VLC object signaled */
447                 break;
448         }
449         else
450         {
451             if (ufd[1].revents)
452             {
453                 assert (p_this->b_die);
454                 errno = EINTR;
455                 goto error;
456             }
457         }
458
459         if (p_vs != NULL)
460             val = p_vs->pf_send (p_vs->p_sys, p_data, i_data);
461         else
462 #ifdef WIN32
463             val = send (fd, p_data, i_data, 0);
464 #else
465             val = write (fd, p_data, i_data);
466 #endif
467
468         if (val == -1)
469         {
470             if (errno == EINTR)
471                 continue;
472             msg_Err (p_this, "Write error: %m");
473             break;
474         }
475
476         p_data += val;
477         i_data -= val;
478         i_total += val;
479     }
480
481     if ((i_total > 0) || (i_data == 0))
482         return i_total;
483
484 error:
485     return -1;
486 }
487
488 char *__net_Gets( vlc_object_t *p_this, int fd, const v_socket_t *p_vs )
489 {
490     char *psz_line = NULL, *ptr = NULL;
491     size_t  i_line = 0, i_max = 0;
492
493
494     for( ;; )
495     {
496         if( i_line == i_max )
497         {
498             i_max += 1024;
499             psz_line = realloc( psz_line, i_max );
500             ptr = psz_line + i_line;
501         }
502
503         if( net_Read( p_this, fd, p_vs, (uint8_t *)ptr, 1, true ) != 1 )
504         {
505             if( i_line == 0 )
506             {
507                 free( psz_line );
508                 return NULL;
509             }
510             break;
511         }
512
513         if ( *ptr == '\n' )
514             break;
515
516         i_line++;
517         ptr++;
518     }
519
520     *ptr-- = '\0';
521
522     if( ( ptr >= psz_line ) && ( *ptr == '\r' ) )
523         *ptr = '\0';
524
525     return psz_line;
526 }
527
528 ssize_t net_Printf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
529                     const char *psz_fmt, ... )
530 {
531     int i_ret;
532     va_list args;
533     va_start( args, psz_fmt );
534     i_ret = net_vaPrintf( p_this, fd, p_vs, psz_fmt, args );
535     va_end( args );
536
537     return i_ret;
538 }
539
540 ssize_t __net_vaPrintf( vlc_object_t *p_this, int fd, const v_socket_t *p_vs,
541                         const char *psz_fmt, va_list args )
542 {
543     char    *psz;
544     int      i_ret;
545
546     int i_size = vasprintf( &psz, psz_fmt, args );
547     if( i_size == -1 )
548         return -1;
549     i_ret = __net_Write( p_this, fd, p_vs, (uint8_t *)psz, i_size ) < i_size
550         ? -1 : i_size;
551     free( psz );
552
553     return i_ret;
554 }
555
556 #ifdef WIN32
557     /* vlc_sendmsg, vlc_recvmsg Defined in winsock.c */
558 #else /* !WIN32 */
559 ssize_t vlc_sendmsg (int s, struct msghdr *hdr, int flags)
560 {
561     return sendmsg (s, hdr, flags);
562 }
563
564 ssize_t vlc_recvmsg (int s, struct msghdr *hdr, int flags)
565 {
566     return recvmsg (s, hdr, flags);
567 }
568 #endif /* WIN32 */
569