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