used by storage to return errors │ │ │ │ also includes which underlying file the │ │ │ │ error happened on
│ │ │ │
│ │ │ │ struct storage_error
│ │ │ │ {
│ │ │ │ explicit operator bool () const;
│ │ │ │ - file_index_t file () const;
│ │ │ │ void file (file_index_t f);
│ │ │ │ + file_index_t file () const;
│ │ │ │
│ │ │ │ error_code ec;
│ │ │ │ operation_t operation;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]explicitly converts to true if this object represents an error, and │ │ │ │ false if it does not.
│ │ │ │ [report issue]│ │ │ │ -file_index_t file () const; │ │ │ │ void file (file_index_t f); │ │ │ │ +file_index_t file () const; │ │ │ ││ │ │ │
set and query the index (in the torrent) of the file this error │ │ │ │ occurred on. This may also have special values defined in │ │ │ │ torrent_status.
│ │ │ │ [report issue]
│ │ │ │ struct session_params
│ │ │ │ {
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │ session_params (settings_pack const& sp);
│ │ │ │ session_params ();
│ │ │ │ - session_params (settings_pack&& sp
│ │ │ │ - , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ session_params (settings_pack const& sp
│ │ │ │ , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ + session_params (settings_pack&& sp
│ │ │ │ + , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │
│ │ │ │ settings_pack settings;
│ │ │ │ std::vector<std::shared_ptr<plugin>> extensions;
│ │ │ │ dht::dht_state dht_state;
│ │ │ │ dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │ disk_io_constructor_type disk_io_constructor;
│ │ │ │ std::map<std::string, std::string> ext_state;
│ │ │ │ @@ -2149,18 +2149,18 @@
│ │ │ │ This constructor can be used to start with the default plugins
│ │ │ │ (ut_metadata, ut_pex and smart_ban). Pass a settings_pack to set the
│ │ │ │ initial settings when the session starts.
│ │ │ │ [report issue]│ │ │ │ -session_params (settings_pack&& sp │ │ │ │ - , std::vector<std::shared_ptr<plugin>> exts); │ │ │ │ session_params (settings_pack const& sp │ │ │ │ , std::vector<std::shared_ptr<plugin>> exts); │ │ │ │ +session_params (settings_pack&& sp │ │ │ │ + , std::vector<std::shared_ptr<plugin>> exts); │ │ │ ││ │ │ │
This constructor helps to configure the set of initial plugins │ │ │ │ to be added to the session before it's started.
│ │ │ │ [report issue]
│ │ │ │ struct session_proxy
│ │ │ │ {
│ │ │ │ - session_proxy& operator= (session_proxy const&) &;
│ │ │ │ - ~session_proxy ();
│ │ │ │ - session_proxy ();
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ - session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ + ~session_proxy ();
│ │ │ │ + session_proxy& operator= (session_proxy const&) &;
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ + session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ + session_proxy ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -[report issue]│ │ │ │ -session_proxy& operator= (session_proxy const&) &; │ │ │ │ -~session_proxy (); │ │ │ │ -session_proxy (); │ │ │ │ session_proxy (session_proxy&&) noexcept; │ │ │ │ -session_proxy& operator= (session_proxy&&) & noexcept; │ │ │ │ +~session_proxy (); │ │ │ │ +session_proxy& operator= (session_proxy const&) &; │ │ │ │ session_proxy (session_proxy const&); │ │ │ │ +session_proxy& operator= (session_proxy&&) & noexcept; │ │ │ │ +session_proxy (); │ │ │ ││ │ │ │
default constructor, does not refer to any session │ │ │ │ implementation object.
│ │ │ │ [report issue]│ │ │ │ @@ -2277,17 +2277,17 @@ │ │ │ │ add_default_plugins do not have an affect on constructors that │ │ │ │ take a session_params object. It already contains the plugins to use. │ │ │ │ [report issue]
│ │ │ │ session (session_params const& params, io_context& ios); │ │ │ │ -session (session_params const& params, io_context& ios, session_flags_t); │ │ │ │ session (session_params&& params, io_context& ios, session_flags_t); │ │ │ │ session (session_params&& params, io_context& ios); │ │ │ │ +session (session_params const& params, io_context& ios, session_flags_t); │ │ │ ││ │ │ │
Overload of the constructor that takes an external io_context to run │ │ │ │ the session object on. This is primarily useful for tests that may want │ │ │ │ to run multiple sessions on a single io_context, or low resource │ │ │ │ systems where additional threads are expensive and sharing an │ │ │ │ io_context with other events is fine.
│ │ │ │
│ │ │ │ struct session_handle
│ │ │ │ {
│ │ │ │ bool is_valid () const;
│ │ │ │ session_params session_state (save_state_flags_t flags = save_state_flags_t::all()) const;
│ │ │ │ + void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ + , status_flags_t flags = {}) const;
│ │ │ │ std::vector<torrent_status> get_torrent_status (
│ │ │ │ std::function<bool(torrent_status const&)> const& pred
│ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ - void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ - , status_flags_t flags = {}) const;
│ │ │ │ void post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │ │ void post_session_stats ();
│ │ │ │ void post_dht_stats ();
│ │ │ │ void set_dht_state (dht::dht_state&& st);
│ │ │ │ void set_dht_state (dht::dht_state const& st);
│ │ │ │ torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ std::vector<torrent_handle> get_torrents () const;
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ - void async_add_torrent (add_torrent_params&& params);
│ │ │ │ - torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ void async_add_torrent (add_torrent_params const& params);
│ │ │ │ - void pause ();
│ │ │ │ - bool is_paused () const;
│ │ │ │ + void async_add_torrent (add_torrent_params&& params);
│ │ │ │ + torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ void resume ();
│ │ │ │ + bool is_paused () const;
│ │ │ │ + void pause ();
│ │ │ │ bool is_dht_running () const;
│ │ │ │ void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │ void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ │ void dht_get_item (sha1_hash const& target);
│ │ │ │ void dht_get_item (std::array<char, 32> key
│ │ │ │ , std::string salt = std::string());
│ │ │ │ sha1_hash dht_put_item (entry data);
│ │ │ │ void dht_put_item (std::array<char, 32> key
│ │ │ │ , std::function<void(entry&, std::array<char, 64>&
│ │ │ │ , std::int64_t&, std::string const&)> cb
│ │ │ │ , std::string salt = std::string());
│ │ │ │ - void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │ void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │ + void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │ void dht_live_nodes (sha1_hash const& nid);
│ │ │ │ void dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ │ void dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ │ void add_extension (std::function<std::shared_ptr<torrent_plugin>(
│ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │ ip_filter get_ip_filter () const;
│ │ │ │ void set_ip_filter (ip_filter f);
│ │ │ │ void set_port_filter (port_filter const& f);
│ │ │ │ - bool is_listening () const;
│ │ │ │ unsigned short listen_port () const;
│ │ │ │ unsigned short ssl_listen_port () const;
│ │ │ │ + bool is_listening () const;
│ │ │ │ void set_peer_class_filter (ip_filter const& f);
│ │ │ │ ip_filter get_peer_class_filter () const;
│ │ │ │ peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ peer_class_t create_peer_class (char const* name);
│ │ │ │ void delete_peer_class (peer_class_t cid);
│ │ │ │ peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │ void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │ - void apply_settings (settings_pack const&);
│ │ │ │ - settings_pack get_settings () const;
│ │ │ │ void apply_settings (settings_pack&&);
│ │ │ │ - void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ + settings_pack get_settings () const;
│ │ │ │ + void apply_settings (settings_pack const&);
│ │ │ │ alert* wait_for_alert (time_duration max_wait);
│ │ │ │ + void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ std::vector<port_mapping_t> add_port_mapping (portmap_protocol t, int external_port, int local_port);
│ │ │ │ void delete_port_mapping (port_mapping_t handle);
│ │ │ │ void reopen_network_sockets (reopen_network_flags_t options = reopen_map_ports);
│ │ │ │ std::shared_ptr<aux::session_impl> native_handle () const;
│ │ │ │
│ │ │ │ static constexpr save_state_flags_t save_settings = 0_bit;
│ │ │ │ @@ -2444,24 +2444,24 @@
│ │ │ │ returns the current session state. This can be passed to
│ │ │ │ write_session_params() to save the state to disk and restored using
│ │ │ │ read_session_params() when constructing a new session. The kind of
│ │ │ │ state that's included is all settings, the DHT routing table, possibly
│ │ │ │ plugin-specific state.
│ │ │ │ the flags parameter can be used to only save certain parts of the
│ │ │ │ session state
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ +void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ + , status_flags_t flags = {}) const;
│ │ │ │ std::vector<torrent_status> get_torrent_status (
│ │ │ │ std::function<bool(torrent_status const&)> const& pred
│ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ -void refresh_torrent_status (std::vector<torrent_status>* ret
│ │ │ │ - , status_flags_t flags = {}) const;
│ │ │ │
│ │ │ │ Note
│ │ │ │these calls are potentially expensive and won't scale well with │ │ │ │ lots of torrents. If you're concerned about performance, consider │ │ │ │ using post_torrent_updates() instead.
│ │ │ ││ │ │ │ void set_dht_state (dht::dht_state&& st); │ │ │ │ void set_dht_state (dht::dht_state const& st); │ │ │ ││ │ │ │
set the DHT state for the session. This will be taken into account the │ │ │ │ next time the DHT is started, as if it had been passed in via the │ │ │ │ session_params on startup.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ torrent_handle find_torrent (sha1_hash const& info_hash) const; │ │ │ │ std::vector<torrent_handle> get_torrents () const; │ │ │ ││ │ │ │
find_torrent() looks for a torrent with the given info-hash. In │ │ │ │ case there is such a torrent in the session, a torrent_handle to that │ │ │ │ torrent is returned. In case the torrent cannot be found, an invalid │ │ │ │ torrent_handle is returned.
│ │ │ │See torrent_handle::is_valid() to know if the torrent was found or │ │ │ │ not.
│ │ │ │get_torrents() returns a vector of torrent_handles to all the │ │ │ │ torrents currently in the session.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params); │ │ │ │ -void async_add_torrent (add_torrent_params&& params); │ │ │ │ -torrent_handle add_torrent (add_torrent_params&& params, error_code& ec); │ │ │ │ torrent_handle add_torrent (add_torrent_params const& params); │ │ │ │ torrent_handle add_torrent (add_torrent_params const& params, error_code& ec); │ │ │ │ void async_add_torrent (add_torrent_params const& params); │ │ │ │ +void async_add_torrent (add_torrent_params&& params); │ │ │ │ +torrent_handle add_torrent (add_torrent_params&& params, error_code& ec); │ │ │ ││ │ │ │
You add torrents through the add_torrent() function where you give an │ │ │ │ object with all the parameters. The add_torrent() overloads will block │ │ │ │ until the torrent has been added (or failed to be added) and returns │ │ │ │ an error code and a torrent_handle. In order to add torrents more │ │ │ │ efficiently, consider using async_add_torrent() which returns │ │ │ │ immediately, without waiting for the torrent to add. Notification of │ │ │ │ @@ -2585,23 +2585,23 @@ │ │ │ │ want to control are torrent_flags::paused and │ │ │ │ torrent_flags::auto_managed. In order to add a magnet link that will │ │ │ │ just download the metadata, but no payload, set the │ │ │ │ torrent_flags::upload_mode flag.
│ │ │ │Special consideration has to be taken when adding hybrid torrents │ │ │ │ (i.e. torrents that are BitTorrent v2 torrents that are backwards │ │ │ │ compatible with v1). For more details, see BitTorrent v2 torrents.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -void pause (); │ │ │ │ -bool is_paused () const; │ │ │ │ void resume (); │ │ │ │ +bool is_paused () const; │ │ │ │ +void pause (); │ │ │ ││ │ │ │
Pausing the session has the same effect as pausing every torrent in │ │ │ │ it, except that torrents will not be resumed by the auto-manage │ │ │ │ mechanism. Resuming will restore the torrents to their previous paused │ │ │ │ state. i.e. the session pause state is separate from the torrent pause │ │ │ │ state. A torrent is inactive if it is paused or if the session is │ │ │ │ paused.
│ │ │ │ @@ -2709,21 +2709,21 @@ │ │ │ │ with the function object's context and make the function entirely │ │ │ │ self-contained. The only reason data blob's value is computed │ │ │ │ via a function instead of just passing in the new value is to avoid │ │ │ │ race conditions. If you want to update the value in the DHT, you │ │ │ │ must first retrieve it, then modify it, then write it back. The way │ │ │ │ the DHT works, it is natural to always do a lookup before storing and │ │ │ │ calling the callback in between is convenient. │ │ │ │ - │ │ │ │ -[report issue]
│ │ │ │ -void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │ void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │ +void dht_get_peers (sha1_hash const& info_hash);
│ │ │ │
│ │ │ │ dht_get_peers() will issue a DHT get_peer request to the DHT for the │ │ │ │ specified info-hash. The response (the peers) will be posted back in a │ │ │ │ dht_get_peers_reply_alert.
│ │ │ │dht_announce() will issue a DHT announce request to the DHT to the │ │ │ │ specified info-hash, advertising the specified port. If the port is │ │ │ │ left at its default, 0, the port will be implied by the DHT message's │ │ │ │ @@ -2830,34 +2830,34 @@ │ │ │ │
│ │ │ │ void set_port_filter (port_filter const& f); │ │ │ ││ │ │ │
apply port_filter f to incoming and outgoing peers. a port filter │ │ │ │ will reject making outgoing peer connections to certain remote ports. │ │ │ │ The main intention is to be able to avoid triggering certain │ │ │ │ anti-virus software by connecting to SMTP, FTP ports.
│ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -bool is_listening () const; │ │ │ │ unsigned short listen_port () const; │ │ │ │ unsigned short ssl_listen_port () const; │ │ │ │ +bool is_listening () const; │ │ │ ││ │ │ │
is_listening() will tell you whether or not the session has │ │ │ │ successfully opened a listening port. If it hasn't, this function will │ │ │ │ return false, and then you can set a new │ │ │ │ settings_pack::listen_interfaces to try another interface and port to │ │ │ │ bind to.
│ │ │ │listen_port() returns the port we ended up listening on.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ void set_peer_class_filter (ip_filter const& f); │ │ │ │ ip_filter get_peer_class_filter () const; │ │ │ ││ │ │ │
Sets the peer class filter for this session. All new peer connections │ │ │ │ will take this into account and be added to the peer classes specified │ │ │ │ by this filter, based on the peer's IP address.
│ │ │ │ @@ -2933,18 +2933,18 @@ │ │ │ │ remove the peer class if it's still assigned to torrents or peers. It │ │ │ │ will however remove it once the last peer and torrent drops their │ │ │ │ references to it. │ │ │ │There is no need to call this function for custom peer classes. All │ │ │ │ peer classes will be properly destructed when the session object │ │ │ │ destructs.
│ │ │ │For more information on peer classes, see peer classes.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ peer_class_info get_peer_class (peer_class_t cid) const; │ │ │ │ void set_peer_class (peer_class_t cid, peer_class_info const& pci); │ │ │ ││ │ │ │
These functions queries information from a peer class and updates the │ │ │ │ configuration of a peer class, respectively.
│ │ │ │cid must refer to an existing peer class. If it does not, the │ │ │ │ @@ -2992,29 +2992,29 @@ │ │ │ │ advised to remove them from the back of the queue, to minimize the │ │ │ │ shifting.
│ │ │ │ │ │ │ │ [report issue]│ │ │ │ -void apply_settings (settings_pack const&); │ │ │ │ -settings_pack get_settings () const; │ │ │ │ void apply_settings (settings_pack&&); │ │ │ │ +settings_pack get_settings () const; │ │ │ │ +void apply_settings (settings_pack const&); │ │ │ ││ │ │ │
Applies the settings specified by the settings_pack s. This is an │ │ │ │ asynchronous operation that will return immediately and actually apply │ │ │ │ the settings to the main thread of libtorrent some time later.
│ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -void set_alert_notify (std::function<void()> const& fun); │ │ │ │ alert* wait_for_alert (time_duration max_wait); │ │ │ │ +void set_alert_notify (std::function<void()> const& fun); │ │ │ │ void pop_alerts (std::vector<alert*>* alerts); │ │ │ ││ │ │ │
Alerts is the main mechanism for libtorrent to report errors and │ │ │ │ events. pop_alerts fills in the vector passed to it with pointers │ │ │ │ to new alerts. The session still owns these alerts and they will stay │ │ │ │ valid until the next time pop_alerts is called. You may not delete │ │ │ │ the alert objects.
│ │ │ │ @@ -3141,20 +3141,20 @@ │ │ │ │ [report issue]Declared in "libtorrent/session_params.hpp"
│ │ │ ││ │ │ │ entry write_session_params (session_params const& sp │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ session_params read_session_params (span<char const> buf │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all()); │ │ │ │ std::vector<char> write_session_params_buf (session_params const& sp │ │ │ │ @@ -3292,35 +3292,35 @@ │ │ │ ││ │ │ ││ │ │ │ - │ │ │ │ +torrent_info
│ │ │ │Declared in "libtorrent/torrent_info.hpp"
│ │ │ │the torrent_info class holds the information found in a .torrent file.
│ │ │ ││ │ │ │ class torrent_info │ │ │ │ { │ │ │ │ + torrent_info (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ + torrent_info (span<char const> buffer, error_code& ec, from_span_t); │ │ │ │ + torrent_info (std::string const& filename, error_code& ec); │ │ │ │ torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t); │ │ │ │ torrent_info (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ - torrent_info (span<char const> buffer, error_code& ec, from_span_t); │ │ │ │ - explicit torrent_info (info_hash_t const& info_hash); │ │ │ │ explicit torrent_info (std::string const& filename); │ │ │ │ - torrent_info (char const* buffer, int size); │ │ │ │ torrent_info (char const* buffer, int size, error_code& ec); │ │ │ │ - torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ - explicit torrent_info (span<char const> buffer, from_span_t); │ │ │ │ + torrent_info (char const* buffer, int size); │ │ │ │ + explicit torrent_info (info_hash_t const& info_hash); │ │ │ │ torrent_info (torrent_info const& t); │ │ │ │ - torrent_info (std::string const& filename, error_code& ec); │ │ │ │ - torrent_info (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ explicit torrent_info (bdecode_node const& torrent_file); │ │ │ │ + explicit torrent_info (span<char const> buffer, from_span_t); │ │ │ │ ~torrent_info (); │ │ │ │ file_storage const& orig_files () const; │ │ │ │ file_storage const& files () const; │ │ │ │ void rename_file (file_index_t index, std::string const& new_filename); │ │ │ │ void remap_files (file_storage const& f); │ │ │ │ + void clear_trackers (); │ │ │ │ void add_tracker (std::string const& url, int tier │ │ │ │ , announce_entry::tracker_source source); │ │ │ │ - void clear_trackers (); │ │ │ │ void add_tracker (std::string const& url, int tier = 0); │ │ │ │ std::vector<announce_entry> const& trackers () const; │ │ │ │ std::vector<std::string> collections () const; │ │ │ │ std::vector<sha1_hash> similar_torrents () const; │ │ │ │ void add_url_seed (std::string const& url │ │ │ │ , std::string const& ext_auth = std::string() │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t()); │ │ │ │ @@ -3328,32 +3328,32 @@ │ │ │ │ void add_http_seed (std::string const& url │ │ │ │ , std::string const& extern_auth = std::string() │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t()); │ │ │ │ void set_web_seeds (std::vector<web_seed_entry> seeds); │ │ │ │ std::int64_t total_size () const; │ │ │ │ int piece_length () const; │ │ │ │ int num_pieces () const; │ │ │ │ + piece_index_t last_piece () const; │ │ │ │ index_range<piece_index_t> piece_range () const; │ │ │ │ piece_index_t end_piece () const; │ │ │ │ - piece_index_t last_piece () const; │ │ │ │ sha1_hash info_hash () const noexcept; │ │ │ │ info_hash_t const& info_hashes () const; │ │ │ │ - bool v2 () const; │ │ │ │ bool v1 () const; │ │ │ │ + bool v2 () const; │ │ │ │ int num_files () const; │ │ │ │ std::vector<file_slice> map_block (piece_index_t const piece │ │ │ │ , std::int64_t offset, int size) const; │ │ │ │ peer_request map_file (file_index_t const file, std::int64_t offset, int size) const; │ │ │ │ string_view ssl_cert () const; │ │ │ │ bool is_valid () const; │ │ │ │ bool priv () const; │ │ │ │ bool is_i2p () const; │ │ │ │ int piece_size (piece_index_t index) const; │ │ │ │ - sha1_hash hash_for_piece (piece_index_t index) const; │ │ │ │ char const* hash_for_piece_ptr (piece_index_t const index) const; │ │ │ │ + sha1_hash hash_for_piece (piece_index_t index) const; │ │ │ │ bool is_loaded () const; │ │ │ │ const std::string& name () const; │ │ │ │ std::time_t creation_date () const; │ │ │ │ const std::string& creator () const; │ │ │ │ const std::string& comment () const; │ │ │ │ std::vector<std::pair<std::string, int>> const& nodes () const; │ │ │ │ void add_node (std::pair<std::string, int> const& node); │ │ │ │ @@ -3363,27 +3363,27 @@ │ │ │ │ span<char const> piece_layer (file_index_t) const; │ │ │ │ void free_piece_layers (); │ │ │ │ }; │ │ │ ││ │ │ │ [report issue]│ │ │ ││ │ │ │torrent_info()
│ │ │ ││ │ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ +torrent_info (span<char const> buffer, error_code& ec, from_span_t); │ │ │ │ +torrent_info (std::string const& filename, error_code& ec); │ │ │ │ torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t); │ │ │ │ torrent_info (bdecode_node const& torrent_file, error_code& ec); │ │ │ │ -torrent_info (span<char const> buffer, error_code& ec, from_span_t); │ │ │ │ -explicit torrent_info (info_hash_t const& info_hash); │ │ │ │ explicit torrent_info (std::string const& filename); │ │ │ │ -torrent_info (char const* buffer, int size); │ │ │ │ torrent_info (char const* buffer, int size, error_code& ec); │ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ -explicit torrent_info (span<char const> buffer, from_span_t); │ │ │ │ +torrent_info (char const* buffer, int size); │ │ │ │ +explicit torrent_info (info_hash_t const& info_hash); │ │ │ │ torrent_info (torrent_info const& t); │ │ │ │ -torrent_info (std::string const& filename, error_code& ec); │ │ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ explicit torrent_info (bdecode_node const& torrent_file); │ │ │ │ +explicit torrent_info (span<char const> buffer, from_span_t); │ │ │ ││ │ │ │The constructor that takes an info-hash will initialize the info-hash │ │ │ │ to the given value, but leave all other fields empty. This is used │ │ │ │ internally when downloading torrents without the metadata. The │ │ │ │ metadata will be created by libtorrent as soon as it has been │ │ │ │ downloaded from the swarm.
│ │ │ │The constructor that takes a bdecode_node will create a torrent_info │ │ │ │ @@ -3412,18 +3412,18 @@ │ │ │ │ [report issue]
│ │ │ ││ │ │ │ - │ │ │ │ +~torrent_info()
│ │ │ ││ │ │ │ ~torrent_info (); │ │ │ ││ │ │ │frees all storage associated with this torrent_info object
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ +│ │ │ │files() orig_files()
│ │ │ ││ │ │ │ file_storage const& orig_files () const; │ │ │ │ file_storage const& files () const; │ │ │ ││ │ │ │The file_storage object contains the information on how to map the │ │ │ │ pieces to files. It is separated from the torrent_info object because │ │ │ │ when creating torrents a storage object needs to be created without │ │ │ │ @@ -3470,23 +3470,23 @@ │ │ │ │
Remaps the file storage to a new file layout. This can be used to, for │ │ │ │ instance, download all data in a torrent to a single file, or to a │ │ │ │ number of fixed size sector aligned files, regardless of the number │ │ │ │ and sizes of the files in the torrent.
│ │ │ │The new specified file_storage must have the exact same size as │ │ │ │ the current one.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ +│ │ │ │ -add_tracker() clear_trackers() trackers()
│ │ │ ││ │ │ │ +void clear_trackers (); │ │ │ │ void add_tracker (std::string const& url, int tier │ │ │ │ , announce_entry::tracker_source source); │ │ │ │ -void clear_trackers (); │ │ │ │ void add_tracker (std::string const& url, int tier = 0); │ │ │ │ std::vector<announce_entry> const& trackers () const; │ │ │ ││ │ │ │add_tracker() adds a tracker to the announce-list. The tier │ │ │ │ determines the order in which the trackers are to be tried. │ │ │ │ The trackers() function will return a sorted vector of │ │ │ │ announce_entry. Each announce entry contains a string, which is │ │ │ │ @@ -3505,20 +3505,20 @@ │ │ │ │ std::vector<sha1_hash> similar_torrents () const; │ │ │ │ │ │ │ │
These two functions are related to BEP 38 (mutable torrents). The │ │ │ │ vectors returned from these correspond to the "similar" and │ │ │ │ "collections" keys in the .torrent file. Both info-hashes and │ │ │ │ collections from within the info-dict and from outside of it are │ │ │ │ included.
│ │ │ │ - │ │ │ │ │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -│ │ │ │ +add_http_seed() set_web_seeds() add_url_seed() web_seeds()
│ │ │ │ + │ │ │ │ +[report issue]│ │ │ │ +│ │ │ │ - │ │ │ │ +set_web_seeds() add_url_seed() add_http_seed() web_seeds()
│ │ │ ││ │ │ │ void add_url_seed (std::string const& url │ │ │ │ , std::string const& ext_auth = std::string() │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t()); │ │ │ │ std::vector<web_seed_entry> const& web_seeds () const; │ │ │ │ void add_http_seed (std::string const& url │ │ │ │ , std::string const& extern_auth = std::string() │ │ │ │ @@ -3547,63 +3547,63 @@ │ │ │ │ std::int64_t total_size () const; │ │ │ ││ │ │ │total_size() returns the total number of bytes the torrent-file │ │ │ │ represents. Note that this is the number of pieces times the piece │ │ │ │ size (modulo the last piece possibly being smaller). With pad files, │ │ │ │ the total size will be larger than the sum of all (regular) file │ │ │ │ sizes.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ +│ │ │ │ - │ │ │ │ +piece_length() num_pieces()
│ │ │ ││ │ │ │ int piece_length () const; │ │ │ │ int num_pieces () const; │ │ │ ││ │ │ │piece_length() and num_pieces() returns the number of byte │ │ │ │ for each piece and the total number of pieces, respectively. The │ │ │ │ difference between piece_size() and piece_length() is that │ │ │ │ piece_size() takes the piece index as argument and gives you the │ │ │ │ exact size of that piece. It will always be the same as │ │ │ │ piece_length() except in the case of the last piece, which may be │ │ │ │ smaller.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ +│ │ │ │ - │ │ │ │ +last_piece() end_piece() piece_range()
│ │ │ ││ │ │ │ +piece_index_t last_piece () const; │ │ │ │ index_range<piece_index_t> piece_range () const; │ │ │ │ piece_index_t end_piece () const; │ │ │ │ -piece_index_t last_piece () const; │ │ │ ││ │ │ │last_piece() returns the index to the last piece in the torrent and │ │ │ │ end_piece() returns the index to the one-past-end piece in the │ │ │ │ torrent │ │ │ │ piece_range() returns an implementation-defined type that can be │ │ │ │ used as the container in a range-for loop. Where the values are the │ │ │ │ indices of all pieces in the file_storage.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ +│ │ │ │info_hashes() info_hash()
│ │ │ ││ │ │ │ sha1_hash info_hash () const noexcept; │ │ │ │ info_hash_t const& info_hashes () const; │ │ │ ││ │ │ │returns the info-hash of the torrent. For BitTorrent v2 support, use │ │ │ │ info_hashes() to get an object that may hold both a v1 and v2 │ │ │ │ info-hash
│ │ │ │ │ │ │ │ [report issue]│ │ │ ││ │ │ │v1() v2()
│ │ │ ││ │ │ │ -bool v2 () const; │ │ │ │ bool v1 () const; │ │ │ │ +bool v2 () const; │ │ │ ││ │ │ │returns whether this torrent has v1 and/or v2 metadata, respectively. │ │ │ │ Hybrid torrents have both. These are shortcuts for │ │ │ │ info_hashes().has_v1() and info_hashes().has_v2() calls.
│ │ │ │ [report issue]│ │ │ ││ │ │ │num_files()
│ │ │ │ @@ -3676,21 +3676,21 @@ │ │ │ ││ │ │ ││ │ │ │ - │ │ │ │ +piece_size()
│ │ │ ││ │ │ │ int piece_size (piece_index_t index) const; │ │ │ ││ │ │ │returns the piece size of file with index. This will be the same as piece_length(), │ │ │ │ except for the last piece, which may be shorter.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ +│ │ │ │ @@ -4286,20 +4286,20 @@ │ │ │ │hash_for_piece_ptr() hash_for_piece()
│ │ │ ││ │ │ │ -sha1_hash hash_for_piece (piece_index_t index) const; │ │ │ │ char const* hash_for_piece_ptr (piece_index_t const index) const; │ │ │ │ +sha1_hash hash_for_piece (piece_index_t index) const; │ │ │ ││ │ │ │hash_for_piece() takes a piece-index and returns the 20-bytes │ │ │ │ sha1-hash for that piece and info_hash() returns the 20-bytes │ │ │ │ sha1-hash for the info-section of the torrent file. │ │ │ │ hash_for_piece_ptr() returns a pointer to the 20 byte sha1 digest │ │ │ │ for the piece. Note that the string is not 0-terminated.
│ │ │ │ [report issue]Note
│ │ │ │If has_v2() is false then the v1 hash might actually be a truncated │ │ │ │ v2 hash
│ │ │ ││ │ │ │ struct info_hash_t │ │ │ │ { │ │ │ │ - explicit info_hash_t (sha256_hash h2) noexcept; │ │ │ │ - info_hash_t () noexcept = default; │ │ │ │ explicit info_hash_t (sha1_hash h1) noexcept; │ │ │ │ + info_hash_t () noexcept = default; │ │ │ │ info_hash_t (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ - bool has (protocol_version v) const; │ │ │ │ + explicit info_hash_t (sha256_hash h2) noexcept; │ │ │ │ bool has_v2 () const; │ │ │ │ + bool has (protocol_version v) const; │ │ │ │ bool has_v1 () const; │ │ │ │ sha1_hash get (protocol_version v) const; │ │ │ │ sha1_hash get_best () const; │ │ │ │ friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs); │ │ │ │ friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept; │ │ │ │ template <typename F> void for_each (F f) const; │ │ │ │ bool operator< (info_hash_t const& o) const; │ │ │ │ @@ -4308,32 +4308,32 @@ │ │ │ │ sha1_hash v1; │ │ │ │ sha256_hash v2; │ │ │ │ }; │ │ │ ││ │ │ │ [report issue]│ │ │ ││ │ │ │info_hash_t()
│ │ │ ││ │ │ │ -explicit info_hash_t (sha256_hash h2) noexcept; │ │ │ │ -info_hash_t () noexcept = default; │ │ │ │ explicit info_hash_t (sha1_hash h1) noexcept; │ │ │ │ +info_hash_t () noexcept = default; │ │ │ │ info_hash_t (sha1_hash h1, sha256_hash h2) noexcept; │ │ │ │ +explicit info_hash_t (sha256_hash h2) noexcept; │ │ │ ││ │ │ │The default constructor creates an object that has neither a v1 or v2 │ │ │ │ hash.
│ │ │ │For backwards compatibility, make it possible to construct directly │ │ │ │ from a v1 hash. This constructor allows implicit conversion from a │ │ │ │ v1 hash, but the implicitness is deprecated.
│ │ │ │ │ │ │ │ │ │ │ │ [report issue]│ │ │ ││ │ │ │has() has_v1() has_v2()
│ │ │ ││ │ │ │ -bool has (protocol_version v) const; │ │ │ │ bool has_v2 () const; │ │ │ │ +bool has (protocol_version v) const; │ │ │ │ bool has_v1 () const; │ │ │ ││ │ │ │returns true if the corresponding info hash is present in this │ │ │ │ object.
│ │ │ │ [report issue]│ │ │ ││ │ │ │ + │ │ │ │ +[report issue]get()
│ │ │ │ @@ -4410,34 +4410,34 @@ │ │ │ │start │ │ │ │The byte offset within that piece where the range starts. │ │ │ │ │ │ │ │ [report issue]│ │ │ │
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]- length
│ │ │ │- The size of the range, in bytes.
│ │ │ │
Declared in "libtorrent/load_torrent.hpp"
│ │ │ ││ │ │ │ -add_torrent_params load_torrent_parsed ( │ │ │ │ - bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ -add_torrent_params load_torrent_buffer ( │ │ │ │ - span<char const> buffer, load_torrent_limits const& cfg); │ │ │ │ add_torrent_params load_torrent_file ( │ │ │ │ std::string const& filename, load_torrent_limits const& cfg); │ │ │ │ +add_torrent_params load_torrent_buffer ( │ │ │ │ + span<char const> buffer, load_torrent_limits const& cfg); │ │ │ │ +add_torrent_params load_torrent_parsed ( │ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg); │ │ │ │ +add_torrent_params load_torrent_parsed ( │ │ │ │ + bdecode_node const& torrent_file); │ │ │ │ add_torrent_params load_torrent_file ( │ │ │ │ std::string const& filename); │ │ │ │ add_torrent_params load_torrent_buffer ( │ │ │ │ span<char const> buffer); │ │ │ │ -add_torrent_params load_torrent_parsed ( │ │ │ │ - bdecode_node const& torrent_file); │ │ │ ││ │ │ │
These functions load the content of a .torrent file into an │ │ │ │ add_torrent_params object. │ │ │ │ The immutable part of a torrent file (the info-dictionary) is stored in │ │ │ │ the ti field in the add_torrent_params object (as a torrent_info │ │ │ │ object). │ │ │ │ The returned object is suitable to be:
│ │ │ │ @@ -4449,16 +4449,16 @@ │ │ │ │ │ │ │ │ │ │ │ │ [report issue]Declared in "libtorrent/magnet_uri.hpp"
│ │ │ ││ │ │ │ -std::string make_magnet_uri (torrent_handle const& handle); │ │ │ │ std::string make_magnet_uri (torrent_info const& info); │ │ │ │ +std::string make_magnet_uri (torrent_handle const& handle); │ │ │ │ std::string make_magnet_uri (add_torrent_params const& atp); │ │ │ ││ │ │ │
Generates a magnet URI from the specified torrent.
│ │ │ │Several fields from the add_torrent_params objects are recorded in the │ │ │ │ magnet link. In order to not include them, they have to be cleared before │ │ │ │ calling make_magnet_uri(). These fields are used:
│ │ │ ││ │ │ │ @@ -4479,17 +4479,17 @@ │ │ │ │ an empty string is returned. │ │ │ │For more information about magnet links, see magnet links.
│ │ │ │ [report issue]
Declared in "libtorrent/magnet_uri.hpp"
│ │ │ ││ │ │ │ +void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec); │ │ │ │ add_torrent_params parse_magnet_uri (string_view uri); │ │ │ │ add_torrent_params parse_magnet_uri (string_view uri, error_code& ec); │ │ │ │ -void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec); │ │ │ ││ │ │ │
This function parses out information from the magnet link and populates the │ │ │ │ add_torrent_params object. The overload that does not take an │ │ │ │ error_code reference will throw a system_error on error │ │ │ │ The overload taking an add_torrent_params reference will fill in the │ │ │ │ fields specified in the magnet URI.
│ │ │ │ [report issue]Torrent plugins are associated with a single torrent and have a number │ │ │ │ of functions called at certain events. Many of its functions have the │ │ │ │ ability to change or override the default libtorrent behavior.
│ │ │ │
│ │ │ │ struct torrent_plugin
│ │ │ │ {
│ │ │ │ virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ │ - virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void on_piece_pass (piece_index_t);
│ │ │ │ + virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void tick ();
│ │ │ │ virtual bool on_pause ();
│ │ │ │ virtual bool on_resume ();
│ │ │ │ virtual void on_files_checked ();
│ │ │ │ virtual void on_state (torrent_status::state_t);
│ │ │ │ virtual void on_add_peer (tcp::endpoint const&,
│ │ │ │ peer_source_flags_t, add_peer_flags_t);
│ │ │ │ @@ -5311,33 +5311,33 @@
│ │ │ │ to it, use weak_ptr.
│ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │
│ │ │ │ [report issue]│ │ │ │ -virtual void on_piece_failed (piece_index_t); │ │ │ │ virtual void on_piece_pass (piece_index_t); │ │ │ │ +virtual void on_piece_failed (piece_index_t); │ │ │ ││ │ │ │
These hooks are called when a piece passes the hash check or fails the hash │ │ │ │ check, respectively. The index is the piece index that was downloaded. │ │ │ │ It is possible to access the list of peers that participated in sending the │ │ │ │ piece through the torrent and the piece_picker.
│ │ │ │ [report issue]│ │ │ │ virtual void tick (); │ │ │ ││ │ │ │
This hook is called approximately once per second. It is a way of making it │ │ │ │ easy for plugins to do timed events, for sending messages or whatever.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ virtual bool on_pause (); │ │ │ │ virtual bool on_resume (); │ │ │ ││ │ │ │
These hooks are called when the torrent is paused and resumed respectively. │ │ │ │ The return value indicates if the event was handled. A return value of │ │ │ │ true indicates that it was handled, and no other plugin after this one │ │ │ │ @@ -5405,51 +5405,51 @@ │ │ │ │ { │ │ │ │ virtual string_view type () const; │ │ │ │ virtual void add_handshake (entry&); │ │ │ │ virtual void on_disconnect (error_code const&); │ │ │ │ virtual void on_connected (); │ │ │ │ virtual bool on_handshake (span<char const>); │ │ │ │ virtual bool on_extension_handshake (bdecode_node const&); │ │ │ │ - virtual bool on_have_all (); │ │ │ │ - virtual bool on_unchoke (); │ │ │ │ - virtual bool on_choke (); │ │ │ │ - virtual bool on_interested (); │ │ │ │ - virtual bool on_request (peer_request const&); │ │ │ │ - virtual bool on_bitfield (bitfield const& /*bitfield*/); │ │ │ │ virtual bool on_not_interested (); │ │ │ │ - virtual bool on_have (piece_index_t); │ │ │ │ + virtual bool on_have_none (); │ │ │ │ virtual bool on_dont_have (piece_index_t); │ │ │ │ + virtual bool on_have (piece_index_t); │ │ │ │ virtual bool on_allowed_fast (piece_index_t); │ │ │ │ - virtual bool on_have_none (); │ │ │ │ + virtual bool on_interested (); │ │ │ │ + virtual bool on_bitfield (bitfield const& /*bitfield*/); │ │ │ │ + virtual bool on_choke (); │ │ │ │ + virtual bool on_request (peer_request const&); │ │ │ │ + virtual bool on_have_all (); │ │ │ │ + virtual bool on_unchoke (); │ │ │ │ virtual bool on_piece (peer_request const& /*piece*/ │ │ │ │ , span<char const> /*buf*/); │ │ │ │ - virtual bool on_cancel (peer_request const&); │ │ │ │ - virtual bool on_reject (peer_request const&); │ │ │ │ virtual bool on_suggest (piece_index_t); │ │ │ │ - virtual void sent_cancel (peer_request const&); │ │ │ │ - virtual void sent_have_all (); │ │ │ │ + virtual bool on_reject (peer_request const&); │ │ │ │ + virtual bool on_cancel (peer_request const&); │ │ │ │ virtual void sent_suggest (piece_index_t); │ │ │ │ + virtual void sent_reject_request (peer_request const&); │ │ │ │ + virtual void sent_request (peer_request const&); │ │ │ │ + virtual void sent_have_all (); │ │ │ │ + virtual void sent_cancel (peer_request const&); │ │ │ │ virtual void sent_choke (); │ │ │ │ virtual void sent_have_none (); │ │ │ │ virtual void sent_allow_fast (piece_index_t); │ │ │ │ - virtual void sent_reject_request (peer_request const&); │ │ │ │ - virtual void sent_request (peer_request const&); │ │ │ │ - virtual void sent_not_interested (); │ │ │ │ virtual void sent_unchoke (); │ │ │ │ virtual void sent_interested (); │ │ │ │ + virtual void sent_not_interested (); │ │ │ │ virtual void sent_have (piece_index_t); │ │ │ │ virtual void sent_piece (peer_request const&); │ │ │ │ virtual void sent_payload (int /* bytes */); │ │ │ │ virtual bool can_disconnect (error_code const& /*ec*/); │ │ │ │ virtual bool on_extended (int /*length*/, int /*msg*/, │ │ │ │ span<char const> /*body*/); │ │ │ │ virtual bool on_unknown_message (int /*length*/, int /*msg*/, │ │ │ │ span<char const> /*body*/); │ │ │ │ - virtual void on_piece_failed (piece_index_t); │ │ │ │ virtual void on_piece_pass (piece_index_t); │ │ │ │ + virtual void on_piece_failed (piece_index_t); │ │ │ │ virtual void tick (); │ │ │ │ virtual bool write_request (peer_request const&); │ │ │ │ }; │ │ │ │ │ │ │ │ [report issue]
│ │ │ │ @@ -5499,39 +5499,39 @@ │ │ │ │ virtual bool on_extension_handshake (bdecode_node const&); │ │ │ ││ │ │ │
called when the extension handshake from the other end is received │ │ │ │ if this returns false, it means that this extension isn't │ │ │ │ supported by this peer. It will result in this peer_plugin │ │ │ │ being removed from the peer_connection and destructed. │ │ │ │ this is not called for web seeds
│ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -virtual bool on_have_all (); │ │ │ │ -virtual bool on_unchoke (); │ │ │ │ -virtual bool on_choke (); │ │ │ │ -virtual bool on_interested (); │ │ │ │ -virtual bool on_request (peer_request const&); │ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/); │ │ │ │ virtual bool on_not_interested (); │ │ │ │ -virtual bool on_have (piece_index_t); │ │ │ │ +virtual bool on_have_none (); │ │ │ │ virtual bool on_dont_have (piece_index_t); │ │ │ │ +virtual bool on_have (piece_index_t); │ │ │ │ virtual bool on_allowed_fast (piece_index_t); │ │ │ │ -virtual bool on_have_none (); │ │ │ │ +virtual bool on_interested (); │ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/); │ │ │ │ +virtual bool on_choke (); │ │ │ │ +virtual bool on_request (peer_request const&); │ │ │ │ +virtual bool on_have_all (); │ │ │ │ +virtual bool on_unchoke (); │ │ │ ││ │ │ │
returning true from any of the message handlers │ │ │ │ indicates that the plugin has handled the message. │ │ │ │ it will break the plugin chain traversing and not let │ │ │ │ anyone else handle the message, including the default │ │ │ │ handler.
│ │ │ │ [report issue]This function is called when the peer connection is receiving │ │ │ │ a piece. buf points (non-owning pointer) to the data in an │ │ │ │ internal immutable disk buffer. The length of the data is specified │ │ │ │ in the length member of the piece parameter. │ │ │ │ returns true to indicate that the piece is handled and the │ │ │ │ rest of the logic should be ignored.
│ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -virtual void sent_not_interested (); │ │ │ │ virtual void sent_unchoke (); │ │ │ │ virtual void sent_interested (); │ │ │ │ +virtual void sent_not_interested (); │ │ │ │ virtual void sent_have (piece_index_t); │ │ │ │ virtual void sent_piece (peer_request const&); │ │ │ ││ │ │ │
called after a choke message has been sent to the peer
│ │ │ │ [report issue]this is not called for web seeds
│ │ │ │ │ │ │ │ [report issue]│ │ │ │ -virtual void on_piece_failed (piece_index_t); │ │ │ │ virtual void on_piece_pass (piece_index_t); │ │ │ │ +virtual void on_piece_failed (piece_index_t); │ │ │ ││ │ │ │
called when a piece that this peer participated in either │ │ │ │ fails or passes the hash_check
│ │ │ │ [report issue]│ │ │ │ @@ -5633,16 +5633,16 @@ │ │ │ │
Declared in "libtorrent/extensions.hpp"
│ │ │ │
│ │ │ │ struct crypto_plugin
│ │ │ │ {
│ │ │ │ - virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │ virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │ + virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │ encrypt (span<span<char>> /*send_vec*/) = 0;
│ │ │ │ virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ @@ -5666,50 +5666,50 @@
│ │ │ │ connection object, to be used by plugins. This is a low level interface that
│ │ │ │ may not be stable across libtorrent versions
│ │ │ │
│ │ │ │ struct peer_connection_handle
│ │ │ │ {
│ │ │ │ explicit peer_connection_handle (std::weak_ptr<peer_connection> impl);
│ │ │ │ connection_type type () const;
│ │ │ │ - void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ + void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ bool is_seed () const;
│ │ │ │ bool upload_only () const;
│ │ │ │ - peer_id const& pid () const;
│ │ │ │ bool has_piece (piece_index_t i) const;
│ │ │ │ + peer_id const& pid () const;
│ │ │ │ bool is_interesting () const;
│ │ │ │ bool is_choked () const;
│ │ │ │ - bool has_peer_choked () const;
│ │ │ │ bool is_peer_interested () const;
│ │ │ │ - void maybe_unchoke_this_peer ();
│ │ │ │ + bool has_peer_choked () const;
│ │ │ │ void choke_this_peer ();
│ │ │ │ + void maybe_unchoke_this_peer ();
│ │ │ │ void get_peer_info (peer_info& p) const;
│ │ │ │ torrent_handle associated_torrent () const;
│ │ │ │ - tcp::endpoint const& remote () const;
│ │ │ │ tcp::endpoint local_endpoint () const;
│ │ │ │ - bool is_connecting () const;
│ │ │ │ + tcp::endpoint const& remote () const;
│ │ │ │ bool is_outgoing () const;
│ │ │ │ + bool is_disconnecting () const;
│ │ │ │ + bool is_connecting () const;
│ │ │ │ void disconnect (error_code const& ec, operation_t op
│ │ │ │ , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ - bool is_disconnecting () const;
│ │ │ │ bool on_local_network () const;
│ │ │ │ bool ignore_unchoke_slots () const;
│ │ │ │ bool failed () const;
│ │ │ │ - bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ │ void peer_log (peer_log_alert::direction_t direction
│ │ │ │ , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT(4,5);
│ │ │ │ + bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ │ bool can_disconnect (error_code const& ec) const;
│ │ │ │ bool has_metadata () const;
│ │ │ │ bool in_handshake () const;
│ │ │ │ void send_buffer (char const* begin, int size);
│ │ │ │ time_point time_of_last_unchoke () const;
│ │ │ │ std::time_t last_seen_complete () const;
│ │ │ │ bool operator< (peer_connection_handle const& o) const;
│ │ │ │ - bool operator!= (peer_connection_handle const& o) const;
│ │ │ │ bool operator== (peer_connection_handle const& o) const;
│ │ │ │ + bool operator!= (peer_connection_handle const& o) const;
│ │ │ │ std::shared_ptr<peer_connection> native_handle () const;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ │ @@ -5719,16 +5719,16 @@ │ │ │ │
│ │ │ │ struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ {
│ │ │ │ explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │ bool support_extensions () const;
│ │ │ │ bool packet_finished () const;
│ │ │ │ bool supports_encryption () const;
│ │ │ │ - void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ + void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]Declared in "libtorrent/extensions/ut_pex.hpp"
│ │ │ │ @@ -5808,75 +5808,75 @@ │ │ │ │ size. Everything necessary to interpret a regular bittorrent storage │ │ │ │ file structure. │ │ │ │
│ │ │ │ class file_storage
│ │ │ │ {
│ │ │ │ bool is_valid () const;
│ │ │ │ void reserve (int num_files);
│ │ │ │ - void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ - void add_file_borrow (error_code& ec, string_view filename
│ │ │ │ + void add_file_borrow (string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ - void add_file_borrow (string_view filename
│ │ │ │ + void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ + void add_file_borrow (error_code& ec, string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │ std::vector<file_slice> map_block (piece_index_t piece, std::int64_t offset
│ │ │ │ , std::int64_t size) const;
│ │ │ │ peer_request map_file (file_index_t file, std::int64_t offset, int size) const;
│ │ │ │ int num_files () const noexcept;
│ │ │ │ file_index_t end_file () const noexcept;
│ │ │ │ index_range<file_index_t> file_range () const noexcept;
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ - void set_num_pieces (int n);
│ │ │ │ int num_pieces () const;
│ │ │ │ + void set_num_pieces (int n);
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │ int piece_length () const;
│ │ │ │ void set_piece_length (int l);
│ │ │ │ int piece_size (piece_index_t index) const;
│ │ │ │ int piece_size2 (piece_index_t index) const;
│ │ │ │ int blocks_in_piece2 (piece_index_t index) const;
│ │ │ │ std::string const& name () const;
│ │ │ │ void set_name (std::string const& n);
│ │ │ │ void swap (file_storage& ti) noexcept;
│ │ │ │ void canonicalize ();
│ │ │ │ - sha1_hash hash (file_index_t index) const;
│ │ │ │ - bool pad_file_at (file_index_t index) const;
│ │ │ │ sha256_hash root (file_index_t index) const;
│ │ │ │ char const* root_ptr (file_index_t const index) const;
│ │ │ │ - std::string symlink (file_index_t index) const;
│ │ │ │ - std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ - std::int64_t file_offset (file_index_t index) const;
│ │ │ │ - std::int64_t file_size (file_index_t index) const;
│ │ │ │ string_view file_name (file_index_t index) const;
│ │ │ │ + std::int64_t file_size (file_index_t index) const;
│ │ │ │ + std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ + std::string symlink (file_index_t index) const;
│ │ │ │ + sha1_hash hash (file_index_t index) const;
│ │ │ │ std::time_t mtime (file_index_t index) const;
│ │ │ │ + std::int64_t file_offset (file_index_t index) const;
│ │ │ │ + bool pad_file_at (file_index_t index) const;
│ │ │ │ + int file_num_pieces (file_index_t index) const;
│ │ │ │ index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ │ int file_num_blocks (file_index_t index) const;
│ │ │ │ - int file_num_pieces (file_index_t index) const;
│ │ │ │ int file_first_block_node (file_index_t index) const;
│ │ │ │ int file_first_piece_node (file_index_t index) const;
│ │ │ │ std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │ void all_path_hashes (std::unordered_set<std::uint32_t>& table) const;
│ │ │ │ file_flags_t file_flags (file_index_t index) const;
│ │ │ │ bool file_absolute_path (file_index_t index) const;
│ │ │ │ - file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │ file_index_t file_index_at_piece (piece_index_t piece) const;
│ │ │ │ + file_index_t file_index_at_offset (std::int64_t offset) const;
│ │ │ │ file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ piece_index_t piece_index_at_file (file_index_t f) const;
│ │ │ │ void sanitize_symlinks ();
│ │ │ │ bool v2 () const;
│ │ │ │
│ │ │ │ static constexpr file_flags_t flag_pad_file = 0_bit;
│ │ │ │ static constexpr file_flags_t flag_hidden = 1_bit;
│ │ │ │ @@ -5903,28 +5903,28 @@
│ │ │ │ be used to avoid reallocating the internal file list when the number
│ │ │ │ of files to be added is known up-front.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ -void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ - , file_flags_t file_flags = {}
│ │ │ │ - , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ - , char const* root_hash = nullptr);
│ │ │ │ void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}
│ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ -void add_file_borrow (error_code& ec, string_view filename
│ │ │ │ +void add_file_borrow (string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ -void add_file_borrow (string_view filename
│ │ │ │ +void add_file (std::string const& path, std::int64_t file_size
│ │ │ │ + , file_flags_t file_flags = {}
│ │ │ │ + , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ + , char const* root_hash = nullptr);
│ │ │ │ +void add_file_borrow (error_code& ec, string_view filename
│ │ │ │ , std::string const& path, std::int64_t file_size
│ │ │ │ , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ │ , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │
│ │ │ │ Adds a file to the file storage. The add_file_borrow version │ │ │ │ expects that filename is the file name (without a path) of │ │ │ │ @@ -6026,21 +6026,21 @@ │ │ │ │ [report issue]
│ │ │ │ std::int64_t total_size () const; │ │ │ ││ │ │ │
returns the total number of bytes all the files in this torrent spans
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -void set_num_pieces (int n); │ │ │ │ int num_pieces () const; │ │ │ │ +void set_num_pieces (int n); │ │ │ ││ │ │ │
set and get the number of pieces in the torrent
│ │ │ │ [report issue]│ │ │ │ piece_index_t end_piece () const; │ │ │ │ @@ -6060,18 +6060,18 @@ │ │ │ │piece_range()
│ │ │ ││ │ │ │ index_range<piece_index_t> piece_range () const noexcept; │ │ │ ││ │ │ │returns an implementation-defined type that can be used as the │ │ │ │ container in a range-for loop. Where the values are the indices of all │ │ │ │ pieces in the file_storage.
│ │ │ │ - │ │ │ │ -[report issue]
│ │ │ │ int piece_length () const; │ │ │ │ void set_piece_length (int l); │ │ │ ││ │ │ │
set and get the size of each piece in this torrent. It must be a power of two │ │ │ │ and at least 16 kiB.
│ │ │ │ [report issue]│ │ │ │ int blocks_in_piece2 (piece_index_t index) const; │ │ │ ││ │ │ │
returns the number of blocks in the specified piece, for v2 torrents.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ std::string const& name () const; │ │ │ │ void set_name (std::string const& n); │ │ │ ││ │ │ │
set and get the name of this torrent. For multi-file torrents, this is also │ │ │ │ the name of the root directory all the files are stored in.
│ │ │ │ [report issue]│ │ │ │ void canonicalize (); │ │ │ ││ │ │ │
arrange files and padding to match the canonical form required │ │ │ │ by BEP 52
│ │ │ │ │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ + │ │ │ │ + │ │ │ │ │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -sha1_hash hash (file_index_t index) const; │ │ │ │ -bool pad_file_at (file_index_t index) const; │ │ │ │ sha256_hash root (file_index_t index) const; │ │ │ │ char const* root_ptr (file_index_t const index) const; │ │ │ │ -std::string symlink (file_index_t index) const; │ │ │ │ -std::string file_path (file_index_t index, std::string const& save_path = "") const; │ │ │ │ -std::int64_t file_offset (file_index_t index) const; │ │ │ │ -std::int64_t file_size (file_index_t index) const; │ │ │ │ string_view file_name (file_index_t index) const; │ │ │ │ +std::int64_t file_size (file_index_t index) const; │ │ │ │ +std::string file_path (file_index_t index, std::string const& save_path = "") const; │ │ │ │ +std::string symlink (file_index_t index) const; │ │ │ │ +sha1_hash hash (file_index_t index) const; │ │ │ │ std::time_t mtime (file_index_t index) const; │ │ │ │ +std::int64_t file_offset (file_index_t index) const; │ │ │ │ +bool pad_file_at (file_index_t index) const; │ │ │ ││ │ │ │
These functions are used to query attributes of files at │ │ │ │ a given index.
│ │ │ │The hash() is a SHA-1 hash of the file, or 0 if none was │ │ │ │ provided in the torrent file. This can potentially be used to │ │ │ │ join a bittorrent network with other file sharing networks.
│ │ │ │root() returns the SHA-256 merkle tree root of the specified file, │ │ │ │ @@ -6169,33 +6169,33 @@ │ │ │ │
file_name() returns just the name of the file, whereas │ │ │ │ file_path() returns the path (inside the torrent file) with │ │ │ │ the filename appended.
│ │ │ │file_offset() returns the byte offset within the torrent file │ │ │ │ where this file starts. It can be used to map the file to a piece │ │ │ │ index (given the piece size).
│ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ +int file_num_pieces (file_index_t index) const; │ │ │ │ index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const; │ │ │ │ int file_num_blocks (file_index_t index) const; │ │ │ │ -int file_num_pieces (file_index_t index) const; │ │ │ ││ │ │ │
Returns the number of pieces or blocks the file at index spans, │ │ │ │ under the assumption that the file is aligned to the start of a piece. │ │ │ │ This is only meaningful for v2 torrents, where files are guaranteed │ │ │ │ such alignment. │ │ │ │ These numbers are used to size and navigate the merkle hash tree for │ │ │ │ each file.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ int file_first_block_node (file_index_t index) const; │ │ │ │ int file_first_piece_node (file_index_t index) const; │ │ │ ││ │ │ │
index of first piece node in the merkle tree
│ │ │ │ [report issue]│ │ │ │ bool file_absolute_path (file_index_t index) const; │ │ │ ││ │ │ │
returns true if the file at the specified index has been renamed to │ │ │ │ have an absolute path, i.e. is not anchored in the save path of the │ │ │ │ torrent.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -file_index_t file_index_at_offset (std::int64_t offset) const; │ │ │ │ file_index_t file_index_at_piece (piece_index_t piece) const; │ │ │ │ +file_index_t file_index_at_offset (std::int64_t offset) const; │ │ │ ││ │ │ │
returns the index of the file at the given offset in the torrent
│ │ │ │ [report issue]
│ │ │ │ file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ @@ -6480,38 +6480,38 @@
│ │ │ │ struct client_data_t
│ │ │ │ {
│ │ │ │ client_data_t () = default;
│ │ │ │ explicit client_data_t (T* v);
│ │ │ │ client_data_t& operator= (T* v);
│ │ │ │ explicit operator T () const;
│ │ │ │ T* get () const;
│ │ │ │ - client_data_t& operator= (void const*) = delete;
│ │ │ │ + client_data_t& operator= (void*) = delete;
│ │ │ │ operator void const* () const = delete;
│ │ │ │ operator void* () const = delete;
│ │ │ │ - client_data_t& operator= (void*) = delete;
│ │ │ │ + client_data_t& operator= (void const*) = delete;
│ │ │ │
│ │ │ │ template <typename T, typename U = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]│ │ │ │ client_data_t () = default; │ │ │ ││ │ │ │
construct a nullptr client data
│ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -client_data_t& operator= (void const*) = delete; │ │ │ │ +client_data_t& operator= (void*) = delete; │ │ │ │ operator void const* () const = delete; │ │ │ │ operator void* () const = delete; │ │ │ │ -client_data_t& operator= (void*) = delete; │ │ │ │ +client_data_t& operator= (void const*) = delete; │ │ │ ││ │ │ │
we don't allow type-unsafe operations
│ │ │ │ [report issue]Declared in "libtorrent/add_torrent_params.hpp"
│ │ │ │ @@ -6896,16 +6896,16 @@ │ │ │ │ peer-classes from peers. It is applied after the peer class filter is applied (which │ │ │ │ is based on the peer's IP address). │ │ │ │
│ │ │ │ struct peer_class_type_filter
│ │ │ │ {
│ │ │ │ void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ - void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ + void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ friend bool operator== (peer_class_type_filter const& lhs
│ │ │ │ , peer_class_type_filter const& rhs);
│ │ │ │
│ │ │ │ enum socket_type_t
│ │ │ │ {
│ │ │ │ tcp_socket,
│ │ │ │ @@ -6922,21 +6922,21 @@
│ │ │ │ remove() add()
│ │ │ │
│ │ │ │ void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │
│ │ │ │ add() and remove() adds and removes a peer class to be added
│ │ │ │ to new peers based on socket type.
│ │ │ │ -
│ │ │ │ -[report issue]│ │ │ │ -void disallow (socket_type_t const st, peer_class_t const peer_class); │ │ │ │ void allow (socket_type_t const st, peer_class_t const peer_class); │ │ │ │ +void disallow (socket_type_t const st, peer_class_t const peer_class); │ │ │ ││ │ │ │
disallow() and allow() adds and removes a peer class to be │ │ │ │ removed from new peers based on socket type.
│ │ │ │The peer_class argument cannot be greater than 31. The bitmasks representing │ │ │ │ peer classes in the peer_class_type_filter are 32 bits.
│ │ │ │ [report issue]│ │ │ │ void set_peer (tcp::endpoint const& ep); │ │ │ │ tcp::endpoint peer () const; │ │ │ ││ │ │ │
The peer is the ip address of the peer this block was downloaded from.
│ │ │ │ [report issue]get_download_queue() returns a vector with information about pieces │ │ │ │ that are partially downloaded or not downloaded but partially │ │ │ │ requested. See partial_piece_info for the fields in the returned │ │ │ │ vector.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]
│ │ │ │ -void clear_piece_deadlines () const;
│ │ │ │ -void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ +void clear_piece_deadlines () const;
│ │ │ │
│ │ │ │ This function sets or resets the deadline associated with a specific │ │ │ │ piece index (index). libtorrent will attempt to download this │ │ │ │ entire piece before the deadline expires. This is not necessarily │ │ │ │ possible, but pieces with a more recent deadline will always be │ │ │ │ prioritized over pieces with a deadline further ahead in time. The │ │ │ │ deadline (and flags) of a piece can be changed by calling this │ │ │ │ @@ -7401,16 +7401,16 @@ │ │ │ │ priority.
│ │ │ │clear_piece_deadlines() removes deadlines on all pieces in │ │ │ │ the torrent. As if reset_piece_deadline() was called on all pieces.
│ │ │ │ [report issue]
│ │ │ │ -void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ +void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │
│ │ │ │ This function fills in the supplied vector, or returns a vector, with │ │ │ │ the number of bytes downloaded of each file in this torrent. The │ │ │ │ progress values are ordered the same as the files in the │ │ │ │ torrent_info.
│ │ │ │This operation is not very cheap. Its complexity is O(n + mj). │ │ │ │ Where n is the number of files, m is the number of currently │ │ │ │ @@ -7439,22 +7439,22 @@ │ │ │ │
│ │ │ │ void clear_error () const; │ │ │ ││ │ │ │
If the torrent is in an error state (i.e. torrent_status::error is │ │ │ │ non-empty), this will clear the error and start the torrent again.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -void replace_trackers (std::vector<announce_entry> const&) const; │ │ │ │ void add_tracker (announce_entry const&) const; │ │ │ │ +void replace_trackers (std::vector<announce_entry> const&) const; │ │ │ │ std::vector<announce_entry> trackers () const; │ │ │ ││ │ │ │
trackers() will return the list of trackers for this torrent. The │ │ │ │ announce entry contains both a string url which specify the │ │ │ │ announce url for the tracker as well as an int tier, which is │ │ │ │ specifies the order in which this tracker is tried. If you want │ │ │ │ libtorrent to use another list of trackers for this torrent, you can │ │ │ │ @@ -7471,36 +7471,36 @@ │ │ │ │ data will replace the original ones.
│ │ │ │ │ │ │ │ │ │ │ │ [report issue]│ │ │ │ -std::set<std::string> url_seeds () const; │ │ │ │ void remove_url_seed (std::string const& url) const; │ │ │ │ void add_url_seed (std::string const& url) const; │ │ │ │ +std::set<std::string> url_seeds () const; │ │ │ ││ │ │ │
add_url_seed() adds another url to the torrent's list of url │ │ │ │ seeds. If the given url already exists in that list, the call has no │ │ │ │ effect. The torrent will connect to the server and try to download │ │ │ │ pieces from it, unless it's paused, queued, checking or seeding. │ │ │ │ remove_url_seed() removes the given url if it exists already. │ │ │ │ url_seeds() return a set of the url seeds currently in this │ │ │ │ torrent. Note that URLs that fails may be removed automatically from │ │ │ │ the list.
│ │ │ │See http seeding for more information.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -void remove_http_seed (std::string const& url) const; │ │ │ │ std::set<std::string> http_seeds () const; │ │ │ │ void add_http_seed (std::string const& url) const; │ │ │ │ +void remove_http_seed (std::string const& url) const; │ │ │ ││ │ │ │
These functions are identical as the *_url_seed() variants, but │ │ │ │ they operate on BEP 17 web seeds instead of BEP 19.
│ │ │ │See http seeding for more information.
│ │ │ │ [report issue]Clients should only use is_valid() to determine if the result of │ │ │ │ session::find_torrent() was successful.
│ │ │ │Unlike other member functions which return a value, is_valid() │ │ │ │ completes immediately, without blocking on a result from the │ │ │ │ network thread. Also unlike other functions, it never throws │ │ │ │ the system_error exception.
│ │ │ │ - │ │ │ │ -[report issue]
│ │ │ │ -void pause (pause_flags_t flags = {}) const;
│ │ │ │ void resume () const;
│ │ │ │ +void pause (pause_flags_t flags = {}) const;
│ │ │ │
│ │ │ │ pause(), and resume() will disconnect all peers and reconnect │ │ │ │ all peers respectively. When a torrent is paused, it will however │ │ │ │ remember all share ratios to all peers and remember all potential (not │ │ │ │ connected) peers. Torrents may be paused automatically if there is a │ │ │ │ file error (e.g. disk full) or something similar. See │ │ │ │ file_error_alert.
│ │ │ │ @@ -7567,24 +7567,24 @@ │ │ │ │Note
│ │ │ │Torrents that are auto-managed may be automatically resumed again. It │ │ │ │ does not make sense to pause an auto-managed torrent without making it │ │ │ │ not auto-managed first. Torrents are auto-managed by default when added │ │ │ │ to the session. For more information, see queuing.
│ │ │ ││ │ │ │ void set_flags (torrent_flags_t flags, torrent_flags_t mask) const; │ │ │ │ -torrent_flags_t flags () const; │ │ │ │ -void set_flags (torrent_flags_t flags) const; │ │ │ │ void unset_flags (torrent_flags_t flags) const; │ │ │ │ +void set_flags (torrent_flags_t flags) const; │ │ │ │ +torrent_flags_t flags () const; │ │ │ ││ │ │ │
sets and gets the torrent state flags. See torrent_flags_t. │ │ │ │ The set_flags overload that take a mask will affect all │ │ │ │ flags part of the mask, and set their values to what the │ │ │ │ flags argument is set to. This allows clearing and │ │ │ │ setting flags in a single function call. │ │ │ │ The set_flags overload that just takes flags, sets all │ │ │ │ @@ -7735,27 +7735,27 @@ │ │ │ │
Note
│ │ │ │A torrent's resume data is considered saved as soon as the │ │ │ │ save_resume_data_alert is posted. It is important to make sure this │ │ │ │ alert is received and handled in order for this function to be │ │ │ │ meaningful.
│ │ │ ││ │ │ │ -queue_position_t queue_position () const; │ │ │ │ void queue_position_down () const; │ │ │ │ +void queue_position_bottom () const; │ │ │ │ void queue_position_top () const; │ │ │ │ void queue_position_up () const; │ │ │ │ -void queue_position_bottom () const; │ │ │ │ +queue_position_t queue_position () const; │ │ │ ││ │ │ │
Every torrent that is added is assigned a queue position exactly one │ │ │ │ greater than the greatest queue position of all existing torrents. │ │ │ │ Torrents that are being seeded have -1 as their queue position, since │ │ │ │ they're no longer in line to be downloaded.
│ │ │ │When a torrent is removed or turns into a seed, all torrents with │ │ │ │ greater queue positions have their positions decreased to fill in the │ │ │ │ @@ -7779,21 +7779,21 @@ │ │ │ │ of all other torrents remain intact but their numerical queue position │ │ │ │ shifts to make space for this torrent's new position
│ │ │ │ │ │ │ │ [report issue]│ │ │ │ -void set_ssl_certificate_buffer (std::string const& certificate │ │ │ │ - , std::string const& private_key │ │ │ │ - , std::string const& dh_params); │ │ │ │ void set_ssl_certificate (std::string const& certificate │ │ │ │ , std::string const& private_key │ │ │ │ , std::string const& dh_params │ │ │ │ , std::string const& passphrase = ""); │ │ │ │ +void set_ssl_certificate_buffer (std::string const& certificate │ │ │ │ + , std::string const& private_key │ │ │ │ + , std::string const& dh_params); │ │ │ ││ │ │ │
For SSL torrents, use this to specify a path to a .pem file to use as │ │ │ │ this client's certificate. The certificate must be signed by the │ │ │ │ certificate in the .torrent file to be valid.
│ │ │ │The set_ssl_certificate_buffer() overload takes the actual certificate, │ │ │ │ private key and DH params as strings, rather than paths to files.
│ │ │ │cert is a path to the (signed) certificate in .pem format │ │ │ │ @@ -7809,18 +7809,18 @@ │ │ │ │
Note that when a torrent first starts up, and it needs a certificate, │ │ │ │ it will suspend connecting to any peers until it has one. It's │ │ │ │ typically desirable to resume the torrent after setting the SSL │ │ │ │ certificate.
│ │ │ │If you receive a torrent_need_cert_alert, you need to call this to │ │ │ │ provide a valid cert. If you don't have a cert you won't be allowed to │ │ │ │ connect to any peers.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ std::shared_ptr<torrent_info> torrent_file_with_hashes () const; │ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const; │ │ │ ││ │ │ │
torrent_file() returns a pointer to the torrent_info object │ │ │ │ associated with this torrent. The torrent_info object may be a copy │ │ │ │ of the internal object. If the torrent doesn't have metadata, the │ │ │ │ @@ -7868,25 +7868,25 @@ │ │ │ │
Fills the specified std::vector<int> with the availability for │ │ │ │ each piece in this torrent. libtorrent does not keep track of │ │ │ │ availability for seeds, so if the torrent is seeding the availability │ │ │ │ for all pieces is reported as 0.
│ │ │ │The piece availability is the number of peers that we are connected │ │ │ │ that has advertised having a particular piece. This is the information │ │ │ │ that libtorrent uses in order to prefer picking rare pieces.
│ │ │ │ - │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ std::vector<download_priority_t> get_piece_priorities () const; │ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const; │ │ │ │ void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const; │ │ │ │ -download_priority_t piece_priority (piece_index_t index) const; │ │ │ │ void prioritize_pieces (std::vector<download_priority_t> const& pieces) const; │ │ │ │ +download_priority_t piece_priority (piece_index_t index) const; │ │ │ ││ │ │ │
These functions are used to set and get the priority of individual │ │ │ │ pieces. By default all pieces have priority 4. That means that the │ │ │ │ random rarest first algorithm is effectively active for all pieces. │ │ │ │ You may however change the priority of individual pieces. There are 8 │ │ │ │ priority levels. 0 means not to download the piece at all. Otherwise, │ │ │ │ lower priority values means less likely to be picked. Piece priority │ │ │ │ @@ -7908,24 +7908,24 @@ │ │ │ │ Invalid entries, where the piece index or priority is out of range, are │ │ │ │ not allowed.
│ │ │ │get_piece_priorities returns a vector with one element for each piece │ │ │ │ in the torrent. Each element is the current priority of that piece.
│ │ │ │It's possible to cancel the effect of file priorities by setting the │ │ │ │ priorities for the affected pieces. Care has to be taken when mixing │ │ │ │ usage of file- and piece priorities.
│ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -void file_priority (file_index_t index, download_priority_t priority) const; │ │ │ │ download_priority_t file_priority (file_index_t index) const; │ │ │ │ -std::vector<download_priority_t> get_file_priorities () const; │ │ │ │ void prioritize_files (std::vector<download_priority_t> const& files) const; │ │ │ │ +std::vector<download_priority_t> get_file_priorities () const; │ │ │ │ +void file_priority (file_index_t index, download_priority_t priority) const; │ │ │ ││ │ │ │
index must be in the range [0, number_of_files).
│ │ │ │file_priority() queries or sets the priority of file index.
│ │ │ │prioritize_files() takes a vector that has at as many elements as │ │ │ │ there are files in the torrent. Each entry is the priority of that │ │ │ │ file. The function sets the priorities of all the pieces in the │ │ │ │ torrent based on the vector.
│ │ │ │ @@ -7948,22 +7948,22 @@ │ │ │ │ file_prio_alert. │ │ │ │When combining file- and piece priorities, the resume file will record │ │ │ │ both. When loading the resume data, the file priorities will be applied │ │ │ │ first, then the piece priorities.
│ │ │ │Moving data from a file into the part file is currently not │ │ │ │ supported. If a file has its priority set to 0 after it has already │ │ │ │ been created, it will not be moved into the partfile.
│ │ │ │ + │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │ void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ +void force_lsd_announce () const;
│ │ │ │ void force_dht_announce () const;
│ │ │ │
│ │ │ │ force_reannounce() will force this torrent to do another tracker │ │ │ │ request, to receive new peers. The seconds argument specifies how │ │ │ │ many seconds from now to issue the tracker announces.
│ │ │ │If the tracker's min_interval has not passed since the last │ │ │ │ announce, the forced announce will be scheduled to happen immediately │ │ │ │ @@ -7988,24 +7988,24 @@ │ │ │ │ idx is >= 0, the tracker with the specified index will scraped.
│ │ │ │A scrape request queries the tracker for statistics such as total │ │ │ │ number of incomplete peers, complete peers, number of downloads etc.
│ │ │ │This request will specifically update the num_complete and │ │ │ │ num_incomplete fields in the torrent_status struct once it │ │ │ │ completes. When it completes, it will generate a scrape_reply_alert. │ │ │ │ If it fails, it will generate a scrape_failed_alert.
│ │ │ │ - │ │ │ │ - │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ +int upload_limit () const; │ │ │ │ void set_download_limit (int limit) const; │ │ │ │ int download_limit () const; │ │ │ │ -int upload_limit () const; │ │ │ │ void set_upload_limit (int limit) const; │ │ │ ││ │ │ │
set_upload_limit will limit the upload bandwidth used by this │ │ │ │ particular torrent to the limit you set. It is given as the number of │ │ │ │ bytes per second the torrent is allowed to upload. │ │ │ │ set_download_limit works the same way but for download bandwidth │ │ │ │ instead of upload bandwidth. Note that setting a higher limit on a │ │ │ │ @@ -8057,16 +8057,16 @@ │ │ │ │ settings_pack.
│ │ │ │max_uploads() returns the current settings.
│ │ │ │ │ │ │ │ [report issue]│ │ │ │ -int max_connections () const; │ │ │ │ void set_max_connections (int max_connections) const; │ │ │ │ +int max_connections () const; │ │ │ ││ │ │ │
set_max_connections() sets the maximum number of connection this │ │ │ │ torrent will open. If all connections are used up, incoming │ │ │ │ connections may be refused or poor connections may be closed. This │ │ │ │ must be at least 2. The default is unlimited number of connections. If │ │ │ │ -1 is given to the function, it means unlimited. There is also a │ │ │ │ global limit of the number of connections, set by │ │ │ │ @@ -8129,36 +8129,36 @@ │ │ │ │
│ │ │ │ void rename_file (file_index_t index, std::string const& new_name) const; │ │ │ ││ │ │ │
Renames the file with the given index asynchronously. The rename │ │ │ │ operation is complete when either a file_renamed_alert or │ │ │ │ file_rename_failed_alert is posted.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -sha1_hash info_hash () const; │ │ │ │ info_hash_t info_hashes () const; │ │ │ │ +sha1_hash info_hash () const; │ │ │ ││ │ │ │
returns the info-hash(es) of the torrent. If this handle is to a │ │ │ │ torrent that hasn't loaded yet (for instance by being added) by a │ │ │ │ URL, the returned value is undefined. │ │ │ │ The info_hash() returns the SHA-1 info-hash for v1 torrents and a │ │ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use │ │ │ │ info_hashes() instead.
│ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -bool operator!= (const torrent_handle& h) const; │ │ │ │ bool operator< (const torrent_handle& h) const; │ │ │ │ +bool operator!= (const torrent_handle& h) const; │ │ │ │ bool operator== (const torrent_handle& h) const; │ │ │ ││ │ │ │
comparison operators. The order of the torrents is unspecified │ │ │ │ but stable.
│ │ │ │ [report issue]│ │ │ │ virtual void remove_torrent (storage_index_t) = 0; │ │ │ ││ │ │ │
remove the storage with the specified index. This is not expected to │ │ │ │ delete any files from disk, just to clean up any resources associated │ │ │ │ with the specified storage.
│ │ │ │ - │ │ │ │ -[report issue]
│ │ │ │ virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ │ , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ │ , disk_job_flags_t flags = {}) = 0;
│ │ │ │ virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ │ , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ │ , std::function<void(storage_error const&)> handler
│ │ │ │ @@ -8703,22 +8703,22 @@
│ │ │ │ internal libtorrent torrent object to tie the storage object allocated
│ │ │ │ for a torrent to the lifetime of the internal torrent object. When a
│ │ │ │ torrent is removed from the session, this holder is destructed and will
│ │ │ │ inform the disk object.
│ │ │ │
│ │ │ │ struct storage_holder
│ │ │ │ {
│ │ │ │ - ~storage_holder ();
│ │ │ │ - storage_holder () = default;
│ │ │ │ storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ + storage_holder () = default;
│ │ │ │ + ~storage_holder ();
│ │ │ │ explicit operator bool () const;
│ │ │ │ operator storage_index_t () const;
│ │ │ │ void reset ();
│ │ │ │ - storage_holder (storage_holder const&) = delete;
│ │ │ │ storage_holder& operator= (storage_holder const&) = delete;
│ │ │ │ + storage_holder (storage_holder const&) = delete;
│ │ │ │ storage_holder (storage_holder&& rhs) noexcept;
│ │ │ │ storage_holder& operator= (storage_holder&& rhs) noexcept;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]The disk buffer holder acts like a unique_ptr that frees a disk buffer │ │ │ │ when it's destructed
│ │ │ │If this buffer holder is moved-from, default constructed or reset, │ │ │ │ data() will return nullptr.
│ │ │ │
│ │ │ │ struct disk_buffer_holder
│ │ │ │ {
│ │ │ │ - disk_buffer_holder (disk_buffer_holder&&) noexcept;
│ │ │ │ disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │ - disk_buffer_holder& operator= (disk_buffer_holder const&) = delete;
│ │ │ │ + disk_buffer_holder (disk_buffer_holder&&) noexcept;
│ │ │ │ disk_buffer_holder (disk_buffer_holder const&) = delete;
│ │ │ │ + disk_buffer_holder& operator= (disk_buffer_holder const&) = delete;
│ │ │ │ disk_buffer_holder (buffer_allocator_interface& alloc
│ │ │ │ , char* buf, int sz) noexcept;
│ │ │ │ disk_buffer_holder () noexcept = default;
│ │ │ │ ~disk_buffer_holder ();
│ │ │ │ char* data () const noexcept;
│ │ │ │ void reset ();
│ │ │ │ void swap (disk_buffer_holder& h) noexcept;
│ │ │ │ @@ -8844,18 +8844,18 @@
│ │ │ │ settings_interface
│ │ │ │ Declared in "libtorrent/settings_pack.hpp"
│ │ │ │ the common interface to settings_pack and the internal representation of
│ │ │ │ settings.
│ │ │ │
│ │ │ │ struct settings_interface
│ │ │ │ {
│ │ │ │ - virtual bool has_val (int name) const = 0;
│ │ │ │ - virtual void set_str (int name, std::string val) = 0;
│ │ │ │ virtual void set_bool (int name, bool val) = 0;
│ │ │ │ + virtual void set_str (int name, std::string val) = 0;
│ │ │ │ virtual void set_int (int name, int val) = 0;
│ │ │ │ + virtual bool has_val (int name) const = 0;
│ │ │ │ virtual std::string const& get_str (int name) const = 0;
│ │ │ │ virtual int get_int (int name) const = 0;
│ │ │ │ virtual bool get_bool (int name) const = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ struct storage_moved_alert final : torrent_alert
│ │ │ │ {
│ │ │ │ std::string message () const override;
│ │ │ │ - char const* old_path () const;
│ │ │ │ char const* storage_path () const;
│ │ │ │ + char const* old_path () const;
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::storage;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]│ │ │ │ -char const* old_path () const; │ │ │ │ char const* storage_path () const; │ │ │ │ +char const* old_path () const; │ │ │ ││ │ │ │
the path the torrent was moved to and from, respectively.
│ │ │ │ [report issue]Declared in "libtorrent/alert_types.hpp"
│ │ │ │ @@ -11618,17 +11618,17 @@ │ │ │ │ std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const; │ │ │ │ int num_nodes () const; │ │ │ │ │ │ │ │ static constexpr alert_category_t static_category = alert_category::dht; │ │ │ │ sha1_hash node_id; │ │ │ │ }; │ │ │ │ │ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const; │ │ │ │ int num_nodes () const; │ │ │ ││ │ │ │
the number of nodes in the routing table and the actual nodes.
│ │ │ │ [report issue]│ │ │ │ std::vector<sha1_hash> samples () const; │ │ │ │ int num_samples () const; │ │ │ ││ │ │ │
returns the number of info-hashes returned by the node, as well as the │ │ │ │ actual info-hashes. num_samples() is more efficient than │ │ │ │ samples().size().
│ │ │ │ @@ -11746,16 +11746,16 @@ │ │ │ │this alert is posted to indicate to the client that some alerts were │ │ │ │ dropped. Dropped meaning that the alert failed to be delivered to the │ │ │ │ client. The most common cause of such failure is that the internal alert │ │ │ │ queue grew too big (controlled by alert_queue_size).
│ │ │ │
│ │ │ │ struct alerts_dropped_alert final : alert
│ │ │ │ {
│ │ │ │ - static_assert (num_alert_types <= abi_alert_count, "need to increase bitset. This is an ABI break");
│ │ │ │ std::string message () const override;
│ │ │ │ + static_assert (num_alert_types <= abi_alert_count, "need to increase bitset. This is an ABI break");
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::error;
│ │ │ │ std::bitset<abi_alert_count> dropped_alerts;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]Declared in "libtorrent/alert.hpp"
│ │ │ ││ │ │ │ -template <typename T> T const* alert_cast (alert const* a); │ │ │ │ template <typename T> T* alert_cast (alert* a); │ │ │ │ +template <typename T> T const* alert_cast (alert const* a); │ │ │ ││ │ │ │
When you get an alert, you can use alert_cast<> to attempt to cast the │ │ │ │ pointer to a specific alert type, in order to query it for more │ │ │ │ information.
│ │ │ │Note
│ │ │ │alert_cast<> can only cast to an exact alert type, not a base class
│ │ │ │ @@ -12361,20 +12361,20 @@ │ │ │ │ a single rule that allows all addresses (0.0.0.0 - 255.255.255.255 for │ │ │ │ the IPv4 range, and the equivalent range covering all addresses for the │ │ │ │ IPv6 range). │ │ │ │A default constructed ip_filter does not filter any address.
│ │ │ │
│ │ │ │ struct ip_filter
│ │ │ │ {
│ │ │ │ - ~ip_filter ();
│ │ │ │ - ip_filter& operator= (ip_filter const&);
│ │ │ │ ip_filter ();
│ │ │ │ - ip_filter (ip_filter&&);
│ │ │ │ - ip_filter& operator= (ip_filter&&);
│ │ │ │ + ip_filter& operator= (ip_filter const&);
│ │ │ │ ip_filter (ip_filter const&);
│ │ │ │ + ip_filter& operator= (ip_filter&&);
│ │ │ │ + ip_filter (ip_filter&&);
│ │ │ │ + ~ip_filter ();
│ │ │ │ bool empty () const;
│ │ │ │ void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │ std::uint32_t access (address const& addr) const;
│ │ │ │ filter_tuple_t export_filter () const;
│ │ │ │
│ │ │ │ enum access_flags
│ │ │ │ {
│ │ │ │ @@ -12458,20 +12458,20 @@
│ │ │ │ the port filter maps non-overlapping port ranges to flags. This
│ │ │ │ is primarily used to indicate whether a range of ports should
│ │ │ │ be connected to or not. The default is to have the full port
│ │ │ │ range (0-65535) set to flag 0.
│ │ │ │
│ │ │ │ class port_filter
│ │ │ │ {
│ │ │ │ + port_filter& operator= (port_filter const&);
│ │ │ │ + port_filter (port_filter&&);
│ │ │ │ + port_filter (port_filter const&);
│ │ │ │ ~port_filter ();
│ │ │ │ - port_filter ();
│ │ │ │ port_filter& operator= (port_filter&&);
│ │ │ │ - port_filter (port_filter const&);
│ │ │ │ - port_filter (port_filter&&);
│ │ │ │ - port_filter& operator= (port_filter const&);
│ │ │ │ + port_filter ();
│ │ │ │ void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ │ std::uint32_t access (std::uint16_t port) const;
│ │ │ │
│ │ │ │ enum access_flags
│ │ │ │ {
│ │ │ │ blocked,
│ │ │ │ };
│ │ │ │ @@ -12547,38 +12547,38 @@
│ │ │ │ entry (preformatted_type);
│ │ │ │ entry (dictionary_type);
│ │ │ │ entry (list_type);
│ │ │ │ entry (integer_type);
│ │ │ │ entry (U v);
│ │ │ │ entry (data_type t);
│ │ │ │ entry (bdecode_node const& n);
│ │ │ │ - entry& operator= (entry const&) &;
│ │ │ │ - entry& operator= (dictionary_type) &;
│ │ │ │ - entry& operator= (bdecode_node const&) &;
│ │ │ │ - entry& operator= (list_type) &;
│ │ │ │ - entry& operator= (preformatted_type) &;
│ │ │ │ entry& operator= (entry&&) & noexcept;
│ │ │ │ + entry& operator= (bdecode_node const&) &;
│ │ │ │ entry& operator= (integer_type) &;
│ │ │ │ + entry& operator= (preformatted_type) &;
│ │ │ │ entry& operator= (span<char const>) &;
│ │ │ │ + entry& operator= (dictionary_type) &;
│ │ │ │ + entry& operator= (list_type) &;
│ │ │ │ + entry& operator= (entry const&) &;
│ │ │ │ entry& operator= (U v) &;
│ │ │ │ - dictionary_type const& dict () const;
│ │ │ │ + preformatted_type const& preformatted () const;
│ │ │ │ + list_type const& list () const;
│ │ │ │ integer_type const& integer () const;
│ │ │ │ - string_type& string ();
│ │ │ │ - list_type& list ();
│ │ │ │ preformatted_type& preformatted ();
│ │ │ │ - string_type const& string () const;
│ │ │ │ dictionary_type& dict ();
│ │ │ │ + dictionary_type const& dict () const;
│ │ │ │ + string_type const& string () const;
│ │ │ │ integer_type& integer ();
│ │ │ │ - preformatted_type const& preformatted () const;
│ │ │ │ - list_type const& list () const;
│ │ │ │ + string_type& string ();
│ │ │ │ + list_type& list ();
│ │ │ │ void swap (entry& e);
│ │ │ │ entry const& operator[] (string_view key) const;
│ │ │ │ entry& operator[] (string_view key);
│ │ │ │ - entry* find_key (string_view key);
│ │ │ │ entry const* find_key (string_view key) const;
│ │ │ │ + entry* find_key (string_view key);
│ │ │ │ std::string to_string (bool single_line = false) const;
│ │ │ │
│ │ │ │ enum data_type
│ │ │ │ {
│ │ │ │ int_t,
│ │ │ │ string_t,
│ │ │ │ list_t,
│ │ │ │ @@ -12622,43 +12622,43 @@
│ │ │ │ entry (bdecode_node const& n);
│ │ │ │
│ │ │ │ construct from bdecode_node parsed form (see bdecode())
│ │ │ │ [report issue]│ │ │ │ -entry& operator= (entry const&) &; │ │ │ │ -entry& operator= (dictionary_type) &; │ │ │ │ -entry& operator= (bdecode_node const&) &; │ │ │ │ -entry& operator= (list_type) &; │ │ │ │ -entry& operator= (preformatted_type) &; │ │ │ │ entry& operator= (entry&&) & noexcept; │ │ │ │ +entry& operator= (bdecode_node const&) &; │ │ │ │ entry& operator= (integer_type) &; │ │ │ │ +entry& operator= (preformatted_type) &; │ │ │ │ entry& operator= (span<char const>) &; │ │ │ │ +entry& operator= (dictionary_type) &; │ │ │ │ +entry& operator= (list_type) &; │ │ │ │ +entry& operator= (entry const&) &; │ │ │ ││ │ │ │
copies the structure of the right hand side into this │ │ │ │ entry.
│ │ │ │ - │ │ │ │ - │ │ │ │ │ │ │ │ + │ │ │ │ │ │ │ │ -[report issue]│ │ │ │ -dictionary_type const& dict () const; │ │ │ │ +preformatted_type const& preformatted () const; │ │ │ │ +list_type const& list () const; │ │ │ │ integer_type const& integer () const; │ │ │ │ -string_type& string (); │ │ │ │ -list_type& list (); │ │ │ │ preformatted_type& preformatted (); │ │ │ │ -string_type const& string () const; │ │ │ │ dictionary_type& dict (); │ │ │ │ +dictionary_type const& dict () const; │ │ │ │ +string_type const& string () const; │ │ │ │ integer_type& integer (); │ │ │ │ -preformatted_type const& preformatted () const; │ │ │ │ -list_type const& list () const; │ │ │ │ +string_type& string (); │ │ │ │ +list_type& list (); │ │ │ ││ │ │ │
The integer(), string(), list() and dict() functions │ │ │ │ are accessors that return the respective type. If the entry object │ │ │ │ isn't of the type you request, the accessor will throw │ │ │ │ system_error. You can ask an entry for its type through the │ │ │ │ type() function.
│ │ │ │If you want to create an entry you give it the type you want it to │ │ │ │ @@ -12718,16 +12718,16 @@ │ │ │ │
The const version of operator[] will only return a reference to an │ │ │ │ existing element at the given key. If the key is not found, it will │ │ │ │ throw system_error.
│ │ │ │ [report issue]│ │ │ │ -entry* find_key (string_view key); │ │ │ │ entry const* find_key (string_view key) const; │ │ │ │ +entry* find_key (string_view key); │ │ │ ││ │ │ │
These functions requires the entry to be a dictionary, if it isn't │ │ │ │ they will throw system_error.
│ │ │ │They will look for an element at the given key in the dictionary, if │ │ │ │ the element cannot be found, they will return nullptr. If an element │ │ │ │ with the given key is found, the return a pointer to it.
│ │ │ │ [report issue]
│ │ │ │ struct create_torrent
│ │ │ │ {
│ │ │ │ explicit create_torrent (torrent_info const& ti);
│ │ │ │ explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │ , create_flags_t flags = {});
│ │ │ │ - std::vector<char> generate_buf () const;
│ │ │ │ entry generate () const;
│ │ │ │ + std::vector<char> generate_buf () const;
│ │ │ │ file_storage const& files () const;
│ │ │ │ void set_comment (char const* str);
│ │ │ │ void set_creator (char const* str);
│ │ │ │ void set_creation_date (std::time_t timestamp);
│ │ │ │ void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ │ void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ │ void add_http_seed (string_view url);
│ │ │ │ void add_url_seed (string_view url);
│ │ │ │ void add_node (std::pair<std::string, int> node);
│ │ │ │ void add_tracker (string_view url, int tier = 0);
│ │ │ │ void set_root_cert (string_view cert);
│ │ │ │ - void set_priv (bool p);
│ │ │ │ bool priv () const;
│ │ │ │ - bool is_v2_only () const;
│ │ │ │ + void set_priv (bool p);
│ │ │ │ bool is_v1_only () const;
│ │ │ │ + bool is_v2_only () const;
│ │ │ │ int num_pieces () const;
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │ file_index_t end_file () const;
│ │ │ │ index_range<file_index_t> file_range () const noexcept;
│ │ │ │ index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ int piece_length () const;
│ │ │ │ int piece_size (piece_index_t i) const;
│ │ │ │ - void add_similar_torrent (sha1_hash ih);
│ │ │ │ void add_collection (string_view c);
│ │ │ │ + void add_similar_torrent (sha1_hash ih);
│ │ │ │
│ │ │ │ static constexpr create_flags_t modification_time = 2_bit;
│ │ │ │ static constexpr create_flags_t symlinks = 3_bit;
│ │ │ │ static constexpr create_flags_t v2_only = 5_bit;
│ │ │ │ static constexpr create_flags_t v1_only = 6_bit;
│ │ │ │ static constexpr create_flags_t canonical_files = 7_bit;
│ │ │ │ static constexpr create_flags_t no_attributes = 8_bit;
│ │ │ │ @@ -12930,16 +12930,16 @@
│ │ │ │ entire duration of the create_torrent object.
│ │ │ │ │ │ │ │ -std::vector<char> generate_buf () const; │ │ │ │ entry generate () const; │ │ │ │ +std::vector<char> generate_buf () const; │ │ │ ││ │ │ │
This function will generate the .torrent file as a bencode tree, or a │ │ │ │ bencoded into a buffer. │ │ │ │ In order to encode the entry into a flat file, use the bencode() function.
│ │ │ │The function returning an entry may be useful to add custom entries │ │ │ │ to the torrent file before bencoding it and saving it to disk.
│ │ │ │Whether the resulting torrent object is v1, v2 or hybrid depends on │ │ │ │ @@ -13022,18 +13022,18 @@ │ │ │ │ 16 kiB blocks. Note that piece sizes must be powers-of-2, so all │ │ │ │ per-piece merkle trees are complete. │ │ │ │ A SHA-256 hash of all zeros is internally used to indicate a hash │ │ │ │ that has not been set. Setting such hash will not be considered set │ │ │ │ when calling generate(). │ │ │ │ This function will throw std::system_error if it is called on an │ │ │ │ object constructed with the v1_only flag.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ void add_http_seed (string_view url); │ │ │ │ void add_url_seed (string_view url); │ │ │ ││ │ │ │
This adds a url seed to the torrent. You can have any number of url seeds. For a │ │ │ │ single file torrent, this should be an HTTP url, pointing to a file with identical │ │ │ │ content as the file of the torrent. For a multi-file torrent, it should point to │ │ │ │ @@ -13070,21 +13070,21 @@ │ │ │ │ │ │ │ │
This function sets an X.509 certificate in PEM format to the torrent. This makes the │ │ │ │ torrent an SSL torrent. An SSL torrent requires that each peer has a valid certificate │ │ │ │ signed by this root certificate. For SSL torrents, all peers are connecting over SSL │ │ │ │ connections. For more information, see the section on ssl torrents.
│ │ │ │The string is not the path to the cert, it's the actual content of the │ │ │ │ certificate.
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ -void set_priv (bool p); │ │ │ │ bool priv () const; │ │ │ │ +void set_priv (bool p); │ │ │ ││ │ │ │
Sets and queries the private flag of the torrent. │ │ │ │ Torrents with the private flag set ask the client to not use any other │ │ │ │ sources than the tracker for peers, and to not use DHT to advertise itself publicly, │ │ │ │ only the tracker.
│ │ │ │ [report issue]│ │ │ │ std::int64_t total_size () const; │ │ │ ││ │ │ │
the total number of bytes of all files and pad files
│ │ │ │ - │ │ │ │ -[report issue]│ │ │ │ int piece_length () const; │ │ │ │ int piece_size (piece_index_t i) const; │ │ │ ││ │ │ │
piece_length() returns the piece size of all pieces but the │ │ │ │ last one. piece_size() returns the size of the specified piece. │ │ │ │ these functions are just forwarding to the associated file_storage.
│ │ │ │ │ │ │ │ [report issue]│ │ │ │ -void add_similar_torrent (sha1_hash ih); │ │ │ │ void add_collection (string_view c); │ │ │ │ +void add_similar_torrent (sha1_hash ih); │ │ │ ││ │ │ │
Add similar torrents (by info-hash) or collections of similar torrents. │ │ │ │ Similar torrents are expected to share some files with this torrent. │ │ │ │ Torrents sharing a collection name with this torrent are also expected │ │ │ │ to share files with this torrent. A torrent may have more than one │ │ │ │ collection and more than one similar torrents. For more information, │ │ │ │ see BEP 38.
│ │ │ │ @@ -13209,17 +13209,17 @@ │ │ │ │ [report issue]Declared in "libtorrent/create_torrent.hpp"
│ │ │ │
│ │ │ │ void add_files (file_storage& fs, std::string const& file
│ │ │ │ - , create_flags_t flags = {});
│ │ │ │ -void add_files (file_storage& fs, std::string const& file
│ │ │ │ , std::function<bool(std::string)> p, create_flags_t flags = {});
│ │ │ │ +void add_files (file_storage& fs, std::string const& file
│ │ │ │ + , create_flags_t flags = {});
│ │ │ │
│ │ │ │ Adds the file specified by path to the file_storage object. In case path │ │ │ │ refers to a directory, files will be added recursively from the directory.
│ │ │ │If specified, the predicate p is called once for every file and directory that │ │ │ │ is encountered. Files for which p returns true are added, and directories for │ │ │ │ which p returns true are traversed. p must have the following signature:
│ │ │ ││ │ │ │ @@ -13232,29 +13232,29 @@ │ │ │ │The flags argument should be the same as the flags passed to the create_torrent │ │ │ │ constructor.
│ │ │ │ [report issue]
Declared in "libtorrent/create_torrent.hpp"
│ │ │ ││ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ - , std::function<void(piece_index_t)> const& f); │ │ │ │ void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ , settings_interface const& settings │ │ │ │ , std::function<void(piece_index_t)> const& f, error_code& ec); │ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p); │ │ │ │ void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ , std::function<void(piece_index_t)> const& f, error_code& ec); │ │ │ │ -void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ - , settings_interface const& settings, disk_io_constructor_type disk_io │ │ │ │ - , std::function<void(piece_index_t)> const& f, error_code& ec); │ │ │ │ inline void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ - , settings_interface const& settings │ │ │ │ , std::function<void(piece_index_t)> const& f); │ │ │ │ -inline void set_piece_hashes (create_torrent& t, std::string const& p); │ │ │ │ inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec); │ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ + , settings_interface const& settings │ │ │ │ + , std::function<void(piece_index_t)> const& f); │ │ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p │ │ │ │ + , settings_interface const& settings, disk_io_constructor_type disk_io │ │ │ │ + , std::function<void(piece_index_t)> const& f, error_code& ec); │ │ │ ││ │ │ │
This function will assume that the files added to the torrent file exists at path │ │ │ │ p, read those files and hash the content and set the hashes in the create_torrent │ │ │ │ object. The optional function f is called in between every hash that is set. f │ │ │ │ must have the following signature:
│ │ │ │