include/libtorrent/session.hpp

   1 /*
   2
   3 Copyright (c) 2006, 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_SESSION_HPP_INCLUDED
  34 #define TORRENT_SESSION_HPP_INCLUDED
  35
  36 #include <ctime>
  37 #include <algorithm>
  38 #include <vector>
  39 #include <set>
  40 #include <list>
  41 #include <deque>
  42
  43 #ifdef _MSC_VER
  44 #pragma warning(push, 1)
  45 #endif
  46
  47 #include <boost/limits.hpp>
  48 #include <boost/tuple/tuple.hpp>
  49 #include <boost/filesystem/path.hpp>
  50 #include <boost/thread.hpp>
  51
  52 #ifdef _MSC_VER
  53 #pragma warning(pop)
  54 #endif
  55
  56 #include "libtorrent/config.hpp"
  57 #include "libtorrent/torrent_handle.hpp"
  58 #include "libtorrent/entry.hpp"
  59 #include "libtorrent/alert.hpp"
  60 #include "libtorrent/session_status.hpp"
  61 #include "libtorrent/version.hpp"
  62 #include "libtorrent/fingerprint.hpp"
  63 #include "libtorrent/time.hpp"
  64 #include "libtorrent/disk_io_thread.hpp"
  65 #include "libtorrent/peer_id.hpp"
  66
  67 #include "libtorrent/storage.hpp"
  68
  69 #ifdef _MSC_VER
  70 #       include <eh.h>
  71 #endif
  72
  73 namespace libtorrent
  74 {
  75         struct torrent_plugin;
  76         class torrent;
  77         class ip_filter;
  78         class port_filter;
  79         class connection_queue;
  80         class natpmp;
  81         class upnp;
  82
  83         namespace fs = boost::filesystem;
  84
  85         namespace aux
  86         {
  87                 // workaround for microsofts
  88                 // hardware exceptions that makes
  89                 // it hard to debug stuff
  90 #ifdef _MSC_VER
  91                 struct eh_initializer
  92                 {
  93                         eh_initializer()
  94                         {
  95                                 ::_set_se_translator(straight_to_debugger);
  96                         }
  97
  98                         static void straight_to_debugger(unsigned int, _EXCEPTION_POINTERS*)
  99                         { throw; }
 100                 };
 101 #else
 102                 struct eh_initializer {};
 103 #endif
 104                 struct session_impl;
 105
 106                 struct filesystem_init
 107                 {
 108                         filesystem_init();
 109                 };
 110
 111         }
 112
 113         class TORRENT_EXPORT session_proxy
 114         {
 115                 friend class session;
 116         public:
 117                 session_proxy() {}
 118         private:
 119                 session_proxy(boost::shared_ptr<aux::session_impl> impl)
 120                         : m_impl(impl) {}
 121                 boost::shared_ptr<aux::session_impl> m_impl;
 122         };
 123
 124         struct add_torrent_params
 125         {
 126                 add_torrent_params(storage_constructor_type sc = default_storage_constructor)
 127                         : tracker_url(0)
 128                         , name(0)
 129                         , resume_data(0)
 130                         , storage_mode(storage_mode_sparse)
 131                         , paused(true)
 132                         , auto_managed(true)
 133                         , duplicate_is_error(false)
 134                         , storage(sc)
 135                         , userdata(0)
 136                 {}
 137
 138                 boost::intrusive_ptr<torrent_info> ti;
 139                 char const* tracker_url;
 140                 sha1_hash info_hash;
 141                 char const* name;
 142                 fs::path save_path;
 143                 std::vector<char>* resume_data;
 144                 storage_mode_t storage_mode;
 145                 bool paused;
 146                 bool auto_managed;
 147                 bool duplicate_is_error;
 148                 storage_constructor_type storage;
 149                 void* userdata;
 150         };
 151
 152         class TORRENT_EXPORT session: public boost::noncopyable, aux::eh_initializer
 153         {
 154         public:
 155
 156                 session(fingerprint const& print = fingerprint("LT"
 157                         , LIBTORRENT_VERSION_MAJOR, LIBTORRENT_VERSION_MINOR, 0, 0)
 158 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
 159                         , fs::path logpath = "."
 160 #endif
 161                                 );
 162                 session(
 163                         fingerprint const& print
 164                         , std::pair<int, int> listen_port_range
 165                         , char const* listen_interface = "0.0.0.0"
 166 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
 167                         , fs::path logpath = "."
 168 #endif
 169                         );
 170
 171                 ~session();
 172
 173                 // returns a list of all torrents in this session
 174                 std::vector<torrent_handle> get_torrents() const;
 175
 176                 // returns an invalid handle in case the torrent doesn't exist
 177                 torrent_handle find_torrent(sha1_hash const& info_hash) const;
 178
 179                 // all torrent_handles must be destructed before the session is destructed!
 180                 torrent_handle add_torrent(add_torrent_params const& params);
 181
 182 #ifndef TORRENT_NO_DEPRECATE
 183                 // deprecated in 0.14
 184                 torrent_handle add_torrent(
 185                         torrent_info const& ti
 186                         , fs::path const& save_path
 187                         , entry const& resume_data = entry()
 188                         , storage_mode_t storage_mode = storage_mode_sparse
 189                         , bool paused = false
 190                         , storage_constructor_type sc = default_storage_constructor) TORRENT_DEPRECATED;
 191
 192                 // deprecated in 0.14
 193                 torrent_handle add_torrent(
 194                         boost::intrusive_ptr<torrent_info> ti
 195                         , fs::path const& save_path
 196                         , entry const& resume_data = entry()
 197                         , storage_mode_t storage_mode = storage_mode_sparse
 198                         , bool paused = false
 199                         , storage_constructor_type sc = default_storage_constructor
 200                         , void* userdata = 0) TORRENT_DEPRECATED;
 201
 202                 // deprecated in 0.14
 203                 torrent_handle add_torrent(
 204                         char const* tracker_url
 205                         , sha1_hash const& info_hash
 206                         , char const* name
 207                         , fs::path const& save_path
 208                         , entry const& resume_data = entry()
 209                         , storage_mode_t storage_mode = storage_mode_sparse
 210                         , bool paused = false
 211                         , storage_constructor_type sc = default_storage_constructor
 212                         , void* userdata = 0) TORRENT_DEPRECATED;
 213 #endif
 214
 215                 session_proxy abort() { return session_proxy(m_impl); }
 216
 217                 void pause();
 218                 void resume();
 219                 bool is_paused() const;
 220
 221                 session_status status() const;
 222                 cache_status get_cache_status() const;
 223
 224                 void get_cache_info(sha1_hash const& ih
 225                         , std::vector<cached_piece_info>& ret) const;
 226
 227 #ifndef TORRENT_DISABLE_DHT
 228                 void start_dht(entry const& startup_state = entry());
 229                 void stop_dht();
 230                 void set_dht_settings(dht_settings const& settings);
 231                 entry dht_state() const;
 232                 void add_dht_node(std::pair<std::string, int> const& node);
 233                 void add_dht_router(std::pair<std::string, int> const& node);
 234 #endif
 235
 236 #ifndef TORRENT_DISABLE_ENCRYPTION
 237                 void set_pe_settings(pe_settings const& settings);
 238                 pe_settings const& get_pe_settings() const;
 239 #endif
 240
 241 #ifndef TORRENT_DISABLE_EXTENSIONS
 242                 void add_extension(boost::function<boost::shared_ptr<torrent_plugin>(torrent*, void*)> ext);
 243 #endif
 244
 245 #ifndef TORRENT_DISABLE_GEO_IP
 246                 int as_for_ip(address const& addr);
 247                 bool load_asnum_db(char const* file);
 248                 bool load_country_db(char const* file);
 249 #endif
 250
 251                 void load_state(entry const& ses_state);
 252                 entry state() const;
 253
 254                 void set_ip_filter(ip_filter const& f);
 255                 void set_port_filter(port_filter const& f);
 256                 void set_peer_id(peer_id const& pid);
 257                 void set_key(int key);
 258                 peer_id id() const;
 259
 260                 bool is_listening() const;
 261
 262                 // if the listen port failed in some way
 263                 // you can retry to listen on another port-
 264                 // range with this function. If the listener
 265                 // succeeded and is currently listening,
 266                 // a call to this function will shut down the
 267                 // listen port and reopen it using these new
 268                 // properties (the given interface and port range).
 269                 // As usual, if the interface is left as 0
 270                 // this function will return false on failure.
 271                 // If it fails, it will also generate alerts describing
 272                 // the error. It will return true on success.
 273                 bool listen_on(
 274                         std::pair<int, int> const& port_range
 275                         , const char* net_interface = 0);
 276
 277                 // returns the port we ended up listening on
 278                 unsigned short listen_port() const;
 279
 280                 // Get the number of uploads.
 281                 int num_uploads() const;
 282
 283                 // Get the number of connections. This number also contains the
 284                 // number of half open connections.
 285                 int num_connections() const;
 286
 287                 enum options_t
 288                 {
 289                         none = 0,
 290                         delete_files = 1
 291                 };
 292
 293                 void remove_torrent(const torrent_handle& h, int options = none);
 294
 295                 void set_settings(session_settings const& s);
 296                 session_settings const& settings();
 297
 298                 void set_peer_proxy(proxy_settings const& s);
 299                 void set_web_seed_proxy(proxy_settings const& s);
 300                 void set_tracker_proxy(proxy_settings const& s);
 301
 302                 proxy_settings const& peer_proxy() const;
 303                 proxy_settings const& web_seed_proxy() const;
 304                 proxy_settings const& tracker_proxy() const;
 305
 306 #ifndef TORRENT_DISABLE_DHT
 307                 void set_dht_proxy(proxy_settings const& s);
 308                 proxy_settings const& dht_proxy() const;
 309 #endif
 310
 311                 int upload_rate_limit() const;
 312                 int download_rate_limit() const;
 313                 int max_half_open_connections() const;
 314
 315                 void set_upload_rate_limit(int bytes_per_second);
 316                 void set_download_rate_limit(int bytes_per_second);
 317                 void set_max_uploads(int limit);
 318                 void set_max_connections(int limit);
 319                 void set_max_half_open_connections(int limit);
 320
 321                 std::auto_ptr<alert> pop_alert();
 322 #ifndef TORRENT_NO_DEPRECATE
 323                 void set_severity_level(alert::severity_t s) TORRENT_DEPRECATED;
 324 #endif
 325                 void set_alert_mask(int m);
 326
 327                 alert const* wait_for_alert(time_duration max_wait);
 328
 329                 connection_queue& get_connection_queue();
 330
 331                 // starts/stops UPnP, NATPMP or LSD port mappers
 332                 // they are stopped by default
 333                 void start_lsd();
 334                 natpmp* start_natpmp();
 335                 upnp* start_upnp();
 336
 337                 void stop_lsd();
 338                 void stop_natpmp();
 339                 void stop_upnp();
 340
 341         private:
 342
 343                 // just a way to initialize boost.filesystem
 344                 // before the session_impl is created
 345                 aux::filesystem_init m_dummy;
 346
 347                 // data shared between the main thread
 348                 // and the working thread
 349                 boost::shared_ptr<aux::session_impl> m_impl;
 350         };
 351
 352 }
 353
 354 #endif // TORRENT_SESSION_HPP_INCLUDED
 355