include/libtorrent/proxy_base.hpp

   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 #ifndef TORRENT_PROXY_BASE_HPP_INCLUDED
  34 #define TORRENT_PROXY_BASE_HPP_INCLUDED
  35
  36 #include "libtorrent/io.hpp"
  37 #include "libtorrent/socket.hpp"
  38 #include <boost/bind.hpp>
  39 #include <boost/lexical_cast.hpp>
  40 #include <boost/function.hpp>
  41 #if BOOST_VERSION < 103500
  42 #include <asio/read.hpp>
  43 #include <asio/write.hpp>
  44 #else
  45 #include <boost/asio/read.hpp>
  46 #include <boost/asio/write.hpp>
  47 #endif
  48
  49 namespace libtorrent {
  50
  51 class proxy_base : boost::noncopyable
  52 {
  53 public:
  54
  55         typedef stream_socket::lowest_layer_type lowest_layer_type;
  56         typedef stream_socket::endpoint_type endpoint_type;
  57         typedef stream_socket::protocol_type protocol_type;
  58
  59         explicit proxy_base(io_service& io_service)
  60                 : m_sock(io_service)
  61                 , m_resolver(io_service)
  62         {}
  63
  64         void set_proxy(std::string hostname, int port)
  65         {
  66                 m_hostname = hostname;
  67                 m_port = port;
  68         }
  69
  70         template <class Mutable_Buffers, class Handler>
  71         void async_read_some(Mutable_Buffers const& buffers, Handler const& handler)
  72         {
  73                 m_sock.async_read_some(buffers, handler);
  74         }
  75
  76         template <class Mutable_Buffers>
  77         std::size_t read_some(Mutable_Buffers const& buffers, error_code& ec)
  78         {
  79                 return m_sock.read_some(buffers, ec);
  80         }
  81
  82 #ifndef BOOST_NO_EXCEPTIONS
  83         template <class Mutable_Buffers>
  84         std::size_t read_some(Mutable_Buffers const& buffers)
  85         {
  86                 return m_sock.read_some(buffers);
  87         }
  88
  89         template <class IO_Control_Command>
  90         void io_control(IO_Control_Command& ioc)
  91         {
  92                 m_sock.io_control(ioc);
  93         }
  94 #endif
  95
  96         template <class IO_Control_Command>
  97         void io_control(IO_Control_Command& ioc, error_code& ec)
  98         {
  99                 m_sock.io_control(ioc, ec);
 100         }
 101
 102         template <class Const_Buffers, class Handler>
 103         void async_write_some(Const_Buffers const& buffers, Handler const& handler)
 104         {
 105                 m_sock.async_write_some(buffers, handler);
 106         }
 107
 108 #ifndef BOOST_NO_EXCEPTIONS
 109         template <class SettableSocketOption>
 110         void set_option(SettableSocketOption const& opt)
 111         {
 112                 m_sock.set_option(opt);
 113         }
 114 #endif
 115
 116         template <class SettableSocketOption>
 117         error_code set_option(SettableSocketOption const& opt, error_code& ec)
 118         {
 119                 return m_sock.set_option(opt, ec);
 120         }
 121
 122 #ifndef BOOST_NO_EXCEPTIONS
 123         void bind(endpoint_type const& endpoint)
 124         {
 125                 m_sock.bind(endpoint);
 126         }
 127 #endif
 128
 129         void bind(endpoint_type const& endpoint, error_code& ec)
 130         {
 131                 m_sock.bind(endpoint, ec);
 132         }
 133
 134 #ifndef BOOST_NO_EXCEPTIONS
 135         void open(protocol_type const& p)
 136         {
 137                 m_sock.open(p);
 138         }
 139 #endif
 140
 141         void open(protocol_type const& p, error_code& ec)
 142         {
 143                 m_sock.open(p, ec);
 144         }
 145
 146 #ifndef BOOST_NO_EXCEPTIONS
 147         void close()
 148         {
 149                 m_remote_endpoint = endpoint_type();
 150                 m_sock.close();
 151                 m_resolver.cancel();
 152         }
 153 #endif
 154
 155         void close(error_code& ec)
 156         {
 157                 m_sock.close(ec);
 158                 m_resolver.cancel();
 159         }
 160
 161 #ifndef BOOST_NO_EXCEPTIONS
 162         endpoint_type remote_endpoint() const
 163         {
 164                 return m_remote_endpoint;
 165         }
 166 #endif
 167
 168         endpoint_type remote_endpoint(error_code& ec) const
 169         {
 170                 return m_remote_endpoint;
 171         }
 172
 173 #ifndef BOOST_NO_EXCEPTIONS
 174         endpoint_type local_endpoint() const
 175         {
 176                 return m_sock.local_endpoint();
 177         }
 178 #endif
 179
 180         endpoint_type local_endpoint(error_code& ec) const
 181         {
 182                 return m_sock.local_endpoint(ec);
 183         }
 184
 185         io_service& get_io_service()
 186         {
 187                 return m_sock.get_io_service();
 188         }
 189
 190         lowest_layer_type& lowest_layer()
 191         {
 192                 return m_sock.lowest_layer();
 193         }
 194
 195         bool is_open() const { return m_sock.is_open(); }
 196
 197 protected:
 198
 199         stream_socket m_sock;
 200         std::string m_hostname;
 201         int m_port;
 202
 203         endpoint_type m_remote_endpoint;
 204
 205         tcp::resolver m_resolver;
 206 };
 207
 208 }
 209
 210 #endif
 211