/usr/include/libtorrent/aux_/session_interface.hpp is in libtorrent-rasterbar-dev 1.1.1-1+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 | /*
Copyright (c) 2012, 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 TORRENT_SESSION_INTERFACE_HPP_INCLUDED
#define TORRENT_SESSION_INTERFACE_HPP_INCLUDED
#include "libtorrent/config.hpp"
#include "libtorrent/peer_id.hpp"
#include "libtorrent/address.hpp"
#include "libtorrent/io_service.hpp"
#include "libtorrent/disk_buffer_holder.hpp"
#ifndef TORRENT_DISABLE_DHT
#include "libtorrent/socket.hpp"
#endif
#include "libtorrent/socket.hpp" // for tcp::endpoint
#include "libtorrent/aux_/disable_warnings_push.hpp"
#include <boost/weak_ptr.hpp>
#include <boost/function.hpp>
#ifndef TORRENT_DISABLE_LOGGING
#include <boost/shared_ptr.hpp>
#endif
#ifdef TORRENT_USE_OPENSSL
#include <boost/asio/ssl/context.hpp>
#endif
#include "libtorrent/aux_/disable_warnings_pop.hpp"
namespace libtorrent
{
class peer_connection;
class torrent;
struct socket_job;
#ifndef TORRENT_NO_DEPRECATE
struct pe_settings;
#endif
struct peer_class_set;
struct bandwidth_channel;
struct bandwidth_manager;
struct peer_class_pool;
struct disk_observer;
struct torrent_peer;
class alert_manager;
struct disk_interface;
struct tracker_request;
struct request_callback;
struct utp_socket_manager;
struct socket_type;
struct block_info;
struct external_ip;
struct torrent_handle;
struct ip_filter;
class port_filter;
struct settings_pack;
struct torrent_peer_allocator_interface;
struct counters;
struct resolver_interface;
#ifndef TORRENT_DISABLE_DHT
namespace dht
{
struct dht_tracker;
}
#endif
}
namespace libtorrent { namespace aux
{
struct proxy_settings;
struct session_settings;
#if !defined TORRENT_DISABLE_LOGGING || TORRENT_USE_ASSERTS
// This is the basic logging and debug interface offered by the session.
// a release build with logging disabled (which is the default) will
// not have this class at all
struct TORRENT_EXTRA_EXPORT session_logger
{
#ifndef TORRENT_DISABLE_LOGGING
virtual void session_log(char const* fmt, ...) const TORRENT_FORMAT(2,3) = 0;
virtual void session_vlog(char const* fmt, va_list& va) const = 0;
#endif
#if TORRENT_USE_ASSERTS
virtual bool is_single_thread() const = 0;
virtual bool has_peer(peer_connection const* p) const = 0;
virtual bool any_torrent_has_peer(peer_connection const* p) const = 0;
virtual bool is_posting_torrent_updates() const = 0;
#endif
protected:
~session_logger() {}
};
#endif // TORRENT_DISABLE_LOGGING || TORRENT_USE_ASSERTS
// TODO: 2 make this interface a lot smaller. It could be split up into
// several smaller interfaces. Each subsystem could then limit the size
// of the mock object to test it.
struct TORRENT_EXTRA_EXPORT session_interface
: buffer_allocator_interface
#if !defined TORRENT_DISABLE_LOGGING || TORRENT_USE_ASSERTS
, session_logger
#endif
{
// TODO: 2 the IP voting mechanism should be factored out
// to its own class, not part of the session
enum
{
source_dht = 1,
source_peer = 2,
source_tracker = 4,
source_router = 8
};
virtual void set_external_address(address const& ip
, int source_type, address const& source) = 0;
virtual external_ip const& external_address() const = 0;
virtual disk_interface& disk_thread() = 0;
virtual alert_manager& alerts() = 0;
virtual torrent_peer_allocator_interface* get_peer_allocator() = 0;
virtual io_service& get_io_service() = 0;
virtual resolver_interface& get_resolver() = 0;
typedef boost::function<void(error_code const&, std::vector<address> const&)>
callback_t;
// TODO: 2 remove this. There's already get_resolver()
virtual void async_resolve(std::string const& host, int flags
, callback_t const& h) = 0;
virtual bool has_connection(peer_connection* p) const = 0;
virtual void insert_peer(boost::shared_ptr<peer_connection> const& c) = 0;
virtual void queue_async_resume_data(boost::shared_ptr<torrent> const& t) = 0;
virtual void done_async_resume() = 0;
virtual void evict_torrent(torrent* t) = 0;
virtual void remove_torrent(torrent_handle const& h, int options = 0) = 0;
virtual void remove_torrent_impl(boost::shared_ptr<torrent> tptr, int options) = 0;
// port filter
virtual port_filter const& get_port_filter() const = 0;
virtual void ban_ip(address addr) = 0;
virtual boost::uint16_t session_time() const = 0;
virtual bool is_paused() const = 0;
virtual bool is_aborted() const = 0;
virtual int num_uploads() const = 0;
virtual bool preemptive_unchoke() const = 0;
virtual void trigger_optimistic_unchoke() = 0;
virtual void trigger_unchoke() = 0;
virtual boost::weak_ptr<torrent> find_torrent(sha1_hash const& info_hash) const = 0;
virtual boost::weak_ptr<torrent> find_disconnect_candidate_torrent() const = 0;
virtual boost::shared_ptr<torrent> delay_load_torrent(sha1_hash const& info_hash
, peer_connection* pc) = 0;
virtual void insert_torrent(sha1_hash const& ih, boost::shared_ptr<torrent> const& t
, std::string uuid) = 0;
virtual void insert_uuid_torrent(std::string uuid, boost::shared_ptr<torrent> const& t) = 0;
virtual void set_queue_position(torrent* t, int p) = 0;
virtual int num_torrents() const = 0;
virtual peer_id const& get_peer_id() const = 0;
// cork a peer and schedule a delayed uncork
// does nothing if the peer is already corked
virtual void cork_burst(peer_connection* p) = 0;
virtual void close_connection(peer_connection* p, error_code const& ec) = 0;
virtual int num_connections() const = 0;
virtual char* allocate_buffer() = 0;
virtual void free_buffer(char* buf) = 0;
virtual int send_buffer_size() const = 0;
virtual void deferred_submit_jobs() = 0;
virtual boost::uint16_t listen_port() const = 0;
virtual boost::uint16_t ssl_listen_port() const = 0;
// TODO: 2 factor out the thread pool for socket jobs into a separate
// class
// used to (potentially) issue socket write calls onto multiple threads
virtual void post_socket_job(socket_job& j) = 0;
// load the specified torrent. also evict one torrent, except
// for the one specified, if we are at the limit of loaded torrents
virtual bool load_torrent(torrent* t) = 0;
// bump the specified torrent to make it the most recently used one
// in the torrent LRU (i.e. the least likely to get unloaded)
virtual void bump_torrent(torrent* t, bool back = true) = 0;
// ask for which interface and port to bind outgoing peer connections on
virtual tcp::endpoint bind_outgoing_socket(socket_type& s, address const&
remote_address, error_code& ec) const = 0;
virtual bool verify_bound_address(address const& addr, bool utp
, error_code& ec) = 0;
#ifndef TORRENT_DISABLE_MUTABLE_TORRENTS
virtual std::vector<boost::shared_ptr<torrent> > find_collection(
std::string const& collection) const = 0;
#endif
// TODO: it would be nice to not have this be part of session_interface
virtual proxy_settings proxy() const = 0;
#if TORRENT_USE_I2P
virtual proxy_settings i2p_proxy() const = 0;
virtual char const* i2p_session() const = 0;
#endif
virtual void prioritize_connections(boost::weak_ptr<torrent> t) = 0;
virtual tcp::endpoint get_ipv6_interface() const = 0;
virtual tcp::endpoint get_ipv4_interface() const = 0;
virtual void trigger_auto_manage() = 0;
virtual void apply_settings_pack(boost::shared_ptr<settings_pack> pack) = 0;
virtual session_settings const& settings() const = 0;
virtual void queue_tracker_request(tracker_request& req
, boost::weak_ptr<request_callback> c) = 0;
// peer-classes
virtual void set_peer_classes(peer_class_set* s, address const& a, int st) = 0;
virtual peer_class_pool const& peer_classes() const = 0;
virtual peer_class_pool& peer_classes() = 0;
virtual bool ignore_unchoke_slots_set(peer_class_set const& set) const = 0;
virtual int copy_pertinent_channels(peer_class_set const& set
, int channel, bandwidth_channel** dst, int max) = 0;
virtual int use_quota_overhead(peer_class_set& set, int amount_down, int amount_up) = 0;
virtual bandwidth_manager* get_bandwidth_manager(int channel) = 0;
virtual void sent_bytes(int bytes_payload, int bytes_protocol) = 0;
virtual void received_bytes(int bytes_payload, int bytes_protocol) = 0;
virtual void trancieve_ip_packet(int bytes, bool ipv6) = 0;
virtual void sent_syn(bool ipv6) = 0;
virtual void received_synack(bool ipv6) = 0;
enum torrent_list_index
{
// this is the set of (subscribed) torrents that have changed
// their states since the last time the user requested updates.
torrent_state_updates,
// all torrents that want to be ticked every second
torrent_want_tick,
// all torrents that want more peers and are still downloading
// these typically have higher priority when connecting peers
torrent_want_peers_download,
// all torrents that want more peers and are finished downloading
torrent_want_peers_finished,
// torrents that want auto-scrape (only paused auto-managed ones)
torrent_want_scrape,
// auto-managed torrents by state. Only these torrents are considered
// when recalculating auto-managed torrents. started auto managed
// torrents that are inactive are not part of these lists, because they
// are not considered for auto managing (they are left started
// unconditionallty)
torrent_downloading_auto_managed,
torrent_seeding_auto_managed,
torrent_checking_auto_managed,
// all torrents that have resume data to save
// torrent_want_save_resume,
num_torrent_lists
};
virtual std::vector<torrent*>& torrent_list(int i) = 0;
virtual bool has_lsd() const = 0;
virtual void announce_lsd(sha1_hash const& ih, int port, bool broadcast = false) = 0;
virtual libtorrent::utp_socket_manager* utp_socket_manager() = 0;
virtual void inc_boost_connections() = 0;
virtual void setup_socket_buffers(socket_type& s) = 0;
virtual std::vector<block_info>& block_info_storage() = 0;
#ifdef TORRENT_USE_OPENSSL
virtual boost::asio::ssl::context* ssl_ctx() = 0 ;
#endif
#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS)
virtual torrent const* find_encrypted_torrent(
sha1_hash const& info_hash, sha1_hash const& xor_mask) = 0;
virtual void add_obfuscated_hash(sha1_hash const& obfuscated
, boost::weak_ptr<torrent> const& t) = 0;
#endif
#ifndef TORRENT_DISABLE_DHT
virtual bool announce_dht() const = 0;
virtual void add_dht_node(udp::endpoint n) = 0;
virtual bool has_dht() const = 0;
virtual int external_udp_port() const = 0;
virtual dht::dht_tracker* dht() = 0;
virtual void prioritize_dht(boost::weak_ptr<torrent> t) = 0;
#endif
virtual counters& stats_counters() = 0;
virtual void received_buffer(int size) = 0;
virtual void sent_buffer(int size) = 0;
protected:
~session_interface() {}
};
}}
#endif
|