]> git.sesse.net Git - vlc/blob - src/network/tcp.c
select() sucks
[vlc] / 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 #ifdef HAVE_POLL
44 # include <poll.h>
45 #endif
46
47 #include <vlc_network.h>
48 #if defined (WIN32) || defined (UNDER_CE)
49 #   undef EINPROGRESS
50 #   define EINPROGRESS WSAEWOULDBLOCK
51 #   undef EINTR
52 #   define EINTR WSAEINTR
53 #   undef ETIMEDOUT
54 #   define ETIMEDOUT WSAETIMEDOUT
55 #endif
56
57 static int SocksNegociate( vlc_object_t *, int fd, int i_socks_version,
58                            char *psz_socks_user, char *psz_socks_passwd );
59 static int SocksHandshakeTCP( vlc_object_t *,
60                               int fd, int i_socks_version,
61                               char *psz_socks_user, char *psz_socks_passwd,
62                               const char *psz_host, int i_port );
63 extern int net_Socket( vlc_object_t *p_this, int i_family, int i_socktype,
64                        int i_protocol );
65
66 /*****************************************************************************
67  * __net_Connect:
68  *****************************************************************************
69  * Open a network connection.
70  * @return socket handler or -1 on error.
71  *****************************************************************************/
72 int __net_Connect( vlc_object_t *p_this, const char *psz_host, int i_port,
73                    int type, int proto )
74 {
75     struct addrinfo hints, *res, *ptr;
76     const char      *psz_realhost;
77     char            *psz_socks;
78     int             i_realport, i_val, i_handle = -1, i_saved_errno = 0;
79     unsigned        u_errstep = 0;
80
81     if( i_port == 0 )
82         i_port = 80; /* historical VLC thing */
83
84     memset( &hints, 0, sizeof( hints ) );
85     hints.ai_socktype = SOCK_STREAM;
86
87     psz_socks = var_CreateGetString( p_this, "socks" );
88     if( *psz_socks && *psz_socks != ':' )
89     {
90         char *psz = strchr( psz_socks, ':' );
91
92         if( psz )
93             *psz++ = '\0';
94
95         psz_realhost = psz_socks;
96         i_realport = ( psz != NULL ) ? atoi( psz ) : 1080;
97
98         msg_Dbg( p_this, "net: connecting to %s port %d for %s port %d",
99                  psz_realhost, i_realport, psz_host, i_port );
100     }
101     else
102     {
103         psz_realhost = psz_host;
104         i_realport = i_port;
105
106         msg_Dbg( p_this, "net: connecting to %s port %d", psz_realhost,
107                  i_realport );
108     }
109
110     i_val = vlc_getaddrinfo( p_this, psz_realhost, i_realport, &hints, &res );
111     if( i_val )
112     {
113         msg_Err( p_this, "cannot resolve %s port %d : %s", psz_realhost,
114                  i_realport, vlc_gai_strerror( i_val ) );
115         free( psz_socks );
116         return -1;
117     }
118
119     for( ptr = res; ptr != NULL; ptr = ptr->ai_next )
120     {
121         int fd = net_Socket( p_this, ptr->ai_family, type ?: ptr->ai_socktype,
122                              proto ?: ptr->ai_protocol );
123         if( fd == -1 )
124         {
125             if( u_errstep <= 0 )
126             {
127                 u_errstep = 1;
128                 i_saved_errno = net_errno;
129             }
130             msg_Dbg( p_this, "socket error: %s", strerror( net_errno ) );
131             continue;
132         }
133
134         if( connect( fd, ptr->ai_addr, ptr->ai_addrlen ) )
135         {
136             socklen_t i_val_size = sizeof( i_val );
137             div_t d;
138             vlc_value_t timeout;
139
140             if( net_errno != EINPROGRESS )
141             {
142                 if( u_errstep <= 1 )
143                 {
144                     u_errstep = 2;
145                     i_saved_errno = net_errno;
146                 }
147                 msg_Dbg( p_this, "connect error: %s", strerror( net_errno ) );
148                 goto next_ai;
149             }
150
151             var_Create( p_this, "ipv4-timeout",
152                         VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
153             var_Get( p_this, "ipv4-timeout", &timeout );
154             if( timeout.i_int < 0 )
155             {
156                 msg_Err( p_this, "invalid negative value for ipv4-timeout" );
157                 timeout.i_int = 0;
158             }
159             d = div( timeout.i_int, 100 );
160
161             msg_Dbg( p_this, "connection in progress" );
162             for (;;)
163             {
164                 struct pollfd ufd = { .fd = fd, .events = POLLOUT };
165                 int i_ret;
166
167                 if( p_this->b_die )
168                 {
169                     msg_Dbg( p_this, "connection aborted" );
170                     net_Close( fd );
171                     vlc_freeaddrinfo( res );
172                     free( psz_socks );
173                     return -1;
174                 }
175
176                 /*
177                  * We'll wait 0.1 second if nothing happens
178                  * NOTE:
179                  * time out will be shortened if we catch a signal (EINTR)
180                  */
181                 i_ret = poll (&ufd, 1, (d.quot > 0) ? 100 : d.rem);
182                 if( i_ret == 1 )
183                     break;
184
185                 if( ( i_ret == -1 ) && ( net_errno != EINTR ) )
186                 {
187                     msg_Warn( p_this, "select error: %s",
188                               strerror( net_errno ) );
189                     goto next_ai;
190                 }
191
192                 if( d.quot <= 0 )
193                 {
194                     msg_Dbg( p_this, "select timed out" );
195                     if( u_errstep <= 2 )
196                     {
197                         u_errstep = 3;
198                         i_saved_errno = ETIMEDOUT;
199                     }
200                     goto next_ai;
201                 }
202
203                 d.quot--;
204             }
205
206 #if !defined( SYS_BEOS ) && !defined( UNDER_CE )
207             if( getsockopt( fd, SOL_SOCKET, SO_ERROR, (void*)&i_val,
208                             &i_val_size ) == -1 || i_val != 0 )
209             {
210                 u_errstep = 4;
211                 i_saved_errno = i_val;
212                 msg_Dbg( p_this, "connect error (via getsockopt): %s",
213                          net_strerror( i_val ) );
214                 goto next_ai;
215             }
216 #endif
217         }
218
219         i_handle = fd; /* success! */
220         break;
221
222 next_ai: /* failure */
223         net_Close( fd );
224         continue;
225     }
226
227     vlc_freeaddrinfo( res );
228
229     if( i_handle == -1 )
230     {
231         msg_Err( p_this, "Connection to %s port %d failed: %s", psz_host,
232                  i_port, net_strerror( i_saved_errno ) );
233         free( psz_socks );
234         return -1;
235     }
236
237     if( *psz_socks && *psz_socks != ':' )
238     {
239         char *psz_user = var_CreateGetString( p_this, "socks-user" );
240         char *psz_pwd  = var_CreateGetString( p_this, "socks-pwd" );
241
242         if( SocksHandshakeTCP( p_this, i_handle, 5, psz_user, psz_pwd,
243                                psz_host, i_port ) )
244         {
245             msg_Err( p_this, "Failed to use the SOCKS server" );
246             net_Close( i_handle );
247             i_handle = -1;
248         }
249
250         free( psz_user );
251         free( psz_pwd );
252     }
253     free( psz_socks );
254
255     return i_handle;
256 }
257
258
259 /*****************************************************************************
260  * __net_Accept:
261  *****************************************************************************
262  * Accept a connection on a set of listening sockets and return it
263  *****************************************************************************/
264 int __net_Accept( vlc_object_t *p_this, int pi_fd[], mtime_t i_wait )
265 {
266     vlc_bool_t b_block = (i_wait < 0);
267
268     while( !p_this->b_die )
269     {
270         unsigned n = 0;
271         while (pi_fd[n] != -1)
272             n++;
273         struct pollfd ufd[n];
274
275         /* Initialize file descriptor set */
276         for (unsigned i = 0; i < n; i++)
277         {
278             ufd[i].fd = pi_fd[i];
279             ufd[i].events = POLLIN;
280             ufd[i].revents = 0;
281         }
282
283         switch (poll (ufd, n, b_block ? 500 : i_wait))
284         {
285             case -1:
286                 if (net_errno != EINTR)
287                 {
288                     msg_Err (p_this, "poll error: %s",
289                              net_strerror (net_errno));
290                 }
291                 return -1;
292
293             case 0:
294                 if (b_block)
295                     continue;
296                 return -1;
297         }
298
299         for (unsigned i = 0; i < n; i++)
300         {
301             if (ufd[i].revents == 0)
302                 continue;
303
304             int sfd = ufd[i].fd;
305             int fd = accept (sfd, NULL, NULL);
306             if (fd == -1)
307             {
308                 msg_Err (p_this, "accept failed (%s)",
309                          net_strerror (net_errno));
310                 continue;
311             }
312             net_SetupSocket (fd);
313
314             /*
315              * Move listening socket to the end to let the others in the
316              * set a chance next time.
317              */
318             memmove (pi_fd + i, pi_fd + i + 1, n - (i + 1));
319             pi_fd[n - 1] = sfd;
320             msg_Dbg (p_this, "accepted socket %d (from socket %d)", fd, sfd);
321             return fd;
322         }
323     }
324
325     return -1;
326 }
327
328
329 /*****************************************************************************
330  * SocksNegociate:
331  *****************************************************************************
332  * Negociate authentication with a SOCKS server.
333  *****************************************************************************/
334 static int SocksNegociate( vlc_object_t *p_obj,
335                            int fd, int i_socks_version,
336                            char *psz_socks_user,
337                            char *psz_socks_passwd )
338 {
339     uint8_t buffer[128+2*256];
340     int i_len;
341     vlc_bool_t b_auth = VLC_FALSE;
342
343     if( i_socks_version != 5 )
344         return VLC_SUCCESS;
345
346     /* We negociate authentication */
347
348     if( psz_socks_user && psz_socks_passwd &&
349         *psz_socks_user && *psz_socks_passwd )
350         b_auth = VLC_TRUE;
351
352     buffer[0] = i_socks_version;    /* SOCKS version */
353     if( b_auth )
354     {
355         buffer[1] = 2;                  /* Number of methods */
356         buffer[2] = 0x00;               /* - No auth required */
357         buffer[3] = 0x02;               /* - USer/Password */
358         i_len = 4;
359     }
360     else
361     {
362         buffer[1] = 1;                  /* Number of methods */
363         buffer[2] = 0x00;               /* - No auth required */
364         i_len = 3;
365     }
366
367     if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
368         return VLC_EGENERIC;
369     if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
370         return VLC_EGENERIC;
371
372     msg_Dbg( p_obj, "socks: v=%d method=%x", buffer[0], buffer[1] );
373
374     if( buffer[1] == 0x00 )
375     {
376         msg_Dbg( p_obj, "socks: no authentication required" );
377     }
378     else if( buffer[1] == 0x02 )
379     {
380         int i_len1 = __MIN( strlen(psz_socks_user), 255 );
381         int i_len2 = __MIN( strlen(psz_socks_passwd), 255 );
382         msg_Dbg( p_obj, "socks: username/password authentication" );
383
384         /* XXX: we don't support user/pwd > 255 (truncated)*/
385         buffer[0] = i_socks_version;        /* Version */
386         buffer[1] = i_len1;                 /* User length */
387         memcpy( &buffer[2], psz_socks_user, i_len1 );
388         buffer[2+i_len1] = i_len2;          /* Password length */
389         memcpy( &buffer[2+i_len1+1], psz_socks_passwd, i_len2 );
390
391         i_len = 3 + i_len1 + i_len2;
392
393         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
394             return VLC_EGENERIC;
395
396         if( net_Read( p_obj, fd, NULL, buffer, 2, VLC_TRUE ) != 2 )
397             return VLC_EGENERIC;
398
399         msg_Dbg( p_obj, "socks: v=%d status=%x", buffer[0], buffer[1] );
400         if( buffer[1] != 0x00 )
401         {
402             msg_Err( p_obj, "socks: authentication rejected" );
403             return VLC_EGENERIC;
404         }
405     }
406     else
407     {
408         if( b_auth )
409             msg_Err( p_obj, "socks: unsupported authentication method %x",
410                      buffer[0] );
411         else
412             msg_Err( p_obj, "socks: authentification needed" );
413         return VLC_EGENERIC;
414     }
415
416     return VLC_SUCCESS;
417 }
418
419 /*****************************************************************************
420  * SocksHandshakeTCP:
421  *****************************************************************************
422  * Open a TCP connection using a SOCKS server and return a handle (RFC 1928)
423  *****************************************************************************/
424 static int SocksHandshakeTCP( vlc_object_t *p_obj,
425                               int fd,
426                               int i_socks_version,
427                               char *psz_socks_user, char *psz_socks_passwd,
428                               const char *psz_host, int i_port )
429 {
430     uint8_t buffer[128+2*256];
431
432     if( i_socks_version != 4 && i_socks_version != 5 )
433     {
434         msg_Warn( p_obj, "invalid socks protocol version %d", i_socks_version );
435         i_socks_version = 5;
436     }
437
438     if( i_socks_version == 5 && 
439         SocksNegociate( p_obj, fd, i_socks_version,
440                         psz_socks_user, psz_socks_passwd ) )
441         return VLC_EGENERIC;
442
443     if( i_socks_version == 4 )
444     {
445         struct addrinfo hints, *p_res;
446
447         /* v4 only support ipv4 */
448         memset (&hints, 0, sizeof (hints));
449         hints.ai_family = AF_INET;
450         if( vlc_getaddrinfo( p_obj, psz_host, 0, &hints, &p_res ) )
451             return VLC_EGENERIC;
452
453         buffer[0] = i_socks_version;
454         buffer[1] = 0x01;               /* CONNECT */
455         SetWBE( &buffer[2], i_port );   /* Port */
456         memcpy( &buffer[4],             /* Address */
457                 &((struct sockaddr_in *)(p_res->ai_addr))->sin_addr, 4 );
458         vlc_freeaddrinfo( p_res );
459
460         buffer[8] = 0;                  /* Empty user id */
461
462         if( net_Write( p_obj, fd, NULL, buffer, 9 ) != 9 )
463             return VLC_EGENERIC;
464         if( net_Read( p_obj, fd, NULL, buffer, 8, VLC_TRUE ) != 8 )
465             return VLC_EGENERIC;
466
467         msg_Dbg( p_obj, "socks: v=%d cd=%d",
468                  buffer[0], buffer[1] );
469
470         if( buffer[1] != 90 )
471             return VLC_EGENERIC;
472     }
473     else if( i_socks_version == 5 )
474     {
475         int i_hlen = __MIN(strlen( psz_host ), 255);
476         int i_len;
477
478         buffer[0] = i_socks_version;    /* Version */
479         buffer[1] = 0x01;               /* Cmd: connect */
480         buffer[2] = 0x00;               /* Reserved */
481         buffer[3] = 3;                  /* ATYP: for now domainname */
482
483         buffer[4] = i_hlen;
484         memcpy( &buffer[5], psz_host, i_hlen );
485         SetWBE( &buffer[5+i_hlen], i_port );
486
487         i_len = 5 + i_hlen + 2;
488
489
490         if( net_Write( p_obj, fd, NULL, buffer, i_len ) != i_len )
491             return VLC_EGENERIC;
492
493         /* Read the header */
494         if( net_Read( p_obj, fd, NULL, buffer, 5, VLC_TRUE ) != 5 )
495             return VLC_EGENERIC;
496
497         msg_Dbg( p_obj, "socks: v=%d rep=%d atyp=%d",
498                  buffer[0], buffer[1], buffer[3] );
499
500         if( buffer[1] != 0x00 )
501         {
502             msg_Err( p_obj, "socks: CONNECT request failed\n" );
503             return VLC_EGENERIC;
504         }
505
506         /* Read the remaining bytes */
507         if( buffer[3] == 0x01 )
508             i_len = 4-1 + 2;
509         else if( buffer[3] == 0x03 )
510             i_len = buffer[4] + 2;
511         else if( buffer[3] == 0x04 )
512             i_len = 16-1+2;
513         else 
514             return VLC_EGENERIC;
515
516         if( net_Read( p_obj, fd, NULL, buffer, i_len, VLC_TRUE ) != i_len )
517             return VLC_EGENERIC;
518     }
519
520     return VLC_SUCCESS;
521 }
522
523 void net_ListenClose( int *pi_fd )
524 {
525     if( pi_fd != NULL )
526     {
527         int *pi;
528
529         for( pi = pi_fd; *pi != -1; pi++ )
530             net_Close( *pi );
531         free( pi_fd );
532     }
533 }