premiere-libtorrent/include/libtorrent/kademlia/node.hpp

346 lines
9.6 KiB
C++

/*
Copyright (c) 2006, Arvid Norberg
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef NODE_HPP
#define NODE_HPP
#include <algorithm>
#include <map>
#include <set>
#include <libtorrent/config.hpp>
#include <libtorrent/kademlia/routing_table.hpp>
#include <libtorrent/kademlia/rpc_manager.hpp>
#include <libtorrent/kademlia/node_id.hpp>
#include <libtorrent/kademlia/msg.hpp>
#include <libtorrent/kademlia/find_data.hpp>
#include <libtorrent/io.hpp>
#include <libtorrent/session_settings.hpp>
#include <libtorrent/assert.hpp>
#include <libtorrent/thread.hpp>
#include <libtorrent/bloom_filter.hpp>
#include <boost/cstdint.hpp>
#include <boost/ref.hpp>
#include "libtorrent/socket.hpp"
namespace libtorrent {
struct alert_manager;
}
namespace libtorrent { namespace dht
{
#ifdef TORRENT_DHT_VERBOSE_LOGGING
TORRENT_DECLARE_LOG(node);
#endif
struct traversal_algorithm;
struct key_desc_t
{
char const* name;
int type;
int size;
int flags;
enum {
// this argument is optional, parsing will not
// fail if it's not present
optional = 1,
// for dictionaries, the following entries refer
// to child nodes to this node, up until and including
// the next item that has the last_child flag set.
// these flags are nestable
parse_children = 2,
// this is the last item in a child dictionary
last_child = 4,
// the size argument refers to that the size
// has to be divisible by the number, instead
// of having that exact size
size_divisible = 8
};
};
bool TORRENT_EXPORT verify_message(lazy_entry const* msg, key_desc_t const desc[], lazy_entry const* ret[]
, int size , char* error, int error_size);
// this is the entry for every peer
// the timestamp is there to make it possible
// to remove stale peers
struct peer_entry
{
tcp::endpoint addr;
ptime added;
};
// this is a group. It contains a set of group members
struct torrent_entry
{
std::string name;
std::set<peer_entry> peers;
};
struct feed_item
{
feed_item() : sequence_number(0), num_announcers(0) {}
enum { list_head, list_item } type;
size_type sequence_number;
std::string name;
unsigned char signature[64];
entry item;
ptime last_seen;
// this counts the number of IPs we have seen
// announcing this item, this is used to determine
// popularity if we reach the limit of items to store
bloom_filter<8> ips;
int num_announcers;
};
// this is the entry for a torrent that has been published
// in the DHT.
struct TORRENT_EXPORT search_torrent_entry
{
search_torrent_entry(): total_tag_points(0), total_name_points(0) {}
// the tags of the torrent. The key of
// this entry is the sha-1 hash of one of
// these tags. The counter is the number of
// times a tag has been included in a publish
// call. The counters are periodically
// decremented by a factor, so that the
// popularity ratio between the tags is
// maintained. The decrement is rounded down.
std::map<std::string, int> tags;
// this is the sum of all values in the tags
// map. It is only an optimization to avoid
// recalculating it constantly
int total_tag_points;
// the name of the torrent
std::map<std::string, int> name;
int total_name_points;
// increase the popularity counters for this torrent
void publish(std::string const& name, char const* in_tags[], int num_tags);
// return a score of how well this torrent matches
// the given set of tags. Each word in the string
// (separated by a space) is considered a tag.
// tags with 2 letters or fewer are ignored
int match(char const* tags[], int num_tags) const;
// this is called once every hour, and will
// decrement the popularity counters of the
// tags. Returns true if this entry should
// be deleted
bool tick();
void get_name(std::string& t) const;
void get_tags(std::string& t) const;
};
inline bool operator<(peer_entry const& lhs, peer_entry const& rhs)
{
return lhs.addr.address() == rhs.addr.address()
? lhs.addr.port() < rhs.addr.port()
: lhs.addr.address() < rhs.addr.address();
}
struct null_type {};
class announce_observer : public observer
{
public:
announce_observer(boost::intrusive_ptr<traversal_algorithm> const& algo
, udp::endpoint const& ep, node_id const& id)
: observer(algo, ep, id)
{}
void reply(msg const&) { flags |= flag_done; }
};
struct count_peers
{
int& count;
count_peers(int& c): count(c) {}
void operator()(std::pair<libtorrent::dht::node_id
, libtorrent::dht::torrent_entry> const& t)
{
count += t.second.peers.size();
}
};
class node_impl : boost::noncopyable
{
typedef std::map<node_id, torrent_entry> table_t;
typedef std::map<node_id, feed_item> feed_table_t;
typedef std::map<std::pair<node_id, sha1_hash>, search_torrent_entry> search_table_t;
public:
typedef boost::function3<void, address, int, address> external_ip_fun;
node_impl(libtorrent::alert_manager& alerts
, bool (*f)(void*, entry&, udp::endpoint const&, int)
, dht_settings const& settings, node_id nid, address const& external_address
, external_ip_fun ext_ip, void* userdata);
virtual ~node_impl() {}
void tick();
void refresh(node_id const& id, find_data::nodes_callback const& f);
void bootstrap(std::vector<udp::endpoint> const& nodes
, find_data::nodes_callback const& f);
void add_router_node(udp::endpoint router);
void unreachable(udp::endpoint const& ep);
void incoming(msg const& m);
int num_torrents() const { return m_map.size(); }
int num_peers() const
{
int ret = 0;
std::for_each(m_map.begin(), m_map.end(), count_peers(ret));
return ret;
}
int bucket_size(int bucket);
node_id const& nid() const { return m_id; }
boost::tuple<int, int> size() const{ return m_table.size(); }
size_type num_global_nodes() const
{ return m_table.num_global_nodes(); }
int data_size() const { return int(m_map.size()); }
#ifdef TORRENT_DHT_VERBOSE_LOGGING
void print_state(std::ostream& os) const
{ m_table.print_state(os); }
#endif
void announce(sha1_hash const& info_hash, int listen_port
, boost::function<void(std::vector<tcp::endpoint> const&)> f);
bool verify_token(std::string const& token, char const* info_hash
, udp::endpoint const& addr);
std::string generate_token(udp::endpoint const& addr, char const* info_hash);
// the returned time is the delay until connection_timeout()
// should be called again the next time
time_duration connection_timeout();
// generates a new secret number used to generate write tokens
void new_write_key();
// pings the given node, and adds it to
// the routing table if it respons and if the
// bucket is not full.
void add_node(udp::endpoint node);
void replacement_cache(bucket_t& nodes) const
{ m_table.replacement_cache(nodes); }
int branch_factor() const { return m_settings.search_branching; }
void add_traversal_algorithm(traversal_algorithm* a)
{
mutex_t::scoped_lock l(m_mutex);
m_running_requests.insert(a);
}
void remove_traversal_algorithm(traversal_algorithm* a)
{
mutex_t::scoped_lock l(m_mutex);
m_running_requests.erase(a);
}
void status(libtorrent::session_status& s);
dht_settings const& settings() const { return m_settings; }
protected:
// is called when a find data request is received. Should
// return false if the data is not stored on this node. If
// the data is stored, it should be serialized into 'data'.
bool lookup_peers(sha1_hash const& info_hash, int prefix, entry& reply) const;
bool lookup_torrents(sha1_hash const& target, entry& reply
, char* tags) const;
dht_settings const& m_settings;
// the maximum number of peers to send in a get_peers
// reply. Ordinary trackers usually limit this to 50.
// 50 => 6 * 50 = 250 bytes + packet overhead
int m_max_peers_reply;
private:
typedef libtorrent::mutex mutex_t;
mutex_t m_mutex;
// this list must be destructed after the rpc manager
// since it might have references to it
std::set<traversal_algorithm*> m_running_requests;
void incoming_request(msg const& h, entry& e);
node_id m_id;
public:
routing_table m_table;
rpc_manager m_rpc;
private:
table_t m_map;
feed_table_t m_feeds;
search_table_t m_search_map;
ptime m_last_tracker_tick;
// secret random numbers used to create write tokens
int m_secret[2];
libtorrent::alert_manager& m_alerts;
bool (*m_send)(void*, entry&, udp::endpoint const&, int);
void* m_userdata;
};
} } // namespace libtorrent::dht
#endif // NODE_HPP