Minor code factorization
[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 <vlc_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
63 /*****************************************************************************
64  * __net_Connect:
65  *****************************************************************************
66  * Open a network connection.
67  * @return socket handler or -1 on error.
68  *****************************************************************************/
69 int __net_Connect( vlc_object_t *p_this, const char *psz_host, int i_port,
70                    int type, int proto )
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, type ?: ptr->ai_socktype,
119                              proto ?: 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_Accept:
266  *****************************************************************************
267  * Accept a connection on a set of listening sockets and return it
268  *****************************************************************************/
269 int __net_Accept( vlc_object_t *p_this, int pi_fd[], mtime_t i_wait )
270 {
271     vlc_bool_t b_block = (i_wait < 0);
272
273     while( !p_this->b_die )
274     {
275         int maxfd = -1;
276         fd_set readset;
277
278         /* Initialize file descriptor set */
279         FD_ZERO (&readset);
280
281         int *pi_end = pi_fd;
282         for (const int *pi = pi_fd; *pi != -1; pi++)
283         {
284             int fd = *pi;
285
286             if (fd > maxfd)
287                 maxfd = fd;
288
289             FD_SET (fd, &readset);
290             pi_end++;
291         }
292
293         struct timeval tv = { 0, b_block ? 500000 : i_wait };
294
295         int val = select (maxfd + 1, &readset, NULL, NULL, &tv);
296         if (val == 0)
297         {
298             if (b_block)
299                 continue;
300             return -1;
301         }
302         if (val < 0)
303         {
304             if (net_errno != EINTR)
305                 msg_Err( p_this, "network select error (%s)",
306                         net_strerror( net_errno ) );
307             return -1;
308         }
309
310         for (const int *pi = pi_fd; *pi != -1; pi++)
311         {
312             int fd = *pi;
313
314             if (!FD_ISSET (fd, &readset))
315                 continue;
316
317             fd = accept (fd, NULL, 0);
318             if (fd < 0)
319             {
320                 msg_Err (p_this, "accept failed (%s)",
321                          net_strerror (net_errno));
322                 continue;
323             }
324             net_SetupSocket (fd);
325
326             /*
327              * This round-robin trick ensures that the first sockets in
328              * pi_fd won't prevent the last ones from getting accept'ed.
329              */
330             --pi_end;
331             memmove (pi_fd, pi_fd + 1, pi_end - pi_fd);
332             *pi_end = *pi;
333             msg_Dbg (p_this, "accepted socket %d (from socket %d)", fd, *pi);
334             return fd;
335         }
336     }
337
338     return -1;
339 }
340
341
342 /*****************************************************************************
343  * SocksNegociate:
344  *****************************************************************************
345  * Negociate authentication with a SOCKS server.
346  *****************************************************************************/
347 static int SocksNegociate( vlc_object_t *p_obj,
348                            int fd, int i_socks_version,
349                            char *psz_socks_user,
350                            char *psz_socks_passwd )
351 {
352     uint8_t buffer[128+2*256];
353     int i_len;
354     vlc_bool_t b_auth = VLC_FALSE;
355
356     if( i_socks_version != 5 )
357         return VLC_SUCCESS;
358
359     /* We negociate authentication */
360
361     if( psz_socks_user && psz_socks_passwd &&
362         *psz_socks_user && *psz_socks_passwd )
363         b_auth = VLC_TRUE;
364
365     buffer[0] = i_socks_version;    /* SOCKS version */
366     if( b_auth )
367     {
368         buffer[1] = 2;                  /* Number of methods */
369         buffer[2] = 0x00;               /* - No auth required */
370         buffer[3] = 0x02;               /* - USer/Password */
371         i_len = 4;
372     }
373     else
374     {
375         buffer[1] = 1;                  /* Number of methods */
376         buffer[2] = 0x00;               /* - No auth required */
377         i_len = 3;
378     }
379
380     if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
381         return VLC_EGENERIC;
382     if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
383         return VLC_EGENERIC;
384
385     msg_Dbg( p_obj, "socks: v=%d method=%x", buffer[0], buffer[1] );
386
387     if( buffer[1] == 0x00 )
388     {
389         msg_Dbg( p_obj, "socks: no authentication required" );
390     }
391     else if( buffer[1] == 0x02 )
392     {
393         int i_len1 = __MIN( strlen(psz_socks_user), 255 );
394         int i_len2 = __MIN( strlen(psz_socks_passwd), 255 );
395         msg_Dbg( p_obj, "socks: username/password authentication" );
396
397         /* XXX: we don't support user/pwd > 255 (truncated)*/
398         buffer[0] = i_socks_version;        /* Version */
399         buffer[1] = i_len1;                 /* User length */
400         memcpy( &buffer[2], psz_socks_user, i_len1 );
401         buffer[2+i_len1] = i_len2;          /* Password length */
402         memcpy( &buffer[2+i_len1+1], psz_socks_passwd, i_len2 );
403
404         i_len = 3 + i_len1 + i_len2;
405
406         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
407             return VLC_EGENERIC;
408
409         if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
410             return VLC_EGENERIC;
411
412         msg_Dbg( p_obj, "socks: v=%d status=%x", buffer[0], buffer[1] );
413         if( buffer[1] != 0x00 )
414         {
415             msg_Err( p_obj, "socks: authentication rejected" );
416             return VLC_EGENERIC;
417         }
418     }
419     else
420     {
421         if( b_auth )
422             msg_Err( p_obj, "socks: unsupported authentication method %x",
423                      buffer[0] );
424         else
425             msg_Err( p_obj, "socks: authentification needed" );
426         return VLC_EGENERIC;
427     }
428
429     return VLC_SUCCESS;
430 }
431
432 /*****************************************************************************
433  * SocksHandshakeTCP:
434  *****************************************************************************
435  * Open a TCP connection using a SOCKS server and return a handle (RFC 1928)
436  *****************************************************************************/
437 static int SocksHandshakeTCP( vlc_object_t *p_obj,
438                               int fd,
439                               int i_socks_version,
440                               char *psz_socks_user, char *psz_socks_passwd,
441                               const char *psz_host, int i_port )
442 {
443     uint8_t buffer[128+2*256];
444
445     if( i_socks_version != 4 && i_socks_version != 5 )
446     {
447         msg_Warn( p_obj, "invalid socks protocol version %d", i_socks_version );
448         i_socks_version = 5;
449     }
450
451     if( i_socks_version == 5 && 
452         SocksNegociate( p_obj, fd, i_socks_version,
453                         psz_socks_user, psz_socks_passwd ) )
454         return VLC_EGENERIC;
455
456     if( i_socks_version == 4 )
457     {
458         struct addrinfo hints, *p_res;
459
460         /* v4 only support ipv4 */
461         memset (&hints, 0, sizeof (hints));
462         hints.ai_family = AF_INET;
463         if( vlc_getaddrinfo( p_obj, psz_host, 0, &hints, &p_res ) )
464             return VLC_EGENERIC;
465
466         buffer[0] = i_socks_version;
467         buffer[1] = 0x01;               /* CONNECT */
468         SetWBE( &buffer[2], i_port );   /* Port */
469         memcpy( &buffer[4],             /* Address */
470                 &((struct sockaddr_in *)(p_res->ai_addr))->sin_addr, 4 );
471         vlc_freeaddrinfo( p_res );
472
473         buffer[8] = 0;                  /* Empty user id */
474
475         if( net_Write( p_obj, fd, NULL, buffer, 9 ) != 9 )
476             return VLC_EGENERIC;
477         if( net_Read( p_obj, fd, NULL, buffer, 8, VLC_TRUE ) != 8 )
478             return VLC_EGENERIC;
479
480         msg_Dbg( p_obj, "socks: v=%d cd=%d",
481                  buffer[0], buffer[1] );
482
483         if( buffer[1] != 90 )
484             return VLC_EGENERIC;
485     }
486     else if( i_socks_version == 5 )
487     {
488         int i_hlen = __MIN(strlen( psz_host ), 255);
489         int i_len;
490
491         buffer[0] = i_socks_version;    /* Version */
492         buffer[1] = 0x01;               /* Cmd: connect */
493         buffer[2] = 0x00;               /* Reserved */
494         buffer[3] = 3;                  /* ATYP: for now domainname */
495
496         buffer[4] = i_hlen;
497         memcpy( &buffer[5], psz_host, i_hlen );
498         SetWBE( &buffer[5+i_hlen], i_port );
499
500         i_len = 5 + i_hlen + 2;
501
502
503         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
504             return VLC_EGENERIC;
505
506         /* Read the header */
507         if( net_Read( p_obj, fd, NULL, buffer, 5, VLC_TRUE ) != 5 )
508             return VLC_EGENERIC;
509
510         msg_Dbg( p_obj, "socks: v=%d rep=%d atyp=%d",
511                  buffer[0], buffer[1], buffer[3] );
512
513         if( buffer[1] != 0x00 )
514         {
515             msg_Err( p_obj, "socks: CONNECT request failed\n" );
516             return VLC_EGENERIC;
517         }
518
519         /* Read the remaining bytes */
520         if( buffer[3] == 0x01 )
521             i_len = 4-1 + 2;
522         else if( buffer[3] == 0x03 )
523             i_len = buffer[4] + 2;
524         else if( buffer[3] == 0x04 )
525             i_len = 16-1+2;
526         else 
527             return VLC_EGENERIC;
528
529         if( net_Read( p_obj, fd, NULL, buffer, i_len, VLC_TRUE ) != i_len )
530             return VLC_EGENERIC;
531     }
532
533     return VLC_SUCCESS;
534 }
535
536 void net_ListenClose( int *pi_fd )
537 {
538     if( pi_fd != NULL )
539     {
540         int *pi;
541
542         for( pi = pi_fd; *pi != -1; pi++ )
543             net_Close( *pi );
544         free( pi_fd );
545     }
546 }