src/socks4_stream.cpp

   1 /*
   2
   3 Copyright (c) 2007, Arvid Norberg
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions
   8 are met:
   9
  10     * Redistributions of source code must retain the above copyright
  11       notice, this list of conditions and the following disclaimer.
  12     * Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in
  14       the documentation and/or other materials provided with the distribution.
  15     * Neither the name of the author nor the names of its
  16       contributors may be used to endorse or promote products derived
  17       from this software without specific prior written permission.
  18
  19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29 POSSIBILITY OF SUCH DAMAGE.
  30
  31 */
  32
  33 #include "libtorrent/pch.hpp"
  34
  35 #include "libtorrent/socks4_stream.hpp"
  36
  37 namespace libtorrent
  38 {
  39
  40         void socks4_stream::name_lookup(error_code const& e, tcp::resolver::iterator i
  41                 , boost::shared_ptr<handler_type> h)
  42         {
  43                 if (e)
  44                 {
  45                         (*h)(e);
  46                         error_code ec;
  47                         close(ec);
  48                         return;
  49                 }
  50
  51                 // SOCKS4 doesn't support IPv6 addresses
  52                 while (i != tcp::resolver::iterator() && i->endpoint().address().is_v6())
  53                         ++i;
  54
  55                 if (i == tcp::resolver::iterator())
  56                 {
  57                         error_code ec = asio::error::operation_not_supported;
  58                         (*h)(ec);
  59                         close(ec);
  60                         return;
  61                 }
  62
  63                 m_sock.async_connect(i->endpoint(), boost::bind(
  64                         &socks4_stream::connected, this, _1, h));
  65         }
  66
  67         void socks4_stream::connected(error_code const& e, boost::shared_ptr<handler_type> h)
  68         {
  69                 if (e)
  70                 {
  71                         (*h)(e);
  72                         error_code ec;
  73                         close(ec);
  74                         return;
  75                 }
  76
  77                 using namespace libtorrent::detail;
  78
  79                 m_buffer.resize(m_user.size() + 9);
  80                 char* p = &m_buffer[0];
  81                 write_uint8(4, p); // SOCKS VERSION 4
  82                 write_uint8(1, p); // SOCKS CONNECT
  83                 write_uint16(m_remote_endpoint.port(), p);
  84                 write_uint32(m_remote_endpoint.address().to_v4().to_ulong(), p);
  85                 std::copy(m_user.begin(), m_user.end(), p);
  86                 p += m_user.size();
  87                 write_uint8(0, p); // NULL terminator
  88
  89                 async_write(m_sock, asio::buffer(m_buffer)
  90                         , boost::bind(&socks4_stream::handshake1, this, _1, h));
  91         }
  92
  93         void socks4_stream::handshake1(error_code const& e, boost::shared_ptr<handler_type> h)
  94         {
  95                 if (e)
  96                 {
  97                         (*h)(e);
  98                         error_code ec;
  99                         close(ec);
 100                         return;
 101                 }
 102
 103                 m_buffer.resize(8);
 104                 async_read(m_sock, asio::buffer(m_buffer)
 105                         , boost::bind(&socks4_stream::handshake2, this, _1, h));
 106         }
 107
 108         void socks4_stream::handshake2(error_code const& e, boost::shared_ptr<handler_type> h)
 109         {
 110                 if (e)
 111                 {
 112                         (*h)(e);
 113                         error_code ec;
 114                         close(ec);
 115                         return;
 116                 }
 117
 118                 using namespace libtorrent::detail;
 119
 120                 char* p = &m_buffer[0];
 121                 int reply_version = read_uint8(p);
 122                 int status_code = read_uint8(p);
 123
 124                 if (reply_version != 0)
 125                 {
 126                         error_code ec = asio::error::operation_not_supported;
 127                         (*h)(ec);
 128                         close(ec);
 129                         return;
 130                 }
 131
 132                 // access granted
 133                 if (status_code == 90)
 134                 {
 135                         std::vector<char>().swap(m_buffer);
 136                         (*h)(e);
 137                         return;
 138                 }
 139
 140                 error_code ec = asio::error::fault;
 141                 switch (status_code)
 142                 {
 143                         case 91: ec = asio::error::connection_refused; break;
 144                         case 92: ec = asio::error::no_permission; break;
 145                         case 93: ec = asio::error::no_permission; break;
 146                 }
 147                 (*h)(ec);
 148                 close(ec);
 149         }
 150
 151 }
 152