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