src/lsd.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/lsd.hpp"
  36 #include "libtorrent/io.hpp"
  37 #include "libtorrent/http_tracker_connection.hpp"
  38 #include "libtorrent/xml_parse.hpp"
  39 #include <boost/bind.hpp>
  40 #include <boost/ref.hpp>
  41 #include <asio/ip/host_name.hpp>
  42 #include <asio/ip/multicast.hpp>
  43 #include <boost/thread/mutex.hpp>
  44 #include <cstdlib>
  45 #include <boost/config.hpp>
  46
  47 using boost::bind;
  48 using namespace libtorrent;
  49
  50 namespace libtorrent
  51 {
  52         // defined in upnp.cpp
  53         address_v4 guess_local_address(asio::io_service&);
  54 }
  55
  56 address_v4 lsd::lsd_multicast_address;
  57 udp::endpoint lsd::lsd_multicast_endpoint;
  58
  59 lsd::lsd(io_service& ios, address const& listen_interface
  60         , peer_callback_t const& cb)
  61         : m_callback(cb)
  62         , m_retry_count(0)
  63         , m_socket(ios)
  64         , m_broadcast_timer(ios)
  65         , m_disabled(false)
  66 {
  67         // Bittorrent Local discovery multicast address and port
  68         lsd_multicast_address = address_v4::from_string("239.192.152.143");
  69         lsd_multicast_endpoint = udp::endpoint(lsd_multicast_address, 6771);
  70
  71 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
  72         m_log.open("lsd.log", std::ios::in | std::ios::out | std::ios::trunc);
  73 #endif
  74         assert(lsd_multicast_address.is_multicast());
  75         rebind(listen_interface);
  76 }
  77
  78 lsd::~lsd() {}
  79
  80 void lsd::rebind(address const& listen_interface)
  81 {
  82         address_v4 local_ip = address_v4::any();
  83         if (listen_interface.is_v4() && listen_interface != address_v4::any())
  84         {
  85                 local_ip = listen_interface.to_v4();
  86         }
  87
  88         try
  89         {
  90                 // the local interface hasn't changed
  91                 if (m_socket.is_open()
  92                         && m_socket.local_endpoint().address() == local_ip)
  93                         return;
  94
  95                 m_socket.close();
  96
  97                 using namespace asio::ip::multicast;
  98
  99                 m_socket.open(udp::v4());
 100                 m_socket.set_option(datagram_socket::reuse_address(true));
 101                 m_socket.bind(udp::endpoint(local_ip, 6771));
 102
 103 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
 104                 m_log << "local ip: " << local_ip << std::endl;
 105 #endif
 106
 107                 m_socket.set_option(join_group(lsd_multicast_address));
 108                 m_socket.set_option(outbound_interface(local_ip));
 109                 m_socket.set_option(enable_loopback(true));
 110                 m_socket.set_option(hops(255));
 111         }
 112         catch (std::exception& e)
 113         {
 114 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
 115                 m_log << "socket multicast error " << e.what()
 116                         << ". disabling local service discovery" << std::endl;
 117 #endif
 118                 m_disabled = true;
 119                 return;
 120         }
 121         m_disabled = false;
 122
 123         setup_receive();
 124 }
 125
 126 void lsd::announce(sha1_hash const& ih, int listen_port)
 127 {
 128         if (m_disabled) return;
 129
 130         std::stringstream btsearch;
 131         btsearch << "BT-SEARCH * HTTP/1.1\r\n"
 132                 "Host: 239.192.152.143:6771\r\n"
 133                 "Port: " << listen_port << "\r\n"
 134                 "Infohash: " << ih << "\r\n"
 135                 "\r\n\r\n";
 136         std::string const& msg = btsearch.str();
 137
 138         m_retry_count = 0;
 139         asio::error_code ec;
 140         m_socket.send_to(asio::buffer(msg.c_str(), msg.size() - 1)
 141                 , lsd_multicast_endpoint, 0, ec);
 142         if (ec)
 143         {
 144                 m_disabled = true;
 145                 return;
 146         }
 147
 148 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
 149         m_log << time_now_string()
 150                 << " ==> announce: ih: " << ih << " port: " << listen_port << std::endl;
 151 #endif
 152
 153         m_broadcast_timer.expires_from_now(milliseconds(250 * m_retry_count));
 154         m_broadcast_timer.async_wait(bind(&lsd::resend_announce, this, _1, msg));
 155 }
 156
 157 void lsd::resend_announce(asio::error_code const& e, std::string msg) try
 158 {
 159         if (e) return;
 160
 161         m_socket.send_to(asio::buffer(msg, msg.size() - 1)
 162                 , lsd_multicast_endpoint);
 163
 164         ++m_retry_count;
 165         if (m_retry_count >= 5)
 166                 return;
 167
 168         m_broadcast_timer.expires_from_now(milliseconds(250 * m_retry_count));
 169         m_broadcast_timer.async_wait(bind(&lsd::resend_announce, this, _1, msg));
 170 }
 171 catch (std::exception&)
 172 {}
 173
 174 void lsd::on_announce(asio::error_code const& e
 175         , std::size_t bytes_transferred)
 176 {
 177         using namespace libtorrent::detail;
 178         if (e) return;
 179
 180         char* p = m_receive_buffer;
 181         char* end = m_receive_buffer + bytes_transferred;
 182         char* line = std::find(p, end, '\n');
 183         for (char* i = p; i < line; ++i) *i = std::tolower(*i);
 184 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
 185         m_log << time_now_string()
 186                 << " <== announce: " << std::string(p, line) << std::endl;
 187 #endif
 188         if (line == end || (line - p >= 9 && std::memcmp("bt-search", p, 9)))
 189         {
 190 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
 191                 m_log << time_now_string()
 192                         << " *** assumed 'bt-search', ignoring" << std::endl;
 193 #endif
 194                 setup_receive();
 195                 return;
 196         }
 197         p = line + 1;
 198         int port = 0;
 199         sha1_hash ih(0);
 200         while (p != end)
 201         {
 202                 line = std::find(p, end, '\n');
 203                 if (line == end) break;
 204                 *line = 0;
 205                 for (char* i = p; i < line; ++i) *i = std::tolower(*i);
 206                 if (line - p >= 5 && memcmp(p, "port:", 5) == 0)
 207                 {
 208                         p += 5;
 209                         while (*p == ' ') ++p;
 210                         port = atoi(p);
 211                 }
 212                 else if (line - p >= 9 && memcmp(p, "infohash:", 9) == 0)
 213                 {
 214                         p += 9;
 215                         while (*p == ' ') ++p;
 216                         if (line - p > 40) p[40] = 0;
 217                         try { ih = boost::lexical_cast<sha1_hash>(p); }
 218                         catch (std::exception&) {}
 219                 }
 220                 p = line + 1;
 221         }
 222
 223         if (!ih.is_all_zeros() && port != 0)
 224         {
 225 #if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING)
 226                 m_log << time_now_string()
 227                         << " *** incoming local announce " << m_remote.address()
 228                         << ":" << port << " ih: " << ih << std::endl;
 229 #endif
 230                 // we got an announce, pass it on through the callback
 231                 try { m_callback(tcp::endpoint(m_remote.address(), port), ih); }
 232                 catch (std::exception&) {}
 233         }
 234         setup_receive();
 235 }
 236
 237 void lsd::setup_receive() try
 238 {
 239         assert(m_socket.is_open());
 240         m_socket.async_receive_from(asio::buffer(m_receive_buffer
 241                 , sizeof(m_receive_buffer)), m_remote, bind(&lsd::on_announce, this, _1, _2));
 242 }
 243 catch (std::exception&)
 244 {}
 245
 246 void lsd::close()
 247 {
 248         m_socket.close();
 249 }
 250