- Clean up error message generation with TCP outgoing connections
[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             continue;
300
301         /* Bind the socket */
302         if( bind( fd, ptr->ai_addr, ptr->ai_addrlen ) )
303         {
304             int saved_errno;
305
306             saved_errno = errno;
307             net_Close( fd );
308 #if !defined(WIN32) && !defined(UNDER_CE)
309             fd = rootwrap_bind( ptr->ai_family, ptr->ai_socktype,
310                                 ptr->ai_protocol, ptr->ai_addr,
311                                 ptr->ai_addrlen );
312             if( fd != -1 )
313             {
314                 msg_Dbg( p_this, "got socket %d from rootwrap", fd );
315             }
316             else
317 #endif
318             {
319                 msg_Warn( p_this, "cannot bind socket (%s)",
320                           strerror( saved_errno ) );
321                 continue;
322             }
323         }
324
325         /* Listen */
326         if( listen( fd, 100 ) == -1 )
327         {
328             msg_Err( p_this, "cannot bring the socket in listening mode (%s)",
329                      net_strerror( net_errno ) );
330             net_Close( fd );
331             continue;
332         }
333
334         newpi = (int *)realloc( pi_handles, (++i_size) * sizeof( int ) );
335         if( newpi == NULL )
336         {
337             net_Close( fd );
338             break;
339         }
340         else
341         {
342             newpi[i_size - 2] = fd;
343             pi_handles = newpi;
344         }
345     }
346
347     vlc_freeaddrinfo( res );
348
349     if( pi_handles != NULL )
350         pi_handles[i_size - 1] = -1;
351     return pi_handles;
352 }
353
354 /*****************************************************************************
355  * __net_Accept:
356  *****************************************************************************
357  * Accept a connection on a set of listening sockets and return it
358  *****************************************************************************/
359 int __net_Accept( vlc_object_t *p_this, int *pi_fd, mtime_t i_wait )
360 {
361     vlc_bool_t b_die = p_this->b_die, b_block = (i_wait < 0);
362
363     while( p_this->b_die == b_die )
364     {
365         int i_val = -1, *pi, *pi_end;
366         struct timeval timeout;
367         fd_set fds_r, fds_e;
368
369         pi = pi_fd;
370
371         /* Initialize file descriptor set */
372         FD_ZERO( &fds_r );
373         FD_ZERO( &fds_e );
374
375         for( pi = pi_fd; *pi != -1; pi++ )
376         {
377             int i_fd = *pi;
378
379             if( i_fd > i_val )
380                 i_val = i_fd;
381
382             FD_SET( i_fd, &fds_r );
383             FD_SET( i_fd, &fds_e );
384         }
385         pi_end = pi;
386
387         timeout.tv_sec = 0;
388         timeout.tv_usec = b_block ? 500000 : i_wait;
389
390         i_val = select( i_val + 1, &fds_r, NULL, &fds_e, &timeout );
391         if( ( ( i_val < 0 ) && ( net_errno == EINTR ) ) || i_val == 0 )
392         {
393             if( b_block )
394                 continue;
395             else
396                 return -1;
397         }
398         else if( i_val < 0 )
399         {
400             msg_Err( p_this, "network select error (%s)",
401                      net_strerror( net_errno ) );
402             return -1;
403         }
404
405         for( pi = pi_fd; *pi != -1; pi++ )
406         {
407             int i_fd = *pi;
408
409             if( !FD_ISSET( i_fd, &fds_r ) && !FD_ISSET( i_fd, &fds_e ) )
410                 continue;
411
412             i_val = accept( i_fd, NULL, 0 );
413             if( i_val < 0 )
414                 msg_Err( p_this, "accept failed (%s)",
415                          net_strerror( net_errno ) );
416             else
417             {
418                 /*
419                  * This round-robin trick ensures that the first sockets in
420                  * pi_fd won't prevent the last ones from getting accept'ed.
421                  */
422                 --pi_end;
423                 memmove( pi, pi + 1, pi_end - pi );
424                 *pi_end = i_fd;
425                 return i_val;
426             }
427         }
428     }
429
430     return -1;
431 }
432
433
434 /*****************************************************************************
435  * SocksNegociate:
436  *****************************************************************************
437  * Negociate authentication with a SOCKS server.
438  *****************************************************************************/
439 static int SocksNegociate( vlc_object_t *p_obj,
440                            int fd, int i_socks_version,
441                            char *psz_socks_user,
442                            char *psz_socks_passwd )
443 {
444     uint8_t buffer[128+2*256];
445     int i_len;
446     vlc_bool_t b_auth = VLC_FALSE;
447
448     if( i_socks_version != 5 )
449         return VLC_SUCCESS;
450
451     /* We negociate authentication */
452
453     if( psz_socks_user && psz_socks_passwd &&
454         *psz_socks_user && *psz_socks_passwd )
455         b_auth = VLC_TRUE;
456
457     buffer[0] = i_socks_version;    /* SOCKS version */
458     if( b_auth )
459     {
460         buffer[1] = 2;                  /* Number of methods */
461         buffer[2] = 0x00;               /* - No auth required */
462         buffer[3] = 0x02;               /* - USer/Password */
463         i_len = 4;
464     }
465     else
466     {
467         buffer[1] = 1;                  /* Number of methods */
468         buffer[2] = 0x00;               /* - No auth required */
469         i_len = 3;
470     }
471
472     if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
473         return VLC_EGENERIC;
474     if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
475         return VLC_EGENERIC;
476
477     msg_Dbg( p_obj, "socks: v=%d method=%x", buffer[0], buffer[1] );
478
479     if( buffer[1] == 0x00 )
480     {
481         msg_Dbg( p_obj, "socks: no authentication required" );
482     }
483     else if( buffer[1] == 0x02 )
484     {
485         int i_len1 = __MIN( strlen(psz_socks_user), 255 );
486         int i_len2 = __MIN( strlen(psz_socks_passwd), 255 );
487         msg_Dbg( p_obj, "socks: username/password authentication" );
488
489         /* XXX: we don't support user/pwd > 255 (truncated)*/
490         buffer[0] = i_socks_version;        /* Version */
491         buffer[1] = i_len1;                 /* User length */
492         memcpy( &buffer[2], psz_socks_user, i_len1 );
493         buffer[2+i_len1] = i_len2;          /* Password length */
494         memcpy( &buffer[2+i_len1+1], psz_socks_passwd, i_len2 );
495
496         i_len = 3 + i_len1 + i_len2;
497
498         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
499             return VLC_EGENERIC;
500
501         if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
502             return VLC_EGENERIC;
503
504         msg_Dbg( p_obj, "socks: v=%d status=%x", buffer[0], buffer[1] );
505         if( buffer[1] != 0x00 )
506         {
507             msg_Err( p_obj, "socks: authentication rejected" );
508             return VLC_EGENERIC;
509         }
510     }
511     else
512     {
513         if( b_auth )
514             msg_Err( p_obj, "socks: unsupported authentication method %x",
515                      buffer[0] );
516         else
517             msg_Err( p_obj, "socks: authentification needed" );
518         return VLC_EGENERIC;
519     }
520
521     return VLC_SUCCESS;
522 }
523
524 /*****************************************************************************
525  * SocksHandshakeTCP:
526  *****************************************************************************
527  * Open a TCP connection using a SOCKS server and return a handle (RFC 1928)
528  *****************************************************************************/
529 static int SocksHandshakeTCP( vlc_object_t *p_obj,
530                               int fd,
531                               int i_socks_version,
532                               char *psz_socks_user, char *psz_socks_passwd,
533                               const char *psz_host, int i_port )
534 {
535     uint8_t buffer[128+2*256];
536
537     if( i_socks_version != 4 && i_socks_version != 5 )
538     {
539         msg_Warn( p_obj, "invalid socks protocol version %d", i_socks_version );
540         i_socks_version = 5;
541     }
542
543     if( i_socks_version == 5 && 
544         SocksNegociate( p_obj, fd, i_socks_version,
545                         psz_socks_user, psz_socks_passwd ) )
546         return VLC_EGENERIC;
547
548     if( i_socks_version == 4 )
549     {
550         struct addrinfo hints = { 0 }, *p_res;
551
552         /* v4 only support ipv4 */
553         hints.ai_family = AF_INET;
554         if( vlc_getaddrinfo( p_obj, psz_host, 0, &hints, &p_res ) )
555             return VLC_EGENERIC;
556
557         buffer[0] = i_socks_version;
558         buffer[1] = 0x01;               /* CONNECT */
559         SetWBE( &buffer[2], i_port );   /* Port */
560         memcpy( &buffer[4],             /* Address */
561                 &((struct sockaddr_in *)(p_res->ai_addr))->sin_addr, 4 );
562         vlc_freeaddrinfo( p_res );
563
564         buffer[8] = 0;                  /* Empty user id */
565
566         if( net_Write( p_obj, fd, NULL, buffer, 9 ) != 9 )
567             return VLC_EGENERIC;
568         if( net_Read( p_obj, fd, NULL, buffer, 8, VLC_TRUE ) != 8 )
569             return VLC_EGENERIC;
570
571         msg_Dbg( p_obj, "socks: v=%d cd=%d",
572                  buffer[0], buffer[1] );
573
574         if( buffer[1] != 90 )
575             return VLC_EGENERIC;
576     }
577     else if( i_socks_version == 5 )
578     {
579         int i_hlen = __MIN(strlen( psz_host ), 255);
580         int i_len;
581
582         buffer[0] = i_socks_version;    /* Version */
583         buffer[1] = 0x01;               /* Cmd: connect */
584         buffer[2] = 0x00;               /* Reserved */
585         buffer[3] = 3;                  /* ATYP: for now domainname */
586
587         buffer[4] = i_hlen;
588         memcpy( &buffer[5], psz_host, i_hlen );
589         SetWBE( &buffer[5+i_hlen], i_port );
590
591         i_len = 5 + i_hlen + 2;
592
593
594         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
595             return VLC_EGENERIC;
596
597         /* Read the header */
598         if( net_Read( p_obj, fd, NULL, buffer, 5, VLC_TRUE ) != 5 )
599             return VLC_EGENERIC;
600
601         msg_Dbg( p_obj, "socks: v=%d rep=%d atyp=%d",
602                  buffer[0], buffer[1], buffer[3] );
603
604         if( buffer[1] != 0x00 )
605         {
606             msg_Err( p_obj, "socks: CONNECT request failed\n" );
607             return VLC_EGENERIC;
608         }
609
610         /* Read the remaining bytes */
611         if( buffer[3] == 0x01 )
612             i_len = 4-1 + 2;
613         else if( buffer[3] == 0x03 )
614             i_len = buffer[4] + 2;
615         else if( buffer[3] == 0x04 )
616             i_len = 16-1+2;
617         else 
618             return VLC_EGENERIC;
619
620         if( net_Read( p_obj, fd, NULL, buffer, i_len, VLC_TRUE ) != i_len )
621             return VLC_EGENERIC;
622     }
623
624     return VLC_SUCCESS;
625 }
626
627 void net_ListenClose( int *pi_fd )
628 {
629     if( pi_fd != NULL )
630     {
631         int *pi;
632
633         for( pi = pi_fd; *pi != -1; pi++ )
634             net_Close( *pi );
635         free( pi_fd );
636     }
637 }