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.
│ │ │ │ - ec
│ │ │ │ - the error that occurred
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -26,29 +26,29 @@
│ │ │ │ │ ************ ssttoorraaggee__eerrrroorr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ │ used by storage to return errors also includes which underlying file the error
│ │ │ │ │ happened on
│ │ │ │ │ struct storage_error
│ │ │ │ │ {
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ - void ffiillee (file_index_t f);
│ │ │ │ │ file_index_t ffiillee () const;
│ │ │ │ │ + void ffiillee (file_index_t f);
│ │ │ │ │
│ │ │ │ │ error_code ec;
│ │ │ │ │ operation_t operation;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bbooooll(()) **********
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ explicitly converts to true if this object represents an error, and false if it
│ │ │ │ │ does not.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee(()) **********
│ │ │ │ │ -void ffiillee (file_index_t f);
│ │ │ │ │ file_index_t ffiillee () const;
│ │ │ │ │ +void ffiillee (file_index_t f);
│ │ │ │ │ set and query the index (in the torrent) of the file this error occurred on.
│ │ │ │ │ This may also have special values defined in _t_o_r_r_e_n_t___s_t_a_t_u_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ec
│ │ │ │ │ the error that occurred
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ operation
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Filter.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -56,20 +56,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&&);
│ │ │ │ - ip_filter ();
│ │ │ │ ip_filter (ip_filter const&);
│ │ │ │ - ~ip_filter ();
│ │ │ │ ip_filter& operator= (ip_filter&&);
│ │ │ │ + ~ip_filter ();
│ │ │ │ ip_filter& operator= (ip_filter const&);
│ │ │ │ + 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
│ │ │ │ {
│ │ │ │ @@ -153,20 +153,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 (port_filter&&);
│ │ │ │ - port_filter& operator= (port_filter&&);
│ │ │ │ - port_filter (port_filter const&);
│ │ │ │ - ~port_filter ();
│ │ │ │ port_filter ();
│ │ │ │ + ~port_filter ();
│ │ │ │ port_filter& operator= (port_filter const&);
│ │ │ │ + port_filter& operator= (port_filter&&);
│ │ │ │ + port_filter (port_filter&&);
│ │ │ │ + port_filter (port_filter const&);
│ │ │ │ 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,
│ │ │ │ };
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -19,20 +19,20 @@
│ │ │ │ │ The ip_filter class is a set of rules that uniquely categorizes all ip
│ │ │ │ │ addresses as allowed or disallowed. The default constructor creates 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 _i_p___f_i_l_t_e_r does not filter any address.
│ │ │ │ │ struct ip_filter
│ │ │ │ │ {
│ │ │ │ │ - iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ - iipp__ffiilltteerr ();
│ │ │ │ │ iipp__ffiilltteerr (ip_filter const&);
│ │ │ │ │ - ~~iipp__ffiilltteerr ();
│ │ │ │ │ ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ + ~~iipp__ffiilltteerr ();
│ │ │ │ │ ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │ + iipp__ffiilltteerr ();
│ │ │ │ │ + iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ bool eemmppttyy () const;
│ │ │ │ │ void aadddd__rruullee (address const& first, address const& last, std::uint32_t
│ │ │ │ │ flags);
│ │ │ │ │ std::uint32_t aacccceessss (address const& addr) const;
│ │ │ │ │ filter_tuple_t eexxppoorrtt__ffiilltteerr () const;
│ │ │ │ │
│ │ │ │ │ enum access_flags
│ │ │ │ │ @@ -81,20 +81,20 @@
│ │ │ │ │ ************ ppoorrtt__ffiilltteerr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_p___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │ 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
│ │ │ │ │ {
│ │ │ │ │ - ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ - port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ - ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │ - ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │ ppoorrtt__ffiilltteerr ();
│ │ │ │ │ + ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │ port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ + port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ + ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ + ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │ void aadddd__rruullee (std::uint16_t first, std::uint16_t last, std::uint32_t
│ │ │ │ │ flags);
│ │ │ │ │ std::uint32_t aacccceessss (std::uint16_t port) const;
│ │ │ │ │
│ │ │ │ │ enum access_flags
│ │ │ │ │ {
│ │ │ │ │ blocked,
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-PeerClass.html
│ │ │ │ @@ -31,15 +31,15 @@
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ @@ -104,16 +104,16 @@
│ │ │ │
Declared in "libtorrent/peer_class_type_filter.hpp"
│ │ │ │
peer_class_type_filter is a simple container for rules for adding and subtracting
│ │ │ │ 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 remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ 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);
│ │ │ │ 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
│ │ │ │ @@ -127,23 +127,23 @@
│ │ │ │ };
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
remove() add()
│ │ │ │
│ │ │ │ -void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
disallow() allow()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
allow() disallow()
│ │ │ │
│ │ │ │ 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);
│ │ │ │
│ │ │ │
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
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2,15 +2,15 @@
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___i_n_f_o
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r
│ │ │ │ │ o _r_e_m_o_v_e_(_)_ _a_d_d_(_)
│ │ │ │ │ - o _d_i_s_a_l_l_o_w_(_)_ _a_l_l_o_w_(_)
│ │ │ │ │ + o _a_l_l_o_w_(_)_ _d_i_s_a_l_l_o_w_(_)
│ │ │ │ │ o _a_p_p_l_y_(_)
│ │ │ │ │ o _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ppeeeerr__ccllaassss__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_l_a_s_s_._h_p_p"
│ │ │ │ │ holds settings for a peer class. Used in _s_e_t___p_e_e_r___c_l_a_s_s_(_) and _g_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ calls.
│ │ │ │ │ @@ -59,16 +59,16 @@
│ │ │ │ │ ************ ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │ peer_class_type_filter is a simple container for rules for adding and
│ │ │ │ │ subtracting peer-classes from peers. It is applied aafftteerr the peer class filter
│ │ │ │ │ is applied (which is based on the peer's IP address).
│ │ │ │ │ struct peer_class_type_filter
│ │ │ │ │ {
│ │ │ │ │ - void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ + void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ std::uint32_t aappppllyy (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ │ friend bool ooppeerraattoorr==== (peer_class_type_filter const& lhs
│ │ │ │ │ , peer_class_type_filter const& rhs);
│ │ │ │ │
│ │ │ │ │ enum socket_type_t
│ │ │ │ │ @@ -79,20 +79,20 @@
│ │ │ │ │ ssl_utp_socket,
│ │ │ │ │ i2p_socket,
│ │ │ │ │ num_socket_types,
│ │ │ │ │ };
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreemmoovvee(()) aadddd(()) **********
│ │ │ │ │ -void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +void rreemmoovvee (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddiissaallllooww(()) aallllooww(()) **********
│ │ │ │ │ +********** aallllooww(()) ddiissaallllooww(()) **********
│ │ │ │ │ void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aallllooww (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Plugins.html
│ │ │ │ @@ -46,37 +46,37 @@
│ │ │ │
- on_tick()
│ │ │ │
- get_unchoke_priority()
│ │ │ │
- load_state()
│ │ │ │
│ │ │ │
│ │ │ │
- torrent_plugin
│ │ │ │
│ │ │ │
- peer_plugin
│ │ │ │
│ │ │ │
- crypto_plugin
│ │ │ │ @@ -348,16 +348,16 @@
│ │ │ │
│ │ │ │ struct torrent_plugin
│ │ │ │ {
│ │ │ │ virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ │ virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void tick ();
│ │ │ │ - virtual bool on_resume ();
│ │ │ │ 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);
│ │ │ │
│ │ │ │ static constexpr add_peer_flags_t first_time = 1_bit;
│ │ │ │ static constexpr add_peer_flags_t filtered = 2_bit;
│ │ │ │ @@ -376,18 +376,18 @@
│ │ │ │ are supposed to return an instance of your peer_plugin class. Which in
│ │ │ │ turn will have its hook functions called on event specific to that peer.
│ │ │ │ The peer_connection_handle will be valid as long as the shared_ptr
│ │ │ │ is being held by the torrent object. So, it is generally a good idea to not
│ │ │ │ keep a shared_ptr to your own peer_plugin. If you want to keep references
│ │ │ │ to it, use weak_ptr.
│ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
│ │ │ │ -
on_piece_pass() on_piece_failed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_piece_failed() on_piece_pass()
│ │ │ │
│ │ │ │ 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
│ │ │ │ @@ -396,21 +396,21 @@
│ │ │ │
│ │ │ │
tick()
│ │ │ │
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
on_resume() on_pause()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_pause() on_resume()
│ │ │ │
│ │ │ │ -virtual bool on_resume ();
│ │ │ │ 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
│ │ │ │ will have this hook function called, and the standard handler will also not be
│ │ │ │ invoked. So, returning true effectively overrides the standard behavior of
│ │ │ │ pause or resume.
│ │ │ │ @@ -475,43 +475,43 @@
│ │ │ │ {
│ │ │ │ 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_interested ();
│ │ │ │ + virtual bool
on_have_none ();
│ │ │ │ virtual bool
on_not_interested ();
│ │ │ │ - virtual bool
on_allowed_fast (piece_index_t);
│ │ │ │ - virtual bool
on_have (piece_index_t);
│ │ │ │ - virtual bool
on_have_all ();
│ │ │ │ + virtual bool
on_bitfield (bitfield const&
/*bitfield*/);
│ │ │ │ + virtual bool
on_choke ();
│ │ │ │ virtual bool
on_unchoke ();
│ │ │ │ - virtual bool
on_request (peer_request const&);
│ │ │ │ + virtual bool
on_have_all ();
│ │ │ │ virtual bool
on_dont_have (piece_index_t);
│ │ │ │ - virtual bool
on_choke ();
│ │ │ │ - virtual bool
on_bitfield (bitfield const&
/*bitfield*/);
│ │ │ │ - virtual bool
on_interested ();
│ │ │ │ - virtual bool
on_have_none ();
│ │ │ │ + virtual bool
on_have (piece_index_t);
│ │ │ │ + virtual bool
on_request (peer_request const&);
│ │ │ │ + virtual bool
on_allowed_fast (piece_index_t);
│ │ │ │ virtual bool
on_piece (peer_request const&
/*piece*/
│ │ │ │ , span<char const>
/*buf*/);
│ │ │ │ virtual bool
on_reject (peer_request const&);
│ │ │ │ - virtual bool
on_cancel (peer_request const&);
│ │ │ │ virtual bool
on_suggest (piece_index_t);
│ │ │ │ + virtual bool
on_cancel (peer_request const&);
│ │ │ │ virtual void
sent_have_none ();
│ │ │ │ + virtual void
sent_request (peer_request const&);
│ │ │ │ virtual void
sent_allow_fast (piece_index_t);
│ │ │ │ virtual void
sent_have_all ();
│ │ │ │ - virtual void
sent_reject_request (peer_request const&);
│ │ │ │ virtual void
sent_cancel (peer_request const&);
│ │ │ │ - virtual void
sent_choke ();
│ │ │ │ - virtual void
sent_request (peer_request const&);
│ │ │ │ virtual void
sent_suggest (piece_index_t);
│ │ │ │ + virtual void
sent_choke ();
│ │ │ │ + virtual void
sent_reject_request (peer_request const&);
│ │ │ │ + virtual void
sent_piece (peer_request const&);
│ │ │ │ virtual void
sent_unchoke ();
│ │ │ │ - virtual void
sent_not_interested ();
│ │ │ │ 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_pass (piece_index_t);
│ │ │ │ @@ -570,38 +570,38 @@
│ │ │ │
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
on_unchoke() on_have() on_dont_have() on_choke() on_have_all() on_have_none() on_request() on_bitfield() on_interested() on_not_interested() on_allowed_fast()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_unchoke() on_have_all() on_choke() on_allowed_fast() on_request() on_bitfield() on_interested() on_dont_have() on_not_interested() on_have_none() on_have()
│ │ │ │
│ │ │ │ +virtual bool on_interested ();
│ │ │ │ +virtual bool on_have_none ();
│ │ │ │ virtual bool on_not_interested ();
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -virtual bool on_have (piece_index_t);
│ │ │ │ -virtual bool on_have_all ();
│ │ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +virtual bool on_choke ();
│ │ │ │ virtual bool on_unchoke ();
│ │ │ │ -virtual bool on_request (peer_request const&);
│ │ │ │ +virtual bool on_have_all ();
│ │ │ │ virtual bool on_dont_have (piece_index_t);
│ │ │ │ -virtual bool on_choke ();
│ │ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -virtual bool on_interested ();
│ │ │ │ -virtual bool on_have_none ();
│ │ │ │ +virtual bool on_have (piece_index_t);
│ │ │ │ +virtual bool on_request (peer_request const&);
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │
│ │ │ │
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]
│ │ │ │ @@ -613,27 +613,27 @@
│ │ │ │
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
sent_piece() sent_have() sent_not_interested() sent_unchoke() sent_interested()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
sent_unchoke() sent_have() sent_piece() sent_interested() sent_not_interested()
│ │ │ │
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │ virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_not_interested ();
│ │ │ │ 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]
│ │ │ │
│ │ │ │
sent_payload()
│ │ │ │
│ │ │ │ virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -669,18 +669,18 @@
│ │ │ │
│ │ │ │
on_unknown_message()
│ │ │ │
│ │ │ │ virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │ span<char const> /*body*/);
│ │ │ │
│ │ │ │
this is not called for web seeds
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
on_piece_pass() on_piece_failed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_piece_failed() on_piece_pass()
│ │ │ │
│ │ │ │ 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]
│ │ │ │ @@ -703,16 +703,16 @@
│ │ │ │
│ │ │ │
│ │ │ │
crypto_plugin
│ │ │ │
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]
│ │ │ │
decrypt()
│ │ │ │
│ │ │ │ @@ -746,59 +746,59 @@
│ │ │ │ bool upload_only () const;
│ │ │ │ bool has_piece (piece_index_t i) const;
│ │ │ │ peer_id const& pid () const;
│ │ │ │ bool is_choked () const;
│ │ │ │ bool is_interesting () const;
│ │ │ │ bool is_peer_interested () const;
│ │ │ │ bool has_peer_choked () const;
│ │ │ │ - void maybe_unchoke_this_peer ();
│ │ │ │ void choke_this_peer ();
│ │ │ │ + void maybe_unchoke_this_peer ();
│ │ │ │ void get_peer_info (peer_info& p) const;
│ │ │ │ torrent_handle associated_torrent () const;
│ │ │ │ tcp::endpoint local_endpoint () const;
│ │ │ │ tcp::endpoint const& remote () const;
│ │ │ │ + bool is_connecting () const;
│ │ │ │ void disconnect (error_code const& ec, operation_t op
│ │ │ │ , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ - bool is_connecting () const;
│ │ │ │ - bool is_outgoing () const;
│ │ │ │ bool is_disconnecting () const;
│ │ │ │ + bool is_outgoing () const;
│ │ │ │ bool ignore_unchoke_slots () const;
│ │ │ │ bool on_local_network () const;
│ │ │ │ bool failed () 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]
│ │ │ │
│ │ │ │
bt_peer_connection_handle
│ │ │ │
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ │
The bt_peer_connection_handle provides a handle to the internal bittorrent
│ │ │ │ peer connection object to plugins. It's low level and may not be a stable API
│ │ │ │ across libtorrent versions.
│ │ │ │
│ │ │ │ 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 support_extensions () const;
│ │ │ │ bool supports_encryption () const;
│ │ │ │ - void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ + void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
create_ut_pex_plugin()
│ │ │ │
Declared in "libtorrent/extensions/ut_pex.hpp"
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -15,38 +15,38 @@
│ │ │ │ │ o _o_n___a_l_e_r_t_(_)
│ │ │ │ │ o _o_n___u_n_k_n_o_w_n___t_o_r_r_e_n_t_(_)
│ │ │ │ │ o _o_n___t_i_c_k_(_)
│ │ │ │ │ o _g_e_t___u_n_c_h_o_k_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ o _l_o_a_d___s_t_a_t_e_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___p_l_u_g_i_n
│ │ │ │ │ o _n_e_w___c_o_n_n_e_c_t_i_o_n_(_)
│ │ │ │ │ - o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)
│ │ │ │ │ + o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ - o _o_n___r_e_s_u_m_e_(_)_ _o_n___p_a_u_s_e_(_)
│ │ │ │ │ + o _o_n___p_a_u_s_e_(_)_ _o_n___r_e_s_u_m_e_(_)
│ │ │ │ │ o _o_n___f_i_l_e_s___c_h_e_c_k_e_d_(_)
│ │ │ │ │ o _o_n___s_t_a_t_e_(_)
│ │ │ │ │ o _o_n___a_d_d___p_e_e_r_(_)
│ │ │ │ │ * _p_e_e_r___p_l_u_g_i_n
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _a_d_d___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ o _o_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │ o _o_n___c_o_n_n_e_c_t_e_d_(_)
│ │ │ │ │ o _o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ o _o_n___e_x_t_e_n_s_i_o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ - o _o_n___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___h_a_v_e___a_l_l_(_)
│ │ │ │ │ - _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ - _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)
│ │ │ │ │ + o _o_n___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___r_e_q_u_e_s_t
│ │ │ │ │ + _(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ + _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___h_a_v_e_(_)
│ │ │ │ │ o _o_n___p_i_e_c_e_(_)
│ │ │ │ │ - o _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___u_n_c_h_o_k_e_(_)
│ │ │ │ │ - _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ + o _s_e_n_t___u_n_c_h_o_k_e_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ + _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ o _s_e_n_t___p_a_y_l_o_a_d_(_)
│ │ │ │ │ o _c_a_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │ o _o_n___e_x_t_e_n_d_e_d_(_)
│ │ │ │ │ o _o_n___u_n_k_n_o_w_n___m_e_s_s_a_g_e_(_)
│ │ │ │ │ - o _o_n___p_i_e_c_e___p_a_s_s_(_)_ _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)
│ │ │ │ │ + o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ o _w_r_i_t_e___r_e_q_u_e_s_t_(_)
│ │ │ │ │ * _c_r_y_p_t_o___p_l_u_g_i_n
│ │ │ │ │ o _d_e_c_r_y_p_t_(_)
│ │ │ │ │ * _p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e
│ │ │ │ │ * _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e
│ │ │ │ │ * _c_r_e_a_t_e___u_t___p_e_x___p_l_u_g_i_n_(_)
│ │ │ │ │ @@ -259,16 +259,16 @@
│ │ │ │ │ struct torrent_plugin
│ │ │ │ │ {
│ │ │ │ │ virtual std::shared_ptr
nneeww__ccoonnnneeccttiioonn (peer_connection_handle
│ │ │ │ │ const&);
│ │ │ │ │ virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ - virtual bool oonn__rreessuummee ();
│ │ │ │ │ virtual bool oonn__ppaauussee ();
│ │ │ │ │ + virtual bool oonn__rreessuummee ();
│ │ │ │ │ virtual void oonn__ffiilleess__cchheecckkeedd ();
│ │ │ │ │ virtual void oonn__ssttaattee (torrent_status::state_t);
│ │ │ │ │ virtual void oonn__aadddd__ppeeeerr (tcp::endpoint const&,
│ │ │ │ │ peer_source_flags_t, add_peer_flags_t);
│ │ │ │ │
│ │ │ │ │ static constexpr add_peer_flags_t ffiirrsstt__ttiimmee = 1_bit;
│ │ │ │ │ static constexpr add_peer_flags_t ffiilltteerreedd = 2_bit;
│ │ │ │ │ @@ -285,30 +285,30 @@
│ │ │ │ │ have its hook functions called on event specific to that peer.
│ │ │ │ │ The peer_connection_handle will be valid as long as the shared_ptr is being
│ │ │ │ │ held by the torrent object. So, it is generally a good idea to not keep a
│ │ │ │ │ shared_ptr to your own _p_e_e_r___p_l_u_g_i_n. If you want to keep references to it, use
│ │ │ │ │ weak_ptr.
│ │ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttiicckk(()) **********
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__rreessuummee(()) oonn__ppaauussee(()) **********
│ │ │ │ │ -virtual bool oonn__rreessuummee ();
│ │ │ │ │ +********** oonn__ppaauussee(()) oonn__rreessuummee(()) **********
│ │ │ │ │ virtual bool oonn__ppaauussee ();
│ │ │ │ │ +virtual bool oonn__rreessuummee ();
│ │ │ │ │ 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 _p_l_u_g_i_n after this one will have
│ │ │ │ │ this hook function called, and the standard handler will also not be invoked.
│ │ │ │ │ So, returning true effectively overrides the standard behavior of pause or
│ │ │ │ │ resume.
│ │ │ │ │ Note that if you call pause() or resume() on the torrent from your handler it
│ │ │ │ │ @@ -354,43 +354,43 @@
│ │ │ │ │ {
│ │ │ │ │ virtual string_view ttyyppee () const;
│ │ │ │ │ virtual void aadddd__hhaannddsshhaakkee (entry&);
│ │ │ │ │ virtual void oonn__ddiissccoonnnneecctt (error_code const&);
│ │ │ │ │ virtual void oonn__ccoonnnneecctteedd ();
│ │ │ │ │ virtual bool oonn__hhaannddsshhaakkee (span);
│ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&);
│ │ │ │ │ + virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ + virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ - virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ - virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ + virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ + virtual bool oonn__cchhookkee ();
│ │ │ │ │ virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ - virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ + virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual bool oonn__cchhookkee ();
│ │ │ │ │ - virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ - virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ - virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ + virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ + virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ + virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │ , span //**bbuuff**//);
│ │ │ │ │ virtual bool oonn__rreejjeecctt (peer_request const&);
│ │ │ │ │ - virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │ virtual bool oonn__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ + virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │ virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ + virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │ - virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │ - virtual void sseenntt__cchhookkee ();
│ │ │ │ │ - virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ + virtual void sseenntt__cchhookkee ();
│ │ │ │ │ + virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ + virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ - virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ + virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │ virtual bool ccaann__ddiissccoonnnneecctt (error_code const& //**eecc**//);
│ │ │ │ │ virtual bool oonn__eexxtteennddeedd (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ @@ -426,48 +426,48 @@
│ │ │ │ │ ********** oonn__eexxtteennssiioonn__hhaannddsshhaakkee(()) **********
│ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (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 _p_e_e_r___p_l_u_g_i_n being removed from the peer_connection and
│ │ │ │ │ destructed. this is not called for web seeds
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__uunncchhookkee(()) oonn__hhaavvee(()) oonn__ddoonntt__hhaavvee(()) oonn__cchhookkee(()) oonn__hhaavvee__aallll(())
│ │ │ │ │ -oonn__hhaavvee__nnoonnee(()) oonn__rreeqquueesstt(()) oonn__bbiittffiieelldd(()) oonn__iinntteerreesstteedd(()) oonn__nnoott__iinntteerreesstteedd(())
│ │ │ │ │ -oonn__aalllloowweedd__ffaasstt(()) **********
│ │ │ │ │ +********** oonn__uunncchhookkee(()) oonn__hhaavvee__aallll(()) oonn__cchhookkee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__rreeqquueesstt(())
│ │ │ │ │ +oonn__bbiittffiieelldd(()) oonn__iinntteerreesstteedd(()) oonn__ddoonntt__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee__nnoonnee(())
│ │ │ │ │ +oonn__hhaavvee(()) **********
│ │ │ │ │ +virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ +virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ -virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ +virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ +virtual bool oonn__cchhookkee ();
│ │ │ │ │ virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ -virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__cchhookkee ();
│ │ │ │ │ -virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ -virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ -virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ +virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ returning true from any of the message handlers indicates that the _p_l_u_g_i_n has
│ │ │ │ │ handled the message. it will break the _p_l_u_g_i_n chain traversing and not let
│ │ │ │ │ anyone else handle the message, including the default handler.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__ppiieeccee(()) **********
│ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │ , span //**bbuuff**//);
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseenntt__ppiieeccee(()) sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__uunncchhookkee(())
│ │ │ │ │ -sseenntt__iinntteerreesstteedd(()) **********
│ │ │ │ │ +********** sseenntt__uunncchhookkee(()) sseenntt__hhaavvee(()) sseenntt__ppiieeccee(()) sseenntt__iinntteerreesstteedd(())
│ │ │ │ │ +sseenntt__nnoott__iinntteerreesstteedd(()) **********
│ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ -virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ +virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ called after a choke message has been sent to the peer
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseenntt__ppaayyllooaadd(()) **********
│ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │ called after piece data has been sent to the peer this can be used for stats
│ │ │ │ │ book keeping
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -490,15 +490,15 @@
│ │ │ │ │ receiving large messages.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__uunnkknnoowwnn__mmeessssaaggee(()) **********
│ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ this is not called for web seeds
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__ppiieeccee__ppaassss(()) oonn__ppiieeccee__ffaaiilleedd(()) **********
│ │ │ │ │ +********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ called when a piece that this peer participated in either fails or passes the
│ │ │ │ │ hash_check
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttiicckk(()) **********
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ @@ -510,16 +510,16 @@
│ │ │ │ │ original request message won't be sent and no other _p_l_u_g_i_n will have this
│ │ │ │ │ function called.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ccrryyppttoo__pplluuggiinn ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_._h_p_p"
│ │ │ │ │ struct crypto_plugin
│ │ │ │ │ {
│ │ │ │ │ - virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ virtual void sseett__oouuttggooiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ + virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ eennccrryypptt (span> //**sseenndd__vveecc**//) = 0;
│ │ │ │ │ virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//
│ │ │ │ │ ) = 0;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddeeccrryypptt(()) **********
│ │ │ │ │ virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//) =
│ │ │ │ │ @@ -548,57 +548,57 @@
│ │ │ │ │ bool uuppllooaadd__oonnllyy () const;
│ │ │ │ │ bool hhaass__ppiieeccee (piece_index_t i) const;
│ │ │ │ │ peer_id const& ppiidd () const;
│ │ │ │ │ bool iiss__cchhookkeedd () const;
│ │ │ │ │ bool iiss__iinntteerreessttiinngg () const;
│ │ │ │ │ bool iiss__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │ bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │ - void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ void cchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ + void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (peer_info& p) const;
│ │ │ │ │ torrent_handle aassssoocciiaatteedd__ttoorrrreenntt () const;
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const;
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t const& rreemmoottee () const;
│ │ │ │ │ + bool iiss__ccoonnnneeccttiinngg () const;
│ │ │ │ │ void ddiissccoonnnneecctt (error_code const& ec, operation_t op
│ │ │ │ │ , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ │ - bool iiss__ccoonnnneeccttiinngg () const;
│ │ │ │ │ - bool iiss__oouuttggooiinngg () const;
│ │ │ │ │ bool iiss__ddiissccoonnnneeccttiinngg () const;
│ │ │ │ │ + bool iiss__oouuttggooiinngg () const;
│ │ │ │ │ bool iiggnnoorree__uunncchhookkee__sslloottss () const;
│ │ │ │ │ bool oonn__llooccaall__nneettwwoorrkk () const;
│ │ │ │ │ bool ffaaiilleedd () const;
│ │ │ │ │ void ppeeeerr__lloogg (peer_log_alert::direction_t direction
│ │ │ │ │ , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT
│ │ │ │ │ (4,5);
│ │ │ │ │ bool sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const;
│ │ │ │ │ bool ccaann__ddiissccoonnnneecctt (error_code const& ec) const;
│ │ │ │ │ bool hhaass__mmeettaaddaattaa () const;
│ │ │ │ │ bool iinn__hhaannddsshhaakkee () const;
│ │ │ │ │ void sseenndd__bbuuffffeerr (char const* begin, int size);
│ │ │ │ │ time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const;
│ │ │ │ │ std::time_t llaasstt__sseeeenn__ccoommpplleettee () const;
│ │ │ │ │ + bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │ bool ooppeerraattoorr!!== (peer_connection_handle const& o) const;
│ │ │ │ │ bool ooppeerraattoorr==== (peer_connection_handle const& o) const;
│ │ │ │ │ - bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ The _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e provides a handle to the internal bittorrent peer
│ │ │ │ │ connection object to plugins. It's low level and may not be a stable API across
│ │ │ │ │ libtorrent versions.
│ │ │ │ │ struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ │ {
│ │ │ │ │ explicit bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (peer_connection_handle pc);
│ │ │ │ │ - bool ssuuppppoorrtt__eexxtteennssiioonnss () const;
│ │ │ │ │ bool ppaacckkeett__ffiinniisshheedd () const;
│ │ │ │ │ + bool ssuuppppoorrtt__eexxtteennssiioonnss () const;
│ │ │ │ │ bool ssuuppppoorrttss__eennccrryyppttiioonn () const;
│ │ │ │ │ - void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ void sswwiittcchh__sseenndd__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ + void sswwiittcchh__rreeccvv__ccrryyppttoo (std::shared_ptr crypto);
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ccrreeaattee__uutt__ppeexx__pplluuggiinn(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_/_u_t___p_e_x_._h_p_p"
│ │ │ │ │ std::shared_ptr ccrreeaattee__uutt__ppeexx__pplluuggiinn (torrent_handle const&,
│ │ │ │ │ client_data_t);
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Resume_Data.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -38,22 +38,22 @@
│ │ │ │ - write_torrent_flags_t
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
read_resume_data()
│ │ │ │
Declared in "libtorrent/read_resume_data.hpp"
│ │ │ │
│ │ │ │ -add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ - , load_torrent_limits const& cfg = {});
│ │ │ │ -add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ - , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ , int piece_limit = 0x200000);
│ │ │ │ add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ +add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ + , load_torrent_limits const& cfg = {});
│ │ │ │ +add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ + , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │
│ │ │ │
these functions are used to parse resume data and populate the appropriate
│ │ │ │ fields in an add_torrent_params object. This object can then be used to add
│ │ │ │ the actual torrent_info object to and pass to session::add_torrent() or
│ │ │ │ session::async_add_torrent().
│ │ │ │
If the client wants to override any field that was loaded from the resume
│ │ │ │ data, e.g. save_path, those fields must be changed after loading resume
│ │ │ │ @@ -67,29 +67,29 @@
│ │ │ │ to torrent_info::parse_info_section().
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
write_resume_data() write_resume_data_buf()
│ │ │ │
Declared in "libtorrent/write_resume_data.hpp"
│ │ │ │
│ │ │ │ -std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │ entry write_resume_data (add_torrent_params const& atp);
│ │ │ │ +std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │
│ │ │ │
this function turns the resume data in an add_torrent_params object
│ │ │ │ into a bencoded structure
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
write_torrent_file_buf() write_torrent_file()
│ │ │ │
Declared in "libtorrent/write_resume_data.hpp"
│ │ │ │
│ │ │ │ -entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │ std::vector<char> write_torrent_file_buf (add_torrent_params const& atp
│ │ │ │ , write_torrent_flags_t flags);
│ │ │ │ -entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │
│ │ │ │
writes only the fields to create a .torrent file. This function may fail
│ │ │ │ with a std::system_error exception if:
│ │ │ │
│ │ │ │ - The add_torrent_params object passed to this function does not contain the
│ │ │ │ info dictionary (the ti field)
│ │ │ │ - The piece layers are not complete for all files that need them
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -6,22 +6,22 @@
│ │ │ │ │ * _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)
│ │ │ │ │ * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ * _w_r_i_t_e___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ rreeaadd__rreessuummee__ddaattaa(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_r_e_a_d___r_e_s_u_m_e___d_a_t_a_._h_p_p"
│ │ │ │ │ -add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ - , load_torrent_limits const& cfg = {});
│ │ │ │ │ -add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ - , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ │ add_torrent_params rreeaadd__rreessuummee__ddaattaa (bdecode_node const& rd
│ │ │ │ │ , int piece_limit = 0x200000);
│ │ │ │ │ add_torrent_params rreeaadd__rreessuummee__ddaattaa (bdecode_node const& rd
│ │ │ │ │ , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ │ +add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ + , load_torrent_limits const& cfg = {});
│ │ │ │ │ +add_torrent_params rreeaadd__rreessuummee__ddaattaa (span buffer
│ │ │ │ │ + , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ │ these functions are used to parse resume data and populate the appropriate
│ │ │ │ │ fields in an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object. This object can then be used to add the
│ │ │ │ │ actual _t_o_r_r_e_n_t___i_n_f_o object to and pass to session::add_torrent() or session::
│ │ │ │ │ async_add_torrent().
│ │ │ │ │ If the client wants to override any field that was loaded from the resume data,
│ │ │ │ │ e.g. save_path, those fields must be changed after loading resume data but
│ │ │ │ │ before adding the torrent.
│ │ │ │ │ @@ -31,26 +31,26 @@
│ │ │ │ │ limits on torrent sizes via load_torrent limits.
│ │ │ │ │ In order to support large torrents, it may also be necessary to raise the
│ │ │ │ │ _s_e_t_t_i_n_g_s___p_a_c_k_:_:_m_a_x___p_i_e_c_e___c_o_u_n_t setting and pass a higher limit to calls to
│ │ │ │ │ _t_o_r_r_e_n_t___i_n_f_o_:_:_p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ wwrriittee__rreessuummee__ddaattaa(()) wwrriittee__rreessuummee__ddaattaa__bbuuff(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_._h_p_p"
│ │ │ │ │ -std::vector wwrriittee__rreessuummee__ddaattaa__bbuuff (add_torrent_params const& atp);
│ │ │ │ │ entry wwrriittee__rreessuummee__ddaattaa (add_torrent_params const& atp);
│ │ │ │ │ +std::vector wwrriittee__rreessuummee__ddaattaa__bbuuff (add_torrent_params const& atp);
│ │ │ │ │ this function turns the resume data in an add_torrent_params object into a
│ │ │ │ │ bencoded structure
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ wwrriittee__ttoorrrreenntt__ffiillee__bbuuff(()) wwrriittee__ttoorrrreenntt__ffiillee(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_._h_p_p"
│ │ │ │ │ -entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp, write_torrent_flags_t
│ │ │ │ │ -flags);
│ │ │ │ │ +entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp);
│ │ │ │ │ std::vector wwrriittee__ttoorrrreenntt__ffiillee__bbuuff (add_torrent_params const& atp
│ │ │ │ │ , write_torrent_flags_t flags);
│ │ │ │ │ -entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp);
│ │ │ │ │ +entry wwrriittee__ttoorrrreenntt__ffiillee (add_torrent_params const& atp, write_torrent_flags_t
│ │ │ │ │ +flags);
│ │ │ │ │ writes only the fields to create a .torrent file. This function may fail with a
│ │ │ │ │ std::system_error exception if:
│ │ │ │ │ * The _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object passed to this function does not contain
│ │ │ │ │ the info dictionary (the ti field)
│ │ │ │ │ * The piece layers are not complete for all files that need them
│ │ │ │ │ The write_torrent_file_buf() overload returns the torrent file in bencoded
│ │ │ │ │ buffer form. This overload may be faster at the expense of lost flexibility to
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Session.html
│ │ │ │ @@ -54,89 +54,89 @@
│ │ │ │ - refresh_torrent_status() get_torrent_status()
│ │ │ │ - post_torrent_updates()
│ │ │ │ - post_session_stats()
│ │ │ │ - post_dht_stats()
│ │ │ │ - set_dht_state()
│ │ │ │ - get_torrents() find_torrent()
│ │ │ │ - async_add_torrent() add_torrent()
│ │ │ │ -- resume() is_paused() pause()
│ │ │ │ +- pause() resume() is_paused()
│ │ │ │ - is_dht_running()
│ │ │ │ - set_dht_storage()
│ │ │ │ - add_dht_node()
│ │ │ │ - dht_get_item()
│ │ │ │ - dht_get_item()
│ │ │ │ - dht_put_item()
│ │ │ │ - dht_put_item()
│ │ │ │ - dht_announce() dht_get_peers()
│ │ │ │ - dht_live_nodes()
│ │ │ │ - dht_sample_infohashes()
│ │ │ │ - dht_direct_request()
│ │ │ │ - add_extension()
│ │ │ │ - set_ip_filter() get_ip_filter()
│ │ │ │ - set_port_filter()
│ │ │ │ -- is_listening() listen_port() ssl_listen_port()
│ │ │ │ +- listen_port() ssl_listen_port() is_listening()
│ │ │ │ - set_peer_class_filter() get_peer_class_filter()
│ │ │ │ -- set_peer_class_type_filter() get_peer_class_type_filter()
│ │ │ │ +- get_peer_class_type_filter() set_peer_class_type_filter()
│ │ │ │ - create_peer_class()
│ │ │ │ - delete_peer_class()
│ │ │ │ -- set_peer_class() get_peer_class()
│ │ │ │ +- get_peer_class() set_peer_class()
│ │ │ │ - remove_torrent()
│ │ │ │ - apply_settings() get_settings()
│ │ │ │ -- pop_alerts() set_alert_notify() wait_for_alert()
│ │ │ │ +- set_alert_notify() wait_for_alert() pop_alerts()
│ │ │ │ - add_port_mapping() delete_port_mapping()
│ │ │ │ - reopen_network_sockets()
│ │ │ │ - native_handle()
│ │ │ │
│ │ │ │
│ │ │ │ -
- write_session_params() write_session_params_buf() read_session_params()
│ │ │ │ +
- write_session_params_buf() write_session_params() read_session_params()
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
session_params
│ │ │ │
Declared in "libtorrent/session_params.hpp"
│ │ │ │
The session_params is a parameters pack for configuring the session
│ │ │ │ before it's started.
│ │ │ │
│ │ │ │ struct session_params
│ │ │ │ {
│ │ │ │ - session_params (settings_pack const& sp);
│ │ │ │ - session_params ();
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │ - session_params (settings_pack const& sp
│ │ │ │ - , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ │ + session_params ();
│ │ │ │ + session_params (settings_pack const& sp);
│ │ │ │ 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);
│ │ │ │
│ │ │ │ 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;
│ │ │ │ libtorrent::ip_filter ip_filter;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
session_params()
│ │ │ │
│ │ │ │ -session_params (settings_pack const& sp);
│ │ │ │ -session_params ();
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │ +session_params ();
│ │ │ │ +session_params (settings_pack const& sp);
│ │ │ │
│ │ │ │
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()
│ │ │ │
│ │ │ │ -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);
│ │ │ │ +session_params (settings_pack const& 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]
│ │ │ │ - settings
│ │ │ │ - The settings to configure the session with
│ │ │ │
│ │ │ │ @@ -178,33 +178,33 @@
│ │ │ │ synchronize the completion of the shutdown. The lifetime of this object
│ │ │ │ may outlive
session, causing the
session destructor to not block. The
│ │ │ │
session_proxy destructor will block however, until the underlying
session
│ │ │ │ is done shutting down.
│ │ │ │
│ │ │ │ struct session_proxy
│ │ │ │ {
│ │ │ │ + session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ session_proxy ();
│ │ │ │ session_proxy& operator= (session_proxy const&) &;
│ │ │ │ - ~session_proxy ();
│ │ │ │ - session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ + ~session_proxy ();
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
~session_proxy() operator=() session_proxy()
│ │ │ │
│ │ │ │ +session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ session_proxy ();
│ │ │ │ session_proxy& operator= (session_proxy const&) &;
│ │ │ │ -~session_proxy ();
│ │ │ │ -session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ +~session_proxy ();
│ │ │ │
│ │ │ │
default constructor, does not refer to any session
│ │ │ │ implementation object.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
session
│ │ │ │ @@ -218,52 +218,52 @@
│ │ │ │
session_handle::apply_settings() member function. To change one or more
│ │ │ │ configuration options, create a
settings_pack. object and fill it with
│ │ │ │ the settings to be set and pass it in to
session::apply_settings().
│ │ │ │
see apply_settings().
│ │ │ │
│ │ │ │ struct session : session_handle
│ │ │ │ {
│ │ │ │ - session ();
│ │ │ │ - session (session_params&& params, session_flags_t flags);
│ │ │ │ session (session_params const& params, session_flags_t flags);
│ │ │ │ - explicit session (session_params const& params);
│ │ │ │ explicit session (session_params&& params);
│ │ │ │ - session (session_params&& params, io_context& ios);
│ │ │ │ + session (session_params&& params, session_flags_t flags);
│ │ │ │ + session ();
│ │ │ │ + explicit session (session_params const& params);
│ │ │ │ session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ - session (session_params const& params, io_context& ios);
│ │ │ │ + session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ + session (session_params const& params, io_context& ios);
│ │ │ │ ~session ();
│ │ │ │ session_proxy abort ();
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
session()
│ │ │ │
│ │ │ │ -session ();
│ │ │ │ -session (session_params&& params, session_flags_t flags);
│ │ │ │ session (session_params const& params, session_flags_t flags);
│ │ │ │ -explicit session (session_params const& params);
│ │ │ │ explicit session (session_params&& params);
│ │ │ │ +session (session_params&& params, session_flags_t flags);
│ │ │ │ +session ();
│ │ │ │ +explicit session (session_params const& params);
│ │ │ │
│ │ │ │
Constructs the session objects which acts as the container of torrents.
│ │ │ │ In order to avoid a race condition between starting the session and
│ │ │ │ configuring it, you can pass in a session_params object. Its settings
│ │ │ │ will take effect before the session starts up.
│ │ │ │
The overloads taking flags can be used to start a session in
│ │ │ │ paused mode (by passing in session::paused). Note that
│ │ │ │ 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 (session_params&& params, io_context& ios);
│ │ │ │ session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ -session (session_params const& params, io_context& ios);
│ │ │ │ +session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params const& params, io_context& ios);
│ │ │ │
│ │ │ │
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.
│ │ │ │
│ │ │ │ @@ -318,30 +318,30 @@
│ │ │ │ any operation on it will throw a system_error exception, with error code
│ │ │ │ invalid_session_handle.
│ │ │ │
│ │ │ │ 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 const& st);
│ │ │ │ void set_dht_state (dht::dht_state&& st);
│ │ │ │ - std::vector<torrent_handle> get_torrents () const;
│ │ │ │ + void set_dht_state (dht::dht_state const& st);
│ │ │ │ torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ - void async_add_torrent (add_torrent_params&& params);
│ │ │ │ + std::vector<torrent_handle> get_torrents () const;
│ │ │ │ + torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ + void async_add_torrent (add_torrent_params&& params);
│ │ │ │ void async_add_torrent (add_torrent_params const& params);
│ │ │ │ - torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ void pause ();
│ │ │ │ bool is_paused () const;
│ │ │ │ void resume ();
│ │ │ │ bool is_dht_running () const;
│ │ │ │ void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ │ @@ -350,40 +350,40 @@
│ │ │ │ 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_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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │ 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::shared_ptr<plugin> ext);
│ │ │ │ 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 ssl_listen_port () const;
│ │ │ │ unsigned short listen_port () const;
│ │ │ │ + unsigned short ssl_listen_port () 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_type_filter get_peer_class_type_filter () const;
│ │ │ │ peer_class_t create_peer_class (char const* name);
│ │ │ │ void delete_peer_class (peer_class_t cid);
│ │ │ │ void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │ void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ │ + settings_pack get_settings () const;
│ │ │ │ void apply_settings (settings_pack&&);
│ │ │ │ void apply_settings (settings_pack const&);
│ │ │ │ - settings_pack get_settings () const;
│ │ │ │ alert* wait_for_alert (time_duration max_wait);
│ │ │ │ void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ 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;
│ │ │ │ @@ -425,19 +425,19 @@
│ │ │ │ the flags parameter can be used to only save certain parts of the
│ │ │ │ session state
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
refresh_torrent_status() get_torrent_status()
│ │ │ │
│ │ │ │ -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.
│ │ │ │
│ │ │ │ @@ -501,45 +501,45 @@
│ │ │ │ void
post_dht_stats ();
│ │ │ │
│ │ │ │
This will cause a dht_stats_alert to be posted.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
set_dht_state()
│ │ │ │
│ │ │ │ -void set_dht_state (dht::dht_state const& st);
│ │ │ │ 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]
│ │ │ │
│ │ │ │
get_torrents() find_torrent()
│ │ │ │
│ │ │ │ -std::vector<torrent_handle> get_torrents () const;
│ │ │ │ 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]
│ │ │ │
│ │ │ │
async_add_torrent() add_torrent()
│ │ │ │
│ │ │ │ -void async_add_torrent (add_torrent_params&& params);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ │ void async_add_torrent (add_torrent_params const& params);
│ │ │ │ -torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ torrent_handle add_torrent (add_torrent_params const& 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
│ │ │ │ @@ -561,19 +561,19 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
resume() is_paused() pause()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
pause() resume() is_paused()
│ │ │ │
│ │ │ │ void pause ();
│ │ │ │ bool is_paused () const;
│ │ │ │ void resume ();
│ │ │ │
│ │ │ │
Pausing the session has the same effect as pausing every torrent in
│ │ │ │ it, except that torrents will not be resumed by the auto-manage
│ │ │ │ @@ -690,16 +690,16 @@
│ │ │ │ the DHT works, it is natural to always do a lookup before storing and
│ │ │ │ calling the callback in between is convenient.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
dht_announce() dht_get_peers()
│ │ │ │
│ │ │ │ -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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │
│ │ │ │
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
│ │ │ │ @@ -743,17 +743,17 @@
│ │ │ │ with the response (if any) and the userdata pointer passed in here.
│ │ │ │ Since this alert is a response to an explicit call, it will always be
│ │ │ │ posted, regardless of the alert mask.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_extension()
│ │ │ │
│ │ │ │ +void add_extension (std::shared_ptr<plugin> ext);
│ │ │ │ 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);
│ │ │ │
│ │ │ │
This function adds an extension to this session. The argument is a
│ │ │ │ function object that is called with a torrent_handle and which should
│ │ │ │ return a std::shared_ptr<torrent_plugin>. To write custom
│ │ │ │ plugins, see libtorrent plugins. For the typical bittorrent client
│ │ │ │ all of these extensions should be added. The main plugins implemented
│ │ │ │ in libtorrent are:
│ │ │ │ @@ -806,23 +806,23 @@
│ │ │ │
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
is_listening() listen_port() ssl_listen_port()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
listen_port() ssl_listen_port() is_listening()
│ │ │ │
│ │ │ │ bool is_listening () const;
│ │ │ │ -unsigned short ssl_listen_port () const;
│ │ │ │ unsigned short listen_port () const;
│ │ │ │ +unsigned short ssl_listen_port () 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.
│ │ │ │ @@ -856,21 +856,21 @@
│ │ │ │ 32 bits in the IP range mapping. Only the set bits matter; no peer
│ │ │ │ class will be removed from a peer as a result of this call, peer
│ │ │ │ classes are only added.
│ │ │ │
The peer_class argument cannot be greater than 31. The bitmasks
│ │ │ │ representing peer classes in the peer_class_filter are 32 bits.
│ │ │ │
The get_peer_class_filter() function returns the current filter.
│ │ │ │
For more information, see peer classes.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
set_peer_class_type_filter() get_peer_class_type_filter()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_peer_class_type_filter() set_peer_class_type_filter()
│ │ │ │
│ │ │ │ -peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ +peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │
│ │ │ │
Sets and gets the peer class type filter. This is controls automatic
│ │ │ │ peer class assignments to peers based on what kind of socket it is.
│ │ │ │
It does not only support assigning peer classes, it also supports
│ │ │ │ removing peer classes based on socket type.
│ │ │ │
The order of these rules being applied are:
│ │ │ │
│ │ │ │ @@ -909,18 +909,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]
│ │ │ │ -
│ │ │ │ -
set_peer_class() get_peer_class()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_peer_class() set_peer_class()
│ │ │ │
│ │ │ │ void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ peer_class_info get_peer_class (peer_class_t cid) const;
│ │ │ │
│ │ │ │
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
│ │ │ │ @@ -968,26 +968,26 @@
│ │ │ │ advised to remove them from the back of the queue, to minimize the
│ │ │ │ shifting.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
apply_settings() get_settings()
│ │ │ │
│ │ │ │ +settings_pack get_settings () const;
│ │ │ │ void apply_settings (settings_pack&&);
│ │ │ │ void apply_settings (settings_pack const&);
│ │ │ │ -settings_pack get_settings () 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]
│ │ │ │ -
│ │ │ │ -
pop_alerts() set_alert_notify() wait_for_alert()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_alert_notify() wait_for_alert() pop_alerts()
│ │ │ │
│ │ │ │ alert* wait_for_alert (time_duration max_wait);
│ │ │ │ void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ void set_alert_notify (std::function<void()> const& fun);
│ │ │ │
│ │ │ │
Alerts is the main mechanism for libtorrent to report errors and
│ │ │ │ events. pop_alerts fills in the vector passed to it with pointers
│ │ │ │ @@ -1117,29 +1117,29 @@
│ │ │ │ [report issue]
│ │ │ │ - reopen_map_ports
│ │ │ │ - This option indicates if the ports are mapped using natpmp
│ │ │ │ and upnp. If mapping was already made, they are deleted and added
│ │ │ │ again. This only works if natpmp and/or upnp are configured to be
│ │ │ │ enable.
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │
│ │ │ │ -
│ │ │ │ -
write_session_params() write_session_params_buf() read_session_params()
│ │ │ │ +
│ │ │ │ +
write_session_params_buf() write_session_params() read_session_params()
│ │ │ │
Declared in "libtorrent/session_params.hpp"
│ │ │ │
│ │ │ │ -entry write_session_params (session_params const& sp
│ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ -std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │ +session_params read_session_params (span<char const> buf
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ session_params read_session_params (bdecode_node const& e
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ -session_params read_session_params (span<char const> buf
│ │ │ │ +std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ +entry write_session_params (session_params const& sp
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │
│ │ │ │
These functions serialize and de-serialize a session_params object to and
│ │ │ │ from bencoded form. The session_params object is used to initialize a new
│ │ │ │ session using the state from a previous one (or by programmatically configure
│ │ │ │ the session up-front).
│ │ │ │ The flags parameter can be used to only save and load certain aspects of the
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -19,79 +19,79 @@
│ │ │ │ │ o _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)
│ │ │ │ │ o _p_o_s_t___t_o_r_r_e_n_t___u_p_d_a_t_e_s_(_)
│ │ │ │ │ o _p_o_s_t___s_e_s_s_i_o_n___s_t_a_t_s_(_)
│ │ │ │ │ o _p_o_s_t___d_h_t___s_t_a_t_s_(_)
│ │ │ │ │ o _s_e_t___d_h_t___s_t_a_t_e_(_)
│ │ │ │ │ o _g_e_t___t_o_r_r_e_n_t_s_(_)_ _f_i_n_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ o _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)_ _a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ - o _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ + o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_)
│ │ │ │ │ o _i_s___d_h_t___r_u_n_n_i_n_g_(_)
│ │ │ │ │ o _s_e_t___d_h_t___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _a_d_d___d_h_t___n_o_d_e_(_)
│ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___a_n_n_o_u_n_c_e_(_)_ _d_h_t___g_e_t___p_e_e_r_s_(_)
│ │ │ │ │ o _d_h_t___l_i_v_e___n_o_d_e_s_(_)
│ │ │ │ │ o _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s_(_)
│ │ │ │ │ o _d_h_t___d_i_r_e_c_t___r_e_q_u_e_s_t_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ o _s_e_t___i_p___f_i_l_t_e_r_(_)_ _g_e_t___i_p___f_i_l_t_e_r_(_)
│ │ │ │ │ o _s_e_t___p_o_r_t___f_i_l_t_e_r_(_)
│ │ │ │ │ - o _i_s___l_i_s_t_e_n_i_n_g_(_)_ _l_i_s_t_e_n___p_o_r_t_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)
│ │ │ │ │ + o _l_i_s_t_e_n___p_o_r_t_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_)
│ │ │ │ │ o _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)
│ │ │ │ │ - o _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)
│ │ │ │ │ + o _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)
│ │ │ │ │ o _c_r_e_a_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _d_e_l_e_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ - o _s_e_t___p_e_e_r___c_l_a_s_s_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ + o _g_e_t___p_e_e_r___c_l_a_s_s_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ │ o _a_p_p_l_y___s_e_t_t_i_n_g_s_(_)_ _g_e_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ - o _p_o_p___a_l_e_r_t_s_(_)_ _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)
│ │ │ │ │ + o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)_ _p_o_p___a_l_e_r_t_s_(_)
│ │ │ │ │ o _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)_ _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │ o _r_e_o_p_e_n___n_e_t_w_o_r_k___s_o_c_k_e_t_s_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ - * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ + * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn__ppaarraammss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ The _s_e_s_s_i_o_n___p_a_r_a_m_s is a parameters pack for configuring the _s_e_s_s_i_o_n before it's
│ │ │ │ │ started.
│ │ │ │ │ struct session_params
│ │ │ │ │ {
│ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ - sseessssiioonn__ppaarraammss ();
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ - , std::vector> exts);
│ │ │ │ │ + sseessssiioonn__ppaarraammss ();
│ │ │ │ │ + sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ , std::vector> exts);
│ │ │ │ │ + sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ + , std::vector> exts);
│ │ │ │ │
│ │ │ │ │ settings_pack settings;
│ │ │ │ │ std::vector> extensions;
│ │ │ │ │ dht::dht_state dht_state;
│ │ │ │ │ dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │ │ disk_io_constructor_type disk_io_constructor;
│ │ │ │ │ std::map ext_state;
│ │ │ │ │ libtorrent::ip_filter ip_filter;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ -sseessssiioonn__ppaarraammss ();
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ +sseessssiioonn__ppaarraammss ();
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ This constructor can be used to start with the default plugins (ut_metadata,
│ │ │ │ │ ut_pex and smart_ban). Pass a _s_e_t_t_i_n_g_s___p_a_c_k to set the initial settings when
│ │ │ │ │ the _s_e_s_s_i_o_n starts.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ - , std::vector> exts);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ , std::vector> exts);
│ │ │ │ │ +sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ + , std::vector> exts);
│ │ │ │ │ This constructor helps to configure the set of initial plugins to be added to
│ │ │ │ │ the _s_e_s_s_i_o_n before it's started.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ settings
│ │ │ │ │ The settings to configure the _s_e_s_s_i_o_n with
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ extensions
│ │ │ │ │ @@ -122,29 +122,29 @@
│ │ │ │ │ _s_e_s_s_i_o_n destruction is explicitly initiated, this holder is used to synchronize
│ │ │ │ │ the completion of the shutdown. The lifetime of this object may outlive
│ │ │ │ │ _s_e_s_s_i_o_n, causing the _s_e_s_s_i_o_n destructor to not block. The _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ destructor will block however, until the underlying _s_e_s_s_i_o_n is done shutting
│ │ │ │ │ down.
│ │ │ │ │ struct session_proxy
│ │ │ │ │ {
│ │ │ │ │ + session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ - ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ - session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ + ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ +session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ -~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ +~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ default constructor, does not refer to any _s_e_s_s_i_o_n implementation object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p"
│ │ │ │ │ The _s_e_s_s_i_o_n holds all state that spans multiple torrents. Among other things it
│ │ │ │ │ runs the network loop and manages all torrents. Once it's created, the _s_e_s_s_i_o_n
│ │ │ │ │ object will spawn the main thread that will do all the work. The main thread
│ │ │ │ │ @@ -152,47 +152,47 @@
│ │ │ │ │ You have some control over _s_e_s_s_i_o_n configuration through the session_handle::
│ │ │ │ │ apply_settings() member function. To change one or more configuration options,
│ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k. object and fill it with the settings to be set and pass
│ │ │ │ │ it in to session::apply_settings().
│ │ │ │ │ see _a_p_p_l_y___s_e_t_t_i_n_g_s_(_).
│ │ │ │ │ struct session : session_handle
│ │ │ │ │ {
│ │ │ │ │ - sseessssiioonn ();
│ │ │ │ │ - sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ - explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ + sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ + sseessssiioonn ();
│ │ │ │ │ + explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ + sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ + sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ ~~sseessssiioonn ();
│ │ │ │ │ session_proxy aabboorrtt ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn ();
│ │ │ │ │ -sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ -explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ +sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ +sseessssiioonn ();
│ │ │ │ │ +explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ Constructs the _s_e_s_s_i_o_n objects which acts as the container of torrents. In
│ │ │ │ │ order to avoid a race condition between starting the _s_e_s_s_i_o_n and configuring
│ │ │ │ │ it, you can pass in a _s_e_s_s_i_o_n___p_a_r_a_m_s object. Its settings will take effect
│ │ │ │ │ before the _s_e_s_s_i_o_n starts up.
│ │ │ │ │ The overloads taking flags can be used to start a _s_e_s_s_i_o_n in paused mode (by
│ │ │ │ │ passing in session::paused). Note that add_default_plugins do not have an
│ │ │ │ │ affect on constructors that take a _s_e_s_s_i_o_n___p_a_r_a_m_s object. It already contains
│ │ │ │ │ the plugins to use.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ +sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ Overload of the constructor that takes an external io_context to run the
│ │ │ │ │ _s_e_s_s_i_o_n 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.
│ │ │ │ │ Warning
│ │ │ │ │ The _s_e_s_s_i_o_n object does not cleanly terminate with an external io_context. The
│ │ │ │ │ @@ -232,30 +232,30 @@
│ │ │ │ │ operation on it will throw a system_error exception, with error code
│ │ │ │ │ invalid_session_handle.
│ │ │ │ │ struct session_handle
│ │ │ │ │ {
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ session_params sseessssiioonn__ssttaattee (save_state_flags_t flags =
│ │ │ │ │ save_state_flags_t::all()) const;
│ │ │ │ │ - void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ - , status_flags_t flags = {}) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss (
│ │ │ │ │ std::function const& pred
│ │ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ │ + void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ + , status_flags_t flags = {}) const;
│ │ │ │ │ void ppoosstt__ttoorrrreenntt__uuppddaatteess (status_flags_t flags = status_flags_t::all());
│ │ │ │ │ void ppoosstt__sseessssiioonn__ssttaattss ();
│ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ - void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ - std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ + void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ + std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code&
│ │ │ │ │ ec);
│ │ │ │ │ void ppaauussee ();
│ │ │ │ │ bool iiss__ppaauusseedd () const;
│ │ │ │ │ void rreessuummee ();
│ │ │ │ │ bool iiss__ddhhtt__rruunnnniinngg () const;
│ │ │ │ │ @@ -265,43 +265,43 @@
│ │ │ │ │ void ddhhtt__ggeett__iitteemm (std::array key
│ │ │ │ │ , std::string salt = std::string());
│ │ │ │ │ sha1_hash ddhhtt__ppuutt__iitteemm (entry data);
│ │ │ │ │ void ddhhtt__ppuutt__iitteemm (std::array key
│ │ │ │ │ , std::function&
│ │ │ │ │ , std::int64_t&, std::string const&)> cb
│ │ │ │ │ , std::string salt = std::string());
│ │ │ │ │ + void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │ announce_flags_t flags = {});
│ │ │ │ │ - void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__lliivvee__nnooddeess (sha1_hash const& nid);
│ │ │ │ │ void ddhhtt__ssaammppllee__iinnffoohhaasshheess (udp::endpoint const& ep, sha1_hash const&
│ │ │ │ │ target);
│ │ │ │ │ void ddhhtt__ddiirreecctt__rreeqquueesstt (udp::endpoint const& ep, entry const& e,
│ │ │ │ │ client_data_t userdata = {});
│ │ │ │ │ + void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ - void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ - unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ + unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ - peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ + peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ peer_class_t ccrreeaattee__ppeeeerr__ccllaassss (char const* name);
│ │ │ │ │ void ddeelleettee__ppeeeerr__ccllaassss (peer_class_t cid);
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │ void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ │ + settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ - settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ │ external_port, int local_port);
│ │ │ │ │ void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options =
│ │ │ │ │ @@ -334,19 +334,19 @@
│ │ │ │ │ returns the current _s_e_s_s_i_o_n state. This can be passed to _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ to save the state to disk and restored using _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) when
│ │ │ │ │ constructing a new _s_e_s_s_i_o_n. 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 _s_e_s_s_i_o_n state
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__ttoorrrreenntt__ssttaattuuss(()) **********
│ │ │ │ │ -void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ - , status_flags_t flags = {}) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss (
│ │ │ │ │ std::function const& pred
│ │ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ │ +void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* 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.
│ │ │ │ │ get_torrent_status returns a vector of the _t_o_r_r_e_n_t___s_t_a_t_u_s for every torrent
│ │ │ │ │ which satisfies pred, which is a predicate function which determines if a
│ │ │ │ │ torrent should be included in the returned set or not. Returning true means it
│ │ │ │ │ @@ -391,35 +391,35 @@
│ │ │ │ │ For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppoosstt__ddhhtt__ssttaattss(()) **********
│ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) **********
│ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next
│ │ │ │ │ time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on
│ │ │ │ │ startup.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) **********
│ │ │ │ │ -std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ +std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ find_torrent() looks for a torrent with the given info-hash. In case there is
│ │ │ │ │ such a torrent in the _s_e_s_s_i_o_n, a _t_o_r_r_e_n_t___h_a_n_d_l_e to that torrent is returned. In
│ │ │ │ │ case the torrent cannot be found, an invalid _t_o_r_r_e_n_t___h_a_n_d_l_e 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 _s_e_s_s_i_o_n.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aassyynncc__aadddd__ttoorrrreenntt(()) aadddd__ttoorrrreenntt(()) **********
│ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ │ You add torrents through the _a_d_d___t_o_r_r_e_n_t_(_) function where you give an object
│ │ │ │ │ with all the parameters. The _a_d_d___t_o_r_r_e_n_t_(_) overloads will block until the
│ │ │ │ │ torrent has been added (or failed to be added) and returns an error code and a
│ │ │ │ │ _t_o_r_r_e_n_t___h_a_n_d_l_e. In order to add torrents more efficiently, consider using
│ │ │ │ │ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) which returns immediately, without waiting for the torrent
│ │ │ │ │ @@ -438,15 +438,15 @@
│ │ │ │ │ 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 _B_i_t_T_o_r_r_e_n_t_ _v_2_ _t_o_r_r_e_n_t_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rreessuummee(()) iiss__ppaauusseedd(()) ppaauussee(()) **********
│ │ │ │ │ +********** ppaauussee(()) rreessuummee(()) iiss__ppaauusseedd(()) **********
│ │ │ │ │ void ppaauussee ();
│ │ │ │ │ bool iiss__ppaauusseedd () const;
│ │ │ │ │ void rreessuummee ();
│ │ │ │ │ Pausing the _s_e_s_s_i_o_n 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 _s_e_s_s_i_o_n pause
│ │ │ │ │ state is separate from the torrent pause state. A torrent is inactive if it is
│ │ │ │ │ @@ -526,17 +526,17 @@
│ │ │ │ │ value is computed via a function instead of just passing in the new value is to
│ │ │ │ │ avoid race conditions. If you want to uuppddaattee 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddhhtt__aannnnoouunnccee(()) ddhhtt__ggeett__ppeeeerrss(()) **********
│ │ │ │ │ +void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │ announce_flags_t flags = {});
│ │ │ │ │ -void ddhhtt__ggeett__ppeeeerrss (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
│ │ │ │ │ _d_h_t___g_e_t___p_e_e_r_s___r_e_p_l_y___a_l_e_r_t.
│ │ │ │ │ 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 source port (which may improve
│ │ │ │ │ connectivity through a NAT).
│ │ │ │ │ @@ -567,17 +567,17 @@
│ │ │ │ │ Send an arbitrary DHT request directly to the specified endpoint. This function
│ │ │ │ │ is intended for use by plugins. When a response is received or the request
│ │ │ │ │ times out, a _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t will be posted with the response (if
│ │ │ │ │ any) and the userdata pointer passed in here. Since this _a_l_e_r_t is a response to
│ │ │ │ │ an explicit call, it will always be posted, regardless of the _a_l_e_r_t mask.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__eexxtteennssiioonn(()) **********
│ │ │ │ │ +void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ -void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ This function adds an extension to this _s_e_s_s_i_o_n. The argument is a function
│ │ │ │ │ object that is called with a torrent_handle and which should return a std::
│ │ │ │ │ shared_ptr. To write custom plugins, see _l_i_b_t_o_r_r_e_n_t_ _p_l_u_g_i_n_s.
│ │ │ │ │ For the typical bittorrent client all of these extensions should be added. The
│ │ │ │ │ main plugins implemented in libtorrent are:
│ │ │ │ │ uTorrent metadata
│ │ │ │ │ Allows peers to download the metadata (.torrent files) from the swarm
│ │ │ │ │ @@ -610,18 +610,18 @@
│ │ │ │ │ ********** sseett__ppoorrtt__ffiilltteerr(()) **********
│ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ apply _p_o_r_t___f_i_l_t_e_r 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iiss__lliisstteenniinngg(()) lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ +********** lliisstteenn__ppoorrtt(()) ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) **********
│ │ │ │ │ bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ -unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ +unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ is_listening() will tell you whether or not the _s_e_s_s_i_o_n has successfully opened
│ │ │ │ │ a listening port. If it hasn't, this function will return false, and then you
│ │ │ │ │ can set a new _s_e_t_t_i_n_g_s___p_a_c_k_:_:_l_i_s_t_e_n___i_n_t_e_r_f_a_c_e_s to try another interface and
│ │ │ │ │ port to bind to.
│ │ │ │ │ listen_port() returns the port we ended up listening on.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) **********
│ │ │ │ │ @@ -647,17 +647,17 @@
│ │ │ │ │ in the IP range mapping. Only the set bits matter; no peer class will be
│ │ │ │ │ removed from a peer as a result of this call, peer classes are only added.
│ │ │ │ │ The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ │ peer classes in the peer_class_filter are 32 bits.
│ │ │ │ │ The get_peer_class_filter() function returns the current filter.
│ │ │ │ │ For more information, see _p_e_e_r_ _c_l_a_s_s_e_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) **********
│ │ │ │ │ -peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr(()) **********
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ +peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ Sets and gets the ppeeeerr ccllaassss ttyyppee ffiilltteerr. This is controls automatic peer class
│ │ │ │ │ assignments to peers based on what kind of socket it is.
│ │ │ │ │ It does not only support assigning peer classes, it also supports removing peer
│ │ │ │ │ classes based on socket type.
│ │ │ │ │ The order of these rules being applied are:
│ │ │ │ │ 1. peer-class IP filter
│ │ │ │ │ 2. peer-class type filter, removing classes
│ │ │ │ │ @@ -685,15 +685,15 @@
│ │ │ │ │ Since peer classes are reference counted, this function will not 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 _s_e_s_s_i_o_n object destructs.
│ │ │ │ │ For more information on peer classes, see _p_e_e_r_ _c_l_a_s_s_e_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss(()) ggeett__ppeeeerr__ccllaassss(()) **********
│ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss(()) sseett__ppeeeerr__ccllaassss(()) **********
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │ 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 return value of
│ │ │ │ │ get_peer_class() is undefined.
│ │ │ │ │ set_peer_class() sets all the information in the _p_e_e_r___c_l_a_s_s___i_n_f_o object in the
│ │ │ │ │ @@ -726,22 +726,22 @@
│ │ │ │ │ Note that when a queued or downloading torrent is removed, its position in the
│ │ │ │ │ download queue is vacated and every subsequent torrent in the queue has their
│ │ │ │ │ queue positions updated. This can potentially cause a large state_update to be
│ │ │ │ │ posted. When removing all torrents, it is advised to remove them from the back
│ │ │ │ │ of the queue, to minimize the shifting.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aappppllyy__sseettttiinnggss(()) ggeett__sseettttiinnggss(()) **********
│ │ │ │ │ +settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ -settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous
│ │ │ │ │ operation that will return immediately and actually apply the settings to the
│ │ │ │ │ main thread of libtorrent some time later.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoopp__aalleerrttss(()) sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) **********
│ │ │ │ │ +********** sseett__aalleerrtt__nnoottiiffyy(()) wwaaiitt__ffoorr__aalleerrtt(()) ppoopp__aalleerrttss(()) **********
│ │ │ │ │ alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ 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
│ │ │ │ │ _s_e_s_s_i_o_n still owns these alerts and they will stay valid until the next time
│ │ │ │ │ pop_alerts is called. You may not delete the _a_l_e_r_t objects.
│ │ │ │ │ @@ -840,24 +840,24 @@
│ │ │ │ │ protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ reopen_map_ports
│ │ │ │ │ This option indicates if the ports are mapped using natpmp and upnp. If
│ │ │ │ │ mapping was already made, they are deleted and added again. This only
│ │ │ │ │ works if natpmp and/or upnp are configured to be enable.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(())
│ │ │ │ │ +************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) wwrriittee__sseessssiioonn__ppaarraammss(()) rreeaadd__sseessssiioonn__ppaarraammss(())
│ │ │ │ │ ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ -entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ -std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp
│ │ │ │ │ +session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ +std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp
│ │ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ +entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ These functions serialize and de-serialize a session_params object to and from
│ │ │ │ │ bencoded form. The _s_e_s_s_i_o_n___p_a_r_a_m_s object is used to initialize a new _s_e_s_s_i_o_n
│ │ │ │ │ using the state from a previous one (or by programmatically configure the
│ │ │ │ │ _s_e_s_s_i_o_n up-front). The flags parameter can be used to only save and load
│ │ │ │ │ certain aspects of the session's state. The _buf suffix indicates the function
│ │ │ │ │ operates on buffer rather than the bencoded structure. The torrents in a
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Settings.html
│ │ │ │ @@ -33,30 +33,30 @@
│ │ │ │ Table of contents
│ │ │ │
│ │ │ │
│ │ │ │
You have some control over session configuration through the session::apply_settings()
│ │ │ │ member function. To change one or more configuration options, create a settings_pack
│ │ │ │ object and fill it with the settings to be set and pass it in to session::apply_settings().
│ │ │ │
The settings_pack object is a collection of settings updates that are applied
│ │ │ │ @@ -4562,23 +4562,23 @@
│ │ │ │ i2p_port).
│ │ │ │
│ │ │ │ struct settings_pack final : settings_interface
│ │ │ │ {
│ │ │ │ friend void apply_pack_impl (settings_pack const*
│ │ │ │ , aux::session_settings_single_thread&
│ │ │ │ , std::vector<void(aux::session_impl::*)()>*);
│ │ │ │ - void set_str (int name, std::string val) override;
│ │ │ │ - void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ void set_bool (int name, bool val) override;
│ │ │ │ void set_int (int name, int val) override;
│ │ │ │ + void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ + void set_str (int name, std::string val) override;
│ │ │ │ bool has_val (int name) const override;
│ │ │ │ void clear ();
│ │ │ │ void clear (int name);
│ │ │ │ - int get_int (int name) const override;
│ │ │ │ bool get_bool (int name) const override;
│ │ │ │ + int get_int (int name) const override;
│ │ │ │ std::string const& get_str (int name) const override;
│ │ │ │ void for_each (Fun&& f) const;
│ │ │ │
│ │ │ │ enum type_bases
│ │ │ │ {
│ │ │ │ string_type_base,
│ │ │ │ int_type_base,
│ │ │ │ @@ -4654,18 +4654,18 @@
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
set_bool() set_str() set_int()
│ │ │ │
│ │ │ │ -void set_str (int name, std::string val) override;
│ │ │ │ -void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ void set_bool (int name, bool val) override;
│ │ │ │ void set_int (int name, int val) override;
│ │ │ │ +void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +void set_str (int name, std::string val) override;
│ │ │ │
│ │ │ │
set a configuration option in the settings_pack. name is one of
│ │ │ │ the enum values from string_types, int_types or bool_types. They must
│ │ │ │ match the respective type of the set_* function.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
has_val()
│ │ │ │ @@ -4686,21 +4686,21 @@
│ │ │ │
│ │ │ │
clear()
│ │ │ │
│ │ │ │ void clear (int name);
│ │ │ │
│ │ │ │
clear a specific setting from the pack
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
get_str() get_bool() get_int()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_str() get_int() get_bool()
│ │ │ │
│ │ │ │ -int get_int (int name) const override;
│ │ │ │ bool get_bool (int name) const override;
│ │ │ │ +int get_int (int name) const override;
│ │ │ │ std::string const& get_str (int name) const override;
│ │ │ │
│ │ │ │
queries the current configuration option from the settings_pack.
│ │ │ │ name is one of the enumeration values from string_types, int_types
│ │ │ │ or bool_types. The enum value must match the type of the get_*
│ │ │ │ function. If the specified setting field has not been set, the default
│ │ │ │ value is returned.
│ │ │ │ @@ -5118,22 +5118,22 @@
│ │ │ │
Tribler |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
There's an informal directory of client id's here.
│ │ │ │
The major, minor, revision and tag parameters are used to
│ │ │ │ identify the version of your client.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ -
│ │ │ │ -
setting_by_name() name_for_setting()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
name_for_setting() setting_by_name()
│ │ │ │
Declared in "libtorrent/settings_pack.hpp"
│ │ │ │
│ │ │ │ char const* name_for_setting (int s);
│ │ │ │ int setting_by_name (string_view name);
│ │ │ │
│ │ │ │
converts a setting integer (from the enums string_types, int_types or
│ │ │ │ bool_types) to a string, and vice versa.
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -4,28 +4,28 @@
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │ o _s_e_t___b_o_o_l_(_)_ _s_e_t___s_t_r_(_)_ _s_e_t___i_n_t_(_)
│ │ │ │ │ o _h_a_s___v_a_l_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ - o _g_e_t___s_t_r_(_)_ _g_e_t___b_o_o_l_(_)_ _g_e_t___i_n_t_(_)
│ │ │ │ │ + o _g_e_t___s_t_r_(_)_ _g_e_t___i_n_t_(_)_ _g_e_t___b_o_o_l_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___b_a_s_e_s
│ │ │ │ │ o _e_n_u_m_ _m_m_a_p___w_r_i_t_e___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _s_u_g_g_e_s_t___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _c_h_o_k_i_n_g___a_l_g_o_r_i_t_h_m___t
│ │ │ │ │ o _e_n_u_m_ _s_e_e_d___c_h_o_k_i_n_g___a_l_g_o_r_i_t_h_m___t
│ │ │ │ │ o _e_n_u_m_ _i_o___b_u_f_f_e_r___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _b_a_n_d_w_i_d_t_h___m_i_x_e_d___a_l_g_o___t
│ │ │ │ │ o _e_n_u_m_ _e_n_c___p_o_l_i_c_y
│ │ │ │ │ o _e_n_u_m_ _e_n_c___l_e_v_e_l
│ │ │ │ │ o _e_n_u_m_ _p_r_o_x_y___t_y_p_e___t
│ │ │ │ │ * _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_)
│ │ │ │ │ - * _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)_ _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ - * _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)_ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ + * _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)_ _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │ + * _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)_ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │ * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ You have some control over _s_e_s_s_i_o_n configuration through the session::
│ │ │ │ │ apply_settings() member function. To change one or more configuration options,
│ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k object and fill it with the settings to be set and pass
│ │ │ │ │ it in to session::apply_settings().
│ │ │ │ │ The _s_e_t_t_i_n_g_s___p_a_c_k object is a collection of settings updates that are applied
│ │ │ │ │ to the _s_e_s_s_i_o_n when passed to session::apply_settings(). It's empty when
│ │ │ │ │ @@ -1420,23 +1420,23 @@
│ │ │ │ │ next time the SAM connection is re-established (by restarting or changing
│ │ │ │ │ i2p_hostname or i2p_port).
│ │ │ │ │ struct settings_pack final : settings_interface
│ │ │ │ │ {
│ │ │ │ │ friend void aappppllyy__ppaacckk__iimmppll (settings_pack const*
│ │ │ │ │ , aux::session_settings_single_thread&
│ │ │ │ │ , std::vector
*);
│ │ │ │ │ - void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ - void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │ void sseett__iinntt (int name, int val) override;
│ │ │ │ │ + void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ + void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ bool hhaass__vvaall (int name) const override;
│ │ │ │ │ void cclleeaarr ();
│ │ │ │ │ void cclleeaarr (int name);
│ │ │ │ │ - int ggeett__iinntt (int name) const override;
│ │ │ │ │ bool ggeett__bbooooll (int name) const override;
│ │ │ │ │ + int ggeett__iinntt (int name) const override;
│ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │ void ffoorr__eeaacchh (Fun&& f) const;
│ │ │ │ │
│ │ │ │ │ enum type_bases
│ │ │ │ │ {
│ │ │ │ │ string_type_base,
│ │ │ │ │ int_type_base,
│ │ │ │ │ @@ -1508,18 +1508,18 @@
│ │ │ │ │ socks5_pw,
│ │ │ │ │ http,
│ │ │ │ │ http_pw,
│ │ │ │ │ };
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__bbooooll(()) sseett__ssttrr(()) sseett__iinntt(()) **********
│ │ │ │ │ -void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ -void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ void sseett__bbooooll (int name, bool val) override;
│ │ │ │ │ void sseett__iinntt (int name, int val) override;
│ │ │ │ │ +void sseett__iinntt (int name, flags::bitfield_flag const val);
│ │ │ │ │ +void sseett__ssttrr (int name, std::string val) override;
│ │ │ │ │ set a configuration option in the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of the enum values
│ │ │ │ │ from string_types, int_types or bool_types. They must match the respective type
│ │ │ │ │ of the set_* function.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** hhaass__vvaall(()) **********
│ │ │ │ │ bool hhaass__vvaall (int name) const override;
│ │ │ │ │ queries whether the specified configuration option has a value set in this
│ │ │ │ │ @@ -1530,17 +1530,17 @@
│ │ │ │ │ void cclleeaarr ();
│ │ │ │ │ clear the settings pack from all settings
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** cclleeaarr(()) **********
│ │ │ │ │ void cclleeaarr (int name);
│ │ │ │ │ clear a specific setting from the pack
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__ssttrr(()) ggeett__bbooooll(()) ggeett__iinntt(()) **********
│ │ │ │ │ -int ggeett__iinntt (int name) const override;
│ │ │ │ │ +********** ggeett__ssttrr(()) ggeett__iinntt(()) ggeett__bbooooll(()) **********
│ │ │ │ │ bool ggeett__bbooooll (int name) const override;
│ │ │ │ │ +int ggeett__iinntt (int name) const override;
│ │ │ │ │ std::string const& ggeett__ssttrr (int name) const override;
│ │ │ │ │ queries the current configuration option from the _s_e_t_t_i_n_g_s___p_a_c_k. name is one of
│ │ │ │ │ the enumeration values from string_types, int_types or bool_types. The enum
│ │ │ │ │ value must match the type of the get_* function. If the specified setting field
│ │ │ │ │ has not been set, the default value is returned.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennuumm ttyyppee__bbaasseess **********
│ │ │ │ │ @@ -1693,18 +1693,18 @@
│ │ │ │ │ |_D_E_ _ _ _ _ _ _|_D_e_l_u_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_A_Z_ _ _ _ _ _ _|_A_z_u_r_e_u_s_ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_T_L_ _ _ _ _ _ _|_T_r_i_b_l_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ There's an informal directory of client id's _h_e_r_e.
│ │ │ │ │ The major, minor, revision and tag parameters are used to identify the version
│ │ │ │ │ of your client.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ mmiinn__mmeemmoorryy__uussaaggee(()) hhiigghh__ppeerrffoorrmmaannccee__sseeeedd(()) ************
│ │ │ │ │ +************ hhiigghh__ppeerrffoorrmmaannccee__sseeeedd(()) mmiinn__mmeemmoorryy__uussaaggee(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p"
│ │ │ │ │ -settings_pack mmiinn__mmeemmoorryy__uussaaggee ();
│ │ │ │ │ settings_pack hhiigghh__ppeerrffoorrmmaannccee__sseeeedd ();
│ │ │ │ │ +settings_pack mmiinn__mmeemmoorryy__uussaaggee ();
│ │ │ │ │ The default values of the _s_e_s_s_i_o_n settings are set for a regular bittorrent
│ │ │ │ │ client running on a desktop system. There are functions that can set the
│ │ │ │ │ _s_e_s_s_i_o_n settings to pre set settings for other environments. These can be used
│ │ │ │ │ for the basis, and should be tweaked to fit your needs better.
│ │ │ │ │ min_memory_usage returns settings that will use the minimal amount of RAM, at
│ │ │ │ │ the potential expense of upload and download performance. It adjusts the socket
│ │ │ │ │ buffer sizes, disables the disk cache, lowers the send buffer watermarks so
│ │ │ │ │ @@ -1717,15 +1717,15 @@
│ │ │ │ │ This configuration is intended to be the starting point for embedded devices.
│ │ │ │ │ It will significantly reduce memory usage.
│ │ │ │ │ high_performance_seed returns settings optimized for a seed box, serving many
│ │ │ │ │ peers and that doesn't do any downloading. It has a 128 MB disk cache and has a
│ │ │ │ │ limit of 400 files in its file pool. It support fast upload rates by allowing
│ │ │ │ │ large send buffers.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ sseettttiinngg__bbyy__nnaammee(()) nnaammee__ffoorr__sseettttiinngg(()) ************
│ │ │ │ │ +************ nnaammee__ffoorr__sseettttiinngg(()) sseettttiinngg__bbyy__nnaammee(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │ char const* nnaammee__ffoorr__sseettttiinngg (int s);
│ │ │ │ │ int sseettttiinngg__bbyy__nnaammee (string_view name);
│ │ │ │ │ converts a setting integer (from the enums string_types, int_types or
│ │ │ │ │ bool_types) to a string, and vice versa.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ddeeffaauulltt__sseettttiinnggss(()) ************
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Stats.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -45,28 +45,28 @@
│ │ │ │ [report issue]
│ │ │ │
counters
│ │ │ │
Declared in "libtorrent/performance_counters.hpp"
│ │ │ │
│ │ │ │ struct counters
│ │ │ │ {
│ │ │ │ counters () ;
│ │ │ │ - counters (counters const&) ;
│ │ │ │ counters& operator= (counters const&) & ;
│ │ │ │ - std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ + counters (counters const&) ;
│ │ │ │ std::int64_t operator[] (int i) const ;
│ │ │ │ + std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │ void set_value (int c, std::int64_t value) ;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
inc_stats_counter() operator[]()
│ │ │ │
│ │ │ │ -std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ std::int64_t operator[] (int i) const ;
│ │ │ │ +std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │
│ │ │ │
returns the new value
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
stats_metric
│ │ │ │
Declared in "libtorrent/session_stats.hpp"
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -11,25 +11,25 @@
│ │ │ │ │ * _e_n_u_m_ _m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ccoouunntteerrss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_r_f_o_r_m_a_n_c_e___c_o_u_n_t_e_r_s_._h_p_p"
│ │ │ │ │ struct counters
│ │ │ │ │ {
│ │ │ │ │ ccoouunntteerrss () ;
│ │ │ │ │ - ccoouunntteerrss (counters const&) ;
│ │ │ │ │ counters& ooppeerraattoorr== (counters const&) & ;
│ │ │ │ │ - std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ + ccoouunntteerrss (counters const&) ;
│ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │ + std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ void bblleenndd__ssttaattss__ccoouunntteerr (int c, std::int64_t value, int ratio) ;
│ │ │ │ │ void sseett__vvaalluuee (int c, std::int64_t value) ;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │ -std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ │ +std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ │ returns the new value
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ssttaattss__mmeettrriicc ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___s_t_a_t_s_._h_p_p"
│ │ │ │ │ describes one statistics metric from the _s_e_s_s_i_o_n. For more information, see the
│ │ │ │ │ _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │ struct stats_metric
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Storage.html
│ │ │ │ @@ -32,15 +32,15 @@
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │ - file_slice
│ │ │ │ - file_storage
│ │ │ │
│ │ │ │ - storage_params
│ │ │ │ @@ -117,76 +117,76 @@
│ │ │ │ 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_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 (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
│ │ │ │ , 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 (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 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;
│ │ │ │ - int num_pieces () const;
│ │ │ │ void set_num_pieces (int n);
│ │ │ │ + int num_pieces () const;
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const noexcept;
│ │ │ │ void set_piece_length (int l);
│ │ │ │ int piece_length () const;
│ │ │ │ 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;
│ │ │ │ int blocks_per_piece () const;
│ │ │ │ std::string const& name () const;
│ │ │ │ void set_name (std::string const& n);
│ │ │ │ void swap (file_storage& ti) noexcept;
│ │ │ │ void canonicalize ();
│ │ │ │ - sha256_hash root (file_index_t index) const;
│ │ │ │ - char const* root_ptr (file_index_t const index) const;
│ │ │ │ - std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ - bool pad_file_at (file_index_t index) const;
│ │ │ │ std::time_t mtime (file_index_t index) const;
│ │ │ │ - std::int64_t file_offset (file_index_t index) const;
│ │ │ │ std::int64_t file_size (file_index_t index) const;
│ │ │ │ - std::string symlink (file_index_t index) const;
│ │ │ │ - sha1_hash hash (file_index_t index) const;
│ │ │ │ string_view file_name (file_index_t index) const;
│ │ │ │ + sha1_hash hash (file_index_t index) const;
│ │ │ │ + std::int64_t file_offset (file_index_t index) const;
│ │ │ │ + std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ + char const* root_ptr (file_index_t const index) const;
│ │ │ │ + sha256_hash root (file_index_t index) const;
│ │ │ │ + std::string symlink (file_index_t index) const;
│ │ │ │ + bool pad_file_at (file_index_t index) const;
│ │ │ │ int file_num_blocks (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_first_piece_node (file_index_t index) const;
│ │ │ │ int file_first_block_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_piece (piece_index_t piece) 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_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;
│ │ │ │ @@ -208,37 +208,37 @@
│ │ │ │ reserve()
│ │ │ │
│ │ │ │ void reserve (int num_files);
│ │ │ │
│ │ │ │ allocates space for num_files in the internal file list. This can
│ │ │ │ be used to avoid reallocating the internal file list when the number
│ │ │ │ of files to be added is known up-front.
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
│ │ │ │ -
add_file_borrow() add_file()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
add_file() add_file_borrow()
│ │ │ │
│ │ │ │ -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 (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
│ │ │ │ , 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 (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);
│ │ │ │
│ │ │ │
Adds a file to the file storage. The add_file_borrow version
│ │ │ │ expects that filename is the file name (without a path) of
│ │ │ │ the file that's being added.
│ │ │ │ This memory is borrowed, i.e. it is the caller's
│ │ │ │ responsibility to make sure it stays valid throughout the lifetime
│ │ │ │ of this file_storage object or any copy of it. The same thing applies
│ │ │ │ @@ -341,16 +341,16 @@
│ │ │ │
│ │ │ │
returns the total number of bytes all the files in this torrent spans
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
num_pieces() set_num_pieces()
│ │ │ │
│ │ │ │ -int num_pieces () const;
│ │ │ │ void set_num_pieces (int n);
│ │ │ │ +int num_pieces () const;
│ │ │ │
│ │ │ │
set and get the number of pieces in the torrent
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
end_piece()
│ │ │ │
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ @@ -438,37 +438,37 @@
│ │ │ │
│ │ │ │
canonicalize()
│ │ │ │
│ │ │ │ void canonicalize ();
│ │ │ │
│ │ │ │
arrange files and padding to match the canonical form required
│ │ │ │ by BEP 52
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
symlink() file_path() hash() file_name() mtime() root_ptr() file_size() root() file_offset() pad_file_at()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
mtime() pad_file_at() file_offset() root_ptr() file_path() symlink() file_size() root() file_name() hash()
│ │ │ │
│ │ │ │ -sha256_hash root (file_index_t index) const;
│ │ │ │ -char const* root_ptr (file_index_t const index) const;
│ │ │ │ -std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ -bool pad_file_at (file_index_t index) const;
│ │ │ │ std::time_t mtime (file_index_t index) const;
│ │ │ │ -std::int64_t file_offset (file_index_t index) const;
│ │ │ │ std::int64_t file_size (file_index_t index) const;
│ │ │ │ -std::string symlink (file_index_t index) const;
│ │ │ │ -sha1_hash hash (file_index_t index) const;
│ │ │ │ string_view file_name (file_index_t index) const;
│ │ │ │ +sha1_hash hash (file_index_t index) const;
│ │ │ │ +std::int64_t file_offset (file_index_t index) const;
│ │ │ │ +std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ +char const* root_ptr (file_index_t const index) const;
│ │ │ │ +sha256_hash root (file_index_t index) const;
│ │ │ │ +std::string symlink (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,
│ │ │ │ @@ -486,34 +486,34 @@
│ │ │ │ index is a pad-file.
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
file_num_blocks() file_num_pieces() file_piece_range()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
file_num_pieces() file_piece_range() file_num_blocks()
│ │ │ │
│ │ │ │ int file_num_blocks (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;
│ │ │ │
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
file_first_block_node() file_first_piece_node()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
file_first_piece_node() file_first_block_node()
│ │ │ │
│ │ │ │ int file_first_piece_node (file_index_t index) const;
│ │ │ │ int file_first_block_node (file_index_t index) const;
│ │ │ │
│ │ │ │
index of first piece node in the merkle tree
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -547,21 +547,21 @@
│ │ │ │
file_absolute_path()
│ │ │ │
│ │ │ │ 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_at_offset() file_index_at_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
file_index_at_piece() file_index_at_offset()
│ │ │ │
│ │ │ │ -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_at_piece (piece_index_t piece) const;
│ │ │ │
│ │ │ │
returns the index of the file at the given offset in the torrent
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
file_index_for_root()
│ │ │ │
│ │ │ │ file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _f_i_l_e___s_l_i_c_e
│ │ │ │ │ * _f_i_l_e___s_t_o_r_a_g_e
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _r_e_s_e_r_v_e_(_)
│ │ │ │ │ - o _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)_ _a_d_d___f_i_l_e_(_)
│ │ │ │ │ + o _a_d_d___f_i_l_e_(_)_ _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │ o _m_a_p___f_i_l_e_(_)
│ │ │ │ │ o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │ o _e_n_d___f_i_l_e_(_)
│ │ │ │ │ o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ @@ -23,23 +23,23 @@
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___i_n___p_i_e_c_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ o _n_a_m_e_(_)_ _s_e_t___n_a_m_e_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ - o _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_)_ _h_a_s_h_(_)_ _f_i_l_e___n_a_m_e_(_)_ _m_t_i_m_e_(_)_ _r_o_o_t___p_t_r_(_)
│ │ │ │ │ - _f_i_l_e___s_i_z_e_(_)_ _r_o_o_t_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)
│ │ │ │ │ - o _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ - o _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)
│ │ │ │ │ + o _m_t_i_m_e_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___p_a_t_h_(_)_ _s_y_m_l_i_n_k
│ │ │ │ │ + _(_)_ _f_i_l_e___s_i_z_e_(_)_ _r_o_o_t_(_)_ _f_i_l_e___n_a_m_e_(_)_ _h_a_s_h_(_)
│ │ │ │ │ + o _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)
│ │ │ │ │ + o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)
│ │ │ │ │ o _f_i_l_e___p_a_t_h___h_a_s_h_(_)
│ │ │ │ │ o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ o _f_i_l_e___f_l_a_g_s_(_)
│ │ │ │ │ o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_)
│ │ │ │ │ - o _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)_ _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)
│ │ │ │ │ + o _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)_ _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___f_o_r___r_o_o_t_(_)
│ │ │ │ │ o _p_i_e_c_e___i_n_d_e_x___a_t___f_i_l_e_(_)
│ │ │ │ │ o _s_a_n_i_t_i_z_e___s_y_m_l_i_n_k_s_(_)
│ │ │ │ │ o _v_2_(_)
│ │ │ │ │ * _s_t_o_r_a_g_e___p_a_r_a_m_s
│ │ │ │ │ * _d_i_s_a_b_l_e_d___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _m_m_a_p___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ @@ -77,80 +77,80 @@
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_f_i_l_e___s_t_o_r_a_g_e_._h_p_p"
│ │ │ │ │ The file_storage class represents a file list and the piece size. Everything
│ │ │ │ │ necessary to interpret a regular bittorrent storage file structure.
│ │ │ │ │ class file_storage
│ │ │ │ │ {
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ void rreesseerrvvee (int num_files);
│ │ │ │ │ - void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ + void aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ + void aadddd__ffiillee (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 aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee (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 aadddd__ffiillee (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 rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │ , std::int64_t size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │ const;
│ │ │ │ │ int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │ file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │ index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - int nnuumm__ppiieecceess () const;
│ │ │ │ │ void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ + int nnuumm__ppiieecceess () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ void sseett__nnaammee (std::string const& n);
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ - sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ - char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ - std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ -"") const;
│ │ │ │ │ - bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ - std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ - std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ - sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ + sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ + std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ + std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ +"") const;
│ │ │ │ │ + char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ + sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ + std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ + bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │ save_path) const;
│ │ │ │ │ void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │ file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ - file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ + file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │ piece_index_t ppiieeccee__iinnddeexx__aatt__ffiillee (file_index_t f) const;
│ │ │ │ │ void ssaanniittiizzee__ssyymmlliinnkkss ();
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │
│ │ │ │ │ static constexpr file_flags_t ffllaagg__ppaadd__ffiillee = 0_bit;
│ │ │ │ │ static constexpr file_flags_t ffllaagg__hhiiddddeenn = 1_bit;
│ │ │ │ │ @@ -166,33 +166,33 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreesseerrvvee(()) **********
│ │ │ │ │ void rreesseerrvvee (int num_files);
│ │ │ │ │ allocates space for num_files in the internal file list. This can be used to
│ │ │ │ │ avoid reallocating the internal file list when the number of files to be added
│ │ │ │ │ is known up-front.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ffiillee__bboorrrrooww(()) aadddd__ffiillee(()) **********
│ │ │ │ │ -void aadddd__ffiillee__bboorrrrooww (error_code& ec, string_view filename
│ │ │ │ │ +********** aadddd__ffiillee(()) aadddd__ffiillee__bboorrrrooww(()) **********
│ │ │ │ │ +void aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee__bboorrrrooww (string_view filename
│ │ │ │ │ +void aadddd__ffiillee (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 aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee (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 aadddd__ffiillee (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);
│ │ │ │ │ Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │ filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │ memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │ stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │ it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │ byte binary SHA-1 hash of the file.
│ │ │ │ │ if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -262,16 +262,16 @@
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ returns the total number of bytes all the files in this torrent spans
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ppiieecceess(()) sseett__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │ void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ +int nnuumm__ppiieecceess () const;
│ │ │ │ │ set and get the number of pieces in the torrent
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eenndd__ppiieeccee(()) **********
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ returns the index of the one-past-end piece in the file storage
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** llaasstt__ppiieeccee(()) **********
│ │ │ │ │ @@ -323,27 +323,27 @@
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ swap all content of tthhiiss with ttii.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ssyymmlliinnkk(()) ffiillee__ppaatthh(()) hhaasshh(()) ffiillee__nnaammee(()) mmttiimmee(()) rroooott__ppttrr(()) ffiillee__ssiizzee(())
│ │ │ │ │ -rroooott(()) ffiillee__ooffffsseett(()) ppaadd__ffiillee__aatt(()) **********
│ │ │ │ │ -sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ -std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ -const;
│ │ │ │ │ -bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ +********** mmttiimmee(()) ppaadd__ffiillee__aatt(()) ffiillee__ooffffsseett(()) rroooott__ppttrr(()) ffiillee__ppaatthh(()) ssyymmlliinnkk(())
│ │ │ │ │ +ffiillee__ssiizzee(()) rroooott(()) ffiillee__nnaammee(()) hhaasshh(()) **********
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ -sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ +const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ +std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ +bool ppaadd__ffiillee__aatt (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, in case this
│ │ │ │ │ is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │ SHA-256 merkle tree root hash for the specified file. The pointer points into
│ │ │ │ │ @@ -356,24 +356,24 @@
│ │ │ │ │ file_size() returns the size of a file.
│ │ │ │ │ pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │ file_name() returns jjuusstt 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).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__nnuumm__bblloocckkss(()) ffiillee__nnuumm__ppiieecceess(()) ffiillee__ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +********** ffiillee__nnuumm__ppiieecceess(()) ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__bblloocckkss(()) **********
│ │ │ │ │ int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ Returns the number of pieces or blocks the file atindexspans, 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) **********
│ │ │ │ │ +********** ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) **********
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ index of first piece node in the merkle tree
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__ppaatthh__hhaasshh(()) **********
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path)
│ │ │ │ │ const;
│ │ │ │ │ @@ -392,17 +392,17 @@
│ │ │ │ │ returns a bitmask of flags from file_flags_t that apply to file at index.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__aabbssoolluuttee__ppaatthh(()) **********
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__iinnddeexx__aatt__ooffffsseett(()) ffiillee__iinnddeexx__aatt__ppiieeccee(()) **********
│ │ │ │ │ -file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ +********** ffiillee__iinnddeexx__aatt__ppiieeccee(()) ffiillee__iinnddeexx__aatt__ooffffsseett(()) **********
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ +file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ returns the index of the file at the given offset in the torrent
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__iinnddeexx__ffoorr__rroooott(()) **********
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │ finds the file with the given root hash and returns its index if there is no
│ │ │ │ │ file with the root hash, file_index_t{-1} is returned
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Handle.html
│ │ │ │ @@ -29,62 +29,62 @@
│ │ │ │
│ │ │ │
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │ - block_info
│ │ │ │
│ │ │ │ - partial_piece_info
│ │ │ │ - torrent_handle
│ │ │ │
│ │ │ │ - hash_value()
│ │ │ │ @@ -111,17 +111,17 @@
│ │ │ │
│ │ │ │ unsigned bytes_progress:15;
│ │ │ │ unsigned block_size:15;
│ │ │ │ unsigned state:2;
│ │ │ │ unsigned num_peers:14;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
set_peer() peer()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
peer() set_peer()
│ │ │ │
│ │ │ │ tcp::endpoint peer () const;
│ │ │ │ void set_peer (tcp::endpoint const& ep);
│ │ │ │
│ │ │ │
The peer is the ip address of the peer this block was downloaded from.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -263,110 +263,110 @@
│ │ │ │ handle will remain valid between two calls.
│ │ │ │
│ │ │ │
│ │ │ │ struct torrent_handle
│ │ │ │ {
│ │ │ │ friend std::size_t hash_value (torrent_handle const& th);
│ │ │ │ torrent_handle () noexcept = default;
│ │ │ │ - void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ + void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void read_piece (piece_index_t piece) const;
│ │ │ │ bool have_piece (piece_index_t piece) const;
│ │ │ │ - void post_peer_info () const;
│ │ │ │ void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ - torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ + void post_peer_info () const;
│ │ │ │ void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ - std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ + torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ void post_download_queue () const;
│ │ │ │ - void clear_piece_deadlines () const;
│ │ │ │ + std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ + void clear_piece_deadlines () const;
│ │ │ │ void reset_piece_deadline (piece_index_t index) const;
│ │ │ │ - std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ - void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ + void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ + std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ std::vector<open_file_state> file_status () const;
│ │ │ │ void clear_error () const;
│ │ │ │ void post_trackers () const;
│ │ │ │ - void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ void add_tracker (announce_entry const&) const;
│ │ │ │ std::vector<announce_entry> trackers () const;
│ │ │ │ + void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ void add_url_seed (std::string const& url) const;
│ │ │ │ - void remove_url_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> url_seeds () const;
│ │ │ │ - std::set<std::string> http_seeds () const;
│ │ │ │ - void add_http_seed (std::string const& url) const;
│ │ │ │ + void remove_url_seed (std::string const& url) const;
│ │ │ │ void remove_http_seed (std::string const& url) const;
│ │ │ │ + void add_http_seed (std::string const& url) const;
│ │ │ │ + std::set<std::string> http_seeds () const;
│ │ │ │ void add_extension (
│ │ │ │ std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ bool set_metadata (span<char const> metadata) const;
│ │ │ │ bool is_valid () const;
│ │ │ │ - void pause (pause_flags_t flags = {}) const;
│ │ │ │ void resume () const;
│ │ │ │ - void set_flags (torrent_flags_t flags) const;
│ │ │ │ + void pause (pause_flags_t flags = {}) const;
│ │ │ │ + torrent_flags_t flags () const;
│ │ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ │ 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 flush_cache () const;
│ │ │ │ void force_recheck () const;
│ │ │ │ void save_resume_data (resume_data_flags_t flags = {}) const;
│ │ │ │ - bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ - void queue_position_bottom () const;
│ │ │ │ + bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ + void queue_position_up () const;
│ │ │ │ queue_position_t queue_position () const;
│ │ │ │ - void queue_position_down () const;
│ │ │ │ void queue_position_top () const;
│ │ │ │ - void queue_position_up () const;
│ │ │ │ + void queue_position_bottom () const;
│ │ │ │ + void queue_position_down () const;
│ │ │ │ void queue_position_set (queue_position_t p) const;
│ │ │ │ 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);
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ - void post_piece_availability () const;
│ │ │ │ void piece_availability (std::vector<int>& avail) const;
│ │ │ │ - void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ + void post_piece_availability () const;
│ │ │ │ download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ - std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ + void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ + std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ + void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ download_priority_t file_priority (file_index_t index) const;
│ │ │ │ - void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ void force_dht_announce () const;
│ │ │ │ - void force_lsd_announce () const;
│ │ │ │ void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ + void force_lsd_announce () const;
│ │ │ │ void scrape_tracker (int idx = -1) const;
│ │ │ │ + int download_limit () const;
│ │ │ │ void set_download_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ - int download_limit () const;
│ │ │ │ void set_upload_limit (int limit) const;
│ │ │ │ void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ void clear_peers ();
│ │ │ │ void set_max_uploads (int max_uploads) const;
│ │ │ │ int max_uploads () const;
│ │ │ │ int max_connections () const;
│ │ │ │ void set_max_connections (int max_connections) const;
│ │ │ │ void move_storage (std::string const& save_path
│ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ ) const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │ - info_hash_t info_hashes () const;
│ │ │ │ sha1_hash info_hash () const;
│ │ │ │ + info_hash_t info_hashes () const;
│ │ │ │ + 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;
│ │ │ │ std::uint32_t id () const;
│ │ │ │ std::shared_ptr<torrent> native_handle () const;
│ │ │ │ client_data_t userdata () const;
│ │ │ │ bool in_session () const;
│ │ │ │
│ │ │ │ static constexpr add_piece_flags_t overwrite_existing = 0_bit;
│ │ │ │ static constexpr status_flags_t query_distributed_copies = 0_bit;
│ │ │ │ @@ -398,16 +398,16 @@
│ │ │ │
│ │ │ │
constructs a torrent handle that does not refer to a torrent.
│ │ │ │ i.e. is_valid() will return false.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
add_piece()
│ │ │ │
│ │ │ │ -void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │
│ │ │ │
This function will write data to the storage as piece piece,
│ │ │ │ as if it had been downloaded from a peer.
│ │ │ │
By default, data that's already been downloaded is not overwritten by
│ │ │ │ this buffer. If you trust this data to be correct (and pass the piece
│ │ │ │ hash check) you may pass the overwrite_existing flag. This will
│ │ │ │ instruct libtorrent to overwrite any data that may already have been
│ │ │ │ @@ -449,16 +449,16 @@
│ │ │ │
Returns true if this piece has been completely downloaded and written
│ │ │ │ to disk, and false otherwise.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
get_peer_info() post_peer_info()
│ │ │ │
│ │ │ │ -void post_peer_info () const;
│ │ │ │ void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ +void post_peer_info () const;
│ │ │ │
│ │ │ │
Query information about connected peers for this torrent. If the
│ │ │ │ torrent_handle is invalid, it will throw a system_error exception.
│ │ │ │
post_peer_info() is asynchronous and will trigger the posting of
│ │ │ │ a peer_info_alert. The alert contain a list of peer_info objects, one
│ │ │ │ for each connected peer.
│ │ │ │
get_peer_info() is synchronous and takes a reference to a vector
│ │ │ │ @@ -467,16 +467,16 @@
│ │ │ │ the vector contains information about that particular peer. See
│ │ │ │ peer_info.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
status() post_status()
│ │ │ │
│ │ │ │ -torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │
│ │ │ │
status() will return a structure with information about the status
│ │ │ │ of this torrent. If the torrent_handle is invalid, it will throw
│ │ │ │ system_error exception. See torrent_status. The flags
│ │ │ │ argument filters what information is returned in the torrent_status.
│ │ │ │ Some information in there is relatively expensive to calculate, and if
│ │ │ │ you're not interested in it (and see performance issues), you can
│ │ │ │ @@ -486,37 +486,37 @@
│ │ │ │ instead call post_status(). It will trigger posting of a
│ │ │ │ state_update_alert with a single torrent_status object for this
│ │ │ │ torrent.
│ │ │ │
In order to get regular updates for torrents whose status changes,
│ │ │ │ consider calling session::post_torrent_updates()`` instead.
│ │ │ │
By default everything is included. The flags you can use to decide
│ │ │ │ what to include are defined in this class.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
post_download_queue() get_download_queue()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_download_queue() post_download_queue()
│ │ │ │
│ │ │ │ -std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ void post_download_queue () const;
│ │ │ │ +std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │
│ │ │ │
post_download_queue() triggers a download_queue_alert to be
│ │ │ │ posted.
│ │ │ │ get_download_queue() is a synchronous call and 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]
│ │ │ │
│ │ │ │
set_piece_deadline() clear_piece_deadlines() reset_piece_deadline()
│ │ │ │
│ │ │ │ -void clear_piece_deadlines () const;
│ │ │ │ void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) const;
│ │ │ │ +void clear_piece_deadlines () const;
│ │ │ │ void reset_piece_deadline (piece_index_t index) 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
│ │ │ │ @@ -533,17 +533,17 @@
│ │ │ │
clear_piece_deadlines() removes deadlines on all pieces in
│ │ │ │ the torrent. As if reset_piece_deadline() was called on all pieces.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
post_file_progress() file_progress()
│ │ │ │
│ │ │ │ -std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
│ │ │ │ -void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
│ │ │ │ +void post_file_progress (file_progress_flags_t flags) const;
│ │ │ │ +std::vector<std::int64_t> file_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
│ │ │ │ @@ -572,25 +572,25 @@
│ │ │ │
│ │ │ │
clear_error()
│ │ │ │
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
trackers() replace_trackers() add_tracker() post_trackers()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
replace_trackers() trackers() add_tracker() post_trackers()
│ │ │ │
│ │ │ │ void post_trackers () const;
│ │ │ │ -void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ void add_tracker (announce_entry const&) const;
│ │ │ │ std::vector<announce_entry> trackers () const;
│ │ │ │ +void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │
│ │ │ │
trackers() returns 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
│ │ │ │ use replace_trackers() which takes a list of the same form as the
│ │ │ │ @@ -602,42 +602,42 @@
│ │ │ │
add_tracker() will look if the specified tracker is already in the
│ │ │ │ set. If it is, it doesn't do anything. If it's not in the current set
│ │ │ │ of trackers, it will insert it in the tier specified in the
│ │ │ │ announce_entry.
│ │ │ │
The updated set of trackers will be saved in the resume data, and when
│ │ │ │ a torrent is started with resume data, the trackers from the resume
│ │ │ │ data will replace the original ones.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
remove_url_seed() url_seeds() add_url_seed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
url_seeds() add_url_seed() remove_url_seed()
│ │ │ │
│ │ │ │ void add_url_seed (std::string const& url) const;
│ │ │ │ -void remove_url_seed (std::string const& url) const;
│ │ │ │ std::set<std::string> url_seeds () const;
│ │ │ │ +void remove_url_seed (std::string const& url) 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]
│ │ │ │ -
│ │ │ │ -
add_http_seed() remove_http_seed() http_seeds()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
remove_http_seed() add_http_seed() http_seeds()
│ │ │ │
│ │ │ │ -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;
│ │ │ │ +void add_http_seed (std::string const& url) const;
│ │ │ │ +std::set<std::string> http_seeds () 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]
│ │ │ │
│ │ │ │
add_extension()
│ │ │ │ @@ -679,21 +679,21 @@
│ │ │ │ afterward.
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
pause() resume()
│ │ │ │
│ │ │ │ -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.
│ │ │ │ @@ -704,24 +704,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.
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
unset_flags() set_flags() flags()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_flags() unset_flags() flags()
│ │ │ │
│ │ │ │ -void set_flags (torrent_flags_t flags) const;
│ │ │ │ +torrent_flags_t flags () const;
│ │ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ │ 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;
│ │ │ │
│ │ │ │
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
│ │ │ │ @@ -858,16 +858,16 @@
│ │ │ │ report that they don't need to save resume data again, and skipped by
│ │ │ │ the initial loop, and thwart the counter otherwise.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
need_save_resume_data()
│ │ │ │
│ │ │ │ -bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ +bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │
│ │ │ │
This function returns true if anything that is stored in the resume
│ │ │ │ data has changed since the last time resume data was saved.
│ │ │ │ The overload that takes flags let you ask if specific categories
│ │ │ │ of properties have changed. These flags have the same behavior as in
│ │ │ │ the save_resume_data() call.
│ │ │ │
This is a blocking call. It will wait for a response from
│ │ │ │ @@ -877,27 +877,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.
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
queue_position() queue_position_top() queue_position_bottom() queue_position_down() queue_position_up()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
queue_position_top() queue_position_up() queue_position() queue_position_bottom() queue_position_down()
│ │ │ │
│ │ │ │ -void queue_position_bottom () const;
│ │ │ │ +void queue_position_up () const;
│ │ │ │ queue_position_t queue_position () const;
│ │ │ │ -void queue_position_down () const;
│ │ │ │ void queue_position_top () const;
│ │ │ │ -void queue_position_up () const;
│ │ │ │ +void queue_position_bottom () const;
│ │ │ │ +void queue_position_down () 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
│ │ │ │ @@ -951,18 +951,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]
│ │ │ │ -
│ │ │ │ -
torrent_file() torrent_file_with_hashes()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
torrent_file_with_hashes() torrent_file()
│ │ │ │
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ std::shared_ptr<torrent_info> torrent_file_with_hashes () 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
│ │ │ │ @@ -997,42 +997,42 @@
│ │ │ │
│ │ │ │ std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │
│ │ │ │
returns the piece layers for all files in the torrent. If this is a
│ │ │ │ v1 torrent (and doesn't have any piece layers) it returns an empty
│ │ │ │ vector. This is a blocking call that will synchronize with the
│ │ │ │ libtorrent network thread.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
piece_availability() post_piece_availability()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
post_piece_availability() piece_availability()
│ │ │ │
│ │ │ │ -void post_piece_availability () const;
│ │ │ │ void piece_availability (std::vector<int>& avail) const;
│ │ │ │ +void post_piece_availability () const;
│ │ │ │
│ │ │ │
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.
│ │ │ │
post_piece_availability() will trigger a piece_availability_alert
│ │ │ │ to be posted.
│ │ │ │
piece_availability() 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.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
piece_priority() get_piece_priorities() prioritize_pieces()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
prioritize_pieces() get_piece_priorities() piece_priority()
│ │ │ │
│ │ │ │ -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;
│ │ │ │ -std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ +void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +std::vector<download_priority_t> get_piece_priorities () 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
│ │ │ │ @@ -1055,23 +1055,23 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
prioritize_files() file_priority() get_file_priorities()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
prioritize_files() get_file_priorities() file_priority()
│ │ │ │
│ │ │ │ std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ +void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ download_priority_t file_priority (file_index_t index) const;
│ │ │ │ -void prioritize_files (std::vector<download_priority_t> const& files) 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.
│ │ │ │ @@ -1094,23 +1094,23 @@
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
force_lsd_announce() force_dht_announce() force_reannounce()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
force_dht_announce() force_reannounce() force_lsd_announce()
│ │ │ │
│ │ │ │ void force_dht_announce () const;
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │ void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ +void force_lsd_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
│ │ │ │ as the min_interval expires. This is to honor trackers minimum
│ │ │ │ @@ -1134,24 +1134,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]
│ │ │ │ -
│ │ │ │ -
set_upload_limit() upload_limit() download_limit() set_download_limit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_download_limit() download_limit() upload_limit() set_upload_limit()
│ │ │ │
│ │ │ │ +int download_limit () const;
│ │ │ │ void set_download_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ -int download_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
│ │ │ │ @@ -1198,18 +1198,18 @@
│ │ │ │
│ │ │ │
set_max_uploads() sets the maximum number of peers that's unchoked
│ │ │ │ at the same time on this torrent. If you set this to -1, there will be
│ │ │ │ no limit. This defaults to infinite. The primary setting controlling
│ │ │ │ this is the global unchoke slots limit, set by unchoke_slots_limit in
│ │ │ │ settings_pack.
│ │ │ │
max_uploads() returns the current settings.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
max_connections() set_max_connections()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_max_connections() max_connections()
│ │ │ │
│ │ │ │ int max_connections () const;
│ │ │ │ void set_max_connections (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
│ │ │ │ @@ -1280,32 +1280,32 @@
│ │ │ │ operation is complete when either a file_renamed_alert or
│ │ │ │ file_rename_failed_alert is posted.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
info_hash() info_hashes()
│ │ │ │
│ │ │ │ -info_hash_t info_hashes () const;
│ │ │ │ sha1_hash info_hash () const;
│ │ │ │ +info_hash_t info_hashes () 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]
│ │ │ │ +
│ │ │ │ +[report issue]
│ │ │ │
│ │ │ │ -
operator!=() operator<() operator==()
│ │ │ │ +
operator!=() operator==() operator<()
│ │ │ │
│ │ │ │ +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]
│ │ │ │
│ │ │ │
id()
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,61 +1,61 @@
│ │ │ │ │ >
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _b_l_o_c_k___i_n_f_o
│ │ │ │ │ - o _s_e_t___p_e_e_r_(_)_ _p_e_e_r_(_)
│ │ │ │ │ + o _p_e_e_r_(_)_ _s_e_t___p_e_e_r_(_)
│ │ │ │ │ o _e_n_u_m_ _b_l_o_c_k___s_t_a_t_e___t
│ │ │ │ │ * _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o
│ │ │ │ │ * _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │ o _t_o_r_r_e_n_t___h_a_n_d_l_e_(_)
│ │ │ │ │ o _a_d_d___p_i_e_c_e_(_)
│ │ │ │ │ o _r_e_a_d___p_i_e_c_e_(_)
│ │ │ │ │ o _h_a_v_e___p_i_e_c_e_(_)
│ │ │ │ │ o _g_e_t___p_e_e_r___i_n_f_o_(_)_ _p_o_s_t___p_e_e_r___i_n_f_o_(_)
│ │ │ │ │ o _s_t_a_t_u_s_(_)_ _p_o_s_t___s_t_a_t_u_s_(_)
│ │ │ │ │ - o _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │ + o _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │ o _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ │ o _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ o _f_i_l_e___s_t_a_t_u_s_(_)
│ │ │ │ │ o _c_l_e_a_r___e_r_r_o_r_(_)
│ │ │ │ │ - o _t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ - o _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ - o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)
│ │ │ │ │ + o _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ + o _u_r_l___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)
│ │ │ │ │ + o _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ o _s_e_t___m_e_t_a_d_a_t_a_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ - o _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ - o _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)
│ │ │ │ │ + o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)
│ │ │ │ │ + o _s_e_t___f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)
│ │ │ │ │ o _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │ o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │ o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - o _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)
│ │ │ │ │ - _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)
│ │ │ │ │ + o _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)
│ │ │ │ │ + _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │ o _q_u_e_u_e___p_o_s_i_t_i_o_n___s_e_t_(_)
│ │ │ │ │ o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)
│ │ │ │ │ - o _t_o_r_r_e_n_t___f_i_l_e_(_)_ _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ + o _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)_ _t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ o _p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │ - o _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ - o _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)
│ │ │ │ │ - o _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ - o _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ + o _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ + o _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ + o _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ + o _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ o _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ - o _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ - _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + o _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │ o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │ o _m_a_x___u_p_l_o_a_d_s_(_)_ _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ - o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ + o _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _i_d_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ o _u_s_e_r_d_a_t_a_(_)
│ │ │ │ │ o _i_n___s_e_s_s_i_o_n_(_)
│ │ │ │ │ * _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bblloocckk__iinnffoo ************
│ │ │ │ │ @@ -77,15 +77,15 @@
│ │ │ │ │
│ │ │ │ │ unsigned bytes_progress:15;
│ │ │ │ │ unsigned block_size:15;
│ │ │ │ │ unsigned state:2;
│ │ │ │ │ unsigned num_peers:14;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr(()) ppeeeerr(()) **********
│ │ │ │ │ +********** ppeeeerr(()) sseett__ppeeeerr(()) **********
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │ void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ The peer is the ip address of the peer this block was downloaded from.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennuumm bblloocckk__ssttaattee__tt **********
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ @@ -175,120 +175,120 @@
│ │ │ │ │ the handle is no longer referring to a torrent. There is one exception _i_s___v_a_l_i_d
│ │ │ │ │ _(_) will never throw. Since the torrents are processed by a background thread,
│ │ │ │ │ there is no guarantee that a handle will remain valid between two calls.
│ │ │ │ │ struct torrent_handle
│ │ │ │ │ {
│ │ │ │ │ friend std::size_t hhaasshh__vvaalluuee (torrent_handle const& th);
│ │ │ │ │ ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │ - void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ -add_piece_flags_t flags = {}) const;
│ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ + void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ +add_piece_flags_t flags = {}) const;
│ │ │ │ │ void rreeaadd__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ - void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ - torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ + void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ - std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ + torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ - void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ + std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ + void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ - std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ -const;
│ │ │ │ │ - void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │ file_progress_flags_t flags = {}) const;
│ │ │ │ │ + void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ + std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ +const;
│ │ │ │ │ std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │ void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ - void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ std::vector ttrraacckkeerrss () const;
│ │ │ │ │ + void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ - void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ │ - std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ - void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ + void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ + void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ + std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ void aadddd__eexxtteennssiioonn (
│ │ │ │ │ std::function(torrent_handle const&,
│ │ │ │ │ client_data_t)> const& ext
│ │ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ │ bool sseett__mmeettaaddaattaa (span metadata) const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ - void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ void rreessuummee () const;
│ │ │ │ │ - void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ + void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ + torrent_flags_t ffllaaggss () const;
│ │ │ │ │ void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ - torrent_flags_t ffllaaggss () const;
│ │ │ │ │ + void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ void fflluusshh__ccaacchhee () const;
│ │ │ │ │ void ffoorrccee__rreecchheecckk () const;
│ │ │ │ │ void ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags = {}) const;
│ │ │ │ │ - bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ + bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │ void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │ , std::string const& private_key
│ │ │ │ │ , std::string const& dh_params
│ │ │ │ │ , std::string const& passphrase = "");
│ │ │ │ │ void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ , std::string const& private_key
│ │ │ │ │ , std::string const& dh_params);
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ - void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ - void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ + void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ │ const;
│ │ │ │ │ - std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ + void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │ const;
│ │ │ │ │ + std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ + void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │ download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ - void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ - void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t =
│ │ │ │ │ {}) const;
│ │ │ │ │ + void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ void ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ │ + int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ - int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ void ccoonnnneecctt__ppeeeerr (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ │ void cclleeaarr__ppeeeerrss ();
│ │ │ │ │ void sseett__mmaaxx__uuppllooaaddss (int max_uploads) const;
│ │ │ │ │ int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │ int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ void sseett__mmaaxx__ccoonnnneeccttiioonnss (int max_connections) const;
│ │ │ │ │ void mmoovvee__ssttoorraaggee (std::string const& save_path
│ │ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ │ ) const;
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_name) const;
│ │ │ │ │ - info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │ + info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │ + bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ - bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ std::uint32_t iidd () const;
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ client_data_t uusseerrddaattaa () const;
│ │ │ │ │ bool iinn__sseessssiioonn () const;
│ │ │ │ │
│ │ │ │ │ static constexpr add_piece_flags_t oovveerrwwrriittee__eexxiissttiinngg = 0_bit;
│ │ │ │ │ static constexpr status_flags_t qquueerryy__ddiissttrriibbuutteedd__ccooppiieess = 0_bit;
│ │ │ │ │ @@ -315,18 +315,18 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoorrrreenntt__hhaannddllee(()) **********
│ │ │ │ │ ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │ constructs a torrent handle that does not refer to a torrent. i.e. _i_s___v_a_l_i_d_(_)
│ │ │ │ │ will return false.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__ppiieeccee(()) **********
│ │ │ │ │ -void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t
│ │ │ │ │ -flags = {}) const;
│ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t flags
│ │ │ │ │ = {}) const;
│ │ │ │ │ +void aadddd__ppiieeccee (piece_index_t piece, std::vector data, add_piece_flags_t
│ │ │ │ │ +flags = {}) const;
│ │ │ │ │ This function will write data to the storage as piece piece, as if it had been
│ │ │ │ │ downloaded from a peer.
│ │ │ │ │ By default, data that's already been downloaded is not overwritten by this
│ │ │ │ │ buffer. If you trust this data to be correct (and pass the piece hash check)
│ │ │ │ │ you may pass the overwrite_existing flag. This will instruct libtorrent to
│ │ │ │ │ overwrite any data that may already have been downloaded with this data.
│ │ │ │ │ Since the data is written asynchronously, you may know that is passed or failed
│ │ │ │ │ @@ -355,29 +355,29 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** hhaavvee__ppiieeccee(()) **********
│ │ │ │ │ bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ Returns true if this piece has been completely downloaded and written to disk,
│ │ │ │ │ and false otherwise.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett__ppeeeerr__iinnffoo(()) ppoosstt__ppeeeerr__iinnffoo(()) **********
│ │ │ │ │ -void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ +void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ Query information about connected peers for this torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │ is invalid, it will throw a system_error exception.
│ │ │ │ │ post_peer_info() is asynchronous and will trigger the posting of a
│ │ │ │ │ _p_e_e_r___i_n_f_o___a_l_e_r_t. The _a_l_e_r_t contain a list of _p_e_e_r___i_n_f_o objects, one for each
│ │ │ │ │ connected peer.
│ │ │ │ │ get_peer_info() is synchronous and takes a reference to a vector that will be
│ │ │ │ │ cleared and filled with one _e_n_t_r_y for each peer connected to this torrent,
│ │ │ │ │ given the handle is valid. Each _e_n_t_r_y in the vector contains information about
│ │ │ │ │ that particular peer. See _p_e_e_r___i_n_f_o.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ssttaattuuss(()) ppoosstt__ssttaattuuss(()) **********
│ │ │ │ │ -torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ +torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ status() will return a structure with information about the status of this
│ │ │ │ │ torrent. If the _t_o_r_r_e_n_t___h_a_n_d_l_e is invalid, it will throw system_error
│ │ │ │ │ exception. See _t_o_r_r_e_n_t___s_t_a_t_u_s. The flags argument filters what information is
│ │ │ │ │ returned in the _t_o_r_r_e_n_t___s_t_a_t_u_s. Some information in there is relatively
│ │ │ │ │ expensive to calculate, and if you're not interested in it (and see performance
│ │ │ │ │ issues), you can filter them out.
│ │ │ │ │ The status() function will block until the internal libtorrent thread responds
│ │ │ │ │ @@ -385,28 +385,28 @@
│ │ │ │ │ It will trigger posting of a _s_t_a_t_e___u_p_d_a_t_e___a_l_e_r_t with a single _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │ object for this torrent.
│ │ │ │ │ In order to get regular updates for torrents whose status changes, consider
│ │ │ │ │ calling session::post_torrent_updates()`` instead.
│ │ │ │ │ By default everything is included. The flags you can use to decide what to
│ │ │ │ │ iinncclluuddee are defined in this class.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) ggeett__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │ -std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +********** ggeett__ddoowwnnllooaadd__qquueeuuee(()) ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ +std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ post_download_queue() triggers a download_queue_alert to be posted.
│ │ │ │ │ get_download_queue() is a synchronous call and returns a vector with
│ │ │ │ │ information about pieces that are partially downloaded or not downloaded but
│ │ │ │ │ partially requested. See _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o for the fields in the returned
│ │ │ │ │ vector.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ │ -void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ +void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) 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 function again.
│ │ │ │ │ @@ -416,19 +416,19 @@
│ │ │ │ │ deadline is the number of milliseconds until this piece should be completed.
│ │ │ │ │ reset_piece_deadline removes the deadline from the piece. If it hasn't already
│ │ │ │ │ been downloaded, it will no longer be considered a priority.
│ │ │ │ │ clear_piece_deadlines() removes deadlines on all pieces in the torrent. As if
│ │ │ │ │ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_) was called on all pieces.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ │ -std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ -const;
│ │ │ │ │ -void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ void ffiillee__pprrooggrreessss (std::vector& progress, file_progress_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ +void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ +std::vector ffiillee__pprrooggrreessss (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 _t_o_r_r_e_n_t___i_n_f_o.
│ │ │ │ │ This operation is not very cheap. Its complexity is OO((nn ++ mmjj)). Where nn is the
│ │ │ │ │ number of files, mm is the number of currently downloading pieces and jj is the
│ │ │ │ │ number of blocks in a piece.
│ │ │ │ │ The flags parameter can be used to specify the granularity of the file
│ │ │ │ │ @@ -449,19 +449,19 @@
│ │ │ │ │ See _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** cclleeaarr__eerrrroorr(()) **********
│ │ │ │ │ void cclleeaarr__eerrrroorr () 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │ +********** rreeppllaaccee__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ppoosstt__ttrraacckkeerrss(()) **********
│ │ │ │ │ void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ -void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ std::vector ttrraacckkeerrss () const;
│ │ │ │ │ +void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ trackers() returns the list of trackers for this torrent. The announce _e_n_t_r_y
│ │ │ │ │ contains both a string url which specify the announce url for the tracker as
│ │ │ │ │ well as an _i_n_t 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 use replace_trackers() which takes a list of the same form as the one
│ │ │ │ │ returned from trackers() and will replace it. If you want an immediate effect,
│ │ │ │ │ you have to call _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_). See _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ @@ -470,30 +470,30 @@
│ │ │ │ │ add_tracker() will look if the specified tracker is already in the set. If it
│ │ │ │ │ is, it doesn't do anything. If it's not in the current set of trackers, it will
│ │ │ │ │ insert it in the tier specified in the _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ The updated set of trackers will be saved in the resume data, and when a
│ │ │ │ │ torrent is started with resume data, the trackers from the resume data will
│ │ │ │ │ replace the original ones.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rreemmoovvee__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ +********** uurrll__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) rreemmoovvee__uurrll__sseeeedd(()) **********
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ -void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ │ +void rreemmoovvee__uurrll__sseeeedd (std::string const& url) 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 _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) rreemmoovvee__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) **********
│ │ │ │ │ -std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +********** rreemmoovvee__hhttttpp__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) hhttttpp__sseeeeddss(()) **********
│ │ │ │ │ void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ +std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ These functions are identical as the *_url_seed() variants, but they operate on
│ │ │ │ │ _B_E_P_ _1_7 web seeds instead of _B_E_P_ _1_9.
│ │ │ │ │ See _h_t_t_p_ _s_e_e_d_i_n_g for more information.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__eexxtteennssiioonn(()) **********
│ │ │ │ │ void aadddd__eexxtteennssiioonn (
│ │ │ │ │ std::function(torrent_handle const&,
│ │ │ │ │ @@ -524,36 +524,36 @@
│ │ │ │ │ and false afterward.
│ │ │ │ │ Clients should only use _i_s___v_a_l_i_d_(_) to determine if the result of session::
│ │ │ │ │ find_torrent() was successful.
│ │ │ │ │ Unlike other member functions which return a value, _i_s___v_a_l_i_d_(_) completes
│ │ │ │ │ immediately, without blocking on a result from the network thread. Also unlike
│ │ │ │ │ other functions, it never throws the system_error exception.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │ -void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ +********** ppaauussee(()) rreessuummee(()) **********
│ │ │ │ │ void rreessuummee () const;
│ │ │ │ │ +void ppaauussee (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 _f_i_l_e___e_r_r_o_r___a_l_e_r_t.
│ │ │ │ │ For possible values of the flags parameter, see pause_flags_t.
│ │ │ │ │ To know if a torrent is paused or not, call torrent_handle::flags() and check
│ │ │ │ │ for the torrent_status::paused flag.
│ │ │ │ │ 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 _s_e_s_s_i_o_n. For more
│ │ │ │ │ information, see _q_u_e_u_i_n_g.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) ffllaaggss(()) **********
│ │ │ │ │ -void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ +********** sseett__ffllaaggss(()) uunnsseett__ffllaaggss(()) ffllaaggss(()) **********
│ │ │ │ │ +torrent_flags_t ffllaaggss () const;
│ │ │ │ │ void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ -torrent_flags_t ffllaaggss () const;
│ │ │ │ │ +void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ sets and gets the torrent state flags. See _t_o_r_r_e_n_t___f_l_a_g_s___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 the specified flags and leave any other flags unchanged. unset_flags
│ │ │ │ │ clears the specified flags, while leaving any other flags unchanged.
│ │ │ │ │ Theseed_modeflag is special, it can only be cleared once the torrent has been
│ │ │ │ │ @@ -663,35 +663,35 @@
│ │ │ │ │ Note how outstanding_resume_data is a global counter in this example. This is
│ │ │ │ │ deliberate, otherwise there is a race condition for torrents that was just
│ │ │ │ │ asked to save their resume data, they posted the _a_l_e_r_t, but it has not been
│ │ │ │ │ received yet. Those torrents would report that they don't need to save resume
│ │ │ │ │ data again, and skipped by the initial loop, and thwart the counter otherwise.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nneeeedd__ssaavvee__rreessuummee__ddaattaa(()) **********
│ │ │ │ │ -bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ +bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ This function returns true if anything that is stored in the resume data has
│ │ │ │ │ changed since the last time resume data was saved. The overload that takes
│ │ │ │ │ flags let you ask if specific categories of properties have changed. These
│ │ │ │ │ flags have the same behavior as in the _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) call.
│ │ │ │ │ This is a bblloocckkiinngg call. It will wait for a response from libtorrent's main
│ │ │ │ │ thread. A way to avoid blocking is to instead call _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_) directly,
│ │ │ │ │ specifying the conditions under which resume data should be saved.
│ │ │ │ │ Note
│ │ │ │ │ A torrent's resume data is considered saved as soon as the
│ │ │ │ │ _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t is posted. It is important to make sure this _a_l_e_r_t is
│ │ │ │ │ received and handled in order for this function to be meaningful.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__bboottttoomm(())
│ │ │ │ │ -qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__uupp(()) **********
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +********** qquueeuuee__ppoossiittiioonn__ttoopp(()) qquueeuuee__ppoossiittiioonn__uupp(()) qquueeuuee__ppoossiittiioonn(())
│ │ │ │ │ +qquueeuuee__ppoossiittiioonn__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) **********
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ +void qquueeuuee__ppoossiittiioonn__ddoowwnn () 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 space in the sequence.
│ │ │ │ │ queue_position() returns the torrent's position in the download queue. The
│ │ │ │ │ @@ -734,15 +734,15 @@
│ │ │ │ │ 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 _t_o_r_r_e_n_t___n_e_e_d___c_e_r_t___a_l_e_r_t, 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttoorrrreenntt__ffiillee(()) ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) **********
│ │ │ │ │ +********** ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess(()) ttoorrrreenntt__ffiillee(()) **********
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ _t_o_r_r_e_n_t___f_i_l_e_(_) returns a pointer to the _t_o_r_r_e_n_t___i_n_f_o object associated with
│ │ │ │ │ this torrent. The _t_o_r_r_e_n_t___i_n_f_o object may be a copy of the internal object. If
│ │ │ │ │ the torrent doesn't have metadata, the pointer will not be initialized (i.e. a
│ │ │ │ │ nullptr). The torrent may be in a state without metadata only if it was started
│ │ │ │ │ without a .torrent file, e.g. by being added by magnet link.
│ │ │ │ │ @@ -770,33 +770,33 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__llaayyeerrss(()) **********
│ │ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ returns the piece layers for all files in the torrent. If this is a v1 torrent
│ │ │ │ │ (and doesn't have any piece layers) it returns an empty vector. This is a
│ │ │ │ │ blocking call that will synchronize with the libtorrent network thread.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__aavvaaiillaabbiilliittyy(()) ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │ -void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ +********** ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ │ void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ +void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ 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.
│ │ │ │ │ post_piece_availability() will trigger a _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y___a_l_e_r_t to be posted.
│ │ │ │ │ piece_availability() fills the specified std::vector 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__pprriioorriittyy(()) ggeett__ppiieeccee__pprriioorriittiieess(()) pprriioorriittiizzee__ppiieecceess(()) **********
│ │ │ │ │ -void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ +********** pprriioorriittiizzee__ppiieecceess(()) ggeett__ppiieeccee__pprriioorriittiieess(()) ppiieeccee__pprriioorriittyy(()) **********
│ │ │ │ │ download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces) const;
│ │ │ │ │ -std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ │ +std::vector ggeett__ppiieeccee__pprriioorriittiieess () 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 takes precedence over piece availability. Every
│ │ │ │ │ piece with priority 7 will be attempted to be picked before a priority 6 piece
│ │ │ │ │ @@ -816,19 +816,19 @@
│ │ │ │ │ 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 ffiillee priorities by setting the priorities
│ │ │ │ │ for the affected pieces. Care has to be taken when mixing usage of file- and
│ │ │ │ │ piece priorities.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** pprriioorriittiizzee__ffiilleess(()) ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) **********
│ │ │ │ │ +********** pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) ffiillee__pprriioorriittyy(()) **********
│ │ │ │ │ std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ │ +void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ │ download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ │ -void pprriioorriittiizzee__ffiilleess (std::vector const& files) 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 _e_n_t_r_y is the priority of that file. The function
│ │ │ │ │ sets the priorities of all the pieces in the torrent based on the vector.
│ │ │ │ │ get_file_priorities() returns a vector with the priorities of all files.
│ │ │ │ │ The priority values are the same as for _p_i_e_c_e___p_r_i_o_r_i_t_y_(_). See
│ │ │ │ │ @@ -847,19 +847,19 @@
│ │ │ │ │ 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 aafftteerr it has already been created, it will not
│ │ │ │ │ be moved into the partfile.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffoorrccee__llssdd__aannnnoouunnccee(()) ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) **********
│ │ │ │ │ +********** ffoorrccee__ddhhtt__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) **********
│ │ │ │ │ void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ │ -void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = {})
│ │ │ │ │ const;
│ │ │ │ │ +void ffoorrccee__llssdd__aannnnoouunnccee () 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 as the min_interval
│ │ │ │ │ expires. This is to honor trackers minimum re-announce interval settings.
│ │ │ │ │ The tracker_index argument specifies which tracker to re-announce. If set to -
│ │ │ │ │ @@ -877,19 +877,19 @@
│ │ │ │ │ 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 _t_o_r_r_e_n_t___s_t_a_t_u_s struct once it completes. When it completes, it
│ │ │ │ │ will generate a _s_c_r_a_p_e___r_e_p_l_y___a_l_e_r_t. If it fails, it will generate a
│ │ │ │ │ _s_c_r_a_p_e___f_a_i_l_e_d___a_l_e_r_t.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__uuppllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ │ +********** sseett__ddoowwnnllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(())
│ │ │ │ │ **********
│ │ │ │ │ +int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ │ int uuppllooaadd__lliimmiitt () const;
│ │ │ │ │ -int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ │ void sseett__uuppllooaadd__lliimmiitt (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 torrent then the global limit (settings_pack::upload_rate_limit)
│ │ │ │ │ will not override the global rate limit. The torrent can never upload more than
│ │ │ │ │ @@ -922,15 +922,15 @@
│ │ │ │ │ int mmaaxx__uuppllooaaddss () const;
│ │ │ │ │ set_max_uploads() sets the maximum number of peers that's unchoked at the same
│ │ │ │ │ time on this torrent. If you set this to -1, there will be no limit. This
│ │ │ │ │ defaults to infinite. The primary setting controlling this is the global
│ │ │ │ │ unchoke slots limit, set by unchoke_slots_limit in _s_e_t_t_i_n_g_s___p_a_c_k.
│ │ │ │ │ max_uploads() returns the current settings.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** mmaaxx__ccoonnnneeccttiioonnss(()) sseett__mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │ +********** sseett__mmaaxx__ccoonnnneeccttiioonnss(()) mmaaxx__ccoonnnneeccttiioonnss(()) **********
│ │ │ │ │ int mmaaxx__ccoonnnneeccttiioonnss () const;
│ │ │ │ │ void sseett__mmaaxx__ccoonnnneeccttiioonnss (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
│ │ │ │ │ @@ -983,26 +983,26 @@
│ │ │ │ │ ********** rreennaammee__ffiillee(()) **********
│ │ │ │ │ void rreennaammee__ffiillee (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 _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t or _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t is
│ │ │ │ │ posted.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ -info_hash_t iinnffoo__hhaasshheess () const;
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const;
│ │ │ │ │ +info_hash_t iinnffoo__hhaasshheess () 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr!!==(()) ooppeerraattoorr<<(()) ooppeerraattoorr====(()) **********
│ │ │ │ │ +********** ooppeerraattoorr!!==(()) ooppeerraattoorr====(()) ooppeerraattoorr<<(()) **********
│ │ │ │ │ +bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ bool ooppeerraattoorr==== (const torrent_handle& h) const;
│ │ │ │ │ bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ │ -bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ │ comparison operators. The order of the torrents is unspecified but stable.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iidd(()) **********
│ │ │ │ │ std::uint32_t iidd () const;
│ │ │ │ │ returns a unique identifier for this torrent. It's not a dense index. It's not
│ │ │ │ │ preserved across sessions.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Torrent_Info.html
│ │ │ │ @@ -38,35 +38,35 @@
│ │ │ │ - enum type_t
│ │ │ │
│ │ │ │
│ │ │ │ - load_torrent_limits
│ │ │ │ - torrent_info
│ │ │ │ class torrent_info
│ │ │ │ {
│ │ │ │ torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ - explicit torrent_info (std::string const& filename);
│ │ │ │ torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ + explicit torrent_info (std::string const& filename);
│ │ │ │ torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ + explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ - explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ + torrent_info (torrent_info const& t);
│ │ │ │ torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ - explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ + explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ torrent_info (char const* buffer, int size);
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ - torrent_info (torrent_info const& 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 add_tracker (std::string const& url, int tier = 0);
│ │ │ │ - std::vector<announce_entry> const& trackers () const;
│ │ │ │ - void clear_trackers ();
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ + void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ + void clear_trackers ();
│ │ │ │ + std::vector<announce_entry> const& trackers () const;
│ │ │ │ std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ std::vector<std::string> collections () const;
│ │ │ │ - void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ - 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());
│ │ │ │ std::vector<web_seed_entry> const& web_seeds () 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());
│ │ │ │ + void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ + 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());
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ int num_pieces () const;
│ │ │ │ int piece_length () const;
│ │ │ │ int blocks_per_piece () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ - piece_index_t end_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const;
│ │ │ │ - sha1_hash info_hash () const noexcept;
│ │ │ │ + piece_index_t end_piece () const;
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ - bool v1 () const;
│ │ │ │ + sha1_hash info_hash () const noexcept;
│ │ │ │ bool v2 () const;
│ │ │ │ + bool v1 () 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);
│ │ │ │ @@ -270,26 +270,26 @@
│ │ │ │ void free_piece_layers ();
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
torrent_info()
│ │ │ │
│ │ │ │ torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ │ torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ │ torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +torrent_info (torrent_info const& t);
│ │ │ │ torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ torrent_info (char const* buffer, int size);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -torrent_info (torrent_info const& 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
│ │ │ │ @@ -318,18 +318,18 @@
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
~torrent_info()
│ │ │ │
│ │ │ │ ~torrent_info ();
│ │ │ │
│ │ │ │
frees all storage associated with this torrent_info object
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
orig_files() files()
│ │ │ │ +
│ │ │ │ +
[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
│ │ │ │ @@ -376,64 +376,64 @@
│ │ │ │
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
trackers() add_tracker() clear_trackers()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
clear_trackers() trackers() add_tracker()
│ │ │ │
│ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ -void clear_trackers ();
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ +void clear_trackers ();
│ │ │ │ +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
│ │ │ │ the tracker url, and a tier index. The tier index is the high-level
│ │ │ │ priority. No matter which trackers that works or not, the ones with
│ │ │ │ lower tier will always be tried before the one with higher tier
│ │ │ │ number. For more information, see announce_entry.
│ │ │ │
trackers() returns all entries from announce-list.
│ │ │ │
clear_trackers() removes all trackers from announce-list.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
collections() similar_torrents()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
similar_torrents() collections()
│ │ │ │
│ │ │ │ std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ std::vector<std::string> collections () 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() add_url_seed() set_web_seeds() web_seeds()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
add_url_seed() add_http_seed() set_web_seeds() web_seeds()
│ │ │ │
│ │ │ │ -void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ -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());
│ │ │ │ std::vector<web_seed_entry> const& web_seeds () 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());
│ │ │ │ +void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +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());
│ │ │ │
│ │ │ │
web_seeds() returns all url seeds and http seeds in the torrent.
│ │ │ │ Each entry is a web_seed_entry and may refer to either a url seed
│ │ │ │ or http seed.
│ │ │ │
add_url_seed() and add_http_seed() adds one url to the list of
│ │ │ │ url/http seeds.
│ │ │ │
set_web_seeds() replaces all web seeds with the ones specified in
│ │ │ │ @@ -476,48 +476,48 @@
│ │ │ │
│ │ │ │
blocks_per_piece()
│ │ │ │
│ │ │ │ int blocks_per_piece () const;
│ │ │ │
│ │ │ │
returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
piece_range() last_piece() end_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
last_piece() end_piece() piece_range()
│ │ │ │
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ -piece_index_t end_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const;
│ │ │ │ +piece_index_t end_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_hash() info_hashes()
│ │ │ │
│ │ │ │ -sha1_hash info_hash () const noexcept;
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ +sha1_hash info_hash () const noexcept;
│ │ │ │
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
v2() v1()
│ │ │ │
│ │ │ │ -bool v1 () const;
│ │ │ │ bool v2 () const;
│ │ │ │ +bool v1 () 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()
│ │ │ │ @@ -590,21 +590,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]
│ │ │ │ -
│ │ │ │ -
hash_for_piece_ptr() hash_for_piece()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
hash_for_piece() hash_for_piece_ptr()
│ │ │ │
│ │ │ │ -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]
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -7,35 +7,35 @@
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │ * _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │ * _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │ o _t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ o _~_t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ - o _o_r_i_g___f_i_l_e_s_(_)_ _f_i_l_e_s_(_)
│ │ │ │ │ + o _f_i_l_e_s_(_)_ _o_r_i_g___f_i_l_e_s_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _r_e_m_a_p___f_i_l_e_s_(_)
│ │ │ │ │ - o _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ - o _c_o_l_l_e_c_t_i_o_n_s_(_)_ _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ - o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_s_(_)
│ │ │ │ │ + o _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ + o _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_)
│ │ │ │ │ + o _a_d_d___u_r_l___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_s_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ - o _p_i_e_c_e___r_a_n_g_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │ + o _l_a_s_t___p_i_e_c_e_(_)_ _e_n_d___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ - o _v_1_(_)_ _v_2_(_)
│ │ │ │ │ + o _v_2_(_)_ _v_1_(_)
│ │ │ │ │ o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │ o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │ o _m_a_p___f_i_l_e_(_)
│ │ │ │ │ o _s_s_l___c_e_r_t_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _p_r_i_v_(_)
│ │ │ │ │ o _i_s___i_2_p_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ - o _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e_(_)
│ │ │ │ │ + o _h_a_s_h___f_o_r___p_i_e_c_e_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)
│ │ │ │ │ o _n_a_m_e_(_)
│ │ │ │ │ o _c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ │ o _c_r_e_a_t_o_r_(_)
│ │ │ │ │ o _c_o_m_m_e_n_t_(_)
│ │ │ │ │ o _n_o_d_e_s_(_)
│ │ │ │ │ o _a_d_d___n_o_d_e_(_)
│ │ │ │ │ o _p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │ @@ -121,73 +121,73 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ttoorrrreenntt__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p"
│ │ │ │ │ the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file.
│ │ │ │ │ class torrent_info
│ │ │ │ │ {
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span
buffer, load_torrent_limits const& cfg,
│ │ │ │ │ from_span_t);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ file_storage const& ffiilleess () const;
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ - std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ - void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ + void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ + void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ + std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ - void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ - void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ - , std::string const& extern_auth = std::string()
│ │ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ + void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ + void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ + , std::string const& extern_auth = std::string()
│ │ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ - piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ - sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ + piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ - bool vv11 () const;
│ │ │ │ │ + sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │ + bool vv11 () const;
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int
│ │ │ │ │ size) const;
│ │ │ │ │ string_view ssssll__cceerrtt () const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ bool iiss__ii22pp () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ - sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ + sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ bool iiss__llooaaddeedd () const;
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ │ │ std::time_t ccrreeaattiioonn__ddaattee () const;
│ │ │ │ │ const std::string& ccrreeaattoorr () const;
│ │ │ │ │ const std::string& ccoommmmeenntt () const;
│ │ │ │ │ std::vector> const& nnooddeess () const;
│ │ │ │ │ void aadddd__nnooddee (std::pair const& node);
│ │ │ │ │ @@ -197,28 +197,28 @@
│ │ │ │ │ span iinnffoo__sseeccttiioonn () const;
│ │ │ │ │ span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ │ void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ from_span_t);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& 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 _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │ from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │ represents a tree node in an bencoded file. To load an ordinary .torrent file
│ │ │ │ │ @@ -241,15 +241,15 @@
│ │ │ │ │ from_span_t to disambiguate the std::string overload for string literals. There
│ │ │ │ │ is an object in the libtorrent namespace of this type called from_span.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ~~ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ frees all storage associated with this _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oorriigg__ffiilleess(()) ffiilleess(()) **********
│ │ │ │ │ +********** ffiilleess(()) oorriigg__ffiilleess(()) **********
│ │ │ │ │ file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ file_storage const& ffiilleess () const;
│ │ │ │ │ The _f_i_l_e___s_t_o_r_a_g_e object contains the information on how to map the pieces to
│ │ │ │ │ files. It is separated from the _t_o_r_r_e_n_t___i_n_f_o object because when creating
│ │ │ │ │ torrents a storage object needs to be created without having a torrent file.
│ │ │ │ │ When renaming files in a storage, the storage needs to make its own copy of the
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e in order to make its mapping differ from the one in the torrent
│ │ │ │ │ @@ -284,49 +284,49 @@
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +********** cclleeaarr__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +std::vector const& ttrraacckkeerrss () 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 _a_n_n_o_u_n_c_e___e_n_t_r_y. Each announce _e_n_t_r_y contains a
│ │ │ │ │ string, which is the tracker url, and a tier index. The tier index is the high-
│ │ │ │ │ level priority. No matter which trackers that works or not, the ones with lower
│ │ │ │ │ tier will always be tried before the one with higher tier number. For more
│ │ │ │ │ information, see _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ trackers() returns all entries from announce-list.
│ │ │ │ │ clear_trackers() removes all trackers from announce-list.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │ +********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ │ std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ These two functions are related to _B_E_P_ _3_8 (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ - , std::string const& extern_auth = std::string()
│ │ │ │ │ - , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ -headers_t());
│ │ │ │ │ +********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) **********
│ │ │ │ │ std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ +void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ + , std::string const& extern_auth = std::string()
│ │ │ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ +headers_t());
│ │ │ │ │ web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is
│ │ │ │ │ a web_seed_entry and may refer to either a url seed or http seed.
│ │ │ │ │ add_url_seed() and add_http_seed() adds one url to the list of url/http seeds.
│ │ │ │ │ set_web_seeds() replaces all web seeds with the ones specified in the seeds
│ │ │ │ │ vector.
│ │ │ │ │ The extern_auth argument can be used for other authorization schemes than basic
│ │ │ │ │ HTTP authorization. If set, it will override any username and password found in
│ │ │ │ │ @@ -353,33 +353,33 @@
│ │ │ │ │ piece_length() except in the case of the last piece, which may be smaller.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) **********
│ │ │ │ │ +********** llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ -piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ +piece_index_t eenndd__ppiieeccee () 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
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ -sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ +sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ 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
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** vv11(()) vv22(()) **********
│ │ │ │ │ -bool vv11 () const;
│ │ │ │ │ +********** vv22(()) vv11(()) **********
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │ +bool vv11 () 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ffiilleess(()) **********
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ If you need index-access to files you can use the num_files() along with the
│ │ │ │ │ @@ -427,17 +427,17 @@
│ │ │ │ │ than the i2p network.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ returns the piece size of file with index. This will be the same as
│ │ │ │ │ _p_i_e_c_e___l_e_n_g_t_h_(_), except for the last piece, which may be shorter.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshh__ffoorr__ppiieeccee__ppttrr(()) hhaasshh__ffoorr__ppiieeccee(()) **********
│ │ │ │ │ -sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ +********** hhaasshh__ffoorr__ppiieeccee(()) hhaasshh__ffoorr__ppiieeccee__ppttrr(()) **********
│ │ │ │ │ char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ +sha1_hash hhaasshh__ffoorr__ppiieeccee (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnaammee(()) **********
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Trackers.html
│ │ │ │ @@ -31,15 +31,15 @@
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
announce_infohash
│ │ │ │ @@ -131,19 +131,19 @@
│ │ │ │
announce_entry
│ │ │ │
Declared in "libtorrent/announce_entry.hpp"
│ │ │ │
this class holds information about one bittorrent tracker, as it
│ │ │ │ relates to a specific torrent.
│ │ │ │
│ │ │ │ struct announce_entry
│ │ │ │ {
│ │ │ │ - announce_entry& operator= (announce_entry const&) &;
│ │ │ │ - announce_entry (announce_entry const&);
│ │ │ │ - explicit announce_entry (string_view u);
│ │ │ │ announce_entry ();
│ │ │ │ + announce_entry (announce_entry const&);
│ │ │ │ ~announce_entry ();
│ │ │ │ + explicit announce_entry (string_view u);
│ │ │ │ + announce_entry& operator= (announce_entry const&) &;
│ │ │ │
│ │ │ │ enum tracker_source
│ │ │ │ {
│ │ │ │ source_torrent,
│ │ │ │ source_client,
│ │ │ │ source_magnet_link,
│ │ │ │ source_tex,
│ │ │ │ @@ -154,24 +154,24 @@
│ │ │ │ std::vector<announce_endpoint> endpoints;
│ │ │ │ std::uint8_t tier = 0;
│ │ │ │ std::uint8_t fail_limit = 0;
│ │ │ │ std::uint8_t source:4;
│ │ │ │ bool verified:1;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
~announce_entry() operator=() announce_entry()
│ │ │ │ +
[report issue]
│ │ │ │ +
announce_entry() operator=() ~announce_entry()
│ │ │ │
│ │ │ │ -announce_entry& operator= (announce_entry const&) &;
│ │ │ │ -announce_entry (announce_entry const&);
│ │ │ │ -explicit announce_entry (string_view u);
│ │ │ │ announce_entry ();
│ │ │ │ +announce_entry (announce_entry const&);
│ │ │ │ ~announce_entry ();
│ │ │ │ +explicit announce_entry (string_view u);
│ │ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ │
│ │ │ │
constructs a tracker announce entry with u as the URL.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
enum tracker_source
│ │ │ │
Declared in "libtorrent/announce_entry.hpp"
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2,15 +2,15 @@
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │ * _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │ * _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │ - o _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)
│ │ │ │ │ + o _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ aannnnoouunnccee__iinnffoohhaasshh ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │ struct announce_infohash
│ │ │ │ │ {
│ │ │ │ │ std::string message;
│ │ │ │ │ @@ -78,19 +78,19 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ aannnnoouunnccee__eennttrryy ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │ this class holds information about one bittorrent tracker, as it relates to a
│ │ │ │ │ specific torrent.
│ │ │ │ │ struct announce_entry
│ │ │ │ │ {
│ │ │ │ │ - announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ - aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ - explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ + aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ + explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ + announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │
│ │ │ │ │ enum tracker_source
│ │ │ │ │ {
│ │ │ │ │ source_torrent,
│ │ │ │ │ source_client,
│ │ │ │ │ source_magnet_link,
│ │ │ │ │ source_tex,
│ │ │ │ │ @@ -101,20 +101,20 @@
│ │ │ │ │ std::vector endpoints;
│ │ │ │ │ std::uint8_t ttiieerr = 0;
│ │ │ │ │ std::uint8_t ffaaiill__lliimmiitt = 0;
│ │ │ │ │ std::uint8_t source:4;
│ │ │ │ │ bool verified:1;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ~~aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │ -announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ -aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ -explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +********** aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) ~~aannnnoouunnccee__eennttrryy(()) **********
│ │ │ │ │ aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ │ ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ │ +explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ │ +announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ │ constructs a tracker announce _e_n_t_r_y with u as the URL.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennuumm ttrraacckkeerr__ssoouurrccee **********
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_n_n_o_u_n_c_e___e_n_t_r_y_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |_s_o_u_r_c_e___t_o_r_r_e_n_t_ _ _ _ _|_1_ _ _ _ _|_t_h_e_ _t_r_a_c_k_e_r_ _w_a_s_ _p_a_r_t_ _o_f_ _t_h_e_ _._t_o_r_r_e_n_t_ _f_i_l_e_ _ _ _ _ _ _ _ _ _ |
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Utility.html
│ │ │ │ @@ -31,16 +31,16 @@
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │ - bitfield
│ │ │ │ struct bitfield
│ │ │ │ {
│ │ │ │ + bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ bitfield (int bits, bool val);
│ │ │ │ explicit bitfield (int bits);
│ │ │ │ - bitfield (char const* b, int bits);
│ │ │ │ bitfield (bitfield const& rhs);
│ │ │ │ - bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ + bitfield (char const* b, int bits);
│ │ │ │ bitfield () noexcept = default;
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │ bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ void set_bit (int index) noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │ bool all_set () const noexcept;
│ │ │ │ bool none_set () const noexcept;
│ │ │ │ int size () const noexcept;
│ │ │ │ int num_words () const noexcept;
│ │ │ │ int num_bytes () const noexcept;
│ │ │ │ bool empty () const noexcept;
│ │ │ │ - char* data () noexcept;
│ │ │ │ char const* data () const noexcept;
│ │ │ │ + char* data () noexcept;
│ │ │ │ void swap (bitfield& rhs) noexcept;
│ │ │ │ int count () const noexcept;
│ │ │ │ int find_first_set () const noexcept;
│ │ │ │ int find_last_clear () const noexcept;
│ │ │ │ bool operator== (lt::bitfield const& rhs) const;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
bitfield()
│ │ │ │
│ │ │ │ +bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ bitfield (int bits, bool val);
│ │ │ │ explicit bitfield (int bits);
│ │ │ │ -bitfield (char const* b, int bits);
│ │ │ │ bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ +bitfield (char const* b, int bits);
│ │ │ │ bitfield () noexcept = default;
│ │ │ │
│ │ │ │
constructs a new bitfield. The default constructor creates an empty
│ │ │ │ bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │ val is the value to initialize the bits to. If not specified
│ │ │ │ all bits are initialized to 0.
│ │ │ │
The constructor taking a pointer b and bits copies a bitfield
│ │ │ │ @@ -121,27 +121,27 @@
│ │ │ │
│ │ │ │
assign()
│ │ │ │
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │
│ │ │ │
copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │ the nearest byte boundary.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
operator[]() get_bit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_bit() operator[]()
│ │ │ │
│ │ │ │ bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │
│ │ │ │
query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
clear_bit() set_bit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_bit() clear_bit()
│ │ │ │
│ │ │ │ void set_bit (int index) noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │
│ │ │ │
set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -187,16 +187,16 @@
│ │ │ │ bool
empty () const noexcept;
│ │ │ │
│ │ │ │
returns true if the bitfield has zero size.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
data()
│ │ │ │
│ │ │ │ -char* data () noexcept;
│ │ │ │ char const* data () const noexcept;
│ │ │ │ +char* data () noexcept;
│ │ │ │
│ │ │ │
returns a pointer to the internal buffer of the bitfield, or
│ │ │ │ nullptr if it's empty.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
swap()
│ │ │ │
│ │ │ │ @@ -242,41 +242,41 @@
│ │ │ │ The built-in software version of sha1-algorithm was implemented
│ │ │ │ by Steve Reid and released as public domain.
│ │ │ │ For more info, see src/sha1.cpp.
│ │ │ │
│ │ │ │ class hasher
│ │ │ │ {
│ │ │ │ hasher ();
│ │ │ │ + hasher (hasher const&);
│ │ │ │ hasher& operator= (hasher const&) &;
│ │ │ │ explicit hasher (span<char const> data);
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ - hasher (hasher const&);
│ │ │ │ - hasher& update (span<char const> data);
│ │ │ │ hasher& update (char const* data, int len);
│ │ │ │ + hasher& update (span<char const> data);
│ │ │ │ sha1_hash final ();
│ │ │ │ void reset ();
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
operator=() hasher()
│ │ │ │
│ │ │ │ +hasher (hasher const&);
│ │ │ │ hasher& operator= (hasher const&) &;
│ │ │ │ explicit hasher (span<char const> data);
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ -hasher (hasher const&);
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ -hasher& update (span<char const> data);
│ │ │ │ hasher& update (char const* data, int len);
│ │ │ │ +hasher& update (span<char const> data);
│ │ │ │
│ │ │ │
append the following bytes to what is being hashed
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
final()
│ │ │ │
│ │ │ │ sha1_hash final ();
│ │ │ │ @@ -296,42 +296,42 @@
│ │ │ │
│ │ │ │
hasher256
│ │ │ │
Declared in "libtorrent/hasher.hpp"
│ │ │ │
│ │ │ │ class hasher256
│ │ │ │ {
│ │ │ │ hasher256 ();
│ │ │ │ - hasher256 (hasher256 const&);
│ │ │ │ - hasher256& operator= (hasher256 const&) &;
│ │ │ │ explicit hasher256 (span<char const> data);
│ │ │ │ hasher256 (char const* data, int len);
│ │ │ │ - hasher256& update (span<char const> data);
│ │ │ │ + hasher256 (hasher256 const&);
│ │ │ │ + hasher256& operator= (hasher256 const&) &;
│ │ │ │ hasher256& update (char const* data, int len);
│ │ │ │ + hasher256& update (span<char const> data);
│ │ │ │ sha256_hash final ();
│ │ │ │ void reset ();
│ │ │ │ ~hasher256 ();
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
hasher256() operator=()
│ │ │ │
│ │ │ │ -hasher256 (hasher256 const&);
│ │ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ │ explicit hasher256 (span<char const> data);
│ │ │ │ hasher256 (char const* data, int len);
│ │ │ │ +hasher256 (hasher256 const&);
│ │ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ -hasher256& update (span<char const> data);
│ │ │ │ hasher256& update (char const* data, int len);
│ │ │ │ +hasher256& update (span<char const> data);
│ │ │ │
│ │ │ │
append the following bytes to what is being hashed
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
final()
│ │ │ │
│ │ │ │ sha256_hash final ();
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -2,16 +2,16 @@
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _b_i_t_f_i_e_l_d
│ │ │ │ │ o _b_i_t_f_i_e_l_d_(_)
│ │ │ │ │ o _a_s_s_i_g_n_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_[_]_(_)_ _g_e_t___b_i_t_(_)
│ │ │ │ │ - o _c_l_e_a_r___b_i_t_(_)_ _s_e_t___b_i_t_(_)
│ │ │ │ │ + o _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ + o _s_e_t___b_i_t_(_)_ _c_l_e_a_r___b_i_t_(_)
│ │ │ │ │ o _a_l_l___s_e_t_(_)
│ │ │ │ │ o _n_o_n_e___s_e_t_(_)
│ │ │ │ │ o _s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___w_o_r_d_s_(_)
│ │ │ │ │ o _n_u_m___b_y_t_e_s_(_)
│ │ │ │ │ o _e_m_p_t_y_(_)
│ │ │ │ │ o _d_a_t_a_(_)
│ │ │ │ │ @@ -32,65 +32,65 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bbiittffiieelldd ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_i_t_f_i_e_l_d_._h_p_p"
│ │ │ │ │ The _b_i_t_f_i_e_l_d type stores any number of bits as a _b_i_t_f_i_e_l_d in a heap allocated
│ │ │ │ │ array.
│ │ │ │ │ struct bitfield
│ │ │ │ │ {
│ │ │ │ │ + bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ explicit bbiittffiieelldd (int bits);
│ │ │ │ │ - bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ - bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ + bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ bbiittffiieelldd () noexcept = default;
│ │ │ │ │ void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │ bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ bool aallll__sseett () const noexcept;
│ │ │ │ │ bool nnoonnee__sseett () const noexcept;
│ │ │ │ │ int ssiizzee () const noexcept;
│ │ │ │ │ int nnuumm__wwoorrddss () const noexcept;
│ │ │ │ │ int nnuumm__bbyytteess () const noexcept;
│ │ │ │ │ bool eemmppttyy () const noexcept;
│ │ │ │ │ - char* ddaattaa () noexcept;
│ │ │ │ │ char const* ddaattaa () const noexcept;
│ │ │ │ │ + char* ddaattaa () noexcept;
│ │ │ │ │ void sswwaapp (bitfield& rhs) noexcept;
│ │ │ │ │ int ccoouunntt () const noexcept;
│ │ │ │ │ int ffiinndd__ffiirrsstt__sseett () const noexcept;
│ │ │ │ │ int ffiinndd__llaasstt__cclleeaarr () const noexcept;
│ │ │ │ │ bool ooppeerraattoorr==== (lt::bitfield const& rhs) const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bbiittffiieelldd(()) **********
│ │ │ │ │ +bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ bbiittffiieelldd (int bits, bool val);
│ │ │ │ │ explicit bbiittffiieelldd (int bits);
│ │ │ │ │ -bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ │ -bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ │ +bbiittffiieelldd (char const* b, int bits);
│ │ │ │ │ bbiittffiieelldd () noexcept = default;
│ │ │ │ │ constructs a new _b_i_t_f_i_e_l_d. The default constructor creates an empty _b_i_t_f_i_e_l_d.
│ │ │ │ │ bits is the size of the _b_i_t_f_i_e_l_d (specified in bits). val is the value to
│ │ │ │ │ initialize the bits to. If not specified all bits are initialized to 0.
│ │ │ │ │ The constructor taking a pointer b and bits copies a _b_i_t_f_i_e_l_d from the
│ │ │ │ │ specified buffer, and bits number of bits (rounded up to the nearest byte
│ │ │ │ │ boundary).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aassssiiggnn(()) **********
│ │ │ │ │ void aassssiiggnn (char const* b, int const bits);
│ │ │ │ │ copy _b_i_t_f_i_e_l_d from buffer b of bits number of bits, rounded up to the nearest
│ │ │ │ │ byte boundary.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ooppeerraattoorr[[]](()) ggeett__bbiitt(()) **********
│ │ │ │ │ +********** ggeett__bbiitt(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ │ bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ │ bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ │ query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** cclleeaarr__bbiitt(()) sseett__bbiitt(()) **********
│ │ │ │ │ +********** sseett__bbiitt(()) cclleeaarr__bbiitt(()) **********
│ │ │ │ │ void sseett__bbiitt (int index) noexcept;
│ │ │ │ │ void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ │ set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aallll__sseett(()) **********
│ │ │ │ │ bool aallll__sseett () const noexcept;
│ │ │ │ │ returns true if all bits in the _b_i_t_f_i_e_l_d are set
│ │ │ │ │ @@ -113,16 +113,16 @@
│ │ │ │ │ returns the number of bytes needed to represent all bits in this _b_i_t_f_i_e_l_d
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eemmppttyy(()) **********
│ │ │ │ │ bool eemmppttyy () const noexcept;
│ │ │ │ │ returns true if the _b_i_t_f_i_e_l_d has zero size.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddaattaa(()) **********
│ │ │ │ │ -char* ddaattaa () noexcept;
│ │ │ │ │ char const* ddaattaa () const noexcept;
│ │ │ │ │ +char* ddaattaa () noexcept;
│ │ │ │ │ returns a pointer to the internal buffer of the _b_i_t_f_i_e_l_d, or nullptr if it's
│ │ │ │ │ empty.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sswwaapp(()) **********
│ │ │ │ │ void sswwaapp (bitfield& rhs) noexcept;
│ │ │ │ │ swaps the bit-fields two variables refer to
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -151,35 +151,35 @@
│ │ │ │ │ If you want to reuse the _h_a_s_h_e_r object once you have created a hash, you have
│ │ │ │ │ to call reset() to reinitialize it.
│ │ │ │ │ The built-in software version of sha1-algorithm was implemented by Steve Reid
│ │ │ │ │ and released as public domain. For more info, see src/sha1.cpp.
│ │ │ │ │ class hasher
│ │ │ │ │ {
│ │ │ │ │ hhaasshheerr ();
│ │ │ │ │ + hhaasshheerr (hasher const&);
│ │ │ │ │ hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ explicit hhaasshheerr (span data);
│ │ │ │ │ hhaasshheerr (char const* data, int len);
│ │ │ │ │ - hhaasshheerr (hasher const&);
│ │ │ │ │ - hasher& uuppddaattee (span data);
│ │ │ │ │ hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ + hasher& uuppddaattee (span data);
│ │ │ │ │ sha1_hash ffiinnaall ();
│ │ │ │ │ void rreesseett ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ooppeerraattoorr==(()) hhaasshheerr(()) **********
│ │ │ │ │ +hhaasshheerr (hasher const&);
│ │ │ │ │ hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ │ explicit hhaasshheerr (span data);
│ │ │ │ │ hhaasshheerr (char const* data, int len);
│ │ │ │ │ -hhaasshheerr (hasher const&);
│ │ │ │ │ this is the same as default constructing followed by a call to update(data,
│ │ │ │ │ len).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher& uuppddaattee (span data);
│ │ │ │ │ hasher& uuppddaattee (char const* data, int len);
│ │ │ │ │ +hasher& uuppddaattee (span data);
│ │ │ │ │ append the following bytes to what is being hashed
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiinnaall(()) **********
│ │ │ │ │ sha1_hash ffiinnaall ();
│ │ │ │ │ returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │ _h_a_s_h_e_r constructor.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -189,36 +189,36 @@
│ │ │ │ │ constructed.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ hhaasshheerr225566 ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_h_a_s_h_e_r_._h_p_p"
│ │ │ │ │ class hasher256
│ │ │ │ │ {
│ │ │ │ │ hhaasshheerr225566 ();
│ │ │ │ │ - hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ - hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ explicit hhaasshheerr225566 (span data);
│ │ │ │ │ hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ - hasher256& uuppddaattee (span data);
│ │ │ │ │ + hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ + hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ + hasher256& uuppddaattee (span data);
│ │ │ │ │ sha256_hash ffiinnaall ();
│ │ │ │ │ void rreesseett ();
│ │ │ │ │ ~~hhaasshheerr225566 ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** hhaasshheerr225566(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ -hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ -hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ explicit hhaasshheerr225566 (span data);
│ │ │ │ │ hhaasshheerr225566 (char const* data, int len);
│ │ │ │ │ +hhaasshheerr225566 (hasher256 const&);
│ │ │ │ │ +hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ │ this is the same as default constructing followed by a call to update(data,
│ │ │ │ │ len).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** uuppddaattee(()) **********
│ │ │ │ │ -hasher256& uuppddaattee (span data);
│ │ │ │ │ hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ │ +hasher256& uuppddaattee (span data);
│ │ │ │ │ append the following bytes to what is being hashed
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiinnaall(()) **********
│ │ │ │ │ sha256_hash ffiinnaall ();
│ │ │ │ │ returns the SHA-1 digest of the buffers previously passed to _u_p_d_a_t_e_(_) and the
│ │ │ │ │ _h_a_s_h_e_r constructor.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference.html
│ │ │ │┄ Ordering differences only
│ │ │ │ @@ -25,33 +25,33 @@
│ │ │ │
│ │ │ │
Session
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
Torrent Info
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
Core
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -97,18 +97,18 @@
│ │ │ │
│ │ │ │
│ │ │ │
Settings
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
DHT
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,29 +3,29 @@
│ │ │ │ │ ************ rreeffeerreennccee ddooccuummeennttaattiioonn ************
│ │ │ │ │ _s_i_n_g_l_e_-_p_a_g_e_ _v_e_r_s_i_o_n
│ │ │ │ │ Session
│ │ │ │ │ _s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ │ _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ _s_e_s_s_i_o_n
│ │ │ │ │ _s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ │ -_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)
│ │ │ │ │ +_w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ Torrent Info
│ │ │ │ │ _w_e_b___s_e_e_d___e_n_t_r_y
│ │ │ │ │ _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │ _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │ Core
│ │ │ │ │ _p_e_e_r___i_n_f_o
│ │ │ │ │ _i_n_f_o___h_a_s_h___t
│ │ │ │ │ _p_i_e_c_e___b_l_o_c_k
│ │ │ │ │ _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │ -_l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)
│ │ │ │ │ _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)
│ │ │ │ │ _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ +_l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)
│ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │ _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │ _v_e_r_s_i_o_n_(_)
│ │ │ │ │ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ @@ -59,18 +59,18 @@
│ │ │ │ │ _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │ _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │ _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │ Settings
│ │ │ │ │ _o_v_e_r_v_i_e_w
│ │ │ │ │ _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │ _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_)
│ │ │ │ │ -_m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │ _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ -_s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │ +_m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)
│ │ │ │ │ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ +_s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │ _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ DHT
│ │ │ │ │ _d_h_t___s_t_a_t_e
│ │ │ │ │ _d_h_t___s_t_o_r_a_g_e___c_o_u_n_t_e_r_s
│ │ │ │ │ _d_h_t___s_t_o_r_a_g_e___i_n_t_e_r_f_a_c_e
│ │ │ │ │ _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │ _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/single-page-ref.html
│ │ │ │ @@ -55,95 +55,95 @@
│ │ │ │
- enum error_code_enum
│ │ │ │
- session_params
│ │ │ │
│ │ │ │
- session_proxy
│ │ │ │
│ │ │ │
- session
│ │ │ │
│ │ │ │
- session_handle
│ │ │ │
│ │ │ │ -
- write_session_params_buf() read_session_params() write_session_params()
│ │ │ │ +
- write_session_params() write_session_params_buf() read_session_params()
│ │ │ │
- web_seed_entry
│ │ │ │
│ │ │ │
- load_torrent_limits
│ │ │ │
- torrent_info
│ │ │ │
- peer_info
│ │ │ │
│ │ │ │
- info_hash_t
│ │ │ │
│ │ │ │
- piece_block
│ │ │ │
- peer_request
│ │ │ │
│ │ │ │ -
- load_torrent_buffer() load_torrent_parsed() load_torrent_file()
│ │ │ │ +
- load_torrent_parsed() load_torrent_file() load_torrent_buffer()
│ │ │ │
- make_magnet_uri()
│ │ │ │
- parse_magnet_uri()
│ │ │ │
- torrent_peer_equal()
│ │ │ │
- truncate_files()
│ │ │ │
- version()
│ │ │ │
- enum socket_type_t
│ │ │ │
- enum protocol_version
│ │ │ │ @@ -217,17 +217,17 @@
│ │ │ │
- peer_plugin
│ │ │ │
│ │ │ │
- dht_get_peers_reply_alert
│ │ │ │
- dht_direct_response_alert
│ │ │ │
- picker_log_alert
│ │ │ │
- session_error_alert
│ │ │ │
- dht_live_nodes_alert
│ │ │ │
│ │ │ │
- session_stats_header_alert
│ │ │ │
- dht_sample_infohashes_alert
│ │ │ │
- entry
│ │ │ │
│ │ │ │ @@ -658,15 +658,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
- add_files()
│ │ │ │
- set_piece_hashes()
│ │ │ │
- bitfield
│ │ │ │
│ │ │ │
- hasher
│ │ │ │
│ │ │ │
- hasher256
│ │ │ │
│ │ │ │
- torrent_status
│ │ │ │
│ │ │ │
- announce_infohash
│ │ │ │
- announce_endpoint
│ │ │ │
- announce_entry
│ │ │ │
│ │ │ │
- settings_pack
│ │ │ │
│ │ │ │
- generate_fingerprint()
│ │ │ │
- min_memory_usage() high_performance_seed()
│ │ │ │ -
- setting_by_name() name_for_setting()
│ │ │ │ +
- name_for_setting() setting_by_name()
│ │ │ │
- default_settings()
│ │ │ │
- bdecode_node
│ │ │ │ @@ -765,16 +765,16 @@
│ │ │ │
- counters()
│ │ │ │
│ │ │ │
│ │ │ │
- sign_mutable_item()
│ │ │ │
- dht_default_storage_constructor()
│ │ │ │
- announce_flags_t
│ │ │ │
- read_resume_data()
│ │ │ │ -
- write_resume_data_buf() write_resume_data()
│ │ │ │ -
- write_torrent_file() write_torrent_file_buf()
│ │ │ │ +
- write_resume_data() write_resume_data_buf()
│ │ │ │ +
- write_torrent_file_buf() write_torrent_file()
│ │ │ │
- write_torrent_flags_t
│ │ │ │
- ed25519_create_seed()
│ │ │ │
- ed25519_create_keypair()
│ │ │ │
- ed25519_sign()
│ │ │ │
- ed25519_verify()
│ │ │ │
- ed25519_add_scalar()
│ │ │ │
- ed25519_key_exchange()
│ │ │ │ @@ -786,16 +786,16 @@
│ │ │ │
used by storage to return errors
│ │ │ │ also includes which underlying file the
│ │ │ │ error happened on
│ │ │ │
│ │ │ │ struct storage_error
│ │ │ │ {
│ │ │ │ explicit operator bool () const;
│ │ │ │ - void file (file_index_t f);
│ │ │ │ file_index_t file () const;
│ │ │ │ + void file (file_index_t f);
│ │ │ │
│ │ │ │ error_code ec;
│ │ │ │ operation_t operation;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bool()
│ │ │ │ @@ -804,16 +804,16 @@
│ │ │ │
│ │ │ │
explicitly converts to true if this object represents an error, and
│ │ │ │ false if it does not.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
file()
│ │ │ │
│ │ │ │ -void file (file_index_t f);
│ │ │ │ file_index_t file () const;
│ │ │ │ +void file (file_index_t f);
│ │ │ │
│ │ │ │
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]
│ │ │ │ - ec
│ │ │ │ - the error that occurred
│ │ │ │ @@ -2130,16 +2130,16 @@
│ │ │ │ session_params
│ │ │ │ Declared in "libtorrent/session_params.hpp"
│ │ │ │ The session_params is a parameters pack for configuring the session
│ │ │ │ before it's started.
│ │ │ │
│ │ │ │ struct session_params
│ │ │ │ {
│ │ │ │ - session_params ();
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │ + session_params ();
│ │ │ │ session_params (settings_pack const& sp);
│ │ │ │ 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);
│ │ │ │
│ │ │ │ settings_pack settings;
│ │ │ │ @@ -2150,16 +2150,16 @@
│ │ │ │ std::map<std::string, std::string> ext_state;
│ │ │ │ libtorrent::ip_filter ip_filter;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
session_params()
│ │ │ │
│ │ │ │ -session_params ();
│ │ │ │ session_params (settings_pack&& sp);
│ │ │ │ +session_params ();
│ │ │ │ session_params (settings_pack const& sp);
│ │ │ │
│ │ │ │
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]
│ │ │ │
│ │ │ │ @@ -2214,33 +2214,33 @@
│ │ │ │ synchronize the completion of the shutdown. The lifetime of this object
│ │ │ │ may outlive
session, causing the
session destructor to not block. The
│ │ │ │
session_proxy destructor will block however, until the underlying
session
│ │ │ │ is done shutting down.
│ │ │ │
│ │ │ │ struct session_proxy
│ │ │ │ {
│ │ │ │ - session_proxy ();
│ │ │ │ ~session_proxy ();
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ - session_proxy& operator= (session_proxy const&) &;
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ + session_proxy ();
│ │ │ │ + session_proxy& operator= (session_proxy const&) &;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
~session_proxy() operator=() session_proxy()
│ │ │ │ +
[report issue]
│ │ │ │ +
session_proxy() operator=() ~session_proxy()
│ │ │ │
│ │ │ │ -session_proxy ();
│ │ │ │ ~session_proxy ();
│ │ │ │ session_proxy (session_proxy const&);
│ │ │ │ session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ │ -session_proxy& operator= (session_proxy const&) &;
│ │ │ │ session_proxy (session_proxy&&) noexcept;
│ │ │ │ +session_proxy ();
│ │ │ │ +session_proxy& operator= (session_proxy const&) &;
│ │ │ │
│ │ │ │
default constructor, does not refer to any session
│ │ │ │ implementation object.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
session
│ │ │ │ @@ -2255,49 +2255,49 @@
│ │ │ │ configuration options, create a
settings_pack. object and fill it with
│ │ │ │ the settings to be set and pass it in to
session::apply_settings().
│ │ │ │
see apply_settings().
│ │ │ │
│ │ │ │ struct session : session_handle
│ │ │ │ {
│ │ │ │ session (session_params&& params, session_flags_t flags);
│ │ │ │ - explicit session (session_params&& params);
│ │ │ │ - explicit session (session_params const& params);
│ │ │ │ session ();
│ │ │ │ + explicit session (session_params&& params);
│ │ │ │ session (session_params const& params, session_flags_t flags);
│ │ │ │ - session (session_params const& params, io_context& ios);
│ │ │ │ + explicit session (session_params const& params);
│ │ │ │ session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ + session (session_params const& params, io_context& ios);
│ │ │ │ session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ ~session ();
│ │ │ │ session_proxy abort ();
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
session()
│ │ │ │
│ │ │ │ session (session_params&& params, session_flags_t flags);
│ │ │ │ -explicit session (session_params&& params);
│ │ │ │ -explicit session (session_params const& params);
│ │ │ │ session ();
│ │ │ │ +explicit session (session_params&& params);
│ │ │ │ session (session_params const& params, session_flags_t flags);
│ │ │ │ +explicit session (session_params const& params);
│ │ │ │
│ │ │ │
Constructs the session objects which acts as the container of torrents.
│ │ │ │ In order to avoid a race condition between starting the session and
│ │ │ │ configuring it, you can pass in a session_params object. Its settings
│ │ │ │ will take effect before the session starts up.
│ │ │ │
The overloads taking flags can be used to start a session in
│ │ │ │ paused mode (by passing in session::paused). Note that
│ │ │ │ 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 (session_params const& params, io_context& ios);
│ │ │ │ session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ +session (session_params const& params, io_context& ios);
│ │ │ │ session (session_params&& params, io_context& ios);
│ │ │ │ session (session_params&& 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
│ │ │ │ @@ -2354,77 +2354,77 @@
│ │ │ │ any operation on it will throw a system_error exception, with error code
│ │ │ │ invalid_session_handle.
│ │ │ │
│ │ │ │ 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;
│ │ │ │ + void set_dht_state (dht::dht_state&& st);
│ │ │ │ std::vector<torrent_handle> get_torrents () const;
│ │ │ │ - void async_add_torrent (add_torrent_params&& params);
│ │ │ │ - torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ + torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ │ void async_add_torrent (add_torrent_params const& params);
│ │ │ │ - torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ + torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ + void async_add_torrent (add_torrent_params&& params);
│ │ │ │ torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ │ - bool is_paused () const;
│ │ │ │ + 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_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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │ 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;
│ │ │ │ - void set_peer_class_filter (ip_filter const& f);
│ │ │ │ + unsigned short listen_port () const;
│ │ │ │ + bool is_listening () const;
│ │ │ │ ip_filter get_peer_class_filter () const;
│ │ │ │ + void set_peer_class_filter (ip_filter const& f);
│ │ │ │ void set_peer_class_type_filter (peer_class_type_filter const& f);
│ │ │ │ peer_class_type_filter get_peer_class_type_filter () const;
│ │ │ │ peer_class_t create_peer_class (char const* name);
│ │ │ │ void delete_peer_class (peer_class_t cid);
│ │ │ │ - void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ 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&);
│ │ │ │ void apply_settings (settings_pack&&);
│ │ │ │ settings_pack get_settings () const;
│ │ │ │ - alert* wait_for_alert (time_duration max_wait);
│ │ │ │ + void apply_settings (settings_pack const&);
│ │ │ │ void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ - void delete_port_mapping (port_mapping_t handle);
│ │ │ │ + alert* wait_for_alert (time_duration max_wait);
│ │ │ │ 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;
│ │ │ │ static constexpr save_state_flags_t save_dht_state = 2_bit;
│ │ │ │ static constexpr save_state_flags_t save_extension_state = 11_bit;
│ │ │ │ static constexpr save_state_flags_t save_ip_filter = 12_bit;
│ │ │ │ @@ -2456,24 +2456,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]
│ │ │ │ -
│ │ │ │ -
get_torrent_status() refresh_torrent_status()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
refresh_torrent_status() get_torrent_status()
│ │ │ │
│ │ │ │ +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.
│ │ │ │
│ │ │ │ @@ -2537,47 +2537,47 @@
│ │ │ │ void
post_dht_stats ();
│ │ │ │
│ │ │ │
This will cause a dht_stats_alert to be posted.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
set_dht_state()
│ │ │ │
│ │ │ │ -void set_dht_state (dht::dht_state&& st);
│ │ │ │ void set_dht_state (dht::dht_state const& st);
│ │ │ │ +void set_dht_state (dht::dht_state&& 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]
│ │ │ │ -
│ │ │ │ -
find_torrent() get_torrents()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_torrents() find_torrent()
│ │ │ │
│ │ │ │ -torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ │ std::vector<torrent_handle> get_torrents () const;
│ │ │ │ +torrent_handle find_torrent (sha1_hash const& info_hash) 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]
│ │ │ │
│ │ │ │
add_torrent() async_add_torrent()
│ │ │ │
│ │ │ │ -void async_add_torrent (add_torrent_params&& params);
│ │ │ │ -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);
│ │ │ │ -torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ │ +torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ │ torrent_handle 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
│ │ │ │ @@ -2597,22 +2597,22 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
pause() resume() is_paused()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
is_paused() resume() 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
│ │ │ │ @@ -2721,21 +2721,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]
│ │ │ │ -
│ │ │ │ -
dht_announce() dht_get_peers()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
dht_get_peers() dht_announce()
│ │ │ │
│ │ │ │ -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_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ │
│ │ │ │
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
│ │ │ │ @@ -2848,31 +2848,31 @@
│ │ │ │ anti-virus software by connecting to SMTP, FTP ports.
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
listen_port() is_listening() ssl_listen_port()
│ │ │ │
│ │ │ │ -bool is_listening () const;
│ │ │ │ -unsigned short listen_port () const;
│ │ │ │ unsigned short ssl_listen_port () const;
│ │ │ │ +unsigned short 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]
│ │ │ │ -
│ │ │ │ -
set_peer_class_filter() get_peer_class_filter()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_peer_class_filter() set_peer_class_filter()
│ │ │ │
│ │ │ │ -void set_peer_class_filter (ip_filter const& f);
│ │ │ │ ip_filter get_peer_class_filter () const;
│ │ │ │ +void set_peer_class_filter (ip_filter const& f);
│ │ │ │
│ │ │ │
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.
│ │ │ │
The ip-filter essentially maps an IP -> uint32. Each bit in that 32
│ │ │ │ bit integer represents a peer class. The least significant bit
│ │ │ │ represents class 0, the next bit class 1 and so on.
│ │ │ │ @@ -2945,21 +2945,21 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
get_peer_class() set_peer_class()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_peer_class() get_peer_class()
│ │ │ │
│ │ │ │ -void set_peer_class (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ 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
│ │ │ │ return value of get_peer_class() is undefined.
│ │ │ │
set_peer_class() sets all the information in the
│ │ │ │ peer_class_info object in the specified peer class. There is no
│ │ │ │ @@ -3004,30 +3004,30 @@
│ │ │ │ advised to remove them from the back of the queue, to minimize the
│ │ │ │ shifting.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
get_settings() apply_settings()
│ │ │ │
│ │ │ │ -void apply_settings (settings_pack 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]
│ │ │ │ -
│ │ │ │ -
set_alert_notify() pop_alerts() wait_for_alert()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
pop_alerts() wait_for_alert() set_alert_notify()
│ │ │ │
│ │ │ │ -alert* wait_for_alert (time_duration max_wait);
│ │ │ │ void set_alert_notify (std::function<void()> const& fun);
│ │ │ │ void pop_alerts (std::vector<alert*>* alerts);
│ │ │ │ +alert* wait_for_alert (time_duration max_wait);
│ │ │ │
│ │ │ │
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.
│ │ │ │
It is safe to call pop_alerts from multiple different threads, as
│ │ │ │ @@ -3078,16 +3078,16 @@
│ │ │ │ alert::type() but can also be queries from a concrete type via
│ │ │ │ T::alert_type, as a static constant.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
delete_port_mapping() add_port_mapping()
│ │ │ │
│ │ │ │ -void delete_port_mapping (port_mapping_t handle);
│ │ │ │ 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);
│ │ │ │
│ │ │ │
add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP,
│ │ │ │ whichever is enabled. A mapping is created for each listen socket
│ │ │ │ in the session. The return values are all handles referring to the
│ │ │ │ port mappings that were just created. Pass them to delete_port_mapping()
│ │ │ │ to remove them.
│ │ │ │
[report issue]
│ │ │ │ @@ -3153,30 +3153,30 @@
│ │ │ │
[report issue]
│ │ │ │ - reopen_map_ports
│ │ │ │ - This option indicates if the ports are mapped using natpmp
│ │ │ │ and upnp. If mapping was already made, they are deleted and added
│ │ │ │ again. This only works if natpmp and/or upnp are configured to be
│ │ │ │ enable.
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ +
[report issue]
│ │ │ │
│ │ │ │ -
│ │ │ │ -
write_session_params_buf() read_session_params() write_session_params()
│ │ │ │ +
│ │ │ │ +
write_session_params() write_session_params_buf() read_session_params()
│ │ │ │
Declared in "libtorrent/session_params.hpp"
│ │ │ │
│ │ │ │ session_params read_session_params (bdecode_node const& e
│ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ std::vector<char> write_session_params_buf (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());
│ │ │ │ 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());
│ │ │ │
│ │ │ │
These functions serialize and de-serialize a session_params object to and
│ │ │ │ from bencoded form. The session_params object is used to initialize a new
│ │ │ │ session using the state from a previous one (or by programmatically configure
│ │ │ │ the session up-front).
│ │ │ │ The flags parameter can be used to only save and load certain aspects of the
│ │ │ │ session's state.
│ │ │ │ @@ -3304,69 +3304,69 @@
│ │ │ │
│ │ │ │
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 (char const* buffer, int size, error_code& ec);
│ │ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ - explicit torrent_info (std::string const& filename);
│ │ │ │ + torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (char const* buffer, int size);
│ │ │ │ - explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ - explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ + torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ torrent_info (torrent_info const& t);
│ │ │ │ - explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ - torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ - torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ - torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ + explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ + explicit torrent_info (std::string const& filename);
│ │ │ │ + explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ + explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ ~torrent_info ();
│ │ │ │ file_storage const& files () const;
│ │ │ │ file_storage const& orig_files () const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ │ void remap_files (file_storage const& f);
│ │ │ │ - std::vector<announce_entry> const& trackers () const;
│ │ │ │ + void clear_trackers ();
│ │ │ │ + void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ - void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ - void clear_trackers ();
│ │ │ │ - std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ + std::vector<announce_entry> const& trackers () const;
│ │ │ │ std::vector<std::string> collections () const;
│ │ │ │ - void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ + std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ + std::vector<web_seed_entry> const& web_seeds () 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());
│ │ │ │ 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());
│ │ │ │ - std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ + void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ std::int64_t total_size () const;
│ │ │ │ - int num_pieces () const;
│ │ │ │ int piece_length () const;
│ │ │ │ + int num_pieces () const;
│ │ │ │ int blocks_per_piece () const;
│ │ │ │ piece_index_t last_piece () const;
│ │ │ │ index_range<piece_index_t> piece_range () const;
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ sha1_hash info_hash () const noexcept;
│ │ │ │ info_hash_t const& info_hashes () const;
│ │ │ │ - bool v1 () const;
│ │ │ │ bool v2 () const;
│ │ │ │ + bool v1 () 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);
│ │ │ │ @@ -3376,27 +3376,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 (char const* buffer, int size, error_code& ec);
│ │ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ torrent_info (char const* buffer, int size);
│ │ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ -explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │ +torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ torrent_info (torrent_info const& t);
│ │ │ │ -explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ │ torrent_info (std::string const& filename, error_code& ec);
│ │ │ │ torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ -torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ │ +explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ │
│ │ │ │
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
│ │ │ │ @@ -3483,64 +3483,64 @@
│ │ │ │
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
clear_trackers() trackers() add_tracker()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
trackers() add_tracker() clear_trackers()
│ │ │ │
│ │ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ │ +void clear_trackers ();
│ │ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ void add_tracker (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ │ -void clear_trackers ();
│ │ │ │ +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
│ │ │ │ the tracker url, and a tier index. The tier index is the high-level
│ │ │ │ priority. No matter which trackers that works or not, the ones with
│ │ │ │ lower tier will always be tried before the one with higher tier
│ │ │ │ number. For more information, see announce_entry.
│ │ │ │
trackers() returns all entries from announce-list.
│ │ │ │
clear_trackers() removes all trackers from announce-list.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
collections() similar_torrents()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
similar_torrents() collections()
│ │ │ │
│ │ │ │ -std::vector<sha1_hash> similar_torrents () const;
│ │ │ │ std::vector<std::string> collections () const;
│ │ │ │ +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]
│ │ │ │ -
│ │ │ │ -
web_seeds() add_http_seed() set_web_seeds() add_url_seed()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_web_seeds() web_seeds() add_http_seed() add_url_seed()
│ │ │ │
│ │ │ │ -void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │ +std::vector<web_seed_entry> const& web_seeds () 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());
│ │ │ │ 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());
│ │ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ │ +void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ │
│ │ │ │
web_seeds() returns all url seeds and http seeds in the torrent.
│ │ │ │ Each entry is a web_seed_entry and may refer to either a url seed
│ │ │ │ or http seed.
│ │ │ │
add_url_seed() and add_http_seed() adds one url to the list of
│ │ │ │ url/http seeds.
│ │ │ │
set_web_seeds() replaces all web seeds with the ones specified in
│ │ │ │ @@ -3565,16 +3565,16 @@
│ │ │ │ the total size will be larger than the sum of all (regular) file
│ │ │ │ sizes.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
num_pieces() piece_length()
│ │ │ │
│ │ │ │ -int num_pieces () const;
│ │ │ │ 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
│ │ │ │ @@ -3583,48 +3583,48 @@
│ │ │ │
│ │ │ │
blocks_per_piece()
│ │ │ │
│ │ │ │ int blocks_per_piece () const;
│ │ │ │
│ │ │ │
returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
end_piece() last_piece() piece_range()
│ │ │ │ +
│ │ │ │ +
[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;
│ │ │ │
│ │ │ │
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_hash() info_hashes()
│ │ │ │ +
│ │ │ │ +
[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 v1 () const;
│ │ │ │ bool v2 () const;
│ │ │ │ +bool v1 () 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()
│ │ │ │ @@ -3697,21 +3697,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]
│ │ │ │ -
│ │ │ │ -
hash_for_piece() hash_for_piece_ptr()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
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]
│ │ │ │ @@ -4319,20 +4319,20 @@
│ │ │ │
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;
│ │ │ │ + explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ info_hash_t () noexcept = default;
│ │ │ │ - explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ - explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ - bool has_v1 () const;
│ │ │ │ bool has (protocol_version v) const;
│ │ │ │ + bool has_v1 () const;
│ │ │ │ bool has_v2 () 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;
│ │ │ │ @@ -4341,32 +4341,32 @@
│ │ │ │ sha1_hash v1;
│ │ │ │ sha256_hash v2;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
info_hash_t()
│ │ │ │
│ │ │ │ +explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ │ +explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ │ info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ info_hash_t () noexcept = default;
│ │ │ │ -explicit info_hash_t (sha1_hash h1) 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()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
has() has_v2() has_v1()
│ │ │ │
│ │ │ │ -bool has_v1 () const;
│ │ │ │ bool has (protocol_version v) const;
│ │ │ │ +bool has_v1 () const;
│ │ │ │ bool has_v2 () const;
│ │ │ │
│ │ │ │
returns true if the corresponding info hash is present in this
│ │ │ │ object.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
get()
│ │ │ │ @@ -4443,30 +4443,30 @@
│ │ │ │
- start
│ │ │ │
- The byte offset within that piece where the range starts.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ - length
│ │ │ │ - The size of the range, in bytes.
│ │ │ │
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │
│ │ │ │ -
│ │ │ │ -
load_torrent_buffer() load_torrent_parsed() load_torrent_file()
│ │ │ │ +
│ │ │ │ +
load_torrent_parsed() load_torrent_file() load_torrent_buffer()
│ │ │ │
Declared in "libtorrent/load_torrent.hpp"
│ │ │ │
│ │ │ │ -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_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_parsed (
│ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ add_torrent_params load_torrent_file (
│ │ │ │ std::string const& filename);
│ │ │ │ add_torrent_params load_torrent_buffer (
│ │ │ │ span<char const> buffer);
│ │ │ │
│ │ │ │
These functions load the content of a .torrent file into an
│ │ │ │ add_torrent_params object.
│ │ │ │ @@ -4482,17 +4482,17 @@
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
make_magnet_uri()
│ │ │ │
Declared in "libtorrent/magnet_uri.hpp"
│ │ │ │
│ │ │ │ +std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │ std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ │ std::string make_magnet_uri (torrent_info const& info);
│ │ │ │ -std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ │
│ │ │ │
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:
│ │ │ │
│ │ │ │ ti, info_hashes, url_seeds, dht_nodes,
│ │ │ │ @@ -4512,16 +4512,16 @@
│ │ │ │ an empty string is returned.
│ │ │ │ For more information about magnet links, see magnet links.
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
parse_magnet_uri()
│ │ │ │
Declared in "libtorrent/magnet_uri.hpp"
│ │ │ │
│ │ │ │ -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);
│ │ │ │ +add_torrent_params parse_magnet_uri (string_view uri, error_code& ec);
│ │ │ │ add_torrent_params parse_magnet_uri (string_view uri);
│ │ │ │
│ │ │ │
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.
│ │ │ │ @@ -5336,16 +5336,16 @@
│ │ │ │
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_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ + virtual void on_piece_pass (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);
│ │ │ │ @@ -5372,16 +5372,16 @@
│ │ │ │ to it, use weak_ptr.
│ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
on_piece_failed() on_piece_pass()
│ │ │ │
│ │ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ +virtual void on_piece_pass (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]
│ │ │ │
│ │ │ │ @@ -5466,51 +5466,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_allowed_fast (piece_index_t);
│ │ │ │ - virtual bool
on_have (piece_index_t);
│ │ │ │ virtual bool
on_choke ();
│ │ │ │ - virtual bool
on_have_none ();
│ │ │ │ + virtual bool
on_not_interested ();
│ │ │ │ virtual bool
on_bitfield (bitfield const&
/*bitfield*/);
│ │ │ │ + virtual bool
on_have_all ();
│ │ │ │ + virtual bool
on_unchoke ();
│ │ │ │ + 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_not_interested ();
│ │ │ │ virtual bool
on_dont_have (piece_index_t);
│ │ │ │ - virtual bool
on_have_all ();
│ │ │ │ virtual bool
on_request (peer_request const&);
│ │ │ │ - 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_suggest (piece_index_t);
│ │ │ │ virtual bool
on_reject (peer_request const&);
│ │ │ │ - virtual bool
on_cancel (peer_request const&);
│ │ │ │ virtual void
sent_cancel (peer_request const&);
│ │ │ │ virtual void
sent_request (peer_request const&);
│ │ │ │ - virtual void
sent_have_none ();
│ │ │ │ - virtual void
sent_reject_request (peer_request const&);
│ │ │ │ - virtual void
sent_suggest (piece_index_t);
│ │ │ │ - virtual void
sent_allow_fast (piece_index_t);
│ │ │ │ virtual void
sent_have_all ();
│ │ │ │ + virtual void
sent_reject_request (peer_request const&);
│ │ │ │ virtual void
sent_choke ();
│ │ │ │ - virtual void
sent_interested ();
│ │ │ │ + virtual void
sent_allow_fast (piece_index_t);
│ │ │ │ + virtual void
sent_suggest (piece_index_t);
│ │ │ │ + virtual void
sent_have_none ();
│ │ │ │ virtual void
sent_unchoke ();
│ │ │ │ virtual void
sent_have (piece_index_t);
│ │ │ │ - virtual void
sent_piece (peer_request const&);
│ │ │ │ virtual void
sent_not_interested ();
│ │ │ │ + virtual void
sent_piece (peer_request const&);
│ │ │ │ + virtual void
sent_interested ();
│ │ │ │ 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_pass (piece_index_t);
│ │ │ │ virtual void
on_piece_failed (piece_index_t);
│ │ │ │ + virtual void
on_piece_pass (piece_index_t);
│ │ │ │ virtual void
tick ();
│ │ │ │ virtual bool
write_request (peer_request const&);
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
type()
│ │ │ │
│ │ │ │ @@ -5560,39 +5560,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]
│ │ │ │ -
│ │ │ │ -
on_have_none() on_bitfield() on_dont_have() on_not_interested() on_have() on_allowed_fast() on_request() on_have_all() on_interested() on_unchoke() on_choke()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_choke() on_have_none() on_allowed_fast() on_have_all() on_unchoke() on_have() on_not_interested() on_dont_have() on_request() on_bitfield() on_interested()
│ │ │ │
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ -virtual bool on_have (piece_index_t);
│ │ │ │ virtual bool on_choke ();
│ │ │ │ -virtual bool on_have_none ();
│ │ │ │ +virtual bool on_not_interested ();
│ │ │ │ virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ +virtual bool on_have_all ();
│ │ │ │ +virtual bool on_unchoke ();
│ │ │ │ +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_not_interested ();
│ │ │ │ virtual bool on_dont_have (piece_index_t);
│ │ │ │ -virtual bool on_have_all ();
│ │ │ │ virtual bool on_request (peer_request const&);
│ │ │ │ -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]
│ │ │ │ @@ -5604,27 +5604,27 @@
│ │ │ │
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
sent_interested() sent_not_interested() sent_piece() sent_unchoke() sent_have()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
sent_piece() sent_have() sent_not_interested() sent_interested() sent_unchoke()
│ │ │ │
│ │ │ │ -virtual void sent_interested ();
│ │ │ │ virtual void sent_unchoke ();
│ │ │ │ virtual void sent_have (piece_index_t);
│ │ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ │ virtual void sent_not_interested ();
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │ +virtual void sent_interested ();
│ │ │ │
│ │ │ │
called after a choke message has been sent to the peer
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
sent_payload()
│ │ │ │
│ │ │ │ virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -5665,16 +5665,16 @@
│ │ │ │
│ │ │ │
this is not called for web seeds
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
on_piece_failed() on_piece_pass()
│ │ │ │
│ │ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ │ virtual void on_piece_failed (piece_index_t);
│ │ │ │ +virtual void on_piece_pass (piece_index_t);
│ │ │ │
│ │ │ │
called when a piece that this peer participated in either
│ │ │ │ fails or passes the hash_check
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
tick()
│ │ │ │
│ │ │ │ @@ -5694,16 +5694,16 @@
│ │ │ │
│ │ │ │
│ │ │ │
crypto_plugin
│ │ │ │
Declared in "libtorrent/extensions.hpp"
│ │ │ │
│ │ │ │ struct crypto_plugin
│ │ │ │ {
│ │ │ │ - virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │ virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │ + virtual void set_outgoing_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]
│ │ │ │
decrypt()
│ │ │ │
│ │ │ │ @@ -5727,50 +5727,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;
│ │ │ │ - peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ + peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ bool is_seed () const;
│ │ │ │ bool upload_only () const;
│ │ │ │ - bool has_piece (piece_index_t i) const;
│ │ │ │ peer_id const& pid () const;
│ │ │ │ + bool has_piece (piece_index_t i) const;
│ │ │ │ bool is_choked () const;
│ │ │ │ bool is_interesting () const;
│ │ │ │ bool has_peer_choked () const;
│ │ │ │ bool is_peer_interested () const;
│ │ │ │ void maybe_unchoke_this_peer ();
│ │ │ │ void choke_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;
│ │ │ │ - bool is_outgoing () const;
│ │ │ │ + bool is_disconnecting () const;
│ │ │ │ void disconnect (error_code const& ec, operation_t op
│ │ │ │ , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ - bool is_disconnecting () const;
│ │ │ │ - bool ignore_unchoke_slots () const;
│ │ │ │ + bool is_connecting () const;
│ │ │ │ + bool is_outgoing () const;
│ │ │ │ bool on_local_network () const;
│ │ │ │ + bool ignore_unchoke_slots () const;
│ │ │ │ bool failed () 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;
│ │ │ │ + time_point time_of_last_unchoke () 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]
│ │ │ │
│ │ │ │
bt_peer_connection_handle
│ │ │ │
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ │ @@ -5878,67 +5878,67 @@
│ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ 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 (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
│ │ │ │ , 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 (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
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;
│ │ │ │ void
set_piece_length (int l);
│ │ │ │ int
piece_length () const;
│ │ │ │ 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;
│ │ │ │ int
blocks_per_piece () const;
│ │ │ │ void
set_name (std::string const& n);
│ │ │ │ std::string const&
name () const;
│ │ │ │ void
swap (file_storage& ti) noexcept;
│ │ │ │ void
canonicalize ();
│ │ │ │ + sha1_hash
hash (file_index_t index) const;
│ │ │ │ + char const*
root_ptr (file_index_t const 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;
│ │ │ │ + string_view
file_name (file_index_t index) const;
│ │ │ │ + std::string
symlink (file_index_t index) const;
│ │ │ │ bool
pad_file_at (file_index_t index) const;
│ │ │ │ std::time_t
mtime (file_index_t index) const;
│ │ │ │ sha256_hash
root (file_index_t index) const;
│ │ │ │ - std::int64_t
file_offset (file_index_t index) const;
│ │ │ │ - std::string
symlink (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::string
file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ - sha1_hash
hash (file_index_t index) const;
│ │ │ │ - char const*
root_ptr (file_index_t const index) const;
│ │ │ │ + int
file_num_blocks (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_first_block_node (file_index_t index) const;
│ │ │ │ int
file_first_piece_node (file_index_t index) const;
│ │ │ │ + int
file_first_block_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_piece (piece_index_t piece) 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_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;
│ │ │ │ @@ -5974,23 +5974,23 @@
│ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ 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 (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
│ │ │ │ , 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 (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);
│ │ │ │
│ │ │ │
Adds a file to the file storage. The add_file_borrow version
│ │ │ │ expects that filename is the file name (without a path) of
│ │ │ │ the file that's being added.
│ │ │ │ This memory is borrowed, i.e. it is the caller's
│ │ │ │ responsibility to make sure it stays valid throughout the lifetime
│ │ │ │ of this file_storage object or any copy of it. The same thing applies
│ │ │ │ @@ -6093,16 +6093,16 @@
│ │ │ │
│ │ │ │
returns the total number of bytes all the files in this torrent spans
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
num_pieces() set_num_pieces()
│ │ │ │
│ │ │ │ -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]
│ │ │ │
│ │ │ │
end_piece()
│ │ │ │
│ │ │ │ piece_index_t end_piece () const;
│ │ │ │ @@ -6122,18 +6122,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]
│ │ │ │ -
│ │ │ │ -
set_piece_length() piece_length()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
piece_length() set_piece_length()
│ │ │ │
│ │ │ │ void set_piece_length (int l);
│ │ │ │ int piece_length () const;
│ │ │ │
│ │ │ │
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]
│ │ │ │ @@ -6165,18 +6165,18 @@
│ │ │ │
│ │ │ │
blocks_per_piece()
│ │ │ │
│ │ │ │ int blocks_per_piece () const;
│ │ │ │
│ │ │ │
returns the number of blocks there are in the typical piece. There
│ │ │ │ may be fewer in the last piece)
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
set_name() name()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
name() set_name()
│ │ │ │
│ │ │ │ void set_name (std::string const& n);
│ │ │ │ std::string const& name () const;
│ │ │ │
│ │ │ │
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]
│ │ │ │ @@ -6190,37 +6190,37 @@
│ │ │ │
│ │ │ │
canonicalize()
│ │ │ │
│ │ │ │ void canonicalize ();
│ │ │ │
│ │ │ │
arrange files and padding to match the canonical form required
│ │ │ │ by BEP 52
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
root() root_ptr() file_name() pad_file_at() symlink() file_path() file_offset() file_size() hash() mtime()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
file_offset() symlink() root() pad_file_at() hash() root_ptr() file_path() mtime() file_size() file_name()
│ │ │ │
│ │ │ │ +sha1_hash hash (file_index_t index) const;
│ │ │ │ +char const* root_ptr (file_index_t const 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;
│ │ │ │ +string_view file_name (file_index_t index) const;
│ │ │ │ +std::string symlink (file_index_t index) const;
│ │ │ │ bool pad_file_at (file_index_t index) const;
│ │ │ │ std::time_t mtime (file_index_t index) const;
│ │ │ │ sha256_hash root (file_index_t index) const;
│ │ │ │ -std::int64_t file_offset (file_index_t index) const;
│ │ │ │ -std::string symlink (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::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ │ -sha1_hash hash (file_index_t index) const;
│ │ │ │ -char const* root_ptr (file_index_t const 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,
│ │ │ │ @@ -6238,37 +6238,37 @@
│ │ │ │ index is a pad-file.
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
file_num_blocks() file_piece_range() file_num_pieces()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
file_num_pieces() file_num_blocks() file_piece_range()
│ │ │ │
│ │ │ │ +int file_num_blocks (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;
│ │ │ │
│ │ │ │
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]
│ │ │ │
│ │ │ │
file_first_piece_node() file_first_block_node()
│ │ │ │
│ │ │ │ -int file_first_block_node (file_index_t index) const;
│ │ │ │ int file_first_piece_node (file_index_t index) const;
│ │ │ │ +int file_first_block_node (file_index_t index) const;
│ │ │ │
│ │ │ │
index of first piece node in the merkle tree
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
file_path_hash()
│ │ │ │
│ │ │ │ std::uint32_t file_path_hash (file_index_t index, std::string const& save_path) const;
│ │ │ │ @@ -6304,16 +6304,16 @@
│ │ │ │ have an absolute path, i.e. is not anchored in the save path of the
│ │ │ │ torrent.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
file_index_at_piece() file_index_at_offset()
│ │ │ │
│ │ │ │ -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_at_piece (piece_index_t piece) const;
│ │ │ │
│ │ │ │
returns the index of the file at the given offset in the torrent
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
file_index_for_root()
│ │ │ │
│ │ │ │ file_index_t file_index_for_root (sha256_hash const& root_hash) const;
│ │ │ │ @@ -6560,38 +6560,38 @@
│ │ │ │ struct client_data_t
│ │ │ │ {
│ │ │ │ client_data_t () = default;
│ │ │ │ explicit client_data_t (T* v);
│ │ │ │ client_data_t& operator= (T* v);
│ │ │ │ T* get () const;
│ │ │ │ explicit operator T () const;
│ │ │ │ + operator void* () const = delete;
│ │ │ │ client_data_t& operator= (void*) = delete;
│ │ │ │ client_data_t& operator= (void const*) = delete;
│ │ │ │ operator void const* () const = delete;
│ │ │ │ - operator void* () const = delete;
│ │ │ │
│ │ │ │ template <typename T, typename U = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
client_data_t()
│ │ │ │
│ │ │ │ client_data_t () = default;
│ │ │ │
│ │ │ │
construct a nullptr client data
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
const*() void*() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
void*() const*() operator=()
│ │ │ │
│ │ │ │ +operator void* () const = delete;
│ │ │ │ client_data_t& operator= (void*) = delete;
│ │ │ │ client_data_t& operator= (void const*) = delete;
│ │ │ │ operator void const* () const = delete;
│ │ │ │ -operator void* () const = delete;
│ │ │ │
│ │ │ │
we don't allow type-unsafe operations
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
add_torrent_params
│ │ │ │
Declared in "libtorrent/add_torrent_params.hpp"
│ │ │ │ @@ -6976,16 +6976,16 @@
│ │ │ │
Declared in "libtorrent/peer_class_type_filter.hpp"
│ │ │ │
peer_class_type_filter is a simple container for rules for adding and subtracting
│ │ │ │ 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 remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ 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);
│ │ │ │ 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
│ │ │ │ @@ -6999,16 +6999,16 @@
│ │ │ │ };
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
remove() add()
│ │ │ │
│ │ │ │ -void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ 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]
│ │ │ │
│ │ │ │
disallow() allow()
│ │ │ │ @@ -7079,16 +7079,16 @@
│ │ │ │
block_info
│ │ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │ │
holds the state of a block in a piece. Who we requested
│ │ │ │ it from and how far along we are at downloading it.
│ │ │ │
│ │ │ │ struct block_info
│ │ │ │ {
│ │ │ │ - tcp::endpoint peer () const;
│ │ │ │ void set_peer (tcp::endpoint const& ep);
│ │ │ │ + tcp::endpoint peer () const;
│ │ │ │
│ │ │ │ enum block_state_t
│ │ │ │ {
│ │ │ │ none,
│ │ │ │ requested,
│ │ │ │ writing,
│ │ │ │ finished,
│ │ │ │ @@ -7096,20 +7096,20 @@
│ │ │ │
│ │ │ │ unsigned bytes_progress:15;
│ │ │ │ unsigned block_size:15;
│ │ │ │ unsigned state:2;
│ │ │ │ unsigned num_peers:14;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
peer() set_peer()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
set_peer() peer()
│ │ │ │
│ │ │ │ -tcp::endpoint peer () const;
│ │ │ │ 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]
│ │ │ │
│ │ │ │
enum block_state_t
│ │ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │ │
│ │ │ │ @@ -7248,109 +7248,109 @@
│ │ │ │ handle will remain valid between two calls.
│ │ │ │
│ │ │ │
│ │ │ │ struct torrent_handle
│ │ │ │ {
│ │ │ │ friend std::size_t hash_value (torrent_handle const& th);
│ │ │ │ torrent_handle () noexcept = default;
│ │ │ │ - void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ + void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void read_piece (piece_index_t piece) const;
│ │ │ │ bool have_piece (piece_index_t piece) const;
│ │ │ │ void post_peer_info () const;
│ │ │ │ void get_peer_info (std::vector<peer_info>& v) const;
│ │ │ │ - torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ + torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void post_download_queue () const;
│ │ │ │ - std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ + std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ 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 post_file_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;
│ │ │ │ std::vector<open_file_state> file_status () const;
│ │ │ │ void clear_error () const;
│ │ │ │ - void add_tracker (announce_entry const&) const;
│ │ │ │ - void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ void post_trackers () const;
│ │ │ │ std::vector<announce_entry> trackers () const;
│ │ │ │ + void add_tracker (announce_entry const&) const;
│ │ │ │ + void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ 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;
│ │ │ │ + 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;
│ │ │ │ void add_extension (
│ │ │ │ std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
│ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ bool set_metadata (span<char const> metadata) const;
│ │ │ │ bool is_valid () const;
│ │ │ │ - void pause (pause_flags_t flags = {}) const;
│ │ │ │ void resume () const;
│ │ │ │ - void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ - void set_flags (torrent_flags_t flags) const;
│ │ │ │ + void pause (pause_flags_t flags = {}) const;
│ │ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ │ torrent_flags_t flags () const;
│ │ │ │ + void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ + void set_flags (torrent_flags_t flags) const;
│ │ │ │ void flush_cache () const;
│ │ │ │ void force_recheck () const;
│ │ │ │ void save_resume_data (resume_data_flags_t flags = {}) const;
│ │ │ │ bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ │ bool need_save_resume_data () const;
│ │ │ │ - void queue_position_up () const;
│ │ │ │ - void queue_position_top () const;
│ │ │ │ void queue_position_bottom () const;
│ │ │ │ + void queue_position_top () const;
│ │ │ │ void queue_position_down () const;
│ │ │ │ + void queue_position_up () const;
│ │ │ │ queue_position_t queue_position () const;
│ │ │ │ void queue_position_set (queue_position_t p) const;
│ │ │ │ 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);
│ │ │ │ std::shared_ptr<torrent_info> torrent_file_with_hashes () const;
│ │ │ │ std::shared_ptr<const torrent_info> torrent_file () const;
│ │ │ │ std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │ - void post_piece_availability () const;
│ │ │ │ void piece_availability (std::vector<int>& avail) const;
│ │ │ │ - download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ + void post_piece_availability () const;
│ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ + download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
│ │ │ │ - std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ + std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ download_priority_t file_priority (file_index_t index) const;
│ │ │ │ - void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ - void force_lsd_announce () const;
│ │ │ │ void force_dht_announce () const;
│ │ │ │ + void force_lsd_announce () const;
│ │ │ │ + void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ void scrape_tracker (int idx = -1) const;
│ │ │ │ + void set_upload_limit (int limit) const;
│ │ │ │ + void set_download_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ int download_limit () const;
│ │ │ │ - void set_download_limit (int limit) const;
│ │ │ │ - void set_upload_limit (int limit) const;
│ │ │ │ void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
│ │ │ │ , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
│ │ │ │ void clear_peers ();
│ │ │ │ - int max_uploads () const;
│ │ │ │ void set_max_uploads (int max_uploads) const;
│ │ │ │ + int max_uploads () const;
│ │ │ │ int max_connections () const;
│ │ │ │ void set_max_connections (int max_connections) const;
│ │ │ │ void move_storage (std::string const& save_path
│ │ │ │ , move_flags_t flags = move_flags_t::always_replace_files
│ │ │ │ ) const;
│ │ │ │ void rename_file (file_index_t index, std::string const& new_name) const;
│ │ │ │ info_hash_t info_hashes () const;
│ │ │ │ sha1_hash info_hash () const;
│ │ │ │ - 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;
│ │ │ │ std::uint32_t id () const;
│ │ │ │ std::shared_ptr<torrent> native_handle () const;
│ │ │ │ client_data_t userdata () const;
│ │ │ │ bool in_session () const;
│ │ │ │
│ │ │ │ static constexpr add_piece_flags_t overwrite_existing = 0_bit;
│ │ │ │ @@ -7383,16 +7383,16 @@
│ │ │ │
│ │ │ │ constructs a torrent handle that does not refer to a torrent.
│ │ │ │ i.e. is_valid() will return false.
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
add_piece()
│ │ │ │
│ │ │ │ -void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │ void add_piece (piece_index_t piece, char const* data, add_piece_flags_t flags = {}) const;
│ │ │ │ +void add_piece (piece_index_t piece, std::vector<char> data, add_piece_flags_t flags = {}) const;
│ │ │ │
│ │ │ │
This function will write data to the storage as piece piece,
│ │ │ │ as if it had been downloaded from a peer.
│ │ │ │
By default, data that's already been downloaded is not overwritten by
│ │ │ │ this buffer. If you trust this data to be correct (and pass the piece
│ │ │ │ hash check) you may pass the overwrite_existing flag. This will
│ │ │ │ instruct libtorrent to overwrite any data that may already have been
│ │ │ │ @@ -7452,16 +7452,16 @@
│ │ │ │ the vector contains information about that particular peer. See
│ │ │ │ peer_info.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
post_status() status()
│ │ │ │
│ │ │ │ -torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ void post_status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ +torrent_status status (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │
│ │ │ │
status() will return a structure with information about the status
│ │ │ │ of this torrent. If the torrent_handle is invalid, it will throw
│ │ │ │ system_error exception. See torrent_status. The flags
│ │ │ │ argument filters what information is returned in the torrent_status.
│ │ │ │ Some information in there is relatively expensive to calculate, and if
│ │ │ │ you're not interested in it (and see performance issues), you can
│ │ │ │ @@ -7477,28 +7477,28 @@
│ │ │ │ what to include are defined in this class.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
post_download_queue() get_download_queue()
│ │ │ │
│ │ │ │ void post_download_queue () const;
│ │ │ │ -std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │ void get_download_queue (std::vector<partial_piece_info>& queue) const;
│ │ │ │ +std::vector<partial_piece_info> get_download_queue () const;
│ │ │ │
│ │ │ │
post_download_queue() triggers a download_queue_alert to be
│ │ │ │ posted.
│ │ │ │ get_download_queue() is a synchronous call and 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]
│ │ │ │ -
│ │ │ │ -
reset_piece_deadline() clear_piece_deadlines() set_piece_deadline()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_piece_deadline() reset_piece_deadline() clear_piece_deadlines()
│ │ │ │
│ │ │ │ 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;
│ │ │ │
│ │ │ │
This function sets or resets the deadline associated with a specific
│ │ │ │ piece index (index). libtorrent will attempt to download this
│ │ │ │ @@ -7558,24 +7558,24 @@
│ │ │ │
clear_error()
│ │ │ │
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
trackers() post_trackers() add_tracker() replace_trackers()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
trackers() add_tracker() post_trackers() replace_trackers()
│ │ │ │
│ │ │ │ -void add_tracker (announce_entry const&) const;
│ │ │ │ -void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │ void post_trackers () const;
│ │ │ │ std::vector<announce_entry> trackers () const;
│ │ │ │ +void add_tracker (announce_entry const&) const;
│ │ │ │ +void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ │
│ │ │ │
trackers() returns 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
│ │ │ │ use replace_trackers() which takes a list of the same form as the
│ │ │ │ @@ -7607,22 +7607,22 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
http_seeds() remove_http_seed() add_http_seed()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
http_seeds() add_http_seed() remove_http_seed()
│ │ │ │
│ │ │ │ +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]
│ │ │ │
│ │ │ │
add_extension()
│ │ │ │ @@ -7664,21 +7664,21 @@
│ │ │ │ afterward.
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
resume() pause()
│ │ │ │
│ │ │ │ -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.
│ │ │ │ @@ -7689,24 +7689,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.
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
unset_flags() set_flags() flags()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
flags() unset_flags() set_flags()
│ │ │ │
│ │ │ │ -void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ -void set_flags (torrent_flags_t flags) const;
│ │ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ │ torrent_flags_t flags () const;
│ │ │ │ +void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +void set_flags (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
│ │ │ │ @@ -7862,26 +7862,26 @@
│ │ │ │
│ │ │ │
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.
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
queue_position_up() queue_position_top() queue_position() queue_position_bottom() queue_position_down()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
queue_position() queue_position_top() queue_position_bottom() queue_position_up() queue_position_down()
│ │ │ │
│ │ │ │ -void queue_position_up () const;
│ │ │ │ -void queue_position_top () const;
│ │ │ │ void queue_position_bottom () const;
│ │ │ │ +void queue_position_top () const;
│ │ │ │ void queue_position_down () const;
│ │ │ │ +void queue_position_up () 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
│ │ │ │ @@ -7982,39 +7982,39 @@
│ │ │ │
│ │ │ │ std::vector<std::vector<sha256_hash>> piece_layers () const;
│ │ │ │
│ │ │ │
returns the piece layers for all files in the torrent. If this is a
│ │ │ │ v1 torrent (and doesn't have any piece layers) it returns an empty
│ │ │ │ vector. This is a blocking call that will synchronize with the
│ │ │ │ libtorrent network thread.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
post_piece_availability() piece_availability()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
piece_availability() post_piece_availability()
│ │ │ │
│ │ │ │ -void post_piece_availability () const;
│ │ │ │ void piece_availability (std::vector<int>& avail) const;
│ │ │ │ +void post_piece_availability () const;
│ │ │ │
│ │ │ │
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.
│ │ │ │
post_piece_availability() will trigger a piece_availability_alert
│ │ │ │ to be posted.
│ │ │ │
piece_availability() 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.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
prioritize_pieces() piece_priority() get_piece_priorities()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
piece_priority() prioritize_pieces() get_piece_priorities()
│ │ │ │
│ │ │ │ -download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ void piece_priority (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +download_priority_t piece_priority (piece_index_t index) const;
│ │ │ │ void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
│ │ │ │ std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ │ void prioritize_pieces (std::vector<download_priority_t> const& pieces) 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.
│ │ │ │ @@ -8039,23 +8039,23 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
get_file_priorities() prioritize_files() file_priority()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
file_priority() prioritize_files() get_file_priorities()
│ │ │ │
│ │ │ │ -std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │ │ void prioritize_files (std::vector<download_priority_t> const& files) const;
│ │ │ │ +std::vector<download_priority_t> get_file_priorities () const;
│ │ │ │ download_priority_t file_priority (file_index_t index) 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
│ │ │ │ @@ -8079,23 +8079,23 @@
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
force_reannounce() force_dht_announce() force_lsd_announce()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
force_dht_announce() force_reannounce() force_lsd_announce()
│ │ │ │
│ │ │ │ -void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
│ │ │ │ -void force_lsd_announce () const;
│ │ │ │ void force_dht_announce () const;
│ │ │ │ +void force_lsd_announce () const;
│ │ │ │ +void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) 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
│ │ │ │ as the min_interval expires. This is to honor trackers minimum
│ │ │ │ @@ -8120,24 +8120,24 @@
│ │ │ │
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]
│ │ │ │ -
│ │ │ │ -
upload_limit() set_upload_limit() set_download_limit() download_limit()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
upload_limit() download_limit() set_download_limit() set_upload_limit()
│ │ │ │
│ │ │ │ +void set_upload_limit (int limit) const;
│ │ │ │ +void set_download_limit (int limit) const;
│ │ │ │ int upload_limit () const;
│ │ │ │ int download_limit () const;
│ │ │ │ -void set_download_limit (int 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
│ │ │ │ torrent then the global limit
│ │ │ │ @@ -8174,27 +8174,27 @@
│ │ │ │ torrent. New peers will have to be acquired before resuming, from
│ │ │ │ trackers, DHT or local service discovery, for example.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
max_uploads() set_max_uploads()
│ │ │ │
│ │ │ │ -int max_uploads () const;
│ │ │ │ void set_max_uploads (int max_uploads) const;
│ │ │ │ +int max_uploads () const;
│ │ │ │
│ │ │ │
set_max_uploads() sets the maximum number of peers that's unchoked
│ │ │ │ at the same time on this torrent. If you set this to -1, there will be
│ │ │ │ no limit. This defaults to infinite. The primary setting controlling
│ │ │ │ this is the global unchoke slots limit, set by unchoke_slots_limit in
│ │ │ │ settings_pack.
│ │ │ │
max_uploads() returns the current settings.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
max_connections() set_max_connections()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
set_max_connections() max_connections()
│ │ │ │
│ │ │ │ int max_connections () const;
│ │ │ │ void set_max_connections (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
│ │ │ │ @@ -8260,36 +8260,36 @@
│ │ │ │
rename_file()
│ │ │ │
│ │ │ │ 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]
│ │ │ │ -
│ │ │ │ -
info_hash() info_hashes()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
info_hashes() info_hash()
│ │ │ │
│ │ │ │ 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]
│ │ │ │ +[report issue]
│ │ │ │
│ │ │ │ -
operator<() operator!=() operator==()
│ │ │ │ +
operator==() operator<() operator!=()
│ │ │ │
│ │ │ │ -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]
│ │ │ │
│ │ │ │
id()
│ │ │ │ @@ -8933,18 +8933,18 @@
│ │ │ │
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& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │ disk_buffer_holder (disk_buffer_holder&&) noexcept;
│ │ │ │ - disk_buffer_holder (disk_buffer_holder const&) = delete;
│ │ │ │ + disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ │ disk_buffer_holder& operator= (disk_buffer_holder const&) = delete;
│ │ │ │ + disk_buffer_holder (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;
│ │ │ │ @@ -9019,17 +9019,17 @@
│ │ │ │ settings_interface
│ │ │ │ Declared in "libtorrent/settings_pack.hpp"
│ │ │ │ the common interface to settings_pack and the internal representation of
│ │ │ │ settings.
│ │ │ │
│ │ │ │ struct settings_interface
│ │ │ │ {
│ │ │ │ - virtual void set_int (int name, int 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 int get_int (int name) const = 0;
│ │ │ │ virtual std::string const& get_str (int name) const = 0;
│ │ │ │ virtual bool get_bool (int name) const = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │ @@ -9386,27 +9386,27 @@
│ │ │ │ Declared in "libtorrent/alert_types.hpp"
│ │ │ │ This is posted as a response to a torrent_handle::rename_file() call, if the rename
│ │ │ │ operation succeeds.
│ │ │ │
│ │ │ │ struct file_renamed_alert final : torrent_alert
│ │ │ │ {
│ │ │ │ std::string message () const override;
│ │ │ │ - char const* old_name () const;
│ │ │ │ char const* new_name () const;
│ │ │ │ + char const* old_name () const;
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::storage;
│ │ │ │ file_index_t const index;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
new_name() old_name()
│ │ │ │
│ │ │ │ -char const* old_name () const;
│ │ │ │ char const* new_name () const;
│ │ │ │ +char const* old_name () const;
│ │ │ │
│ │ │ │
returns the new and previous file name, respectively.
│ │ │ │
[report issue]
│ │ │ │ - index
│ │ │ │ - refers to the index of the file that was renamed,
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ @@ -10135,17 +10135,17 @@
│ │ │ │ std::string message () const override;
│ │ │ │ char const* storage_path () const;
│ │ │ │ char const* old_path () const;
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::storage;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
storage_path() old_path()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
old_path() storage_path()
│ │ │ │
│ │ │ │ char const* storage_path () const;
│ │ │ │ char const* old_path () const;
│ │ │ │
│ │ │ │
the path the torrent was moved to and from, respectively.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │ @@ -11786,27 +11786,27 @@
│ │ │ │ posted in response to a call to session::dht_live_nodes(). It contains the
│ │ │ │ live nodes from the DHT routing table of one of the DHT nodes running
│ │ │ │ locally.
│ │ │ │
│ │ │ │ struct dht_live_nodes_alert final : alert
│ │ │ │ {
│ │ │ │ std::string message () const override;
│ │ │ │ - int num_nodes () const;
│ │ │ │ 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]
│ │ │ │ -
nodes() num_nodes()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
num_nodes() nodes()
│ │ │ │
│ │ │ │ -int num_nodes () const;
│ │ │ │ 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]
│ │ │ │ - node_id
│ │ │ │ - the local DHT node's node-ID this routing table belongs to
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ @@ -11835,32 +11835,32 @@
│ │ │ │
Declared in "libtorrent/alert_types.hpp"
│ │ │ │
posted as a response to a call to session::dht_sample_infohashes() with
│ │ │ │ the information from the DHT response message.
│ │ │ │
│ │ │ │ struct dht_sample_infohashes_alert final : alert
│ │ │ │ {
│ │ │ │ std::string message () const override;
│ │ │ │ - std::vector<sha1_hash> samples () const;
│ │ │ │ int num_samples () const;
│ │ │ │ + std::vector<sha1_hash> samples () const;
│ │ │ │ int num_nodes () const;
│ │ │ │ std::vector<std::pair<sha1_hash, udp::endpoint>> nodes () const;
│ │ │ │
│ │ │ │ static constexpr alert_category_t static_category = alert_category::dht_operation;
│ │ │ │ sha1_hash node_id;
│ │ │ │ aux::noexcept_movable<udp::endpoint> endpoint;
│ │ │ │ time_duration const interval;
│ │ │ │ int const num_infohashes;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
samples() num_samples()
│ │ │ │
│ │ │ │ -std::vector<sha1_hash> samples () const;
│ │ │ │ int num_samples () const;
│ │ │ │ +std::vector<sha1_hash> 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().
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
num_nodes()
│ │ │ │ @@ -11921,16 +11921,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]
│ │ │ │ - dropped_alerts
│ │ │ │ @@ -12529,26 +12529,26 @@
│ │ │ │ Declared in "libtorrent/performance_counters.hpp"
│ │ │ │
│ │ │ │ struct counters
│ │ │ │ {
│ │ │ │ counters () ;
│ │ │ │ counters& operator= (counters const&) & ;
│ │ │ │ counters (counters const&) ;
│ │ │ │ - std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ std::int64_t operator[] (int i) const ;
│ │ │ │ + std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ void set_value (int c, std::int64_t value) ;
│ │ │ │ void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
inc_stats_counter() operator[]()
│ │ │ │
│ │ │ │ -std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │ std::int64_t operator[] (int i) const ;
│ │ │ │ +std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ │
│ │ │ │
returns the new value
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
stats_metric
│ │ │ │
Declared in "libtorrent/session_stats.hpp"
│ │ │ │ @@ -12631,20 +12631,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&&);
│ │ │ │ - ip_filter& operator= (ip_filter const&);
│ │ │ │ - ip_filter (ip_filter const&);
│ │ │ │ ip_filter& operator= (ip_filter&&);
│ │ │ │ - ip_filter ();
│ │ │ │ ~ip_filter ();
│ │ │ │ + ip_filter ();
│ │ │ │ + ip_filter (ip_filter const&);
│ │ │ │ + ip_filter (ip_filter&&);
│ │ │ │ + ip_filter& operator= (ip_filter const&);
│ │ │ │ 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
│ │ │ │ {
│ │ │ │ @@ -12728,20 +12728,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 (port_filter&&);
│ │ │ │ + port_filter& operator= (port_filter&&);
│ │ │ │ + port_filter (port_filter const&);
│ │ │ │ + port_filter ();
│ │ │ │ ~port_filter ();
│ │ │ │ port_filter& operator= (port_filter const&);
│ │ │ │ - port_filter ();
│ │ │ │ - port_filter (port_filter const&);
│ │ │ │ - port_filter& operator= (port_filter&&);
│ │ │ │ - port_filter (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,
│ │ │ │ };
│ │ │ │ @@ -12809,46 +12809,46 @@
│ │ │ │ The entry class represents one node in a bencoded hierarchy. It works as a
│ │ │ │ variant type, it can be either a list, a dictionary (std::map), an integer
│ │ │ │ or a string.
│ │ │ │
│ │ │ │ class entry
│ │ │ │ {
│ │ │ │ data_type type () const;
│ │ │ │ - entry (preformatted_type);
│ │ │ │ - entry (list_type);
│ │ │ │ entry (span<char const>);
│ │ │ │ - entry (integer_type);
│ │ │ │ entry (dictionary_type);
│ │ │ │ + entry (integer_type);
│ │ │ │ + entry (preformatted_type);
│ │ │ │ + entry (list_type);
│ │ │ │ entry (U v);
│ │ │ │ entry (data_type t);
│ │ │ │ entry (bdecode_node const& n);
│ │ │ │ entry& operator= (list_type) &;
│ │ │ │ + entry& operator= (dictionary_type) &;
│ │ │ │ + entry& operator= (integer_type) &;
│ │ │ │ + entry& operator= (entry&&) & noexcept;
│ │ │ │ + entry& operator= (preformatted_type) &;
│ │ │ │ + entry& operator= (bdecode_node const&) &;
│ │ │ │ entry& operator= (entry const&) &;
│ │ │ │ entry& operator= (span<char const>) &;
│ │ │ │ - entry& operator= (bdecode_node const&) &;
│ │ │ │ - entry& operator= (preformatted_type) &;
│ │ │ │ - entry& operator= (entry&&) & noexcept;
│ │ │ │ - entry& operator= (integer_type) &;
│ │ │ │ - entry& operator= (dictionary_type) &;
│ │ │ │ entry& operator= (U v) &;
│ │ │ │ - integer_type const& integer () const;
│ │ │ │ integer_type& integer ();
│ │ │ │ + list_type const& list () const;
│ │ │ │ + preformatted_type const& preformatted () const;
│ │ │ │ list_type& list ();
│ │ │ │ dictionary_type& dict ();
│ │ │ │ - preformatted_type& preformatted ();
│ │ │ │ string_type& string ();
│ │ │ │ - preformatted_type const& preformatted () const;
│ │ │ │ string_type const& string () const;
│ │ │ │ dictionary_type const& dict () const;
│ │ │ │ - list_type const& list () const;
│ │ │ │ + preformatted_type& preformatted ();
│ │ │ │ + integer_type const& integer () const;
│ │ │ │ void swap (entry& e);
│ │ │ │ entry& operator[] (string_view key);
│ │ │ │ entry const& operator[] (string_view key) const;
│ │ │ │ - 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,
│ │ │ │ @@ -12864,19 +12864,19 @@
│ │ │ │ data_type type () const;
│ │ │ │
│ │ │ │ returns the concrete type of the entry
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
entry()
│ │ │ │
│ │ │ │ -entry (preformatted_type);
│ │ │ │ -entry (list_type);
│ │ │ │ entry (span<char const>);
│ │ │ │ -entry (integer_type);
│ │ │ │ entry (dictionary_type);
│ │ │ │ +entry (integer_type);
│ │ │ │ +entry (preformatted_type);
│ │ │ │ +entry (list_type);
│ │ │ │
│ │ │ │
constructors directly from a specific type.
│ │ │ │ The content of the argument is copied into the
│ │ │ │ newly constructed entry
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
entry()
│ │ │ │ @@ -12893,42 +12893,42 @@
│ │ │ │
│ │ │ │
construct from bdecode_node parsed form (see bdecode())
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
operator=()
│ │ │ │
│ │ │ │ entry& operator= (list_type) &;
│ │ │ │ +entry& operator= (dictionary_type) &;
│ │ │ │ +entry& operator= (integer_type) &;
│ │ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ │ +entry& operator= (preformatted_type) &;
│ │ │ │ +entry& operator= (bdecode_node const&) &;
│ │ │ │ entry& operator= (entry const&) &;
│ │ │ │ entry& operator= (span<char const>) &;
│ │ │ │ -entry& operator= (bdecode_node const&) &;
│ │ │ │ -entry& operator= (preformatted_type) &;
│ │ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ │ -entry& operator= (integer_type) &;
│ │ │ │ -entry& operator= (dictionary_type) &;
│ │ │ │
│ │ │ │
copies the structure of the right hand side into this
│ │ │ │ entry.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │
find_key()
│ │ │ │
│ │ │ │ -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]
│ │ │ │ @@ -13127,61 +13127,61 @@
│ │ │ │
This class holds state for creating a torrent. After having added
│ │ │ │ all information to it, call create_torrent::generate() to generate
│ │ │ │ the torrent. The entry that's returned can then be bencoded into a
│ │ │ │ .torrent file using bencode().
│ │ │ │
│ │ │ │ struct create_torrent
│ │ │ │ {
│ │ │ │ - explicit create_torrent (torrent_info const& ti);
│ │ │ │ explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │ , create_flags_t flags = {});
│ │ │ │ + explicit create_torrent (torrent_info const& ti);
│ │ │ │ std::vector<char> generate_buf () const;
│ │ │ │ entry generate () 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_url_seed (string_view url);
│ │ │ │ void add_http_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_size (piece_index_t i) const;
│ │ │ │ int piece_length () const;
│ │ │ │ - void add_similar_torrent (sha1_hash ih);
│ │ │ │ + int piece_size (piece_index_t i) const;
│ │ │ │ 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;
│ │ │ │ static constexpr create_flags_t canonical_files_no_tail_padding = 9_bit;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
create_torrent()
│ │ │ │
│ │ │ │ -explicit create_torrent (torrent_info const& ti);
│ │ │ │ explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ │ , create_flags_t flags = {});
│ │ │ │ +explicit create_torrent (torrent_info const& ti);
│ │ │ │
│ │ │ │
The piece_size is the size of each piece in bytes. It must be a
│ │ │ │ power of 2 and a minimum of 16 kiB. If a piece size of 0 is
│ │ │ │ specified, a piece_size will be set automatically.
│ │ │ │
The flags arguments specifies options for the torrent creation. It can
│ │ │ │ be any combination of the flags defined by create_flags_t.
│ │ │ │
The file_storage (fs) parameter defines the files, sizes and
│ │ │ │ @@ -13345,16 +13345,16 @@
│ │ │ │
The string is not the path to the cert, it's the actual content of the
│ │ │ │ certificate.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
set_priv() priv()
│ │ │ │
│ │ │ │ -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]
│ │ │ │
│ │ │ │ @@ -13394,27 +13394,27 @@
│ │ │ │
│ │ │ │
the total number of bytes of all files and pad files
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
piece_size() piece_length()
│ │ │ │
│ │ │ │ -int piece_size (piece_index_t i) const;
│ │ │ │ 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]
│ │ │ │
│ │ │ │
add_collection() add_similar_torrent()
│ │ │ │
│ │ │ │ -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.
│ │ │ │ @@ -13479,17 +13479,17 @@
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
│ │ │ │
add_files()
│ │ │ │
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:
│ │ │ │
│ │ │ │ @@ -13502,29 +13502,29 @@
│ │ │ │ The flags argument should be the same as the flags passed to the create_torrent
│ │ │ │ constructor.
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
set_piece_hashes()
│ │ │ │
Declared in "libtorrent/create_torrent.hpp"
│ │ │ │
│ │ │ │ -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
│ │ │ │ - , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +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, 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, 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
│ │ │ │ + , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │ +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);
│ │ │ │ -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);
│ │ │ │
│ │ │ │
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:
│ │ │ │
│ │ │ │ void Fun(piece_index_t);
│ │ │ │ @@ -13538,49 +13538,49 @@
│ │ │ │ bitfield
│ │ │ │ Declared in "libtorrent/bitfield.hpp"
│ │ │ │ The bitfield type stores any number of bits as a bitfield
│ │ │ │ in a heap allocated array.
│ │ │ │
│ │ │ │ struct bitfield
│ │ │ │ {
│ │ │ │ - bitfield () noexcept = default;
│ │ │ │ - bitfield (int bits, bool val);
│ │ │ │ - bitfield (bitfield const& rhs);
│ │ │ │ - bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ bitfield (char const* b, int bits);
│ │ │ │ + bitfield (bitfield const& rhs);
│ │ │ │ + bitfield (int bits, bool val);
│ │ │ │ + bitfield () noexcept = default;
│ │ │ │ explicit bitfield (int bits);
│ │ │ │ + bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │ - bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ + bool operator[] (int index) const noexcept;
│ │ │ │ void set_bit (int index) noexcept;
│ │ │ │ void clear_bit (int index) noexcept;
│ │ │ │ bool all_set () const noexcept;
│ │ │ │ bool none_set () const noexcept;
│ │ │ │ int size () const noexcept;
│ │ │ │ int num_words () const noexcept;
│ │ │ │ int num_bytes () const noexcept;
│ │ │ │ bool empty () const noexcept;
│ │ │ │ - char const* data () const noexcept;
│ │ │ │ char* data () noexcept;
│ │ │ │ + char const* data () const noexcept;
│ │ │ │ void swap (bitfield& rhs) noexcept;
│ │ │ │ int count () const noexcept;
│ │ │ │ int find_first_set () const noexcept;
│ │ │ │ int find_last_clear () const noexcept;
│ │ │ │ bool operator== (lt::bitfield const& rhs) const;
│ │ │ │ };
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
bitfield()
│ │ │ │
│ │ │ │ -bitfield () noexcept = default;
│ │ │ │ -bitfield (int bits, bool val);
│ │ │ │ -bitfield (bitfield const& rhs);
│ │ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │ bitfield (char const* b, int bits);
│ │ │ │ +bitfield (bitfield const& rhs);
│ │ │ │ +bitfield (int bits, bool val);
│ │ │ │ +bitfield () noexcept = default;
│ │ │ │ explicit bitfield (int bits);
│ │ │ │ +bitfield (bitfield&& rhs) noexcept = default;
│ │ │ │
│ │ │ │
constructs a new bitfield. The default constructor creates an empty
│ │ │ │ bitfield. bits is the size of the bitfield (specified in bits).
│ │ │ │ val is the value to initialize the bits to. If not specified
│ │ │ │ all bits are initialized to 0.
│ │ │ │
The constructor taking a pointer b and bits copies a bitfield
│ │ │ │ from the specified buffer, and bits number of bits (rounded up to
│ │ │ │ @@ -13589,21 +13589,21 @@
│ │ │ │
│ │ │ │
assign()
│ │ │ │
│ │ │ │ void assign (char const* b, int const bits);
│ │ │ │
│ │ │ │
copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ │ the nearest byte boundary.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
operator[]() get_bit()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
get_bit() operator[]()
│ │ │ │
│ │ │ │ -bool operator[] (int index) const noexcept;
│ │ │ │ bool get_bit (int index) const noexcept;
│ │ │ │ +bool operator[] (int index) const noexcept;
│ │ │ │
│ │ │ │
query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
clear_bit() set_bit()
│ │ │ │
│ │ │ │ @@ -13655,16 +13655,16 @@
│ │ │ │ bool empty () const noexcept;
│ │ │ │
│ │ │ │
returns true if the bitfield has zero size.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
data()
│ │ │ │
│ │ │ │ -char const* data () const noexcept;
│ │ │ │ char* data () noexcept;
│ │ │ │ +char const* data () const noexcept;
│ │ │ │
│ │ │ │
returns a pointer to the internal buffer of the bitfield, or
│ │ │ │ nullptr if it's empty.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
swap()
│ │ │ │
│ │ │ │ @@ -13710,32 +13710,32 @@
│ │ │ │ The built-in software version of sha1-algorithm was implemented
│ │ │ │ by Steve Reid and released as public domain.
│ │ │ │ For more info, see src/sha1.cpp.
│ │ │ │
│ │ │ │ class hasher
│ │ │ │ {
│ │ │ │ hasher ();
│ │ │ │ - explicit hasher (span<char const> data);
│ │ │ │ - hasher& operator= (hasher const&) &;
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ hasher (hasher const&);
│ │ │ │ + explicit hasher (span<char const> data);
│ │ │ │ + hasher& operator= (hasher const&) &;
│ │ │ │ hasher& update (span<char const> data);
│ │ │ │ hasher& update (char const* data, int len);
│ │ │ │ sha1_hash final ();
│ │ │ │ void reset ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
hasher() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
operator=() hasher()
│ │ │ │
│ │ │ │ -explicit hasher (span<char const> data);
│ │ │ │ -hasher& operator= (hasher const&) &;
│ │ │ │ hasher (char const* data, int len);
│ │ │ │ hasher (hasher const&);
│ │ │ │ +explicit hasher (span<char const> data);
│ │ │ │ +hasher& operator= (hasher const&) &;
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ @@ -13765,41 +13765,41 @@
│ │ │ │ hasher256
│ │ │ │ Declared in "libtorrent/hasher.hpp"
│ │ │ │
│ │ │ │ class hasher256
│ │ │ │ {
│ │ │ │ hasher256 ();
│ │ │ │ hasher256 (hasher256 const&);
│ │ │ │ - hasher256 (char const* data, int len);
│ │ │ │ - hasher256& operator= (hasher256 const&) &;
│ │ │ │ explicit hasher256 (span<char const> data);
│ │ │ │ - hasher256& update (span<char const> data);
│ │ │ │ + hasher256& operator= (hasher256 const&) &;
│ │ │ │ + hasher256 (char const* data, int len);
│ │ │ │ hasher256& update (char const* data, int len);
│ │ │ │ + hasher256& update (span<char const> data);
│ │ │ │ sha256_hash final ();
│ │ │ │ void reset ();
│ │ │ │ ~hasher256 ();
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
operator=() hasher256()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
hasher256() operator=()
│ │ │ │
│ │ │ │ hasher256 (hasher256 const&);
│ │ │ │ -hasher256 (char const* data, int len);
│ │ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ │ explicit hasher256 (span<char const> data);
│ │ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ │ +hasher256 (char const* data, int len);
│ │ │ │
│ │ │ │
this is the same as default constructing followed by a call to
│ │ │ │ update(data, len).
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
update()
│ │ │ │
│ │ │ │ -hasher256& update (span<char const> data);
│ │ │ │ hasher256& update (char const* data, int len);
│ │ │ │ +hasher256& update (span<char const> data);
│ │ │ │
│ │ │ │
append the following bytes to what is being hashed
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
final()
│ │ │ │
│ │ │ │ sha256_hash final ();
│ │ │ │ @@ -14483,19 +14483,19 @@
│ │ │ │ announce_entry
│ │ │ │ Declared in "libtorrent/announce_entry.hpp"
│ │ │ │ this class holds information about one bittorrent tracker, as it
│ │ │ │ relates to a specific torrent.
│ │ │ │
│ │ │ │ struct announce_entry
│ │ │ │ {
│ │ │ │ - announce_entry& operator= (announce_entry const&) &;
│ │ │ │ explicit announce_entry (string_view u);
│ │ │ │ + announce_entry (announce_entry const&);
│ │ │ │ ~announce_entry ();
│ │ │ │ announce_entry ();
│ │ │ │ - announce_entry (announce_entry const&);
│ │ │ │ + announce_entry& operator= (announce_entry const&) &;
│ │ │ │
│ │ │ │ enum tracker_source
│ │ │ │ {
│ │ │ │ source_torrent,
│ │ │ │ source_client,
│ │ │ │ source_magnet_link,
│ │ │ │ source_tex,
│ │ │ │ @@ -14507,23 +14507,23 @@
│ │ │ │ std::uint8_t tier = 0;
│ │ │ │ std::uint8_t fail_limit = 0;
│ │ │ │ std::uint8_t source:4;
│ │ │ │ bool verified:1;
│ │ │ │ };
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
~announce_entry() announce_entry() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
~announce_entry() operator=() announce_entry()
│ │ │ │
│ │ │ │ -announce_entry& operator= (announce_entry const&) &;
│ │ │ │ explicit announce_entry (string_view u);
│ │ │ │ +announce_entry (announce_entry const&);
│ │ │ │ ~announce_entry ();
│ │ │ │ announce_entry ();
│ │ │ │ -announce_entry (announce_entry const&);
│ │ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ │
│ │ │ │
constructs a tracker announce entry with u as the URL.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
enum tracker_source
│ │ │ │
Declared in "libtorrent/announce_entry.hpp"
│ │ │ │
│ │ │ │ @@ -19098,24 +19098,24 @@
│ │ │ │ i2p_port).
│ │ │ │
│ │ │ │ struct settings_pack final : settings_interface
│ │ │ │ {
│ │ │ │ friend void apply_pack_impl (settings_pack const*
│ │ │ │ , aux::session_settings_single_thread&
│ │ │ │ , std::vector<void(aux::session_impl::*)()>*);
│ │ │ │ - void set_int (int name, int val) override;
│ │ │ │ void set_str (int name, std::string val) override;
│ │ │ │ - void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ void set_bool (int name, bool val) override;
│ │ │ │ + void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ + void set_int (int name, int val) override;
│ │ │ │ bool has_val (int name) const override;
│ │ │ │ void clear ();
│ │ │ │ void clear (int name);
│ │ │ │ + bool get_bool (int name) const override;
│ │ │ │ std::string const& get_str (int name) const override;
│ │ │ │ int get_int (int name) const override;
│ │ │ │ - bool get_bool (int name) const override;
│ │ │ │ void for_each (Fun&& f) const;
│ │ │ │
│ │ │ │ enum type_bases
│ │ │ │ {
│ │ │ │ string_type_base,
│ │ │ │ int_type_base,
│ │ │ │ bool_type_base,
│ │ │ │ @@ -19185,23 +19185,23 @@
│ │ │ │ socks5,
│ │ │ │ socks5_pw,
│ │ │ │ http,
│ │ │ │ http_pw,
│ │ │ │ };
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -[report issue]
│ │ │ │ -
set_int() set_bool() set_str()
│ │ │ │ +
[report issue]
│ │ │ │ +
set_str() set_bool() set_int()
│ │ │ │
│ │ │ │ -void set_int (int name, int val) override;
│ │ │ │ void set_str (int name, std::string val) override;
│ │ │ │ -void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ void set_bool (int name, bool val) override;
│ │ │ │ +void set_int (int name, flags::bitfield_flag<Type, Tag> const val);
│ │ │ │ +void set_int (int name, int val) override;
│ │ │ │
│ │ │ │
set a configuration option in the settings_pack. name is one of
│ │ │ │ the enum values from string_types, int_types or bool_types. They must
│ │ │ │ match the respective type of the set_* function.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
has_val()
│ │ │ │ @@ -19227,17 +19227,17 @@
│ │ │ │
clear a specific setting from the pack
│ │ │ │
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
get_str() get_int() get_bool()
│ │ │ │
│ │ │ │ +bool get_bool (int name) const override;
│ │ │ │ std::string const& get_str (int name) const override;
│ │ │ │ int get_int (int name) const override;
│ │ │ │ -bool get_bool (int name) const override;
│ │ │ │
│ │ │ │
queries the current configuration option from the settings_pack.
│ │ │ │ name is one of the enumeration values from string_types, int_types
│ │ │ │ or bool_types. The enum value must match the type of the get_*
│ │ │ │ function. If the specified setting field has not been set, the default
│ │ │ │ value is returned.
│ │ │ │
[report issue]
│ │ │ │ @@ -19683,18 +19683,18 @@
│ │ │ │ pieces, instead of reading it all into memory before hashing.
│ │ │ │
This configuration is intended to be the starting point for embedded
│ │ │ │ devices. It will significantly reduce memory usage.
│ │ │ │
high_performance_seed returns settings optimized for a seed box,
│ │ │ │ serving many peers and that doesn't do any downloading. It has a 128 MB
│ │ │ │ disk cache and has a limit of 400 files in its file pool. It support fast
│ │ │ │ upload rates by allowing large send buffers.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
setting_by_name() name_for_setting()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
name_for_setting() setting_by_name()
│ │ │ │
Declared in "libtorrent/settings_pack.hpp"
│ │ │ │
│ │ │ │ int setting_by_name (string_view name);
│ │ │ │ char const* name_for_setting (int s);
│ │ │ │
│ │ │ │
converts a setting integer (from the enums string_types, int_types or
│ │ │ │ bool_types) to a string, and vice versa.
│ │ │ │ @@ -19714,46 +19714,46 @@
│ │ │ │ to be able to copy it as a reference for instance). For that, use the
│ │ │ │
non_owning() member function.
│ │ │ │
There are 5 different types of nodes, see type_t.
│ │ │ │
│ │ │ │ struct bdecode_node
│ │ │ │ {
│ │ │ │ bdecode_node () = default;
│ │ │ │ + bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ + bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ bdecode_node (bdecode_node const&);
│ │ │ │ bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ - bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ - bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ type_t type () const noexcept;
│ │ │ │ explicit operator bool () const noexcept;
│ │ │ │ bdecode_node non_owning () const;
│ │ │ │ - span<char const> data_section () const noexcept;
│ │ │ │ std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ + span<char const> data_section () const noexcept;
│ │ │ │ + bdecode_node list_at (int i) const;
│ │ │ │ std::int64_t list_int_value_at (int i
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ - bdecode_node list_at (int i) const;
│ │ │ │ int list_size () const;
│ │ │ │ string_view list_string_value_at (int i
│ │ │ │ , string_view default_val = string_view()) const;
│ │ │ │ - bdecode_node dict_find_int (string_view key) const;
│ │ │ │ - int dict_size () const;
│ │ │ │ - bdecode_node dict_find_list (string_view key) const;
│ │ │ │ - bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ - bdecode_node dict_find_string (string_view key) const;
│ │ │ │ std::int64_t dict_find_int_value (string_view key
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ + std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ bdecode_node dict_find (string_view key) const;
│ │ │ │ + std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ + int dict_size () const;
│ │ │ │ + bdecode_node dict_find_int (string_view key) const;
│ │ │ │ + bdecode_node dict_find_string (string_view key) const;
│ │ │ │ + bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ + bdecode_node dict_find_list (string_view key) const;
│ │ │ │ string_view dict_find_string_value (string_view key
│ │ │ │ , string_view default_value = string_view()) const;
│ │ │ │ - std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ - std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ std::int64_t int_value () const;
│ │ │ │ - std::ptrdiff_t string_offset () const;
│ │ │ │ string_view string_value () const;
│ │ │ │ - int string_length () const;
│ │ │ │ + std::ptrdiff_t string_offset () const;
│ │ │ │ char const* string_ptr () const;
│ │ │ │ + int string_length () const;
│ │ │ │ void clear ();
│ │ │ │ void swap (bdecode_node& n);
│ │ │ │ void reserve (int tokens);
│ │ │ │ void switch_underlying_buffer (char const* buf) noexcept;
│ │ │ │ bool has_soft_error (span<char> error) const;
│ │ │ │
│ │ │ │ enum type_t
│ │ │ │ @@ -19768,23 +19768,23 @@
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
bdecode_node()
│ │ │ │
│ │ │ │ bdecode_node () = default;
│ │ │ │
│ │ │ │
creates a default constructed node, it will have the type none_t.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
bdecode_node() operator=()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
operator=() bdecode_node()
│ │ │ │
│ │ │ │ +bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │ +bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ bdecode_node (bdecode_node const&);
│ │ │ │ bdecode_node (bdecode_node&&) noexcept;
│ │ │ │ -bdecode_node& operator= (bdecode_node const&) &;
│ │ │ │ -bdecode_node& operator= (bdecode_node&&) & = default;
│ │ │ │
│ │ │ │
For owning nodes, the copy will create a copy of the tree, but the
│ │ │ │ underlying buffer remains the same.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
type()
│ │ │ │
│ │ │ │ @@ -19807,66 +19807,66 @@
│ │ │ │ return a non-owning reference to this node. This is useful to refer to
│ │ │ │ the root node without copying it in assignments.
│ │ │ │
│ │ │ │ [report issue]
│ │ │ │
│ │ │ │
data_section() data_offset()
│ │ │ │
│ │ │ │ -span<char const> data_section () const noexcept;
│ │ │ │ std::ptrdiff_t data_offset () const noexcept;
│ │ │ │ +span<char const> data_section () const noexcept;
│ │ │ │
│ │ │ │
returns the buffer and length of the section in the original bencoded
│ │ │ │ buffer where this node is defined. For a dictionary for instance, this
│ │ │ │ starts with d and ends with e, and has all the content of the
│ │ │ │ dictionary in between.
│ │ │ │ the data_offset() function returns the byte-offset to this node in,
│ │ │ │ starting from the beginning of the buffer that was parsed.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
list_at() list_string_value_at() list_size() list_int_value_at()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
list_string_value_at() list_int_value_at() list_at() list_size()
│ │ │ │
│ │ │ │ +bdecode_node list_at (int i) const;
│ │ │ │ std::int64_t list_int_value_at (int i
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ -bdecode_node list_at (int i) const;
│ │ │ │ int list_size () const;
│ │ │ │ string_view list_string_value_at (int i
│ │ │ │ , string_view default_val = string_view()) const;
│ │ │ │
│ │ │ │
functions with the list_ prefix operate on lists. These functions are
│ │ │ │ only valid if type() == list_t. list_at() returns the item
│ │ │ │ in the list at index i. i may not be greater than or equal to the
│ │ │ │ size of the list. size() returns the size of the list.
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
dict_find_dict() dict_at() dict_find_int() dict_size() dict_at_node() dict_find_int_value() dict_find() dict_find_list() dict_find_string_value() dict_find_string()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
dict_find_string_value() dict_find() dict_find_int_value() dict_at() dict_find_list() dict_find_string() dict_find_dict() dict_find_int() dict_size() dict_at_node()
│ │ │ │
│ │ │ │ -bdecode_node dict_find_int (string_view key) const;
│ │ │ │ -int dict_size () const;
│ │ │ │ -bdecode_node dict_find_list (string_view key) const;
│ │ │ │ -bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ -bdecode_node dict_find_string (string_view key) const;
│ │ │ │ std::int64_t dict_find_int_value (string_view key
│ │ │ │ , std::int64_t default_val = 0) const;
│ │ │ │ +std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │ bdecode_node dict_find (string_view key) const;
│ │ │ │ +std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ +int dict_size () const;
│ │ │ │ +bdecode_node dict_find_int (string_view key) const;
│ │ │ │ +bdecode_node dict_find_string (string_view key) const;
│ │ │ │ +bdecode_node dict_find_dict (string_view key) const;
│ │ │ │ +bdecode_node dict_find_list (string_view key) const;
│ │ │ │ string_view dict_find_string_value (string_view key
│ │ │ │ , string_view default_value = string_view()) const;
│ │ │ │ -std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ │ -std::pair<bdecode_node, bdecode_node> dict_at_node (int i) const;
│ │ │ │
│ │ │ │
Functions with the dict_ prefix operates on dictionaries. They are
│ │ │ │ only valid if type() == dict_t. In case a key you're looking up
│ │ │ │ contains a 0 byte, you cannot use the 0-terminated string overloads,
│ │ │ │ but have to use string_view instead. dict_find_list will return a
│ │ │ │ valid bdecode_node if the key is found _and_ it is a list. Otherwise
│ │ │ │ it will return a default-constructed bdecode_node.
│ │ │ │ @@ -19881,25 +19881,25 @@
│ │ │ │
│ │ │ │
int_value()
│ │ │ │
│ │ │ │ std::int64_t int_value () const;
│ │ │ │
│ │ │ │
this function is only valid if type() == int_t. It returns the
│ │ │ │ value of the integer.
│ │ │ │ -
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
string_length() string_ptr() string_offset() string_value()
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
string_ptr() string_value() string_length() string_offset()
│ │ │ │
│ │ │ │ -std::ptrdiff_t string_offset () const;
│ │ │ │ string_view string_value () const;
│ │ │ │ -int string_length () const;
│ │ │ │ +std::ptrdiff_t string_offset () const;
│ │ │ │ char const* string_ptr () const;
│ │ │ │ +int string_length () const;
│ │ │ │
│ │ │ │
these functions are only valid if type() == string_t. They return
│ │ │ │ the string values. Note that string_ptr() is not 0-terminated.
│ │ │ │ string_length() returns the number of bytes in the string.
│ │ │ │ string_offset() returns the byte offset from the start of the parsed
│ │ │ │ bencoded buffer this string can be found.
│ │ │ │
[report issue]
│ │ │ │ @@ -20338,21 +20338,21 @@
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
read_resume_data()
│ │ │ │
Declared in "libtorrent/read_resume_data.hpp"
│ │ │ │
│ │ │ │ add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ + , int piece_limit = 0x200000);
│ │ │ │ +add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ , error_code& ec, int piece_limit = 0x200000);
│ │ │ │ add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ , load_torrent_limits const& cfg = {});
│ │ │ │ add_torrent_params read_resume_data (span<char const> buffer
│ │ │ │ , error_code& ec, load_torrent_limits const& cfg = {});
│ │ │ │ -add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ │ - , int piece_limit = 0x200000);
│ │ │ │
│ │ │ │
these functions are used to parse resume data and populate the appropriate
│ │ │ │ fields in an add_torrent_params object. This object can then be used to add
│ │ │ │ the actual torrent_info object to and pass to session::add_torrent() or
│ │ │ │ session::async_add_torrent().
│ │ │ │
If the client wants to override any field that was loaded from the resume
│ │ │ │ data, e.g. save_path, those fields must be changed after loading resume
│ │ │ │ @@ -20360,33 +20360,33 @@
│ │ │ │
The piece_limit parameter determines the largest number of pieces
│ │ │ │ allowed in the torrent that may be loaded as part of the resume data, if
│ │ │ │ it contains an info field. The overloads that take a flat buffer are
│ │ │ │ instead configured with limits on torrent sizes via load_torrent limits.
│ │ │ │
In order to support large torrents, it may also be necessary to raise the
│ │ │ │ settings_pack::max_piece_count setting and pass a higher limit to calls
│ │ │ │ to torrent_info::parse_info_section().
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
write_resume_data_buf() write_resume_data()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
write_resume_data() write_resume_data_buf()
│ │ │ │
Declared in "libtorrent/write_resume_data.hpp"
│ │ │ │
│ │ │ │ entry write_resume_data (add_torrent_params const& atp);
│ │ │ │ std::vector<char> write_resume_data_buf (add_torrent_params const& atp);
│ │ │ │
│ │ │ │
this function turns the resume data in an add_torrent_params object
│ │ │ │ into a bencoded structure
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
write_torrent_file() write_torrent_file_buf()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
write_torrent_file_buf() write_torrent_file()
│ │ │ │
Declared in "libtorrent/write_resume_data.hpp"
│ │ │ │
│ │ │ │ -entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │ entry write_torrent_file (add_torrent_params const& atp, write_torrent_flags_t flags);
│ │ │ │ +entry write_torrent_file (add_torrent_params const& atp);
│ │ │ │ std::vector<char> write_torrent_file_buf (add_torrent_params const& atp
│ │ │ │ , write_torrent_flags_t flags);
│ │ │ │
│ │ │ │
writes only the fields to create a .torrent file. This function may fail
│ │ │ │ with a std::system_error exception if:
│ │ │ │
│ │ │ │
│ │ │ │
ed25519_add_scalar()
│ │ │ │
Declared in "libtorrent/kademlia/ed25519.hpp"
│ │ │ │
│ │ │ │ -secret_key ed25519_add_scalar (secret_key const& sk
│ │ │ │ - , std::array<char, 32> const& scalar);
│ │ │ │ public_key ed25519_add_scalar (public_key const& pk
│ │ │ │ , std::array<char, 32> const& scalar);
│ │ │ │ +secret_key ed25519_add_scalar (secret_key const& sk
│ │ │ │ + , std::array<char, 32> const& scalar);
│ │ │ │
│ │ │ │
Adds a scalar to the given key pair where scalar is a 32 byte buffer
│ │ │ │ (possibly generated with ed25519_create_seed), generating a new key pair.
│ │ │ │
You can calculate the public key sum without knowing the private key and
│ │ │ │ vice versa by passing in null for the key you don't know. This is useful
│ │ │ │ when a third party (an authoritative server for example) needs to enforce
│ │ │ │ randomness on a key pair while only knowing the public key of the other
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -22,87 +22,87 @@
│ │ │ │ │ * _e_n_u_m_ _s_o_c_k_s___e_r_r_o_r___c_o_d_e
│ │ │ │ │ * _e_n_u_m_ _p_c_p___e_r_r_o_r_s
│ │ │ │ │ * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ │ * _s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ │ o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ o _s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ - o _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _s_e_s_s_i_o_n___p_r_o_x_y_(_)
│ │ │ │ │ + o _s_e_s_s_i_o_n___p_r_o_x_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _~_s_e_s_s_i_o_n___p_r_o_x_y_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n
│ │ │ │ │ o _s_e_s_s_i_o_n_(_)
│ │ │ │ │ o _s_e_s_s_i_o_n_(_)
│ │ │ │ │ o _~_s_e_s_s_i_o_n_(_)
│ │ │ │ │ o _a_b_o_r_t_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _s_e_s_s_i_o_n___s_t_a_t_e_(_)
│ │ │ │ │ - o _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)
│ │ │ │ │ + o _r_e_f_r_e_s_h___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)_ _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_)
│ │ │ │ │ o _p_o_s_t___t_o_r_r_e_n_t___u_p_d_a_t_e_s_(_)
│ │ │ │ │ o _p_o_s_t___s_e_s_s_i_o_n___s_t_a_t_s_(_)
│ │ │ │ │ o _p_o_s_t___d_h_t___s_t_a_t_s_(_)
│ │ │ │ │ o _s_e_t___d_h_t___s_t_a_t_e_(_)
│ │ │ │ │ - o _f_i_n_d___t_o_r_r_e_n_t_(_)_ _g_e_t___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ + o _g_e_t___t_o_r_r_e_n_t_s_(_)_ _f_i_n_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ o _a_d_d___t_o_r_r_e_n_t_(_)_ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ - o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)_ _i_s___p_a_u_s_e_d_(_)
│ │ │ │ │ + o _i_s___p_a_u_s_e_d_(_)_ _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ o _i_s___d_h_t___r_u_n_n_i_n_g_(_)
│ │ │ │ │ o _s_e_t___d_h_t___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _a_d_d___d_h_t___n_o_d_e_(_)
│ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___g_e_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ o _d_h_t___p_u_t___i_t_e_m_(_)
│ │ │ │ │ - o _d_h_t___a_n_n_o_u_n_c_e_(_)_ _d_h_t___g_e_t___p_e_e_r_s_(_)
│ │ │ │ │ + o _d_h_t___g_e_t___p_e_e_r_s_(_)_ _d_h_t___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ o _d_h_t___l_i_v_e___n_o_d_e_s_(_)
│ │ │ │ │ o _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s_(_)
│ │ │ │ │ o _d_h_t___d_i_r_e_c_t___r_e_q_u_e_s_t_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ o _g_e_t___i_p___f_i_l_t_e_r_(_)_ _s_e_t___i_p___f_i_l_t_e_r_(_)
│ │ │ │ │ o _s_e_t___p_o_r_t___f_i_l_t_e_r_(_)
│ │ │ │ │ o _l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_)_ _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)
│ │ │ │ │ - o _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)
│ │ │ │ │ + o _g_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_)
│ │ │ │ │ o _g_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_(_)
│ │ │ │ │ o _c_r_e_a_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _d_e_l_e_t_e___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ - o _g_e_t___p_e_e_r___c_l_a_s_s_(_)_ _s_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ + o _s_e_t___p_e_e_r___c_l_a_s_s_(_)_ _g_e_t___p_e_e_r___c_l_a_s_s_(_)
│ │ │ │ │ o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ │ o _g_e_t___s_e_t_t_i_n_g_s_(_)_ _a_p_p_l_y___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ - o _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)_ _p_o_p___a_l_e_r_t_s_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)
│ │ │ │ │ + o _p_o_p___a_l_e_r_t_s_(_)_ _w_a_i_t___f_o_r___a_l_e_r_t_(_)_ _s_e_t___a_l_e_r_t___n_o_t_i_f_y_(_)
│ │ │ │ │ o _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_)_ _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │ o _r_e_o_p_e_n___n_e_t_w_o_r_k___s_o_c_k_e_t_s_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ - * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ + * _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)_ _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s___b_u_f_(_)_ _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ * _w_e_b___s_e_e_d___e_n_t_r_y
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_<_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │ * _l_o_a_d___t_o_r_r_e_n_t___l_i_m_i_t_s
│ │ │ │ │ * _t_o_r_r_e_n_t___i_n_f_o
│ │ │ │ │ o _t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ o _~_t_o_r_r_e_n_t___i_n_f_o_(_)
│ │ │ │ │ o _f_i_l_e_s_(_)_ _o_r_i_g___f_i_l_e_s_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ o _r_e_m_a_p___f_i_l_e_s_(_)
│ │ │ │ │ - o _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)_ _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ - o _c_o_l_l_e_c_t_i_o_n_s_(_)_ _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)
│ │ │ │ │ - o _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ + o _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _c_l_e_a_r___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ + o _s_i_m_i_l_a_r___t_o_r_r_e_n_t_s_(_)_ _c_o_l_l_e_c_t_i_o_n_s_(_)
│ │ │ │ │ + o _s_e_t___w_e_b___s_e_e_d_s_(_)_ _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ - o _e_n_d___p_i_e_c_e_(_)_ _l_a_s_t___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ - o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ + o _l_a_s_t___p_i_e_c_e_(_)_ _e_n_d___p_i_e_c_e_(_)_ _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ + o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ o _v_1_(_)_ _v_2_(_)
│ │ │ │ │ o _n_u_m___f_i_l_e_s_(_)
│ │ │ │ │ o _m_a_p___b_l_o_c_k_(_)
│ │ │ │ │ o _m_a_p___f_i_l_e_(_)
│ │ │ │ │ o _s_s_l___c_e_r_t_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ o _p_r_i_v_(_)
│ │ │ │ │ o _i_s___i_2_p_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ - o _h_a_s_h___f_o_r___p_i_e_c_e_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)
│ │ │ │ │ + o _h_a_s_h___f_o_r___p_i_e_c_e___p_t_r_(_)_ _h_a_s_h___f_o_r___p_i_e_c_e_(_)
│ │ │ │ │ o _n_a_m_e_(_)
│ │ │ │ │ o _c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ │ o _c_r_e_a_t_o_r_(_)
│ │ │ │ │ o _c_o_m_m_e_n_t_(_)
│ │ │ │ │ o _n_o_d_e_s_(_)
│ │ │ │ │ o _a_d_d___n_o_d_e_(_)
│ │ │ │ │ o _p_a_r_s_e___i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │ @@ -110,22 +110,22 @@
│ │ │ │ │ o _i_n_f_o___s_e_c_t_i_o_n_(_)
│ │ │ │ │ o _p_i_e_c_e___l_a_y_e_r_(_)
│ │ │ │ │ o _f_r_e_e___p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │ * _p_e_e_r___i_n_f_o
│ │ │ │ │ o _i_2_p___d_e_s_t_i_n_a_t_i_o_n_(_)
│ │ │ │ │ * _i_n_f_o___h_a_s_h___t
│ │ │ │ │ o _i_n_f_o___h_a_s_h___t_(_)
│ │ │ │ │ - o _h_a_s_(_)_ _h_a_s___v_1_(_)_ _h_a_s___v_2_(_)
│ │ │ │ │ + o _h_a_s_(_)_ _h_a_s___v_2_(_)_ _h_a_s___v_1_(_)
│ │ │ │ │ o _g_e_t_(_)
│ │ │ │ │ o _g_e_t___b_e_s_t_(_)
│ │ │ │ │ o _f_o_r___e_a_c_h_(_)
│ │ │ │ │ * _p_i_e_c_e___b_l_o_c_k
│ │ │ │ │ * _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ - * _l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)_ _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)_ _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ + * _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)_ _l_o_a_d___t_o_r_r_e_n_t___f_i_l_e_(_)_ _l_o_a_d___t_o_r_r_e_n_t___b_u_f_f_e_r_(_)
│ │ │ │ │ * _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ * _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ │ * _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ │ * _v_e_r_s_i_o_n_(_)
│ │ │ │ │ * _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ │ @@ -164,20 +164,20 @@
│ │ │ │ │ * _p_e_e_r___p_l_u_g_i_n
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _a_d_d___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ o _o_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │ o _o_n___c_o_n_n_e_c_t_e_d_(_)
│ │ │ │ │ o _o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ o _o_n___e_x_t_e_n_s_i_o_n___h_a_n_d_s_h_a_k_e_(_)
│ │ │ │ │ - o _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ - _o_n___h_a_v_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_)
│ │ │ │ │ - _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___u_n_c_h_o_k_e_(_)_ _o_n___c_h_o_k_e_(_)
│ │ │ │ │ + o _o_n___c_h_o_k_e_(_)_ _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_)
│ │ │ │ │ + _o_n___u_n_c_h_o_k_e_(_)_ _o_n___h_a_v_e_(_)_ _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)
│ │ │ │ │ + _o_n___r_e_q_u_e_s_t_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ o _o_n___p_i_e_c_e_(_)
│ │ │ │ │ - o _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___u_n_c_h_o_k_e_(_)
│ │ │ │ │ - _s_e_n_t___h_a_v_e_(_)
│ │ │ │ │ + o _s_e_n_t___p_i_e_c_e_(_)_ _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _s_e_n_t___i_n_t_e_r_e_s_t_e_d_(_)
│ │ │ │ │ + _s_e_n_t___u_n_c_h_o_k_e_(_)
│ │ │ │ │ o _s_e_n_t___p_a_y_l_o_a_d_(_)
│ │ │ │ │ o _c_a_n___d_i_s_c_o_n_n_e_c_t_(_)
│ │ │ │ │ o _o_n___e_x_t_e_n_d_e_d_(_)
│ │ │ │ │ o _o_n___u_n_k_n_o_w_n___m_e_s_s_a_g_e_(_)
│ │ │ │ │ o _o_n___p_i_e_c_e___f_a_i_l_e_d_(_)_ _o_n___p_i_e_c_e___p_a_s_s_(_)
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ o _w_r_i_t_e___r_e_q_u_e_s_t_(_)
│ │ │ │ │ @@ -200,25 +200,25 @@
│ │ │ │ │ o _e_n_d___f_i_l_e_(_)
│ │ │ │ │ o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)_ _s_e_t___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ o _e_n_d___p_i_e_c_e_(_)
│ │ │ │ │ o _l_a_s_t___p_i_e_c_e_(_)
│ │ │ │ │ o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ - o _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ + o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _s_e_t___p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___i_n___p_i_e_c_e_2_(_)
│ │ │ │ │ o _b_l_o_c_k_s___p_e_r___p_i_e_c_e_(_)
│ │ │ │ │ - o _s_e_t___n_a_m_e_(_)_ _n_a_m_e_(_)
│ │ │ │ │ + o _n_a_m_e_(_)_ _s_e_t___n_a_m_e_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_a_n_o_n_i_c_a_l_i_z_e_(_)
│ │ │ │ │ - o _r_o_o_t_(_)_ _r_o_o_t___p_t_r_(_)_ _f_i_l_e___n_a_m_e_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ - _f_i_l_e___o_f_f_s_e_t_(_)_ _f_i_l_e___s_i_z_e_(_)_ _h_a_s_h_(_)_ _m_t_i_m_e_(_)
│ │ │ │ │ - o _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ │ + o _f_i_l_e___o_f_f_s_e_t_(_)_ _s_y_m_l_i_n_k_(_)_ _r_o_o_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _h_a_s_h_(_)_ _r_o_o_t___p_t_r_(_)
│ │ │ │ │ + _f_i_l_e___p_a_t_h_(_)_ _m_t_i_m_e_(_)_ _f_i_l_e___s_i_z_e_(_)_ _f_i_l_e___n_a_m_e_(_)
│ │ │ │ │ + o _f_i_l_e___n_u_m___p_i_e_c_e_s_(_)_ _f_i_l_e___n_u_m___b_l_o_c_k_s_(_)_ _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ │ o _f_i_l_e___f_i_r_s_t___p_i_e_c_e___n_o_d_e_(_)_ _f_i_l_e___f_i_r_s_t___b_l_o_c_k___n_o_d_e_(_)
│ │ │ │ │ o _f_i_l_e___p_a_t_h___h_a_s_h_(_)
│ │ │ │ │ o _a_l_l___p_a_t_h___h_a_s_h_e_s_(_)
│ │ │ │ │ o _f_i_l_e___f_l_a_g_s_(_)
│ │ │ │ │ o _f_i_l_e___a_b_s_o_l_u_t_e___p_a_t_h_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___a_t___p_i_e_c_e_(_)_ _f_i_l_e___i_n_d_e_x___a_t___o_f_f_s_e_t_(_)
│ │ │ │ │ o _f_i_l_e___i_n_d_e_x___f_o_r___r_o_o_t_(_)
│ │ │ │ │ @@ -231,71 +231,71 @@
│ │ │ │ │ * _p_o_s_i_x___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _d_e_f_a_u_l_t___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _e_n_u_m_ _s_t_o_r_a_g_e___m_o_d_e___t
│ │ │ │ │ * _e_n_u_m_ _s_t_a_t_u_s___t
│ │ │ │ │ * _e_n_u_m_ _m_o_v_e___f_l_a_g_s___t
│ │ │ │ │ * _c_l_i_e_n_t___d_a_t_a___t
│ │ │ │ │ o _c_l_i_e_n_t___d_a_t_a___t_(_)
│ │ │ │ │ - o _c_o_n_s_t_*_(_)_ _v_o_i_d_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _v_o_i_d_*_(_)_ _c_o_n_s_t_*_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ * _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___i_n_f_o
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r
│ │ │ │ │ o _r_e_m_o_v_e_(_)_ _a_d_d_(_)
│ │ │ │ │ o _d_i_s_a_l_l_o_w_(_)_ _a_l_l_o_w_(_)
│ │ │ │ │ o _a_p_p_l_y_(_)
│ │ │ │ │ o _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ │ * _b_l_o_c_k___i_n_f_o
│ │ │ │ │ - o _p_e_e_r_(_)_ _s_e_t___p_e_e_r_(_)
│ │ │ │ │ + o _s_e_t___p_e_e_r_(_)_ _p_e_e_r_(_)
│ │ │ │ │ o _e_n_u_m_ _b_l_o_c_k___s_t_a_t_e___t
│ │ │ │ │ * _p_a_r_t_i_a_l___p_i_e_c_e___i_n_f_o
│ │ │ │ │ * _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ │ o _t_o_r_r_e_n_t___h_a_n_d_l_e_(_)
│ │ │ │ │ o _a_d_d___p_i_e_c_e_(_)
│ │ │ │ │ o _r_e_a_d___p_i_e_c_e_(_)
│ │ │ │ │ o _h_a_v_e___p_i_e_c_e_(_)
│ │ │ │ │ o _p_o_s_t___p_e_e_r___i_n_f_o_(_)_ _g_e_t___p_e_e_r___i_n_f_o_(_)
│ │ │ │ │ o _p_o_s_t___s_t_a_t_u_s_(_)_ _s_t_a_t_u_s_(_)
│ │ │ │ │ o _p_o_s_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)_ _g_e_t___d_o_w_n_l_o_a_d___q_u_e_u_e_(_)
│ │ │ │ │ - o _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)_ _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ │ + o _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _r_e_s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)_ _c_l_e_a_r___p_i_e_c_e___d_e_a_d_l_i_n_e_s_(_)
│ │ │ │ │ o _f_i_l_e___p_r_o_g_r_e_s_s_(_)_ _p_o_s_t___f_i_l_e___p_r_o_g_r_e_s_s_(_)
│ │ │ │ │ o _f_i_l_e___s_t_a_t_u_s_(_)
│ │ │ │ │ o _c_l_e_a_r___e_r_r_o_r_(_)
│ │ │ │ │ - o _t_r_a_c_k_e_r_s_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ + o _t_r_a_c_k_e_r_s_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)_ _r_e_p_l_a_c_e___t_r_a_c_k_e_r_s_(_)
│ │ │ │ │ o _u_r_l___s_e_e_d_s_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ - o _h_t_t_p___s_e_e_d_s_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ + o _h_t_t_p___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ o _a_d_d___e_x_t_e_n_s_i_o_n_(_)
│ │ │ │ │ o _s_e_t___m_e_t_a_d_a_t_a_(_)
│ │ │ │ │ o _i_s___v_a_l_i_d_(_)
│ │ │ │ │ - o _p_a_u_s_e_(_)_ _r_e_s_u_m_e_(_)
│ │ │ │ │ - o _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)
│ │ │ │ │ + o _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ │ + o _f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)
│ │ │ │ │ o _f_l_u_s_h___c_a_c_h_e_(_)
│ │ │ │ │ o _f_o_r_c_e___r_e_c_h_e_c_k_(_)
│ │ │ │ │ o _s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ o _n_e_e_d___s_a_v_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - o _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)
│ │ │ │ │ - _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │ + o _q_u_e_u_e___p_o_s_i_t_i_o_n_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___t_o_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___b_o_t_t_o_m_(_)
│ │ │ │ │ + _q_u_e_u_e___p_o_s_i_t_i_o_n___u_p_(_)_ _q_u_e_u_e___p_o_s_i_t_i_o_n___d_o_w_n_(_)
│ │ │ │ │ o _q_u_e_u_e___p_o_s_i_t_i_o_n___s_e_t_(_)
│ │ │ │ │ o _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_)
│ │ │ │ │ o _t_o_r_r_e_n_t___f_i_l_e___w_i_t_h___h_a_s_h_e_s_(_)_ _t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ o _p_i_e_c_e___l_a_y_e_r_s_(_)
│ │ │ │ │ - o _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ - o _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ - o _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _f_i_l_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ │ - o _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ + o _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)_ _p_o_s_t___p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y_(_)
│ │ │ │ │ + o _p_i_e_c_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)_ _g_e_t___p_i_e_c_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ + o _f_i_l_e___p_r_i_o_r_i_t_y_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)_ _g_e_t___f_i_l_e___p_r_i_o_r_i_t_i_e_s_(_)
│ │ │ │ │ + o _f_o_r_c_e___d_h_t___a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___r_e_a_n_n_o_u_n_c_e_(_)_ _f_o_r_c_e___l_s_d___a_n_n_o_u_n_c_e_(_)
│ │ │ │ │ o _s_c_r_a_p_e___t_r_a_c_k_e_r_(_)
│ │ │ │ │ - o _u_p_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ - _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + o _u_p_l_o_a_d___l_i_m_i_t_(_)_ _d_o_w_n_l_o_a_d___l_i_m_i_t_(_)_ _s_e_t___d_o_w_n_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ + _s_e_t___u_p_l_o_a_d___l_i_m_i_t_(_)
│ │ │ │ │ o _c_o_n_n_e_c_t___p_e_e_r_(_)
│ │ │ │ │ o _c_l_e_a_r___p_e_e_r_s_(_)
│ │ │ │ │ o _m_a_x___u_p_l_o_a_d_s_(_)_ _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)
│ │ │ │ │ - o _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ + o _s_e_t___m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)_ _m_a_x___c_o_n_n_e_c_t_i_o_n_s_(_)
│ │ │ │ │ o _m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ │ o _r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ │ - o _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)_ _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ + o _i_n_f_o___h_a_s_h_e_s_(_)_ _i_n_f_o___h_a_s_h_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_=_(_)_ _o_p_e_r_a_t_o_r_<_(_)_ _o_p_e_r_a_t_o_r_!_=_(_)
│ │ │ │ │ o _i_d_(_)
│ │ │ │ │ o _n_a_t_i_v_e___h_a_n_d_l_e_(_)
│ │ │ │ │ o _u_s_e_r_d_a_t_a_(_)
│ │ │ │ │ o _i_n___s_e_s_s_i_o_n_(_)
│ │ │ │ │ * _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ │ * _o_p_e_n___f_i_l_e___s_t_a_t_e
│ │ │ │ │ * _d_i_s_k___i_n_t_e_r_f_a_c_e
│ │ │ │ │ @@ -376,15 +376,15 @@
│ │ │ │ │ * _p_i_e_c_e___f_i_n_i_s_h_e_d___a_l_e_r_t
│ │ │ │ │ * _r_e_q_u_e_s_t___d_r_o_p_p_e_d___a_l_e_r_t
│ │ │ │ │ * _b_l_o_c_k___t_i_m_e_o_u_t___a_l_e_r_t
│ │ │ │ │ * _b_l_o_c_k___f_i_n_i_s_h_e_d___a_l_e_r_t
│ │ │ │ │ * _b_l_o_c_k___d_o_w_n_l_o_a_d_i_n_g___a_l_e_r_t
│ │ │ │ │ * _u_n_w_a_n_t_e_d___b_l_o_c_k___a_l_e_r_t
│ │ │ │ │ * _s_t_o_r_a_g_e___m_o_v_e_d___a_l_e_r_t
│ │ │ │ │ - o _s_t_o_r_a_g_e___p_a_t_h_(_)_ _o_l_d___p_a_t_h_(_)
│ │ │ │ │ + o _o_l_d___p_a_t_h_(_)_ _s_t_o_r_a_g_e___p_a_t_h_(_)
│ │ │ │ │ * _s_t_o_r_a_g_e___m_o_v_e_d___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │ o _f_i_l_e___p_a_t_h_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___d_e_l_e_t_e_d___a_l_e_r_t
│ │ │ │ │ * _t_o_r_r_e_n_t___d_e_l_e_t_e___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │ * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t
│ │ │ │ │ * _s_a_v_e___r_e_s_u_m_e___d_a_t_a___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ │ * _t_o_r_r_e_n_t___p_a_u_s_e_d___a_l_e_r_t
│ │ │ │ │ @@ -449,15 +449,15 @@
│ │ │ │ │ o _p_k_t___b_u_f_(_)
│ │ │ │ │ o _e_n_u_m_ _d_i_r_e_c_t_i_o_n___t
│ │ │ │ │ * _d_h_t___g_e_t___p_e_e_r_s___r_e_p_l_y___a_l_e_r_t
│ │ │ │ │ * _d_h_t___d_i_r_e_c_t___r_e_s_p_o_n_s_e___a_l_e_r_t
│ │ │ │ │ * _p_i_c_k_e_r___l_o_g___a_l_e_r_t
│ │ │ │ │ * _s_e_s_s_i_o_n___e_r_r_o_r___a_l_e_r_t
│ │ │ │ │ * _d_h_t___l_i_v_e___n_o_d_e_s___a_l_e_r_t
│ │ │ │ │ - o _n_o_d_e_s_(_)_ _n_u_m___n_o_d_e_s_(_)
│ │ │ │ │ + o _n_u_m___n_o_d_e_s_(_)_ _n_o_d_e_s_(_)
│ │ │ │ │ * _s_e_s_s_i_o_n___s_t_a_t_s___h_e_a_d_e_r___a_l_e_r_t
│ │ │ │ │ * _d_h_t___s_a_m_p_l_e___i_n_f_o_h_a_s_h_e_s___a_l_e_r_t
│ │ │ │ │ o _s_a_m_p_l_e_s_(_)_ _n_u_m___s_a_m_p_l_e_s_(_)
│ │ │ │ │ o _n_u_m___n_o_d_e_s_(_)
│ │ │ │ │ o _n_o_d_e_s_(_)
│ │ │ │ │ * _b_l_o_c_k___u_p_l_o_a_d_e_d___a_l_e_r_t
│ │ │ │ │ * _a_l_e_r_t_s___d_r_o_p_p_e_d___a_l_e_r_t
│ │ │ │ │ @@ -493,15 +493,15 @@
│ │ │ │ │ o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ │ * _e_n_t_r_y
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_t_r_y_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ - o _s_t_r_i_n_g_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _l_i_s_t_(_)_ _d_i_c_t_(_)_ _i_n_t_e_g_e_r_(_)
│ │ │ │ │ + o _d_i_c_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)_ _l_i_s_t_(_)_ _i_n_t_e_g_e_r_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ o _f_i_n_d___k_e_y_(_)
│ │ │ │ │ o _t_o___s_t_r_i_n_g_(_)
│ │ │ │ │ o _e_n_u_m_ _d_a_t_a___t_y_p_e
│ │ │ │ │ * _o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ │ * _b_e_n_c_o_d_e_(_)
│ │ │ │ │ @@ -527,47 +527,47 @@
│ │ │ │ │ o _p_i_e_c_e___s_i_z_e_(_)_ _p_i_e_c_e___l_e_n_g_t_h_(_)
│ │ │ │ │ o _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)_ _a_d_d___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)
│ │ │ │ │ * _a_d_d___f_i_l_e_s_(_)
│ │ │ │ │ * _s_e_t___p_i_e_c_e___h_a_s_h_e_s_(_)
│ │ │ │ │ * _b_i_t_f_i_e_l_d
│ │ │ │ │ o _b_i_t_f_i_e_l_d_(_)
│ │ │ │ │ o _a_s_s_i_g_n_(_)
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_[_]_(_)_ _g_e_t___b_i_t_(_)
│ │ │ │ │ + o _g_e_t___b_i_t_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ │ o _c_l_e_a_r___b_i_t_(_)_ _s_e_t___b_i_t_(_)
│ │ │ │ │ o _a_l_l___s_e_t_(_)
│ │ │ │ │ o _n_o_n_e___s_e_t_(_)
│ │ │ │ │ o _s_i_z_e_(_)
│ │ │ │ │ o _n_u_m___w_o_r_d_s_(_)
│ │ │ │ │ o _n_u_m___b_y_t_e_s_(_)
│ │ │ │ │ o _e_m_p_t_y_(_)
│ │ │ │ │ o _d_a_t_a_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _c_o_u_n_t_(_)
│ │ │ │ │ o _f_i_n_d___f_i_r_s_t___s_e_t_(_)
│ │ │ │ │ o _f_i_n_d___l_a_s_t___c_l_e_a_r_(_)
│ │ │ │ │ * _h_a_s_h_e_r
│ │ │ │ │ - o _h_a_s_h_e_r_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_(_)
│ │ │ │ │ o _u_p_d_a_t_e_(_)
│ │ │ │ │ o _f_i_n_a_l_(_)
│ │ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ │ * _h_a_s_h_e_r_2_5_6
│ │ │ │ │ - o _o_p_e_r_a_t_o_r_=_(_)_ _h_a_s_h_e_r_2_5_6_(_)
│ │ │ │ │ + o _h_a_s_h_e_r_2_5_6_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ o _u_p_d_a_t_e_(_)
│ │ │ │ │ o _f_i_n_a_l_(_)
│ │ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ │ * _t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ │ o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ │ o _e_n_u_m_ _s_t_a_t_e___t
│ │ │ │ │ * _a_n_n_o_u_n_c_e___i_n_f_o_h_a_s_h
│ │ │ │ │ * _a_n_n_o_u_n_c_e___e_n_d_p_o_i_n_t
│ │ │ │ │ * _a_n_n_o_u_n_c_e___e_n_t_r_y
│ │ │ │ │ - o _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)_ _a_n_n_o_u_n_c_e___e_n_t_r_y_(_)
│ │ │ │ │ o _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e
│ │ │ │ │ * _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ │ - o _s_e_t___i_n_t_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___s_t_r_(_)
│ │ │ │ │ + o _s_e_t___s_t_r_(_)_ _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_)
│ │ │ │ │ o _h_a_s___v_a_l_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ o _g_e_t___s_t_r_(_)_ _g_e_t___i_n_t_(_)_ _g_e_t___b_o_o_l_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___b_a_s_e_s
│ │ │ │ │ o _e_n_u_m_ _m_m_a_p___w_r_i_t_e___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _s_u_g_g_e_s_t___m_o_d_e___t
│ │ │ │ │ @@ -576,29 +576,29 @@
│ │ │ │ │ o _e_n_u_m_ _i_o___b_u_f_f_e_r___m_o_d_e___t
│ │ │ │ │ o _e_n_u_m_ _b_a_n_d_w_i_d_t_h___m_i_x_e_d___a_l_g_o___t
│ │ │ │ │ o _e_n_u_m_ _e_n_c___p_o_l_i_c_y
│ │ │ │ │ o _e_n_u_m_ _e_n_c___l_e_v_e_l
│ │ │ │ │ o _e_n_u_m_ _p_r_o_x_y___t_y_p_e___t
│ │ │ │ │ * _g_e_n_e_r_a_t_e___f_i_n_g_e_r_p_r_i_n_t_(_)
│ │ │ │ │ * _m_i_n___m_e_m_o_r_y___u_s_a_g_e_(_)_ _h_i_g_h___p_e_r_f_o_r_m_a_n_c_e___s_e_e_d_(_)
│ │ │ │ │ - * _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)_ _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ │ + * _n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)_ _s_e_t_t_i_n_g___b_y___n_a_m_e_(_)
│ │ │ │ │ * _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ │ * _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │ o _b_d_e_c_o_d_e___n_o_d_e_(_)
│ │ │ │ │ - o _b_d_e_c_o_d_e___n_o_d_e_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ │ + o _o_p_e_r_a_t_o_r_=_(_)_ _b_d_e_c_o_d_e___n_o_d_e_(_)
│ │ │ │ │ o _t_y_p_e_(_)
│ │ │ │ │ o _b_o_o_l_(_)
│ │ │ │ │ o _n_o_n___o_w_n_i_n_g_(_)
│ │ │ │ │ o _d_a_t_a___s_e_c_t_i_o_n_(_)_ _d_a_t_a___o_f_f_s_e_t_(_)
│ │ │ │ │ - o _l_i_s_t___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)
│ │ │ │ │ - o _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___a_t___n_o_d_e
│ │ │ │ │ - _(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)
│ │ │ │ │ - _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)
│ │ │ │ │ + o _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)
│ │ │ │ │ + o _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d_(_)_ _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___a_t
│ │ │ │ │ + _(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_)
│ │ │ │ │ + _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___s_i_z_e_(_)_ _d_i_c_t___a_t___n_o_d_e_(_)
│ │ │ │ │ o _i_n_t___v_a_l_u_e_(_)
│ │ │ │ │ - o _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)
│ │ │ │ │ + o _s_t_r_i_n_g___p_t_r_(_)_ _s_t_r_i_n_g___v_a_l_u_e_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)_ _s_t_r_i_n_g___o_f_f_s_e_t_(_)
│ │ │ │ │ o _c_l_e_a_r_(_)
│ │ │ │ │ o _s_w_a_p_(_)
│ │ │ │ │ o _r_e_s_e_r_v_e_(_)
│ │ │ │ │ o _s_w_i_t_c_h___u_n_d_e_r_l_y_i_n_g___b_u_f_f_e_r_(_)
│ │ │ │ │ o _h_a_s___s_o_f_t___e_r_r_o_r_(_)
│ │ │ │ │ o _e_n_u_m_ _t_y_p_e___t
│ │ │ │ │ * _p_r_i_n_t___e_n_t_r_y_(_)
│ │ │ │ │ @@ -618,16 +618,16 @@
│ │ │ │ │ o _g_e_t___i_n_f_o_h_a_s_h_e_s___s_a_m_p_l_e_(_)
│ │ │ │ │ o _t_i_c_k_(_)
│ │ │ │ │ o _c_o_u_n_t_e_r_s_(_)
│ │ │ │ │ * _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ │ * _d_h_t___d_e_f_a_u_l_t___s_t_o_r_a_g_e___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ │ * _a_n_n_o_u_n_c_e___f_l_a_g_s___t
│ │ │ │ │ * _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)
│ │ │ │ │ - * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)
│ │ │ │ │ + * _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a_(_)_ _w_r_i_t_e___r_e_s_u_m_e___d_a_t_a___b_u_f_(_)
│ │ │ │ │ + * _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e___b_u_f_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ * _w_r_i_t_e___t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ │ * _e_d_2_5_5_1_9___c_r_e_a_t_e___s_e_e_d_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___c_r_e_a_t_e___k_e_y_p_a_i_r_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___s_i_g_n_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___v_e_r_i_f_y_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___a_d_d___s_c_a_l_a_r_(_)
│ │ │ │ │ * _e_d_2_5_5_1_9___k_e_y___e_x_c_h_a_n_g_e_(_)
│ │ │ │ │ @@ -635,29 +635,29 @@
│ │ │ │ │ ************ ssttoorraaggee__eerrrroorr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ │ used by storage to return errors also includes which underlying file the error
│ │ │ │ │ happened on
│ │ │ │ │ struct storage_error
│ │ │ │ │ {
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ - void ffiillee (file_index_t f);
│ │ │ │ │ file_index_t ffiillee () const;
│ │ │ │ │ + void ffiillee (file_index_t f);
│ │ │ │ │
│ │ │ │ │ error_code ec;
│ │ │ │ │ operation_t operation;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bbooooll(()) **********
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ explicitly converts to true if this object represents an error, and false if it
│ │ │ │ │ does not.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee(()) **********
│ │ │ │ │ -void ffiillee (file_index_t f);
│ │ │ │ │ file_index_t ffiillee () const;
│ │ │ │ │ +void ffiillee (file_index_t f);
│ │ │ │ │ set and query the index (in the torrent) of the file this error occurred on.
│ │ │ │ │ This may also have special values defined in _t_o_r_r_e_n_t___s_t_a_t_u_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ec
│ │ │ │ │ the error that occurred
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ operation
│ │ │ │ │ @@ -1236,16 +1236,16 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn__ppaarraammss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ The _s_e_s_s_i_o_n___p_a_r_a_m_s is a parameters pack for configuring the _s_e_s_s_i_o_n before it's
│ │ │ │ │ started.
│ │ │ │ │ struct session_params
│ │ │ │ │ {
│ │ │ │ │ - sseessssiioonn__ppaarraammss ();
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ + sseessssiioonn__ppaarraammss ();
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ , std::vector> exts);
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp
│ │ │ │ │ , std::vector> exts);
│ │ │ │ │
│ │ │ │ │ settings_pack settings;
│ │ │ │ │ @@ -1254,16 +1254,16 @@
│ │ │ │ │ dht::dht_storage_constructor_type dht_storage_constructor;
│ │ │ │ │ disk_io_constructor_type disk_io_constructor;
│ │ │ │ │ std::map ext_state;
│ │ │ │ │ libtorrent::ip_filter ip_filter;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ -sseessssiioonn__ppaarraammss ();
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp);
│ │ │ │ │ +sseessssiioonn__ppaarraammss ();
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ │ This constructor can be used to start with the default plugins (ut_metadata,
│ │ │ │ │ ut_pex and smart_ban). Pass a _s_e_t_t_i_n_g_s___p_a_c_k to set the initial settings when
│ │ │ │ │ the _s_e_s_s_i_o_n starts.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn__ppaarraammss(()) **********
│ │ │ │ │ sseessssiioonn__ppaarraammss (settings_pack&& sp
│ │ │ │ │ @@ -1304,29 +1304,29 @@
│ │ │ │ │ _s_e_s_s_i_o_n destruction is explicitly initiated, this holder is used to synchronize
│ │ │ │ │ the completion of the shutdown. The lifetime of this object may outlive
│ │ │ │ │ _s_e_s_s_i_o_n, causing the _s_e_s_s_i_o_n destructor to not block. The _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ │ destructor will block however, until the underlying _s_e_s_s_i_o_n is done shutting
│ │ │ │ │ down.
│ │ │ │ │ struct session_proxy
│ │ │ │ │ {
│ │ │ │ │ - sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ - session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ + sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ + session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ -sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ +********** sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) ~~sseessssiioonn__pprrooxxyy(()) **********
│ │ │ │ │ ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ │ session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ │ +sseessssiioonn__pprrooxxyy ();
│ │ │ │ │ +session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ │ default constructor, does not refer to any _s_e_s_s_i_o_n implementation object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseessssiioonn ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p"
│ │ │ │ │ The _s_e_s_s_i_o_n holds all state that spans multiple torrents. Among other things it
│ │ │ │ │ runs the network loop and manages all torrents. Once it's created, the _s_e_s_s_i_o_n
│ │ │ │ │ object will spawn the main thread that will do all the work. The main thread
│ │ │ │ │ @@ -1335,44 +1335,44 @@
│ │ │ │ │ apply_settings() member function. To change one or more configuration options,
│ │ │ │ │ create a _s_e_t_t_i_n_g_s___p_a_c_k. object and fill it with the settings to be set and pass
│ │ │ │ │ it in to session::apply_settings().
│ │ │ │ │ see _a_p_p_l_y___s_e_t_t_i_n_g_s_(_).
│ │ │ │ │ struct session : session_handle
│ │ │ │ │ {
│ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ - explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ - explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ sseessssiioonn ();
│ │ │ │ │ + explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ + explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ + sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ ~~sseessssiioonn ();
│ │ │ │ │ session_proxy aabboorrtt ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn(()) **********
│ │ │ │ │ sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ │ -explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ -explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ sseessssiioonn ();
│ │ │ │ │ +explicit sseessssiioonn (session_params&& params);
│ │ │ │ │ sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ │ +explicit sseessssiioonn (session_params const& params);
│ │ │ │ │ Constructs the _s_e_s_s_i_o_n objects which acts as the container of torrents. In
│ │ │ │ │ order to avoid a race condition between starting the _s_e_s_s_i_o_n and configuring
│ │ │ │ │ it, you can pass in a _s_e_s_s_i_o_n___p_a_r_a_m_s object. Its settings will take effect
│ │ │ │ │ before the _s_e_s_s_i_o_n starts up.
│ │ │ │ │ The overloads taking flags can be used to start a _s_e_s_s_i_o_n in paused mode (by
│ │ │ │ │ passing in session::paused). Note that add_default_plugins do not have an
│ │ │ │ │ affect on constructors that take a _s_e_s_s_i_o_n___p_a_r_a_m_s object. It already contains
│ │ │ │ │ the plugins to use.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseessssiioonn(()) **********
│ │ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ │ +sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ │ sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ │ Overload of the constructor that takes an external io_context to run the
│ │ │ │ │ _s_e_s_s_i_o_n 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.
│ │ │ │ │ @@ -1414,82 +1414,82 @@
│ │ │ │ │ operation on it will throw a system_error exception, with error code
│ │ │ │ │ invalid_session_handle.
│ │ │ │ │ struct session_handle
│ │ │ │ │ {
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ session_params sseessssiioonn__ssttaattee (save_state_flags_t flags =
│ │ │ │ │ save_state_flags_t::all()) const;
│ │ │ │ │ + void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ + , status_flags_t flags = {}) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss (
│ │ │ │ │ std::function const& pred
│ │ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ │ - void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ - , status_flags_t flags = {}) const;
│ │ │ │ │ void ppoosstt__ttoorrrreenntt__uuppddaatteess (status_flags_t flags = status_flags_t::all());
│ │ │ │ │ void ppoosstt__sseessssiioonn__ssttaattss ();
│ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ - void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ - torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ + void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ + torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code&
│ │ │ │ │ ec);
│ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ + void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ - bool iiss__ppaauusseedd () const;
│ │ │ │ │ + torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ void rreessuummee ();
│ │ │ │ │ + bool iiss__ppaauusseedd () const;
│ │ │ │ │ void ppaauussee ();
│ │ │ │ │ bool iiss__ddhhtt__rruunnnniinngg () const;
│ │ │ │ │ void sseett__ddhhtt__ssttoorraaggee (dht::dht_storage_constructor_type sc);
│ │ │ │ │ void aadddd__ddhhtt__nnooddee (std::pair const& node);
│ │ │ │ │ void ddhhtt__ggeett__iitteemm (sha1_hash const& target);
│ │ │ │ │ void ddhhtt__ggeett__iitteemm (std::array key
│ │ │ │ │ , std::string salt = std::string());
│ │ │ │ │ sha1_hash ddhhtt__ppuutt__iitteemm (entry data);
│ │ │ │ │ void ddhhtt__ppuutt__iitteemm (std::array key
│ │ │ │ │ , std::function&
│ │ │ │ │ , std::int64_t&, std::string const&)> cb
│ │ │ │ │ , std::string salt = std::string());
│ │ │ │ │ + void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │ announce_flags_t flags = {});
│ │ │ │ │ - void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__lliivvee__nnooddeess (sha1_hash const& nid);
│ │ │ │ │ void ddhhtt__ssaammppllee__iinnffoohhaasshheess (udp::endpoint const& ep, sha1_hash const&
│ │ │ │ │ target);
│ │ │ │ │ void ddhhtt__ddiirreecctt__rreeqquueesstt (udp::endpoint const& ep, entry const& e,
│ │ │ │ │ client_data_t userdata = {});
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::function(
│ │ │ │ │ torrent_handle const&, client_data_t)> ext);
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::shared_ptr ext);
│ │ │ │ │ ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ │ void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ - bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ - unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ - void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ + unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ + bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ + void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ void sseett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr (peer_class_type_filter const& f);
│ │ │ │ │ peer_class_type_filter ggeett__ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr () const;
│ │ │ │ │ peer_class_t ccrreeaattee__ppeeeerr__ccllaassss (char const* name);
│ │ │ │ │ void ddeelleettee__ppeeeerr__ccllaassss (peer_class_t cid);
│ │ │ │ │ - void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │ + void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ │ - void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ - alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ + void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ - void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ + alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ │ external_port, int local_port);
│ │ │ │ │ + void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options =
│ │ │ │ │ reopen_map_ports);
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │
│ │ │ │ │ static constexpr save_state_flags_t ssaavvee__sseettttiinnggss = 0_bit;
│ │ │ │ │ static constexpr save_state_flags_t ssaavvee__ddhhtt__ssttaattee = 2_bit;
│ │ │ │ │ static constexpr save_state_flags_t ssaavvee__eexxtteennssiioonn__ssttaattee = 11_bit;
│ │ │ │ │ @@ -1515,20 +1515,20 @@
│ │ │ │ │ all()) const;
│ │ │ │ │ returns the current _s_e_s_s_i_o_n state. This can be passed to _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_)
│ │ │ │ │ to save the state to disk and restored using _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) when
│ │ │ │ │ constructing a new _s_e_s_s_i_o_n. 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 _s_e_s_s_i_o_n state
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__ttoorrrreenntt__ssttaattuuss(()) rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) **********
│ │ │ │ │ +********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__ttoorrrreenntt__ssttaattuuss(()) **********
│ │ │ │ │ +void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* ret
│ │ │ │ │ + , status_flags_t flags = {}) const;
│ │ │ │ │ std::vector ggeett__ttoorrrreenntt__ssttaattuuss (
│ │ │ │ │ std::function const& pred
│ │ │ │ │ , status_flags_t flags = {}) const;
│ │ │ │ │ -void rreeffrreesshh__ttoorrrreenntt__ssttaattuuss (std::vector* 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.
│ │ │ │ │ get_torrent_status returns a vector of the _t_o_r_r_e_n_t___s_t_a_t_u_s for every torrent
│ │ │ │ │ which satisfies pred, which is a predicate function which determines if a
│ │ │ │ │ torrent should be included in the returned set or not. Returning true means it
│ │ │ │ │ @@ -1573,37 +1573,37 @@
│ │ │ │ │ For more information, see the _s_e_s_s_i_o_n_ _s_t_a_t_i_s_t_i_c_s section.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppoosstt__ddhhtt__ssttaattss(()) **********
│ │ │ │ │ void ppoosstt__ddhhtt__ssttaattss ();
│ │ │ │ │ This will cause a _d_h_t___s_t_a_t_s___a_l_e_r_t to be posted.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseett__ddhhtt__ssttaattee(()) **********
│ │ │ │ │ -void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ void sseett__ddhhtt__ssttaattee (dht::dht_state const& st);
│ │ │ │ │ +void sseett__ddhhtt__ssttaattee (dht::dht_state&& st);
│ │ │ │ │ set the DHT state for the _s_e_s_s_i_o_n. This will be taken into account the next
│ │ │ │ │ time the DHT is started, as if it had been passed in via the _s_e_s_s_i_o_n___p_a_r_a_m_s on
│ │ │ │ │ startup.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiinndd__ttoorrrreenntt(()) ggeett__ttoorrrreennttss(()) **********
│ │ │ │ │ -torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ +********** ggeett__ttoorrrreennttss(()) ffiinndd__ttoorrrreenntt(()) **********
│ │ │ │ │ std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ │ +torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ │ find_torrent() looks for a torrent with the given info-hash. In case there is
│ │ │ │ │ such a torrent in the _s_e_s_s_i_o_n, a _t_o_r_r_e_n_t___h_a_n_d_l_e to that torrent is returned. In
│ │ │ │ │ case the torrent cannot be found, an invalid _t_o_r_r_e_n_t___h_a_n_d_l_e 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 _s_e_s_s_i_o_n.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** aadddd__ttoorrrreenntt(()) aassyynncc__aadddd__ttoorrrreenntt(()) **********
│ │ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ │ void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ │ +void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ │ +torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ │ You add torrents through the _a_d_d___t_o_r_r_e_n_t_(_) function where you give an object
│ │ │ │ │ with all the parameters. The _a_d_d___t_o_r_r_e_n_t_(_) overloads will block until the
│ │ │ │ │ torrent has been added (or failed to be added) and returns an error code and a
│ │ │ │ │ _t_o_r_r_e_n_t___h_a_n_d_l_e. In order to add torrents more efficiently, consider using
│ │ │ │ │ _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_) which returns immediately, without waiting for the torrent
│ │ │ │ │ to add. Notification of the torrent being added is sent as _a_d_d___t_o_r_r_e_n_t___a_l_e_r_t.
│ │ │ │ │ The overload that does not take an error_code throws an exception on error and
│ │ │ │ │ @@ -1620,17 +1620,17 @@
│ │ │ │ │ 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 _B_i_t_T_o_r_r_e_n_t_ _v_2_ _t_o_r_r_e_n_t_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppaauussee(()) rreessuummee(()) iiss__ppaauusseedd(()) **********
│ │ │ │ │ -bool iiss__ppaauusseedd () const;
│ │ │ │ │ +********** iiss__ppaauusseedd(()) rreessuummee(()) ppaauussee(()) **********
│ │ │ │ │ void rreessuummee ();
│ │ │ │ │ +bool iiss__ppaauusseedd () const;
│ │ │ │ │ void ppaauussee ();
│ │ │ │ │ Pausing the _s_e_s_s_i_o_n 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 _s_e_s_s_i_o_n pause
│ │ │ │ │ state is separate from the torrent pause state. A torrent is inactive if it is
│ │ │ │ │ paused or if the _s_e_s_s_i_o_n is paused.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -1707,18 +1707,18 @@
│ │ │ │ │ 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 uuppddaattee 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddhhtt__aannnnoouunnccee(()) ddhhtt__ggeett__ppeeeerrss(()) **********
│ │ │ │ │ +********** ddhhtt__ggeett__ppeeeerrss(()) ddhhtt__aannnnoouunnccee(()) **********
│ │ │ │ │ +void ddhhtt__ggeett__ppeeeerrss (sha1_hash const& info_hash);
│ │ │ │ │ void ddhhtt__aannnnoouunnccee (sha1_hash const& info_hash, int port = 0, dht::
│ │ │ │ │ announce_flags_t flags = {});
│ │ │ │ │ -void ddhhtt__ggeett__ppeeeerrss (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
│ │ │ │ │ _d_h_t___g_e_t___p_e_e_r_s___r_e_p_l_y___a_l_e_r_t.
│ │ │ │ │ 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 source port (which may improve
│ │ │ │ │ connectivity through a NAT).
│ │ │ │ │ @@ -1793,26 +1793,26 @@
│ │ │ │ │ void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ │ apply _p_o_r_t___f_i_l_t_e_r 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) ssssll__lliisstteenn__ppoorrtt(()) **********
│ │ │ │ │ -bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ -unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ │ +unsigned short lliisstteenn__ppoorrtt () const;
│ │ │ │ │ +bool iiss__lliisstteenniinngg () const;
│ │ │ │ │ is_listening() will tell you whether or not the _s_e_s_s_i_o_n has successfully opened
│ │ │ │ │ a listening port. If it hasn't, this function will return false, and then you
│ │ │ │ │ can set a new _s_e_t_t_i_n_g_s___p_a_c_k_:_:_l_i_s_t_e_n___i_n_t_e_r_f_a_c_e_s to try another interface and
│ │ │ │ │ port to bind to.
│ │ │ │ │ listen_port() returns the port we ended up listening on.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) **********
│ │ │ │ │ -void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ +********** ggeett__ppeeeerr__ccllaassss__ffiilltteerr(()) sseett__ppeeeerr__ccllaassss__ffiilltteerr(()) **********
│ │ │ │ │ ip_filter ggeett__ppeeeerr__ccllaassss__ffiilltteerr () const;
│ │ │ │ │ +void sseett__ppeeeerr__ccllaassss__ffiilltteerr (ip_filter const& f);
│ │ │ │ │ Sets the peer class filter for this _s_e_s_s_i_o_n. 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.
│ │ │ │ │ The ip-filter essentially maps an IP -> uint32. Each bit in that 32 bit integer
│ │ │ │ │ represents a peer class. The least significant bit represents class 0, the next
│ │ │ │ │ bit class 1 and so on.
│ │ │ │ │ For more info, see _i_p___f_i_l_t_e_r.
│ │ │ │ │ @@ -1867,17 +1867,17 @@
│ │ │ │ │ Since peer classes are reference counted, this function will not 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 _s_e_s_s_i_o_n object destructs.
│ │ │ │ │ For more information on peer classes, see _p_e_e_r_ _c_l_a_s_s_e_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ggeett__ppeeeerr__ccllaassss(()) sseett__ppeeeerr__ccllaassss(()) **********
│ │ │ │ │ -void sseett__ppeeeerr__ccllaassss (peer_class_t cid, peer_class_info const& pci);
│ │ │ │ │ +********** sseett__ppeeeerr__ccllaassss(()) ggeett__ppeeeerr__ccllaassss(()) **********
│ │ │ │ │ peer_class_info ggeett__ppeeeerr__ccllaassss (peer_class_t cid) const;
│ │ │ │ │ +void sseett__ppeeeerr__ccllaassss (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 return value of
│ │ │ │ │ get_peer_class() is undefined.
│ │ │ │ │ set_peer_class() sets all the information in the _p_e_e_r___c_l_a_s_s___i_n_f_o object in the
│ │ │ │ │ specified peer class. There is no option to only update a single property.
│ │ │ │ │ A peer or torrent belonging to more than one class, the highest priority among
│ │ │ │ │ @@ -1908,25 +1908,25 @@
│ │ │ │ │ Note that when a queued or downloading torrent is removed, its position in the
│ │ │ │ │ download queue is vacated and every subsequent torrent in the queue has their
│ │ │ │ │ queue positions updated. This can potentially cause a large state_update to be
│ │ │ │ │ posted. When removing all torrents, it is advised to remove them from the back
│ │ │ │ │ of the queue, to minimize the shifting.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett__sseettttiinnggss(()) aappppllyy__sseettttiinnggss(()) **********
│ │ │ │ │ -void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ │ settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ │ +void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ │ Applies the settings specified by the _s_e_t_t_i_n_g_s___p_a_c_k s. This is an asynchronous
│ │ │ │ │ operation that will return immediately and actually apply the settings to the
│ │ │ │ │ main thread of libtorrent some time later.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__aalleerrtt__nnoottiiffyy(()) ppoopp__aalleerrttss(()) wwaaiitt__ffoorr__aalleerrtt(()) **********
│ │ │ │ │ -alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ +********** ppoopp__aalleerrttss(()) wwaaiitt__ffoorr__aalleerrtt(()) sseett__aalleerrtt__nnoottiiffyy(()) **********
│ │ │ │ │ void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ │ void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ │ +alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ │ 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
│ │ │ │ │ _s_e_s_s_i_o_n still owns these alerts and they will stay valid until the next time
│ │ │ │ │ pop_alerts is called. You may not delete the _a_l_e_r_t objects.
│ │ │ │ │ It is safe to call pop_alerts from multiple different threads, as long as the
│ │ │ │ │ alerts themselves are not accessed once another thread calls pop_alerts. Doing
│ │ │ │ │ this requires manual synchronization between the popping threads.
│ │ │ │ │ @@ -1966,17 +1966,17 @@
│ │ │ │ │ block. It should not perform any expensive work. It really should just notify
│ │ │ │ │ the main application thread.
│ │ │ │ │ The type of an _a_l_e_r_t is returned by the polymorphic function alert::type() but
│ │ │ │ │ can also be queries from a concrete type via T::alert_type, as a static
│ │ │ │ │ constant.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddeelleettee__ppoorrtt__mmaappppiinngg(()) aadddd__ppoorrtt__mmaappppiinngg(()) **********
│ │ │ │ │ -void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ │ external_port, int local_port);
│ │ │ │ │ +void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ │ add_port_mapping adds one or more port forwards on UPnP and/or NAT-PMP,
│ │ │ │ │ whichever is enabled. A mapping is created for each listen socket in the
│ │ │ │ │ _s_e_s_s_i_o_n. The return values are all handles referring to the port mappings that
│ │ │ │ │ were just created. Pass them to _d_e_l_e_t_e___p_o_r_t___m_a_p_p_i_n_g_(_) to remove them.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreeooppeenn__nneettwwoorrkk__ssoocckkeettss(()) **********
│ │ │ │ │ void rreeooppeenn__nneettwwoorrkk__ssoocckkeettss (reopen_network_flags_t options =
│ │ │ │ │ @@ -2022,25 +2022,25 @@
│ │ │ │ │ protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ reopen_map_ports
│ │ │ │ │ This option indicates if the ports are mapped using natpmp and upnp. If
│ │ │ │ │ mapping was already made, they are deleted and added again. This only
│ │ │ │ │ works if natpmp and/or upnp are configured to be enable.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss(())
│ │ │ │ │ +************ wwrriittee__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(()) rreeaadd__sseessssiioonn__ppaarraammss(())
│ │ │ │ │ ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ session_params rreeaadd__sseessssiioonn__ppaarraammss (bdecode_node const& e
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (session_params const& sp
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ -session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ entry wwrriittee__sseessssiioonn__ppaarraammss (session_params const& sp
│ │ │ │ │ , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ +session_params rreeaadd__sseessssiioonn__ppaarraammss (span buf
│ │ │ │ │ + , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ │ │ These functions serialize and de-serialize a session_params object to and from
│ │ │ │ │ bencoded form. The _s_e_s_s_i_o_n___p_a_r_a_m_s object is used to initialize a new _s_e_s_s_i_o_n
│ │ │ │ │ using the state from a previous one (or by programmatically configure the
│ │ │ │ │ _s_e_s_s_i_o_n up-front). The flags parameter can be used to only save and load
│ │ │ │ │ certain aspects of the session's state. The _buf suffix indicates the function
│ │ │ │ │ operates on buffer rather than the bencoded structure. The torrents in a
│ │ │ │ │ _s_e_s_s_i_o_n are not part of the _s_e_s_s_i_o_n___p_a_r_a_m_s state, they have to be restored
│ │ │ │ │ @@ -2122,74 +2122,74 @@
│ │ │ │ │ the max number of bdecode tokens
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ttoorrrreenntt__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___i_n_f_o_._h_p_p"
│ │ │ │ │ the _t_o_r_r_e_n_t___i_n_f_o class holds the information found in a .torrent file.
│ │ │ │ │ class torrent_info
│ │ │ │ │ {
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ from_span_t);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ + ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ - explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ + explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ ~~ttoorrrreenntt__iinnffoo ();
│ │ │ │ │ file_storage const& ffiilleess () const;
│ │ │ │ │ file_storage const& oorriigg__ffiilleess () const;
│ │ │ │ │ void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ │ - std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ + void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ + void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ - void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ - std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ + std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ - void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ + std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ + std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& extern_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ - std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ + void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ + int nnuumm__ppiieecceess () const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ │ - bool vv11 () const;
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │ + bool vv11 () const;
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int
│ │ │ │ │ size) const;
│ │ │ │ │ string_view ssssll__cceerrtt () const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ bool iiss__ii22pp () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ - sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ + sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ bool iiss__llooaaddeedd () const;
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ │ │ std::time_t ccrreeaattiioonn__ddaattee () const;
│ │ │ │ │ const std::string& ccrreeaattoorr () const;
│ │ │ │ │ const std::string& ccoommmmeenntt () const;
│ │ │ │ │ std::vector> const& nnooddeess () const;
│ │ │ │ │ void aadddd__nnooddee (std::pair const& node);
│ │ │ │ │ @@ -2198,29 +2198,29 @@
│ │ │ │ │ bdecode_node iinnffoo (char const* key) const;
│ │ │ │ │ span iinnffoo__sseeccttiioonn () const;
│ │ │ │ │ span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ │ void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ +cfg);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ │ from_span_t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ │ -explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ │ ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ │ -cfg);
│ │ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ │ +explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ │ 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 _b_d_e_c_o_d_e___n_o_d_e will create a _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ │ from the information found in the given torrent_file. The _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ │ represents a tree node in an bencoded file. To load an ordinary .torrent file
│ │ │ │ │ @@ -2286,49 +2286,49 @@
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** cclleeaarr__ttrraacckkeerrss(()) ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ │ +********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ │ +void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ │ +std::vector const& ttrraacckkeerrss () 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 _a_n_n_o_u_n_c_e___e_n_t_r_y. Each announce _e_n_t_r_y contains a
│ │ │ │ │ string, which is the tracker url, and a tier index. The tier index is the high-
│ │ │ │ │ level priority. No matter which trackers that works or not, the ones with lower
│ │ │ │ │ tier will always be tried before the one with higher tier number. For more
│ │ │ │ │ information, see _a_n_n_o_u_n_c_e___e_n_t_r_y.
│ │ │ │ │ trackers() returns all entries from announce-list.
│ │ │ │ │ clear_trackers() removes all trackers from announce-list.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ │ -std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ +********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ │ +std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ │ These two functions are related to _B_E_P_ _3_8 (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) sseett__wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ +********** sseett__wweebb__sseeeeddss(()) wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ +std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& ext_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& ext_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url
│ │ │ │ │ , std::string const& extern_auth = std::string()
│ │ │ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::
│ │ │ │ │ headers_t());
│ │ │ │ │ -std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ │ +void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ │ web_seeds() returns all url seeds and http seeds in the torrent. Each _e_n_t_r_y is
│ │ │ │ │ a web_seed_entry and may refer to either a url seed or http seed.
│ │ │ │ │ add_url_seed() and add_http_seed() adds one url to the list of url/http seeds.
│ │ │ │ │ set_web_seeds() replaces all web seeds with the ones specified in the seeds
│ │ │ │ │ vector.
│ │ │ │ │ The extern_auth argument can be used for other authorization schemes than basic
│ │ │ │ │ HTTP authorization. If set, it will override any username and password found in
│ │ │ │ │ @@ -2342,46 +2342,46 @@
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +int nnuumm__ppiieecceess () 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** eenndd__ppiieeccee(()) llaasstt__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +********** llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () 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
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** iinnffoo__hhaasshh(()) iinnffoo__hhaasshheess(()) **********
│ │ │ │ │ +********** iinnffoo__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ │ sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () 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
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** vv11(()) vv22(()) **********
│ │ │ │ │ -bool vv11 () const;
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │ +bool vv11 () 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ffiilleess(()) **********
│ │ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ │ If you need index-access to files you can use the num_files() along with the
│ │ │ │ │ @@ -2429,17 +2429,17 @@
│ │ │ │ │ than the i2p network.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ returns the piece size of file with index. This will be the same as
│ │ │ │ │ _p_i_e_c_e___l_e_n_g_t_h_(_), except for the last piece, which may be shorter.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaasshh__ffoorr__ppiieeccee(()) hhaasshh__ffoorr__ppiieeccee__ppttrr(()) **********
│ │ │ │ │ -sha1_hash hhaasshh__ffoorr__ppiieeccee (piece_index_t index) const;
│ │ │ │ │ +********** hhaasshh__ffoorr__ppiieeccee__ppttrr(()) hhaasshh__ffoorr__ppiieeccee(()) **********
│ │ │ │ │ char const* hhaasshh__ffoorr__ppiieeccee__ppttrr (piece_index_t const index) const;
│ │ │ │ │ +sha1_hash hhaasshh__ffoorr__ppiieeccee (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnaammee(()) **********
│ │ │ │ │ const std::string& nnaammee () const;
│ │ │ │ │ @@ -2889,20 +2889,20 @@
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p"
│ │ │ │ │ class holding the info-hash of a torrent. It can hold a v1 info-hash (SHA-1) or
│ │ │ │ │ a v2 info-hash (SHA-256) or both.
│ │ │ │ │ Note
│ │ │ │ │ If has_v2() is false then the v1 hash might actually be a truncated v2 hash
│ │ │ │ │ struct info_hash_t
│ │ │ │ │ {
│ │ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ - bool hhaass__vv11 () const;
│ │ │ │ │ bool hhaass (protocol_version v) const;
│ │ │ │ │ + bool hhaass__vv11 () const;
│ │ │ │ │ bool hhaass__vv22 () const;
│ │ │ │ │ sha1_hash ggeett (protocol_version v) const;
│ │ │ │ │ sha1_hash ggeett__bbeesstt () const;
│ │ │ │ │ friend bool ooppeerraattoorr!!== (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ │ │ friend bool ooppeerraattoorr==== (info_hash_t const& lhs, info_hash_t const& rhs)
│ │ │ │ │ noexcept;
│ │ │ │ │ template void ffoorr__eeaacchh (F f) const;
│ │ │ │ │ @@ -2910,26 +2910,26 @@
│ │ │ │ │ friend std::ostream& ooppeerraattoorr<<<< (std::ostream& os, info_hash_t const& ih);
│ │ │ │ │
│ │ │ │ │ sha1_hash v1;
│ │ │ │ │ sha256_hash v2;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** iinnffoo__hhaasshh__tt(()) **********
│ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ │ iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ │ -explicit iinnffoo__hhaasshh__tt (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 iimmpplliicciitt conversion from a v1 hash, but the
│ │ │ │ │ implicitness is deprecated.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** hhaass(()) hhaass__vv11(()) hhaass__vv22(()) **********
│ │ │ │ │ -bool hhaass__vv11 () const;
│ │ │ │ │ +********** hhaass(()) hhaass__vv22(()) hhaass__vv11(()) **********
│ │ │ │ │ bool hhaass (protocol_version v) const;
│ │ │ │ │ +bool hhaass__vv11 () const;
│ │ │ │ │ bool hhaass__vv22 () const;
│ │ │ │ │ returns true if the corresponding info hash is present in this object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeett(()) **********
│ │ │ │ │ sha1_hash ggeett (protocol_version v) const;
│ │ │ │ │ returns the has for the specified protocol version
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -2982,41 +2982,41 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ start
│ │ │ │ │ The byte offset within that piece where the range starts.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ length
│ │ │ │ │ The size of the range, in bytes.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ llooaadd__ttoorrrreenntt__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__ffiillee(()) ************
│ │ │ │ │ +************ llooaadd__ttoorrrreenntt__ppaarrsseedd(()) llooaadd__ttoorrrreenntt__ffiillee(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_l_o_a_d___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ - span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ - bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ bdecode_node const& torrent_file);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ + span buffer, load_torrent_limits const& cfg);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ │ +add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ │ + bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ │ std::string const& filename);
│ │ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__bbuuffffeerr (
│ │ │ │ │ span buffer);
│ │ │ │ │ These functions load the content of a .torrent file into an _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ │ object. The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ │ │ the ti field in the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s object (as a _t_o_r_r_e_n_t___i_n_f_o object). The
│ │ │ │ │ returned object is suitable to be:
│ │ │ │ │ * added to a _s_e_s_s_i_o_n via _a_d_d___t_o_r_r_e_n_t_(_) or _a_s_y_n_c___a_d_d___t_o_r_r_e_n_t_(_)
│ │ │ │ │ * saved as a .torrent_file via _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ │ * turned into a magnet link via _m_a_k_e___m_a_g_n_e_t___u_r_i_(_)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ mmaakkee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │ +std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (add_torrent_params const& atp);
│ │ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ │ -std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ │ Generates a magnet URI from the specified torrent.
│ │ │ │ │ Several fields from the _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s objects are recorded in the magnet
│ │ │ │ │ link. In order to not include them, they have to be cleared before calling
│ │ │ │ │ _m_a_k_e___m_a_g_n_e_t___u_r_i_(_). These fields are used:
│ │ │ │ │ ti, info_hashes, url_seeds, dht_nodes, file_priorities, trackers,
│ │ │ │ │ name, peers.
│ │ │ │ │ Depending on what the use case for the resulting magnet link is, clearing peers
│ │ │ │ │ @@ -3031,16 +3031,16 @@
│ │ │ │ │ The overload that takes a _t_o_r_r_e_n_t___h_a_n_d_l_e will make blocking calls to query
│ │ │ │ │ information about the torrent. If the torrent handle is invalid, an empty
│ │ │ │ │ string is returned.
│ │ │ │ │ For more information about magnet links, see _m_a_g_n_e_t_ _l_i_n_k_s.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ppaarrssee__mmaaggnneett__uurrii(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_m_a_g_n_e_t___u_r_i_._h_p_p"
│ │ │ │ │ -add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec);
│ │ │ │ │ void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ │ +add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri, error_code& ec);
│ │ │ │ │ add_torrent_params ppaarrssee__mmaaggnneett__uurrii (string_view uri);
│ │ │ │ │ This function parses out information from the magnet link and populates the
│ │ │ │ │ _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -3542,16 +3542,16 @@
│ │ │ │ │ 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 nneeww__ccoonnnneeccttiioonn (peer_connection_handle
│ │ │ │ │ const&);
│ │ │ │ │ - virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ + virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ virtual bool oonn__ppaauussee ();
│ │ │ │ │ virtual bool oonn__rreessuummee ();
│ │ │ │ │ virtual void oonn__ffiilleess__cchheecckkeedd ();
│ │ │ │ │ virtual void oonn__ssttaattee (torrent_status::state_t);
│ │ │ │ │ virtual void oonn__aadddd__ppeeeerr (tcp::endpoint const&,
│ │ │ │ │ peer_source_flags_t, add_peer_flags_t);
│ │ │ │ │ @@ -3572,16 +3572,16 @@
│ │ │ │ │ The peer_connection_handle will be valid as long as the shared_ptr is being
│ │ │ │ │ held by the torrent object. So, it is generally a good idea to not keep a
│ │ │ │ │ shared_ptr to your own _p_e_e_r___p_l_u_g_i_n. If you want to keep references to it, use
│ │ │ │ │ weak_ptr.
│ │ │ │ │ If this function throws an exception, the connection will be closed.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ -virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +virtual void oonn__ppiieeccee__ppaassss (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttiicckk(()) **********
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ @@ -3640,51 +3640,51 @@
│ │ │ │ │ {
│ │ │ │ │ virtual string_view ttyyppee () const;
│ │ │ │ │ virtual void aadddd__hhaannddsshhaakkee (entry&);
│ │ │ │ │ virtual void oonn__ddiissccoonnnneecctt (error_code const&);
│ │ │ │ │ virtual void oonn__ccoonnnneecctteedd ();
│ │ │ │ │ virtual bool oonn__hhaannddsshhaakkee (span);
│ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (bdecode_node const&);
│ │ │ │ │ - virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ - virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ virtual bool oonn__cchhookkee ();
│ │ │ │ │ - virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ + virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ + virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ + virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ + virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ + virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ + virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ - virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ - virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │ , span //**bbuuff**//);
│ │ │ │ │ + virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │ virtual bool oonn__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ virtual bool oonn__rreejjeecctt (peer_request const&);
│ │ │ │ │ - virtual bool oonn__ccaanncceell (peer_request const&);
│ │ │ │ │ virtual void sseenntt__ccaanncceell (peer_request const&);
│ │ │ │ │ virtual void sseenntt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ - virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ - virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ - virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ - virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ virtual void sseenntt__hhaavvee__aallll ();
│ │ │ │ │ + virtual void sseenntt__rreejjeecctt__rreeqquueesstt (peer_request const&);
│ │ │ │ │ virtual void sseenntt__cchhookkee ();
│ │ │ │ │ - virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ + virtual void sseenntt__aallllooww__ffaasstt (piece_index_t);
│ │ │ │ │ + virtual void sseenntt__ssuuggggeesstt (piece_index_t);
│ │ │ │ │ + virtual void sseenntt__hhaavvee__nnoonnee ();
│ │ │ │ │ virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ - virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ + virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ + virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │ virtual bool ccaann__ddiissccoonnnneecctt (error_code const& //**eecc**//);
│ │ │ │ │ virtual bool oonn__eexxtteennddeedd (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ - virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ + virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ virtual bool wwrriittee__rreeqquueesstt (peer_request const&);
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttyyppee(()) **********
│ │ │ │ │ virtual string_view ttyyppee () const;
│ │ │ │ │ This function is expected to return the name of the _p_l_u_g_i_n.
│ │ │ │ │ @@ -3712,48 +3712,48 @@
│ │ │ │ │ ********** oonn__eexxtteennssiioonn__hhaannddsshhaakkee(()) **********
│ │ │ │ │ virtual bool oonn__eexxtteennssiioonn__hhaannddsshhaakkee (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 _p_e_e_r___p_l_u_g_i_n being removed from the peer_connection and
│ │ │ │ │ destructed. this is not called for web seeds
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** oonn__hhaavvee__nnoonnee(()) oonn__bbiittffiieelldd(()) oonn__ddoonntt__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__hhaavvee(())
│ │ │ │ │ -oonn__aalllloowweedd__ffaasstt(()) oonn__rreeqquueesstt(()) oonn__hhaavvee__aallll(()) oonn__iinntteerreesstteedd(()) oonn__uunncchhookkee(())
│ │ │ │ │ -oonn__cchhookkee(()) **********
│ │ │ │ │ -virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ -virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ +********** oonn__cchhookkee(()) oonn__hhaavvee__nnoonnee(()) oonn__aalllloowweedd__ffaasstt(()) oonn__hhaavvee__aallll(()) oonn__uunncchhookkee(())
│ │ │ │ │ +oonn__hhaavvee(()) oonn__nnoott__iinntteerreesstteedd(()) oonn__ddoonntt__hhaavvee(()) oonn__rreeqquueesstt(()) oonn__bbiittffiieelldd(())
│ │ │ │ │ +oonn__iinntteerreesstteedd(()) **********
│ │ │ │ │ virtual bool oonn__cchhookkee ();
│ │ │ │ │ -virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ +virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual bool oonn__bbiittffiieelldd (bitfield const& //**bbiittffiieelldd**//);
│ │ │ │ │ +virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ +virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ +virtual bool oonn__hhaavvee (piece_index_t);
│ │ │ │ │ +virtual bool oonn__aalllloowweedd__ffaasstt (piece_index_t);
│ │ │ │ │ +virtual bool oonn__hhaavvee__nnoonnee ();
│ │ │ │ │ virtual bool oonn__iinntteerreesstteedd ();
│ │ │ │ │ -virtual bool oonn__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ virtual bool oonn__ddoonntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual bool oonn__hhaavvee__aallll ();
│ │ │ │ │ virtual bool oonn__rreeqquueesstt (peer_request const&);
│ │ │ │ │ -virtual bool oonn__uunncchhookkee ();
│ │ │ │ │ returning true from any of the message handlers indicates that the _p_l_u_g_i_n has
│ │ │ │ │ handled the message. it will break the _p_l_u_g_i_n chain traversing and not let
│ │ │ │ │ anyone else handle the message, including the default handler.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__ppiieeccee(()) **********
│ │ │ │ │ virtual bool oonn__ppiieeccee (peer_request const& //**ppiieeccee**//
│ │ │ │ │ , span //**bbuuff**//);
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseenntt__iinntteerreesstteedd(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__ppiieeccee(()) sseenntt__uunncchhookkee(())
│ │ │ │ │ -sseenntt__hhaavvee(()) **********
│ │ │ │ │ -virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ +********** sseenntt__ppiieeccee(()) sseenntt__hhaavvee(()) sseenntt__nnoott__iinntteerreesstteedd(()) sseenntt__iinntteerreesstteedd(())
│ │ │ │ │ +sseenntt__uunncchhookkee(()) **********
│ │ │ │ │ virtual void sseenntt__uunncchhookkee ();
│ │ │ │ │ virtual void sseenntt__hhaavvee (piece_index_t);
│ │ │ │ │ -virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ virtual void sseenntt__nnoott__iinntteerreesstteedd ();
│ │ │ │ │ +virtual void sseenntt__ppiieeccee (peer_request const&);
│ │ │ │ │ +virtual void sseenntt__iinntteerreesstteedd ();
│ │ │ │ │ called after a choke message has been sent to the peer
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sseenntt__ppaayyllooaadd(()) **********
│ │ │ │ │ virtual void sseenntt__ppaayyllooaadd (int //** bbyytteess **//);
│ │ │ │ │ called after piece data has been sent to the peer this can be used for stats
│ │ │ │ │ book keeping
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -3777,16 +3777,16 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__uunnkknnoowwnn__mmeessssaaggee(()) **********
│ │ │ │ │ virtual bool oonn__uunnkknnoowwnn__mmeessssaaggee (int //**lleennggtthh**//, int //**mmssgg**//,
│ │ │ │ │ span //**bbooddyy**//);
│ │ │ │ │ this is not called for web seeds
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** oonn__ppiieeccee__ffaaiilleedd(()) oonn__ppiieeccee__ppaassss(()) **********
│ │ │ │ │ -virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ virtual void oonn__ppiieeccee__ffaaiilleedd (piece_index_t);
│ │ │ │ │ +virtual void oonn__ppiieeccee__ppaassss (piece_index_t);
│ │ │ │ │ called when a piece that this peer participated in either fails or passes the
│ │ │ │ │ hash_check
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttiicckk(()) **********
│ │ │ │ │ virtual void ttiicckk ();
│ │ │ │ │ called approximately once every second
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -3796,16 +3796,16 @@
│ │ │ │ │ original request message won't be sent and no other _p_l_u_g_i_n will have this
│ │ │ │ │ function called.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ccrryyppttoo__pplluuggiinn ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_x_t_e_n_s_i_o_n_s_._h_p_p"
│ │ │ │ │ struct crypto_plugin
│ │ │ │ │ {
│ │ │ │ │ - virtual void sseett__oouuttggooiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ virtual void sseett__iinnccoommiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ + virtual void sseett__oouuttggooiinngg__kkeeyy (span key) = 0;
│ │ │ │ │ eennccrryypptt (span> //**sseenndd__vveecc**//) = 0;
│ │ │ │ │ virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//
│ │ │ │ │ ) = 0;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddeeccrryypptt(()) **********
│ │ │ │ │ virtual std::tuple ddeeccrryypptt (span> //**rreecceeiivvee__vveecc**//) =
│ │ │ │ │ @@ -3824,51 +3824,51 @@
│ │ │ │ │ the _p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e class provides a handle to the internal peer
│ │ │ │ │ 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 ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee (std::weak_ptr impl);
│ │ │ │ │ connection_type ttyyppee () const;
│ │ │ │ │ - peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const;
│ │ │ │ │ void aadddd__eexxtteennssiioonn (std::shared_ptr);
│ │ │ │ │ + peer_plugin const* ffiinndd__pplluuggiinn (string_view type) const;
│ │ │ │ │ bool iiss__sseeeedd () const;
│ │ │ │ │ bool uuppllooaadd__oonnllyy () const;
│ │ │ │ │ - bool hhaass__ppiieeccee (piece_index_t i) const;
│ │ │ │ │ peer_id const& ppiidd () const;
│ │ │ │ │ + bool hhaass__ppiieeccee (piece_index_t i) const;
│ │ │ │ │ bool iiss__cchhookkeedd () const;
│ │ │ │ │ bool iiss__iinntteerreessttiinngg () const;
│ │ │ │ │ bool hhaass__ppeeeerr__cchhookkeedd () const;
│ │ │ │ │ bool iiss__ppeeeerr__iinntteerreesstteedd () const;
│ │ │ │ │ void mmaayybbee__uunncchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ void cchhookkee__tthhiiss__ppeeeerr ();
│ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (peer_info& p) const;
│ │ │ │ │ torrent_handle aassssoocciiaatteedd__ttoorrrreenntt () const;
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t const& rreemmoottee () const;
│ │ │ │ │ _t_c_p_:_:_e_n_d_p_o_i_n_t llooccaall__eennddppooiinntt () const;
│ │ │ │ │ - bool iiss__ccoonnnneeccttiinngg () const;
│ │ │ │ │ - bool iiss__oouuttggooiinngg () const;
│ │ │ │ │ + bool iiss__ddiissccoonnnneeccttiinngg () const;
│ │ │ │ │ void ddiissccoonnnneecctt (error_code const& ec, operation_t op
│ │ │ │ │ , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ │ - bool iiss__ddiissccoonnnneeccttiinngg () const;
│ │ │ │ │ - bool iiggnnoorree__uunncchhookkee__sslloottss () const;
│ │ │ │ │ + bool iiss__ccoonnnneeccttiinngg () const;
│ │ │ │ │ + bool iiss__oouuttggooiinngg () const;
│ │ │ │ │ bool oonn__llooccaall__nneettwwoorrkk () const;
│ │ │ │ │ + bool iiggnnoorree__uunncchhookkee__sslloottss () const;
│ │ │ │ │ bool ffaaiilleedd () const;
│ │ │ │ │ void ppeeeerr__lloogg (peer_log_alert::direction_t direction
│ │ │ │ │ , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT
│ │ │ │ │ (4,5);
│ │ │ │ │ bool sshhoouulldd__lloogg (peer_log_alert::direction_t direction) const;
│ │ │ │ │ bool ccaann__ddiissccoonnnneecctt (error_code const& ec) const;
│ │ │ │ │ bool hhaass__mmeettaaddaattaa () const;
│ │ │ │ │ bool iinn__hhaannddsshhaakkee () const;
│ │ │ │ │ void sseenndd__bbuuffffeerr (char const* begin, int size);
│ │ │ │ │ - time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const;
│ │ │ │ │ std::time_t llaasstt__sseeeenn__ccoommpplleettee () const;
│ │ │ │ │ + time_point ttiimmee__ooff__llaasstt__uunncchhookkee () const;
│ │ │ │ │ bool ooppeerraattoorr!!== (peer_connection_handle const& o) const;
│ │ │ │ │ - bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │ bool ooppeerraattoorr==== (peer_connection_handle const& o) const;
│ │ │ │ │ + bool ooppeerraattoorr<< (peer_connection_handle const& o) const;
│ │ │ │ │ std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bbtt__ppeeeerr__ccoonnnneeccttiioonn__hhaannddllee ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ The _b_t___p_e_e_r___c_o_n_n_e_c_t_i_o_n___h_a_n_d_l_e provides a handle to the internal bittorrent peer
│ │ │ │ │ connection object to plugins. It's low level and may not be a stable API across
│ │ │ │ │ @@ -3954,71 +3954,71 @@
│ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee (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 aadddd__ffiillee__bboorrrrooww (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 rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t piece, std::int64_t offset
│ │ │ │ │ , std::int64_t size) const;
│ │ │ │ │ peer_request mmaapp__ffiillee (file_index_t file, std::int64_t offset, int size)
│ │ │ │ │ const;
│ │ │ │ │ int nnuumm__ffiilleess () const noexcept;
│ │ │ │ │ file_index_t eenndd__ffiillee () const noexcept;
│ │ │ │ │ index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ + void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ int ppiieeccee__ssiizzee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__iinn__ppiieeccee22 (piece_index_t index) const;
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ void sseett__nnaammee (std::string const& n);
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ + sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ + char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ + std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ +"") const;
│ │ │ │ │ + std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ + string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ + std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ - std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ - std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ - string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ - std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path =
│ │ │ │ │ -"") const;
│ │ │ │ │ - sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ - char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ + int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ - int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ - int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ + int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const&
│ │ │ │ │ save_path) const;
│ │ │ │ │ void aallll__ppaatthh__hhaasshheess (std::unordered_set& table) const;
│ │ │ │ │ file_flags_t ffiillee__ffllaaggss (file_index_t index) const;
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (file_index_t index) const;
│ │ │ │ │ - file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ + file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │ piece_index_t ppiieeccee__iinnddeexx__aatt__ffiillee (file_index_t f) const;
│ │ │ │ │ void ssaanniittiizzee__ssyymmlliinnkkss ();
│ │ │ │ │ bool vv22 () const;
│ │ │ │ │
│ │ │ │ │ static constexpr file_flags_t ffllaagg__ppaadd__ffiillee = 0_bit;
│ │ │ │ │ static constexpr file_flags_t ffllaagg__hhiiddddeenn = 1_bit;
│ │ │ │ │ @@ -4044,23 +4044,23 @@
│ │ │ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ │ │ , char const* root_hash = nullptr);
│ │ │ │ │ void aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee (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 aadddd__ffiillee__bboorrrrooww (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 aadddd__ffiillee (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);
│ │ │ │ │ Adds a file to the file storage. The add_file_borrow version expects that
│ │ │ │ │ filename is the file name (without a path) of the file that's being added. This
│ │ │ │ │ memory is bboorrrroowweedd, i.e. it is the caller's responsibility to make sure it
│ │ │ │ │ stays valid throughout the lifetime of this _f_i_l_e___s_t_o_r_a_g_e object or any copy of
│ │ │ │ │ it. The same thing applies to filehash, which is an optional pointer to a 20
│ │ │ │ │ byte binary SHA-1 hash of the file.
│ │ │ │ │ if filename is empty, the filename from path is used and not borrowed.
│ │ │ │ │ @@ -4130,16 +4130,16 @@
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ returns the total number of bytes all the files in this torrent spans
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** nnuumm__ppiieecceess(()) sseett__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ -void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ +void sseett__nnuumm__ppiieecceess (int n);
│ │ │ │ │ set and get the number of pieces in the torrent
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eenndd__ppiieeccee(()) **********
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ returns the index of the one-past-end piece in the file storage
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** llaasstt__ppiieeccee(()) **********
│ │ │ │ │ @@ -4150,15 +4150,15 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__rraannggee(()) **********
│ │ │ │ │ index_range ppiieeccee__rraannggee () 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
│ │ │ │ │ _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__ppiieeccee__lleennggtthh(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ +********** ppiieeccee__lleennggtthh(()) sseett__ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ void sseett__ppiieeccee__lleennggtthh (int l);
│ │ │ │ │ int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ set and get the size of each piece in this torrent. It must be a power of two
│ │ │ │ │ and at least 16 kiB.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t index) const;
│ │ │ │ │ @@ -4177,41 +4177,41 @@
│ │ │ │ │ returns the number of blocks in the specified piece, for v2 torrents.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bblloocckkss__ppeerr__ppiieeccee(()) **********
│ │ │ │ │ int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ │ returns the number of blocks there are in the typical piece. There may be fewer
│ │ │ │ │ in the last piece)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** sseett__nnaammee(()) nnaammee(()) **********
│ │ │ │ │ +********** nnaammee(()) sseett__nnaammee(()) **********
│ │ │ │ │ void sseett__nnaammee (std::string const& n);
│ │ │ │ │ std::string const& nnaammee () const;
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** sswwaapp(()) **********
│ │ │ │ │ void sswwaapp (file_storage& ti) noexcept;
│ │ │ │ │ swap all content of tthhiiss with ttii.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ccaannoonniiccaalliizzee(()) **********
│ │ │ │ │ void ccaannoonniiccaalliizzee ();
│ │ │ │ │ arrange files and padding to match the canonical form required by BEP 52
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** rroooott(()) rroooott__ppttrr(()) ffiillee__nnaammee(()) ppaadd__ffiillee__aatt(()) ssyymmlliinnkk(()) ffiillee__ppaatthh(())
│ │ │ │ │ -ffiillee__ooffffsseett(()) ffiillee__ssiizzee(()) hhaasshh(()) mmttiimmee(()) **********
│ │ │ │ │ +********** ffiillee__ooffffsseett(()) ssyymmlliinnkk(()) rroooott(()) ppaadd__ffiillee__aatt(()) hhaasshh(()) rroooott__ppttrr(()) ffiillee__ppaatthh
│ │ │ │ │ +(()) mmttiimmee(()) ffiillee__ssiizzee(()) ffiillee__nnaammee(()) **********
│ │ │ │ │ +sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ +char const* rroooott__ppttrr (file_index_t const index) const;
│ │ │ │ │ +std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ +const;
│ │ │ │ │ +std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ +string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ +std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ bool ppaadd__ffiillee__aatt (file_index_t index) const;
│ │ │ │ │ std::time_t mmttiimmee (file_index_t index) const;
│ │ │ │ │ sha256_hash rroooott (file_index_t index) const;
│ │ │ │ │ -std::int64_t ffiillee__ooffffsseett (file_index_t index) const;
│ │ │ │ │ -std::string ssyymmlliinnkk (file_index_t index) const;
│ │ │ │ │ std::int64_t ffiillee__ssiizzee (file_index_t index) const;
│ │ │ │ │ -string_view ffiillee__nnaammee (file_index_t index) const;
│ │ │ │ │ -std::string ffiillee__ppaatthh (file_index_t index, std::string const& save_path = "")
│ │ │ │ │ -const;
│ │ │ │ │ -sha1_hash hhaasshh (file_index_t index) const;
│ │ │ │ │ -char const* rroooott__ppttrr (file_index_t const 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, in case this
│ │ │ │ │ is a v2 torrent. Otherwise returns zeros. root_ptr() returns a pointer to the
│ │ │ │ │ SHA-256 merkle tree root hash for the specified file. The pointer points into
│ │ │ │ │ @@ -4224,26 +4224,26 @@
│ │ │ │ │ file_size() returns the size of a file.
│ │ │ │ │ pad_file_at() returns true if the file at the given index is a pad-file.
│ │ │ │ │ file_name() returns jjuusstt 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).
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ffiillee__nnuumm__bblloocckkss(()) ffiillee__ppiieeccee__rraannggee(()) ffiillee__nnuumm__ppiieecceess(()) **********
│ │ │ │ │ +********** ffiillee__nnuumm__ppiieecceess(()) ffiillee__nnuumm__bblloocckkss(()) ffiillee__ppiieeccee__rraannggee(()) **********
│ │ │ │ │ +int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ int ffiillee__nnuumm__ppiieecceess (file_index_t index) const;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t) const;
│ │ │ │ │ -int ffiillee__nnuumm__bblloocckkss (file_index_t index) const;
│ │ │ │ │ Returns the number of pieces or blocks the file atindexspans, 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__ffiirrsstt__ppiieeccee__nnooddee(()) ffiillee__ffiirrsstt__bblloocckk__nnooddee(()) **********
│ │ │ │ │ -int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ int ffiillee__ffiirrsstt__ppiieeccee__nnooddee (file_index_t index) const;
│ │ │ │ │ +int ffiillee__ffiirrsstt__bblloocckk__nnooddee (file_index_t index) const;
│ │ │ │ │ index of first piece node in the merkle tree
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__ppaatthh__hhaasshh(()) **********
│ │ │ │ │ std::uint32_t ffiillee__ppaatthh__hhaasshh (file_index_t index, std::string const& save_path)
│ │ │ │ │ const;
│ │ │ │ │ returns the crc32 hash of file_path(index)
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -4261,16 +4261,16 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__aabbssoolluuttee__ppaatthh(()) **********
│ │ │ │ │ bool ffiillee__aabbssoolluuttee__ppaatthh (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__iinnddeexx__aatt__ppiieeccee(()) ffiillee__iinnddeexx__aatt__ooffffsseett(()) **********
│ │ │ │ │ -file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__aatt__ooffffsseett (std::int64_t offset) const;
│ │ │ │ │ +file_index_t ffiillee__iinnddeexx__aatt__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ returns the index of the file at the given offset in the torrent
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ffiillee__iinnddeexx__ffoorr__rroooott(()) **********
│ │ │ │ │ file_index_t ffiillee__iinnddeexx__ffoorr__rroooott (sha256_hash const& root_hash) const;
│ │ │ │ │ finds the file with the given root hash and returns its index if there is no
│ │ │ │ │ file with the root hash, file_index_t{-1} is returned
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -4410,32 +4410,32 @@
│ │ │ │ │ struct client_data_t
│ │ │ │ │ {
│ │ │ │ │ cclliieenntt__ddaattaa__tt () = default;
│ │ │ │ │ explicit cclliieenntt__ddaattaa__tt (T* v);
│ │ │ │ │ client_data_t& ooppeerraattoorr== (T* v);
│ │ │ │ │ T* ggeett () const;
│ │ │ │ │ explicit operator TT () const;
│ │ │ │ │ + operator vvooiidd** () const = delete;
│ │ │ │ │ client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ operator void ccoonnsstt** () const = delete;
│ │ │ │ │ - operator vvooiidd** () const = delete;
│ │ │ │ │
│ │ │ │ │ template ::value>::type>
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** cclliieenntt__ddaattaa__tt(()) **********
│ │ │ │ │ cclliieenntt__ddaattaa__tt () = default;
│ │ │ │ │ construct a nullptr client data
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ccoonnsstt**(()) vvooiidd**(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ +********** vvooiidd**(()) ccoonnsstt**(()) ooppeerraattoorr==(()) **********
│ │ │ │ │ +operator vvooiidd** () const = delete;
│ │ │ │ │ client_data_t& ooppeerraattoorr== (void*) = delete;
│ │ │ │ │ client_data_t& ooppeerraattoorr== (void const*) = delete;
│ │ │ │ │ operator void ccoonnsstt** () const = delete;
│ │ │ │ │ -operator vvooiidd** () const = delete;
│ │ │ │ │ we don't allow type-unsafe operations
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ aadddd__ttoorrrreenntt__ppaarraammss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s_._h_p_p"
│ │ │ │ │ The _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s contains all the information in a .torrent file along
│ │ │ │ │ with all information necessary to add that torrent to a _s_e_s_s_i_o_n. The key fields
│ │ │ │ │ when adding a torrent are:
│ │ │ │ │ @@ -4739,16 +4739,16 @@
│ │ │ │ │ ************ ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │ peer_class_type_filter is a simple container for rules for adding and
│ │ │ │ │ subtracting peer-classes from peers. It is applied aafftteerr the peer class filter
│ │ │ │ │ is applied (which is based on the peer's IP address).
│ │ │ │ │ struct peer_class_type_filter
│ │ │ │ │ {
│ │ │ │ │ - void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ + void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ std::uint32_t aappppllyy (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ │ friend bool ooppeerraattoorr==== (peer_class_type_filter const& lhs
│ │ │ │ │ , peer_class_type_filter const& rhs);
│ │ │ │ │
│ │ │ │ │ enum socket_type_t
│ │ │ │ │ @@ -4759,16 +4759,16 @@
│ │ │ │ │ ssl_utp_socket,
│ │ │ │ │ i2p_socket,
│ │ │ │ │ num_socket_types,
│ │ │ │ │ };
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** rreemmoovvee(()) aadddd(()) **********
│ │ │ │ │ -void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +void rreemmoovvee (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ddiissaallllooww(()) aallllooww(()) **********
│ │ │ │ │ void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aallllooww (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
│ │ │ │ │ @@ -4795,16 +4795,16 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ bblloocckk__iinnffoo ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ holds the state of a block in a piece. Who we requested it from and how far
│ │ │ │ │ along we are at downloading it.
│ │ │ │ │ struct block_info
│ │ │ │ │ {
│ │ │ │ │ - _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │ void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ + _t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │
│ │ │ │ │ enum block_state_t
│ │ │ │ │ {
│ │ │ │ │ none,
│ │ │ │ │ requested,
│ │ │ │ │ writing,
│ │ │ │ │ finished,
│ │ │ │ │ @@ -4812,17 +4812,17 @@
│ │ │ │ │
│ │ │ │ │ unsigned bytes_progress:15;
│ │ │ │ │ unsigned block_size:15;
│ │ │ │ │ unsigned state:2;
│ │ │ │ │ unsigned num_peers:14;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppeeeerr(()) sseett__ppeeeerr(()) **********
│ │ │ │ │ -_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │ +********** sseett__ppeeeerr(()) ppeeeerr(()) **********
│ │ │ │ │ void sseett__ppeeeerr (tcp::endpoint const& ep);
│ │ │ │ │ +_t_c_p_:_:_e_n_d_p_o_i_n_t ppeeeerr () const;
│ │ │ │ │ The peer is the ip address of the peer this block was downloaded from.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** eennuumm bblloocckk__ssttaattee__tt **********
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___h_a_n_d_l_e_._h_p_p"
│ │ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ │ |none |0 |This block has not been downloaded or requested form any |
│ │ │ │ │ @@ -4910,119 +4910,119 @@
│ │ │ │ │ the handle is no longer referring to a torrent. There is one exception _i_s___v_a_l_i_d
│ │ │ │ │ _(_) will never throw. Since the torrents are processed by a background thread,
│ │ │ │ │ there is no guarantee that a handle will remain valid between two calls.
│ │ │ │ │ struct torrent_handle
│ │ │ │ │ {
│ │ │ │ │ friend std::size_t hhaasshh__vvaalluuee (torrent_handle const& th);
│ │ │ │ │ ttoorrrreenntt__hhaannddllee () noexcept = default;
│ │ │ │ │ - void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ -add_piece_flags_t flags = {}) const;
│ │ │ │ │ void aadddd__ppiieeccee (piece_index_t piece, char const* data, add_piece_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ + void aadddd__ppiieeccee (piece_index_t piece, std::vector data,
│ │ │ │ │ +add_piece_flags_t flags = {}) const;
│ │ │ │ │ void rreeaadd__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ bool hhaavvee__ppiieeccee (piece_index_t piece) const;
│ │ │ │ │ void ppoosstt__ppeeeerr__iinnffoo () const;
│ │ │ │ │ void ggeett__ppeeeerr__iinnffoo (std::vector& v) const;
│ │ │ │ │ - torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ void ppoosstt__ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ + torrent_status ssttaattuuss (status_flags_t flags = status_flags_t::all()) const;
│ │ │ │ │ void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ - std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) const;
│ │ │ │ │ + std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ │ void cclleeaarr__ppiieeccee__ddeeaaddlliinneess () const;
│ │ │ │ │ void rreesseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index) const;
│ │ │ │ │ void sseett__ppiieeccee__ddeeaaddlliinnee (piece_index_t index, int deadline, deadline_flags_t
│ │ │ │ │ flags = {}) const;
│ │ │ │ │ void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ │ std::vector ffiillee__pprrooggrreessss (file_progress_flags_t flags = {})
│ │ │ │ │ const;
│ │ │ │ │ void ffiillee__pprrooggrreessss (std::vector& progress,
│ │ │ │ │ file_progress_flags_t flags = {}) const;
│ │ │ │ │ std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ │ void cclleeaarr__eerrrroorr () const;
│ │ │ │ │ - void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ - void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ void ppoosstt__ttrraacckkeerrss () const;
│ │ │ │ │ std::vector ttrraacckkeerrss () const;
│ │ │ │ │ + void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ │ + void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ │ void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ │ + void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ std::set hhttttpp__sseeeeddss () const;
│ │ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ - void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ │ void aadddd__eexxtteennssiioonn (
│ │ │ │ │ std::function(torrent_handle const&,
│ │ │ │ │ client_data_t)> const& ext
│ │ │ │ │ , client_data_t userdata = client_data_t{});
│ │ │ │ │ bool sseett__mmeettaaddaattaa (span metadata) const;
│ │ │ │ │ bool iiss__vvaalliidd () const;
│ │ │ │ │ - void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ void rreessuummee () const;
│ │ │ │ │ - void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ - void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ + void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ │ void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ torrent_flags_t ffllaaggss () const;
│ │ │ │ │ + void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ │ + void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ │ void fflluusshh__ccaacchhee () const;
│ │ │ │ │ void ffoorrccee__rreecchheecckk () const;
│ │ │ │ │ void ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags = {}) const;
│ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa (resume_data_flags_t flags) const;
│ │ │ │ │ bool nneeeedd__ssaavvee__rreessuummee__ddaattaa () const;
│ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ - void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ │ + void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ │ void sseett__ssssll__cceerrttiiffiiccaattee (std::string const& certificate
│ │ │ │ │ , std::string const& private_key
│ │ │ │ │ , std::string const& dh_params
│ │ │ │ │ , std::string const& passphrase = "");
│ │ │ │ │ void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ │ , std::string const& private_key
│ │ │ │ │ , std::string const& dh_params);
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ │ - void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ │ - download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ + void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ │ void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ │ const;
│ │ │ │ │ + download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ │ std::vector