* 2nd review of /src/* \ libvlc.h (refs #438)
[vlc.git] / src / network / tcp.c
1 /*****************************************************************************
2  * tcp.c:
3  *****************************************************************************
4  * Copyright (C) 2004-2005 the VideoLAN team
5  * Copyright (C) 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  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 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 General Public License for more details.
20  *
21  * You should have received a copy of the GNU 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 /*****************************************************************************
27  * Preamble
28  *****************************************************************************/
29 #include <stdlib.h>
30 #include <vlc/vlc.h>
31
32 #include <errno.h>
33
34 #ifdef HAVE_FCNTL_H
35 #   include <fcntl.h>
36 #endif
37 #ifdef HAVE_SYS_TIME_H
38 #    include <sys/time.h>
39 #endif
40 #ifdef HAVE_UNISTD_H
41 #   include <unistd.h>
42 #endif
43
44 #include "network.h"
45 #if defined (WIN32) || defined (UNDER_CE)
46 #   undef EINPROGRESS
47 #   define EINPROGRESS WSAEWOULDBLOCK
48 #   undef EINTR
49 #   define EINTR WSAEINTR
50 #   undef ETIMEDOUT
51 #   define ETIMEDOUT WSAETIMEDOUT
52 #endif
53
54 static int SocksNegociate( vlc_object_t *, int fd, int i_socks_version,
55                            char *psz_socks_user, char *psz_socks_passwd );
56 static int SocksHandshakeTCP( vlc_object_t *,
57                               int fd, int i_socks_version,
58                               char *psz_socks_user, char *psz_socks_passwd,
59                               const char *psz_host, int i_port );
60 extern int net_Socket( vlc_object_t *p_this, int i_family, int i_socktype,
61                        int i_protocol );
62 extern int rootwrap_bind (int family, int socktype, int protocol,
63                           const struct sockaddr *addr, size_t alen);
64
65 /*****************************************************************************
66  * __net_ConnectTCP:
67  *****************************************************************************
68  * Open a TCP connection and return a handle
69  *****************************************************************************/
70 int __net_ConnectTCP( vlc_object_t *p_this, const char *psz_host, int i_port )
71 {
72     struct addrinfo hints, *res, *ptr;
73     const char      *psz_realhost;
74     char            *psz_socks;
75     int             i_realport, i_val, i_handle = -1, i_saved_errno = 0;
76     unsigned        u_errstep = 0;
77
78     if( i_port == 0 )
79         i_port = 80; /* historical VLC thing */
80
81     memset( &hints, 0, sizeof( hints ) );
82     hints.ai_socktype = SOCK_STREAM;
83
84     psz_socks = var_CreateGetString( p_this, "socks" );
85     if( *psz_socks && *psz_socks != ':' )
86     {
87         char *psz = strchr( psz_socks, ':' );
88
89         if( psz )
90             *psz++ = '\0';
91
92         psz_realhost = psz_socks;
93         i_realport = ( psz != NULL ) ? atoi( psz ) : 1080;
94
95         msg_Dbg( p_this, "net: connecting to %s port %d for %s port %d",
96                  psz_realhost, i_realport, psz_host, i_port );
97     }
98     else
99     {
100         psz_realhost = psz_host;
101         i_realport = i_port;
102
103         msg_Dbg( p_this, "net: connecting to %s port %d", psz_realhost,
104                  i_realport );
105     }
106
107     i_val = vlc_getaddrinfo( p_this, psz_realhost, i_realport, &hints, &res );
108     if( i_val )
109     {
110         msg_Err( p_this, "cannot resolve %s port %d : %s", psz_realhost,
111                  i_realport, vlc_gai_strerror( i_val ) );
112         free( psz_socks );
113         return -1;
114     }
115
116     for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
117     {
118         int fd = net_Socket( p_this, ptr->ai_family, ptr->ai_socktype,
119                              ptr->ai_protocol );
120         if( fd == -1 )
121         {
122             if( u_errstep <= 0 )
123             {
124                 u_errstep = 1;
125                 i_saved_errno = net_errno;
126             }
127             msg_Dbg( p_this, "socket error: %s", strerror( net_errno ) );
128             continue;
129         }
130
131         if( connect( fd, ptr->ai_addr, ptr->ai_addrlen ) )
132         {
133             socklen_t i_val_size = sizeof( i_val );
134             div_t d;
135             struct timeval tv;
136             vlc_value_t timeout;
137
138             if( net_errno != EINPROGRESS )
139             {
140                 if( u_errstep <= 1 )
141                 {
142                     u_errstep = 2;
143                     i_saved_errno = net_errno;
144                 }
145                 msg_Dbg( p_this, "connect error: %s", strerror( net_errno ) );
146                 goto next_ai;
147             }
148
149             var_Create( p_this, "ipv4-timeout",
150                         VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
151             var_Get( p_this, "ipv4-timeout", &timeout );
152             if( timeout.i_int < 0 )
153             {
154                 msg_Err( p_this, "invalid negative value for ipv4-timeout" );
155                 timeout.i_int = 0;
156             }
157             d = div( timeout.i_int, 100 );
158
159             msg_Dbg( p_this, "connection in progress" );
160             for (;;)
161             {
162                 fd_set fds;
163                 int i_ret;
164
165                 if( p_this->b_die )
166                 {
167                     msg_Dbg( p_this, "connection aborted" );
168                     net_Close( fd );
169                     vlc_freeaddrinfo( res );
170                     free( psz_socks );
171                     return -1;
172                 }
173
174                 /* Initialize file descriptor set */
175                 FD_ZERO( &fds );
176                 FD_SET( fd, &fds );
177
178                 /*
179                  * We'll wait 0.1 second if nothing happens
180                  * NOTE:
181                  * time out will be shortened if we catch a signal (EINTR)
182                  */
183                 tv.tv_sec = 0;
184                 tv.tv_usec = (d.quot > 0) ? 100000 : (1000 * d.rem);
185
186                 i_ret = select( fd + 1, NULL, &fds, NULL, &tv );
187                 if( i_ret == 1 )
188                     break;
189
190                 if( ( i_ret == -1 ) && ( net_errno != EINTR ) )
191                 {
192                     msg_Warn( p_this, "select error: %s",
193                               strerror( net_errno ) );
194                     goto next_ai;
195                 }
196
197                 if( d.quot <= 0 )
198                 {
199                     msg_Dbg( p_this, "select timed out" );
200                     if( u_errstep <= 2 )
201                     {
202                         u_errstep = 3;
203                         i_saved_errno = ETIMEDOUT;
204                     }
205                     goto next_ai;
206                 }
207
208                 d.quot--;
209             }
210
211 #if !defined( SYS_BEOS ) && !defined( UNDER_CE )
212             if( getsockopt( fd, SOL_SOCKET, SO_ERROR, (void*)&i_val,
213                             &i_val_size ) == -1 || i_val != 0 )
214             {
215                 u_errstep = 4;
216                 i_saved_errno = i_val;
217                 msg_Dbg( p_this, "connect error (via getsockopt): %s",
218                          net_strerror( i_val ) );
219                 goto next_ai;
220             }
221 #endif
222         }
223
224         i_handle = fd; /* success! */
225         break;
226
227 next_ai: /* failure */
228         net_Close( fd );
229         continue;
230     }
231
232     vlc_freeaddrinfo( res );
233
234     if( i_handle == -1 )
235     {
236         msg_Err( p_this, "Connection to %s port %d failed: %s", psz_host,
237                  i_port, net_strerror( i_saved_errno ) );
238         free( psz_socks );
239         return -1;
240     }
241
242     if( *psz_socks && *psz_socks != ':' )
243     {
244         char *psz_user = var_CreateGetString( p_this, "socks-user" );
245         char *psz_pwd  = var_CreateGetString( p_this, "socks-pwd" );
246
247         if( SocksHandshakeTCP( p_this, i_handle, 5, psz_user, psz_pwd,
248                                psz_host, i_port ) )
249         {
250             msg_Err( p_this, "Failed to use the SOCKS server" );
251             net_Close( i_handle );
252             i_handle = -1;
253         }
254
255         free( psz_user );
256         free( psz_pwd );
257     }
258     free( psz_socks );
259
260     return i_handle;
261 }
262
263
264 /*****************************************************************************
265  * __net_ListenTCP:
266  *****************************************************************************
267  * Open TCP passive "listening" socket(s)
268  * This function returns NULL in case of error.
269  *****************************************************************************/
270 int *__net_ListenTCP( vlc_object_t *p_this, const char *psz_host, int i_port )
271 {
272     struct addrinfo hints, *res, *ptr;
273     int             i_val, *pi_handles, i_size;
274
275     memset( &hints, 0, sizeof( hints ) );
276     hints.ai_socktype = SOCK_STREAM;
277     hints.ai_flags = AI_PASSIVE;
278
279     msg_Dbg( p_this, "net: listening to %s port %d", psz_host, i_port );
280
281     i_val = vlc_getaddrinfo( p_this, psz_host, i_port, &hints, &res );
282     if( i_val )
283     {
284         msg_Err( p_this, "Cannot resolve %s port %d : %s", psz_host, i_port,
285                  vlc_gai_strerror( i_val ) );
286         return NULL;
287     }
288
289     pi_handles = NULL;
290     i_size = 1;
291
292     for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
293     {
294         int fd, *newpi;
295
296         fd = net_Socket( p_this, ptr->ai_family, ptr->ai_socktype,
297                          ptr->ai_protocol );
298         if( fd == -1 )
299         {
300             msg_Dbg( p_this, "socket error: %s", net_strerror( net_errno ) );
301             continue;
302         }
303
304         /* Bind the socket */
305         if( bind( fd, ptr->ai_addr, ptr->ai_addrlen ) )
306         {
307             int saved_errno;
308
309             saved_errno = net_errno;
310             net_Close( fd );
311 #if !defined(WIN32) && !defined(UNDER_CE)
312             fd = rootwrap_bind( ptr->ai_family, ptr->ai_socktype,
313                                 ptr->ai_protocol, ptr->ai_addr,
314                                 ptr->ai_addrlen );
315             if( fd != -1 )
316             {
317                 msg_Dbg( p_this, "got socket %d from rootwrap", fd );
318             }
319             else
320 #endif
321             {
322                 msg_Err( p_this, "cannot bind socket (%s)",
323                          net_strerror( saved_errno ) );
324                 continue;
325             }
326         }
327
328         /* Listen */
329         if( listen( fd, 100 ) == -1 )
330         {
331             msg_Err( p_this, "cannot bring the socket in listening mode (%s)",
332                      net_strerror( net_errno ) );
333             net_Close( fd );
334             continue;
335         }
336
337         newpi = (int *)realloc( pi_handles, (++i_size) * sizeof( int ) );
338         if( newpi == NULL )
339         {
340             net_Close( fd );
341             break;
342         }
343         else
344         {
345             newpi[i_size - 2] = fd;
346             pi_handles = newpi;
347         }
348     }
349
350     vlc_freeaddrinfo( res );
351
352     if( pi_handles != NULL )
353         pi_handles[i_size - 1] = -1;
354     return pi_handles;
355 }
356
357 /*****************************************************************************
358  * __net_Accept:
359  *****************************************************************************
360  * Accept a connection on a set of listening sockets and return it
361  *****************************************************************************/
362 int __net_Accept( vlc_object_t *p_this, int *pi_fd, mtime_t i_wait )
363 {
364     vlc_bool_t b_die = p_this->b_die, b_block = (i_wait < 0);
365
366     while( p_this->b_die == b_die )
367     {
368         int i_val = -1, *pi, *pi_end;
369         struct timeval timeout;
370         fd_set fds_r, fds_e;
371
372         pi = pi_fd;
373
374         /* Initialize file descriptor set */
375         FD_ZERO( &fds_r );
376         FD_ZERO( &fds_e );
377
378         for( pi = pi_fd; *pi != -1; pi++ )
379         {
380             int i_fd = *pi;
381
382             if( i_fd > i_val )
383                 i_val = i_fd;
384
385             FD_SET( i_fd, &fds_r );
386             FD_SET( i_fd, &fds_e );
387         }
388         pi_end = pi;
389
390         timeout.tv_sec = 0;
391         timeout.tv_usec = b_block ? 500000 : i_wait;
392
393         i_val = select( i_val + 1, &fds_r, NULL, &fds_e, &timeout );
394         if( ( ( i_val < 0 ) && ( net_errno == EINTR ) ) || i_val == 0 )
395         {
396             if( b_block )
397                 continue;
398             else
399                 return -1;
400         }
401         else if( i_val < 0 )
402         {
403             msg_Err( p_this, "network select error (%s)",
404                      net_strerror( net_errno ) );
405             return -1;
406         }
407
408         for( pi = pi_fd; *pi != -1; pi++ )
409         {
410             int i_fd = *pi;
411
412             if( !FD_ISSET( i_fd, &fds_r ) && !FD_ISSET( i_fd, &fds_e ) )
413                 continue;
414
415             i_val = accept( i_fd, NULL, 0 );
416             if( i_val < 0 )
417                 msg_Err( p_this, "accept failed (%s)",
418                          net_strerror( net_errno ) );
419             else
420             {
421                 /*
422                  * This round-robin trick ensures that the first sockets in
423                  * pi_fd won't prevent the last ones from getting accept'ed.
424                  */
425                 --pi_end;
426                 memmove( pi, pi + 1, pi_end - pi );
427                 *pi_end = i_fd;
428                 return i_val;
429             }
430         }
431     }
432
433     return -1;
434 }
435
436
437 /*****************************************************************************
438  * SocksNegociate:
439  *****************************************************************************
440  * Negociate authentication with a SOCKS server.
441  *****************************************************************************/
442 static int SocksNegociate( vlc_object_t *p_obj,
443                            int fd, int i_socks_version,
444                            char *psz_socks_user,
445                            char *psz_socks_passwd )
446 {
447     uint8_t buffer[128+2*256];
448     int i_len;
449     vlc_bool_t b_auth = VLC_FALSE;
450
451     if( i_socks_version != 5 )
452         return VLC_SUCCESS;
453
454     /* We negociate authentication */
455
456     if( psz_socks_user && psz_socks_passwd &&
457         *psz_socks_user && *psz_socks_passwd )
458         b_auth = VLC_TRUE;
459
460     buffer[0] = i_socks_version;    /* SOCKS version */
461     if( b_auth )
462     {
463         buffer[1] = 2;                  /* Number of methods */
464         buffer[2] = 0x00;               /* - No auth required */
465         buffer[3] = 0x02;               /* - USer/Password */
466         i_len = 4;
467     }
468     else
469     {
470         buffer[1] = 1;                  /* Number of methods */
471         buffer[2] = 0x00;               /* - No auth required */
472         i_len = 3;
473     }
474
475     if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
476         return VLC_EGENERIC;
477     if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
478         return VLC_EGENERIC;
479
480     msg_Dbg( p_obj, "socks: v=%d method=%x", buffer[0], buffer[1] );
481
482     if( buffer[1] == 0x00 )
483     {
484         msg_Dbg( p_obj, "socks: no authentication required" );
485     }
486     else if( buffer[1] == 0x02 )
487     {
488         int i_len1 = __MIN( strlen(psz_socks_user), 255 );
489         int i_len2 = __MIN( strlen(psz_socks_passwd), 255 );
490         msg_Dbg( p_obj, "socks: username/password authentication" );
491
492         /* XXX: we don't support user/pwd > 255 (truncated)*/
493         buffer[0] = i_socks_version;        /* Version */
494         buffer[1] = i_len1;                 /* User length */
495         memcpy( &buffer[2], psz_socks_user, i_len1 );
496         buffer[2+i_len1] = i_len2;          /* Password length */
497         memcpy( &buffer[2+i_len1+1], psz_socks_passwd, i_len2 );
498
499         i_len = 3 + i_len1 + i_len2;
500
501         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
502             return VLC_EGENERIC;
503
504         if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
505             return VLC_EGENERIC;
506
507         msg_Dbg( p_obj, "socks: v=%d status=%x", buffer[0], buffer[1] );
508         if( buffer[1] != 0x00 )
509         {
510             msg_Err( p_obj, "socks: authentication rejected" );
511             return VLC_EGENERIC;
512         }
513     }
514     else
515     {
516         if( b_auth )
517             msg_Err( p_obj, "socks: unsupported authentication method %x",
518                      buffer[0] );
519         else
520             msg_Err( p_obj, "socks: authentification needed" );
521         return VLC_EGENERIC;
522     }
523
524     return VLC_SUCCESS;
525 }
526
527 /*****************************************************************************
528  * SocksHandshakeTCP:
529  *****************************************************************************
530  * Open a TCP connection using a SOCKS server and return a handle (RFC 1928)
531  *****************************************************************************/
532 static int SocksHandshakeTCP( vlc_object_t *p_obj,
533                               int fd,
534                               int i_socks_version,
535                               char *psz_socks_user, char *psz_socks_passwd,
536                               const char *psz_host, int i_port )
537 {
538     uint8_t buffer[128+2*256];
539
540     if( i_socks_version != 4 && i_socks_version != 5 )
541     {
542         msg_Warn( p_obj, "invalid socks protocol version %d", i_socks_version );
543         i_socks_version = 5;
544     }
545
546     if( i_socks_version == 5 && 
547         SocksNegociate( p_obj, fd, i_socks_version,
548                         psz_socks_user, psz_socks_passwd ) )
549         return VLC_EGENERIC;
550
551     if( i_socks_version == 4 )
552     {
553         struct addrinfo hints = { 0 }, *p_res;
554
555         /* v4 only support ipv4 */
556         hints.ai_family = AF_INET;
557         if( vlc_getaddrinfo( p_obj, psz_host, 0, &hints, &p_res ) )
558             return VLC_EGENERIC;
559
560         buffer[0] = i_socks_version;
561         buffer[1] = 0x01;               /* CONNECT */
562         SetWBE( &buffer[2], i_port );   /* Port */
563         memcpy( &buffer[4],             /* Address */
564                 &((struct sockaddr_in *)(p_res->ai_addr))->sin_addr, 4 );
565         vlc_freeaddrinfo( p_res );
566
567         buffer[8] = 0;                  /* Empty user id */
568
569         if( net_Write( p_obj, fd, NULL, buffer, 9 ) != 9 )
570             return VLC_EGENERIC;
571         if( net_Read( p_obj, fd, NULL, buffer, 8, VLC_TRUE ) != 8 )
572             return VLC_EGENERIC;
573
574         msg_Dbg( p_obj, "socks: v=%d cd=%d",
575                  buffer[0], buffer[1] );
576
577         if( buffer[1] != 90 )
578             return VLC_EGENERIC;
579     }
580     else if( i_socks_version == 5 )
581     {
582         int i_hlen = __MIN(strlen( psz_host ), 255);
583         int i_len;
584
585         buffer[0] = i_socks_version;    /* Version */
586         buffer[1] = 0x01;               /* Cmd: connect */
587         buffer[2] = 0x00;               /* Reserved */
588         buffer[3] = 3;                  /* ATYP: for now domainname */
589
590         buffer[4] = i_hlen;
591         memcpy( &buffer[5], psz_host, i_hlen );
592         SetWBE( &buffer[5+i_hlen], i_port );
593
594         i_len = 5 + i_hlen + 2;
595
596
597         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
598             return VLC_EGENERIC;
599
600         /* Read the header */
601         if( net_Read( p_obj, fd, NULL, buffer, 5, VLC_TRUE ) != 5 )
602             return VLC_EGENERIC;
603
604         msg_Dbg( p_obj, "socks: v=%d rep=%d atyp=%d",
605                  buffer[0], buffer[1], buffer[3] );
606
607         if( buffer[1] != 0x00 )
608         {
609             msg_Err( p_obj, "socks: CONNECT request failed\n" );
610             return VLC_EGENERIC;
611         }
612
613         /* Read the remaining bytes */
614         if( buffer[3] == 0x01 )
615             i_len = 4-1 + 2;
616         else if( buffer[3] == 0x03 )
617             i_len = buffer[4] + 2;
618         else if( buffer[3] == 0x04 )
619             i_len = 16-1+2;
620         else 
621             return VLC_EGENERIC;
622
623         if( net_Read( p_obj, fd, NULL, buffer, i_len, VLC_TRUE ) != i_len )
624             return VLC_EGENERIC;
625     }
626
627     return VLC_SUCCESS;
628 }
629
630 void net_ListenClose( int *pi_fd )
631 {
632     if( pi_fd != NULL )
633     {
634         int *pi;
635
636         for( pi = pi_fd; *pi != -1; pi++ )
637             net_Close( *pi );
638         free( pi_fd );
639     }
640 }