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