│ │ │
id()
│ │ │
│ │ │ ├── html2text {}
│ │ │ │ @@ -9,53 +9,53 @@
│ │ │ │ * _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 _s_t_a_t_u_s_(_)_ _p_o_s_t___s_t_a_t_u_s_(_)
│ │ │ │ + o _p_o_s_t___s_t_a_t_u_s_(_)_ _s_t_a_t_u_s_(_)
│ │ │ │ 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 _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_(_)_ _s_e_t___p_i_e_c_e___d_e_a_d_l_i_n_e_(_)
│ │ │ │ - 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 _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 _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 _r_e_p_l_a_c_e___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_(_)_ _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_(_)_ _h_t_t_p___s_e_e_d_s_(_)_ _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)
│ │ │ │ + o _t_r_a_c_k_e_r_s_(_)_ _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_(_)_ _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ + o _a_d_d___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)_ _r_e_m_o_v_e___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 _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 _f_l_a_g_s_(_)_ _s_e_t___f_l_a_g_s_(_)_ _u_n_s_e_t___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___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_(_)
│ │ │ │ _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_(_)
│ │ │ │ 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___b_u_f_f_e_r_(_)_ _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e_(_)
│ │ │ │ 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 _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 _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_(_)_ _p_r_i_o_r_i_t_i_z_e___p_i_e_c_e_s_(_)
│ │ │ │ - o _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_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)
│ │ │ │ - o _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_(_)_ _f_o_r_c_e___r_e_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_(_)_ _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_(_)_ _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___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_(_)_ _f_o_r_c_e___d_h_t___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___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 _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 _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 _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_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 _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 ************
│ │ │ │ @@ -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 ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) 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;
│ │ │ │ - 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;
│ │ │ │ + void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ std::vector ffiillee__ssttaattuuss () const;
│ │ │ │ void cclleeaarr__eerrrroorr () const;
│ │ │ │ + std::vector ttrraacckkeerrss () 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__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ - void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ + void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ - std::set hhttttpp__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 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;
│ │ │ │ - torrent_flags_t ffllaaggss () const;
│ │ │ │ - void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ + void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ + torrent_flags_t ffllaaggss () 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__ddoowwnn () const;
│ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ + void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ void qquueeuuee__ppoossiittiioonn__ttoopp () const;
│ │ │ │ void qquueeuuee__ppoossiittiioonn__bboottttoomm () const;
│ │ │ │ + void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ + void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ + , std::string const& private_key
│ │ │ │ + , std::string const& dh_params);
│ │ │ │ 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::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ std::vector> ppiieeccee__llaayyeerrss () const;
│ │ │ │ - void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ void ppiieeccee__aavvaaiillaabbiilliittyy (std::vector& avail) const;
│ │ │ │ - void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ -const;
│ │ │ │ + void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ + download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) const;
│ │ │ │ - download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ + std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ + void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority)
│ │ │ │ +const;
│ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector const& pieces)
│ │ │ │ const;
│ │ │ │ - std::vector ggeett__ppiieeccee__pprriioorriittiieess () const;
│ │ │ │ - std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ + std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) const;
│ │ │ │ void pprriioorriittiizzee__ffiilleess (std::vector const& files) const;
│ │ │ │ - void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ - void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t =
│ │ │ │ {}) const;
│ │ │ │ + void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ + void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ void ssccrraappee__ttrraacckkeerr (int idx = -1) const;
│ │ │ │ - void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ - int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ + int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ int uuppllooaadd__lliimmiitt () const;
│ │ │ │ + void sseett__ddoowwnnllooaadd__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 ();
│ │ │ │ int mmaaxx__uuppllooaaddss () const;
│ │ │ │ void sseett__mmaaxx__uuppllooaaddss (int max_uploads) 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;
│ │ │ │ - bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ - bool ooppeerraattoorr<< (const torrent_handle& h) 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;
│ │ │ │ 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]
│ │ │ │ ********** ppoosstt__ppeeeerr__iinnffoo(()) ggeett__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;
│ │ │ │ +********** ppoosstt__ssttaattuuss(()) ssttaattuuss(()) **********
│ │ │ │ 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
│ │ │ │ @@ -386,24 +386,24 @@
│ │ │ │ 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]
│ │ │ │ ********** ggeett__ddoowwnnllooaadd__qquueeuuee(()) ppoosstt__ddoowwnnllooaadd__qquueeuuee(()) **********
│ │ │ │ -std::vector ggeett__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ void ppoosstt__ddoowwnnllooaadd__qquueeuuee () const;
│ │ │ │ void ggeett__ddoowwnnllooaadd__qquueeuuee (std::vector& queue) 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]
│ │ │ │ -********** cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) sseett__ppiieeccee__ddeeaaddlliinnee(()) **********
│ │ │ │ +********** sseett__ppiieeccee__ddeeaaddlliinnee(()) rreesseett__ppiieeccee__ddeeaaddlliinnee(()) cclleeaarr__ppiieeccee__ddeeaaddlliinneess(()) **********
│ │ │ │ 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
│ │ │ │ @@ -415,20 +415,20 @@
│ │ │ │ same effect as calling _r_e_a_d___p_i_e_c_e_(_) for index.
│ │ │ │ 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]
│ │ │ │ -********** ffiillee__pprrooggrreessss(()) ppoosstt__ffiillee__pprrooggrreessss(()) **********
│ │ │ │ -void ppoosstt__ffiillee__pprrooggrreessss (file_progress_flags_t flags) const;
│ │ │ │ +********** ppoosstt__ffiillee__pprrooggrreessss(()) ffiillee__pprrooggrreessss(()) **********
│ │ │ │ std::vector 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;
│ │ │ │ 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]
│ │ │ │ -********** rreeppllaaccee__ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) **********
│ │ │ │ +********** ttrraacckkeerrss(()) ppoosstt__ttrraacckkeerrss(()) rreeppllaaccee__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) **********
│ │ │ │ +std::vector ttrraacckkeerrss () const;
│ │ │ │ void aadddd__ttrraacckkeerr (announce_entry const&) const;
│ │ │ │ -void rreeppllaaccee__ttrraacckkeerrss (std::vector const&) const;
│ │ │ │ void ppoosstt__ttrraacckkeerrss () 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,29 +470,29 @@
│ │ │ │ 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(()) **********
│ │ │ │ -void aadddd__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ -void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ +********** aadddd__uurrll__sseeeedd(()) uurrll__sseeeeddss(()) rreemmoovvee__uurrll__sseeeedd(()) **********
│ │ │ │ std::set uurrll__sseeeeddss () const;
│ │ │ │ +void rreemmoovvee__uurrll__sseeeedd (std::string const& url) const;
│ │ │ │ +void aadddd__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(()) hhttttpp__sseeeeddss(()) rreemmoovvee__hhttttpp__sseeeedd(()) **********
│ │ │ │ -std::set hhttttpp__sseeeeddss () const;
│ │ │ │ +********** hhttttpp__sseeeeddss(()) rreemmoovvee__hhttttpp__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ void rreemmoovvee__hhttttpp__sseeeedd (std::string const& url) const;
│ │ │ │ +std::set hhttttpp__sseeeeddss () const;
│ │ │ │ void aadddd__hhttttpp__sseeeedd (std::string const& url) 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 (
│ │ │ │ @@ -524,15 +524,15 @@
│ │ │ │ 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]
│ │ │ │ -********** ppaauussee(()) rreessuummee(()) **********
│ │ │ │ +********** rreessuummee(()) ppaauussee(()) **********
│ │ │ │ void ppaauussee (pause_flags_t flags = {}) const;
│ │ │ │ void rreessuummee () 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.
│ │ │ │ @@ -541,19 +541,19 @@
│ │ │ │ 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]
│ │ │ │ -********** ffllaaggss(()) sseett__ffllaaggss(()) uunnsseett__ffllaaggss(()) **********
│ │ │ │ -torrent_flags_t ffllaaggss () const;
│ │ │ │ -void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ +********** ffllaaggss(()) uunnsseett__ffllaaggss(()) sseett__ffllaaggss(()) **********
│ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ void sseett__ffllaaggss (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ │ +void uunnsseett__ffllaaggss (torrent_flags_t flags) const;
│ │ │ │ +torrent_flags_t ffllaaggss () 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
│ │ │ │ @@ -679,19 +679,19 @@
│ │ │ │ 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__bboottttoomm(()) qquueeuuee__ppoossiittiioonn__ddoowwnn(()) qquueeuuee__ppoossiittiioonn__uupp(())
│ │ │ │ qquueeuuee__ppoossiittiioonn(()) qquueeuuee__ppoossiittiioonn__ttoopp(()) **********
│ │ │ │ -void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ -void qquueeuuee__ppoossiittiioonn__ddoowwnn () const;
│ │ │ │ queue_position_t qquueeuuee__ppoossiittiioonn () const;
│ │ │ │ +void qquueeuuee__ppoossiittiioonn__uupp () const;
│ │ │ │ void qquueeuuee__ppoossiittiioonn__ttoopp () 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
│ │ │ │ @@ -706,21 +706,21 @@
│ │ │ │ ********** qquueeuuee__ppoossiittiioonn__sseett(()) **********
│ │ │ │ void qquueeuuee__ppoossiittiioonn__sseett (queue_position_t p) const;
│ │ │ │ updates the position in the queue for this torrent. The relative order of all
│ │ │ │ other torrents remain intact but their numerical queue position shifts to make
│ │ │ │ space for this torrent's new position
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ********** sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr(()) sseett__ssssll__cceerrttiiffiiccaattee(()) **********
│ │ │ │ +void sseett__ssssll__cceerrttiiffiiccaattee__bbuuffffeerr (std::string const& certificate
│ │ │ │ + , std::string const& private_key
│ │ │ │ + , std::string const& dh_params);
│ │ │ │ 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);
│ │ │ │ For SSL torrents, use this to specify a path to a .pem file to use as this
│ │ │ │ client's certificate. The certificate must be signed by the certificate in the
│ │ │ │ .torrent file to be valid.
│ │ │ │ The _s_e_t___s_s_l___c_e_r_t_i_f_i_c_a_t_e___b_u_f_f_e_r_(_) overload takes the actual certificate, private
│ │ │ │ key and DH params as strings, rather than paths to files.
│ │ │ │ cert is a path to the (signed) certificate in .pem format corresponding to this
│ │ │ │ torrent.
│ │ │ │ @@ -735,16 +735,16 @@
│ │ │ │ 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(()) **********
│ │ │ │ -std::shared_ptr ttoorrrreenntt__ffiillee () const;
│ │ │ │ std::shared_ptr ttoorrrreenntt__ffiillee__wwiitthh__hhaasshheess () const;
│ │ │ │ +std::shared_ptr ttoorrrreenntt__ffiillee () 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.
│ │ │ │ Note that the _t_o_r_r_e_n_t___i_n_f_o object returned here may be a different instance
│ │ │ │ than the one added to the _s_e_s_s_i_o_n, with different attributes like piece layers,
│ │ │ │ @@ -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]
│ │ │ │ -********** ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy(()) ppiieeccee__aavvaaiillaabbiilliittyy(()) **********
│ │ │ │ -void ppoosstt__ppiieeccee__aavvaaiillaabbiilliittyy () const;
│ │ │ │ +********** ppiieeccee__aavvaaiillaabbiilliittyy(()) ppoosstt__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]
│ │ │ │ -********** ggeett__ppiieeccee__pprriioorriittiieess(()) ppiieeccee__pprriioorriittyy(()) pprriioorriittiizzee__ppiieecceess(()) **********
│ │ │ │ -void ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +********** ppiieeccee__pprriioorriittyy(()) ggeett__ppiieeccee__pprriioorriittiieess(()) pprriioorriittiizzee__ppiieecceess(()) **********
│ │ │ │ +download_priority_t ppiieeccee__pprriioorriittyy (piece_index_t index) const;
│ │ │ │ void pprriioorriittiizzee__ppiieecceess (std::vector> const& pieces) 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 ppiieeccee__pprriioorriittyy (piece_index_t index, download_priority_t priority) const;
│ │ │ │ +void pprriioorriittiizzee__ppiieecceess (std::vector 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. 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,17 +816,17 @@
│ │ │ │ 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]
│ │ │ │ -********** ffiillee__pprriioorriittyy(()) ggeett__ffiillee__pprriioorriittiieess(()) pprriioorriittiizzee__ffiilleess(()) **********
│ │ │ │ -std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ +********** pprriioorriittiizzee__ffiilleess(()) ggeett__ffiillee__pprriioorriittiieess(()) ffiillee__pprriioorriittyy(()) **********
│ │ │ │ download_priority_t ffiillee__pprriioorriittyy (file_index_t index) const;
│ │ │ │ +std::vector ggeett__ffiillee__pprriioorriittiieess () const;
│ │ │ │ void ffiillee__pprriioorriittyy (file_index_t index, download_priority_t priority) 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.
│ │ │ │ @@ -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__ddhhtt__aannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) ffoorrccee__rreeaannnnoouunnccee(()) **********
│ │ │ │ -void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ -void ffoorrccee__ddhhtt__aannnnoouunnccee () const;
│ │ │ │ +********** ffoorrccee__rreeaannnnoouunnccee(()) ffoorrccee__llssdd__aannnnoouunnccee(()) ffoorrccee__ddhhtt__aannnnoouunnccee(()) **********
│ │ │ │ void ffoorrccee__rreeaannnnoouunnccee (int seconds = 0, int idx = -1, reannounce_flags_t = {})
│ │ │ │ const;
│ │ │ │ +void ffoorrccee__llssdd__aannnnoouunnccee () const;
│ │ │ │ +void ffoorrccee__ddhhtt__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,20 +877,20 @@
│ │ │ │ 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__ddoowwnnllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(()) uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(())
│ │ │ │ +********** uuppllooaadd__lliimmiitt(()) sseett__uuppllooaadd__lliimmiitt(()) sseett__ddoowwnnllooaadd__lliimmiitt(()) ddoowwnnllooaadd__lliimmiitt(())
│ │ │ │ **********
│ │ │ │ -void sseett__ddoowwnnllooaadd__lliimmiitt (int limit) const;
│ │ │ │ -int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ void sseett__uuppllooaadd__lliimmiitt (int limit) const;
│ │ │ │ +int ddoowwnnllooaadd__lliimmiitt () const;
│ │ │ │ int uuppllooaadd__lliimmiitt () const;
│ │ │ │ +void sseett__ddoowwnnllooaadd__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
│ │ │ │ the global rate limit.
│ │ │ │ @@ -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__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ │ │ -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====(()) **********
│ │ │ │ -bool ooppeerraattoorr!!== (const torrent_handle& h) const;
│ │ │ │ -bool ooppeerraattoorr<< (const torrent_handle& h) const;
│ │ │ │ +********** ooppeerraattoorr!!==(()) ooppeerraattoorr====(()) ooppeerraattoorr<<(()) **********
│ │ │ │ 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
│ │ │ @@ -41,21 +41,21 @@
│ │ │ load_torrent_limits
│ │ │ torrent_info
│ │ │ - torrent_info()
│ │ │ - ~torrent_info()
│ │ │ - files() orig_files()
│ │ │ - rename_file()
│ │ │ - remap_files()
│ │ │ -- clear_trackers() add_tracker() trackers()
│ │ │ -- similar_torrents() collections()
│ │ │ -- add_http_seed() add_url_seed() web_seeds() set_web_seeds()
│ │ │ +- trackers() add_tracker() clear_trackers()
│ │ │ +- collections() similar_torrents()
│ │ │ +- add_url_seed() web_seeds() set_web_seeds() add_http_seed()
│ │ │ - total_size()
│ │ │ -- piece_length() num_pieces()
│ │ │ +- num_pieces() piece_length()
│ │ │ - blocks_per_piece()
│ │ │ -- piece_range() last_piece() end_piece()
│ │ │ +- end_piece() last_piece() piece_range()
│ │ │ - info_hashes() info_hash()
│ │ │ - v1() v2()
│ │ │ - num_files()
│ │ │ - map_block()
│ │ │ - map_file()
│ │ │ - ssl_cert()
│ │ │ - is_valid()
│ │ │ @@ -197,54 +197,54 @@
│ │ │
│ │ │
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 (bdecode_node const& torrent_file, error_code& ec);
│ │ │ - torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ - torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ - torrent_info (torrent_info const& t);
│ │ │ - torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ - explicit torrent_info (std::string const& filename);
│ │ │ - explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ + explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ + explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ explicit torrent_info (info_hash_t const& info_hash);
│ │ │ torrent_info (char const* buffer, int size);
│ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ + torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ + torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ torrent_info (std::string const& filename, error_code& ec);
│ │ │ - explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ + explicit torrent_info (std::string const& filename);
│ │ │ + torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ + torrent_info (torrent_info const& t);
│ │ │ ~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);
│ │ │ - void add_tracker (std::string const& url, int tier = 0);
│ │ │ void clear_trackers ();
│ │ │ - std::vector<announce_entry> const& trackers () const;
│ │ │ + void add_tracker (std::string const& url, int tier = 0);
│ │ │ void add_tracker (std::string const& url, int tier
│ │ │ , announce_entry::tracker_source source);
│ │ │ + std::vector<announce_entry> const& trackers () const;
│ │ │ std::vector<std::string> collections () const;
│ │ │ std::vector<sha1_hash> similar_torrents () const;
│ │ │ - void add_url_seed (std::string const& url
│ │ │ - , std::string const& ext_auth = std::string()
│ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ - std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ void add_http_seed (std::string const& url
│ │ │ , std::string const& extern_auth = std::string()
│ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ + std::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());
│ │ │ std::int64_t total_size () 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;
│ │ │ - piece_index_t last_piece () const;
│ │ │ sha1_hash info_hash () const noexcept;
│ │ │ info_hash_t const& info_hashes () const;
│ │ │ bool v1 () const;
│ │ │ bool v2 () const;
│ │ │ int num_files () const;
│ │ │ std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ , std::int64_t offset, int size) const;
│ │ │ @@ -269,27 +269,27 @@
│ │ │ span<char const> piece_layer (file_index_t) const;
│ │ │ void free_piece_layers ();
│ │ │ };
│ │ │
│ │ │
[report issue]
│ │ │
torrent_info()
│ │ │
│ │ │ -torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ -torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ -torrent_info (torrent_info const& t);
│ │ │ -torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ +explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ explicit torrent_info (info_hash_t const& info_hash);
│ │ │ torrent_info (char const* buffer, int size);
│ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ +torrent_info (bdecode_node const& torrent_file, error_code& ec);
│ │ │ torrent_info (std::string const& filename, error_code& ec);
│ │ │ -explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ +explicit torrent_info (std::string const& filename);
│ │ │ +torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ +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
│ │ │ @@ -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]
│ │ │ -
clear_trackers() add_tracker() trackers()
│ │ │ +
[report issue]
│ │ │ +
trackers() add_tracker() clear_trackers()
│ │ │
│ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ void clear_trackers ();
│ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ +void add_tracker (std::string const& url, int tier = 0);
│ │ │ void add_tracker (std::string const& url, int tier
│ │ │ , announce_entry::tracker_source source);
│ │ │ +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]
│ │ │ -
similar_torrents() collections()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
collections() similar_torrents()
│ │ │
│ │ │ 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]
│ │ │ -
add_http_seed() add_url_seed() web_seeds() set_web_seeds()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
add_url_seed() web_seeds() set_web_seeds() add_http_seed()
│ │ │
│ │ │ -void add_url_seed (std::string const& url
│ │ │ - , std::string const& ext_auth = std::string()
│ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ void add_http_seed (std::string const& url
│ │ │ , std::string const& extern_auth = std::string()
│ │ │ , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ 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());
│ │ │
│ │ │
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
│ │ │ @@ -453,18 +453,18 @@
│ │ │ std::int64_t total_size () const;
│ │ │
│ │ │
total_size() returns the total number of bytes the torrent-file
│ │ │ represents. Note that this is the number of pieces times the piece
│ │ │ size (modulo the last piece possibly being smaller). With pad files,
│ │ │ the total size will be larger than the sum of all (regular) file
│ │ │ sizes.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
piece_length() num_pieces()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
num_pieces() piece_length()
│ │ │
│ │ │ 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
│ │ │ @@ -476,23 +476,23 @@
│ │ │
│ │ │
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]
│ │ │ +
│ │ │ +
end_piece() last_piece() piece_range()
│ │ │
│ │ │ +piece_index_t last_piece () const;
│ │ │ index_range<piece_index_t> piece_range () const;
│ │ │ piece_index_t end_piece () const;
│ │ │ -piece_index_t last_piece () const;
│ │ │
│ │ │
last_piece() returns the index to the last piece in the torrent and
│ │ │ end_piece() returns the index to the one-past-end piece in the
│ │ │ torrent
│ │ │ piece_range() returns an implementation-defined type that can be
│ │ │ used as the container in a range-for loop. Where the values are the
│ │ │ indices of all pieces in the file_storage.
│ │ │ ├── html2text {}
│ │ │ │ @@ -10,21 +10,21 @@
│ │ │ │ * _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_(_)_ _a_d_d___t_r_a_c_k_e_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 _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _s_e_t___w_e_b___s_e_e_d_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___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ - o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ + 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 _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_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_(_)
│ │ │ │ @@ -120,58 +120,58 @@
│ │ │ │ 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 (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ -cfg);
│ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ ttoorrrreenntt__iinnffoo (span
buffer, error_code& ec, from_span_t);
│ │ │ │ - ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ -from_span_t);
│ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ + explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ + explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ +cfg);
│ │ │ │ + ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ + ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ - explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ + explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ + ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ +from_span_t);
│ │ │ │ + ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ ~~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);
│ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ - std::vector const& ttrraacckkeerrss () const;
│ │ │ │ + void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ + std::vector const& ttrraacckkeerrss () const;
│ │ │ │ std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ std::vector ssiimmiillaarr__ttoorrrreennttss () 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());
│ │ │ │ - std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ 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());
│ │ │ │ void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ + 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());
│ │ │ │ std::int64_t ttoottaall__ssiizzee () 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;
│ │ │ │ - piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ sha1_hash iinnffoo__hhaasshh () const noexcept;
│ │ │ │ info_hash_t const& iinnffoo__hhaasshheess () const;
│ │ │ │ bool vv11 () const;
│ │ │ │ bool vv22 () const;
│ │ │ │ int nnuumm__ffiilleess () const;
│ │ │ │ std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ , std::int64_t offset, int size) const;
│ │ │ │ @@ -196,29 +196,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 (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ -cfg);
│ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ -from_span_t);
│ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ +explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ +explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ explicit ttoorrrreenntt__iinnffoo (info_hash_t const& info_hash);
│ │ │ │ ttoorrrreenntt__iinnffoo (char const* buffer, int size);
│ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, load_torrent_limits const&
│ │ │ │ +cfg);
│ │ │ │ +ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ +ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, error_code& ec);
│ │ │ │ ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ -explicit ttoorrrreenntt__iinnffoo (span buffer, from_span_t);
│ │ │ │ +explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ +ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ +from_span_t);
│ │ │ │ +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
│ │ │ │ @@ -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]
│ │ │ │ -********** cclleeaarr__ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) **********
│ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ +********** ttrraacckkeerrss(()) aadddd__ttrraacckkeerr(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ +void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ , announce_entry::tracker_source source);
│ │ │ │ +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]
│ │ │ │ -********** ssiimmiillaarr__ttoorrrreennttss(()) ccoolllleeccttiioonnss(()) **********
│ │ │ │ +********** ccoolllleeccttiioonnss(()) ssiimmiillaarr__ttoorrrreennttss(()) **********
│ │ │ │ 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]
│ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) sseett__wweebb__sseeeeddss(()) **********
│ │ │ │ -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());
│ │ │ │ -std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ +********** aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) sseett__wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ 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());
│ │ │ │ void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ +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());
│ │ │ │ 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
│ │ │ │ @@ -339,32 +339,32 @@
│ │ │ │ ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ 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]
│ │ │ │ -********** ppiieeccee__lleennggtthh(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ +********** nnuumm__ppiieecceess(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ 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]
│ │ │ │ -********** ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) **********
│ │ │ │ +********** eenndd__ppiieeccee(()) llaasstt__ppiieeccee(()) ppiieeccee__rraannggee(()) **********
│ │ │ │ +piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ index_range ppiieeccee__rraannggee () const;
│ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ -piece_index_t llaasstt__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__hhaasshheess(()) iinnffoo__hhaasshh(()) **********
│ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Trackers.html
│ │ │ @@ -31,15 +31,15 @@
│ │ │ home
│ │ │
│ │ │
Table of contents
│ │ │
│ │ │
│ │ │
announce_infohash
│ │ │ @@ -131,18 +131,18 @@
│ │ │
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&);
│ │ │ ~announce_entry ();
│ │ │ explicit announce_entry (string_view u);
│ │ │ + announce_entry (announce_entry const&);
│ │ │ + announce_entry& operator= (announce_entry const&) &;
│ │ │ announce_entry ();
│ │ │
│ │ │ enum tracker_source
│ │ │ {
│ │ │ source_torrent,
│ │ │ source_client,
│ │ │ source_magnet_link,
│ │ │ @@ -154,23 +154,23 @@
│ │ │ 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() announce_entry() operator=()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
announce_entry() ~announce_entry() operator=()
│ │ │
│ │ │ -announce_entry& operator= (announce_entry const&) &;
│ │ │ -announce_entry (announce_entry const&);
│ │ │ ~announce_entry ();
│ │ │ explicit announce_entry (string_view u);
│ │ │ +announce_entry (announce_entry const&);
│ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ announce_entry ();
│ │ │
│ │ │
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.11
│ │ │ │ _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_(_)_ _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_(_)_ _~_a_n_n_o_u_n_c_e___e_n_t_r_y_(_)_ _o_p_e_r_a_t_o_r_=_(_)
│ │ │ │ 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,18 +78,18 @@
│ │ │ │ [_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&);
│ │ │ │ ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ + aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ + announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ aannnnoouunnccee__eennttrryy ();
│ │ │ │
│ │ │ │ enum tracker_source
│ │ │ │ {
│ │ │ │ source_torrent,
│ │ │ │ source_client,
│ │ │ │ source_magnet_link,
│ │ │ │ @@ -101,19 +101,19 @@
│ │ │ │ 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(()) aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) **********
│ │ │ │ -announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ -aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ +********** aannnnoouunnccee__eennttrryy(()) ~~aannnnoouunnccee__eennttrryy(()) ooppeerraattoorr==(()) **********
│ │ │ │ ~~aannnnoouunnccee__eennttrryy ();
│ │ │ │ explicit aannnnoouunnccee__eennttrryy (string_view u);
│ │ │ │ +aannnnoouunnccee__eennttrryy (announce_entry const&);
│ │ │ │ +announce_entry& ooppeerraattoorr== (announce_entry const&) &;
│ │ │ │ aannnnoouunnccee__eennttrryy ();
│ │ │ │ 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_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Utility.html
│ │ │ @@ -47,22 +47,22 @@
│ │ │ - swap()
│ │ │ - count()
│ │ │ - find_first_set()
│ │ │ - find_last_clear()
│ │ │
│ │ │
│ │ │ - hasher
│ │ │
│ │ │ - hasher256
│ │ │
│ │ │
│ │ │
│ │ │ @@ -70,49 +70,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 (bitfield const& rhs);
│ │ │ bitfield (int bits, bool val);
│ │ │ - bitfield () noexcept = default;
│ │ │ + bitfield (char const* b, int bits);
│ │ │ explicit bitfield (int bits);
│ │ │ + bitfield () noexcept = default;
│ │ │ + bitfield (bitfield const& rhs);
│ │ │ bitfield (bitfield&& rhs) noexcept = default;
│ │ │ - bitfield (char const* b, int bits);
│ │ │ void assign (char const* b, int const bits);
│ │ │ bool get_bit (int index) const noexcept;
│ │ │ bool operator[] (int index) const noexcept;
│ │ │ - void clear_bit (int index) 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 (bitfield const& rhs);
│ │ │ bitfield (int bits, bool val);
│ │ │ -bitfield () noexcept = default;
│ │ │ +bitfield (char const* b, int bits);
│ │ │ explicit bitfield (int bits);
│ │ │ +bitfield () noexcept = default;
│ │ │ +bitfield (bitfield const& rhs);
│ │ │ bitfield (bitfield&& rhs) noexcept = default;
│ │ │ -bitfield (char const* b, int bits);
│ │ │
│ │ │
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
│ │ │ @@ -135,16 +135,16 @@
│ │ │
│ │ │
query bit at index. Returns true if bit is 1, otherwise false.
│ │ │
│ │ │
[report issue]
│ │ │
│ │ │
set_bit() clear_bit()
│ │ │
│ │ │ -void clear_bit (int index) noexcept;
│ │ │ 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]
│ │ │
│ │ │
all_set()
│ │ │
│ │ │ bool all_set () const noexcept;
│ │ │ @@ -187,16 +187,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()
│ │ │
│ │ │ @@ -242,32 +242,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 ();
│ │ │ - hasher (char const* data, int len);
│ │ │ + hasher& operator= (hasher const&) &;
│ │ │ explicit hasher (span<char const> data);
│ │ │ hasher (hasher const&);
│ │ │ - hasher& operator= (hasher const&) &;
│ │ │ + hasher (char const* data, int len);
│ │ │ hasher& update (char const* data, int len);
│ │ │ hasher& update (span<char const> data);
│ │ │ sha1_hash final ();
│ │ │ void reset ();
│ │ │ };
│ │ │
│ │ │ -
│ │ │ -[report issue]
│ │ │ -
hasher() operator=()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
operator=() hasher()
│ │ │
│ │ │ -hasher (char const* data, int len);
│ │ │ +hasher& operator= (hasher const&) &;
│ │ │ explicit hasher (span<char const> data);
│ │ │ hasher (hasher const&);
│ │ │ -hasher& operator= (hasher const&) &;
│ │ │ +hasher (char const* data, int len);
│ │ │
│ │ │
this is the same as default constructing followed by a call to
│ │ │ update(data, len).
│ │ │
[report issue]
│ │ │
│ │ │
update()
│ │ │
│ │ │ @@ -296,42 +296,42 @@
│ │ │
│ │ │
hasher256
│ │ │
Declared in "libtorrent/hasher.hpp"
│ │ │
│ │ │ class hasher256
│ │ │ {
│ │ │ hasher256 ();
│ │ │ - hasher256& operator= (hasher256 const&) &;
│ │ │ - explicit hasher256 (span<char const> data);
│ │ │ hasher256 (hasher256 const&);
│ │ │ hasher256 (char const* data, int len);
│ │ │ - hasher256& update (char const* data, int len);
│ │ │ + explicit hasher256 (span<char const> data);
│ │ │ + hasher256& operator= (hasher256 const&) &;
│ │ │ hasher256& update (span<char const> data);
│ │ │ + hasher256& update (char const* data, int len);
│ │ │ sha256_hash final ();
│ │ │ void reset ();
│ │ │ ~hasher256 ();
│ │ │ };
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
operator=() hasher256()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
hasher256() operator=()
│ │ │
│ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ -explicit hasher256 (span<char const> data);
│ │ │ hasher256 (hasher256 const&);
│ │ │ hasher256 (char const* data, int len);
│ │ │ +explicit hasher256 (span<char const> data);
│ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │
│ │ │
this is the same as default constructing followed by a call to
│ │ │ update(data, len).
│ │ │
[report issue]
│ │ │
│ │ │
update()
│ │ │
│ │ │ -hasher256& update (char const* data, int len);
│ │ │ hasher256& update (span<char const> data);
│ │ │ +hasher256& update (char const* data, int len);
│ │ │
│ │ │
append the following bytes to what is being hashed
│ │ │
[report issue]
│ │ │
│ │ │
final()
│ │ │
│ │ │ sha256_hash final ();
│ │ │ ├── html2text {}
│ │ │ │ @@ -16,63 +16,63 @@
│ │ │ │ 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_(_)
│ │ │ │ [_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 const& rhs);
│ │ │ │ bbiittffiieelldd (int bits, bool val);
│ │ │ │ - bbiittffiieelldd () noexcept = default;
│ │ │ │ + bbiittffiieelldd (char const* b, int bits);
│ │ │ │ explicit bbiittffiieelldd (int bits);
│ │ │ │ + bbiittffiieelldd () noexcept = default;
│ │ │ │ + bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ - bbiittffiieelldd (char const* b, int bits);
│ │ │ │ void aassssiiggnn (char const* b, int const bits);
│ │ │ │ bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ bool ooppeerraattoorr[[]] (int index) const noexcept;
│ │ │ │ - void cclleeaarr__bbiitt (int index) 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 const* ddaattaa () const noexcept;
│ │ │ │ char* ddaattaa () noexcept;
│ │ │ │ + char const* ddaattaa () const 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 const& rhs);
│ │ │ │ bbiittffiieelldd (int bits, bool val);
│ │ │ │ -bbiittffiieelldd () noexcept = default;
│ │ │ │ +bbiittffiieelldd (char const* b, int bits);
│ │ │ │ explicit bbiittffiieelldd (int bits);
│ │ │ │ +bbiittffiieelldd () noexcept = default;
│ │ │ │ +bbiittffiieelldd (bitfield const& rhs);
│ │ │ │ bbiittffiieelldd (bitfield&& rhs) noexcept = default;
│ │ │ │ -bbiittffiieelldd (char const* b, int bits);
│ │ │ │ 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]
│ │ │ │ @@ -83,16 +83,16 @@
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ********** ooppeerraattoorr[[]](()) ggeett__bbiitt(()) **********
│ │ │ │ bool ggeett__bbiitt (int index) const noexcept;
│ │ │ │ bool ooppeerraattoorr[[]] (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]
│ │ │ │ ********** sseett__bbiitt(()) cclleeaarr__bbiitt(()) **********
│ │ │ │ -void cclleeaarr__bbiitt (int index) noexcept;
│ │ │ │ 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
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ********** nnoonnee__sseett(()) **********
│ │ │ │ @@ -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 const* ddaattaa () const noexcept;
│ │ │ │ char* ddaattaa () noexcept;
│ │ │ │ +char const* ddaattaa () const 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,29 +151,29 @@
│ │ │ │ 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 (char const* data, int len);
│ │ │ │ + hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ explicit hhaasshheerr (span data);
│ │ │ │ hhaasshheerr (hasher const&);
│ │ │ │ - hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ + hhaasshheerr (char const* data, int len);
│ │ │ │ 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]
│ │ │ │ -********** hhaasshheerr(()) ooppeerraattoorr==(()) **********
│ │ │ │ -hhaasshheerr (char const* data, int len);
│ │ │ │ +********** ooppeerraattoorr==(()) hhaasshheerr(()) **********
│ │ │ │ +hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ explicit hhaasshheerr (span data);
│ │ │ │ hhaasshheerr (hasher const&);
│ │ │ │ -hasher& ooppeerraattoorr== (hasher const&) &;
│ │ │ │ +hhaasshheerr (char const* data, int len);
│ │ │ │ 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 (char const* data, int len);
│ │ │ │ hasher& uuppddaattee (span data);
│ │ │ │ append the following bytes to what is being hashed
│ │ │ │ @@ -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 ();
│ │ │ │ - hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ - explicit hhaasshheerr225566 (span data);
│ │ │ │ hhaasshheerr225566 (hasher256 const&);
│ │ │ │ hhaasshheerr225566 (char const* data, int len);
│ │ │ │ - hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ + explicit hhaasshheerr225566 (span data);
│ │ │ │ + hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ hasher256& uuppddaattee (span data);
│ │ │ │ + hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ sha256_hash ffiinnaall ();
│ │ │ │ void rreesseett ();
│ │ │ │ ~~hhaasshheerr225566 ();
│ │ │ │ };
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ooppeerraattoorr==(()) hhaasshheerr225566(()) **********
│ │ │ │ -hasher256& ooppeerraattoorr== (hasher256 const&) &;
│ │ │ │ -explicit hhaasshheerr225566 (span data);
│ │ │ │ +********** hhaasshheerr225566(()) ooppeerraattoorr==(()) **********
│ │ │ │ hhaasshheerr225566 (hasher256 const&);
│ │ │ │ hhaasshheerr225566 (char const* data, int len);
│ │ │ │ +explicit hhaasshheerr225566 (span data);
│ │ │ │ +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 (char const* data, int len);
│ │ │ │ hasher256& uuppddaattee (span data);
│ │ │ │ +hasher256& uuppddaattee (char const* data, int len);
│ │ │ │ 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
│ │ │ @@ -19,214 +19,214 @@
│ │ │ 
│ │ │
│ │ │
│ │ │
reference documentation
│ │ │
│ │ │
single-page version
│ │ │
│ │ │ -
Session
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
Torrent Info
│ │ │ +
Stats
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
Core
│ │ │
│ │ │ -
│ │ │ +
│ │ │
│ │ │ +
│ │ │
│ │ │ -
│ │ │
│ │ │ -
│ │ │
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │
│ │ │ -
│ │ │ +
│ │ │
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ -
│ │ │
│ │ │
│ │ │ +
Trackers
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
Session
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
Torrent Status
│ │ │ +
│ │ │
Add Torrent
│ │ │
│ │ │ -
│ │ │
│ │ │ +
│ │ │
│ │ │
Torrent Handle
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ -
Stats
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
Torrent Status
│ │ │ -
│ │ │ -
Trackers
│ │ │ +
Torrent Info
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
Settings
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │
│ │ │ +
│ │ │
│ │ │ +
│ │ │ +
│ │ │
│ │ │
DHT
│ │ │
│ │ │ -
│ │ │
│ │ │
│ │ │ -
│ │ │ +
│ │ │
│ │ │ +
│ │ │
│ │ │
│ │ │
Resume Data
│ │ │
│ │ │
│ │ │ -
│ │ │
│ │ │ -
│ │ │ +
│ │ │
│ │ │ +
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
Error Codes
│ │ │
│ │ │
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ -
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │
│ │ │
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │ +
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │
│ │ │
│ │ │ -
Filter
│ │ │ +
Create Torrents
│ │ │
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
Bencoding
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
│ │ │ -
│ │ │ -
Create Torrents
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │
│ │ │
Bdecoding
│ │ │
│ │ │ +
Filter
│ │ │ +
│ │ │
│ │ │
│ │ │ -
Plugins
│ │ │ +
Custom Storage
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
PeerClass
│ │ │ +
│ │ │
Storage
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
│ │ │ +
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ -
PeerClass
│ │ │ -
│ │ │ -
Custom Storage
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │
Utility
│ │ │
│ │ │ +
Plugins
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
ed25519
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ @@ -334,19 +334,19 @@
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ -
│ │ │
│ │ │ +
│ │ │
│ │ │
│ │ │ -
│ │ │ +
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ ├── html2text {}
│ │ │ │ @@ -1,165 +1,165 @@
│ │ │ │ >
│ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ ************ 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___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
│ │ │ │ +Stats
│ │ │ │ +_c_o_u_n_t_e_r_s
│ │ │ │ +_s_t_a_t_s___m_e_t_r_i_c
│ │ │ │ +_s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_)
│ │ │ │ +_f_i_n_d___m_e_t_r_i_c___i_d_x_(_)
│ │ │ │ +_m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ Core
│ │ │ │ -_p_e_e_r___i_n_f_o
│ │ │ │ +_p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ _i_n_f_o___h_a_s_h___t
│ │ │ │ +_p_e_e_r___i_n_f_o
│ │ │ │ _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___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_(_)
│ │ │ │ +_t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ +_t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ _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
│ │ │ │ +_c_o_n_n_e_c_t_i_o_n___t_y_p_e
│ │ │ │ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ +_e_v_e_n_t___t
│ │ │ │ +_s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ _p_o_r_t_m_a_p___t_r_a_n_s_p_o_r_t
│ │ │ │ _p_o_r_t_m_a_p___p_r_o_t_o_c_o_l
│ │ │ │ -_e_v_e_n_t___t
│ │ │ │ -_c_o_n_n_e_c_t_i_o_n___t_y_p_e
│ │ │ │ _d_o_w_n_l_o_a_d___p_r_i_o_r_i_t_y___t
│ │ │ │ +_p_e_x___f_l_a_g_s___t
│ │ │ │ _i_n_t
│ │ │ │ _c_h_a_r_ _c_o_n_s_t_*
│ │ │ │ _s_t_d_:_:_u_i_n_t_6_4___t
│ │ │ │ -_p_e_x___f_l_a_g_s___t
│ │ │ │ _t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ +Trackers
│ │ │ │ +_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
│ │ │ │ +Session
│ │ │ │ +_s_e_s_s_i_o_n___p_a_r_a_m_s
│ │ │ │ +_s_e_s_s_i_o_n___h_a_n_d_l_e
│ │ │ │ +_s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ +_s_e_s_s_i_o_n
│ │ │ │ +_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_(_)
│ │ │ │ +Torrent Status
│ │ │ │ +_t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ Add Torrent
│ │ │ │ -_c_l_i_e_n_t___d_a_t_a___t
│ │ │ │ _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ +_c_l_i_e_n_t___d_a_t_a___t
│ │ │ │ Torrent Handle
│ │ │ │ _b_l_o_c_k___i_n_f_o
│ │ │ │ _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
│ │ │ │ _h_a_s_h___v_a_l_u_e_(_)
│ │ │ │ -Stats
│ │ │ │ -_c_o_u_n_t_e_r_s
│ │ │ │ -_s_t_a_t_s___m_e_t_r_i_c
│ │ │ │ -_s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_)
│ │ │ │ -_f_i_n_d___m_e_t_r_i_c___i_d_x_(_)
│ │ │ │ -_m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ -Torrent Status
│ │ │ │ -_t_o_r_r_e_n_t___s_t_a_t_u_s
│ │ │ │ -Trackers
│ │ │ │ -_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
│ │ │ │ +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
│ │ │ │ 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_(_)
│ │ │ │ -_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_(_)
│ │ │ │ +_n_a_m_e___f_o_r___s_e_t_t_i_n_g_(_)
│ │ │ │ _d_e_f_a_u_l_t___s_e_t_t_i_n_g_s_(_)
│ │ │ │ +_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_(_)
│ │ │ │ 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___s_t_a_t_e
│ │ │ │ _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_(_)
│ │ │ │ +_s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ _a_n_n_o_u_n_c_e___f_l_a_g_s___t
│ │ │ │ Resume Data
│ │ │ │ _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___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
│ │ │ │ Error Codes
│ │ │ │ _s_t_o_r_a_g_e___e_r_r_o_r
│ │ │ │ +_g_z_i_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ +_p_c_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ +_s_o_c_k_s___c_a_t_e_g_o_r_y_(_)
│ │ │ │ +_i_2_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ _l_i_b_t_o_r_r_e_n_t___c_a_t_e_g_o_r_y_(_)
│ │ │ │ _h_t_t_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ -_g_z_i_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ _u_p_n_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ -_i_2_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ -_s_o_c_k_s___c_a_t_e_g_o_r_y_(_)
│ │ │ │ -_p_c_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ _b_d_e_c_o_d_e___c_a_t_e_g_o_r_y_(_)
│ │ │ │ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ -_h_t_t_p___e_r_r_o_r_s
│ │ │ │ +_p_c_p___e_r_r_o_r_s
│ │ │ │ +_s_o_c_k_s___e_r_r_o_r___c_o_d_e
│ │ │ │ +_i_2_p___e_r_r_o_r___c_o_d_e
│ │ │ │ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ +_h_t_t_p___e_r_r_o_r_s
│ │ │ │ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ -_i_2_p___e_r_r_o_r___c_o_d_e
│ │ │ │ -_s_o_c_k_s___e_r_r_o_r___c_o_d_e
│ │ │ │ -_p_c_p___e_r_r_o_r_s
│ │ │ │ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ -Filter
│ │ │ │ -_i_p___f_i_l_t_e_r
│ │ │ │ -_p_o_r_t___f_i_l_t_e_r
│ │ │ │ -Bencoding
│ │ │ │ -_o_v_e_r_v_i_e_w
│ │ │ │ -_e_n_t_r_y
│ │ │ │ -_o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ -_b_e_n_c_o_d_e_(_)
│ │ │ │ Create Torrents
│ │ │ │ _o_v_e_r_v_i_e_w
│ │ │ │ _c_r_e_a_t_e___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_(_)
│ │ │ │ +Bencoding
│ │ │ │ +_o_v_e_r_v_i_e_w
│ │ │ │ +_e_n_t_r_y
│ │ │ │ +_b_e_n_c_o_d_e_(_)
│ │ │ │ +_o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ Bdecoding
│ │ │ │ _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ _p_r_i_n_t___e_n_t_r_y_(_)
│ │ │ │ _b_d_e_c_o_d_e_(_)
│ │ │ │ -Plugins
│ │ │ │ +Filter
│ │ │ │ +_i_p___f_i_l_t_e_r
│ │ │ │ +_p_o_r_t___f_i_l_t_e_r
│ │ │ │ +Custom Storage
│ │ │ │ _o_v_e_r_v_i_e_w
│ │ │ │ -_p_l_u_g_i_n
│ │ │ │ -_t_o_r_r_e_n_t___p_l_u_g_i_n
│ │ │ │ -_p_e_e_r___p_l_u_g_i_n
│ │ │ │ -_c_r_y_p_t_o___p_l_u_g_i_n
│ │ │ │ -_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_(_)
│ │ │ │ -_c_r_e_a_t_e___s_m_a_r_t___b_a_n___p_l_u_g_i_n_(_)
│ │ │ │ -_c_r_e_a_t_e___u_t___m_e_t_a_d_a_t_a___p_l_u_g_i_n_(_)
│ │ │ │ +_d_i_s_k___o_b_s_e_r_v_e_r
│ │ │ │ +_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
│ │ │ │ +_s_t_o_r_a_g_e___h_o_l_d_e_r
│ │ │ │ +_s_e_t_t_i_n_g_s___i_n_t_e_r_f_a_c_e
│ │ │ │ +_b_u_f_f_e_r___a_l_l_o_c_a_t_o_r___i_n_t_e_r_f_a_c_e
│ │ │ │ +_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r
│ │ │ │ +_f_i_l_e___o_p_e_n___m_o_d_e___t
│ │ │ │ +PeerClass
│ │ │ │ +_p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r
│ │ │ │ +_p_e_e_r___c_l_a_s_s___i_n_f_o
│ │ │ │ Storage
│ │ │ │ _f_i_l_e___s_l_i_c_e
│ │ │ │ _f_i_l_e___s_t_o_r_a_g_e
│ │ │ │ _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_(_)
│ │ │ │ _p_o_s_i_x___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_(_)
│ │ │ │ _d_e_f_a_u_l_t___d_i_s_k___i_o___c_o_n_s_t_r_u_c_t_o_r_(_)
│ │ │ │ _s_t_o_r_a_g_e___m_o_d_e___t
│ │ │ │ _s_t_a_t_u_s___t
│ │ │ │ _m_o_v_e___f_l_a_g_s___t
│ │ │ │ -PeerClass
│ │ │ │ -_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
│ │ │ │ -Custom Storage
│ │ │ │ -_o_v_e_r_v_i_e_w
│ │ │ │ -_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
│ │ │ │ -_s_t_o_r_a_g_e___h_o_l_d_e_r
│ │ │ │ -_d_i_s_k___o_b_s_e_r_v_e_r
│ │ │ │ -_b_u_f_f_e_r___a_l_l_o_c_a_t_o_r___i_n_t_e_r_f_a_c_e
│ │ │ │ -_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r
│ │ │ │ -_s_e_t_t_i_n_g_s___i_n_t_e_r_f_a_c_e
│ │ │ │ -_f_i_l_e___o_p_e_n___m_o_d_e___t
│ │ │ │ Utility
│ │ │ │ _b_i_t_f_i_e_l_d
│ │ │ │ _h_a_s_h_e_r
│ │ │ │ _h_a_s_h_e_r_2_5_6
│ │ │ │ +Plugins
│ │ │ │ +_o_v_e_r_v_i_e_w
│ │ │ │ +_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
│ │ │ │ +_p_l_u_g_i_n
│ │ │ │ +_t_o_r_r_e_n_t___p_l_u_g_i_n
│ │ │ │ +_p_e_e_r___p_l_u_g_i_n
│ │ │ │ +_c_r_y_p_t_o___p_l_u_g_i_n
│ │ │ │ +_c_r_e_a_t_e___s_m_a_r_t___b_a_n___p_l_u_g_i_n_(_)
│ │ │ │ +_c_r_e_a_t_e___u_t___p_e_x___p_l_u_g_i_n_(_)
│ │ │ │ +_c_r_e_a_t_e___u_t___m_e_t_a_d_a_t_a___p_l_u_g_i_n_(_)
│ │ │ │ ed25519
│ │ │ │ _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_(_)
│ │ │ │ @@ -262,16 +262,16 @@
│ │ │ │ _o_v_e_r_s_i_z_e_d___f_i_l_e___a_l_e_r_t
│ │ │ │ _t_o_r_r_e_n_t___c_o_n_f_l_i_c_t___a_l_e_r_t
│ │ │ │ _p_e_e_r___i_n_f_o___a_l_e_r_t
│ │ │ │ _f_i_l_e___p_r_o_g_r_e_s_s___a_l_e_r_t
│ │ │ │ _p_i_e_c_e___i_n_f_o___a_l_e_r_t
│ │ │ │ _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y___a_l_e_r_t
│ │ │ │ _t_r_a_c_k_e_r___l_i_s_t___a_l_e_r_t
│ │ │ │ -_a_l_e_r_t___c_a_s_t_(_)
│ │ │ │ _o_p_e_r_a_t_i_o_n___n_a_m_e_(_)
│ │ │ │ +_a_l_e_r_t___c_a_s_t_(_)
│ │ │ │ _o_p_e_r_a_t_i_o_n___t
│ │ │ │ _a_l_e_r_t___c_a_t_e_g_o_r_y___t
│ │ │ │ _i_n_t
│ │ │ │ _h_o_m_e
│ │ │ │ _b_l_o_g
│ │ │ │ _u_T_P
│ │ │ │ _d_o_w_n_l_o_a_d
│ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/single-page-ref.html
│ │ │ @@ -28,3813 +28,980 @@
│ │ │
2.0.11 |
│ │ │
│ │ │
│ │ │
home
│ │ │
│ │ │
Table of contents
│ │ │
│ │ │ -
[report issue]
│ │ │ -
storage_error
│ │ │ -
Declared in "libtorrent/error_code.hpp"
│ │ │ -
used by storage to return errors
│ │ │ -also includes which underlying file the
│ │ │ -error happened on
│ │ │ +
[report issue]
│ │ │ +
counters
│ │ │ +
Declared in "libtorrent/performance_counters.hpp"
│ │ │
│ │ │ -struct storage_error
│ │ │ +struct counters
│ │ │ {
│ │ │ - explicit operator bool () const;
│ │ │ - file_index_t file () const;
│ │ │ - void file (file_index_t f);
│ │ │ -
│ │ │ - error_code ec;
│ │ │ - operation_t operation;
│ │ │ + 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 ;
│ │ │ + void blend_stats_counter (int c, std::int64_t value, int ratio) ;
│ │ │ + void set_value (int c, std::int64_t value) ;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
bool()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
inc_stats_counter() operator[]()
│ │ │
│ │ │ -explicit operator bool () const;
│ │ │ +std::int64_t inc_stats_counter (int c, std::int64_t value = 1) ;
│ │ │ +std::int64_t operator[] (int i) const ;
│ │ │
│ │ │ -
explicitly converts to true if this object represents an error, and
│ │ │ -false if it does not.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
file()
│ │ │ +
returns the new value
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
stats_metric
│ │ │ +
Declared in "libtorrent/session_stats.hpp"
│ │ │ +
describes one statistics metric from the session. For more information,
│ │ │ +see the session statistics section.
│ │ │
│ │ │ -file_index_t file () const;
│ │ │ -void file (file_index_t f);
│ │ │ +struct stats_metric
│ │ │ +{
│ │ │ + char const* name;
│ │ │ + int value_index;
│ │ │ + metric_type_t type;
│ │ │ +};
│ │ │
│ │ │ -
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
│ │ │ +[report issue]
│ │ │ +- name
│ │ │ +- the name of the counter or gauge
│ │ │
│ │ │ -[report issue]
│ │ │ -- operation
│ │ │ -- A code from operation_t enum, indicating what
│ │ │ -kind of operation failed.
│ │ │ +
│ │ │ +[report issue]
│ │ │ +- value_index type
│ │ │ +- the index into the session stats array, where the underlying value of
│ │ │ +this counter or gauge is found. The session stats array is part of the
│ │ │ +session_stats_alert object.
│ │ │
│ │ │ -[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
libtorrent_category()
│ │ │ -
Declared in "libtorrent/error_code.hpp"
│ │ │ -
│ │ │ -boost::system::error_category& libtorrent_category ();
│ │ │ -
│ │ │ -
return the instance of the libtorrent_error_category which
│ │ │ -maps libtorrent error codes to human readable error messages.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
http_category()
│ │ │ -
Declared in "libtorrent/error_code.hpp"
│ │ │ -
│ │ │ -boost::system::error_category& http_category ();
│ │ │ -
│ │ │ -
returns the error_category for HTTP errors
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
gzip_category()
│ │ │ -
Declared in "libtorrent/gzip.hpp"
│ │ │ -
│ │ │ -boost::system::error_category& gzip_category ();
│ │ │ -
│ │ │ -
get the error_category for zip errors
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
upnp_category()
│ │ │ -
Declared in "libtorrent/upnp.hpp"
│ │ │ -
│ │ │ -boost::system::error_category& upnp_category ();
│ │ │ -
│ │ │ -
the boost.system error category for UPnP errors
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
i2p_category()
│ │ │ -
Declared in "libtorrent/i2p_stream.hpp"
│ │ │ -
│ │ │ -boost::system::error_category& i2p_category ();
│ │ │ -
│ │ │ -
returns the error category for I2P errors
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
socks_category()
│ │ │ -
Declared in "libtorrent/socks5_stream.hpp"
│ │ │ -
│ │ │ -boost::system::error_category& socks_category ();
│ │ │ -
│ │ │ -
returns the error_category for SOCKS5 errors
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
session_stats_metrics()
│ │ │ +
Declared in "libtorrent/session_stats.hpp"
│ │ │
│ │ │ -boost::system::error_category& pcp_category ();
│ │ │ +std::vector<stats_metric> session_stats_metrics ();
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
bdecode_category()
│ │ │ -
Declared in "libtorrent/bdecode.hpp"
│ │ │ +
This free function returns the list of available metrics exposed by
│ │ │ +libtorrent's statistics API. Each metric has a name and a value index.
│ │ │ +The value index is the index into the array in session_stats_alert where
│ │ │ +this metric's value can be found when the session stats is sampled (by
│ │ │ +calling post_session_stats()).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
find_metric_idx()
│ │ │ +
Declared in "libtorrent/session_stats.hpp"
│ │ │
│ │ │ -boost::system::error_category& bdecode_category ();
│ │ │ +int find_metric_idx (string_view name);
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum error_code_enum
│ │ │ -
Declared in "libtorrent/error_code.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| no_error |
│ │ │ -0 |
│ │ │ -Not an error |
│ │ │ -
│ │ │ -| file_collision |
│ │ │ -1 |
│ │ │ -Two torrents has files which end up overwriting each other |
│ │ │ -
│ │ │ -| failed_hash_check |
│ │ │ -2 |
│ │ │ -A piece did not match its piece hash |
│ │ │ -
│ │ │ -| torrent_is_no_dict |
│ │ │ -3 |
│ │ │ -The .torrent file does not contain a bencoded dictionary at
│ │ │ -its top level |
│ │ │ -
│ │ │ -| torrent_missing_info |
│ │ │ -4 |
│ │ │ -The .torrent file does not have an info dictionary |
│ │ │ -
│ │ │ -| torrent_info_no_dict |
│ │ │ -5 |
│ │ │ -The .torrent file's info entry is not a dictionary |
│ │ │ -
│ │ │ -| torrent_missing_piece_length |
│ │ │ -6 |
│ │ │ -The .torrent file does not have a piece length entry |
│ │ │ -
│ │ │ -| torrent_missing_name |
│ │ │ -7 |
│ │ │ -The .torrent file does not have a name entry |
│ │ │ -
│ │ │ -| torrent_invalid_name |
│ │ │ -8 |
│ │ │ -The .torrent file's name entry is invalid |
│ │ │ -
│ │ │ -| torrent_invalid_length |
│ │ │ -9 |
│ │ │ -The length of a file, or of the whole .torrent file is invalid.
│ │ │ -Either negative or not an integer |
│ │ │ -
│ │ │ -| torrent_file_parse_failed |
│ │ │ -10 |
│ │ │ -Failed to parse a file entry in the .torrent |
│ │ │ -
│ │ │ -| torrent_missing_pieces |
│ │ │ -11 |
│ │ │ -The pieces field is missing or invalid in the .torrent file |
│ │ │ -
│ │ │ -| torrent_invalid_hashes |
│ │ │ -12 |
│ │ │ -The pieces string has incorrect length |
│ │ │ -
│ │ │ -| too_many_pieces_in_torrent |
│ │ │ -13 |
│ │ │ -The .torrent file has more pieces than is supported by libtorrent |
│ │ │ -
│ │ │ -| invalid_swarm_metadata |
│ │ │ -14 |
│ │ │ -The metadata (.torrent file) that was received from the swarm
│ │ │ -matched the info-hash, but failed to be parsed |
│ │ │ -
│ │ │ -| invalid_bencoding |
│ │ │ -15 |
│ │ │ -The file or buffer is not correctly bencoded |
│ │ │ -
│ │ │ -| no_files_in_torrent |
│ │ │ -16 |
│ │ │ -The .torrent file does not contain any files |
│ │ │ -
│ │ │ -| invalid_escaped_string |
│ │ │ -17 |
│ │ │ -The string was not properly url-encoded as expected |
│ │ │ -
│ │ │ -| session_is_closing |
│ │ │ -18 |
│ │ │ -Operation is not permitted since the session is shutting down |
│ │ │ -
│ │ │ -| duplicate_torrent |
│ │ │ -19 |
│ │ │ -There's already a torrent with that info-hash added to the
│ │ │ -session |
│ │ │ -
│ │ │ -| invalid_torrent_handle |
│ │ │ -20 |
│ │ │ -The supplied torrent_handle is not referring to a valid torrent |
│ │ │ -
│ │ │ -| invalid_entry_type |
│ │ │ -21 |
│ │ │ -The type requested from the entry did not match its type |
│ │ │ -
│ │ │ -| missing_info_hash_in_uri |
│ │ │ -22 |
│ │ │ -The specified URI does not contain a valid info-hash |
│ │ │ -
│ │ │ -| file_too_short |
│ │ │ -23 |
│ │ │ -One of the files in the torrent was unexpectedly small. This
│ │ │ -might be caused by files being changed by an external process |
│ │ │ -
│ │ │ -| unsupported_url_protocol |
│ │ │ -24 |
│ │ │ -The URL used an unknown protocol. Currently http and
│ │ │ -https (if built with openssl support) are recognized. For
│ │ │ -trackers udp is recognized as well. |
│ │ │ -
│ │ │ -| url_parse_error |
│ │ │ -25 |
│ │ │ -The URL did not conform to URL syntax and failed to be parsed |
│ │ │ -
│ │ │ -| peer_sent_empty_piece |
│ │ │ -26 |
│ │ │ -The peer sent a piece message of length 0 |
│ │ │ -
│ │ │ -| parse_failed |
│ │ │ -27 |
│ │ │ -A bencoded structure was corrupt and failed to be parsed |
│ │ │ -
│ │ │ -| invalid_file_tag |
│ │ │ -28 |
│ │ │ -The fast resume file was missing or had an invalid file version
│ │ │ -tag |
│ │ │ -
│ │ │ -| missing_info_hash |
│ │ │ -29 |
│ │ │ -The fast resume file was missing or had an invalid info-hash |
│ │ │ -
│ │ │ -| mismatching_info_hash |
│ │ │ -30 |
│ │ │ -The info-hash did not match the torrent |
│ │ │ -
│ │ │ -| invalid_hostname |
│ │ │ -31 |
│ │ │ -The URL contained an invalid hostname |
│ │ │ -
│ │ │ -| invalid_port |
│ │ │ -32 |
│ │ │ -The URL had an invalid port |
│ │ │ -
│ │ │ -| port_blocked |
│ │ │ -33 |
│ │ │ -The port is blocked by the port-filter, and prevented the
│ │ │ -connection |
│ │ │ -
│ │ │ -| expected_close_bracket_in_address |
│ │ │ -34 |
│ │ │ -The IPv6 address was expected to end with "]" |
│ │ │ -
│ │ │ -| destructing_torrent |
│ │ │ -35 |
│ │ │ -The torrent is being destructed, preventing the operation to
│ │ │ -succeed |
│ │ │ -
│ │ │ -| timed_out |
│ │ │ -36 |
│ │ │ -The connection timed out |
│ │ │ -
│ │ │ -| upload_upload_connection |
│ │ │ -37 |
│ │ │ -The peer is upload only, and we are upload only. There's no point
│ │ │ -in keeping the connection |
│ │ │ -
│ │ │ -| uninteresting_upload_peer |
│ │ │ -38 |
│ │ │ -The peer is upload only, and we're not interested in it. There's
│ │ │ -no point in keeping the connection |
│ │ │ -
│ │ │ -| invalid_info_hash |
│ │ │ -39 |
│ │ │ -The peer sent an unknown info-hash |
│ │ │ -
│ │ │ -| torrent_paused |
│ │ │ -40 |
│ │ │ -The torrent is paused, preventing the operation from succeeding |
│ │ │ -
│ │ │ -| invalid_have |
│ │ │ -41 |
│ │ │ -The peer sent an invalid have message, either wrong size or
│ │ │ -referring to a piece that doesn't exist in the torrent |
│ │ │ -
│ │ │ -| invalid_bitfield_size |
│ │ │ -42 |
│ │ │ -The bitfield message had the incorrect size |
│ │ │ -
│ │ │ -| too_many_requests_when_choked |
│ │ │ -43 |
│ │ │ -The peer kept requesting pieces after it was choked, possible
│ │ │ -abuse attempt. |
│ │ │ -
│ │ │ -| invalid_piece |
│ │ │ -44 |
│ │ │ -The peer sent a piece message that does not correspond to a
│ │ │ -piece request sent by the client |
│ │ │ -
│ │ │ -| no_memory |
│ │ │ -45 |
│ │ │ -memory allocation failed |
│ │ │ -
│ │ │ -| torrent_aborted |
│ │ │ -46 |
│ │ │ -The torrent is aborted, preventing the operation to succeed |
│ │ │ -
│ │ │ -| self_connection |
│ │ │ -47 |
│ │ │ -The peer is a connection to ourself, no point in keeping it |
│ │ │ -
│ │ │ -| invalid_piece_size |
│ │ │ -48 |
│ │ │ -The peer sent a piece message with invalid size, either negative
│ │ │ -or greater than one block |
│ │ │ -
│ │ │ -| timed_out_no_interest |
│ │ │ -49 |
│ │ │ -The peer has not been interesting or interested in us for too
│ │ │ -long, no point in keeping it around |
│ │ │ -
│ │ │ -| timed_out_inactivity |
│ │ │ -50 |
│ │ │ -The peer has not said anything in a long time, possibly dead |
│ │ │ -
│ │ │ -| timed_out_no_handshake |
│ │ │ -51 |
│ │ │ -The peer did not send a handshake within a reasonable amount of
│ │ │ -time, it might not be a bittorrent peer |
│ │ │ -
│ │ │ -| timed_out_no_request |
│ │ │ -52 |
│ │ │ -The peer has been unchoked for too long without requesting any
│ │ │ -data. It might be lying about its interest in us |
│ │ │ -
│ │ │ -| invalid_choke |
│ │ │ -53 |
│ │ │ -The peer sent an invalid choke message |
│ │ │ -
│ │ │ -| invalid_unchoke |
│ │ │ -54 |
│ │ │ -The peer send an invalid unchoke message |
│ │ │ -
│ │ │ -| invalid_interested |
│ │ │ -55 |
│ │ │ -The peer sent an invalid interested message |
│ │ │ -
│ │ │ -| invalid_not_interested |
│ │ │ -56 |
│ │ │ -The peer sent an invalid not-interested message |
│ │ │ -
│ │ │ -| invalid_request |
│ │ │ -57 |
│ │ │ -The peer sent an invalid piece request message |
│ │ │ -
│ │ │ -| invalid_hash_list |
│ │ │ -58 |
│ │ │ -The peer sent an invalid hash-list message (this is part of the
│ │ │ -merkle-torrent extension) |
│ │ │ -
│ │ │ -| invalid_hash_piece |
│ │ │ -59 |
│ │ │ -The peer sent an invalid hash-piece message (this is part of the
│ │ │ -merkle-torrent extension) |
│ │ │ -
│ │ │ -| invalid_cancel |
│ │ │ -60 |
│ │ │ -The peer sent an invalid cancel message |
│ │ │ -
│ │ │ -| invalid_dht_port |
│ │ │ -61 |
│ │ │ -The peer sent an invalid DHT port-message |
│ │ │ -
│ │ │ -| invalid_suggest |
│ │ │ -62 |
│ │ │ -The peer sent an invalid suggest piece-message |
│ │ │ -
│ │ │ -| invalid_have_all |
│ │ │ -63 |
│ │ │ -The peer sent an invalid have all-message |
│ │ │ -
│ │ │ -| invalid_have_none |
│ │ │ -64 |
│ │ │ -The peer sent an invalid have none-message |
│ │ │ -
│ │ │ -| invalid_reject |
│ │ │ -65 |
│ │ │ -The peer sent an invalid reject message |
│ │ │ -
│ │ │ -| invalid_allow_fast |
│ │ │ -66 |
│ │ │ -The peer sent an invalid allow fast-message |
│ │ │ -
│ │ │ -| invalid_extended |
│ │ │ -67 |
│ │ │ -The peer sent an invalid extension message ID |
│ │ │ -
│ │ │ -| invalid_message |
│ │ │ -68 |
│ │ │ -The peer sent an invalid message ID |
│ │ │ -
│ │ │ -| sync_hash_not_found |
│ │ │ -69 |
│ │ │ -The synchronization hash was not found in the encrypted handshake |
│ │ │ -
│ │ │ -| invalid_encryption_constant |
│ │ │ -70 |
│ │ │ -The encryption constant in the handshake is invalid |
│ │ │ -
│ │ │ -| no_plaintext_mode |
│ │ │ -71 |
│ │ │ -The peer does not support plain text, which is the selected mode |
│ │ │ -
│ │ │ -| no_rc4_mode |
│ │ │ -72 |
│ │ │ -The peer does not support RC4, which is the selected mode |
│ │ │ -
│ │ │ -| unsupported_encryption_mode |
│ │ │ -73 |
│ │ │ -The peer does not support any of the encryption modes that the
│ │ │ -client supports |
│ │ │ -
│ │ │ -| unsupported_encryption_mode_selected |
│ │ │ -74 |
│ │ │ -The peer selected an encryption mode that the client did not
│ │ │ -advertise and does not support |
│ │ │ -
│ │ │ -| invalid_pad_size |
│ │ │ -75 |
│ │ │ -The pad size used in the encryption handshake is of invalid size |
│ │ │ -
│ │ │ -| invalid_encrypt_handshake |
│ │ │ -76 |
│ │ │ -The encryption handshake is invalid |
│ │ │ -
│ │ │ -| no_incoming_encrypted |
│ │ │ -77 |
│ │ │ -The client is set to not support incoming encrypted connections
│ │ │ -and this is an encrypted connection |
│ │ │ -
│ │ │ -| no_incoming_regular |
│ │ │ -78 |
│ │ │ -The client is set to not support incoming regular bittorrent
│ │ │ -connections, and this is a regular connection |
│ │ │ -
│ │ │ -| duplicate_peer_id |
│ │ │ -79 |
│ │ │ -The client is already connected to this peer-ID |
│ │ │ -
│ │ │ -| torrent_removed |
│ │ │ -80 |
│ │ │ -Torrent was removed |
│ │ │ -
│ │ │ -| packet_too_large |
│ │ │ -81 |
│ │ │ -The packet size exceeded the upper sanity check-limit |
│ │ │ -
│ │ │ -| reserved |
│ │ │ -82 |
│ │ │ - |
│ │ │ -
│ │ │ -| http_error |
│ │ │ -83 |
│ │ │ -The web server responded with an error |
│ │ │ -
│ │ │ -| missing_location |
│ │ │ -84 |
│ │ │ -The web server response is missing a location header |
│ │ │ -
│ │ │ -| invalid_redirection |
│ │ │ -85 |
│ │ │ -The web seed redirected to a path that no longer matches the
│ │ │ -.torrent directory structure |
│ │ │ -
│ │ │ -| redirecting |
│ │ │ -86 |
│ │ │ -The connection was closed because it redirected to a different
│ │ │ -URL |
│ │ │ -
│ │ │ -| invalid_range |
│ │ │ -87 |
│ │ │ -The HTTP range header is invalid |
│ │ │ -
│ │ │ -| no_content_length |
│ │ │ -88 |
│ │ │ -The HTTP response did not have a content length |
│ │ │ -
│ │ │ -| banned_by_ip_filter |
│ │ │ -89 |
│ │ │ -The IP is blocked by the IP filter |
│ │ │ -
│ │ │ -| too_many_connections |
│ │ │ -90 |
│ │ │ -At the connection limit |
│ │ │ -
│ │ │ -| peer_banned |
│ │ │ -91 |
│ │ │ -The peer is marked as banned |
│ │ │ -
│ │ │ -| stopping_torrent |
│ │ │ -92 |
│ │ │ -The torrent is stopping, causing the operation to fail |
│ │ │ -
│ │ │ -| too_many_corrupt_pieces |
│ │ │ -93 |
│ │ │ -The peer has sent too many corrupt pieces and is banned |
│ │ │ -
│ │ │ -| torrent_not_ready |
│ │ │ -94 |
│ │ │ -The torrent is not ready to receive peers |
│ │ │ -
│ │ │ -| peer_not_constructed |
│ │ │ -95 |
│ │ │ -The peer is not completely constructed yet |
│ │ │ -
│ │ │ -| session_closing |
│ │ │ -96 |
│ │ │ -The session is closing, causing the operation to fail |
│ │ │ -
│ │ │ -| optimistic_disconnect |
│ │ │ -97 |
│ │ │ -The peer was disconnected in order to leave room for a
│ │ │ -potentially better peer |
│ │ │ -
│ │ │ -| torrent_finished |
│ │ │ -98 |
│ │ │ -The torrent is finished |
│ │ │ -
│ │ │ -| no_router |
│ │ │ -99 |
│ │ │ -No UPnP router found |
│ │ │ -
│ │ │ -| metadata_too_large |
│ │ │ -100 |
│ │ │ -The metadata message says the metadata exceeds the limit |
│ │ │ -
│ │ │ -| invalid_metadata_request |
│ │ │ -101 |
│ │ │ -The peer sent an invalid metadata request message |
│ │ │ -
│ │ │ -| invalid_metadata_size |
│ │ │ -102 |
│ │ │ -The peer advertised an invalid metadata size |
│ │ │ -
│ │ │ -| invalid_metadata_offset |
│ │ │ -103 |
│ │ │ -The peer sent a message with an invalid metadata offset |
│ │ │ -
│ │ │ -| invalid_metadata_message |
│ │ │ -104 |
│ │ │ -The peer sent an invalid metadata message |
│ │ │ -
│ │ │ -| pex_message_too_large |
│ │ │ -105 |
│ │ │ -The peer sent a peer exchange message that was too large |
│ │ │ -
│ │ │ -| invalid_pex_message |
│ │ │ -106 |
│ │ │ -The peer sent an invalid peer exchange message |
│ │ │ -
│ │ │ -| invalid_lt_tracker_message |
│ │ │ -107 |
│ │ │ -The peer sent an invalid tracker exchange message |
│ │ │ -
│ │ │ -| too_frequent_pex |
│ │ │ -108 |
│ │ │ -The peer sent an pex messages too often. This is a possible
│ │ │ -attempt of and attack |
│ │ │ -
│ │ │ -| no_metadata |
│ │ │ -109 |
│ │ │ -The operation failed because it requires the torrent to have
│ │ │ -the metadata (.torrent file) and it doesn't have it yet.
│ │ │ -This happens for magnet links before they have downloaded the
│ │ │ -metadata, and also torrents added by URL. |
│ │ │ -
│ │ │ -| invalid_dont_have |
│ │ │ -110 |
│ │ │ -The peer sent an invalid dont_have message. The don't have
│ │ │ -message is an extension to allow peers to advertise that the
│ │ │ -no longer has a piece they previously had. |
│ │ │ -
│ │ │ -| requires_ssl_connection |
│ │ │ -111 |
│ │ │ -The peer tried to connect to an SSL torrent without connecting
│ │ │ -over SSL. |
│ │ │ -
│ │ │ -| invalid_ssl_cert |
│ │ │ -112 |
│ │ │ -The peer tried to connect to a torrent with a certificate
│ │ │ -for a different torrent. |
│ │ │ -
│ │ │ -| not_an_ssl_torrent |
│ │ │ -113 |
│ │ │ -the torrent is not an SSL torrent, and the operation requires
│ │ │ -an SSL torrent |
│ │ │ -
│ │ │ -| banned_by_port_filter |
│ │ │ -114 |
│ │ │ -peer was banned because its listen port is within a banned port
│ │ │ -range, as specified by the port_filter. |
│ │ │ -
│ │ │ -| invalid_session_handle |
│ │ │ -115 |
│ │ │ -The session_handle is not referring to a valid session_impl |
│ │ │ -
│ │ │ -| invalid_listen_socket |
│ │ │ -116 |
│ │ │ -the listen socket associated with this request was closed |
│ │ │ -
│ │ │ -| invalid_hash_request |
│ │ │ -117 |
│ │ │ - |
│ │ │ -
│ │ │ -| invalid_hashes |
│ │ │ -118 |
│ │ │ - |
│ │ │ -
│ │ │ -| invalid_hash_reject |
│ │ │ -119 |
│ │ │ - |
│ │ │ -
│ │ │ -| deprecated_120 |
│ │ │ -120 |
│ │ │ - |
│ │ │ -
│ │ │ -| deprecated_121 |
│ │ │ -121 |
│ │ │ - |
│ │ │ -
│ │ │ -| deprecated_122 |
│ │ │ -122 |
│ │ │ - |
│ │ │ -
│ │ │ -| deprecated_123 |
│ │ │ -123 |
│ │ │ - |
│ │ │ -
│ │ │ -| deprecated_124 |
│ │ │ -124 |
│ │ │ - |
│ │ │ -
│ │ │ -| missing_file_sizes |
│ │ │ -130 |
│ │ │ -The resume data file is missing the file sizes entry |
│ │ │ -
│ │ │ -| no_files_in_resume_data |
│ │ │ -131 |
│ │ │ -The resume data file file sizes entry is empty |
│ │ │ -
│ │ │ -| missing_pieces |
│ │ │ -132 |
│ │ │ -The resume data file is missing the pieces and slots entry |
│ │ │ -
│ │ │ -| mismatching_number_of_files |
│ │ │ -133 |
│ │ │ -The number of files in the resume data does not match the number
│ │ │ -of files in the torrent |
│ │ │ -
│ │ │ -| mismatching_file_size |
│ │ │ -134 |
│ │ │ -One of the files on disk has a different size than in the fast
│ │ │ -resume file |
│ │ │ -
│ │ │ -| mismatching_file_timestamp |
│ │ │ -135 |
│ │ │ -One of the files on disk has a different timestamp than in the
│ │ │ -fast resume file |
│ │ │ -
│ │ │ -| not_a_dictionary |
│ │ │ -136 |
│ │ │ -The resume data file is not a dictionary |
│ │ │ -
│ │ │ -| invalid_blocks_per_piece |
│ │ │ -137 |
│ │ │ -The blocks per piece entry is invalid in the resume data file |
│ │ │ -
│ │ │ -| missing_slots |
│ │ │ -138 |
│ │ │ -The resume file is missing the slots entry, which is required
│ │ │ -for torrents with compact allocation. DEPRECATED |
│ │ │ -
│ │ │ -| too_many_slots |
│ │ │ -139 |
│ │ │ -The resume file contains more slots than the torrent |
│ │ │ -
│ │ │ -| invalid_slot_list |
│ │ │ -140 |
│ │ │ -The slot entry is invalid in the resume data |
│ │ │ -
│ │ │ -| invalid_piece_index |
│ │ │ -141 |
│ │ │ -One index in the slot list is invalid |
│ │ │ -
│ │ │ -| pieces_need_reorder |
│ │ │ -142 |
│ │ │ -The pieces on disk needs to be re-ordered for the specified
│ │ │ -allocation mode. This happens if you specify sparse allocation
│ │ │ -and the files on disk are using compact storage. The pieces needs
│ │ │ -to be moved to their right position. DEPRECATED |
│ │ │ -
│ │ │ -| resume_data_not_modified |
│ │ │ -143 |
│ │ │ -this error is returned when asking to save resume data and
│ │ │ -specifying the flag to only save when there's anything new to save
│ │ │ -(torrent_handle::only_if_modified) and there wasn't anything changed. |
│ │ │ -
│ │ │ -| invalid_save_path |
│ │ │ -144 |
│ │ │ -the save_path in add_torrent_params is not valid |
│ │ │ -
│ │ │ -| http_parse_error |
│ │ │ -150 |
│ │ │ -The HTTP header was not correctly formatted |
│ │ │ -
│ │ │ -| http_missing_location |
│ │ │ -151 |
│ │ │ -The HTTP response was in the 300-399 range but lacked a location
│ │ │ -header |
│ │ │ -
│ │ │ -| http_failed_decompress |
│ │ │ -152 |
│ │ │ -The HTTP response was encoded with gzip or deflate but
│ │ │ -decompressing it failed |
│ │ │ -
│ │ │ -| no_i2p_router |
│ │ │ -160 |
│ │ │ -The URL specified an i2p address, but no i2p router is configured |
│ │ │ -
│ │ │ -| no_i2p_endpoint |
│ │ │ -161 |
│ │ │ -i2p acceptor is not available yet, can't announce without endpoint |
│ │ │ -
│ │ │ -| scrape_not_available |
│ │ │ -170 |
│ │ │ -The tracker URL doesn't support transforming it into a scrape
│ │ │ -URL. i.e. it doesn't contain "announce. |
│ │ │ -
│ │ │ -| invalid_tracker_response |
│ │ │ -171 |
│ │ │ -invalid tracker response |
│ │ │ -
│ │ │ -| invalid_peer_dict |
│ │ │ -172 |
│ │ │ -invalid peer dictionary entry. Not a dictionary |
│ │ │ -
│ │ │ -| tracker_failure |
│ │ │ -173 |
│ │ │ -tracker sent a failure message |
│ │ │ -
│ │ │ -| invalid_files_entry |
│ │ │ -174 |
│ │ │ -missing or invalid files entry |
│ │ │ -
│ │ │ -| invalid_hash_entry |
│ │ │ -175 |
│ │ │ -missing or invalid hash entry |
│ │ │ -
│ │ │ -| invalid_peers_entry |
│ │ │ -176 |
│ │ │ -missing or invalid peers and peers6 entry |
│ │ │ -
│ │ │ -| invalid_tracker_response_length |
│ │ │ -177 |
│ │ │ -UDP tracker response packet has invalid size |
│ │ │ -
│ │ │ -| invalid_tracker_transaction_id |
│ │ │ -178 |
│ │ │ -invalid transaction id in UDP tracker response |
│ │ │ -
│ │ │ -| invalid_tracker_action |
│ │ │ -179 |
│ │ │ -invalid action field in UDP tracker response |
│ │ │ -
│ │ │ -| announce_skipped |
│ │ │ -180 |
│ │ │ -skipped announce (because it's assumed to be unreachable over the
│ │ │ -given source network interface) |
│ │ │ -
│ │ │ -| no_entropy |
│ │ │ -200 |
│ │ │ -random number generation failed |
│ │ │ -
│ │ │ -| ssrf_mitigation |
│ │ │ -201 |
│ │ │ -blocked by SSRF mitigation |
│ │ │ -
│ │ │ -| blocked_by_idna |
│ │ │ -202 |
│ │ │ -blocked because IDNA host names are banned |
│ │ │ -
│ │ │ -| torrent_unknown_version |
│ │ │ -210 |
│ │ │ -the torrent file has an unknown meta version |
│ │ │ -
│ │ │ -| torrent_missing_file_tree |
│ │ │ -211 |
│ │ │ -the v2 torrent file has no file tree |
│ │ │ -
│ │ │ -| torrent_missing_meta_version |
│ │ │ -212 |
│ │ │ -the torrent contains v2 keys but does not specify meta version 2 |
│ │ │ -
│ │ │ -| torrent_inconsistent_files |
│ │ │ -213 |
│ │ │ -the v1 and v2 file metadata does not match |
│ │ │ -
│ │ │ -| torrent_missing_piece_layer |
│ │ │ -214 |
│ │ │ -one or more files are missing piece layer hashes |
│ │ │ -
│ │ │ -| torrent_invalid_piece_layer |
│ │ │ -215 |
│ │ │ -a piece layer has the wrong size or failed hash check |
│ │ │ -
│ │ │ -| torrent_missing_pieces_root |
│ │ │ -216 |
│ │ │ -a v2 file entry has no root hash |
│ │ │ -
│ │ │ -| torrent_inconsistent_hashes |
│ │ │ -217 |
│ │ │ -the v1 and v2 hashes do not describe the same data |
│ │ │ -
│ │ │ -| torrent_invalid_pad_file |
│ │ │ -218 |
│ │ │ -a file in the v2 metadata has the pad attribute set |
│ │ │ -
│ │ │ -| error_code_max |
│ │ │ -219 |
│ │ │ -the number of error codes |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum http_errors
│ │ │ -
Declared in "libtorrent/error_code.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| cont |
│ │ │ -100 |
│ │ │ - |
│ │ │ -
│ │ │ -| ok |
│ │ │ -200 |
│ │ │ - |
│ │ │ -
│ │ │ -| created |
│ │ │ -201 |
│ │ │ - |
│ │ │ -
│ │ │ -| accepted |
│ │ │ -202 |
│ │ │ - |
│ │ │ -
│ │ │ -| no_content |
│ │ │ -204 |
│ │ │ - |
│ │ │ -
│ │ │ -| multiple_choices |
│ │ │ -300 |
│ │ │ - |
│ │ │ -
│ │ │ -| moved_permanently |
│ │ │ -301 |
│ │ │ - |
│ │ │ -
│ │ │ -| moved_temporarily |
│ │ │ -302 |
│ │ │ - |
│ │ │ -
│ │ │ -| not_modified |
│ │ │ -304 |
│ │ │ - |
│ │ │ -
│ │ │ -| bad_request |
│ │ │ -400 |
│ │ │ - |
│ │ │ -
│ │ │ -| unauthorized |
│ │ │ -401 |
│ │ │ - |
│ │ │ -
│ │ │ -| forbidden |
│ │ │ -403 |
│ │ │ - |
│ │ │ -
│ │ │ -| not_found |
│ │ │ -404 |
│ │ │ - |
│ │ │ -
│ │ │ -| internal_server_error |
│ │ │ -500 |
│ │ │ - |
│ │ │ -
│ │ │ -| not_implemented |
│ │ │ -501 |
│ │ │ - |
│ │ │ -
│ │ │ -| bad_gateway |
│ │ │ -502 |
│ │ │ - |
│ │ │ -
│ │ │ -| service_unavailable |
│ │ │ -503 |
│ │ │ - |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum error_code_enum
│ │ │ -
Declared in "libtorrent/gzip.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| no_error |
│ │ │ -0 |
│ │ │ -Not an error |
│ │ │ -
│ │ │ -| invalid_gzip_header |
│ │ │ -1 |
│ │ │ -the supplied gzip buffer has invalid header |
│ │ │ -
│ │ │ -| inflated_data_too_large |
│ │ │ -2 |
│ │ │ -the gzip buffer would inflate to more bytes than the specified
│ │ │ -maximum size, and was rejected. |
│ │ │ -
│ │ │ -| data_did_not_terminate |
│ │ │ -3 |
│ │ │ -available inflate data did not terminate |
│ │ │ -
│ │ │ -| space_exhausted |
│ │ │ -4 |
│ │ │ -output space exhausted before completing inflate |
│ │ │ -
│ │ │ -| invalid_block_type |
│ │ │ -5 |
│ │ │ -invalid block type (type == 3) |
│ │ │ -
│ │ │ -| invalid_stored_block_length |
│ │ │ -6 |
│ │ │ -stored block length did not match one's complement |
│ │ │ -
│ │ │ -| too_many_length_or_distance_codes |
│ │ │ -7 |
│ │ │ -dynamic block code description: too many length or distance codes |
│ │ │ -
│ │ │ -| code_lengths_codes_incomplete |
│ │ │ -8 |
│ │ │ -dynamic block code description: code lengths codes incomplete |
│ │ │ -
│ │ │ -| repeat_lengths_with_no_first_length |
│ │ │ -9 |
│ │ │ -dynamic block code description: repeat lengths with no first length |
│ │ │ -
│ │ │ -| repeat_more_than_specified_lengths |
│ │ │ -10 |
│ │ │ -dynamic block code description: repeat more than specified lengths |
│ │ │ -
│ │ │ -| invalid_literal_length_code_lengths |
│ │ │ -11 |
│ │ │ -dynamic block code description: invalid literal/length code lengths |
│ │ │ -
│ │ │ -| invalid_distance_code_lengths |
│ │ │ -12 |
│ │ │ -dynamic block code description: invalid distance code lengths |
│ │ │ -
│ │ │ -| invalid_literal_code_in_block |
│ │ │ -13 |
│ │ │ -invalid literal/length or distance code in fixed or dynamic block |
│ │ │ -
│ │ │ -| distance_too_far_back_in_block |
│ │ │ -14 |
│ │ │ -distance is too far back in fixed or dynamic block |
│ │ │ -
│ │ │ -| unknown_gzip_error |
│ │ │ -15 |
│ │ │ -an unknown error occurred during gzip inflation |
│ │ │ -
│ │ │ -| error_code_max |
│ │ │ -16 |
│ │ │ -the number of error codes |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum error_code_enum
│ │ │ -
Declared in "libtorrent/upnp.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| no_error |
│ │ │ -0 |
│ │ │ -No error |
│ │ │ -
│ │ │ -| invalid_argument |
│ │ │ -402 |
│ │ │ -One of the arguments in the request is invalid |
│ │ │ -
│ │ │ -| action_failed |
│ │ │ -501 |
│ │ │ -The request failed |
│ │ │ -
│ │ │ -| value_not_in_array |
│ │ │ -714 |
│ │ │ -The specified value does not exist in the array |
│ │ │ -
│ │ │ -| source_ip_cannot_be_wildcarded |
│ │ │ -715 |
│ │ │ -The source IP address cannot be wild-carded, but
│ │ │ -must be fully specified |
│ │ │ -
│ │ │ -| external_port_cannot_be_wildcarded |
│ │ │ -716 |
│ │ │ -The external port cannot be a wildcard, but must
│ │ │ -be specified |
│ │ │ -
│ │ │ -| port_mapping_conflict |
│ │ │ -718 |
│ │ │ -The port mapping entry specified conflicts with a
│ │ │ -mapping assigned previously to another client |
│ │ │ -
│ │ │ -| internal_port_must_match_external |
│ │ │ -724 |
│ │ │ -Internal and external port value must be the same |
│ │ │ -
│ │ │ -| only_permanent_leases_supported |
│ │ │ -725 |
│ │ │ -The NAT implementation only supports permanent
│ │ │ -lease times on port mappings |
│ │ │ -
│ │ │ -| remote_host_must_be_wildcard |
│ │ │ -726 |
│ │ │ -RemoteHost must be a wildcard and cannot be a
│ │ │ -specific IP address or DNS name |
│ │ │ -
│ │ │ -| external_port_must_be_wildcard |
│ │ │ -727 |
│ │ │ -ExternalPort must be a wildcard and cannot be a
│ │ │ -specific port |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum i2p_error_code
│ │ │ -
Declared in "libtorrent/i2p_stream.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| no_error |
│ │ │ -0 |
│ │ │ - |
│ │ │ -
│ │ │ -| parse_failed |
│ │ │ -1 |
│ │ │ - |
│ │ │ -
│ │ │ -| cant_reach_peer |
│ │ │ -2 |
│ │ │ - |
│ │ │ -
│ │ │ -| i2p_error |
│ │ │ -3 |
│ │ │ - |
│ │ │ -
│ │ │ -| invalid_key |
│ │ │ -4 |
│ │ │ - |
│ │ │ -
│ │ │ -| invalid_id |
│ │ │ -5 |
│ │ │ - |
│ │ │ -
│ │ │ -| timeout |
│ │ │ -6 |
│ │ │ - |
│ │ │ -
│ │ │ -| key_not_found |
│ │ │ -7 |
│ │ │ - |
│ │ │ -
│ │ │ -| duplicated_id |
│ │ │ -8 |
│ │ │ - |
│ │ │ -
│ │ │ -| num_errors |
│ │ │ -9 |
│ │ │ - |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum socks_error_code
│ │ │ -
Declared in "libtorrent/socks5_stream.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| no_error |
│ │ │ -0 |
│ │ │ - |
│ │ │ -
│ │ │ -| unsupported_version |
│ │ │ -1 |
│ │ │ - |
│ │ │ -
│ │ │ -| unsupported_authentication_method |
│ │ │ -2 |
│ │ │ - |
│ │ │ -
│ │ │ -| unsupported_authentication_version |
│ │ │ -3 |
│ │ │ - |
│ │ │ -
│ │ │ -| authentication_error |
│ │ │ -4 |
│ │ │ - |
│ │ │ -
│ │ │ -| username_required |
│ │ │ -5 |
│ │ │ - |
│ │ │ -
│ │ │ -| general_failure |
│ │ │ -6 |
│ │ │ - |
│ │ │ -
│ │ │ -| command_not_supported |
│ │ │ -7 |
│ │ │ - |
│ │ │ -
│ │ │ -| no_identd |
│ │ │ -8 |
│ │ │ - |
│ │ │ -
│ │ │ -| identd_error |
│ │ │ -9 |
│ │ │ - |
│ │ │ -
│ │ │ -| num_errors |
│ │ │ -10 |
│ │ │ - |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum pcp_errors
│ │ │ -
Declared in "libtorrent/natpmp.hpp"
│ │ │ +
given a name of a metric, this function returns the counter index of it,
│ │ │ +or -1 if it could not be found. The counter index is the index into the
│ │ │ +values array returned by session_stats_alert.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum metric_type_t
│ │ │ +
Declared in "libtorrent/session_stats.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| pcp_success |
│ │ │ +
| counter |
│ │ │ 0 |
│ │ │ |
│ │ │
│ │ │ -| pcp_unsupp_version |
│ │ │ +
| gauge |
│ │ │ 1 |
│ │ │ |
│ │ │
│ │ │ -| pcp_not_authorized |
│ │ │ -2 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_malformed_request |
│ │ │ -3 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_unsupp_opcode |
│ │ │ -4 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_unsupp_option |
│ │ │ -5 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_malformed_option |
│ │ │ -6 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_network_failure |
│ │ │ -7 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_no_resources |
│ │ │ -8 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_unsupp_protocol |
│ │ │ -9 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_user_ex_quota |
│ │ │ -10 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_cannot_provide_external |
│ │ │ -11 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_address_mismatch |
│ │ │ -12 |
│ │ │ - |
│ │ │ -
│ │ │ -| pcp_excessive_remote_peers |
│ │ │ -13 |
│ │ │ - |
│ │ │ -
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum error_code_enum
│ │ │ -
Declared in "libtorrent/bdecode.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| no_error |
│ │ │ -0 |
│ │ │ -Not an error |
│ │ │ -
│ │ │ -| expected_digit |
│ │ │ -1 |
│ │ │ -expected digit in bencoded string |
│ │ │ -
│ │ │ -| expected_colon |
│ │ │ -2 |
│ │ │ -expected colon in bencoded string |
│ │ │ -
│ │ │ -| unexpected_eof |
│ │ │ -3 |
│ │ │ -unexpected end of file in bencoded string |
│ │ │ -
│ │ │ -| expected_value |
│ │ │ -4 |
│ │ │ -expected value (list, dict, int or string) in bencoded string |
│ │ │ -
│ │ │ -| depth_exceeded |
│ │ │ -5 |
│ │ │ -bencoded recursion depth limit exceeded |
│ │ │ -
│ │ │ -| limit_exceeded |
│ │ │ -6 |
│ │ │ -bencoded item count limit exceeded |
│ │ │ -
│ │ │ -| overflow |
│ │ │ -7 |
│ │ │ -integer overflow |
│ │ │ -
│ │ │ -| error_code_max |
│ │ │ -8 |
│ │ │ -the number of error codes |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
peer_request
│ │ │ +
Declared in "libtorrent/peer_request.hpp"
│ │ │ +
represents a byte range within a piece. Internally this is is used for
│ │ │ +incoming piece requests.
│ │ │
│ │ │ -struct session_params
│ │ │ +struct peer_request
│ │ │ {
│ │ │ - session_params (settings_pack&& sp);
│ │ │ - session_params (settings_pack const& sp);
│ │ │ - session_params ();
│ │ │ - session_params (settings_pack&& sp
│ │ │ - , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ - session_params (settings_pack const& sp
│ │ │ - , std::vector<std::shared_ptr<plugin>> exts);
│ │ │ + bool operator== (peer_request const& r) const;
│ │ │
│ │ │ - 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;
│ │ │ + piece_index_t piece;
│ │ │ + int start;
│ │ │ + int length;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
session_params()
│ │ │ -
│ │ │ -session_params (settings_pack&& sp);
│ │ │ -session_params (settings_pack const& sp);
│ │ │ -session_params ();
│ │ │ -
│ │ │ -
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()
│ │ │ +
[report issue]
│ │ │ +
operator==()
│ │ │
│ │ │ -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);
│ │ │ +bool operator== (peer_request const& r) const;
│ │ │
│ │ │ -
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
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- extensions
│ │ │ -- the plugins to add to the session as it is constructed
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- dht_state
│ │ │ -- DHT node ID and node addresses to bootstrap the DHT with.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- dht_storage_constructor
│ │ │ -- function object to construct the storage object for DHT items.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- disk_io_constructor
│ │ │ -- function object to create the disk I/O subsystem. Defaults to
│ │ │ -default_disk_io_constructor.
│ │ │ +returns true if the right hand side peer_request refers to the same
│ │ │ +range as this does.
│ │ │ +[report issue]
│ │ │ +- piece
│ │ │ +- The index of the piece in which the range starts.
│ │ │
│ │ │ -[report issue]
│ │ │ -- ext_state
│ │ │ -- this container can be used by extensions/plugins to store settings. It's
│ │ │ -primarily here to make it convenient to save and restore state across
│ │ │ -sessions, using read_session_params() and write_session_params().
│ │ │ +[report issue]
│ │ │ +- start
│ │ │ +- The byte offset within that piece where the range starts.
│ │ │
│ │ │ -[report issue]
│ │ │ -- ip_filter
│ │ │ -- the IP filter to use for the session. This restricts which peers are allowed
│ │ │ -to connect. As if passed to set_ip_filter().
│ │ │ +[report issue]
│ │ │ +- length
│ │ │ +- The size of the range, in bytes.
│ │ │
│ │ │ -[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
session_proxy
│ │ │ -
Declared in "libtorrent/session.hpp"
│ │ │ -
this is a holder for the internal session implementation object. Once the
│ │ │ -session destruction is explicitly initiated, this holder is used to
│ │ │ -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 const&) &;
│ │ │ - session_proxy (session_proxy&&) noexcept;
│ │ │ - session_proxy ();
│ │ │ - ~session_proxy ();
│ │ │ - session_proxy (session_proxy const&);
│ │ │ - session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ -};
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
session_proxy() ~session_proxy() operator=()
│ │ │ -
│ │ │ -session_proxy& operator= (session_proxy const&) &;
│ │ │ -session_proxy (session_proxy&&) noexcept;
│ │ │ -session_proxy ();
│ │ │ -~session_proxy ();
│ │ │ -session_proxy (session_proxy const&);
│ │ │ -session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ -
│ │ │ -
default constructor, does not refer to any session
│ │ │ -implementation object.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
session
│ │ │ -
Declared in "libtorrent/session.hpp"
│ │ │ -
The session holds all state that spans multiple torrents. Among other
│ │ │ -things it runs the network loop and manages all torrents. Once it's
│ │ │ -created, the session object will spawn the main thread that will do all
│ │ │ -the work. The main thread will be idle as long it doesn't have any
│ │ │ -torrents to participate in.
│ │ │ -
You have some control over session configuration through the
│ │ │ -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_params const& params, session_flags_t flags);
│ │ │ - session ();
│ │ │ - explicit session (session_params const& params);
│ │ │ - session (session_params&& params, session_flags_t flags);
│ │ │ - explicit session (session_params&& params);
│ │ │ - session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ - session (session_params&& params, io_context& ios);
│ │ │ - session (session_params const& params, io_context& ios);
│ │ │ - session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ - ~session ();
│ │ │ - session_proxy abort ();
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
session()
│ │ │ -
│ │ │ -session (session_params const& params, session_flags_t flags);
│ │ │ -session ();
│ │ │ -explicit session (session_params const& params);
│ │ │ -session (session_params&& params, session_flags_t flags);
│ │ │ -explicit session (session_params&& 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_flags_t);
│ │ │ -session (session_params&& params, io_context& ios);
│ │ │ -session (session_params const& params, io_context& ios);
│ │ │ -session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ -
│ │ │ -
Overload of the constructor that takes an external io_context to run
│ │ │ -the session object on. This is primarily useful for tests that may want
│ │ │ -to run multiple sessions on a single io_context, or low resource
│ │ │ -systems where additional threads are expensive and sharing an
│ │ │ -io_context with other events is fine.
│ │ │ -
│ │ │ -
Warning
│ │ │ -
The session object does not cleanly terminate with an external
│ │ │ -io_context. The io_context::run() call must have returned
│ │ │ -before it's safe to destruct the session. Which means you MUST
│ │ │ -call session::abort() and save the session_proxy first, then
│ │ │ -destruct the session object, then sync with the io_context, then
│ │ │ -destruct the session_proxy object.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
~session()
│ │ │ -
│ │ │ -~session ();
│ │ │ -
│ │ │ -
The destructor of session will notify all trackers that our torrents
│ │ │ -have been shut down. If some trackers are down, they will time out.
│ │ │ -All this before the destructor of session returns. So, it's advised
│ │ │ -that any kind of interface (such as windows) are closed before
│ │ │ -destructing the session object. Because it can take a few second for
│ │ │ -it to finish. The timeout can be set with apply_settings().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
abort()
│ │ │ -
│ │ │ -session_proxy abort ();
│ │ │ -
│ │ │ -
In case you want to destruct the session asynchronously, you can
│ │ │ -request a session destruction proxy. If you don't do this, the
│ │ │ -destructor of the session object will block while the trackers are
│ │ │ -contacted. If you keep one session_proxy to the session when
│ │ │ -destructing it, the destructor will not block, but start to close down
│ │ │ -the session, the destructor of the proxy will then synchronize the
│ │ │ -threads. So, the destruction of the session is performed from the
│ │ │ -session destructor call until the session_proxy destructor
│ │ │ -call. The session_proxy does not have any operations on it (since
│ │ │ -the session is being closed down, no operations are allowed on it).
│ │ │ -The only valid operation is calling the destructor:
│ │ │ -
│ │ │ -struct session_proxy {};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ +
[report issue]
│ │ │
│ │ │ -
│ │ │ -
session_handle
│ │ │ -
Declared in "libtorrent/session_handle.hpp"
│ │ │ -
this class provides a non-owning handle to a session and a subset of the
│ │ │ -interface of the session class. If the underlying session is destructed
│ │ │ -any handle to it will no longer be valid. is_valid() will return false and
│ │ │ -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;
│ │ │ - 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);
│ │ │ - torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ - std::vector<torrent_handle> get_torrents () const;
│ │ │ - void async_add_torrent (add_torrent_params const& params);
│ │ │ - torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ - torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ - void async_add_torrent (add_torrent_params&& params);
│ │ │ - torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ - torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ - bool is_paused () const;
│ │ │ - void resume ();
│ │ │ - void pause ();
│ │ │ - bool is_dht_running () const;
│ │ │ - void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ - void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ - void dht_get_item (sha1_hash const& target);
│ │ │ - void dht_get_item (std::array<char, 32> key
│ │ │ - , std::string salt = std::string());
│ │ │ - sha1_hash dht_put_item (entry data);
│ │ │ - void dht_put_item (std::array<char, 32> key
│ │ │ - , std::function<void(entry&, std::array<char, 64>&
│ │ │ - , std::int64_t&, std::string const&)> cb
│ │ │ - , std::string salt = std::string());
│ │ │ - void dht_get_peers (sha1_hash const& info_hash);
│ │ │ - void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ - void dht_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);
│ │ │ - ip_filter get_ip_filter () const;
│ │ │ - void set_ip_filter (ip_filter f);
│ │ │ - void set_port_filter (port_filter const& f);
│ │ │ - unsigned short ssl_listen_port () const;
│ │ │ - 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 remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ - void apply_settings (settings_pack&&);
│ │ │ - void apply_settings (settings_pack const&);
│ │ │ - settings_pack get_settings () const;
│ │ │ - void pop_alerts (std::vector<alert*>* alerts);
│ │ │ - void set_alert_notify (std::function<void()> const& fun);
│ │ │ - alert* wait_for_alert (time_duration max_wait);
│ │ │ - 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 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;
│ │ │ - static constexpr peer_class_t global_peer_class_id {0};
│ │ │ - static constexpr peer_class_t tcp_peer_class_id {1};
│ │ │ - static constexpr peer_class_t local_peer_class_id {2};
│ │ │ - static constexpr remove_flags_t delete_files = 0_bit;
│ │ │ - static constexpr remove_flags_t delete_partfile = 1_bit;
│ │ │ - static constexpr session_flags_t paused = 2_bit;
│ │ │ - static constexpr portmap_protocol udp = portmap_protocol::udp;
│ │ │ - static constexpr portmap_protocol tcp = portmap_protocol::tcp;
│ │ │ - static constexpr reopen_network_flags_t reopen_map_ports = 0_bit;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
is_valid()
│ │ │ -
│ │ │ -bool is_valid () const;
│ │ │ -
│ │ │ -
returns true if this handle refers to a valid session object. If the
│ │ │ -session has been destroyed, all session_handle objects will expire and
│ │ │ -not be valid.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
session_state()
│ │ │ -
│ │ │ -session_params session_state (save_state_flags_t flags = save_state_flags_t::all()) const;
│ │ │ -
│ │ │ -
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]
│ │ │ -
│ │ │ -
refresh_torrent_status() get_torrent_status()
│ │ │ -
│ │ │ -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;
│ │ │ -
│ │ │ +
│ │ │ +
info_hash_t
│ │ │ +
Declared in "libtorrent/info_hash.hpp"
│ │ │ +
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
│ │ │ -
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 torrent_status 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 should be included and false means
│ │ │ -excluded. The flags argument is the same as to
│ │ │ -torrent_handle::status(). Since pred is guaranteed to be
│ │ │ -called for every torrent, it may be used to count the number of
│ │ │ -torrents of different categories as well.
│ │ │ -
refresh_torrent_status takes a vector of torrent_status structs
│ │ │ -(for instance the same vector that was returned by
│ │ │ -get_torrent_status() ) and refreshes the status based on the
│ │ │ -handle member. It is possible to use this function by first
│ │ │ -setting up a vector of default constructed torrent_status objects,
│ │ │ -only initializing the handle member, in order to request the
│ │ │ -torrent status for multiple torrents in a single call. This can save a
│ │ │ -significant amount of time if you have a lot of torrents.
│ │ │ -
Any torrent_status object whose handle member is not referring to
│ │ │ -a valid torrent are ignored.
│ │ │ -
The intended use of these functions is to start off by calling
│ │ │ -get_torrent_status() to get a list of all torrents that match your
│ │ │ -criteria. Then call refresh_torrent_status() on that list. This
│ │ │ -will only refresh the status for the torrents in your list, and thus
│ │ │ -ignore all other torrents you might be running. This may save a
│ │ │ -significant amount of time, especially if the number of torrents you're
│ │ │ -interested in is small. In order to keep your list of interested
│ │ │ -torrents up to date, you can either call get_torrent_status() from
│ │ │ -time to time, to include torrents you might have become interested in
│ │ │ -since the last time. In order to stop refreshing a certain torrent,
│ │ │ -simply remove it from the list.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
post_torrent_updates()
│ │ │ -
│ │ │ -void post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │ -
│ │ │ -
This functions instructs the session to post the state_update_alert,
│ │ │ -containing the status of all torrents whose state changed since the
│ │ │ -last time this function was called.
│ │ │ -
Only torrents who has the state subscription flag set will be
│ │ │ -included. This flag is on by default. See add_torrent_params.
│ │ │ -the flags argument is the same as for torrent_handle::status().
│ │ │ -see status_flags_t in torrent_handle.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
post_session_stats()
│ │ │ -
│ │ │ -void post_session_stats ();
│ │ │ -
│ │ │ -
This function will post a session_stats_alert object, containing a
│ │ │ -snapshot of the performance counters from the internals of libtorrent.
│ │ │ -To interpret these counters, query the session via
│ │ │ -session_stats_metrics().
│ │ │ -
For more information, see the session statistics section.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
post_dht_stats()
│ │ │ -
│ │ │ -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);
│ │ │ -
│ │ │ -
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()
│ │ │ -
│ │ │ -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]
│ │ │ -
│ │ │ -
add_torrent() async_add_torrent()
│ │ │ -
│ │ │ -void async_add_torrent (add_torrent_params const& params);
│ │ │ -torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ -torrent_handle add_torrent (add_torrent_params&& params, error_code& ec);
│ │ │ -void async_add_torrent (add_torrent_params&& params);
│ │ │ -torrent_handle add_torrent (add_torrent_params const& params, error_code& ec);
│ │ │ -torrent_handle add_torrent (add_torrent_params const& params);
│ │ │ -
│ │ │ -
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
│ │ │ -the torrent being added is sent as add_torrent_alert.
│ │ │ -
The save_path field in add_torrent_params must be set to a valid
│ │ │ -path where the files for the torrent will be saved. Even when using a
│ │ │ -custom storage, this needs to be set to something. If the save_path
│ │ │ -is empty, the call to add_torrent() will throw a system_error
│ │ │ -exception.
│ │ │ -
The overload that does not take an error_code throws an exception on
│ │ │ -error and is not available when building without exception support.
│ │ │ -The torrent_handle returned by add_torrent() can be used to retrieve
│ │ │ -information about the torrent's progress, its peers etc. It is also
│ │ │ -used to abort a torrent.
│ │ │ -
If the torrent you are trying to add already exists in the session (is
│ │ │ -either queued for checking, being checked or downloading)
│ │ │ -add_torrent() will throw system_error which derives from
│ │ │ -std::exception unless duplicate_is_error is set to false. In that
│ │ │ -case, add_torrent() will return the handle to the existing torrent.
│ │ │ -
The add_torrent_params class has a flags field. It can be used to
│ │ │ -control what state the new torrent will be added in. Common flags to
│ │ │ -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]
│ │ │ -
│ │ │ -
is_paused() resume() pause()
│ │ │ -
│ │ │ -bool is_paused () const;
│ │ │ -void resume ();
│ │ │ -void pause ();
│ │ │ -
│ │ │ -
Pausing the session has the same effect as pausing every torrent in
│ │ │ -it, except that torrents will not be resumed by the auto-manage
│ │ │ -mechanism. Resuming will restore the torrents to their previous paused
│ │ │ -state. i.e. the session pause state is separate from the torrent pause
│ │ │ -state. A torrent is inactive if it is paused or if the session is
│ │ │ -paused.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
is_dht_running()
│ │ │ -
│ │ │ -bool is_dht_running () const;
│ │ │ -
│ │ │ -
is_dht_running() returns true if the DHT support has been started
│ │ │ -and false otherwise.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_dht_storage()
│ │ │ -
│ │ │ -void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ -
│ │ │ -
set_dht_storage set a dht custom storage constructor function
│ │ │ -to be used internally when the dht is created.
│ │ │ -
Since the dht storage is a critical component for the dht behavior,
│ │ │ -this function will only be effective the next time the dht is started.
│ │ │ -If you never touch this feature, a default map-memory based storage
│ │ │ -is used.
│ │ │ -
If you want to make sure the dht is initially created with your
│ │ │ -custom storage, create a session with the setting
│ │ │ -settings_pack::enable_dht to false, set your constructor function
│ │ │ -and call apply_settings with settings_pack::enable_dht to true.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
add_dht_node()
│ │ │ -
│ │ │ -void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ -
│ │ │ -
add_dht_node takes a host name and port pair. That endpoint will be
│ │ │ -pinged, and if a valid DHT reply is received, the node will be added to
│ │ │ -the routing table.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_get_item()
│ │ │ -
│ │ │ -void dht_get_item (sha1_hash const& target);
│ │ │ -
│ │ │ -
query the DHT for an immutable item at the target hash.
│ │ │ -the result is posted as a dht_immutable_item_alert.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_get_item()
│ │ │ -
│ │ │ -void dht_get_item (std::array<char, 32> key
│ │ │ - , std::string salt = std::string());
│ │ │ -
│ │ │ -
query the DHT for a mutable item under the public key key.
│ │ │ -this is an ed25519 key. salt is optional and may be left
│ │ │ -as an empty string if no salt is to be used.
│ │ │ -if the item is found in the DHT, a dht_mutable_item_alert is
│ │ │ -posted.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_put_item()
│ │ │ -
│ │ │ -sha1_hash dht_put_item (entry data);
│ │ │ -
│ │ │ -
store the given bencoded data as an immutable item in the DHT.
│ │ │ -the returned hash is the key that is to be used to look the item
│ │ │ -up again. It's just the SHA-1 hash of the bencoded form of the
│ │ │ -structure.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_put_item()
│ │ │ -
│ │ │ -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());
│ │ │ -
│ │ │ -
store a mutable item. The key is the public key the blob is
│ │ │ -to be stored under. The optional salt argument is a string that
│ │ │ -is to be mixed in with the key when determining where in the DHT
│ │ │ -the value is to be stored. The callback function is called from within
│ │ │ -the libtorrent network thread once we've found where to store the blob,
│ │ │ -possibly with the current value stored under the key.
│ │ │ -The values passed to the callback functions are:
│ │ │ -
│ │ │ -- entry& value
│ │ │ -- the current value stored under the key (may be empty). Also expected
│ │ │ -to be set to the value to be stored by the function.
│ │ │ -- std::array<char,64>& signature
│ │ │ -- the signature authenticating the current value. This may be zeros
│ │ │ -if there is currently no value stored. The function is expected to
│ │ │ -fill in this buffer with the signature of the new value to store.
│ │ │ -To generate the signature, you may want to use the
│ │ │ -sign_mutable_item function.
│ │ │ -- std::int64_t& seq
│ │ │ -- current sequence number. May be zero if there is no current value.
│ │ │ -The function is expected to set this to the new sequence number of
│ │ │ -the value that is to be stored. Sequence numbers must be monotonically
│ │ │ -increasing. Attempting to overwrite a value with a lower or equal
│ │ │ -sequence number will fail, even if the signature is correct.
│ │ │ -- std::string const& salt
│ │ │ -- this is the salt that was used for this put call.
│ │ │ -
│ │ │ -
Since the callback function cb is called from within libtorrent,
│ │ │ -it is critical to not perform any blocking operations. Ideally not
│ │ │ -even locking a mutex. Pass any data required for this function along
│ │ │ -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()
│ │ │ -
│ │ │ -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
│ │ │ -source port (which may improve connectivity through a NAT).
│ │ │ -dht_announce() is not affected by the announce_port override setting.
│ │ │ -
Both these functions are exposed for advanced custom use of the DHT.
│ │ │ -All torrents eligible to be announce to the DHT will be automatically,
│ │ │ -by libtorrent.
│ │ │ -
For possible flags, see announce_flags_t.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_live_nodes()
│ │ │ -
│ │ │ -void dht_live_nodes (sha1_hash const& nid);
│ │ │ -
│ │ │ -
Retrieve all the live DHT (identified by nid) nodes. All the
│ │ │ -nodes id and endpoint will be returned in the list of nodes in the
│ │ │ -alert dht_live_nodes_alert.
│ │ │ -Since this alert is a response to an explicit call, it will always be
│ │ │ -posted, regardless of the alert mask.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_sample_infohashes()
│ │ │ -
│ │ │ -void dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ -
│ │ │ -
Query the DHT node specified by ep to retrieve a sample of the
│ │ │ -info-hashes that the node currently have in their storage.
│ │ │ -The target is included for iterative lookups so that indexing nodes
│ │ │ -can perform a key space traversal with a single RPC per node by adjusting
│ │ │ -the target value for each RPC. It has no effect on the returned sample value.
│ │ │ -The result is posted as a dht_sample_infohashes_alert.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_direct_request()
│ │ │ -
│ │ │ -void dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ -
│ │ │ -
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 dht_direct_response_alert will be posted
│ │ │ -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);
│ │ │ -
│ │ │ -
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:
│ │ │ -
│ │ │ -- uTorrent metadata
│ │ │ -- Allows peers to download the metadata (.torrent files) from the swarm
│ │ │ -directly. Makes it possible to join a swarm with just a tracker and
│ │ │ -info-hash.
│ │ │ -
│ │ │ -
│ │ │ - ses.add_extension(<::create_ut_metadata_plugin);
│ │ │ -
│ │ │ -
│ │ │ -- uTorrent peer exchange
│ │ │ -- Exchanges peers between clients.
│ │ │ -
│ │ │ -
│ │ │ - ses.add_extension(<::create_ut_pex_plugin);
│ │ │ -
│ │ │ -
│ │ │ -- smart ban plugin
│ │ │ -- A plugin that, with a small overhead, can ban peers
│ │ │ -that sends bad data with very high accuracy. Should
│ │ │ -eliminate most problems on poisoned torrents.
│ │ │ -
│ │ │ -
│ │ │ - ses.add_extension(<::create_smart_ban_plugin);
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_ip_filter() get_ip_filter()
│ │ │ -
│ │ │ -ip_filter get_ip_filter () const;
│ │ │ -void set_ip_filter (ip_filter f);
│ │ │ -
│ │ │ -
Sets a filter that will be used to reject and accept incoming as well
│ │ │ -as outgoing connections based on their originating ip address. The
│ │ │ -default filter will allow connections to any ip address. To build a
│ │ │ -set of rules for which addresses are accepted and not, see ip_filter.
│ │ │ -
Each time a peer is blocked because of the IP filter, a
│ │ │ -peer_blocked_alert is generated. get_ip_filter() Returns the
│ │ │ -ip_filter currently in the session. See ip_filter.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_port_filter()
│ │ │ -
│ │ │ -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]
│ │ │ -
│ │ │ -
ssl_listen_port() is_listening() listen_port()
│ │ │ -
│ │ │ -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()
│ │ │ -
│ │ │ -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.
│ │ │ -
For more info, see ip_filter.
│ │ │ -
For example, to make all peers in the range 200.1.1.0 - 200.1.255.255
│ │ │ -belong to their own peer class, apply the following filter:
│ │ │ -
│ │ │ -ip_filter f = ses.get_peer_class_filter();
│ │ │ -peer_class_t my_class = ses.create_peer_class("200.1.x.x IP range");
│ │ │ -f.add_rule(make_address("200.1.1.0"), make_address("200.1.255.255")
│ │ │ - , 1 << static_cast<std::uint32_t>(my_class));
│ │ │ -ses.set_peer_class_filter(f);
│ │ │ -
│ │ │ -
This setting only applies to new connections, it won't affect existing
│ │ │ -peer connections.
│ │ │ -
This function is limited to only peer class 0-31, since there are only
│ │ │ -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()
│ │ │ -
│ │ │ -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:
│ │ │ -
│ │ │ -- peer-class IP filter
│ │ │ -- peer-class type filter, removing classes
│ │ │ -- peer-class type filter, adding classes
│ │ │ -
│ │ │ -
For more information, see peer classes.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
create_peer_class()
│ │ │ -
│ │ │ -peer_class_t create_peer_class (char const* name);
│ │ │ -
│ │ │ -
Creates a new peer class (see peer classes) with the given name. The
│ │ │ -returned integer is the new peer class identifier. Peer classes may
│ │ │ -have the same name, so each invocation of this function creates a new
│ │ │ -class and returns a unique identifier.
│ │ │ -
Identifiers are assigned from low numbers to higher. So if you plan on
│ │ │ -using certain peer classes in a call to set_peer_class_filter(),
│ │ │ -make sure to create those early on, to get low identifiers.
│ │ │ -
For more information on peer classes, see peer classes.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
delete_peer_class()
│ │ │ -
│ │ │ -void delete_peer_class (peer_class_t cid);
│ │ │ -
│ │ │ -
This call dereferences the reference count of the specified peer
│ │ │ -class. When creating a peer class it's automatically referenced by 1.
│ │ │ -If you want to recycle a peer class, you may call this function. You
│ │ │ -may only call this function once per peer class you create.
│ │ │ -Calling it more than once for the same class will lead to memory
│ │ │ -corruption.
│ │ │ -
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 session object
│ │ │ -destructs.
│ │ │ -
For more information on peer classes, see peer classes.
│ │ │ -
│ │ │ -
[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;
│ │ │ -
│ │ │ -
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
│ │ │ -option to only update a single property.
│ │ │ -
A peer or torrent belonging to more than one class, the highest
│ │ │ -priority among any of its classes is the one that is taken into
│ │ │ -account.
│ │ │ -
For more information, see peer classes.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
remove_torrent()
│ │ │ -
│ │ │ -void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ -
│ │ │ -
remove_torrent() will close all peer connections associated with
│ │ │ -the torrent and tell the tracker that we've stopped participating in
│ │ │ -the swarm. This operation cannot fail. When it completes, you will
│ │ │ -receive a torrent_removed_alert.
│ │ │ -
remove_torrent() is non-blocking, but will remove the torrent from the
│ │ │ -session synchronously. Calling session_handle::add_torrent() immediately
│ │ │ -afterward with the same torrent will succeed. Note that this creates a
│ │ │ -new handle which is not equal to the removed one.
│ │ │ -
The optional second argument options can be used to delete all the
│ │ │ -files downloaded by this torrent. To do so, pass in the value
│ │ │ -session_handle::delete_files. Once the torrent is deleted, a
│ │ │ -torrent_deleted_alert is posted.
│ │ │ -
The torrent_handle remains valid for some time after remove_torrent() is
│ │ │ -called. It will become invalid only after all libtorrent tasks (such as
│ │ │ -I/O tasks) release their references to the torrent. Until this happens,
│ │ │ -torrent_handle::is_valid() will return true, and other calls such
│ │ │ -as torrent_handle::status() will succeed. Because of this, and because
│ │ │ -remove_torrent() is non-blocking, the following sequence usually
│ │ │ -succeeds (does not throw system_error):
│ │ │ -.. code:: c++
│ │ │ -
│ │ │ -session.remove_handle(handle);
│ │ │ -handle.save_resume_data();
│ │ │ -
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.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
get_settings() apply_settings()
│ │ │ -
│ │ │ -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]
│ │ │ -
│ │ │ -
wait_for_alert() set_alert_notify() pop_alerts()
│ │ │ -
│ │ │ -void pop_alerts (std::vector<alert*>* alerts);
│ │ │ -void set_alert_notify (std::function<void()> const& fun);
│ │ │ -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
│ │ │ -long as the alerts themselves are not accessed once another thread
│ │ │ -calls pop_alerts. Doing this requires manual synchronization
│ │ │ -between the popping threads.
│ │ │ -
wait_for_alert will block the current thread for max_wait time
│ │ │ -duration, or until another alert is posted. If an alert is available
│ │ │ -at the time of the call, it returns immediately. The returned alert
│ │ │ -pointer is the head of the alert queue. wait_for_alert does not
│ │ │ -pop alerts from the queue, it merely peeks at it. The returned alert
│ │ │ -will stay valid until pop_alerts is called twice. The first time
│ │ │ -will pop it and the second will free it.
│ │ │ -
If there is no alert in the queue and no alert arrives within the
│ │ │ -specified timeout, wait_for_alert returns nullptr.
│ │ │ -
In the python binding, wait_for_alert takes the number of
│ │ │ -milliseconds to wait as an integer.
│ │ │ -
The alert queue in the session will not grow indefinitely. Make sure
│ │ │ -to pop periodically to not miss notifications. To control the max
│ │ │ -number of alerts that's queued by the session, see
│ │ │ -settings_pack::alert_queue_size.
│ │ │ -
Some alerts are considered so important that they are posted even when
│ │ │ -the alert queue is full. Some alerts are considered mandatory and cannot
│ │ │ -be disabled by the alert_mask. For instance,
│ │ │ -save_resume_data_alert and save_resume_data_failed_alert are always
│ │ │ -posted, regardless of the alert mask.
│ │ │ -
To control which alerts are posted, set the alert_mask
│ │ │ -(settings_pack::alert_mask).
│ │ │ -
If the alert queue fills up to the point where alerts are dropped, this
│ │ │ -will be indicated by a alerts_dropped_alert, which contains a bitmask
│ │ │ -of which types of alerts were dropped. Generally it is a good idea to
│ │ │ -make sure the alert queue is large enough, the alert_mask doesn't have
│ │ │ -unnecessary categories enabled and to call pop_alert() frequently, to
│ │ │ -avoid alerts being dropped.
│ │ │ -
the set_alert_notify function lets the client set a function object
│ │ │ -to be invoked every time the alert queue goes from having 0 alerts to
│ │ │ -1 alert. This function is called from within libtorrent, it may be the
│ │ │ -main thread, or it may be from within a user call. The intention of
│ │ │ -of the function is that the client wakes up its main thread, to poll
│ │ │ -for more alerts using pop_alerts(). If the notify function fails
│ │ │ -to do so, it won't be called again, until pop_alerts is called for
│ │ │ -some other reason. For instance, it could signal an eventfd, post a
│ │ │ -message to an HWND or some other main message pump. The actual
│ │ │ -retrieval of alerts should not be done in the callback. In fact, the
│ │ │ -callback should not block. It should not perform any expensive work.
│ │ │ -It really should just notify the main application thread.
│ │ │ -
The type of an alert 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.
│ │ │ -
│ │ │ -
[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);
│ │ │ -
│ │ │ -
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]
│ │ │ -
│ │ │ -
reopen_network_sockets()
│ │ │ -
│ │ │ -void reopen_network_sockets (reopen_network_flags_t options = reopen_map_ports);
│ │ │ -
│ │ │ -
Instructs the session to reopen all listen and outgoing sockets.
│ │ │ -
It's useful in the case your platform doesn't support the built in
│ │ │ -IP notifier mechanism, or if you have a better more reliable way to
│ │ │ -detect changes in the IP routing table.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
native_handle()
│ │ │ -
│ │ │ -std::shared_ptr<aux::session_impl> native_handle () const;
│ │ │ -
│ │ │ -
This function is intended only for use by plugins. This type does
│ │ │ -not have a stable API and should be relied on as little as possible.
│ │ │ -
[report issue]
│ │ │ -- save_settings
│ │ │ -- saves settings (i.e. the settings_pack)
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- save_dht_state
│ │ │ -- saves dht state such as nodes and node-id, possibly accelerating
│ │ │ -joining the DHT if provided at next session startup.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- save_extension_state
│ │ │ -- load or save state from plugins
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- save_ip_filter
│ │ │ -- load or save the IP filter set on the session
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- global_peer_class_id tcp_peer_class_id local_peer_class_id
│ │ │ -- built-in peer classes
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- delete_files
│ │ │ -- delete the files belonging to the torrent from disk.
│ │ │ -including the part-file, if there is one
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- delete_partfile
│ │ │ -- delete just the part-file associated with this torrent
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- paused
│ │ │ -- when set, the session will start paused. Call
│ │ │ -session_handle::resume() to start
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- udp tcp
│ │ │ -- protocols used by add_port_mapping()
│ │ │ -
│ │ │ -
[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]
│ │ │ +
If has_v2() is false then the v1 hash might actually be a truncated
│ │ │ +v2 hash
│ │ │
│ │ │ -
│ │ │ -
write_session_params() read_session_params() write_session_params_buf()
│ │ │ -
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());
│ │ │ -entry write_session_params (session_params const& sp
│ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ -session_params read_session_params (span<char const> buf
│ │ │ - , save_state_flags_t flags = save_state_flags_t::all());
│ │ │ -std::vector<char> write_session_params_buf (session_params const& sp
│ │ │ - , 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.
│ │ │ -The _buf suffix indicates the function operates on buffer rather than the
│ │ │ -bencoded structure.
│ │ │ -The torrents in a session are not part of the session_params state, they have
│ │ │ -to be restored separately.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
web_seed_entry
│ │ │ -
Declared in "libtorrent/torrent_info.hpp"
│ │ │ -
the web_seed_entry holds information about a web seed (also known
│ │ │ -as URL seed or HTTP seed). It is essentially a URL with some state
│ │ │ -associated with it. For more information, see BEP 17 and BEP 19.
│ │ │ -
│ │ │ -struct web_seed_entry
│ │ │ +struct info_hash_t
│ │ │ {
│ │ │ - bool operator== (web_seed_entry const& e) const;
│ │ │ - bool operator< (web_seed_entry const& e) const;
│ │ │ -
│ │ │ - enum type_t
│ │ │ - {
│ │ │ - url_seed,
│ │ │ - http_seed,
│ │ │ - };
│ │ │ + explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ + info_hash_t () noexcept = default;
│ │ │ + explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ + info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ + bool has_v2 () const;
│ │ │ + bool has_v1 () const;
│ │ │ + bool has (protocol_version v) 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;
│ │ │ + friend std::ostream& operator<< (std::ostream& os, info_hash_t const& ih);
│ │ │
│ │ │ - std::string url;
│ │ │ - std::string auth;
│ │ │ - headers_t extra_headers;
│ │ │ - std::uint8_t type;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
operator==()
│ │ │ -
│ │ │ -bool operator== (web_seed_entry const& e) const;
│ │ │ -
│ │ │ -
URL and type comparison
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
operator<()
│ │ │ -
│ │ │ -bool operator< (web_seed_entry const& e) const;
│ │ │ -
│ │ │ -
URL and type less-than comparison
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum type_t
│ │ │ -
Declared in "libtorrent/torrent_info.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| url_seed |
│ │ │ -0 |
│ │ │ - |
│ │ │ -
│ │ │ -| http_seed |
│ │ │ -1 |
│ │ │ - |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- url
│ │ │ -- The URL of the web seed
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- auth
│ │ │ -- Optional authentication. If this is set, it's passed
│ │ │ -in as HTTP basic auth to the web seed. The format is:
│ │ │ -username:password.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- extra_headers
│ │ │ -- Any extra HTTP headers that need to be passed to the web seed
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- type
│ │ │ -- The type of web seed (see type_t)
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
load_torrent_limits
│ │ │ -
Declared in "libtorrent/torrent_info.hpp"
│ │ │ -
this object holds configuration options for limits to use when loading
│ │ │ -torrents. They are meant to prevent loading potentially malicious torrents
│ │ │ -that cause excessive memory allocations.
│ │ │ -
│ │ │ -struct load_torrent_limits
│ │ │ -{
│ │ │ - int max_buffer_size = 10000000;
│ │ │ - int max_pieces = 0x200000;
│ │ │ - int max_decode_depth = 100;
│ │ │ - int max_decode_tokens = 3000000;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- max_buffer_size
│ │ │ -- the max size of a .torrent file to load into RAM
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- max_pieces
│ │ │ -- the max number of pieces allowed in the torrent
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- max_decode_depth
│ │ │ -- the max recursion depth in the bdecoded structure
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- max_decode_tokens
│ │ │ -- the max number of bdecode tokens
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
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 (std::string const& filename, error_code& ec);
│ │ │ - torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ - explicit torrent_info (std::string const& filename);
│ │ │ - explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ - torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ - torrent_info (bdecode_node const& torrent_file, 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 (char const* buffer, int size);
│ │ │ - torrent_info (torrent_info const& t);
│ │ │ - torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ - ~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);
│ │ │ - void add_tracker (std::string const& url, int tier = 0);
│ │ │ - std::vector<announce_entry> const& trackers () const;
│ │ │ - void add_tracker (std::string const& url, int tier
│ │ │ - , announce_entry::tracker_source source);
│ │ │ - void clear_trackers ();
│ │ │ - std::vector<sha1_hash> similar_torrents () const;
│ │ │ - std::vector<std::string> collections () const;
│ │ │ - std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ - void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ - void add_url_seed (std::string const& url
│ │ │ - , std::string const& ext_auth = std::string()
│ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ - 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;
│ │ │ - index_range<piece_index_t> piece_range () const;
│ │ │ - piece_index_t end_piece () const;
│ │ │ - piece_index_t last_piece () const;
│ │ │ - info_hash_t const& info_hashes () 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;
│ │ │ - 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);
│ │ │ - bool parse_info_section (bdecode_node const& info, error_code& ec, int max_pieces);
│ │ │ - bdecode_node info (char const* key) const;
│ │ │ - span<char const> info_section () const;
│ │ │ - span<char const> piece_layer (file_index_t) const;
│ │ │ - void free_piece_layers ();
│ │ │ + sha1_hash v1;
│ │ │ + sha256_hash v2;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
torrent_info()
│ │ │ -
│ │ │ -torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ -torrent_info (std::string const& filename, error_code& ec);
│ │ │ -torrent_info (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ -explicit torrent_info (std::string const& filename);
│ │ │ -explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ -torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ -torrent_info (bdecode_node const& torrent_file, 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 (char const* buffer, int size);
│ │ │ -torrent_info (torrent_info const& t);
│ │ │ -torrent_info (span<char const> buffer, load_torrent_limits const& cfg, from_span_t);
│ │ │ -
│ │ │ -
The constructor that takes an info-hash will initialize the info-hash
│ │ │ -to the given value, but leave all other fields empty. This is used
│ │ │ -internally when downloading torrents without the metadata. The
│ │ │ -metadata will be created by libtorrent as soon as it has been
│ │ │ -downloaded from the swarm.
│ │ │ -
The constructor that takes a bdecode_node will create a torrent_info
│ │ │ -object from the information found in the given torrent_file. The
│ │ │ -bdecode_node represents a tree node in an bencoded file. To load an
│ │ │ -ordinary .torrent file into a bdecode_node, use bdecode().
│ │ │ -
The version that takes a buffer pointer and a size will decode it as a
│ │ │ -.torrent file and initialize the torrent_info object for you.
│ │ │ -
The version that takes a filename will simply load the torrent file
│ │ │ -and decode it inside the constructor, for convenience. This might not
│ │ │ -be the most suitable for applications that want to be able to report
│ │ │ -detailed errors on what might go wrong.
│ │ │ -
There is an upper limit on the size of the torrent file that will be
│ │ │ -loaded by the overload taking a filename. If it's important that even
│ │ │ -very large torrent files are loaded, use one of the other overloads.
│ │ │ -
The overloads that takes an error_code const& never throws if an
│ │ │ -error occur, they will simply set the error code to describe what went
│ │ │ -wrong and not fully initialize the torrent_info object. The overloads
│ │ │ -that do not take the extra error_code parameter will always throw if
│ │ │ -an error occurs. These overloads are not available when building
│ │ │ -without exception support.
│ │ │ -
The overload that takes a span also needs an extra parameter of
│ │ │ -type 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.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
~torrent_info()
│ │ │ -
│ │ │ -~torrent_info ();
│ │ │ -
│ │ │ -
frees all storage associated with this torrent_info object
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
files() orig_files()
│ │ │ -
│ │ │ -file_storage const& files () const;
│ │ │ -file_storage const& orig_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
│ │ │ -having a torrent file. When renaming files in a storage, the storage
│ │ │ -needs to make its own copy of the file_storage in order to make its
│ │ │ -mapping differ from the one in the torrent file.
│ │ │ -
orig_files() returns the original (unmodified) file storage for
│ │ │ -this torrent. This is used by the web server connection, which needs
│ │ │ -to request files with the original names. Filename may be changed using
│ │ │ -torrent_info::rename_file().
│ │ │ -
For more information on the file_storage object, see the separate
│ │ │ -document on how to create torrents.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
rename_file()
│ │ │ -
│ │ │ -void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ -
│ │ │ -
Renames the file with the specified index to the new name. The new
│ │ │ -filename is reflected by the file_storage returned by files()
│ │ │ -but not by the one returned by orig_files().
│ │ │ -
If you want to rename the base name of the torrent (for a multi file
│ │ │ -torrent), you can copy the file_storage (see files() and
│ │ │ -orig_files() ), change the name, and then use remap_files().
│ │ │ -
The new_filename can both be a relative path, in which case the
│ │ │ -file name is relative to the save_path of the torrent. If the
│ │ │ -new_filename is an absolute path (i.e. is_complete(new_filename)
│ │ │ -== true), then the file is detached from the save_path of the
│ │ │ -torrent. In this case the file is not moved when move_storage() is
│ │ │ -invoked.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
remap_files()
│ │ │ -
│ │ │ -void remap_files (file_storage const& f);
│ │ │ -
│ │ │ -
│ │ │ -
Warning
│ │ │ -
Using remap_files() is discouraged as it's incompatible with v2
│ │ │ -torrents. This is because the piece boundaries and piece hashes in
│ │ │ -v2 torrents are intimately tied to the file boundaries. Instead,
│ │ │ -just rename individual files, or implement a custom disk_interface
│ │ │ -to customize how to store files.
│ │ │ -
│ │ │ -
Remaps the file storage to a new file layout. This can be used to, for
│ │ │ -instance, download all data in a torrent to a single file, or to a
│ │ │ -number of fixed size sector aligned files, regardless of the number
│ │ │ -and sizes of the files in the torrent.
│ │ │ -
The new specified file_storage must have the exact same size as
│ │ │ -the current one.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
add_tracker() trackers() clear_trackers()
│ │ │ -
│ │ │ -void add_tracker (std::string const& url, int tier = 0);
│ │ │ -std::vector<announce_entry> const& trackers () const;
│ │ │ -void add_tracker (std::string const& url, int tier
│ │ │ - , announce_entry::tracker_source source);
│ │ │ -void clear_trackers ();
│ │ │ -
│ │ │ -
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()
│ │ │ -
│ │ │ -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]
│ │ │ -
│ │ │ -
set_web_seeds() add_url_seed() web_seeds() add_http_seed()
│ │ │ -
│ │ │ -std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ -void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ -void add_url_seed (std::string const& url
│ │ │ - , std::string const& ext_auth = std::string()
│ │ │ - , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ -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
│ │ │ -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 the URL itself. The string will be sent
│ │ │ -as the HTTP authorization header's value (without specifying "Basic").
│ │ │ -
The extra_headers argument defaults to an empty list, but can be
│ │ │ -used to insert custom HTTP headers in the requests to a specific web
│ │ │ -seed.
│ │ │ -
See http seeding for more information.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
total_size()
│ │ │ -
│ │ │ -std::int64_t total_size () const;
│ │ │ -
│ │ │ -
total_size() returns the total number of bytes the torrent-file
│ │ │ -represents. Note that this is the number of pieces times the piece
│ │ │ -size (modulo the last piece possibly being smaller). With pad files,
│ │ │ -the total size will be larger than the sum of all (regular) file
│ │ │ -sizes.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
piece_length() num_pieces()
│ │ │ -
│ │ │ -int num_pieces () const;
│ │ │ -int piece_length () const;
│ │ │ -
│ │ │ -
piece_length() and num_pieces() returns the number of byte
│ │ │ -for each piece and the total number of pieces, respectively. The
│ │ │ -difference between piece_size() and piece_length() is that
│ │ │ -piece_size() takes the piece index as argument and gives you the
│ │ │ -exact size of that piece. It will always be the same as
│ │ │ -piece_length() except in the case of the last piece, which may be
│ │ │ -smaller.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
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()
│ │ │ -
│ │ │ -index_range<piece_index_t> piece_range () const;
│ │ │ -piece_index_t end_piece () const;
│ │ │ -piece_index_t last_piece () const;
│ │ │ -
│ │ │ -
last_piece() returns the index to the last piece in the torrent and
│ │ │ -end_piece() returns the index to the one-past-end piece in the
│ │ │ -torrent
│ │ │ -piece_range() returns an implementation-defined type that can be
│ │ │ -used as the container in a range-for loop. Where the values are the
│ │ │ -indices of all pieces in the file_storage.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
info_hash() info_hashes()
│ │ │ -
│ │ │ -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]
│ │ │ -
│ │ │ -
v1() v2()
│ │ │ -
│ │ │ -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()
│ │ │ -
│ │ │ -int num_files () const;
│ │ │ -
│ │ │ -
If you need index-access to files you can use the num_files() along
│ │ │ -with the file_path(), file_size()-family of functions to access
│ │ │ -files using indices.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
map_block()
│ │ │ -
│ │ │ -std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ - , std::int64_t offset, int size) const;
│ │ │ -
│ │ │ -
This function will map a piece index, a byte offset within that piece
│ │ │ -and a size (in bytes) into the corresponding files with offsets where
│ │ │ -that data for that piece is supposed to be stored. See file_slice.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
map_file()
│ │ │ -
│ │ │ -peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ -
│ │ │ -
This function will map a range in a specific file into a range in the
│ │ │ -torrent. The file_offset parameter is the offset in the file,
│ │ │ -given in bytes, where 0 is the start of the file. See peer_request.
│ │ │ -
The input range is assumed to be valid within the torrent.
│ │ │ -file_offset + size is not allowed to be greater than the file
│ │ │ -size. file_index must refer to a valid file, i.e. it cannot be >=
│ │ │ -num_files().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
ssl_cert()
│ │ │ -
│ │ │ -string_view ssl_cert () const;
│ │ │ -
│ │ │ -
Returns the SSL root certificate for the torrent, if it is an SSL
│ │ │ -torrent. Otherwise returns an empty string. The certificate is
│ │ │ -the public certificate in x509 format.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
is_valid()
│ │ │ -
│ │ │ -bool is_valid () const;
│ │ │ -
│ │ │ -
returns true if this torrent_info object has a torrent loaded.
│ │ │ -This is primarily used to determine if a magnet link has had its
│ │ │ -metadata resolved yet or not.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
priv()
│ │ │ -
│ │ │ -bool priv () const;
│ │ │ -
│ │ │ -
returns true if this torrent is private. i.e., the client should not
│ │ │ -advertise itself on the trackerless network (the Kademlia DHT) for this torrent.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
is_i2p()
│ │ │ -
│ │ │ -bool is_i2p () const;
│ │ │ -
│ │ │ -
returns true if this is an i2p torrent. This is determined by whether
│ │ │ -or not it has a tracker whose URL domain name ends with ".i2p". i2p
│ │ │ -torrents disable the DHT and local peer discovery as well as talking
│ │ │ -to peers over anything other than the i2p network.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
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()
│ │ │ -
│ │ │ -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]
│ │ │ -
│ │ │ -
name()
│ │ │ -
│ │ │ -const std::string& name () const;
│ │ │ -
│ │ │ -
name() returns the name of the torrent.
│ │ │ -name contains UTF-8 encoded string.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
creator()
│ │ │ -
│ │ │ -const std::string& creator () const;
│ │ │ -
│ │ │ -
creator() returns the creator string in the torrent. If there is
│ │ │ -no creator string it will return an empty string.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
nodes()
│ │ │ -
│ │ │ -std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │ -
│ │ │ -
If this torrent contains any DHT nodes, they are put in this vector in
│ │ │ -their original form (host name and port number).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
add_node()
│ │ │ +
[report issue]
│ │ │ +
info_hash_t()
│ │ │
│ │ │ -void add_node (std::pair<std::string, int> const& node);
│ │ │ +explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ +info_hash_t () noexcept = default;
│ │ │ +explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ +info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │
│ │ │ -
This is used when creating torrent. Use this to add a known DHT node.
│ │ │ -It may be used, by the client, to bootstrap into the DHT network.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
parse_info_section()
│ │ │ +
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_v1() has_v2() has()
│ │ │
│ │ │ -bool parse_info_section (bdecode_node const& info, error_code& ec, int max_pieces);
│ │ │ +bool has_v2 () const;
│ │ │ +bool has_v1 () const;
│ │ │ +bool has (protocol_version v) const;
│ │ │
│ │ │ -
populates the torrent_info by providing just the info-dict buffer.
│ │ │ -This is used when loading a torrent from a magnet link for instance,
│ │ │ -where we only have the info-dict. The bdecode_node e points to a
│ │ │ -parsed info-dictionary. ec returns an error code if something
│ │ │ -fails (typically if the info dictionary is malformed).
│ │ │ -The max_pieces parameter allows limiting the amount of memory
│ │ │ -dedicated to loading the torrent, and fails for torrents that exceed
│ │ │ -the limit. To load large torrents, this limit may also need to be
│ │ │ -raised in settings_pack::max_piece_count and in calls to
│ │ │ -read_resume_data().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
info()
│ │ │ +
returns true if the corresponding info hash is present in this
│ │ │ +object.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get()
│ │ │
│ │ │ -bdecode_node info (char const* key) const;
│ │ │ +sha1_hash get (protocol_version v) const;
│ │ │
│ │ │ -
This function looks up keys from the info-dictionary of the loaded
│ │ │ -torrent file. It can be used to access extension values put in the
│ │ │ -.torrent file. If the specified key cannot be found, it returns nullptr.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
info_section()
│ │ │ +
returns the has for the specified protocol version
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get_best()
│ │ │
│ │ │ -span<char const> info_section () const;
│ │ │ +sha1_hash get_best () const;
│ │ │
│ │ │ -
returns a the raw info section of the torrent file.
│ │ │ -The underlying buffer is still owned by the torrent_info object
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
piece_layer()
│ │ │ +
returns the v2 (truncated) info-hash, if there is one, otherwise
│ │ │ +returns the v1 info-hash
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
for_each()
│ │ │
│ │ │ -span<char const> piece_layer (file_index_t) const;
│ │ │ +template <typename F> void for_each (F f) const;
│ │ │
│ │ │ -
return the bytes of the piece layer hashes for the specified file. If
│ │ │ -the file doesn't have a piece layer, an empty span is returned.
│ │ │ -The span size is divisible by 32, the size of a SHA-256 hash.
│ │ │ -If the size of the file is smaller than or equal to the piece size,
│ │ │ -the files "root hash" is the hash of the file and is not saved
│ │ │ -separately in the "piece layers" field, but this function still
│ │ │ -returns the root hash of the file in that case.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
free_piece_layers()
│ │ │ +
calls the function object f for each hash that is available.
│ │ │ +starting with v1. The signature of F is:
│ │ │
│ │ │ -void free_piece_layers ();
│ │ │ +void(sha1_hash const&, protocol_version);
│ │ │
│ │ │ -
clears the piece layers from the torrent_info. This is done by the
│ │ │ -session when a torrent is added, to avoid storing it twice. The piece
│ │ │ -layer (or other hashes part of the merkle tree) are stored in the
│ │ │ -internal torrent object.
│ │ │
[report issue]
│ │ │
│ │ │
│ │ │
peer_info
│ │ │
Declared in "libtorrent/peer_info.hpp"
│ │ │
holds information and statistics about one peer
│ │ │ that libtorrent is connected to
│ │ │ @@ -4314,187 +1481,82 @@
│ │ │
[report issue]
│ │ │ - read_state write_state
│ │ │ - bitmasks indicating what state this peer
│ │ │ is in with regards to sending and receiving data. The states are
│ │ │ defined as independent flags of type bandwidth_state_flags_t, in this
│ │ │ class.
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
info_hash_t
│ │ │ -
Declared in "libtorrent/info_hash.hpp"
│ │ │ -
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
│ │ │ -{
│ │ │ - info_hash_t () noexcept = default;
│ │ │ - explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ - info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ - explicit info_hash_t (sha1_hash h1) noexcept;
│ │ │ - bool has (protocol_version v) const;
│ │ │ - bool has_v2 () const;
│ │ │ - bool has_v1 () const;
│ │ │ - sha1_hash get (protocol_version v) const;
│ │ │ - sha1_hash get_best () const;
│ │ │ - friend bool operator!= (info_hash_t const& lhs, info_hash_t const& rhs);
│ │ │ - friend bool operator== (info_hash_t const& lhs, info_hash_t const& rhs) noexcept;
│ │ │ - template <typename F> void for_each (F f) const;
│ │ │ - bool operator< (info_hash_t const& o) const;
│ │ │ - friend std::ostream& operator<< (std::ostream& os, info_hash_t const& ih);
│ │ │ -
│ │ │ - sha1_hash v1;
│ │ │ - sha256_hash v2;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
info_hash_t()
│ │ │ -
│ │ │ -info_hash_t () noexcept = default;
│ │ │ -explicit info_hash_t (sha256_hash h2) noexcept;
│ │ │ -info_hash_t (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ -explicit info_hash_t (sha1_hash h1) 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_v2() has() has_v1()
│ │ │ -
│ │ │ -bool has (protocol_version v) const;
│ │ │ -bool has_v2 () const;
│ │ │ -bool has_v1 () const;
│ │ │ -
│ │ │ -
returns true if the corresponding info hash is present in this
│ │ │ -object.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
get()
│ │ │ -
│ │ │ -sha1_hash get (protocol_version v) const;
│ │ │ -
│ │ │ -
returns the has for the specified protocol version
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
get_best()
│ │ │ -
│ │ │ -sha1_hash get_best () const;
│ │ │ -
│ │ │ -
returns the v2 (truncated) info-hash, if there is one, otherwise
│ │ │ -returns the v1 info-hash
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
for_each()
│ │ │ -
│ │ │ -template <typename F> void for_each (F f) const;
│ │ │ -
│ │ │ -
calls the function object f for each hash that is available.
│ │ │ -starting with v1. The signature of F is:
│ │ │ -
│ │ │ -void(sha1_hash const&, protocol_version);
│ │ │ -
│ │ │
[report issue]
│ │ │
│ │ │
│ │ │
piece_block
│ │ │
Declared in "libtorrent/piece_block.hpp"
│ │ │
│ │ │ struct piece_block
│ │ │ {
│ │ │ - piece_block (piece_index_t p_index, int b_index);
│ │ │ piece_block () = default;
│ │ │ + piece_block (piece_index_t p_index, int b_index);
│ │ │ bool operator< (piece_block const& b) const;
│ │ │ bool operator== (piece_block const& b) const;
│ │ │ bool operator!= (piece_block const& b) const;
│ │ │
│ │ │ static const piece_block invalid;
│ │ │ piece_index_t piece_index {0};
│ │ │ int block_index = 0;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
peer_request
│ │ │ -
Declared in "libtorrent/peer_request.hpp"
│ │ │ -
represents a byte range within a piece. Internally this is is used for
│ │ │ -incoming piece requests.
│ │ │ -
│ │ │ -struct peer_request
│ │ │ -{
│ │ │ - bool operator== (peer_request const& r) const;
│ │ │ -
│ │ │ - piece_index_t piece;
│ │ │ - int start;
│ │ │ - int length;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
operator==()
│ │ │ -
│ │ │ -bool operator== (peer_request const& r) const;
│ │ │ -
│ │ │ -
returns true if the right hand side peer_request refers to the same
│ │ │ -range as this does.
│ │ │ -
[report issue]
│ │ │ -- piece
│ │ │ -- The index of the piece in which the range starts.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- start
│ │ │ -- The byte offset within that piece where the range starts.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- length
│ │ │ -- The size of the range, in bytes.
│ │ │ -
│ │ │ -
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
load_torrent_file() load_torrent_buffer() load_torrent_parsed()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
load_torrent_buffer() load_torrent_file() load_torrent_parsed()
│ │ │
Declared in "libtorrent/load_torrent.hpp"
│ │ │
│ │ │ add_torrent_params load_torrent_buffer (
│ │ │ - span<char const> buffer);
│ │ │ -add_torrent_params load_torrent_file (
│ │ │ - std::string const& filename, load_torrent_limits const& cfg);
│ │ │ -add_torrent_params load_torrent_buffer (
│ │ │ span<char const> buffer, load_torrent_limits const& cfg);
│ │ │ add_torrent_params load_torrent_parsed (
│ │ │ bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ add_torrent_params load_torrent_file (
│ │ │ - std::string const& filename);
│ │ │ + std::string const& filename, load_torrent_limits const& cfg);
│ │ │ add_torrent_params load_torrent_parsed (
│ │ │ bdecode_node const& torrent_file);
│ │ │ +add_torrent_params load_torrent_file (
│ │ │ + std::string const& filename);
│ │ │ +add_torrent_params load_torrent_buffer (
│ │ │ + span<char const> buffer);
│ │ │
│ │ │
These functions load the content of a .torrent file into an
│ │ │ add_torrent_params object.
│ │ │ The immutable part of a torrent file (the info-dictionary) is stored in
│ │ │ the ti field in the add_torrent_params object (as a torrent_info
│ │ │ object).
│ │ │ The returned object is suitable to be:
│ │ │
│ │ │
│ │ │
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
truncate_files()
│ │ │ +
Declared in "libtorrent/truncate.hpp"
│ │ │ +
│ │ │ +void truncate_files (file_storage const& fs, std::string const& save_path, storage_error& ec);
│ │ │ +
│ │ │ +
Truncates files larger than specified in the file_storage, saved under
│ │ │ +the specified save_path.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
torrent_peer_equal()
│ │ │ +
Declared in "libtorrent/torrent_peer.hpp"
│ │ │ +
│ │ │ +inline bool torrent_peer_equal (torrent_peer const* lhs, torrent_peer const* rhs);
│ │ │ +
│ │ │
[report issue]
│ │ │
│ │ │
make_magnet_uri()
│ │ │
Declared in "libtorrent/magnet_uri.hpp"
│ │ │
│ │ │ std::string make_magnet_uri (add_torrent_params const& atp);
│ │ │ std::string make_magnet_uri (torrent_handle const& handle);
│ │ │ @@ -4523,100 +1585,60 @@
│ │ │ 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);
│ │ │ +void parse_magnet_uri (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │
│ │ │
This function parses out information from the magnet link and populates the
│ │ │ add_torrent_params object. The overload that does not take an
│ │ │ error_code reference will throw a system_error on error
│ │ │ The overload taking an add_torrent_params reference will fill in the
│ │ │ fields specified in the magnet URI.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
torrent_peer_equal()
│ │ │ -
Declared in "libtorrent/torrent_peer.hpp"
│ │ │ -
│ │ │ -inline bool torrent_peer_equal (torrent_peer const* lhs, torrent_peer const* rhs);
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
truncate_files()
│ │ │ -
Declared in "libtorrent/truncate.hpp"
│ │ │ -
│ │ │ -void truncate_files (file_storage const& fs, std::string const& save_path, storage_error& ec);
│ │ │ -
│ │ │ -
Truncates files larger than specified in the file_storage, saved under
│ │ │ -the specified save_path.
│ │ │
[report issue]
│ │ │
│ │ │
version()
│ │ │
Declared in "libtorrent/version.hpp"
│ │ │
│ │ │ char const* version ();
│ │ │
│ │ │
returns the libtorrent version as string form in this format:
│ │ │ "<major>.<minor>.<tiny>.<tag>"
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum connection_type
│ │ │ +
Declared in "libtorrent/peer_connection.hpp"
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| tcp |
│ │ │ +
| bittorrent |
│ │ │ 0 |
│ │ │ |
│ │ │
│ │ │ -| socks5 |
│ │ │ +
| url_seed |
│ │ │ 1 |
│ │ │ |
│ │ │
│ │ │ -| http |
│ │ │ +
| http_seed |
│ │ │ 2 |
│ │ │ |
│ │ │
│ │ │ -| utp |
│ │ │ -3 |
│ │ │ - |
│ │ │ -
│ │ │ -| i2p |
│ │ │ -4 |
│ │ │ - |
│ │ │ -
│ │ │ -| tcp_ssl |
│ │ │ -5 |
│ │ │ - |
│ │ │ -
│ │ │ -| socks5_ssl |
│ │ │ -6 |
│ │ │ - |
│ │ │ -
│ │ │ -| http_ssl |
│ │ │ -7 |
│ │ │ - |
│ │ │ -
│ │ │ -| utp_ssl |
│ │ │ -8 |
│ │ │ - |
│ │ │ -
│ │ │
│ │ │
│ │ │
[report issue]
│ │ │
│ │ │
enum protocol_version
│ │ │
Declared in "libtorrent/info_hash.hpp"
│ │ │
│ │ │ @@ -4642,137 +1664,161 @@
│ │ │
│ │ │ | NUM |
│ │ │ 2 |
│ │ │ |
│ │ │
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum event_t
│ │ │ +
Declared in "libtorrent/tracker_manager.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| natpmp |
│ │ │ +
| none |
│ │ │ 0 |
│ │ │ -natpmp can be NAT-PMP or PCP |
│ │ │ + |
│ │ │
│ │ │ -| upnp |
│ │ │ +
| completed |
│ │ │ 1 |
│ │ │ |
│ │ │
│ │ │ +| started |
│ │ │ +2 |
│ │ │ + |
│ │ │ +
│ │ │ +| stopped |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| paused |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum socket_type_t
│ │ │ +
Declared in "libtorrent/socket_type.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| none |
│ │ │ +
| tcp |
│ │ │ 0 |
│ │ │ |
│ │ │
│ │ │ -| tcp |
│ │ │ +
| socks5 |
│ │ │ 1 |
│ │ │ |
│ │ │
│ │ │ -| udp |
│ │ │ +
| http |
│ │ │ 2 |
│ │ │ |
│ │ │
│ │ │ +| utp |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| i2p |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │ +| tcp_ssl |
│ │ │ +5 |
│ │ │ + |
│ │ │ +
│ │ │ +| socks5_ssl |
│ │ │ +6 |
│ │ │ + |
│ │ │ +
│ │ │ +| http_ssl |
│ │ │ +7 |
│ │ │ + |
│ │ │ +
│ │ │ +| utp_ssl |
│ │ │ +8 |
│ │ │ + |
│ │ │ +
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum portmap_transport
│ │ │ +
Declared in "libtorrent/portmap.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| none |
│ │ │ +
| natpmp |
│ │ │ 0 |
│ │ │ - |
│ │ │ +natpmp can be NAT-PMP or PCP |
│ │ │
│ │ │ -| completed |
│ │ │ +
| upnp |
│ │ │ 1 |
│ │ │ |
│ │ │
│ │ │ -| started |
│ │ │ -2 |
│ │ │ - |
│ │ │ -
│ │ │ -| stopped |
│ │ │ -3 |
│ │ │ - |
│ │ │ -
│ │ │ -| paused |
│ │ │ -4 |
│ │ │ - |
│ │ │ -
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum portmap_protocol
│ │ │ +
Declared in "libtorrent/portmap.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| bittorrent |
│ │ │ +
| none |
│ │ │ 0 |
│ │ │ |
│ │ │
│ │ │ -| url_seed |
│ │ │ +
| tcp |
│ │ │ 1 |
│ │ │ |
│ │ │
│ │ │ -| http_seed |
│ │ │ +
| udp |
│ │ │ 2 |
│ │ │ |
│ │ │
│ │ │
│ │ │
│ │ │
[report issue]
│ │ │
│ │ │ @@ -4791,14 +1837,41 @@
│ │ │
- low_priority
│ │ │
- The lowest priority for files and pieces.
│ │ │
│ │ │
│ │ │ - top_priority
│ │ │ - The highest priority for files and pieces.
│ │ │
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
pex_flags_t
│ │ │ +
Declared in "libtorrent/pex_flags.hpp"
│ │ │ +
│ │ │ +- pex_encryption
│ │ │ +- the peer supports protocol encryption
│ │ │ +
│ │ │ +
│ │ │ +- pex_seed
│ │ │ +- the peer is a seed
│ │ │ +
│ │ │ +
│ │ │ +- pex_utp
│ │ │ +- the peer supports the uTP, transport protocol over UDP.
│ │ │ +
│ │ │ +
│ │ │ +- pex_holepunch
│ │ │ +- the peer supports the holepunch extension If this flag is received from a
│ │ │ +peer, it can be used as a rendezvous point in case direct connections to
│ │ │ +the peer fail
│ │ │ +
│ │ │ +
│ │ │ +- pex_lt_v2
│ │ │ +- protocol v2
│ │ │ +this is not a standard flag, it is only used internally
│ │ │ +
│ │ │
[report issue]
│ │ │
│ │ │
int
│ │ │
Declared in "libtorrent/version.hpp"
│ │ │
│ │ │ - version_major
│ │ │ - the major, minor and tiny versions of libtorrent
│ │ │ @@ -4823,41 +1896,14 @@
│ │ │
│ │ │ -
│ │ │ -
pex_flags_t
│ │ │ -
Declared in "libtorrent/pex_flags.hpp"
│ │ │ -
│ │ │ -- pex_encryption
│ │ │ -- the peer supports protocol encryption
│ │ │ -
│ │ │ -
│ │ │ -- pex_seed
│ │ │ -- the peer is a seed
│ │ │ -
│ │ │ -
│ │ │ -- pex_utp
│ │ │ -- the peer supports the uTP, transport protocol over UDP.
│ │ │ -
│ │ │ -
│ │ │ -- pex_holepunch
│ │ │ -- the peer supports the holepunch extension If this flag is received from a
│ │ │ -peer, it can be used as a rendezvous point in case direct connections to
│ │ │ -the peer fail
│ │ │ -
│ │ │ -
│ │ │ -- pex_lt_v2
│ │ │ -- protocol v2
│ │ │ -this is not a standard flag, it is only used internally
│ │ │ -
│ │ │
[report issue]
│ │ │
torrent_flags_t
│ │ │
Declared in "libtorrent/torrent_flags.hpp"
│ │ │
│ │ │ - seed_mode
│ │ │ If seed_mode is set, libtorrent will assume that all files
│ │ │ @@ -5084,767 +2130,2028 @@
│ │ │ URL.
│ │ │
│ │ │ - all
│ │ │ - all torrent flags combined. Can conveniently be used when creating masks
│ │ │ for flags
│ │ │
│ │ │ -
libtorrent has a plugin interface for implementing extensions to the protocol.
│ │ │ -These can be general extensions for transferring metadata or peer exchange
│ │ │ -extensions, or it could be used to provide a way to customize the protocol
│ │ │ -to fit a particular (closed) network.
│ │ │ -
In short, the plugin interface makes it possible to:
│ │ │ -
│ │ │ -- register extension messages (sent in the extension handshake), see
│ │ │ -extensions.
│ │ │ -- add data and parse data from the extension handshake.
│ │ │ -- send extension messages and standard bittorrent messages.
│ │ │ -- override or block the handling of standard bittorrent messages.
│ │ │ -- save and restore state via the session state
│ │ │ -- see all alerts that are posted
│ │ │ -
│ │ │ -
│ │ │ -
a word of caution
│ │ │ -
Writing your own plugin is a very easy way to introduce serious bugs such as
│ │ │ -dead locks and race conditions. Since a plugin has access to internal
│ │ │ -structures it is also quite easy to sabotage libtorrent's operation.
│ │ │ -
All the callbacks are always called from the libtorrent network thread. In
│ │ │ -case portions of your plugin are called from other threads, typically the main
│ │ │ -thread, you cannot use any of the member functions on the internal structures
│ │ │ -in libtorrent, since those require being called from the libtorrent network
│ │ │ -thread . Furthermore, you also need to synchronize your own shared data
│ │ │ -within the plugin, to make sure it is not accessed at the same time from the
│ │ │ -libtorrent thread (through a callback). If you need to send out a message
│ │ │ -from another thread, it is advised to use an internal queue, and do the
│ │ │ -actual sending in tick().
│ │ │ -
Since the plugin interface gives you easy access to internal structures, it
│ │ │ -is not supported as a stable API. Plugins should be considered specific to a
│ │ │ -specific version of libtorrent. Although, in practice the internals mostly
│ │ │ -don't change that dramatically.
│ │ │ -
│ │ │ -
plugin-interface
│ │ │ -
The plugin interface consists of three base classes that the plugin may
│ │ │ -implement. These are called plugin, torrent_plugin and peer_plugin.
│ │ │ -They are found in the <libtorrent/extensions.hpp> header.
│ │ │ -
These plugins are instantiated for each session, torrent and possibly each peer,
│ │ │ -respectively.
│ │ │ -
For plugins that only need per torrent state, it is enough to only implement
│ │ │ -torrent_plugin and pass a constructor function or function object to
│ │ │ -session::add_extension() or torrent_handle::add_extension() (if the
│ │ │ -torrent has already been started and you want to hook in the extension at
│ │ │ -run-time).
│ │ │ -
The signature of the function is:
│ │ │ -
│ │ │ -std::shared_ptr<torrent_plugin> (*)(torrent_handle const&, client_data_t);
│ │ │ +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
│ │ │ +to the session when passed to session::apply_settings(). It's empty when
│ │ │ +constructed.
│ │ │ +You have control over proxy and authorization settings and also the user-agent
│ │ │ +that will be sent to the tracker. The user-agent will also be used to identify the
│ │ │ +client with other peers.
│ │ │ +Each configuration option is named with an enum value inside the
│ │ │ +settings_pack class. These are the available settings:
│ │ │ +[report issue]
│ │ │ +
disk_observer
│ │ │ +
Declared in "libtorrent/disk_observer.hpp"
│ │ │ +
│ │ │ +struct disk_observer
│ │ │ +{
│ │ │ + virtual void on_disk () = 0;
│ │ │ +};
│ │ │
│ │ │ -
The second argument is the userdata passed to session::add_torrent() or
│ │ │ -torrent_handle::add_extension().
│ │ │ -
The function should return a std::shared_ptr<torrent_plugin> which
│ │ │ -may or may not be 0. If it is a nullptr, the extension is simply ignored
│ │ │ -for this torrent. If it is a valid pointer (to a class inheriting
│ │ │ -torrent_plugin), it will be associated with this torrent and callbacks
│ │ │ -will be made on torrent events.
│ │ │ -
For more elaborate plugins which require session wide state, you would
│ │ │ -implement plugin, construct an object (in a std::shared_ptr) and pass
│ │ │ -it in to session::add_extension().
│ │ │ +
[report issue]
│ │ │ +
on_disk()
│ │ │ +
│ │ │ +virtual void on_disk () = 0;
│ │ │ +
│ │ │ +
called when the disk cache size has dropped
│ │ │ +below the low watermark again and we can
│ │ │ +resume downloading from peers
│ │ │ +
[report issue]
│ │ │
│ │ │ -
custom alerts
│ │ │ -
Since plugins are running within internal libtorrent threads, one convenient
│ │ │ -way to communicate with the client is to post custom alerts.
│ │ │ -
The expected interface of any alert, apart from deriving from the alert
│ │ │ -base class, looks like this:
│ │ │ +
│ │ │ +
open_file_state
│ │ │ +
Declared in "libtorrent/disk_interface.hpp"
│ │ │ +
this contains information about a file that's currently open by the
│ │ │ +libtorrent disk I/O subsystem. It's associated with a single torrent.
│ │ │
│ │ │ -static const int alert_type = <unique alert ID>;
│ │ │ -virtual int type() const { return alert_type; }
│ │ │ -
│ │ │ -virtual std::string message() const;
│ │ │ -
│ │ │ -static const alert_category_t static_category = <bitmask of alert::category_t flags>;
│ │ │ -virtual alert_category_t category() const { return static_category; }
│ │ │ -
│ │ │ -virtual char const* what() const { return <string literal of the name of this alert>; }
│ │ │ +struct open_file_state
│ │ │ +{
│ │ │ + file_index_t file_index;
│ │ │ + file_open_mode_t open_mode;
│ │ │ + time_point last_use;
│ │ │ +};
│ │ │
│ │ │ -
The alert_type is used for the type-checking in alert_cast. It must
│ │ │ -not collide with any other alert. The built-in alerts in libtorrent will
│ │ │ -not use alert type IDs greater than user_alert_id. When defining your
│ │ │ -own alert, make sure it's greater than this constant.
│ │ │ -
type() is the run-time equivalence of the alert_type.
│ │ │ -
The message() virtual function is expected to construct a useful
│ │ │ -string representation of the alert and the event or data it represents.
│ │ │ -Something convenient to put in a log file for instance.
│ │ │ -
clone() is used internally to copy alerts. The suggested implementation
│ │ │ -of simply allocating a new instance as a copy of *this is all that's
│ │ │ -expected.
│ │ │ -
The static category is required for checking whether or not the category
│ │ │ -for a specific alert is enabled or not, without instantiating the alert.
│ │ │ -The category virtual function is the run-time equivalence.
│ │ │ -
The what() virtual function may simply be a string literal of the class
│ │ │ -name of your alert.
│ │ │ -
For more information, see the alert section.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
plugin
│ │ │ -
Declared in "libtorrent/extensions.hpp"
│ │ │ -
this is the base class for a session plugin. One primary feature
│ │ │ -is that it is notified of all torrents that are added to the session,
│ │ │ -and can add its own torrent_plugins.
│ │ │ +
[report issue]
│ │ │ +- file_index
│ │ │ +- the index of the file this entry refers to into the file_storage
│ │ │ +file list of this torrent. This starts indexing at 0.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- open_mode
│ │ │ +open_mode is a bitmask of the file flags this file is currently
│ │ │ +opened with. For possible flags, see file_open_mode_t.
│ │ │ +Note that the read/write mode is not a bitmask. The two least significant bits are used
│ │ │ +to represent the read/write mode. Those bits can be masked out using the rw_mask constant.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- last_use
│ │ │ +- a (high precision) timestamp of when the file was last used.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
disk_interface
│ │ │ +
Declared in "libtorrent/disk_interface.hpp"
│ │ │ +
The disk_interface is the customization point for disk I/O in libtorrent.
│ │ │ +implement this interface and provide a factory function to the session constructor
│ │ │ +use custom disk I/O. All functions on the disk subsystem (implementing
│ │ │ +disk_interface) are called from within libtorrent's network thread. For
│ │ │ +disk I/O to be performed in a separate thread, the disk subsystem has to
│ │ │ +manage that itself.
│ │ │ +
Although the functions are called async_*, they do not technically
│ │ │ +have to be asynchronous, but they support being asynchronous, by
│ │ │ +expecting the result passed back into a callback. The callbacks must be
│ │ │ +posted back onto the network thread via the io_context object passed into
│ │ │ +the constructor. The callbacks will be run in the network thread.
│ │ │
│ │ │ -struct plugin
│ │ │ +struct disk_interface
│ │ │ {
│ │ │ - virtual feature_flags_t implemented_features ();
│ │ │ - virtual std::shared_ptr<torrent_plugin> new_torrent (torrent_handle const&, client_data_t);
│ │ │ - virtual void added (session_handle const&);
│ │ │ - virtual void abort ();
│ │ │ - virtual bool on_dht_request (string_view /* query */
│ │ │ - , udp::endpoint const& /* source */, bdecode_node const& /* message */
│ │ │ - , entry& /* response */);
│ │ │ - virtual void on_alert (alert const*);
│ │ │ - virtual bool on_unknown_torrent (info_hash_t const& /* info_hash */
│ │ │ - , peer_connection_handle const& /* pc */, add_torrent_params& /* p */);
│ │ │ - virtual void on_tick ();
│ │ │ - virtual uint64_t get_unchoke_priority (peer_connection_handle const& /* peer */);
│ │ │ - virtual std::map<std::string, std::string> save_state () const;
│ │ │ - virtual void load_state (std::map<std::string, std::string> const&);
│ │ │ + virtual storage_holder new_torrent (storage_params const& p
│ │ │ + , std::shared_ptr<void> const& torrent) = 0;
│ │ │ + virtual void remove_torrent (storage_index_t) = 0;
│ │ │ + virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ + , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ + , std::function<void(storage_error const&)> handler
│ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ + virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ + , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ + virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ + , disk_job_flags_t flags
│ │ │ + , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │ + virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ + , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │ + virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ + , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │ + virtual void async_release_files (storage_index_t storage
│ │ │ + , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │ + virtual void async_check_files (storage_index_t storage
│ │ │ + , add_torrent_params const* resume_data
│ │ │ + , aux::vector<std::string, file_index_t> links
│ │ │ + , std::function<void(status_t, storage_error const&)> handler) = 0;
│ │ │ + virtual void async_stop_torrent (storage_index_t storage
│ │ │ + , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │ + virtual void async_rename_file (storage_index_t storage
│ │ │ + , file_index_t index, std::string name
│ │ │ + , std::function<void(std::string const&, file_index_t, storage_error const&)> handler) = 0;
│ │ │ + virtual void async_delete_files (storage_index_t storage, remove_flags_t options
│ │ │ + , std::function<void(storage_error const&)> handler) = 0;
│ │ │ + virtual void async_set_file_priority (storage_index_t storage
│ │ │ + , aux::vector<download_priority_t, file_index_t> prio
│ │ │ + , std::function<void(storage_error const&
│ │ │ + , aux::vector<download_priority_t, file_index_t>)> handler) = 0;
│ │ │ + virtual void async_clear_piece (storage_index_t storage, piece_index_t index
│ │ │ + , std::function<void(piece_index_t)> handler) = 0;
│ │ │ + virtual void update_stats_counters (counters& c) const = 0;
│ │ │ + virtual std::vector<open_file_state> get_status (storage_index_t) const = 0;
│ │ │ + virtual void abort (bool wait) = 0;
│ │ │ + virtual void submit_jobs () = 0;
│ │ │ + virtual void settings_updated () = 0;
│ │ │
│ │ │ - static constexpr feature_flags_t optimistic_unchoke_feature = 1_bit;
│ │ │ - static constexpr feature_flags_t tick_feature = 2_bit;
│ │ │ - static constexpr feature_flags_t dht_request_feature = 3_bit;
│ │ │ - static constexpr feature_flags_t alert_feature = 4_bit;
│ │ │ - static constexpr feature_flags_t unknown_torrent_feature = 5_bit;
│ │ │ + static constexpr disk_job_flags_t force_copy = 0_bit;
│ │ │ + static constexpr disk_job_flags_t sequential_access = 3_bit;
│ │ │ + static constexpr disk_job_flags_t volatile_read = 4_bit;
│ │ │ + static constexpr disk_job_flags_t v1_hash = 5_bit;
│ │ │ + static constexpr disk_job_flags_t flush_piece = 7_bit;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
implemented_features()
│ │ │ +
[report issue]
│ │ │ +
new_torrent()
│ │ │
│ │ │ -virtual feature_flags_t implemented_features ();
│ │ │ +virtual storage_holder new_torrent (storage_params const& p
│ │ │ + , std::shared_ptr<void> const& torrent) = 0;
│ │ │
│ │ │ -
This function is expected to return a bitmask indicating which features
│ │ │ -this plugin implements. Some callbacks on this object may not be called
│ │ │ -unless the corresponding feature flag is returned here. Note that
│ │ │ -callbacks may still be called even if the corresponding feature is not
│ │ │ -specified in the return value here. See feature_flags_t for possible
│ │ │ -flags to return.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
new_torrent()
│ │ │ +
this is called when a new torrent is added. The shared_ptr can be
│ │ │ +used to hold the internal torrent object alive as long as there are
│ │ │ +outstanding disk operations on the storage.
│ │ │ +The returned storage_holder is an owning reference to the underlying
│ │ │ +storage that was just created. It is fundamentally a storage_index_t
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
remove_torrent()
│ │ │
│ │ │ -virtual std::shared_ptr<torrent_plugin> new_torrent (torrent_handle const&, client_data_t);
│ │ │ +virtual void remove_torrent (storage_index_t) = 0;
│ │ │
│ │ │ -
this is called by the session every time a new torrent is added.
│ │ │ -The torrent* points to the internal torrent object created
│ │ │ -for the new torrent. The client_data_t is the userdata pointer as
│ │ │ -passed in via add_torrent_params.
│ │ │ -
If the plugin returns a torrent_plugin instance, it will be added
│ │ │ -to the new torrent. Otherwise, return an empty shared_ptr to a
│ │ │ -torrent_plugin (the default).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
added()
│ │ │ +
remove the storage with the specified index. This is not expected to
│ │ │ +delete any files from disk, just to clean up any resources associated
│ │ │ +with the specified storage.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_read() async_write()
│ │ │
│ │ │ -virtual void added (session_handle const&);
│ │ │ +virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ + , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ + , std::function<void(storage_error const&)> handler
│ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ +virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ + , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │
│ │ │ -
called when plugin is added to a session
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
abort()
│ │ │ +
perform a read or write operation from/to the specified storage
│ │ │ +index and the specified request. When the operation completes, call
│ │ │ +handler possibly with a disk_buffer_holder, holding the buffer with
│ │ │ +the result. Flags may be set to affect the read operation. See
│ │ │ +disk_job_flags_t.
│ │ │ +
The disk_observer is a callback to indicate that
│ │ │ +the store buffer/disk write queue is below the watermark to let peers
│ │ │ +start writing buffers to disk again. When async_write() returns
│ │ │ +true, indicating the write queue is full, the peer will stop
│ │ │ +further writes and wait for the passed-in disk_observer to be
│ │ │ +notified before resuming.
│ │ │ +
Note that for async_read, the peer_request (r) is not
│ │ │ +necessarily aligned to blocks (but it is most of the time). However,
│ │ │ +all writes (passed to async_write) are guaranteed to be block
│ │ │ +aligned.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_hash()
│ │ │
│ │ │ -virtual void abort ();
│ │ │ +virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ + , disk_job_flags_t flags
│ │ │ + , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │
│ │ │ -
called when the session is aborted
│ │ │ -the plugin should perform any cleanup necessary to allow the session's
│ │ │ -destruction (e.g. cancel outstanding async operations)
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_dht_request()
│ │ │ +
Compute hash(es) for the specified piece. Unless the v1_hash flag is
│ │ │ +set (in flags), the SHA-1 hash of the whole piece does not need
│ │ │ +to be computed.
│ │ │ +
The v2 span is optional and can be empty, which means v2 hashes
│ │ │ +should not be computed. If v2 is non-empty it must be at least large
│ │ │ +enough to hold all v2 blocks in the piece, and this function will
│ │ │ +fill in the span with the SHA-256 block hashes of the piece.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_hash2()
│ │ │
│ │ │ -virtual bool on_dht_request (string_view /* query */
│ │ │ - , udp::endpoint const& /* source */, bdecode_node const& /* message */
│ │ │ - , entry& /* response */);
│ │ │ +virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ + , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │
│ │ │ -
called when a dht request is received.
│ │ │ -If your plugin expects this to be called, make sure to include the flag
│ │ │ -dht_request_feature in the return value from implemented_features().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_alert()
│ │ │ +
computes the v2 hash (SHA-256) of a single block. The block at
│ │ │ +offset in piece piece.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_move_storage()
│ │ │
│ │ │ -virtual void on_alert (alert const*);
│ │ │ +virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ + , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │
│ │ │ -
called when an alert is posted alerts that are filtered are not posted.
│ │ │ -If your plugin expects this to be called, make sure to include the flag
│ │ │ -alert_feature in the return value from implemented_features().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_unknown_torrent()
│ │ │ +
called to request the files for the specified storage/torrent be
│ │ │ +moved to a new location. It is the disk I/O object's responsibility
│ │ │ +to synchronize this with any currently outstanding disk operations to
│ │ │ +the storage. Whether files are replaced at the destination path or
│ │ │ +not is controlled by flags (see move_flags_t).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_release_files()
│ │ │
│ │ │ -virtual bool on_unknown_torrent (info_hash_t const& /* info_hash */
│ │ │ - , peer_connection_handle const& /* pc */, add_torrent_params& /* p */);
│ │ │ +virtual void async_release_files (storage_index_t storage
│ │ │ + , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │
│ │ │ -
return true if the add_torrent_params should be added
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_tick()
│ │ │ +
This is called on disk I/O objects to request they close all open
│ │ │ +files for the specified storage/torrent. If file handles are not
│ │ │ +pooled/cached, it can be a no-op. For truly asynchronous disk I/O,
│ │ │ +this should provide at least one point in time when all files are
│ │ │ +closed. It is possible that later asynchronous operations will
│ │ │ +re-open some of the files, by the time this completion handler is
│ │ │ +called, that's fine.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_check_files()
│ │ │
│ │ │ -virtual void on_tick ();
│ │ │ +virtual void async_check_files (storage_index_t storage
│ │ │ + , add_torrent_params const* resume_data
│ │ │ + , aux::vector<std::string, file_index_t> links
│ │ │ + , std::function<void(status_t, storage_error const&)> handler) = 0;
│ │ │
│ │ │ -
called once per second.
│ │ │ -If your plugin expects this to be called, make sure to include the flag
│ │ │ -tick_feature in the return value from implemented_features().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
get_unchoke_priority()
│ │ │ +
this is called when torrents are added to validate their resume data
│ │ │ +against the files on disk. This function is expected to do a few things:
│ │ │ +
if links is non-empty, it contains a string for each file in the
│ │ │ +torrent. The string being a path to an existing identical file. The
│ │ │ +default behavior is to create hard links of those files into the
│ │ │ +storage of the new torrent (specified by storage). An empty
│ │ │ +string indicates that there is no known identical file. This is part
│ │ │ +of the "mutable torrent" feature, where files can be reused from
│ │ │ +other torrents.
│ │ │ +
The resume_data points the resume data passed in by the client.
│ │ │ +
If the resume_data->flags field has the seed_mode flag set, all
│ │ │ +files/pieces are expected to be on disk already. This should be
│ │ │ +verified. Not just the existence of the file, but also that it has
│ │ │ +the correct size.
│ │ │ +
Any file with a piece set in the resume_data->have_pieces bitmask
│ │ │ +should exist on disk, this should be verified. Pad files and files
│ │ │ +with zero priority may be skipped.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_stop_torrent()
│ │ │
│ │ │ -virtual uint64_t get_unchoke_priority (peer_connection_handle const& /* peer */);
│ │ │ +virtual void async_stop_torrent (storage_index_t storage
│ │ │ + , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │
│ │ │ -
called when choosing peers to optimistically unchoke. The return value
│ │ │ -indicates the peer's priority for unchoking. Lower return values
│ │ │ -correspond to higher priority. Priorities above 2^63-1 are reserved.
│ │ │ -If your plugin has no priority to assign a peer it should return 2^64-1.
│ │ │ -If your plugin expects this to be called, make sure to include the flag
│ │ │ -optimistic_unchoke_feature in the return value from implemented_features().
│ │ │ -If multiple plugins implement this function the lowest return value
│ │ │ -(i.e. the highest priority) is used.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
load_state()
│ │ │ +
This is called when a torrent is stopped. It gives the disk I/O
│ │ │ +object an opportunity to flush any data to disk that's currently kept
│ │ │ +cached. This function should at least do the same thing as
│ │ │ +async_release_files().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_rename_file()
│ │ │
│ │ │ -virtual void load_state (std::map<std::string, std::string> const&);
│ │ │ +virtual void async_rename_file (storage_index_t storage
│ │ │ + , file_index_t index, std::string name
│ │ │ + , std::function<void(std::string const&, file_index_t, storage_error const&)> handler) = 0;
│ │ │
│ │ │ -
called on startup while loading settings state from the session_params
│ │ │ -
[report issue]
│ │ │ -- optimistic_unchoke_feature
│ │ │ -- include this bit if your plugin needs to alter the order of the
│ │ │ -optimistic unchoke of peers. i.e. have the on_optimistic_unchoke()
│ │ │ -callback be called.
│ │ │ +This function is called when the name of a file in the specified
│ │ │ +storage has been requested to be renamed. The disk I/O object is
│ │ │ +responsible for renaming the file without racing with other
│ │ │ +potentially outstanding operations against the file (such as read,
│ │ │ +write, move, etc.).
│ │ │ +[report issue]
│ │ │ +
│ │ │ +
async_delete_files()
│ │ │ +
│ │ │ +virtual void async_delete_files (storage_index_t storage, remove_flags_t options
│ │ │ + , std::function<void(storage_error const&)> handler) = 0;
│ │ │ +
│ │ │ +
This function is called when some file(s) on disk have been requested
│ │ │ +to be removed by the client. storage indicates which torrent is
│ │ │ +referred to. See session_handle for remove_flags_t flags
│ │ │ +indicating which files are to be removed.
│ │ │ +e.g. session_handle::delete_files - delete all files
│ │ │ +session_handle::delete_partfile - only delete part file.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_set_file_priority()
│ │ │ +
│ │ │ +virtual void async_set_file_priority (storage_index_t storage
│ │ │ + , aux::vector<download_priority_t, file_index_t> prio
│ │ │ + , std::function<void(storage_error const&
│ │ │ + , aux::vector<download_priority_t, file_index_t>)> handler) = 0;
│ │ │ +
│ │ │ +
This is called to set the priority of some or all files. Changing the
│ │ │ +priority from or to 0 may involve moving data to and from the
│ │ │ +partfile. The disk I/O object is responsible for correctly
│ │ │ +synchronizing this work to not race with any potentially outstanding
│ │ │ +asynchronous operations affecting these files.
│ │ │ +
prio is a vector of the file priority for all files. If it's
│ │ │ +shorter than the total number of files in the torrent, they are
│ │ │ +assumed to be set to the default priority.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
async_clear_piece()
│ │ │ +
│ │ │ +virtual void async_clear_piece (storage_index_t storage, piece_index_t index
│ │ │ + , std::function<void(piece_index_t)> handler) = 0;
│ │ │ +
│ │ │ +
This is called when a piece fails the hash check, to ensure there are
│ │ │ +no outstanding disk operations to the piece before blocks are
│ │ │ +re-requested from peers to overwrite the existing blocks. The disk I/O
│ │ │ +object does not need to perform any action other than synchronize
│ │ │ +with all outstanding disk operations to the specified piece before
│ │ │ +posting the result back.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
update_stats_counters()
│ │ │ +
│ │ │ +virtual void update_stats_counters (counters& c) const = 0;
│ │ │ +
│ │ │ +
update_stats_counters() is called to give the disk storage an
│ │ │ +opportunity to update gauges in the c stats counters, that aren't
│ │ │ +updated continuously as operations are performed. This is called
│ │ │ +before a snapshot of the counters are passed to the client.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get_status()
│ │ │ +
│ │ │ +virtual std::vector<open_file_state> get_status (storage_index_t) const = 0;
│ │ │ +
│ │ │ +
Return a list of all the files that are currently open for the
│ │ │ +specified storage/torrent. This is is just used for the client to
│ │ │ +query the currently open files, and which modes those files are open
│ │ │ +in.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
abort()
│ │ │ +
│ │ │ +virtual void abort (bool wait) = 0;
│ │ │ +
│ │ │ +
this is called when the session is starting to shut down. The disk
│ │ │ +I/O object is expected to flush any outstanding write jobs, cancel
│ │ │ +hash jobs and initiate tearing down of any internal threads. If
│ │ │ +wait is true, this should be asynchronous. i.e. this call should
│ │ │ +not return until all threads have stopped and all jobs have either
│ │ │ +been aborted or completed and the disk I/O object is ready to be
│ │ │ +destructed.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
submit_jobs()
│ │ │ +
│ │ │ +virtual void submit_jobs () = 0;
│ │ │ +
│ │ │ +
This will be called after a batch of disk jobs has been issues (via
│ │ │ +the async_* ). It gives the disk I/O object an opportunity to
│ │ │ +notify any potential condition variables to wake up the disk
│ │ │ +thread(s). The async_* calls can of course also notify condition
│ │ │ +variables, but doing it in this call allows for batching jobs, by
│ │ │ +issuing the notification once for a collection of jobs.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
settings_updated()
│ │ │ +
│ │ │ +virtual void settings_updated () = 0;
│ │ │ +
│ │ │ +
This is called to notify the disk I/O object that the settings have
│ │ │ +been updated. In the disk io constructor, a settings_interface
│ │ │ +reference is passed in. Whenever these settings are updated, this
│ │ │ +function is called to allow the disk I/O object to react to any
│ │ │ +changed settings relevant to its operations.
│ │ │ +
[report issue]
│ │ │ +- force_copy
│ │ │ +- force making a copy of the cached block, rather than getting a
│ │ │ +reference to a block already in the cache. This is used the block is
│ │ │ +expected to be overwritten very soon, by async_write()`, and we need
│ │ │ +access to the previous content.
│ │ │
│ │ │ -
[report issue]
│ │ │ -- tick_feature
│ │ │ -- include this bit if your plugin needs to have on_tick() called
│ │ │ +[report issue]
│ │ │ +- sequential_access
│ │ │ +- hint that there may be more disk operations with sequential access to
│ │ │ +the file
│ │ │
│ │ │ -[report issue]
│ │ │ -- dht_request_feature
│ │ │ -- include this bit if your plugin needs to have on_dht_request()
│ │ │ -called
│ │ │ +[report issue]
│ │ │ +- volatile_read
│ │ │ +- don't keep the read block in cache. This is a hint that this block is
│ │ │ +unlikely to be read again anytime soon, and caching it would be
│ │ │ +wasteful.
│ │ │
│ │ │ -[report issue]
│ │ │ -- alert_feature
│ │ │ -- include this bit if your plugin needs to have on_alert()
│ │ │ -called
│ │ │ +[report issue]
│ │ │ +- v1_hash
│ │ │ +- compute a v1 piece hash. This is only used by the async_hash() call.
│ │ │ +If this flag is not set in the async_hash() call, the SHA-1 piece
│ │ │ +hash does not need to be computed.
│ │ │
│ │ │ -[report issue]
│ │ │ -- unknown_torrent_feature
│ │ │ -- include this bit if your plugin needs to have on_unknown_torrent()
│ │ │ -called even if there is no active torrent in the session
│ │ │ +[report issue]
│ │ │ +- flush_piece
│ │ │ +- this flag instructs a hash job that we just completed this piece, and
│ │ │ +it should be flushed to disk
│ │ │
│ │ │ -[report issue]
│ │ │ +
[report issue]
│ │ │
│ │ │ -
│ │ │ -
torrent_plugin
│ │ │ -
Declared in "libtorrent/extensions.hpp"
│ │ │ -
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.
│ │ │ +
│ │ │ +
storage_holder
│ │ │ +
Declared in "libtorrent/disk_interface.hpp"
│ │ │ +
a unique, owning, reference to the storage of a torrent in a disk io
│ │ │ +subsystem (class that implements disk_interface). This is held by the
│ │ │ +internal libtorrent torrent object to tie the storage object allocated
│ │ │ +for a torrent to the lifetime of the internal torrent object. When a
│ │ │ +torrent is removed from the session, this holder is destructed and will
│ │ │ +inform the disk object.
│ │ │
│ │ │ -struct torrent_plugin
│ │ │ +struct storage_holder
│ │ │ {
│ │ │ - virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ - virtual void on_piece_failed (piece_index_t);
│ │ │ - virtual void on_piece_pass (piece_index_t);
│ │ │ - virtual void 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);
│ │ │ -
│ │ │ - static constexpr add_peer_flags_t first_time = 1_bit;
│ │ │ - static constexpr add_peer_flags_t filtered = 2_bit;
│ │ │ + storage_holder () = default;
│ │ │ + ~storage_holder ();
│ │ │ + storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ + explicit operator bool () const;
│ │ │ + operator storage_index_t () const;
│ │ │ + void reset ();
│ │ │ + storage_holder& operator= (storage_holder const&) = delete;
│ │ │ + storage_holder (storage_holder const&) = delete;
│ │ │ + storage_holder (storage_holder&& rhs) noexcept;
│ │ │ + storage_holder& operator= (storage_holder&& rhs) noexcept;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ +
│ │ │ +
settings_interface
│ │ │ +
Declared in "libtorrent/settings_pack.hpp"
│ │ │ +
the common interface to settings_pack and the internal representation of
│ │ │ +settings.
│ │ │
│ │ │ -virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ +struct settings_interface
│ │ │ +{
│ │ │ + virtual void set_int (int name, int val) = 0;
│ │ │ + virtual void set_str (int name, std::string val) = 0;
│ │ │ + virtual bool has_val (int name) const = 0;
│ │ │ + virtual void set_bool (int name, bool val) = 0;
│ │ │ + virtual std::string const& get_str (int name) const = 0;
│ │ │ + virtual bool get_bool (int name) const = 0;
│ │ │ + virtual int get_int (int name) const = 0;
│ │ │ +};
│ │ │
│ │ │ -
This function is called each time a new peer is connected to the torrent. You
│ │ │ -may choose to ignore this by just returning a default constructed
│ │ │ -shared_ptr (in which case you don't need to override this member
│ │ │ -function).
│ │ │ -
If you need an extension to the peer connection (which most plugins do) you
│ │ │ -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_failed() on_piece_pass()
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
buffer_allocator_interface
│ │ │ +
Declared in "libtorrent/disk_buffer_holder.hpp"
│ │ │ +
the interface for freeing disk buffers, used by the disk_buffer_holder.
│ │ │ +when implementing disk_interface, this must also be implemented in order
│ │ │ +to return disk buffers back to libtorrent
│ │ │
│ │ │ -virtual void on_piece_failed (piece_index_t);
│ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ +struct buffer_allocator_interface
│ │ │ +{
│ │ │ + virtual void free_disk_buffer (char* b) = 0;
│ │ │ +};
│ │ │
│ │ │ -
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]
│ │ │ -
│ │ │ +
│ │ │ +
disk_buffer_holder
│ │ │ +
Declared in "libtorrent/disk_buffer_holder.hpp"
│ │ │ +
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.
│ │ │
│ │ │ -virtual void tick ();
│ │ │ +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 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;
│ │ │ + bool is_mutable () const noexcept;
│ │ │ + explicit operator bool () const noexcept;
│ │ │ + std::ptrdiff_t size () const;
│ │ │ +};
│ │ │
│ │ │ -
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]
│ │ │ +
disk_buffer_holder()
│ │ │
│ │ │ -virtual bool on_pause ();
│ │ │ -virtual bool on_resume ();
│ │ │ +disk_buffer_holder (buffer_allocator_interface& alloc
│ │ │ + , char* buf, int sz) noexcept;
│ │ │
│ │ │ -
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.
│ │ │ -
Note that if you call pause() or resume() on the torrent from your
│ │ │ -handler it will recurse back into your handler, so in order to invoke the
│ │ │ -standard handler, you have to keep your own state on whether you want standard
│ │ │ -behavior or overridden behavior.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_files_checked()
│ │ │ +
construct a buffer holder that will free the held buffer
│ │ │ +using a disk buffer pool directly (there's only one
│ │ │ +disk_buffer_pool per session)
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
disk_buffer_holder()
│ │ │
│ │ │ -virtual void on_files_checked ();
│ │ │ +disk_buffer_holder () noexcept = default;
│ │ │
│ │ │ -
This function is called when the initial files of the torrent have been
│ │ │ -checked. If there are no files to check, this function is called immediately.
│ │ │ -
i.e. This function is always called when the torrent is in a state where it
│ │ │ -can start downloading.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_state()
│ │ │ +
default construct a holder that does not own any buffer
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
~disk_buffer_holder()
│ │ │
│ │ │ -virtual void on_state (torrent_status::state_t);
│ │ │ +~disk_buffer_holder ();
│ │ │
│ │ │ -
called when the torrent changes state
│ │ │ -the state is one of torrent_status::state_t
│ │ │ -enum members
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_add_peer()
│ │ │ +
frees disk buffer held by this object
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
data()
│ │ │
│ │ │ -virtual void on_add_peer (tcp::endpoint const&,
│ │ │ - peer_source_flags_t, add_peer_flags_t);
│ │ │ +char* data () const noexcept;
│ │ │
│ │ │ -
called every time a new peer is added to the peer list.
│ │ │ -This is before the peer is connected to. For flags, see
│ │ │ -torrent_plugin::flags_t. The source argument refers to
│ │ │ -the source where we learned about this peer from. It's a
│ │ │ -bitmask, because many sources may have told us about the same
│ │ │ -peer. For peer source flags, see peer_info::peer_source_flags.
│ │ │ -
[report issue]
│ │ │ -- first_time
│ │ │ -- this is the first time we see this peer
│ │ │ +return a pointer to the held buffer, if any. Otherwise returns nullptr.
│ │ │ +[report issue]
│ │ │ +
│ │ │ +
reset()
│ │ │ +
│ │ │ +void reset ();
│ │ │ +
│ │ │ +
free the held disk buffer, if any, and clear the holder. This sets the
│ │ │ +holder object to a default-constructed state
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
swap()
│ │ │ +
│ │ │ +void swap (disk_buffer_holder& h) noexcept;
│ │ │ +
│ │ │ +
swap pointers of two disk buffer holders.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
is_mutable()
│ │ │ +
│ │ │ +bool is_mutable () const noexcept;
│ │ │ +
│ │ │ +
if this returns true, the buffer may not be modified in place
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
bool()
│ │ │ +
│ │ │ +explicit operator bool () const noexcept;
│ │ │ +
│ │ │ +
implicitly convertible to true if the object is currently holding a
│ │ │ +buffer
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
file_open_mode_t
│ │ │ +
Declared in "libtorrent/disk_interface.hpp"
│ │ │ +
│ │ │ +- read_only
│ │ │ +- open the file for reading only
│ │ │
│ │ │ -
[report issue]
│ │ │ -- filtered
│ │ │ -- this peer was not added because it was
│ │ │ -filtered by the IP filter
│ │ │ +
│ │ │ +- write_only
│ │ │ +- open the file for writing only
│ │ │
│ │ │ -[report issue]
│ │ │ +
│ │ │ +- read_write
│ │ │ +- open the file for reading and writing
│ │ │ +
│ │ │ +
│ │ │ +- rw_mask
│ │ │ +- the mask for the bits determining read or write mode
│ │ │ +
│ │ │ +
│ │ │ +- sparse
│ │ │ +- open the file in sparse mode (if supported by the
│ │ │ +filesystem).
│ │ │ +
│ │ │ +
│ │ │ +- no_atime
│ │ │ +- don't update the access timestamps on the file (if
│ │ │ +supported by the operating system and filesystem).
│ │ │ +this generally improves disk performance.
│ │ │ +
│ │ │ +
│ │ │ +- random_access
│ │ │ +- When this is not set, the kernel is hinted that access to this file will
│ │ │ +be made sequentially.
│ │ │ +
│ │ │ +
│ │ │ +- mmapped
│ │ │ +- the file is memory mapped
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
announce_infohash
│ │ │ +
Declared in "libtorrent/announce_entry.hpp"
│ │ │ +
│ │ │ +struct announce_infohash
│ │ │ +{
│ │ │ + std::string message;
│ │ │ + error_code last_error;
│ │ │ + int scrape_incomplete = -1;
│ │ │ + int scrape_complete = -1;
│ │ │ + int scrape_downloaded = -1;
│ │ │ + std::uint8_t fails : 7;
│ │ │ + bool updating : 1;
│ │ │ + bool start_sent : 1;
│ │ │ + bool complete_sent : 1;
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- message
│ │ │ +- if this tracker has returned an error or warning message
│ │ │ +that message is stored here
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- last_error
│ │ │ +- if this tracker failed the last time it was contacted
│ │ │ +this error code specifies what error occurred
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- scrape_incomplete scrape_complete scrape_downloaded
│ │ │ +- if this tracker has returned scrape data, these fields are filled in
│ │ │ +with valid numbers. Otherwise they are set to -1. incomplete counts
│ │ │ +the number of current downloaders. complete counts the number of
│ │ │ +current peers completed the download, or "seeds". downloaded is the
│ │ │ +cumulative number of completed downloads.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- fails
│ │ │ +- the number of times in a row we have failed to announce to this
│ │ │ +tracker.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- updating
│ │ │ +- true while we're waiting for a response from the tracker.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- start_sent
│ │ │ +- set to true when we get a valid response from an announce
│ │ │ +with event=started. If it is set, we won't send start in the subsequent
│ │ │ +announces.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- complete_sent
│ │ │ +- set to true when we send a event=completed.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
announce_endpoint
│ │ │ +
Declared in "libtorrent/announce_entry.hpp"
│ │ │ +
announces are sent to each tracker using every listen socket
│ │ │ +this class holds information about one listen socket for one tracker
│ │ │ +
│ │ │ +struct announce_endpoint
│ │ │ +{
│ │ │ + announce_endpoint ();
│ │ │ +
│ │ │ + tcp::endpoint local_endpoint;
│ │ │ + aux::array<announce_infohash, num_protocols, protocol_version> info_hashes;
│ │ │ + bool enabled = true;
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- local_endpoint
│ │ │ +- the local endpoint of the listen interface associated with this endpoint
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- info_hashes
│ │ │ +- info_hashes[0] is the v1 info hash (SHA1)
│ │ │ +info_hashes[1] is the v2 info hash (truncated SHA-256)
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- enabled
│ │ │ +- set to false to not announce from this endpoint
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
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
│ │ │ +{
│ │ │ + explicit announce_entry (string_view u);
│ │ │ + announce_entry& operator= (announce_entry const&) &;
│ │ │ + ~announce_entry ();
│ │ │ + announce_entry ();
│ │ │ + announce_entry (announce_entry const&);
│ │ │ +
│ │ │ + enum tracker_source
│ │ │ + {
│ │ │ + source_torrent,
│ │ │ + source_client,
│ │ │ + source_magnet_link,
│ │ │ + source_tex,
│ │ │ + };
│ │ │ +
│ │ │ + std::string url;
│ │ │ + std::string trackerid;
│ │ │ + 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]
│ │ │ +
operator=() ~announce_entry() announce_entry()
│ │ │ +
│ │ │ +explicit announce_entry (string_view u);
│ │ │ +announce_entry& operator= (announce_entry const&) &;
│ │ │ +~announce_entry ();
│ │ │ +announce_entry ();
│ │ │ +announce_entry (announce_entry const&);
│ │ │ +
│ │ │ +
constructs a tracker announce entry with u as the URL.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum tracker_source
│ │ │ +
Declared in "libtorrent/announce_entry.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| source_torrent |
│ │ │ +1 |
│ │ │ +the tracker was part of the .torrent file |
│ │ │ +
│ │ │ +| source_client |
│ │ │ +2 |
│ │ │ +the tracker was added programmatically via the add_tracker() function |
│ │ │ +
│ │ │ +| source_magnet_link |
│ │ │ +4 |
│ │ │ +the tracker was part of a magnet link |
│ │ │ +
│ │ │ +| source_tex |
│ │ │ +8 |
│ │ │ +the tracker was received from the swarm via tracker exchange |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- url
│ │ │ +- tracker URL as it appeared in the torrent file
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- trackerid
│ │ │ +- the current &trackerid= argument passed to the tracker.
│ │ │ +this is optional and is normally empty (in which case no
│ │ │ +trackerid is sent).
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- endpoints
│ │ │ +- each local listen socket (endpoint) will announce to the tracker. This
│ │ │ +list contains state per endpoint.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- tier
│ │ │ +- the tier this tracker belongs to
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- fail_limit
│ │ │ +- the max number of failures to announce to this tracker in
│ │ │ +a row, before this tracker is not used anymore. 0 means unlimited
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- source
│ │ │ +- a bitmask specifying which sources we got this tracker from.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- verified
│ │ │ +- set to true the first time we receive a valid response
│ │ │ +from this tracker.
│ │ │ +
│ │ │ +
[report issue]
│ │ │
│ │ │ -
│ │ │ -
peer_plugin
│ │ │ -
Declared in "libtorrent/extensions.hpp"
│ │ │ -
peer plugins are associated with a specific peer. A peer could be
│ │ │ -both a regular bittorrent peer (bt_peer_connection) or one of the
│ │ │ -web seed connections (web_peer_connection or http_seed_connection).
│ │ │ -In order to only attach to certain peers, make your
│ │ │ -torrent_plugin::new_connection only return a plugin for certain peer
│ │ │ -connection types
│ │ │ +
│ │ │ +
session_params
│ │ │ +
Declared in "libtorrent/session_params.hpp"
│ │ │ +
The session_params is a parameters pack for configuring the session
│ │ │ +before it's started.
│ │ │
│ │ │ -struct peer_plugin
│ │ │ +struct session_params
│ │ │ {
│ │ │ - 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_dont_have (piece_index_t);
│ │ │ - virtual bool on_have_none ();
│ │ │ - virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ - virtual bool on_allowed_fast (piece_index_t);
│ │ │ - virtual bool on_request (peer_request const&);
│ │ │ - virtual bool on_not_interested ();
│ │ │ - virtual bool on_have_all ();
│ │ │ - virtual bool on_unchoke ();
│ │ │ - virtual bool on_choke ();
│ │ │ - virtual bool on_have (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_suggest (piece_index_t);
│ │ │ - virtual bool on_cancel (peer_request const&);
│ │ │ - virtual void sent_suggest (piece_index_t);
│ │ │ - virtual void sent_allow_fast (piece_index_t);
│ │ │ - virtual void sent_request (peer_request const&);
│ │ │ - virtual void sent_have_all ();
│ │ │ - virtual void sent_have_none ();
│ │ │ - virtual void sent_cancel (peer_request const&);
│ │ │ - virtual void sent_reject_request (peer_request const&);
│ │ │ - virtual void sent_choke ();
│ │ │ - virtual void sent_piece (peer_request const&);
│ │ │ - virtual void sent_unchoke ();
│ │ │ - virtual void sent_interested ();
│ │ │ - virtual void sent_not_interested ();
│ │ │ - virtual void sent_have (piece_index_t);
│ │ │ - virtual void sent_payload (int /* bytes */);
│ │ │ - virtual bool can_disconnect (error_code const& /*ec*/);
│ │ │ - virtual bool on_extended (int /*length*/, int /*msg*/,
│ │ │ - span<char const> /*body*/);
│ │ │ - virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ - span<char const> /*body*/);
│ │ │ - virtual void on_piece_failed (piece_index_t);
│ │ │ - virtual void on_piece_pass (piece_index_t);
│ │ │ - virtual void tick ();
│ │ │ - virtual bool write_request (peer_request const&);
│ │ │ + session_params ();
│ │ │ + session_params (settings_pack const& sp);
│ │ │ + session_params (settings_pack&& 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]
│ │ │ -
type()
│ │ │ +
[report issue]
│ │ │ +
session_params()
│ │ │
│ │ │ -virtual string_view type () const;
│ │ │ +session_params ();
│ │ │ +session_params (settings_pack const& sp);
│ │ │ +session_params (settings_pack&& sp);
│ │ │
│ │ │ -
This function is expected to return the name of
│ │ │ -the plugin.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
add_handshake()
│ │ │ +
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()
│ │ │
│ │ │ -virtual void add_handshake (entry&);
│ │ │ +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);
│ │ │
│ │ │ -
can add entries to the extension handshake
│ │ │ -this is not called for web seeds
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_disconnect()
│ │ │ +
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
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- extensions
│ │ │ +- the plugins to add to the session as it is constructed
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- dht_state
│ │ │ +- DHT node ID and node addresses to bootstrap the DHT with.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- dht_storage_constructor
│ │ │ +- function object to construct the storage object for DHT items.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- disk_io_constructor
│ │ │ +- function object to create the disk I/O subsystem. Defaults to
│ │ │ +default_disk_io_constructor.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- ext_state
│ │ │ +- this container can be used by extensions/plugins to store settings. It's
│ │ │ +primarily here to make it convenient to save and restore state across
│ │ │ +sessions, using read_session_params() and write_session_params().
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- ip_filter
│ │ │ +- the IP filter to use for the session. This restricts which peers are allowed
│ │ │ +to connect. As if passed to set_ip_filter().
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
session_handle
│ │ │ +
Declared in "libtorrent/session_handle.hpp"
│ │ │ +
this class provides a non-owning handle to a session and a subset of the
│ │ │ +interface of the session class. If the underlying session is destructed
│ │ │ +any handle to it will no longer be valid. is_valid() will return false and
│ │ │ +any operation on it will throw a system_error exception, with error code
│ │ │ +invalid_session_handle.
│ │ │
│ │ │ -virtual void on_disconnect (error_code const&);
│ │ │ +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 post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │ + void post_session_stats ();
│ │ │ + void post_dht_stats ();
│ │ │ + void set_dht_state (dht::dht_state&& st);
│ │ │ + void set_dht_state (dht::dht_state const& st);
│ │ │ + torrent_handle find_torrent (sha1_hash const& info_hash) const;
│ │ │ + std::vector<torrent_handle> get_torrents () const;
│ │ │ + torrent_handle add_torrent (add_torrent_params 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);
│ │ │ + void async_add_torrent (add_torrent_params&& params);
│ │ │ + torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ + 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_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);
│ │ │ + 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;
│ │ │ + void set_peer_class_filter (ip_filter const& f);
│ │ │ + ip_filter get_peer_class_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);
│ │ │ + 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 = {});
│ │ │ + settings_pack get_settings () const;
│ │ │ + void apply_settings (settings_pack&&);
│ │ │ + void apply_settings (settings_pack const&);
│ │ │ + void pop_alerts (std::vector<alert*>* alerts);
│ │ │ + alert* wait_for_alert (time_duration max_wait);
│ │ │ + 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;
│ │ │ +
│ │ │ + 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;
│ │ │ + static constexpr peer_class_t global_peer_class_id {0};
│ │ │ + static constexpr peer_class_t tcp_peer_class_id {1};
│ │ │ + static constexpr peer_class_t local_peer_class_id {2};
│ │ │ + static constexpr remove_flags_t delete_files = 0_bit;
│ │ │ + static constexpr remove_flags_t delete_partfile = 1_bit;
│ │ │ + static constexpr session_flags_t paused = 2_bit;
│ │ │ + static constexpr portmap_protocol udp = portmap_protocol::udp;
│ │ │ + static constexpr portmap_protocol tcp = portmap_protocol::tcp;
│ │ │ + static constexpr reopen_network_flags_t reopen_map_ports = 0_bit;
│ │ │ +};
│ │ │
│ │ │ -
called when the peer is being disconnected.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_connected()
│ │ │ +
[report issue]
│ │ │ +
is_valid()
│ │ │
│ │ │ -virtual void on_connected ();
│ │ │ +bool is_valid () const;
│ │ │
│ │ │ -
called when the peer is successfully connected. Note that
│ │ │ -incoming connections will have been connected by the time
│ │ │ -the peer plugin is attached to it, and won't have this hook
│ │ │ -called.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_handshake()
│ │ │ +
returns true if this handle refers to a valid session object. If the
│ │ │ +session has been destroyed, all session_handle objects will expire and
│ │ │ +not be valid.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
session_state()
│ │ │
│ │ │ -virtual bool on_handshake (span<char const>);
│ │ │ +session_params session_state (save_state_flags_t flags = save_state_flags_t::all()) const;
│ │ │
│ │ │ -
this is called when the initial bittorrent handshake is received.
│ │ │ -Returning false means that the other end doesn't support this extension
│ │ │ -and will remove it from the list of plugins. this is not called for web
│ │ │ -seeds
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_extension_handshake()
│ │ │ +
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()
│ │ │
│ │ │ -virtual bool on_extension_handshake (bdecode_node 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;
│ │ │
│ │ │ -
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_request() on_dont_have() on_have_all() on_choke() on_not_interested() on_interested() on_unchoke() on_allowed_fast() on_have_none() on_have() on_bitfield()
│ │ │ +
│ │ │ +
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 torrent_status 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 should be included and false means
│ │ │ +excluded. The flags argument is the same as to
│ │ │ +torrent_handle::status(). Since pred is guaranteed to be
│ │ │ +called for every torrent, it may be used to count the number of
│ │ │ +torrents of different categories as well.
│ │ │ +
refresh_torrent_status takes a vector of torrent_status structs
│ │ │ +(for instance the same vector that was returned by
│ │ │ +get_torrent_status() ) and refreshes the status based on the
│ │ │ +handle member. It is possible to use this function by first
│ │ │ +setting up a vector of default constructed torrent_status objects,
│ │ │ +only initializing the handle member, in order to request the
│ │ │ +torrent status for multiple torrents in a single call. This can save a
│ │ │ +significant amount of time if you have a lot of torrents.
│ │ │ +
Any torrent_status object whose handle member is not referring to
│ │ │ +a valid torrent are ignored.
│ │ │ +
The intended use of these functions is to start off by calling
│ │ │ +get_torrent_status() to get a list of all torrents that match your
│ │ │ +criteria. Then call refresh_torrent_status() on that list. This
│ │ │ +will only refresh the status for the torrents in your list, and thus
│ │ │ +ignore all other torrents you might be running. This may save a
│ │ │ +significant amount of time, especially if the number of torrents you're
│ │ │ +interested in is small. In order to keep your list of interested
│ │ │ +torrents up to date, you can either call get_torrent_status() from
│ │ │ +time to time, to include torrents you might have become interested in
│ │ │ +since the last time. In order to stop refreshing a certain torrent,
│ │ │ +simply remove it from the list.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
post_torrent_updates()
│ │ │
│ │ │ -virtual bool on_interested ();
│ │ │ -virtual bool on_dont_have (piece_index_t);
│ │ │ -virtual bool on_have_none ();
│ │ │ -virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ -virtual bool on_request (peer_request const&);
│ │ │ -virtual bool on_not_interested ();
│ │ │ -virtual bool on_have_all ();
│ │ │ -virtual bool on_unchoke ();
│ │ │ -virtual bool on_choke ();
│ │ │ -virtual bool on_have (piece_index_t);
│ │ │ +void post_torrent_updates (status_flags_t flags = status_flags_t::all());
│ │ │
│ │ │ -
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]
│ │ │ -
│ │ │ -
on_piece()
│ │ │ +
This functions instructs the session to post the state_update_alert,
│ │ │ +containing the status of all torrents whose state changed since the
│ │ │ +last time this function was called.
│ │ │ +
Only torrents who has the state subscription flag set will be
│ │ │ +included. This flag is on by default. See add_torrent_params.
│ │ │ +the flags argument is the same as for torrent_handle::status().
│ │ │ +see status_flags_t in torrent_handle.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
post_session_stats()
│ │ │
│ │ │ -virtual bool on_piece (peer_request const& /*piece*/
│ │ │ - , span<char const> /*buf*/);
│ │ │ +void post_session_stats ();
│ │ │
│ │ │ -
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]
│ │ │ -
│ │ │ +
│ │ │ +
post_dht_stats()
│ │ │ +
│ │ │ +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);
│ │ │ +
│ │ │ +
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()
│ │ │ +
│ │ │ +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()
│ │ │ +
│ │ │ +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);
│ │ │ +void async_add_torrent (add_torrent_params&& params);
│ │ │ +torrent_handle add_torrent (add_torrent_params&& params);
│ │ │ +
│ │ │ +
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
│ │ │ +the torrent being added is sent as add_torrent_alert.
│ │ │ +
The save_path field in add_torrent_params must be set to a valid
│ │ │ +path where the files for the torrent will be saved. Even when using a
│ │ │ +custom storage, this needs to be set to something. If the save_path
│ │ │ +is empty, the call to add_torrent() will throw a system_error
│ │ │ +exception.
│ │ │ +
The overload that does not take an error_code throws an exception on
│ │ │ +error and is not available when building without exception support.
│ │ │ +The torrent_handle returned by add_torrent() can be used to retrieve
│ │ │ +information about the torrent's progress, its peers etc. It is also
│ │ │ +used to abort a torrent.
│ │ │ +
If the torrent you are trying to add already exists in the session (is
│ │ │ +either queued for checking, being checked or downloading)
│ │ │ +add_torrent() will throw system_error which derives from
│ │ │ +std::exception unless duplicate_is_error is set to false. In that
│ │ │ +case, add_torrent() will return the handle to the existing torrent.
│ │ │ +
The add_torrent_params class has a flags field. It can be used to
│ │ │ +control what state the new torrent will be added in. Common flags to
│ │ │ +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()
│ │ │ +
│ │ │ +void resume ();
│ │ │ +bool is_paused () const;
│ │ │ +void pause ();
│ │ │ +
│ │ │ +
Pausing the session has the same effect as pausing every torrent in
│ │ │ +it, except that torrents will not be resumed by the auto-manage
│ │ │ +mechanism. Resuming will restore the torrents to their previous paused
│ │ │ +state. i.e. the session pause state is separate from the torrent pause
│ │ │ +state. A torrent is inactive if it is paused or if the session is
│ │ │ +paused.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
is_dht_running()
│ │ │ +
│ │ │ +bool is_dht_running () const;
│ │ │ +
│ │ │ +
is_dht_running() returns true if the DHT support has been started
│ │ │ +and false otherwise.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_dht_storage()
│ │ │ +
│ │ │ +void set_dht_storage (dht::dht_storage_constructor_type sc);
│ │ │ +
│ │ │ +
set_dht_storage set a dht custom storage constructor function
│ │ │ +to be used internally when the dht is created.
│ │ │ +
Since the dht storage is a critical component for the dht behavior,
│ │ │ +this function will only be effective the next time the dht is started.
│ │ │ +If you never touch this feature, a default map-memory based storage
│ │ │ +is used.
│ │ │ +
If you want to make sure the dht is initially created with your
│ │ │ +custom storage, create a session with the setting
│ │ │ +settings_pack::enable_dht to false, set your constructor function
│ │ │ +and call apply_settings with settings_pack::enable_dht to true.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_dht_node()
│ │ │ +
│ │ │ +void add_dht_node (std::pair<std::string, int> const& node);
│ │ │ +
│ │ │ +
add_dht_node takes a host name and port pair. That endpoint will be
│ │ │ +pinged, and if a valid DHT reply is received, the node will be added to
│ │ │ +the routing table.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_get_item()
│ │ │ +
│ │ │ +void dht_get_item (sha1_hash const& target);
│ │ │ +
│ │ │ +
query the DHT for an immutable item at the target hash.
│ │ │ +the result is posted as a dht_immutable_item_alert.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_get_item()
│ │ │ +
│ │ │ +void dht_get_item (std::array<char, 32> key
│ │ │ + , std::string salt = std::string());
│ │ │ +
│ │ │ +
query the DHT for a mutable item under the public key key.
│ │ │ +this is an ed25519 key. salt is optional and may be left
│ │ │ +as an empty string if no salt is to be used.
│ │ │ +if the item is found in the DHT, a dht_mutable_item_alert is
│ │ │ +posted.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_put_item()
│ │ │ +
│ │ │ +sha1_hash dht_put_item (entry data);
│ │ │ +
│ │ │ +
store the given bencoded data as an immutable item in the DHT.
│ │ │ +the returned hash is the key that is to be used to look the item
│ │ │ +up again. It's just the SHA-1 hash of the bencoded form of the
│ │ │ +structure.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_put_item()
│ │ │ +
│ │ │ +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());
│ │ │ +
│ │ │ +
store a mutable item. The key is the public key the blob is
│ │ │ +to be stored under. The optional salt argument is a string that
│ │ │ +is to be mixed in with the key when determining where in the DHT
│ │ │ +the value is to be stored. The callback function is called from within
│ │ │ +the libtorrent network thread once we've found where to store the blob,
│ │ │ +possibly with the current value stored under the key.
│ │ │ +The values passed to the callback functions are:
│ │ │ +
│ │ │ +- entry& value
│ │ │ +- the current value stored under the key (may be empty). Also expected
│ │ │ +to be set to the value to be stored by the function.
│ │ │ +- std::array<char,64>& signature
│ │ │ +- the signature authenticating the current value. This may be zeros
│ │ │ +if there is currently no value stored. The function is expected to
│ │ │ +fill in this buffer with the signature of the new value to store.
│ │ │ +To generate the signature, you may want to use the
│ │ │ +sign_mutable_item function.
│ │ │ +- std::int64_t& seq
│ │ │ +- current sequence number. May be zero if there is no current value.
│ │ │ +The function is expected to set this to the new sequence number of
│ │ │ +the value that is to be stored. Sequence numbers must be monotonically
│ │ │ +increasing. Attempting to overwrite a value with a lower or equal
│ │ │ +sequence number will fail, even if the signature is correct.
│ │ │ +- std::string const& salt
│ │ │ +- this is the salt that was used for this put call.
│ │ │ +
│ │ │ +
Since the callback function cb is called from within libtorrent,
│ │ │ +it is critical to not perform any blocking operations. Ideally not
│ │ │ +even locking a mutex. Pass any data required for this function along
│ │ │ +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()
│ │ │ +
│ │ │ +void dht_announce (sha1_hash const& info_hash, int port = 0, dht::announce_flags_t flags = {});
│ │ │ +void dht_get_peers (sha1_hash const& info_hash);
│ │ │ +
│ │ │ +
dht_get_peers() will issue a DHT get_peer request to the DHT for the
│ │ │ +specified info-hash. The response (the peers) will be posted back in a
│ │ │ +dht_get_peers_reply_alert.
│ │ │ +
dht_announce() will issue a DHT announce request to the DHT to the
│ │ │ +specified info-hash, advertising the specified port. If the port is
│ │ │ +left at its default, 0, the port will be implied by the DHT message's
│ │ │ +source port (which may improve connectivity through a NAT).
│ │ │ +dht_announce() is not affected by the announce_port override setting.
│ │ │ +
Both these functions are exposed for advanced custom use of the DHT.
│ │ │ +All torrents eligible to be announce to the DHT will be automatically,
│ │ │ +by libtorrent.
│ │ │ +
For possible flags, see announce_flags_t.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_live_nodes()
│ │ │ +
│ │ │ +void dht_live_nodes (sha1_hash const& nid);
│ │ │ +
│ │ │ +
Retrieve all the live DHT (identified by nid) nodes. All the
│ │ │ +nodes id and endpoint will be returned in the list of nodes in the
│ │ │ +alert dht_live_nodes_alert.
│ │ │ +Since this alert is a response to an explicit call, it will always be
│ │ │ +posted, regardless of the alert mask.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_sample_infohashes()
│ │ │ +
│ │ │ +void dht_sample_infohashes (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ +
│ │ │ +
Query the DHT node specified by ep to retrieve a sample of the
│ │ │ +info-hashes that the node currently have in their storage.
│ │ │ +The target is included for iterative lookups so that indexing nodes
│ │ │ +can perform a key space traversal with a single RPC per node by adjusting
│ │ │ +the target value for each RPC. It has no effect on the returned sample value.
│ │ │ +The result is posted as a dht_sample_infohashes_alert.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_direct_request()
│ │ │ +
│ │ │ +void dht_direct_request (udp::endpoint const& ep, entry const& e, client_data_t userdata = {});
│ │ │ +
│ │ │ +
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 dht_direct_response_alert will be posted
│ │ │ +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);
│ │ │ +
│ │ │ +
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:
│ │ │ +
│ │ │ +- uTorrent metadata
│ │ │ +- Allows peers to download the metadata (.torrent files) from the swarm
│ │ │ +directly. Makes it possible to join a swarm with just a tracker and
│ │ │ +info-hash.
│ │ │ +
│ │ │ +
│ │ │ + ses.add_extension(<::create_ut_metadata_plugin);
│ │ │ +
│ │ │ +
│ │ │ +- uTorrent peer exchange
│ │ │ +- Exchanges peers between clients.
│ │ │ +
│ │ │ +
│ │ │ + ses.add_extension(<::create_ut_pex_plugin);
│ │ │ +
│ │ │ +
│ │ │ +- smart ban plugin
│ │ │ +- A plugin that, with a small overhead, can ban peers
│ │ │ +that sends bad data with very high accuracy. Should
│ │ │ +eliminate most problems on poisoned torrents.
│ │ │ +
│ │ │ +
│ │ │ + ses.add_extension(<::create_smart_ban_plugin);
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get_ip_filter() set_ip_filter()
│ │ │ +
│ │ │ +ip_filter get_ip_filter () const;
│ │ │ +void set_ip_filter (ip_filter f);
│ │ │ +
│ │ │ +
Sets a filter that will be used to reject and accept incoming as well
│ │ │ +as outgoing connections based on their originating ip address. The
│ │ │ +default filter will allow connections to any ip address. To build a
│ │ │ +set of rules for which addresses are accepted and not, see ip_filter.
│ │ │ +
Each time a peer is blocked because of the IP filter, a
│ │ │ +peer_blocked_alert is generated. get_ip_filter() Returns the
│ │ │ +ip_filter currently in the session. See ip_filter.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_port_filter()
│ │ │ +
│ │ │ +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]
│ │ │ +
│ │ │ +
ssl_listen_port() is_listening() listen_port()
│ │ │ +
│ │ │ +bool is_listening () const;
│ │ │ +unsigned short ssl_listen_port () const;
│ │ │ +unsigned short 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.
│ │ │ +
│ │ │ +
[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;
│ │ │ +
│ │ │ +
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.
│ │ │ +
For more info, see ip_filter.
│ │ │ +
For example, to make all peers in the range 200.1.1.0 - 200.1.255.255
│ │ │ +belong to their own peer class, apply the following filter:
│ │ │ +
│ │ │ +ip_filter f = ses.get_peer_class_filter();
│ │ │ +peer_class_t my_class = ses.create_peer_class("200.1.x.x IP range");
│ │ │ +f.add_rule(make_address("200.1.1.0"), make_address("200.1.255.255")
│ │ │ + , 1 << static_cast<std::uint32_t>(my_class));
│ │ │ +ses.set_peer_class_filter(f);
│ │ │ +
│ │ │ +
This setting only applies to new connections, it won't affect existing
│ │ │ +peer connections.
│ │ │ +
This function is limited to only peer class 0-31, since there are only
│ │ │ +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()
│ │ │ +
│ │ │ +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:
│ │ │ +
│ │ │ +- peer-class IP filter
│ │ │ +- peer-class type filter, removing classes
│ │ │ +- peer-class type filter, adding classes
│ │ │ +
│ │ │ +
For more information, see peer classes.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
create_peer_class()
│ │ │ +
│ │ │ +peer_class_t create_peer_class (char const* name);
│ │ │ +
│ │ │ +
Creates a new peer class (see peer classes) with the given name. The
│ │ │ +returned integer is the new peer class identifier. Peer classes may
│ │ │ +have the same name, so each invocation of this function creates a new
│ │ │ +class and returns a unique identifier.
│ │ │ +
Identifiers are assigned from low numbers to higher. So if you plan on
│ │ │ +using certain peer classes in a call to set_peer_class_filter(),
│ │ │ +make sure to create those early on, to get low identifiers.
│ │ │ +
For more information on peer classes, see peer classes.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
delete_peer_class()
│ │ │ +
│ │ │ +void delete_peer_class (peer_class_t cid);
│ │ │ +
│ │ │ +
This call dereferences the reference count of the specified peer
│ │ │ +class. When creating a peer class it's automatically referenced by 1.
│ │ │ +If you want to recycle a peer class, you may call this function. You
│ │ │ +may only call this function once per peer class you create.
│ │ │ +Calling it more than once for the same class will lead to memory
│ │ │ +corruption.
│ │ │ +
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 session object
│ │ │ +destructs.
│ │ │ +
For more information on peer classes, see peer classes.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get_peer_class() set_peer_class()
│ │ │ +
│ │ │ +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
│ │ │ +option to only update a single property.
│ │ │ +
A peer or torrent belonging to more than one class, the highest
│ │ │ +priority among any of its classes is the one that is taken into
│ │ │ +account.
│ │ │ +
For more information, see peer classes.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
remove_torrent()
│ │ │ +
│ │ │ +void remove_torrent (const torrent_handle&, remove_flags_t = {});
│ │ │ +
│ │ │ +
remove_torrent() will close all peer connections associated with
│ │ │ +the torrent and tell the tracker that we've stopped participating in
│ │ │ +the swarm. This operation cannot fail. When it completes, you will
│ │ │ +receive a torrent_removed_alert.
│ │ │ +
remove_torrent() is non-blocking, but will remove the torrent from the
│ │ │ +session synchronously. Calling session_handle::add_torrent() immediately
│ │ │ +afterward with the same torrent will succeed. Note that this creates a
│ │ │ +new handle which is not equal to the removed one.
│ │ │ +
The optional second argument options can be used to delete all the
│ │ │ +files downloaded by this torrent. To do so, pass in the value
│ │ │ +session_handle::delete_files. Once the torrent is deleted, a
│ │ │ +torrent_deleted_alert is posted.
│ │ │ +
The torrent_handle remains valid for some time after remove_torrent() is
│ │ │ +called. It will become invalid only after all libtorrent tasks (such as
│ │ │ +I/O tasks) release their references to the torrent. Until this happens,
│ │ │ +torrent_handle::is_valid() will return true, and other calls such
│ │ │ +as torrent_handle::status() will succeed. Because of this, and because
│ │ │ +remove_torrent() is non-blocking, the following sequence usually
│ │ │ +succeeds (does not throw system_error):
│ │ │ +.. code:: c++
│ │ │ +
│ │ │ +session.remove_handle(handle);
│ │ │ +handle.save_resume_data();
│ │ │ +
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.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
apply_settings() get_settings()
│ │ │ +
│ │ │ +settings_pack get_settings () const;
│ │ │ +void apply_settings (settings_pack&&);
│ │ │ +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]
│ │ │ +
│ │ │ +
wait_for_alert() set_alert_notify() pop_alerts()
│ │ │ +
│ │ │ +void pop_alerts (std::vector<alert*>* alerts);
│ │ │ +alert* wait_for_alert (time_duration max_wait);
│ │ │ +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
│ │ │ +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
│ │ │ +long as the alerts themselves are not accessed once another thread
│ │ │ +calls pop_alerts. Doing this requires manual synchronization
│ │ │ +between the popping threads.
│ │ │ +
wait_for_alert will block the current thread for max_wait time
│ │ │ +duration, or until another alert is posted. If an alert is available
│ │ │ +at the time of the call, it returns immediately. The returned alert
│ │ │ +pointer is the head of the alert queue. wait_for_alert does not
│ │ │ +pop alerts from the queue, it merely peeks at it. The returned alert
│ │ │ +will stay valid until pop_alerts is called twice. The first time
│ │ │ +will pop it and the second will free it.
│ │ │ +
If there is no alert in the queue and no alert arrives within the
│ │ │ +specified timeout, wait_for_alert returns nullptr.
│ │ │ +
In the python binding, wait_for_alert takes the number of
│ │ │ +milliseconds to wait as an integer.
│ │ │ +
The alert queue in the session will not grow indefinitely. Make sure
│ │ │ +to pop periodically to not miss notifications. To control the max
│ │ │ +number of alerts that's queued by the session, see
│ │ │ +settings_pack::alert_queue_size.
│ │ │ +
Some alerts are considered so important that they are posted even when
│ │ │ +the alert queue is full. Some alerts are considered mandatory and cannot
│ │ │ +be disabled by the alert_mask. For instance,
│ │ │ +save_resume_data_alert and save_resume_data_failed_alert are always
│ │ │ +posted, regardless of the alert mask.
│ │ │ +
To control which alerts are posted, set the alert_mask
│ │ │ +(settings_pack::alert_mask).
│ │ │ +
If the alert queue fills up to the point where alerts are dropped, this
│ │ │ +will be indicated by a alerts_dropped_alert, which contains a bitmask
│ │ │ +of which types of alerts were dropped. Generally it is a good idea to
│ │ │ +make sure the alert queue is large enough, the alert_mask doesn't have
│ │ │ +unnecessary categories enabled and to call pop_alert() frequently, to
│ │ │ +avoid alerts being dropped.
│ │ │ +
the set_alert_notify function lets the client set a function object
│ │ │ +to be invoked every time the alert queue goes from having 0 alerts to
│ │ │ +1 alert. This function is called from within libtorrent, it may be the
│ │ │ +main thread, or it may be from within a user call. The intention of
│ │ │ +of the function is that the client wakes up its main thread, to poll
│ │ │ +for more alerts using pop_alerts(). If the notify function fails
│ │ │ +to do so, it won't be called again, until pop_alerts is called for
│ │ │ +some other reason. For instance, it could signal an eventfd, post a
│ │ │ +message to an HWND or some other main message pump. The actual
│ │ │ +retrieval of alerts should not be done in the callback. In fact, the
│ │ │ +callback should not block. It should not perform any expensive work.
│ │ │ +It really should just notify the main application thread.
│ │ │ +
The type of an alert 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.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
delete_port_mapping() add_port_mapping()
│ │ │ +
│ │ │ +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]
│ │ │ +
│ │ │ +
reopen_network_sockets()
│ │ │ +
│ │ │ +void reopen_network_sockets (reopen_network_flags_t options = reopen_map_ports);
│ │ │ +
│ │ │ +
Instructs the session to reopen all listen and outgoing sockets.
│ │ │ +
It's useful in the case your platform doesn't support the built in
│ │ │ +IP notifier mechanism, or if you have a better more reliable way to
│ │ │ +detect changes in the IP routing table.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
native_handle()
│ │ │ +
│ │ │ +std::shared_ptr<aux::session_impl> native_handle () const;
│ │ │ +
│ │ │ +
This function is intended only for use by plugins. This type does
│ │ │ +not have a stable API and should be relied on as little as possible.
│ │ │ +
[report issue]
│ │ │ +- save_settings
│ │ │ +- saves settings (i.e. the settings_pack)
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- save_dht_state
│ │ │ +- saves dht state such as nodes and node-id, possibly accelerating
│ │ │ +joining the DHT if provided at next session startup.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- save_extension_state
│ │ │ +- load or save state from plugins
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- save_ip_filter
│ │ │ +- load or save the IP filter set on the session
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- global_peer_class_id tcp_peer_class_id local_peer_class_id
│ │ │ +- built-in peer classes
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- delete_files
│ │ │ +- delete the files belonging to the torrent from disk.
│ │ │ +including the part-file, if there is one
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- delete_partfile
│ │ │ +- delete just the part-file associated with this torrent
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- paused
│ │ │ +- when set, the session will start paused. Call
│ │ │ +session_handle::resume() to start
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- udp tcp
│ │ │ +- protocols used by add_port_mapping()
│ │ │ +
│ │ │ +
[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]
│ │ │ +
│ │ │ +
│ │ │ +
session_proxy
│ │ │ +
Declared in "libtorrent/session.hpp"
│ │ │ +
this is a holder for the internal session implementation object. Once the
│ │ │ +session destruction is explicitly initiated, this holder is used to
│ │ │ +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.
│ │ │
│ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ -virtual void sent_unchoke ();
│ │ │ -virtual void sent_interested ();
│ │ │ -virtual void sent_not_interested ();
│ │ │ -virtual void sent_have (piece_index_t);
│ │ │ +struct session_proxy
│ │ │ +{
│ │ │ + session_proxy (session_proxy&&) noexcept;
│ │ │ + session_proxy& operator= (session_proxy const&) &;
│ │ │ + ~session_proxy ();
│ │ │ + session_proxy (session_proxy const&);
│ │ │ + session_proxy ();
│ │ │ + session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │ +};
│ │ │
│ │ │ -
called after a choke message has been sent to the peer
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
sent_payload()
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
operator=() session_proxy() ~session_proxy()
│ │ │
│ │ │ -virtual void sent_payload (int /* bytes */);
│ │ │ +session_proxy (session_proxy&&) noexcept;
│ │ │ +session_proxy& operator= (session_proxy const&) &;
│ │ │ +~session_proxy ();
│ │ │ +session_proxy (session_proxy const&);
│ │ │ +session_proxy ();
│ │ │ +session_proxy& operator= (session_proxy&&) & noexcept;
│ │ │
│ │ │ -
called after piece data has been sent to the peer
│ │ │ -this can be used for stats book keeping
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
can_disconnect()
│ │ │ +
default constructor, does not refer to any session
│ │ │ +implementation object.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
session
│ │ │ +
Declared in "libtorrent/session.hpp"
│ │ │ +
The session holds all state that spans multiple torrents. Among other
│ │ │ +things it runs the network loop and manages all torrents. Once it's
│ │ │ +created, the session object will spawn the main thread that will do all
│ │ │ +the work. The main thread will be idle as long it doesn't have any
│ │ │ +torrents to participate in.
│ │ │ +
You have some control over session configuration through the
│ │ │ +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().
│ │ │
│ │ │ -virtual bool can_disconnect (error_code const& /*ec*/);
│ │ │ +struct session : session_handle
│ │ │ +{
│ │ │ + explicit session (session_params&& params);
│ │ │ + session (session_params&& params, session_flags_t flags);
│ │ │ + session (session_params const& params, session_flags_t flags);
│ │ │ + explicit session (session_params const& params);
│ │ │ + session ();
│ │ │ + session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ + session (session_params&& params, io_context& ios);
│ │ │ + session (session_params const& params, io_context& ios);
│ │ │ + session (session_params const& params, io_context& ios, session_flags_t);
│ │ │ + ~session ();
│ │ │ + session_proxy abort ();
│ │ │ +};
│ │ │
│ │ │ -
called when libtorrent think this peer should be disconnected.
│ │ │ -if the plugin returns false, the peer will not be disconnected.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_extended()
│ │ │ +
[report issue]
│ │ │ +
session()
│ │ │
│ │ │ -virtual bool on_extended (int /*length*/, int /*msg*/,
│ │ │ - span<char const> /*body*/);
│ │ │ +explicit session (session_params&& params);
│ │ │ +session (session_params&& params, session_flags_t flags);
│ │ │ +session (session_params const& params, session_flags_t flags);
│ │ │ +explicit session (session_params const& params);
│ │ │ +session ();
│ │ │
│ │ │ -
called when an extended message is received. If returning true,
│ │ │ -the message is not processed by any other plugin and if false
│ │ │ -is returned the next plugin in the chain will receive it to
│ │ │ -be able to handle it. This is not called for web seeds.
│ │ │ -thus function may be called more than once per incoming message, but
│ │ │ -only the last of the calls will the body size equal the length.
│ │ │ -i.e. Every time another fragment of the message is received, this
│ │ │ -function will be called, until finally the whole message has been
│ │ │ -received. The purpose of this is to allow early disconnects for invalid
│ │ │ -messages and for reporting progress of receiving large messages.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_unknown_message()
│ │ │ +
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()
│ │ │
│ │ │ -virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ - span<char const> /*body*/);
│ │ │ +session (session_params&& params, io_context& ios, session_flags_t);
│ │ │ +session (session_params&& params, io_context& ios);
│ │ │ +session (session_params const& params, io_context& ios);
│ │ │ +session (session_params const& params, io_context& ios, session_flags_t);
│ │ │
│ │ │ -
this is not called for web seeds
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
on_piece_failed() on_piece_pass()
│ │ │ +
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.
│ │ │ +
│ │ │ +
Warning
│ │ │ +
The session object does not cleanly terminate with an external
│ │ │ +io_context. The io_context::run() call must have returned
│ │ │ +before it's safe to destruct the session. Which means you MUST
│ │ │ +call session::abort() and save the session_proxy first, then
│ │ │ +destruct the session object, then sync with the io_context, then
│ │ │ +destruct the session_proxy object.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
~session()
│ │ │
│ │ │ -virtual void on_piece_failed (piece_index_t);
│ │ │ -virtual void on_piece_pass (piece_index_t);
│ │ │ +~session ();
│ │ │
│ │ │ -
called when a piece that this peer participated in either
│ │ │ -fails or passes the hash_check
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
tick()
│ │ │ +
The destructor of session will notify all trackers that our torrents
│ │ │ +have been shut down. If some trackers are down, they will time out.
│ │ │ +All this before the destructor of session returns. So, it's advised
│ │ │ +that any kind of interface (such as windows) are closed before
│ │ │ +destructing the session object. Because it can take a few second for
│ │ │ +it to finish. The timeout can be set with apply_settings().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
abort()
│ │ │
│ │ │ -virtual void tick ();
│ │ │ +session_proxy abort ();
│ │ │
│ │ │ -
called approximately once every second
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
write_request()
│ │ │ +
In case you want to destruct the session asynchronously, you can
│ │ │ +request a session destruction proxy. If you don't do this, the
│ │ │ +destructor of the session object will block while the trackers are
│ │ │ +contacted. If you keep one session_proxy to the session when
│ │ │ +destructing it, the destructor will not block, but start to close down
│ │ │ +the session, the destructor of the proxy will then synchronize the
│ │ │ +threads. So, the destruction of the session is performed from the
│ │ │ +session destructor call until the session_proxy destructor
│ │ │ +call. The session_proxy does not have any operations on it (since
│ │ │ +the session is being closed down, no operations are allowed on it).
│ │ │ +The only valid operation is calling the destructor:
│ │ │
│ │ │ -virtual bool write_request (peer_request const&);
│ │ │ +struct session_proxy {};
│ │ │
│ │ │ -
called each time a request message is to be sent. If true
│ │ │ -is returned, the original request message won't be sent and
│ │ │ -no other plugin will have this function called.
│ │ │ -
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │
│ │ │ -
│ │ │ -
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;
│ │ │ - encrypt (span<span<char>> /*send_vec*/) = 0;
│ │ │ - virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
decrypt()
│ │ │ +
│ │ │ +
read_session_params() write_session_params() write_session_params_buf()
│ │ │ +
Declared in "libtorrent/session_params.hpp"
│ │ │
│ │ │ -virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │ +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());
│ │ │
│ │ │ -
decrypt the provided buffers.
│ │ │ -returns is a tuple representing the values
│ │ │ -(consume, produce, packet_size)
│ │ │ -
consume is set to the number of bytes which should be trimmed from the
│ │ │ -head of the buffers, default is 0
│ │ │ -
produce is set to the number of bytes of payload which are now ready to
│ │ │ -be sent to the upper layer. default is the number of bytes passed in receive_vec
│ │ │ -
packet_size is set to the minimum number of bytes which must be read to
│ │ │ -advance the next step of decryption. default is 0
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
peer_connection_handle
│ │ │ -
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ -
the peer_connection_handle 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
│ │ │ +
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.
│ │ │ +The _buf suffix indicates the function operates on buffer rather than the
│ │ │ +bencoded structure.
│ │ │ +The torrents in a session are not part of the session_params state, they have
│ │ │ +to be restored separately.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
peer_class_type_filter
│ │ │ +
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_connection_handle
│ │ │ +struct peer_class_type_filter
│ │ │ {
│ │ │ - 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>);
│ │ │ - bool is_seed () const;
│ │ │ - bool upload_only () const;
│ │ │ - bool has_piece (piece_index_t i) const;
│ │ │ - peer_id const& pid () const;
│ │ │ - bool is_interesting () const;
│ │ │ - bool is_choked () const;
│ │ │ - bool has_peer_choked () const;
│ │ │ - bool is_peer_interested () const;
│ │ │ - void 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;
│ │ │ - bool is_disconnecting () const;
│ │ │ - void disconnect (error_code const& ec, operation_t op
│ │ │ - , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ - bool is_outgoing () const;
│ │ │ - bool on_local_network () const;
│ │ │ - bool ignore_unchoke_slots () const;
│ │ │ - bool failed () const;
│ │ │ - bool should_log (peer_log_alert::direction_t direction) const;
│ │ │ - void peer_log (peer_log_alert::direction_t direction
│ │ │ - , char const* event, char const* fmt = "", ...) const TORRENT_FORMAT(4,5);
│ │ │ - bool 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;
│ │ │ - std::shared_ptr<peer_connection> native_handle () const;
│ │ │ + 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 allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ + void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ + std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ + friend bool operator== (peer_class_type_filter const& lhs
│ │ │ + , peer_class_type_filter const& rhs);
│ │ │ +
│ │ │ + enum socket_type_t
│ │ │ + {
│ │ │ + tcp_socket,
│ │ │ + utp_socket,
│ │ │ + ssl_tcp_socket,
│ │ │ + ssl_utp_socket,
│ │ │ + i2p_socket,
│ │ │ + num_socket_types,
│ │ │ + };
│ │ │ };
│ │ │
│ │ │ -
[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.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
remove() add()
│ │ │
│ │ │ -struct bt_peer_connection_handle : peer_connection_handle
│ │ │ -{
│ │ │ - explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ - bool support_extensions () const;
│ │ │ - bool packet_finished () const;
│ │ │ - bool supports_encryption () const;
│ │ │ - void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ - void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ - std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ -};
│ │ │ +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);
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
create_ut_pex_plugin()
│ │ │ -
Declared in "libtorrent/extensions/ut_pex.hpp"
│ │ │ +
add() and remove() adds and removes a peer class to be added
│ │ │ +to new peers based on socket type.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
allow() disallow()
│ │ │
│ │ │ -std::shared_ptr<torrent_plugin> create_ut_pex_plugin (torrent_handle const&, client_data_t);
│ │ │ +void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ +void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │
│ │ │ -
constructor function for the ut_pex extension. The ut_pex
│ │ │ -extension allows peers to gossip about their connections, allowing
│ │ │ -the swarm stay well connected and peers aware of more peers in the
│ │ │ -swarm. This extension is enabled by default unless explicitly disabled in
│ │ │ -the session constructor.
│ │ │ -
This can either be passed in the add_torrent_params::extensions field, or
│ │ │ -via torrent_handle::add_extension().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
create_smart_ban_plugin()
│ │ │ -
Declared in "libtorrent/extensions/smart_ban.hpp"
│ │ │ +
disallow() and allow() adds and removes a peer class to be
│ │ │ +removed from new peers based on socket type.
│ │ │ +
The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ +peer classes in the peer_class_type_filter are 32 bits.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
apply()
│ │ │
│ │ │ -std::shared_ptr<torrent_plugin> create_smart_ban_plugin (torrent_handle const&, client_data_t);
│ │ │ +std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │
│ │ │ -
constructor function for the smart ban extension. The extension keeps
│ │ │ -track of the data peers have sent us for failing pieces and once the
│ │ │ -piece completes and passes the hash check bans the peers that turned
│ │ │ -out to have sent corrupt data.
│ │ │ -This function can either be passed in the add_torrent_params::extensions
│ │ │ -field, or via torrent_handle::add_extension().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum socket_type_t
│ │ │ +
Declared in "libtorrent/peer_class_type_filter.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| tcp_socket |
│ │ │ +0 |
│ │ │ +these match the socket types from socket_type.hpp
│ │ │ +shifted one down |
│ │ │ +
│ │ │ +| utp_socket |
│ │ │ +1 |
│ │ │ + |
│ │ │ +
│ │ │ +| ssl_tcp_socket |
│ │ │ +2 |
│ │ │ + |
│ │ │ +
│ │ │ +| ssl_utp_socket |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| i2p_socket |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │ +| num_socket_types |
│ │ │ +5 |
│ │ │ + |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
peer_class_info
│ │ │ +
Declared in "libtorrent/peer_class.hpp"
│ │ │ +
holds settings for a peer class. Used in set_peer_class() and
│ │ │ +get_peer_class() calls.
│ │ │
│ │ │ -std::shared_ptr<torrent_plugin> create_ut_metadata_plugin (torrent_handle const&, client_data_t);
│ │ │ +struct peer_class_info
│ │ │ +{
│ │ │ + bool ignore_unchoke_slots;
│ │ │ + int connection_limit_factor;
│ │ │ + std::string label;
│ │ │ + int upload_limit;
│ │ │ + int download_limit;
│ │ │ + int upload_priority;
│ │ │ + int download_priority;
│ │ │ +};
│ │ │
│ │ │ -
constructor function for the ut_metadata extension. The ut_metadata
│ │ │ -extension allows peers to request the .torrent file (or more
│ │ │ -specifically the info-dictionary of the .torrent file) from each
│ │ │ -other. This is the main building block in making magnet links work.
│ │ │ -This extension is enabled by default unless explicitly disabled in
│ │ │ -the session constructor.
│ │ │ -
This can either be passed in the add_torrent_params::extensions field, or
│ │ │ -via torrent_handle::add_extension().
│ │ │ +
[report issue]
│ │ │ +- ignore_unchoke_slots
│ │ │ +- ignore_unchoke_slots determines whether peers should always
│ │ │ +unchoke a peer, regardless of the choking algorithm, or if it should
│ │ │ +honor the unchoke slot limits. It's used for local peers by default.
│ │ │ +If any of the peer classes a peer belongs to has this set to true,
│ │ │ +that peer will be unchoked at all times.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- connection_limit_factor
│ │ │ +- adjusts the connection limit (global and per torrent) that applies to
│ │ │ +this peer class. By default, local peers are allowed to exceed the
│ │ │ +normal connection limit for instance. This is specified as a percent
│ │ │ +factor. 100 makes the peer class apply normally to the limit. 200
│ │ │ +means as long as there are fewer connections than twice the limit, we
│ │ │ +accept this peer. This factor applies both to the global connection
│ │ │ +limit and the per-torrent limit. Note that if not used carefully one
│ │ │ +peer class can potentially completely starve out all other over time.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- label
│ │ │ +- not used by libtorrent. It's intended as a potentially user-facing
│ │ │ +identifier of this peer class.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- upload_limit download_limit
│ │ │ +- transfer rates limits for the whole peer class. They are specified in
│ │ │ +bytes per second and apply to the sum of all peers that are members of
│ │ │ +this class.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- upload_priority download_priority
│ │ │ +- relative priorities used by the bandwidth allocator in the rate
│ │ │ +limiter. If no rate limits are in use, the priority is not used
│ │ │ +either. Priorities start at 1 (0 is not a valid priority) and may not
│ │ │ +exceed 255.
│ │ │ +
│ │ │
[report issue]
│ │ │
│ │ │
file_slice
│ │ │
Declared in "libtorrent/file_storage.hpp"
│ │ │
represents a window of a file in a torrent.
│ │ │
The file_index refers to the index of the file (in the torrent_info).
│ │ │ To get the path and filename, use file_path() and give the file_index
│ │ │ @@ -5879,32 +4186,32 @@
│ │ │ 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
│ │ │ + , 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
│ │ │ , 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 add_file_borrow (error_code& ec, string_view filename
│ │ │ - , std::string const& path, std::int64_t file_size
│ │ │ - , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ - , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ - , char const* root_hash = nullptr);
│ │ │ void rename_file (file_index_t index, std::string const& new_filename);
│ │ │ std::vector<file_slice> map_block (piece_index_t piece, std::int64_t offset
│ │ │ , std::int64_t size) const;
│ │ │ peer_request map_file (file_index_t file, std::int64_t offset, int size) const;
│ │ │ int num_files () const noexcept;
│ │ │ file_index_t end_file () const noexcept;
│ │ │ index_range<file_index_t> file_range () const noexcept;
│ │ │ @@ -5920,29 +4227,29 @@
│ │ │ 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 ();
│ │ │ - std::time_t mtime (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;
│ │ │ - bool pad_file_at (file_index_t index) const;
│ │ │ - sha256_hash root (file_index_t index) const;
│ │ │ - char const* root_ptr (file_index_t const index) const;
│ │ │ string_view file_name (file_index_t index) const;
│ │ │ std::int64_t file_offset (file_index_t index) const;
│ │ │ + std::time_t mtime (file_index_t index) const;
│ │ │ + sha256_hash root (file_index_t index) const;
│ │ │ + char const* root_ptr (file_index_t const index) const;
│ │ │ + std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ + bool pad_file_at (file_index_t index) const;
│ │ │ std::int64_t file_size (file_index_t index) const;
│ │ │ std::string symlink (file_index_t index) const;
│ │ │ - index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ - int file_num_pieces (file_index_t index) const;
│ │ │ int file_num_blocks (file_index_t index) const;
│ │ │ - int file_first_block_node (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_for_root (sha256_hash const& root_hash) const;
│ │ │ @@ -5952,15 +4259,15 @@
│ │ │
│ │ │ static constexpr file_flags_t flag_pad_file = 0_bit;
│ │ │ static constexpr file_flags_t flag_hidden = 1_bit;
│ │ │ static constexpr file_flags_t flag_executable = 2_bit;
│ │ │ static constexpr file_flags_t flag_symlink = 3_bit;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ +
[report issue]
│ │ │
is_valid()
│ │ │
│ │ │ bool is_valid () const;
│ │ │
│ │ │
returns true if the piece length has been initialized
│ │ │ on the file_storage. This is typically taken as a proxy
│ │ │ of whether the file_storage as a whole is initialized or
│ │ │ @@ -5970,37 +4277,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() add_file_borrow()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_file_borrow() add_file()
│ │ │
│ │ │ +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_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 (std::string const& path, std::int64_t file_size
│ │ │ , file_flags_t file_flags = {}
│ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ , char const* root_hash = nullptr);
│ │ │ void add_file (error_code& ec, std::string const& path, std::int64_t file_size
│ │ │ , file_flags_t file_flags = {}
│ │ │ , std::time_t mtime = 0, string_view symlink_path = string_view()
│ │ │ , char const* root_hash = nullptr);
│ │ │ -void add_file_borrow (error_code& ec, string_view filename
│ │ │ - , std::string const& path, std::int64_t file_size
│ │ │ - , file_flags_t file_flags = {}, char const* filehash = nullptr
│ │ │ - , std::int64_t mtime = 0, string_view symlink_path = string_view()
│ │ │ - , char const* root_hash = nullptr);
│ │ │
│ │ │
Adds a file to the file storage. The add_file_borrow version
│ │ │ expects that filename is the file name (without a path) of
│ │ │ 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
│ │ │ @@ -6034,50 +4341,50 @@
│ │ │ the same root directory.
│ │ │
That is, the first path element of all files must be the same.
│ │ │ This shared path element is also set to the name of the torrent. It
│ │ │ can be changed by calling set_name.
│ │ │
The overloads that take an error_code reference will report failures
│ │ │ via that variable, otherwise system_error is thrown.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
rename_file()
│ │ │
│ │ │ void rename_file (file_index_t index, std::string const& new_filename);
│ │ │
│ │ │
renames the file at index to new_filename. Keep in mind
│ │ │ that filenames are expected to be UTF-8 encoded.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
map_block()
│ │ │
│ │ │ std::vector<file_slice> map_block (piece_index_t piece, std::int64_t offset
│ │ │ , std::int64_t size) const;
│ │ │
│ │ │
returns a list of file_slice objects representing the portions of
│ │ │ files the specified piece index, byte offset and size range overlaps.
│ │ │ -this is the inverse mapping of map_file().
│ │ │ +this is the inverse mapping of
map_file().
│ │ │
Preconditions of this function is that the input range is within the
│ │ │ torrents address space. piece may not be negative and
│ │ │
│ │ │ piece * piece_size + offset + size
│ │ │
may not exceed the total size of the torrent.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
map_file()
│ │ │
│ │ │ peer_request map_file (file_index_t file, std::int64_t offset, int size) const;
│ │ │
│ │ │
returns a peer_request representing the piece index, byte offset
│ │ │ and size the specified file range overlaps. This is the inverse
│ │ │ -mapping over map_block(). Note that the peer_request return type
│ │ │ +mapping over map_block(). Note that the peer_request return type
│ │ │ is meant to hold bittorrent block requests, which may not be larger
│ │ │ than 16 kiB. Mapping a range larger than that may return an overflown
│ │ │ integer.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
num_files()
│ │ │
│ │ │ int num_files () const noexcept;
│ │ │
│ │ │
returns the number of files in the file_storage
│ │ │
[report issue]
│ │ │
│ │ │ @@ -6092,15 +4399,15 @@
│ │ │
│ │ │ index_range<file_index_t> file_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
│ │ │ files in the file_storage.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
total_size()
│ │ │
│ │ │ std::int64_t total_size () const;
│ │ │
│ │ │
returns the total number of bytes all the files in this torrent spans
│ │ │
│ │ │
[report issue]
│ │ │ @@ -6132,26 +4439,26 @@
│ │ │
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]
│ │ │ -
│ │ │ -
piece_length() set_piece_length()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_piece_length() 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]
│ │ │ -
│ │ │ +
│ │ │
piece_size()
│ │ │
│ │ │ int piece_size (piece_index_t index) const;
│ │ │
│ │ │
returns the piece size of index. This will be the same as piece_length(), except
│ │ │ for the last piece, which may be shorter.
│ │ │
[report issue]
│ │ │ @@ -6168,67 +4475,67 @@
│ │ │
│ │ │
blocks_in_piece2()
│ │ │
│ │ │ int blocks_in_piece2 (piece_index_t index) const;
│ │ │
│ │ │
returns the number of blocks in the specified piece, for v2 torrents.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
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]
│ │ │ -
│ │ │ +
│ │ │ +
name() set_name()
│ │ │
│ │ │ std::string const& name () const;
│ │ │ void set_name (std::string const& n);
│ │ │
│ │ │
set and get the name of this torrent. For multi-file torrents, this is also
│ │ │ the name of the root directory all the files are stored in.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
swap()
│ │ │
│ │ │ void swap (file_storage& ti) noexcept;
│ │ │
│ │ │
swap all content of this with ti.
│ │ │
[report issue]
│ │ │
│ │ │
canonicalize()
│ │ │
│ │ │ void canonicalize ();
│ │ │
│ │ │
arrange files and padding to match the canonical form required
│ │ │ by BEP 52
│ │ │ -
│ │ │ -
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │
│ │ │ +
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
file_path() file_offset() mtime() file_name() file_size() hash() symlink() root_ptr() pad_file_at() root()
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
mtime() file_name() symlink() file_path() root_ptr() hash() file_offset() file_size() root() pad_file_at()
│ │ │
│ │ │ -std::time_t mtime (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;
│ │ │ -bool pad_file_at (file_index_t index) const;
│ │ │ -sha256_hash root (file_index_t index) const;
│ │ │ -char const* root_ptr (file_index_t const index) const;
│ │ │ string_view file_name (file_index_t index) const;
│ │ │ std::int64_t file_offset (file_index_t index) const;
│ │ │ +std::time_t mtime (file_index_t index) const;
│ │ │ +sha256_hash root (file_index_t index) const;
│ │ │ +char const* root_ptr (file_index_t const index) const;
│ │ │ +std::string file_path (file_index_t index, std::string const& save_path = "") const;
│ │ │ +bool pad_file_at (file_index_t index) const;
│ │ │ std::int64_t file_size (file_index_t index) const;
│ │ │ std::string symlink (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
│ │ │ @@ -6248,37 +4555,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_pieces() file_num_blocks() file_piece_range()
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
file_piece_range() file_num_blocks() file_num_pieces()
│ │ │
│ │ │ -index_range<piece_index_t::diff_type> file_piece_range (file_index_t) const;
│ │ │ -int file_num_pieces (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;
│ │ │
│ │ │
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;
│ │ │ @@ -6403,34 +4710,34 @@
│ │ │
│ │ │ std::unique_ptr<disk_interface> disabled_disk_io_constructor (
│ │ │ io_context& ios, settings_interface const&, counters& cnt);
│ │ │
│ │ │ creates a disk io object that discards all data written to it, and only
│ │ │ returns zero-buffers when read from. May be useful for testing and
│ │ │ benchmarking.
│ │ │ -[report issue]
│ │ │ -
│ │ │ -
mmap_disk_io_constructor()
│ │ │ -
Declared in "libtorrent/mmap_disk_io.hpp"
│ │ │ -
│ │ │ -std::unique_ptr<disk_interface> mmap_disk_io_constructor (
│ │ │ - io_context& ios, settings_interface const&, counters& cnt);
│ │ │ -
│ │ │ -
constructs a memory mapped file disk I/O object.
│ │ │
[report issue]
│ │ │
│ │ │
posix_disk_io_constructor()
│ │ │
Declared in "libtorrent/posix_disk_io.hpp"
│ │ │
│ │ │ std::unique_ptr<disk_interface> posix_disk_io_constructor (
│ │ │ io_context& ios, settings_interface const&, counters& cnt);
│ │ │
│ │ │
this is a simple posix disk I/O back-end, used for systems that don't
│ │ │ have a 64 bit virtual address space or don't support memory mapped files.
│ │ │ It's implemented using portable C file functions and is single-threaded.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
mmap_disk_io_constructor()
│ │ │ +
Declared in "libtorrent/mmap_disk_io.hpp"
│ │ │ +
│ │ │ +std::unique_ptr<disk_interface> mmap_disk_io_constructor (
│ │ │ + io_context& ios, settings_interface const&, counters& cnt);
│ │ │ +
│ │ │ +
constructs a memory mapped file disk I/O object.
│ │ │
[report issue]
│ │ │
│ │ │
default_disk_io_constructor()
│ │ │
Declared in "libtorrent/session.hpp"
│ │ │
│ │ │ std::unique_ptr<disk_interface> default_disk_io_constructor (
│ │ │ io_context& ios, settings_interface const&, counters& cnt);
│ │ │ @@ -6555,55 +4862,874 @@
│ │ │ | reset_save_path_unchecked |
│ │ │ 4 |
│ │ │ don't move any source files, just change save path
│ │ │ and continue working without any checks |
│ │ │
│ │ │
│ │ │
│ │ │ -[report issue]
│ │ │ -
│ │ │ -
client_data_t
│ │ │ -
Declared in "libtorrent/client_data.hpp"
│ │ │ -
A thin wrapper around a void pointer used as "user data". i.e. an opaque
│ │ │ -cookie passed in to libtorrent and returned on demand. It adds type-safety by
│ │ │ -requiring the same type be requested out of it as was assigned to it.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
bitfield
│ │ │ +
Declared in "libtorrent/bitfield.hpp"
│ │ │ +
The bitfield type stores any number of bits as a bitfield
│ │ │ +in a heap allocated array.
│ │ │
│ │ │ -struct client_data_t
│ │ │ +struct bitfield
│ │ │ {
│ │ │ - client_data_t () = default;
│ │ │ - explicit client_data_t (T* v);
│ │ │ - client_data_t& operator= (T* v);
│ │ │ - explicit operator T () const;
│ │ │ - T* get () const;
│ │ │ - client_data_t& operator= (void*) = delete;
│ │ │ - operator void* () const = delete;
│ │ │ - client_data_t& operator= (void const*) = delete;
│ │ │ - operator void const* () const = delete;
│ │ │ -
│ │ │ - template <typename T, typename U = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ + explicit bitfield (int bits);
│ │ │ + bitfield () noexcept = default;
│ │ │ + bitfield (bitfield const& rhs);
│ │ │ + bitfield (char const* b, int bits);
│ │ │ + bitfield (bitfield&& rhs) noexcept = default;
│ │ │ + bitfield (int bits, bool val);
│ │ │ + void assign (char const* b, int const bits);
│ │ │ + 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;
│ │ │ + 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]
│ │ │ -
client_data_t()
│ │ │ +
[report issue]
│ │ │ +
bitfield()
│ │ │
│ │ │ -client_data_t () = default;
│ │ │ +explicit bitfield (int bits);
│ │ │ +bitfield () noexcept = default;
│ │ │ +bitfield (bitfield const& rhs);
│ │ │ +bitfield (char const* b, int bits);
│ │ │ +bitfield (bitfield&& rhs) noexcept = default;
│ │ │ +bitfield (int bits, bool val);
│ │ │ +
│ │ │ +
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
│ │ │ +the nearest byte boundary).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
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]
│ │ │ +
│ │ │ +
get_bit() operator[]()
│ │ │ +
│ │ │ +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()
│ │ │ +
│ │ │ +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]
│ │ │ +
│ │ │ +
all_set()
│ │ │ +
│ │ │ +bool all_set () const noexcept;
│ │ │ +
│ │ │ +
returns true if all bits in the bitfield are set
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
none_set()
│ │ │ +
│ │ │ +bool none_set () const noexcept;
│ │ │ +
│ │ │ +
returns true if no bit in the bitfield is set
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
size()
│ │ │ +
│ │ │ +int size () const noexcept;
│ │ │ +
│ │ │ +
returns the size of the bitfield in bits.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
num_words()
│ │ │ +
│ │ │ +int num_words () const noexcept;
│ │ │ +
│ │ │ +
returns the number of 32 bit words are needed to represent all bits in
│ │ │ +this bitfield.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
num_bytes()
│ │ │ +
│ │ │ +int num_bytes () const noexcept;
│ │ │ +
│ │ │ +
returns the number of bytes needed to represent all bits in this
│ │ │ +bitfield
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
empty()
│ │ │ +
│ │ │ +bool empty () const noexcept;
│ │ │ +
│ │ │ +
returns true if the bitfield has zero size.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
data()
│ │ │ +
│ │ │ +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()
│ │ │ +
│ │ │ +void swap (bitfield& rhs) noexcept;
│ │ │ +
│ │ │ +
swaps the bit-fields two variables refer to
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
count()
│ │ │ +
│ │ │ +int count () const noexcept;
│ │ │ +
│ │ │ +
count the number of bits in the bitfield that are set to 1.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
find_first_set()
│ │ │ +
│ │ │ +int find_first_set () const noexcept;
│ │ │ +
│ │ │ +
returns the index of the first set bit in the bitfield, i.e. 1 bit.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
find_last_clear()
│ │ │ +
│ │ │ +int find_last_clear () const noexcept;
│ │ │ +
│ │ │ +
returns the index to the last cleared bit in the bitfield, i.e. 0 bit.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
hasher
│ │ │ +
Declared in "libtorrent/hasher.hpp"
│ │ │ +
this is a SHA-1 hash class.
│ │ │ +
You use it by first instantiating it, then call update() to feed it
│ │ │ +with data. i.e. you don't have to keep the entire buffer of which you want to
│ │ │ +create the hash in memory. You can feed the hasher parts of it at a time. When
│ │ │ +You have fed the hasher with all the data, you call final() and it
│ │ │ +will return the sha1-hash of the data.
│ │ │ +
The constructor that takes a char const* and an integer will construct the
│ │ │ +sha1 context and feed it the data passed in.
│ │ │ +
If you want to reuse the hasher 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
│ │ │ +{
│ │ │ + hasher ();
│ │ │ + hasher& operator= (hasher const&) &;
│ │ │ + hasher (char const* data, int len);
│ │ │ + hasher (hasher const&);
│ │ │ + explicit hasher (span<char const> data);
│ │ │ + hasher& update (char const* data, int len);
│ │ │ + hasher& update (span<char const> data);
│ │ │ + sha1_hash final ();
│ │ │ + void reset ();
│ │ │ +};
│ │ │
│ │ │ -
construct a nullptr client data
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
operator=() void*() const*()
│ │ │ +
[report issue]
│ │ │ +
operator=() hasher()
│ │ │
│ │ │ -client_data_t& operator= (void*) = delete;
│ │ │ -operator void* () const = delete;
│ │ │ -client_data_t& operator= (void const*) = delete;
│ │ │ -operator void const* () const = delete;
│ │ │ +hasher& operator= (hasher const&) &;
│ │ │ +hasher (char const* data, int len);
│ │ │ +hasher (hasher const&);
│ │ │ +explicit hasher (span<char const> data);
│ │ │
│ │ │ -
we don't allow type-unsafe operations
│ │ │ +
this is the same as default constructing followed by a call to
│ │ │ +update(data, len).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
update()
│ │ │ +
│ │ │ +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 ();
│ │ │ +
│ │ │ +
returns the SHA-1 digest of the buffers previously passed to
│ │ │ +update() and the hasher constructor.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
reset()
│ │ │ +
│ │ │ +void reset ();
│ │ │ +
│ │ │ +
restore the hasher state to be as if the hasher has just been
│ │ │ +default constructed.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
hasher256
│ │ │ +
Declared in "libtorrent/hasher.hpp"
│ │ │ +
│ │ │ +class hasher256
│ │ │ +{
│ │ │ + hasher256 ();
│ │ │ + hasher256& operator= (hasher256 const&) &;
│ │ │ + hasher256 (char const* data, int len);
│ │ │ + explicit hasher256 (span<char const> data);
│ │ │ + hasher256 (hasher256 const&);
│ │ │ + hasher256& update (span<char const> data);
│ │ │ + hasher256& update (char const* data, int len);
│ │ │ + sha256_hash final ();
│ │ │ + void reset ();
│ │ │ + ~hasher256 ();
│ │ │ +};
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
operator=() hasher256()
│ │ │ +
│ │ │ +hasher256& operator= (hasher256 const&) &;
│ │ │ +hasher256 (char const* data, int len);
│ │ │ +explicit hasher256 (span<char const> data);
│ │ │ +hasher256 (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);
│ │ │ +
│ │ │ +
append the following bytes to what is being hashed
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
final()
│ │ │ +
│ │ │ +sha256_hash final ();
│ │ │ +
│ │ │ +
returns the SHA-1 digest of the buffers previously passed to
│ │ │ +update() and the hasher constructor.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
reset()
│ │ │ +
│ │ │ +void reset ();
│ │ │ +
│ │ │ +
restore the hasher state to be as if the hasher has just been
│ │ │ +default constructed.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
torrent_status
│ │ │ +
Declared in "libtorrent/torrent_status.hpp"
│ │ │ +
holds a snapshot of the status of a torrent, as queried by
│ │ │ +torrent_handle::status().
│ │ │ +
│ │ │ +struct torrent_status
│ │ │ +{
│ │ │ + bool operator== (torrent_status const& st) const;
│ │ │ +
│ │ │ + enum state_t
│ │ │ + {
│ │ │ + checking_files,
│ │ │ + downloading_metadata,
│ │ │ + downloading,
│ │ │ + finished,
│ │ │ + seeding,
│ │ │ + unused_enum_for_backwards_compatibility_allocating,
│ │ │ + checking_resume_data,
│ │ │ + };
│ │ │ +
│ │ │ + torrent_handle handle;
│ │ │ + error_code errc;
│ │ │ + file_index_t error_file = torrent_status::error_file_none;
│ │ │ + static constexpr file_index_t error_file_none {-1};
│ │ │ + static constexpr file_index_t error_file_ssl_ctx {-3};
│ │ │ + static constexpr file_index_t error_file_metadata {-4};
│ │ │ + static constexpr file_index_t error_file_exception {-5};
│ │ │ + static constexpr file_index_t error_file_partfile {-6};
│ │ │ + std::string save_path;
│ │ │ + std::string name;
│ │ │ + std::weak_ptr<const torrent_info> torrent_file;
│ │ │ + time_duration next_announce = seconds{0};
│ │ │ + std::string current_tracker;
│ │ │ + std::int64_t total_download = 0;
│ │ │ + std::int64_t total_upload = 0;
│ │ │ + std::int64_t total_payload_download = 0;
│ │ │ + std::int64_t total_payload_upload = 0;
│ │ │ + std::int64_t total_failed_bytes = 0;
│ │ │ + std::int64_t total_redundant_bytes = 0;
│ │ │ + typed_bitfield<piece_index_t> pieces;
│ │ │ + typed_bitfield<piece_index_t> verified_pieces;
│ │ │ + std::int64_t total_done = 0;
│ │ │ + std::int64_t total = 0;
│ │ │ + std::int64_t total_wanted_done = 0;
│ │ │ + std::int64_t total_wanted = 0;
│ │ │ + std::int64_t all_time_upload = 0;
│ │ │ + std::int64_t all_time_download = 0;
│ │ │ + std::time_t added_time = 0;
│ │ │ + std::time_t completed_time = 0;
│ │ │ + std::time_t last_seen_complete = 0;
│ │ │ + storage_mode_t storage_mode = storage_mode_sparse;
│ │ │ + float progress = 0.f;
│ │ │ + int progress_ppm = 0;
│ │ │ + queue_position_t queue_position {};
│ │ │ + int download_rate = 0;
│ │ │ + int upload_rate = 0;
│ │ │ + int download_payload_rate = 0;
│ │ │ + int upload_payload_rate = 0;
│ │ │ + int num_seeds = 0;
│ │ │ + int num_peers = 0;
│ │ │ + int num_complete = -1;
│ │ │ + int num_incomplete = -1;
│ │ │ + int list_seeds = 0;
│ │ │ + int list_peers = 0;
│ │ │ + int connect_candidates = 0;
│ │ │ + int num_pieces = 0;
│ │ │ + int distributed_full_copies = 0;
│ │ │ + int distributed_fraction = 0;
│ │ │ + float distributed_copies = 0.f;
│ │ │ + int block_size = 0;
│ │ │ + int num_uploads = 0;
│ │ │ + int num_connections = 0;
│ │ │ + int uploads_limit = 0;
│ │ │ + int connections_limit = 0;
│ │ │ + int up_bandwidth_queue = 0;
│ │ │ + int down_bandwidth_queue = 0;
│ │ │ + int seed_rank = 0;
│ │ │ + state_t state = checking_resume_data;
│ │ │ + bool need_save_resume = false;
│ │ │ + bool is_seeding = false;
│ │ │ + bool is_finished = false;
│ │ │ + bool has_metadata = false;
│ │ │ + bool has_incoming = false;
│ │ │ + bool moving_storage = false;
│ │ │ + bool announcing_to_trackers = false;
│ │ │ + bool announcing_to_lsd = false;
│ │ │ + bool announcing_to_dht = false;
│ │ │ + info_hash_t info_hashes;
│ │ │ + time_point last_upload;
│ │ │ + time_point last_download;
│ │ │ + seconds active_duration;
│ │ │ + seconds finished_duration;
│ │ │ + seconds seeding_duration;
│ │ │ + torrent_flags_t flags {};
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
operator==()
│ │ │ +
│ │ │ +bool operator== (torrent_status const& st) const;
│ │ │ +
│ │ │ +
compares if the torrent status objects come from the same torrent. i.e.
│ │ │ +only the torrent_handle field is compared.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum state_t
│ │ │ +
Declared in "libtorrent/torrent_status.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| checking_files |
│ │ │ +1 |
│ │ │ +The torrent has not started its download yet, and is
│ │ │ +currently checking existing files. |
│ │ │ +
│ │ │ +| downloading_metadata |
│ │ │ +2 |
│ │ │ +The torrent is trying to download metadata from peers.
│ │ │ +This implies the ut_metadata extension is in use. |
│ │ │ +
│ │ │ +| downloading |
│ │ │ +3 |
│ │ │ +The torrent is being downloaded. This is the state
│ │ │ +most torrents will be in most of the time. The progress
│ │ │ +meter will tell how much of the files that has been
│ │ │ +downloaded. |
│ │ │ +
│ │ │ +| finished |
│ │ │ +4 |
│ │ │ +In this state the torrent has finished downloading but
│ │ │ +still doesn't have the entire torrent. i.e. some pieces
│ │ │ +are filtered and won't get downloaded. |
│ │ │ +
│ │ │ +| seeding |
│ │ │ +5 |
│ │ │ +In this state the torrent has finished downloading and
│ │ │ +is a pure seeder. |
│ │ │ +
│ │ │ +| unused_enum_for_backwards_compatibility_allocating |
│ │ │ +6 |
│ │ │ +If the torrent was started in full allocation mode, this
│ │ │ +indicates that the (disk) storage for the torrent is
│ │ │ +allocated. |
│ │ │ +
│ │ │ +| checking_resume_data |
│ │ │ +7 |
│ │ │ +The torrent is currently checking the fast resume data and
│ │ │ +comparing it to the files on disk. This is typically
│ │ │ +completed in a fraction of a second, but if you add a
│ │ │ +large number of torrents at once, they will queue up. |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- handle
│ │ │ +- a handle to the torrent whose status the object represents.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- errc
│ │ │ +- may be set to an error code describing why the torrent was paused, in
│ │ │ +case it was paused by an error. If the torrent is not paused or if it's
│ │ │ +paused but not because of an error, this error_code is not set.
│ │ │ +if the error is attributed specifically to a file, error_file is set to
│ │ │ +the index of that file in the .torrent file.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- error_file
│ │ │ +- if the torrent is stopped because of an disk I/O error, this field
│ │ │ +contains the index of the file in the torrent that encountered the
│ │ │ +error. If the error did not originate in a file in the torrent, there
│ │ │ +are a few special values this can be set to: error_file_none,
│ │ │ +error_file_ssl_ctx, error_file_exception, error_file_partfile or
│ │ │ +error_file_metadata;
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- error_file_none
│ │ │ +- special values for error_file to describe which file or component
│ │ │ +encountered the error (errc).
│ │ │ +the error did not occur on a file
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- error_file_ssl_ctx
│ │ │ +- the error occurred setting up the SSL context
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- error_file_metadata
│ │ │ +- the error occurred while loading the metadata for the torrent
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- error_file_exception
│ │ │ +- there was a serious error reported in this torrent. The error code
│ │ │ +or a torrent log alert may provide more information.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- error_file_partfile
│ │ │ +- the error occurred with the partfile
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- save_path
│ │ │ +- the path to the directory where this torrent's files are stored.
│ │ │ +It's typically the path as was given to async_add_torrent() or
│ │ │ +add_torrent() when this torrent was started. This field is only
│ │ │ +included if the torrent status is queried with
│ │ │ +torrent_handle::query_save_path.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- name
│ │ │ +- the name of the torrent. Typically this is derived from the
│ │ │ +.torrent file. In case the torrent was started without metadata,
│ │ │ +and hasn't completely received it yet, it returns the name given
│ │ │ +to it when added to the session. See session::add_torrent.
│ │ │ +This field is only included if the torrent status is queried
│ │ │ +with torrent_handle::query_name.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- torrent_file
│ │ │ +- set to point to the torrent_info object for this torrent. It's
│ │ │ +only included if the torrent status is queried with
│ │ │ +torrent_handle::query_torrent_file.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- next_announce
│ │ │ +- the time until the torrent will announce itself to the tracker.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- current_tracker
│ │ │ +- the URL of the last working tracker. If no tracker request has
│ │ │ +been successful yet, it's set to an empty string.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_download total_upload
│ │ │ +- the number of bytes downloaded and uploaded to all peers, accumulated,
│ │ │ +this session only. The session is considered to restart when a
│ │ │ +torrent is paused and restarted again. When a torrent is paused, these
│ │ │ +counters are reset to 0. If you want complete, persistent, stats, see
│ │ │ +all_time_upload and all_time_download.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_payload_download total_payload_upload
│ │ │ +- counts the amount of bytes send and received this session, but only
│ │ │ +the actual payload data (i.e the interesting data), these counters
│ │ │ +ignore any protocol overhead. The session is considered to restart
│ │ │ +when a torrent is paused and restarted again. When a torrent is
│ │ │ +paused, these counters are reset to 0.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_failed_bytes
│ │ │ +- the number of bytes that has been downloaded and that has failed the
│ │ │ +piece hash test. In other words, this is just how much crap that has
│ │ │ +been downloaded since the torrent was last started. If a torrent is
│ │ │ +paused and then restarted again, this counter will be reset.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_redundant_bytes
│ │ │ +- the number of bytes that has been downloaded even though that data
│ │ │ +already was downloaded. The reason for this is that in some situations
│ │ │ +the same data can be downloaded by mistake. When libtorrent sends
│ │ │ +requests to a peer, and the peer doesn't send a response within a
│ │ │ +certain timeout, libtorrent will re-request that block. Another
│ │ │ +situation when libtorrent may re-request blocks is when the requests
│ │ │ +it sends out are not replied in FIFO-order (it will re-request blocks
│ │ │ +that are skipped by an out of order block). This is supposed to be as
│ │ │ +low as possible. This only counts bytes since the torrent was last
│ │ │ +started. If a torrent is paused and then restarted again, this counter
│ │ │ +will be reset.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- pieces
│ │ │ +- a bitmask that represents which pieces we have (set to true) and the
│ │ │ +pieces we don't have. It's a pointer and may be set to 0 if the
│ │ │ +torrent isn't downloading or seeding.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- verified_pieces
│ │ │ +- a bitmask representing which pieces has had their hash checked. This
│ │ │ +only applies to torrents in seed mode. If the torrent is not in seed
│ │ │ +mode, this bitmask may be empty.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_done
│ │ │ +- the total number of bytes of the file(s) that we have. All this does
│ │ │ +not necessarily has to be downloaded during this session (that's
│ │ │ +total_payload_download).
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total
│ │ │ +- the total number of bytes to download for this torrent. This
│ │ │ +may be less than the size of the torrent in case there are
│ │ │ +pad files. This number only counts bytes that will actually
│ │ │ +be requested from peers.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_wanted_done
│ │ │ +- the number of bytes we have downloaded, only counting the pieces that
│ │ │ +we actually want to download. i.e. excluding any pieces that we have
│ │ │ +but have priority 0 (i.e. not wanted).
│ │ │ +Once a torrent becomes seed, any piece- and file priorities are
│ │ │ +forgotten and all bytes are considered "wanted".
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- total_wanted
│ │ │ +- The total number of bytes we want to download. This may be smaller
│ │ │ +than the total torrent size in case any pieces are prioritized to 0,
│ │ │ +i.e. not wanted.
│ │ │ +Once a torrent becomes seed, any piece- and file priorities are
│ │ │ +forgotten and all bytes are considered "wanted".
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- all_time_upload all_time_download
│ │ │ +- are accumulated upload and download payload byte counters. They are
│ │ │ +saved in and restored from resume data to keep totals across sessions.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- added_time
│ │ │ +- the posix-time when this torrent was added. i.e. what time(nullptr)
│ │ │ +returned at the time.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- completed_time
│ │ │ +- the posix-time when this torrent was finished. If the torrent is not
│ │ │ +yet finished, this is 0.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- last_seen_complete
│ │ │ +- the time when we, or one of our peers, last saw a complete copy of
│ │ │ +this torrent.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- storage_mode
│ │ │ +- The allocation mode for the torrent. See storage_mode_t for the
│ │ │ +options. For more information, see storage allocation.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- progress
│ │ │ +- a value in the range [0, 1], that represents the progress of the
│ │ │ +torrent's current task. It may be checking files or downloading.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- progress_ppm
│ │ │ +progress parts per million (progress * 1000000) when disabling
│ │ │ +floating point operations, this is the only option to query progress
│ │ │ +reflects the same value as progress, but instead in a range [0,
│ │ │ +1000000] (ppm = parts per million). When floating point operations are
│ │ │ +disabled, this is the only alternative to the floating point value in
│ │ │ +progress.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- queue_position
│ │ │ +- the position this torrent has in the download
│ │ │ +queue. If the torrent is a seed or finished, this is -1.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- download_rate upload_rate
│ │ │ +- the total rates for all peers for this torrent. These will usually
│ │ │ +have better precision than summing the rates from all peers. The rates
│ │ │ +are given as the number of bytes per second.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- download_payload_rate upload_payload_rate
│ │ │ +- the total transfer rate of payload only, not counting protocol
│ │ │ +chatter. This might be slightly smaller than the other rates, but if
│ │ │ +projected over a long time (e.g. when calculating ETA:s) the
│ │ │ +difference may be noticeable.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- num_seeds
│ │ │ +- the number of peers that are seeding that this client is
│ │ │ +currently connected to.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- num_peers
│ │ │ +- the number of peers this torrent currently is connected to. Peer
│ │ │ +connections that are in the half-open state (is attempting to connect)
│ │ │ +or are queued for later connection attempt do not count. Although they
│ │ │ +are visible in the peer list when you call get_peer_info().
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- num_complete num_incomplete
│ │ │ +- if the tracker sends scrape info in its announce reply, these fields
│ │ │ +will be set to the total number of peers that have the whole file and
│ │ │ +the total number of peers that are still downloading. set to -1 if the
│ │ │ +tracker did not send any scrape data in its announce reply.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- list_seeds list_peers
│ │ │ +- the number of seeds in our peer list and the total number of peers
│ │ │ +(including seeds). We are not necessarily connected to all the peers
│ │ │ +in our peer list. This is the number of peers we know of in total,
│ │ │ +including banned peers and peers that we have failed to connect to.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- connect_candidates
│ │ │ +- the number of peers in this torrent's peer list that is a candidate to
│ │ │ +be connected to. i.e. It has fewer connect attempts than the max fail
│ │ │ +count, it is not a seed if we are a seed, it is not banned etc. If
│ │ │ +this is 0, it means we don't know of any more peers that we can try.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- num_pieces
│ │ │ +- the number of pieces that has been downloaded. It is equivalent to:
│ │ │ +std::accumulate(pieces->begin(), pieces->end()). So you don't have
│ │ │ +to count yourself. This can be used to see if anything has updated
│ │ │ +since last time if you want to keep a graph of the pieces up to date.
│ │ │ +Note that these pieces have not necessarily been written to disk yet,
│ │ │ +and there is a risk the write to disk will fail.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- distributed_full_copies
│ │ │ +- the number of distributed copies of the torrent. Note that one copy
│ │ │ +may be spread out among many peers. It tells how many copies there are
│ │ │ +currently of the rarest piece(s) among the peers this client is
│ │ │ +connected to.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- distributed_fraction
│ │ │ +tells the share of pieces that have more copies than the rarest
│ │ │ +piece(s). Divide this number by 1000 to get the fraction.
│ │ │ +For example, if distributed_full_copies is 2 and
│ │ │ +distributed_fraction is 500, it means that the rarest pieces have
│ │ │ +only 2 copies among the peers this torrent is connected to, and that
│ │ │ +50% of all the pieces have more than two copies.
│ │ │ +If we are a seed, the piece picker is deallocated as an optimization,
│ │ │ +and piece availability is no longer tracked. In this case the
│ │ │ +distributed copies members are set to -1.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- distributed_copies
│ │ │ +the number of distributed copies of the file. note that one copy may
│ │ │ +be spread out among many peers. This is a floating point
│ │ │ +representation of the distributed copies.
│ │ │ +
│ │ │ +- the integer part tells how many copies
│ │ │ +- there are of the rarest piece(s)
│ │ │ +- the fractional part tells the fraction of pieces that
│ │ │ +- have more copies than the rarest piece(s).
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- block_size
│ │ │ +- the size of a block, in bytes. A block is a sub piece, it is the
│ │ │ +number of bytes that each piece request asks for and the number of
│ │ │ +bytes that each bit in the partial_piece_info's bitset represents,
│ │ │ +see get_download_queue(). This is typically 16 kB, but it may be
│ │ │ +smaller, if the pieces are smaller.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- num_uploads
│ │ │ +- the number of unchoked peers in this torrent.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- num_connections
│ │ │ +- the number of peer connections this torrent has, including half-open
│ │ │ +connections that hasn't completed the bittorrent handshake yet. This
│ │ │ +is always >= num_peers.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- uploads_limit
│ │ │ +- the set limit of upload slots (unchoked peers) for this torrent.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- connections_limit
│ │ │ +- the set limit of number of connections for this torrent.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- up_bandwidth_queue down_bandwidth_queue
│ │ │ +- the number of peers in this torrent that are waiting for more
│ │ │ +bandwidth quota from the torrent rate limiter. This can determine if
│ │ │ +the rate you get from this torrent is bound by the torrents limit or
│ │ │ +not. If there is no limit set on this torrent, the peers might still
│ │ │ +be waiting for bandwidth quota from the global limiter, but then they
│ │ │ +are counted in the session_status object.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- seed_rank
│ │ │ +- A rank of how important it is to seed the torrent, it is used to
│ │ │ +determine which torrents to seed and which to queue. It is based on
│ │ │ +the peer to seed ratio from the tracker scrape. For more information,
│ │ │ +see queuing. Higher value means more important to seed
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- state
│ │ │ +- the main state the torrent is in. See torrent_status::state_t.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- need_save_resume
│ │ │ +- true if this torrent has unsaved changes
│ │ │ +to its download state and statistics since the last resume data
│ │ │ +was saved.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- is_seeding
│ │ │ +- true if all pieces have been downloaded.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- is_finished
│ │ │ +- true if all pieces that have a priority > 0 are downloaded. There is
│ │ │ +only a distinction between finished and seeding if some pieces or
│ │ │ +files have been set to priority 0, i.e. are not downloaded.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- has_metadata
│ │ │ +- true if this torrent has metadata (either it was started from a
│ │ │ +.torrent file or the metadata has been downloaded). The only scenario
│ │ │ +where this can be false is when the torrent was started torrent-less
│ │ │ +(i.e. with just an info-hash and tracker ip, a magnet link for
│ │ │ +instance).
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- has_incoming
│ │ │ +- true if there has ever been an incoming connection attempt to this
│ │ │ +torrent.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- moving_storage
│ │ │ +- this is true if this torrent's storage is currently being moved from
│ │ │ +one location to another. This may potentially be a long operation
│ │ │ +if a large file ends up being copied from one drive to another.
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- announcing_to_trackers announcing_to_lsd announcing_to_dht
│ │ │ +- these are set to true if this torrent is allowed to announce to the
│ │ │ +respective peer source. Whether they are true or false is determined by
│ │ │ +the queue logic/auto manager. Torrents that are not auto managed will
│ │ │ +always be allowed to announce to all peer sources.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- info_hashes
│ │ │ +- the info-hash for this torrent
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- last_upload last_download
│ │ │ +- the timestamps of the last time this torrent uploaded or downloaded
│ │ │ +payload to any peer.
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- active_duration finished_duration seeding_duration
│ │ │ +- these are cumulative counters of for how long the torrent has been in
│ │ │ +different states. active means not paused and added to session. Whether
│ │ │ +it has found any peers or not is not relevant.
│ │ │ +finished means all selected files/pieces were downloaded and available
│ │ │ +to other peers (this is always a subset of active time).
│ │ │ +seeding means all files/pieces were downloaded and available to
│ │ │ +peers. Being available to peers does not imply there are other peers
│ │ │ +asking for the payload.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- flags
│ │ │ +- reflects several of the torrent's flags. For more
│ │ │ +information, see torrent_handle::flags().
│ │ │ +
│ │ │
[report issue]
│ │ │
│ │ │
│ │ │
add_torrent_params
│ │ │
Declared in "libtorrent/add_torrent_params.hpp"
│ │ │
The add_torrent_params contains all the information in a .torrent file
│ │ │ along with all information necessary to add that torrent to a session.
│ │ │ @@ -6919,186 +6045,67 @@
│ │ │ [report issue]
│ │ │ - last_download last_upload
│ │ │ - the posix time of the last time payload was received or sent for this
│ │ │ torrent, respectively. A value of 0 means we don't know when we last
│ │ │ uploaded or downloaded, or we have never uploaded or downloaded any
│ │ │ payload for this torrent.
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
peer_class_info
│ │ │ -
Declared in "libtorrent/peer_class.hpp"
│ │ │ -
holds settings for a peer class. Used in set_peer_class() and
│ │ │ -get_peer_class() calls.
│ │ │ -
│ │ │ -struct peer_class_info
│ │ │ -{
│ │ │ - bool ignore_unchoke_slots;
│ │ │ - int connection_limit_factor;
│ │ │ - std::string label;
│ │ │ - int upload_limit;
│ │ │ - int download_limit;
│ │ │ - int upload_priority;
│ │ │ - int download_priority;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- ignore_unchoke_slots
│ │ │ -- ignore_unchoke_slots determines whether peers should always
│ │ │ -unchoke a peer, regardless of the choking algorithm, or if it should
│ │ │ -honor the unchoke slot limits. It's used for local peers by default.
│ │ │ -If any of the peer classes a peer belongs to has this set to true,
│ │ │ -that peer will be unchoked at all times.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- connection_limit_factor
│ │ │ -- adjusts the connection limit (global and per torrent) that applies to
│ │ │ -this peer class. By default, local peers are allowed to exceed the
│ │ │ -normal connection limit for instance. This is specified as a percent
│ │ │ -factor. 100 makes the peer class apply normally to the limit. 200
│ │ │ -means as long as there are fewer connections than twice the limit, we
│ │ │ -accept this peer. This factor applies both to the global connection
│ │ │ -limit and the per-torrent limit. Note that if not used carefully one
│ │ │ -peer class can potentially completely starve out all other over time.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- label
│ │ │ -- not used by libtorrent. It's intended as a potentially user-facing
│ │ │ -identifier of this peer class.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- upload_limit download_limit
│ │ │ -- transfer rates limits for the whole peer class. They are specified in
│ │ │ -bytes per second and apply to the sum of all peers that are members of
│ │ │ -this class.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- upload_priority download_priority
│ │ │ -- relative priorities used by the bandwidth allocator in the rate
│ │ │ -limiter. If no rate limits are in use, the priority is not used
│ │ │ -either. Priorities start at 1 (0 is not a valid priority) and may not
│ │ │ -exceed 255.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
peer_class_type_filter
│ │ │ -
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).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
client_data_t
│ │ │ +
Declared in "libtorrent/client_data.hpp"
│ │ │ +
A thin wrapper around a void pointer used as "user data". i.e. an opaque
│ │ │ +cookie passed in to libtorrent and returned on demand. It adds type-safety by
│ │ │ +requiring the same type be requested out of it as was assigned to it.
│ │ │
│ │ │ -struct peer_class_type_filter
│ │ │ +struct client_data_t
│ │ │ {
│ │ │ - 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 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);
│ │ │ + 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* () const = delete;
│ │ │ + operator void* () const = delete;
│ │ │ + client_data_t& operator= (void*) = delete;
│ │ │ + client_data_t& operator= (void const*) = delete;
│ │ │
│ │ │ - enum socket_type_t
│ │ │ - {
│ │ │ - tcp_socket,
│ │ │ - utp_socket,
│ │ │ - ssl_tcp_socket,
│ │ │ - ssl_utp_socket,
│ │ │ - i2p_socket,
│ │ │ - num_socket_types,
│ │ │ - };
│ │ │ + template <typename T, typename U = typename std::enable_if<std::is_pointer<T>::value>::type>
│ │ │ };
│ │ │
│ │ │ -
│ │ │ -
[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);
│ │ │ -
│ │ │ -
add() and remove() adds and removes a peer class to be added
│ │ │ -to new peers based on socket type.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
allow() disallow()
│ │ │ +
[report issue]
│ │ │ +
client_data_t()
│ │ │
│ │ │ -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);
│ │ │ +client_data_t () = default;
│ │ │
│ │ │ -
disallow() and allow() adds and removes a peer class to be
│ │ │ -removed from new peers based on socket type.
│ │ │ -
The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ -peer classes in the peer_class_type_filter are 32 bits.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
apply()
│ │ │ +
construct a nullptr client data
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
operator=() void*() const*()
│ │ │
│ │ │ -std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ +operator void const* () const = delete;
│ │ │ +operator void* () const = delete;
│ │ │ +client_data_t& operator= (void*) = delete;
│ │ │ +client_data_t& operator= (void const*) = delete;
│ │ │
│ │ │ -
takes a bitmask of peer classes and returns a new bitmask of
│ │ │ -peer classes after the rules have been applied, based on the socket type argument
│ │ │ -(st).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum socket_type_t
│ │ │ -
Declared in "libtorrent/peer_class_type_filter.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| tcp_socket |
│ │ │ -0 |
│ │ │ -these match the socket types from socket_type.hpp
│ │ │ -shifted one down |
│ │ │ -
│ │ │ -| utp_socket |
│ │ │ -1 |
│ │ │ - |
│ │ │ -
│ │ │ -| ssl_tcp_socket |
│ │ │ -2 |
│ │ │ - |
│ │ │ -
│ │ │ -| ssl_utp_socket |
│ │ │ -3 |
│ │ │ - |
│ │ │ -
│ │ │ -| i2p_socket |
│ │ │ -4 |
│ │ │ - |
│ │ │ -
│ │ │ -| num_socket_types |
│ │ │ -5 |
│ │ │ - |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
we don't allow type-unsafe operations
│ │ │
[report issue]
│ │ │
│ │ │
│ │ │
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
│ │ │ {
│ │ │ - void set_peer (tcp::endpoint const& ep);
│ │ │ tcp::endpoint peer () const;
│ │ │ + void set_peer (tcp::endpoint const& ep);
│ │ │
│ │ │ enum block_state_t
│ │ │ {
│ │ │ none,
│ │ │ requested,
│ │ │ writing,
│ │ │ finished,
│ │ │ @@ -7106,20 +6113,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()
│ │ │
│ │ │ -void set_peer (tcp::endpoint const& ep);
│ │ │ 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]
│ │ │
│ │ │
enum block_state_t
│ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │
│ │ │ @@ -7262,103 +6269,103 @@
│ │ │ {
│ │ │ friend std::size_t hash_value (torrent_handle const& th);
│ │ │ torrent_handle () noexcept = default;
│ │ │ 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;
│ │ │ + void post_peer_info () 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;
│ │ │ - void post_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;
│ │ │ - void set_piece_deadline (piece_index_t index, int deadline, deadline_flags_t flags = {}) 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;
│ │ │ std::vector<open_file_state> file_status () const;
│ │ │ void clear_error () const;
│ │ │ - void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ std::vector<announce_entry> trackers () const;
│ │ │ - void post_trackers () const;
│ │ │ void add_tracker (announce_entry const&) const;
│ │ │ + void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ + void post_trackers () const;
│ │ │ + std::set<std::string> url_seeds () 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;
│ │ │ - void remove_http_seed (std::string const& url) const;
│ │ │ void add_http_seed (std::string const& url) const;
│ │ │ + void remove_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 resume () const;
│ │ │ void pause (pause_flags_t flags = {}) const;
│ │ │ + void resume () const;
│ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ void set_flags (torrent_flags_t flags) const;
│ │ │ void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ 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 () const;
│ │ │ bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ + bool need_save_resume_data () const;
│ │ │ + queue_position_t queue_position () const;
│ │ │ void queue_position_up () const;
│ │ │ - void queue_position_bottom () const;
│ │ │ void queue_position_top () const;
│ │ │ - queue_position_t queue_position () const;
│ │ │ void queue_position_down () const;
│ │ │ + void queue_position_bottom () const;
│ │ │ void queue_position_set (queue_position_t p) const;
│ │ │ void set_ssl_certificate_buffer (std::string const& certificate
│ │ │ , std::string const& private_key
│ │ │ , std::string const& dh_params);
│ │ │ void set_ssl_certificate (std::string const& certificate
│ │ │ , std::string const& private_key
│ │ │ , std::string const& dh_params
│ │ │ , std::string const& passphrase = "");
│ │ │ 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 post_piece_availability () const;
│ │ │ + std::vector<download_priority_t> get_piece_priorities () 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;
│ │ │ 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<download_priority_t> const& pieces) const;
│ │ │ - std::vector<download_priority_t> get_piece_priorities () const;
│ │ │ - download_priority_t file_priority (file_index_t index) 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;
│ │ │ - void force_lsd_announce () const;
│ │ │ + download_priority_t file_priority (file_index_t index) const;
│ │ │ + void file_priority (file_index_t index, download_priority_t priority) 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_download_limit (int limit) const;
│ │ │ - int upload_limit () const;
│ │ │ int download_limit () const;
│ │ │ + int upload_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;
│ │ │ void set_max_connections (int max_connections) const;
│ │ │ 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;
│ │ │ - sha1_hash info_hash () 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;
│ │ │ std::uint32_t id () const;
│ │ │ std::shared_ptr<torrent> native_handle () const;
│ │ │ client_data_t userdata () const;
│ │ │ bool in_session () const;
│ │ │ @@ -7444,16 +6451,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
│ │ │ @@ -7486,33 +6493,33 @@
│ │ │
By default everything is included. The flags you can use to decide
│ │ │ what to include are defined in this class.
│ │ │
│ │ │
[report issue]
│ │ │
get_download_queue() post_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;
│ │ │ -void post_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 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;
│ │ │ -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
│ │ │ 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
│ │ │ @@ -7567,29 +6574,29 @@
│ │ │
│ │ │
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() add_tracker() post_trackers() replace_trackers()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
replace_trackers() add_tracker() trackers() post_trackers()
│ │ │
│ │ │ -void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ std::vector<announce_entry> trackers () const;
│ │ │ -void post_trackers () const;
│ │ │ void add_tracker (announce_entry const&) const;
│ │ │ +void replace_trackers (std::vector<announce_entry> const&) const;
│ │ │ +void post_trackers () 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
│ │ │ +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
│ │ │ one returned from trackers() and will replace it. If you want an
│ │ │ immediate effect, you have to call force_reannounce(). See
│ │ │ announce_entry.
│ │ │
post_trackers() is the asynchronous version of trackers(). It
│ │ │ @@ -7597,41 +6604,41 @@
│ │ │
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]
│ │ │ -
│ │ │ -
url_seeds() remove_url_seed() add_url_seed()
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_url_seed() remove_url_seed() url_seeds()
│ │ │
│ │ │ +std::set<std::string> url_seeds () 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;
│ │ │
│ │ │
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]
│ │ │ -
│ │ │ -
remove_http_seed() http_seeds() add_http_seed()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
http_seeds() remove_http_seed() add_http_seed()
│ │ │
│ │ │ -void remove_http_seed (std::string const& url) const;
│ │ │ void add_http_seed (std::string const& url) const;
│ │ │ +void remove_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]
│ │ │
│ │ │ @@ -7656,15 +6663,15 @@
│ │ │ buffer passed in will be hashed and verified against the info-hash. If
│ │ │ it fails, a
metadata_failed_alert will be generated. If it passes,
│ │ │ a
metadata_received_alert is generated. The function returns true
│ │ │ if the metadata is successfully set on the torrent, and false
│ │ │ otherwise. If the torrent already has metadata, this function will not
│ │ │ affect the torrent, and false will be returned.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
is_valid()
│ │ │
│ │ │ bool is_valid () const;
│ │ │
│ │ │
Returns true if this handle refers to a valid torrent and false if it
│ │ │ hasn't been initialized or if the torrent it refers to has been
│ │ │ removed from the session AND destructed.
│ │ │ @@ -7674,21 +6681,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 resume () const;
│ │ │ void pause (pause_flags_t flags = {}) const;
│ │ │ +void resume () 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.
│ │ │ @@ -7699,19 +6706,19 @@
│ │ │
│ │ │
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]
│ │ │ -
│ │ │ -
set_flags() flags() unset_flags()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
flags() unset_flags() set_flags()
│ │ │
│ │ │ void unset_flags (torrent_flags_t flags) const;
│ │ │ void set_flags (torrent_flags_t flags) const;
│ │ │ void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
│ │ │ torrent_flags_t flags () const;
│ │ │
│ │ │
sets and gets the torrent state flags. See torrent_flags_t.
│ │ │ @@ -7853,16 +6860,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 () const;
│ │ │ bool need_save_resume_data (resume_data_flags_t flags) const;
│ │ │ +bool need_save_resume_data () 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
│ │ │ @@ -7872,27 +6879,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_top() queue_position_bottom() queue_position_up() queue_position() queue_position_down()
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
queue_position_down() queue_position() queue_position_bottom() queue_position_top() queue_position_up()
│ │ │
│ │ │ +queue_position_t queue_position () const;
│ │ │ void queue_position_up () const;
│ │ │ -void queue_position_bottom () const;
│ │ │ void queue_position_top () const;
│ │ │ -queue_position_t queue_position () const;
│ │ │ void queue_position_down () const;
│ │ │ +void queue_position_bottom () 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
│ │ │ @@ -7992,42 +6999,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]
│ │ │ -
│ │ │ -
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]
│ │ │ -
│ │ │ -
piece_priority() get_piece_priorities() prioritize_pieces()
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
prioritize_pieces() get_piece_priorities() piece_priority()
│ │ │
│ │ │ +std::vector<download_priority_t> get_piece_priorities () 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;
│ │ │ 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<download_priority_t> const& pieces) 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
│ │ │ @@ -8049,24 +7056,24 @@
│ │ │ Invalid entries, where the piece index or priority is out of range, are
│ │ │ not allowed.
│ │ │
get_piece_priorities returns a vector with one element for each piece
│ │ │ in the torrent. Each element is the current priority of that piece.
│ │ │
It's possible to cancel the effect of file priorities by setting the
│ │ │ priorities for the affected pieces. Care has to be taken when mixing
│ │ │ usage of file- and piece priorities.
│ │ │ -
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
prioritize_files() file_priority() get_file_priorities()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
file_priority() get_file_priorities() prioritize_files()
│ │ │
│ │ │ -download_priority_t file_priority (file_index_t index) 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;
│ │ │ +download_priority_t file_priority (file_index_t index) const;
│ │ │ +void file_priority (file_index_t index, download_priority_t priority) const;
│ │ │
│ │ │
index must be in the range [0, number_of_files).
│ │ │
file_priority() queries or sets the priority of file index.
│ │ │
prioritize_files() takes a vector that has at as many elements as
│ │ │ there are files in the torrent. Each entry is the priority of that
│ │ │ file. The function sets the priorities of all the pieces in the
│ │ │ torrent based on the vector.
│ │ │ @@ -8089,22 +7096,22 @@
│ │ │
file_prio_alert.
│ │ │
When combining file- and piece priorities, the resume file will record
│ │ │ both. When loading the resume data, the file priorities will be applied
│ │ │ first, then the piece priorities.
│ │ │
Moving data from a file into the part file is currently not
│ │ │ supported. If a file has its priority set to 0 after it has already
│ │ │ been created, it will not be moved into the partfile.
│ │ │ -
│ │ │ +
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
force_reannounce() force_lsd_announce() force_dht_announce()
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
force_dht_announce() force_lsd_announce() force_reannounce()
│ │ │
│ │ │ -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
│ │ │ @@ -8129,24 +7136,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() set_download_limit() download_limit()
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_download_limit() upload_limit() set_upload_limit() download_limit()
│ │ │
│ │ │ void set_download_limit (int limit) const;
│ │ │ -int upload_limit () const;
│ │ │ int download_limit () const;
│ │ │ +int upload_limit () const;
│ │ │ void set_upload_limit (int limit) const;
│ │ │
│ │ │
set_upload_limit will limit the upload bandwidth used by this
│ │ │ particular torrent to the limit you set. It is given as the number of
│ │ │ bytes per second the torrent is allowed to upload.
│ │ │ set_download_limit works the same way but for download bandwidth
│ │ │ instead of upload bandwidth. Note that setting a higher limit on a
│ │ │ @@ -8262,41 +7269,41 @@
│ │ │ well. This goes for files that have been renamed to absolute paths
│ │ │ that still end up inside the save path.
│ │ │
When copying files, sparse regions are not likely to be preserved.
│ │ │ This makes it proportionally more expensive to move a large torrent
│ │ │ when only few pieces have been downloaded, since the files are then
│ │ │ allocated with zeros in the destination directory.
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
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()
│ │ │
│ │ │ -sha1_hash info_hash () const;
│ │ │ info_hash_t info_hashes () const;
│ │ │ +sha1_hash info_hash () const;
│ │ │
│ │ │
returns the info-hash(es) of the torrent. If this handle is to a
│ │ │ torrent that hasn't loaded yet (for instance by being added) by a
│ │ │ URL, the returned value is undefined.
│ │ │ The info_hash() returns the SHA-1 info-hash for v1 torrents and a
│ │ │ truncated hash for v2 torrents. For the full v2 info-hash, use
│ │ │ info_hashes() instead.
│ │ │ -
│ │ │ +
│ │ │
│ │ │ -
[report issue]
│ │ │ +
[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;
│ │ │
│ │ │
comparison operators. The order of the torrents is unspecified
│ │ │ but stable.
│ │ │ @@ -8489,603 +7496,651 @@
│ │ │
│ │ │
hash_value()
│ │ │
Declared in "libtorrent/torrent_handle.hpp"
│ │ │
│ │ │ std::size_t hash_value (torrent_handle const& h);
│ │ │
│ │ │
for std::hash (and to support using this type in unordered_map etc.)
│ │ │ -
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
│ │ │ -to the session when passed to session::apply_settings(). It's empty when
│ │ │ -constructed.
│ │ │ -
You have control over proxy and authorization settings and also the user-agent
│ │ │ -that will be sent to the tracker. The user-agent will also be used to identify the
│ │ │ -client with other peers.
│ │ │ -
Each configuration option is named with an enum value inside the
│ │ │ -settings_pack class. These are the available settings:
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
open_file_state
│ │ │ -
Declared in "libtorrent/disk_interface.hpp"
│ │ │ -
this contains information about a file that's currently open by the
│ │ │ -libtorrent disk I/O subsystem. It's associated with a single torrent.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
web_seed_entry
│ │ │ +
Declared in "libtorrent/torrent_info.hpp"
│ │ │ +
the web_seed_entry holds information about a web seed (also known
│ │ │ +as URL seed or HTTP seed). It is essentially a URL with some state
│ │ │ +associated with it. For more information, see BEP 17 and BEP 19.
│ │ │
│ │ │ -struct open_file_state
│ │ │ +struct web_seed_entry
│ │ │ {
│ │ │ - file_index_t file_index;
│ │ │ - file_open_mode_t open_mode;
│ │ │ - time_point last_use;
│ │ │ + bool operator== (web_seed_entry const& e) const;
│ │ │ + bool operator< (web_seed_entry const& e) const;
│ │ │ +
│ │ │ + enum type_t
│ │ │ + {
│ │ │ + url_seed,
│ │ │ + http_seed,
│ │ │ + };
│ │ │ +
│ │ │ + std::string url;
│ │ │ + std::string auth;
│ │ │ + headers_t extra_headers;
│ │ │ + std::uint8_t type;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -- file_index
│ │ │ -- the index of the file this entry refers to into the file_storage
│ │ │ -file list of this torrent. This starts indexing at 0.
│ │ │ +[report issue]
│ │ │ +
operator==()
│ │ │ +
│ │ │ +bool operator== (web_seed_entry const& e) const;
│ │ │ +
│ │ │ +
URL and type comparison
│ │ │ +
[report issue]
│ │ │ +
operator<()
│ │ │ +
│ │ │ +bool operator< (web_seed_entry const& e) const;
│ │ │ +
│ │ │ +
URL and type less-than comparison
│ │ │ +
[report issue]
│ │ │ +
enum type_t
│ │ │ +
Declared in "libtorrent/torrent_info.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| url_seed |
│ │ │ +0 |
│ │ │ + |
│ │ │ +
│ │ │ +| http_seed |
│ │ │ +1 |
│ │ │ + |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- url
│ │ │ +- The URL of the web seed
│ │ │
│ │ │ -
[report issue]
│ │ │ -- open_mode
│ │ │ -open_mode is a bitmask of the file flags this file is currently
│ │ │ -opened with. For possible flags, see file_open_mode_t.
│ │ │ -Note that the read/write mode is not a bitmask. The two least significant bits are used
│ │ │ -to represent the read/write mode. Those bits can be masked out using the rw_mask constant.
│ │ │ -
│ │ │ +- auth
│ │ │ +- Optional authentication. If this is set, it's passed
│ │ │ +in as HTTP basic auth to the web seed. The format is:
│ │ │ +username:password.
│ │ │
│ │ │ -[report issue]
│ │ │ -- last_use
│ │ │ -- a (high precision) timestamp of when the file was last used.
│ │ │ +[report issue]
│ │ │ +- extra_headers
│ │ │ +- Any extra HTTP headers that need to be passed to the web seed
│ │ │
│ │ │ -[report issue]
│ │ │ -
disk_interface
│ │ │ -
Declared in "libtorrent/disk_interface.hpp"
│ │ │ -
The disk_interface is the customization point for disk I/O in libtorrent.
│ │ │ -implement this interface and provide a factory function to the session constructor
│ │ │ -use custom disk I/O. All functions on the disk subsystem (implementing
│ │ │ -disk_interface) are called from within libtorrent's network thread. For
│ │ │ -disk I/O to be performed in a separate thread, the disk subsystem has to
│ │ │ -manage that itself.
│ │ │ -
Although the functions are called async_*, they do not technically
│ │ │ -have to be asynchronous, but they support being asynchronous, by
│ │ │ -expecting the result passed back into a callback. The callbacks must be
│ │ │ -posted back onto the network thread via the io_context object passed into
│ │ │ -the constructor. The callbacks will be run in the network thread.
│ │ │ +
[report issue]
│ │ │ +- type
│ │ │ +- The type of web seed (see type_t)
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
load_torrent_limits
│ │ │ +
Declared in "libtorrent/torrent_info.hpp"
│ │ │ +
this object holds configuration options for limits to use when loading
│ │ │ +torrents. They are meant to prevent loading potentially malicious torrents
│ │ │ +that cause excessive memory allocations.
│ │ │
│ │ │ -struct disk_interface
│ │ │ +struct load_torrent_limits
│ │ │ {
│ │ │ - virtual storage_holder new_torrent (storage_params const& p
│ │ │ - , std::shared_ptr<void> const& torrent) = 0;
│ │ │ - virtual void remove_torrent (storage_index_t) = 0;
│ │ │ - virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ - , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ - , disk_job_flags_t flags = {}) = 0;
│ │ │ - virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ - , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ - , std::function<void(storage_error const&)> handler
│ │ │ - , disk_job_flags_t flags = {}) = 0;
│ │ │ - virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ - , disk_job_flags_t flags
│ │ │ - , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │ - virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ - , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │ - virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ - , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │ - virtual void async_release_files (storage_index_t storage
│ │ │ - , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │ - virtual void async_check_files (storage_index_t storage
│ │ │ - , add_torrent_params const* resume_data
│ │ │ - , aux::vector<std::string, file_index_t> links
│ │ │ - , std::function<void(status_t, storage_error const&)> handler) = 0;
│ │ │ - virtual void async_stop_torrent (storage_index_t storage
│ │ │ - , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │ - virtual void async_rename_file (storage_index_t storage
│ │ │ - , file_index_t index, std::string name
│ │ │ - , std::function<void(std::string const&, file_index_t, storage_error const&)> handler) = 0;
│ │ │ - virtual void async_delete_files (storage_index_t storage, remove_flags_t options
│ │ │ - , std::function<void(storage_error const&)> handler) = 0;
│ │ │ - virtual void async_set_file_priority (storage_index_t storage
│ │ │ - , aux::vector<download_priority_t, file_index_t> prio
│ │ │ - , std::function<void(storage_error const&
│ │ │ - , aux::vector<download_priority_t, file_index_t>)> handler) = 0;
│ │ │ - virtual void async_clear_piece (storage_index_t storage, piece_index_t index
│ │ │ - , std::function<void(piece_index_t)> handler) = 0;
│ │ │ - virtual void update_stats_counters (counters& c) const = 0;
│ │ │ - virtual std::vector<open_file_state> get_status (storage_index_t) const = 0;
│ │ │ - virtual void abort (bool wait) = 0;
│ │ │ - virtual void submit_jobs () = 0;
│ │ │ - virtual void settings_updated () = 0;
│ │ │ -
│ │ │ - static constexpr disk_job_flags_t force_copy = 0_bit;
│ │ │ - static constexpr disk_job_flags_t sequential_access = 3_bit;
│ │ │ - static constexpr disk_job_flags_t volatile_read = 4_bit;
│ │ │ - static constexpr disk_job_flags_t v1_hash = 5_bit;
│ │ │ - static constexpr disk_job_flags_t flush_piece = 7_bit;
│ │ │ + int max_buffer_size = 10000000;
│ │ │ + int max_pieces = 0x200000;
│ │ │ + int max_decode_depth = 100;
│ │ │ + int max_decode_tokens = 3000000;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
new_torrent()
│ │ │ +
[report issue]
│ │ │ +- max_buffer_size
│ │ │ +- the max size of a .torrent file to load into RAM
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- max_pieces
│ │ │ +- the max number of pieces allowed in the torrent
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- max_decode_depth
│ │ │ +- the max recursion depth in the bdecoded structure
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- max_decode_tokens
│ │ │ +- the max number of bdecode tokens
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
torrent_info
│ │ │ +
Declared in "libtorrent/torrent_info.hpp"
│ │ │ +
the torrent_info class holds the information found in a .torrent file.
│ │ │
│ │ │ -virtual storage_holder new_torrent (storage_params const& p
│ │ │ - , std::shared_ptr<void> const& torrent) = 0;
│ │ │ +class torrent_info
│ │ │ +{
│ │ │ + explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ + torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ + explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ + torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ + torrent_info (bdecode_node const& torrent_file, 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 (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ + torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ + torrent_info (torrent_info const& t);
│ │ │ + torrent_info (char const* buffer, int size);
│ │ │ + explicit torrent_info (info_hash_t const& info_hash);
│ │ │ + torrent_info (std::string const& filename, error_code& ec);
│ │ │ + ~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);
│ │ │ + 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 clear_trackers ();
│ │ │ + std::vector<announce_entry> const& trackers () const;
│ │ │ + std::vector<std::string> collections () const;
│ │ │ + std::vector<sha1_hash> similar_torrents () const;
│ │ │ + void add_url_seed (std::string const& url
│ │ │ + , std::string const& ext_auth = std::string()
│ │ │ + , web_seed_entry::headers_t const& ext_headers = web_seed_entry::headers_t());
│ │ │ + void add_http_seed (std::string const& url
│ │ │ + , std::string const& extern_auth = std::string()
│ │ │ + , web_seed_entry::headers_t const& extra_headers = web_seed_entry::headers_t());
│ │ │ + void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ + std::vector<web_seed_entry> const& web_seeds () const;
│ │ │ + std::int64_t total_size () const;
│ │ │ + int num_pieces () const;
│ │ │ + int piece_length () const;
│ │ │ + int blocks_per_piece () const;
│ │ │ + index_range<piece_index_t> piece_range () const;
│ │ │ + piece_index_t last_piece () const;
│ │ │ + piece_index_t end_piece () const;
│ │ │ + info_hash_t const& info_hashes () const;
│ │ │ + sha1_hash info_hash () const noexcept;
│ │ │ + bool v1 () const;
│ │ │ + bool v2 () const;
│ │ │ + int num_files () const;
│ │ │ + std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ + , std::int64_t offset, int size) const;
│ │ │ + peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │ + string_view ssl_cert () const;
│ │ │ + bool is_valid () const;
│ │ │ + bool priv () const;
│ │ │ + bool is_i2p () const;
│ │ │ + int piece_size (piece_index_t index) const;
│ │ │ + 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);
│ │ │ + bool parse_info_section (bdecode_node const& info, error_code& ec, int max_pieces);
│ │ │ + bdecode_node info (char const* key) const;
│ │ │ + span<char const> info_section () const;
│ │ │ + span<char const> piece_layer (file_index_t) const;
│ │ │ + void free_piece_layers ();
│ │ │ +};
│ │ │
│ │ │ -
this is called when a new torrent is added. The shared_ptr can be
│ │ │ -used to hold the internal torrent object alive as long as there are
│ │ │ -outstanding disk operations on the storage.
│ │ │ -The returned storage_holder is an owning reference to the underlying
│ │ │ -storage that was just created. It is fundamentally a storage_index_t
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
remove_torrent()
│ │ │ +
[report issue]
│ │ │ +
torrent_info()
│ │ │
│ │ │ -virtual void remove_torrent (storage_index_t) = 0;
│ │ │ +explicit torrent_info (bdecode_node const& torrent_file);
│ │ │ +torrent_info (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ +explicit torrent_info (span<char const> buffer, from_span_t);
│ │ │ +torrent_info (bdecode_node const& torrent_file, load_torrent_limits const& cfg);
│ │ │ +torrent_info (bdecode_node const& torrent_file, 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 (span<char const> buffer, error_code& ec, from_span_t);
│ │ │ +torrent_info (char const* buffer, int size, error_code& ec);
│ │ │ +torrent_info (torrent_info const& t);
│ │ │ +torrent_info (char const* buffer, int size);
│ │ │ +explicit torrent_info (info_hash_t const& info_hash);
│ │ │ +torrent_info (std::string const& filename, error_code& ec);
│ │ │
│ │ │ -
remove the storage with the specified index. This is not expected to
│ │ │ -delete any files from disk, just to clean up any resources associated
│ │ │ -with the specified storage.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_write() async_read()
│ │ │ +
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
│ │ │ +object from the information found in the given torrent_file. The
│ │ │ +bdecode_node represents a tree node in an bencoded file. To load an
│ │ │ +ordinary .torrent file into a bdecode_node, use bdecode().
│ │ │ +
The version that takes a buffer pointer and a size will decode it as a
│ │ │ +.torrent file and initialize the torrent_info object for you.
│ │ │ +
The version that takes a filename will simply load the torrent file
│ │ │ +and decode it inside the constructor, for convenience. This might not
│ │ │ +be the most suitable for applications that want to be able to report
│ │ │ +detailed errors on what might go wrong.
│ │ │ +
There is an upper limit on the size of the torrent file that will be
│ │ │ +loaded by the overload taking a filename. If it's important that even
│ │ │ +very large torrent files are loaded, use one of the other overloads.
│ │ │ +
The overloads that takes an error_code const& never throws if an
│ │ │ +error occur, they will simply set the error code to describe what went
│ │ │ +wrong and not fully initialize the torrent_info object. The overloads
│ │ │ +that do not take the extra error_code parameter will always throw if
│ │ │ +an error occurs. These overloads are not available when building
│ │ │ +without exception support.
│ │ │ +
The overload that takes a span also needs an extra parameter of
│ │ │ +type 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.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
~torrent_info()
│ │ │
│ │ │ -virtual void async_read (storage_index_t storage, peer_request const& r
│ │ │ - , std::function<void(disk_buffer_holder, storage_error const&)> handler
│ │ │ - , disk_job_flags_t flags = {}) = 0;
│ │ │ -virtual bool async_write (storage_index_t storage, peer_request const& r
│ │ │ - , char const* buf, std::shared_ptr<disk_observer> o
│ │ │ - , std::function<void(storage_error const&)> handler
│ │ │ - , disk_job_flags_t flags = {}) = 0;
│ │ │ +~torrent_info ();
│ │ │
│ │ │ -
perform a read or write operation from/to the specified storage
│ │ │ -index and the specified request. When the operation completes, call
│ │ │ -handler possibly with a disk_buffer_holder, holding the buffer with
│ │ │ -the result. Flags may be set to affect the read operation. See
│ │ │ -disk_job_flags_t.
│ │ │ -
The disk_observer is a callback to indicate that
│ │ │ -the store buffer/disk write queue is below the watermark to let peers
│ │ │ -start writing buffers to disk again. When async_write() returns
│ │ │ -true, indicating the write queue is full, the peer will stop
│ │ │ -further writes and wait for the passed-in disk_observer to be
│ │ │ -notified before resuming.
│ │ │ -
Note that for async_read, the peer_request (r) is not
│ │ │ -necessarily aligned to blocks (but it is most of the time). However,
│ │ │ -all writes (passed to async_write) are guaranteed to be block
│ │ │ -aligned.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
files() orig_files()
│ │ │
│ │ │ -virtual void async_hash (storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
│ │ │ - , disk_job_flags_t flags
│ │ │ - , std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) = 0;
│ │ │ +file_storage const& files () const;
│ │ │ +file_storage const& orig_files () const;
│ │ │
│ │ │ -
Compute hash(es) for the specified piece. Unless the v1_hash flag is
│ │ │ -set (in flags), the SHA-1 hash of the whole piece does not need
│ │ │ -to be computed.
│ │ │ -
The v2 span is optional and can be empty, which means v2 hashes
│ │ │ -should not be computed. If v2 is non-empty it must be at least large
│ │ │ -enough to hold all v2 blocks in the piece, and this function will
│ │ │ -fill in the span with the SHA-256 block hashes of the piece.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_hash2()
│ │ │ +
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
│ │ │ +having a torrent file. When renaming files in a storage, the storage
│ │ │ +needs to make its own copy of the file_storage in order to make its
│ │ │ +mapping differ from the one in the torrent file.
│ │ │ +
orig_files() returns the original (unmodified) file storage for
│ │ │ +this torrent. This is used by the web server connection, which needs
│ │ │ +to request files with the original names. Filename may be changed using
│ │ │ +torrent_info::rename_file().
│ │ │ +
For more information on the file_storage object, see the separate
│ │ │ +document on how to create torrents.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
rename_file()
│ │ │
│ │ │ -virtual void async_hash2 (storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
│ │ │ - , std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) = 0;
│ │ │ +void rename_file (file_index_t index, std::string const& new_filename);
│ │ │
│ │ │ -
computes the v2 hash (SHA-256) of a single block. The block at
│ │ │ -offset in piece piece.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_move_storage()
│ │ │ +
Renames the file with the specified index to the new name. The new
│ │ │ +filename is reflected by the file_storage returned by files()
│ │ │ +but not by the one returned by orig_files().
│ │ │ +
If you want to rename the base name of the torrent (for a multi file
│ │ │ +torrent), you can copy the file_storage (see files() and
│ │ │ +orig_files() ), change the name, and then use remap_files().
│ │ │ +
The new_filename can both be a relative path, in which case the
│ │ │ +file name is relative to the save_path of the torrent. If the
│ │ │ +new_filename is an absolute path (i.e. is_complete(new_filename)
│ │ │ +== true), then the file is detached from the save_path of the
│ │ │ +torrent. In this case the file is not moved when move_storage() is
│ │ │ +invoked.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
remap_files()
│ │ │
│ │ │ -virtual void async_move_storage (storage_index_t storage, std::string p, move_flags_t flags
│ │ │ - , std::function<void(status_t, std::string const&, storage_error const&)> handler) = 0;
│ │ │ +void remap_files (file_storage const& f);
│ │ │
│ │ │ -
called to request the files for the specified storage/torrent be
│ │ │ -moved to a new location. It is the disk I/O object's responsibility
│ │ │ -to synchronize this with any currently outstanding disk operations to
│ │ │ -the storage. Whether files are replaced at the destination path or
│ │ │ -not is controlled by flags (see move_flags_t).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_release_files()
│ │ │ +
│ │ │ +
Warning
│ │ │ +
Using remap_files() is discouraged as it's incompatible with v2
│ │ │ +torrents. This is because the piece boundaries and piece hashes in
│ │ │ +v2 torrents are intimately tied to the file boundaries. Instead,
│ │ │ +just rename individual files, or implement a custom disk_interface
│ │ │ +to customize how to store files.
│ │ │ +
│ │ │ +
Remaps the file storage to a new file layout. This can be used to, for
│ │ │ +instance, download all data in a torrent to a single file, or to a
│ │ │ +number of fixed size sector aligned files, regardless of the number
│ │ │ +and sizes of the files in the torrent.
│ │ │ +
The new specified file_storage must have the exact same size as
│ │ │ +the current one.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_tracker() trackers() clear_trackers()
│ │ │
│ │ │ -virtual void async_release_files (storage_index_t storage
│ │ │ - , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │ +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 clear_trackers ();
│ │ │ +std::vector<announce_entry> const& trackers () const;
│ │ │
│ │ │ -
This is called on disk I/O objects to request they close all open
│ │ │ -files for the specified storage/torrent. If file handles are not
│ │ │ -pooled/cached, it can be a no-op. For truly asynchronous disk I/O,
│ │ │ -this should provide at least one point in time when all files are
│ │ │ -closed. It is possible that later asynchronous operations will
│ │ │ -re-open some of the files, by the time this completion handler is
│ │ │ -called, that's fine.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_check_files()
│ │ │ +
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]
│ │ │ +
│ │ │ +
similar_torrents() collections()
│ │ │
│ │ │ -virtual void async_check_files (storage_index_t storage
│ │ │ - , add_torrent_params const* resume_data
│ │ │ - , aux::vector<std::string, file_index_t> links
│ │ │ - , std::function<void(status_t, storage_error const&)> handler) = 0;
│ │ │ +std::vector<std::string> collections () const;
│ │ │ +std::vector<sha1_hash> similar_torrents () const;
│ │ │
│ │ │ -
this is called when torrents are added to validate their resume data
│ │ │ -against the files on disk. This function is expected to do a few things:
│ │ │ -
if links is non-empty, it contains a string for each file in the
│ │ │ -torrent. The string being a path to an existing identical file. The
│ │ │ -default behavior is to create hard links of those files into the
│ │ │ -storage of the new torrent (specified by storage). An empty
│ │ │ -string indicates that there is no known identical file. This is part
│ │ │ -of the "mutable torrent" feature, where files can be reused from
│ │ │ -other torrents.
│ │ │ -
The resume_data points the resume data passed in by the client.
│ │ │ -
If the resume_data->flags field has the seed_mode flag set, all
│ │ │ -files/pieces are expected to be on disk already. This should be
│ │ │ -verified. Not just the existence of the file, but also that it has
│ │ │ -the correct size.
│ │ │ -
Any file with a piece set in the resume_data->have_pieces bitmask
│ │ │ -should exist on disk, this should be verified. Pad files and files
│ │ │ -with zero priority may be skipped.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_stop_torrent()
│ │ │ +
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_url_seed() web_seeds() set_web_seeds() add_http_seed()
│ │ │
│ │ │ -virtual void async_stop_torrent (storage_index_t storage
│ │ │ - , std::function<void()> handler = std::function<void()>()) = 0;
│ │ │ +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());
│ │ │ +void set_web_seeds (std::vector<web_seed_entry> seeds);
│ │ │ +std::vector<web_seed_entry> const& web_seeds () const;
│ │ │
│ │ │ -
This is called when a torrent is stopped. It gives the disk I/O
│ │ │ -object an opportunity to flush any data to disk that's currently kept
│ │ │ -cached. This function should at least do the same thing as
│ │ │ -async_release_files().
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_rename_file()
│ │ │ +
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
│ │ │ +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 the URL itself. The string will be sent
│ │ │ +as the HTTP authorization header's value (without specifying "Basic").
│ │ │ +
The extra_headers argument defaults to an empty list, but can be
│ │ │ +used to insert custom HTTP headers in the requests to a specific web
│ │ │ +seed.
│ │ │ +
See http seeding for more information.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
total_size()
│ │ │
│ │ │ -virtual void async_rename_file (storage_index_t storage
│ │ │ - , file_index_t index, std::string name
│ │ │ - , std::function<void(std::string const&, file_index_t, storage_error const&)> handler) = 0;
│ │ │ +std::int64_t total_size () const;
│ │ │
│ │ │ -
This function is called when the name of a file in the specified
│ │ │ -storage has been requested to be renamed. The disk I/O object is
│ │ │ -responsible for renaming the file without racing with other
│ │ │ -potentially outstanding operations against the file (such as read,
│ │ │ -write, move, etc.).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_delete_files()
│ │ │ +
total_size() returns the total number of bytes the torrent-file
│ │ │ +represents. Note that this is the number of pieces times the piece
│ │ │ +size (modulo the last piece possibly being smaller). With pad files,
│ │ │ +the total size will be larger than the sum of all (regular) file
│ │ │ +sizes.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
num_pieces() piece_length()
│ │ │
│ │ │ -virtual void async_delete_files (storage_index_t storage, remove_flags_t options
│ │ │ - , std::function<void(storage_error const&)> handler) = 0;
│ │ │ +int num_pieces () const;
│ │ │ +int piece_length () const;
│ │ │
│ │ │ -
This function is called when some file(s) on disk have been requested
│ │ │ -to be removed by the client. storage indicates which torrent is
│ │ │ -referred to. See session_handle for remove_flags_t flags
│ │ │ -indicating which files are to be removed.
│ │ │ -e.g. session_handle::delete_files - delete all files
│ │ │ -session_handle::delete_partfile - only delete part file.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_set_file_priority()
│ │ │ +
piece_length() and num_pieces() returns the number of byte
│ │ │ +for each piece and the total number of pieces, respectively. The
│ │ │ +difference between piece_size() and piece_length() is that
│ │ │ +piece_size() takes the piece index as argument and gives you the
│ │ │ +exact size of that piece. It will always be the same as
│ │ │ +piece_length() except in the case of the last piece, which may be
│ │ │ +smaller.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
blocks_per_piece()
│ │ │
│ │ │ -virtual void async_set_file_priority (storage_index_t storage
│ │ │ - , aux::vector<download_priority_t, file_index_t> prio
│ │ │ - , std::function<void(storage_error const&
│ │ │ - , aux::vector<download_priority_t, file_index_t>)> handler) = 0;
│ │ │ +int blocks_per_piece () const;
│ │ │
│ │ │ -
This is called to set the priority of some or all files. Changing the
│ │ │ -priority from or to 0 may involve moving data to and from the
│ │ │ -partfile. The disk I/O object is responsible for correctly
│ │ │ -synchronizing this work to not race with any potentially outstanding
│ │ │ -asynchronous operations affecting these files.
│ │ │ -
prio is a vector of the file priority for all files. If it's
│ │ │ -shorter than the total number of files in the torrent, they are
│ │ │ -assumed to be set to the default priority.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
async_clear_piece()
│ │ │ +
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()
│ │ │
│ │ │ -virtual void async_clear_piece (storage_index_t storage, piece_index_t index
│ │ │ - , std::function<void(piece_index_t)> handler) = 0;
│ │ │ +index_range<piece_index_t> piece_range () const;
│ │ │ +piece_index_t last_piece () const;
│ │ │ +piece_index_t end_piece () const;
│ │ │
│ │ │ -
This is called when a piece fails the hash check, to ensure there are
│ │ │ -no outstanding disk operations to the piece before blocks are
│ │ │ -re-requested from peers to overwrite the existing blocks. The disk I/O
│ │ │ -object does not need to perform any action other than synchronize
│ │ │ -with all outstanding disk operations to the specified piece before
│ │ │ -posting the result back.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
update_stats_counters()
│ │ │ +
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()
│ │ │
│ │ │ -virtual void update_stats_counters (counters& c) const = 0;
│ │ │ +info_hash_t const& info_hashes () const;
│ │ │ +sha1_hash info_hash () const noexcept;
│ │ │
│ │ │ -
update_stats_counters() is called to give the disk storage an
│ │ │ -opportunity to update gauges in the c stats counters, that aren't
│ │ │ -updated continuously as operations are performed. This is called
│ │ │ -before a snapshot of the counters are passed to the client.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
get_status()
│ │ │ +
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()
│ │ │
│ │ │ -virtual std::vector<open_file_state> get_status (storage_index_t) const = 0;
│ │ │ +bool v1 () const;
│ │ │ +bool v2 () const;
│ │ │
│ │ │ -
Return a list of all the files that are currently open for the
│ │ │ -specified storage/torrent. This is is just used for the client to
│ │ │ -query the currently open files, and which modes those files are open
│ │ │ -in.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
abort()
│ │ │ +
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()
│ │ │
│ │ │ -virtual void abort (bool wait) = 0;
│ │ │ +int num_files () const;
│ │ │
│ │ │ -
this is called when the session is starting to shut down. The disk
│ │ │ -I/O object is expected to flush any outstanding write jobs, cancel
│ │ │ -hash jobs and initiate tearing down of any internal threads. If
│ │ │ -wait is true, this should be asynchronous. i.e. this call should
│ │ │ -not return until all threads have stopped and all jobs have either
│ │ │ -been aborted or completed and the disk I/O object is ready to be
│ │ │ -destructed.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
submit_jobs()
│ │ │ +
If you need index-access to files you can use the num_files() along
│ │ │ +with the file_path(), file_size()-family of functions to access
│ │ │ +files using indices.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
map_block()
│ │ │
│ │ │ -virtual void submit_jobs () = 0;
│ │ │ +std::vector<file_slice> map_block (piece_index_t const piece
│ │ │ + , std::int64_t offset, int size) const;
│ │ │
│ │ │ -
This will be called after a batch of disk jobs has been issues (via
│ │ │ -the async_* ). It gives the disk I/O object an opportunity to
│ │ │ -notify any potential condition variables to wake up the disk
│ │ │ -thread(s). The async_* calls can of course also notify condition
│ │ │ -variables, but doing it in this call allows for batching jobs, by
│ │ │ -issuing the notification once for a collection of jobs.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
settings_updated()
│ │ │ +
This function will map a piece index, a byte offset within that piece
│ │ │ +and a size (in bytes) into the corresponding files with offsets where
│ │ │ +that data for that piece is supposed to be stored. See file_slice.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
map_file()
│ │ │
│ │ │ -virtual void settings_updated () = 0;
│ │ │ +peer_request map_file (file_index_t const file, std::int64_t offset, int size) const;
│ │ │
│ │ │ -
This is called to notify the disk I/O object that the settings have
│ │ │ -been updated. In the disk io constructor, a settings_interface
│ │ │ -reference is passed in. Whenever these settings are updated, this
│ │ │ -function is called to allow the disk I/O object to react to any
│ │ │ -changed settings relevant to its operations.
│ │ │ -
[report issue]
│ │ │ -- force_copy
│ │ │ -- force making a copy of the cached block, rather than getting a
│ │ │ -reference to a block already in the cache. This is used the block is
│ │ │ -expected to be overwritten very soon, by async_write()`, and we need
│ │ │ -access to the previous content.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- sequential_access
│ │ │ -- hint that there may be more disk operations with sequential access to
│ │ │ -the file
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- volatile_read
│ │ │ -- don't keep the read block in cache. This is a hint that this block is
│ │ │ -unlikely to be read again anytime soon, and caching it would be
│ │ │ -wasteful.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- v1_hash
│ │ │ -- compute a v1 piece hash. This is only used by the async_hash() call.
│ │ │ -If this flag is not set in the async_hash() call, the SHA-1 piece
│ │ │ -hash does not need to be computed.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- flush_piece
│ │ │ -- this flag instructs a hash job that we just completed this piece, and
│ │ │ -it should be flushed to disk
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
storage_holder
│ │ │ -
Declared in "libtorrent/disk_interface.hpp"
│ │ │ -
a unique, owning, reference to the storage of a torrent in a disk io
│ │ │ -subsystem (class that implements disk_interface). This is held by the
│ │ │ -internal libtorrent torrent object to tie the storage object allocated
│ │ │ -for a torrent to the lifetime of the internal torrent object. When a
│ │ │ -torrent is removed from the session, this holder is destructed and will
│ │ │ -inform the disk object.
│ │ │ +
This function will map a range in a specific file into a range in the
│ │ │ +torrent. The file_offset parameter is the offset in the file,
│ │ │ +given in bytes, where 0 is the start of the file. See peer_request.
│ │ │ +
The input range is assumed to be valid within the torrent.
│ │ │ +file_offset + size is not allowed to be greater than the file
│ │ │ +size. file_index must refer to a valid file, i.e. it cannot be >=
│ │ │ +num_files().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
ssl_cert()
│ │ │
│ │ │ -struct storage_holder
│ │ │ -{
│ │ │ - ~storage_holder ();
│ │ │ - storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ - storage_holder () = default;
│ │ │ - explicit operator bool () const;
│ │ │ - operator storage_index_t () const;
│ │ │ - void reset ();
│ │ │ - storage_holder (storage_holder const&) = delete;
│ │ │ - storage_holder& operator= (storage_holder const&) = delete;
│ │ │ - storage_holder (storage_holder&& rhs) noexcept;
│ │ │ - storage_holder& operator= (storage_holder&& rhs) noexcept;
│ │ │ -};
│ │ │ +string_view ssl_cert () const;
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
disk_observer
│ │ │ -
Declared in "libtorrent/disk_observer.hpp"
│ │ │ +
Returns the SSL root certificate for the torrent, if it is an SSL
│ │ │ +torrent. Otherwise returns an empty string. The certificate is
│ │ │ +the public certificate in x509 format.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
is_valid()
│ │ │
│ │ │ -struct disk_observer
│ │ │ -{
│ │ │ - virtual void on_disk () = 0;
│ │ │ -};
│ │ │ +bool is_valid () const;
│ │ │
│ │ │ -
[report issue]
│ │ │ -
on_disk()
│ │ │ +
returns true if this torrent_info object has a torrent loaded.
│ │ │ +This is primarily used to determine if a magnet link has had its
│ │ │ +metadata resolved yet or not.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
priv()
│ │ │
│ │ │ -virtual void on_disk () = 0;
│ │ │ +bool priv () const;
│ │ │
│ │ │ -
called when the disk cache size has dropped
│ │ │ -below the low watermark again and we can
│ │ │ -resume downloading from peers
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
buffer_allocator_interface
│ │ │ -
Declared in "libtorrent/disk_buffer_holder.hpp"
│ │ │ -
the interface for freeing disk buffers, used by the disk_buffer_holder.
│ │ │ -when implementing disk_interface, this must also be implemented in order
│ │ │ -to return disk buffers back to libtorrent
│ │ │ +
returns true if this torrent is private. i.e., the client should not
│ │ │ +advertise itself on the trackerless network (the Kademlia DHT) for this torrent.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
is_i2p()
│ │ │
│ │ │ -struct buffer_allocator_interface
│ │ │ -{
│ │ │ - virtual void free_disk_buffer (char* b) = 0;
│ │ │ -};
│ │ │ +bool is_i2p () const;
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
disk_buffer_holder
│ │ │ -
Declared in "libtorrent/disk_buffer_holder.hpp"
│ │ │ -
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.
│ │ │ +
returns true if this is an i2p torrent. This is determined by whether
│ │ │ +or not it has a tracker whose URL domain name ends with ".i2p". i2p
│ │ │ +torrents disable the DHT and local peer discovery as well as talking
│ │ │ +to peers over anything other than the i2p network.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
piece_size()
│ │ │
│ │ │ -struct disk_buffer_holder
│ │ │ -{
│ │ │ - disk_buffer_holder& operator= (disk_buffer_holder&&) & noexcept;
│ │ │ - disk_buffer_holder (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;
│ │ │ - bool is_mutable () const noexcept;
│ │ │ - explicit operator bool () const noexcept;
│ │ │ - std::ptrdiff_t size () const;
│ │ │ -};
│ │ │ +int piece_size (piece_index_t index) const;
│ │ │
│ │ │ -
[report issue]
│ │ │ -
disk_buffer_holder()
│ │ │ +
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()
│ │ │
│ │ │ -disk_buffer_holder (buffer_allocator_interface& alloc
│ │ │ - , char* buf, int sz) noexcept;
│ │ │ +char const* hash_for_piece_ptr (piece_index_t const index) const;
│ │ │ +sha1_hash hash_for_piece (piece_index_t index) const;
│ │ │
│ │ │ -
construct a buffer holder that will free the held buffer
│ │ │ -using a disk buffer pool directly (there's only one
│ │ │ -disk_buffer_pool per session)
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
disk_buffer_holder()
│ │ │ +
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]
│ │ │ +
│ │ │ +
name()
│ │ │
│ │ │ -disk_buffer_holder () noexcept = default;
│ │ │ +const std::string& name () const;
│ │ │
│ │ │ -
default construct a holder that does not own any buffer
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
~disk_buffer_holder()
│ │ │ +
name() returns the name of the torrent.
│ │ │ +name contains UTF-8 encoded string.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
creation_date()
│ │ │
│ │ │ -~disk_buffer_holder ();
│ │ │ +std::time_t creation_date () const;
│ │ │
│ │ │ -
frees disk buffer held by this object
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
creator()
│ │ │
│ │ │ -char* data () const noexcept;
│ │ │ +const std::string& creator () const;
│ │ │
│ │ │ -
return a pointer to the held buffer, if any. Otherwise returns nullptr.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
reset()
│ │ │ +
creator() returns the creator string in the torrent. If there is
│ │ │ +no creator string it will return an empty string.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ -
│ │ │ -
swap()
│ │ │ +
comment() returns the comment associated with the torrent. If
│ │ │ +there's no comment, it will return an empty string.
│ │ │ +comment contains UTF-8 encoded string.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
nodes()
│ │ │
│ │ │ -void swap (disk_buffer_holder& h) noexcept;
│ │ │ +std::vector<std::pair<std::string, int>> const& nodes () const;
│ │ │
│ │ │ -
swap pointers of two disk buffer holders.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
is_mutable()
│ │ │ +
If this torrent contains any DHT nodes, they are put in this vector in
│ │ │ +their original form (host name and port number).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_node()
│ │ │
│ │ │ -bool is_mutable () const noexcept;
│ │ │ +void add_node (std::pair<std::string, int> const& node);
│ │ │
│ │ │ -
if this returns true, the buffer may not be modified in place
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
bool()
│ │ │ +
This is used when creating torrent. Use this to add a known DHT node.
│ │ │ +It may be used, by the client, to bootstrap into the DHT network.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
parse_info_section()
│ │ │
│ │ │ -explicit operator bool () const noexcept;
│ │ │ +bool parse_info_section (bdecode_node const& info, error_code& ec, int max_pieces);
│ │ │
│ │ │ -
implicitly convertible to true if the object is currently holding a
│ │ │ -buffer
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
settings_interface
│ │ │ -
Declared in "libtorrent/settings_pack.hpp"
│ │ │ -
the common interface to settings_pack and the internal representation of
│ │ │ -settings.
│ │ │ +
populates the torrent_info by providing just the info-dict buffer.
│ │ │ +This is used when loading a torrent from a magnet link for instance,
│ │ │ +where we only have the info-dict. The bdecode_node e points to a
│ │ │ +parsed info-dictionary. ec returns an error code if something
│ │ │ +fails (typically if the info dictionary is malformed).
│ │ │ +The max_pieces parameter allows limiting the amount of memory
│ │ │ +dedicated to loading the torrent, and fails for torrents that exceed
│ │ │ +the limit. To load large torrents, this limit may also need to be
│ │ │ +raised in settings_pack::max_piece_count and in calls to
│ │ │ +read_resume_data().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
info()
│ │ │
│ │ │ -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 bool has_val (int name) const = 0;
│ │ │ - virtual bool get_bool (int name) const = 0;
│ │ │ - virtual std::string const& get_str (int name) const = 0;
│ │ │ - virtual int get_int (int name) const = 0;
│ │ │ -};
│ │ │ +bdecode_node info (char const* key) const;
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
file_open_mode_t
│ │ │ -
Declared in "libtorrent/disk_interface.hpp"
│ │ │ -
│ │ │ -- read_only
│ │ │ -- open the file for reading only
│ │ │ -
│ │ │ -
│ │ │ -- write_only
│ │ │ -- open the file for writing only
│ │ │ -
│ │ │ -
│ │ │ -- read_write
│ │ │ -- open the file for reading and writing
│ │ │ -
│ │ │ -
│ │ │ -- rw_mask
│ │ │ -- the mask for the bits determining read or write mode
│ │ │ -
│ │ │ -
│ │ │ -- sparse
│ │ │ -- open the file in sparse mode (if supported by the
│ │ │ -filesystem).
│ │ │ -
│ │ │ -
│ │ │ -- no_atime
│ │ │ -- don't update the access timestamps on the file (if
│ │ │ -supported by the operating system and filesystem).
│ │ │ -this generally improves disk performance.
│ │ │ -
│ │ │ -
│ │ │ -- random_access
│ │ │ -- When this is not set, the kernel is hinted that access to this file will
│ │ │ -be made sequentially.
│ │ │ -
│ │ │ -
│ │ │ -- mmapped
│ │ │ -- the file is memory mapped
│ │ │ -
│ │ │ +
This function looks up keys from the info-dictionary of the loaded
│ │ │ +torrent file. It can be used to access extension values put in the
│ │ │ +.torrent file. If the specified key cannot be found, it returns nullptr.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
info_section()
│ │ │ +
│ │ │ +span<char const> info_section () const;
│ │ │ +
│ │ │ +
returns a the raw info section of the torrent file.
│ │ │ +The underlying buffer is still owned by the torrent_info object
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
piece_layer()
│ │ │ +
│ │ │ +span<char const> piece_layer (file_index_t) const;
│ │ │ +
│ │ │ +
return the bytes of the piece layer hashes for the specified file. If
│ │ │ +the file doesn't have a piece layer, an empty span is returned.
│ │ │ +The span size is divisible by 32, the size of a SHA-256 hash.
│ │ │ +If the size of the file is smaller than or equal to the piece size,
│ │ │ +the files "root hash" is the hash of the file and is not saved
│ │ │ +separately in the "piece layers" field, but this function still
│ │ │ +returns the root hash of the file in that case.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
free_piece_layers()
│ │ │ +
│ │ │ +void free_piece_layers ();
│ │ │ +
│ │ │ +
clears the piece layers from the torrent_info. This is done by the
│ │ │ +session when a torrent is added, to avoid storing it twice. The piece
│ │ │ +layer (or other hashes part of the merkle tree) are stored in the
│ │ │ +internal torrent object.
│ │ │
The pop_alerts() function on session is the main interface for retrieving
│ │ │ alerts (warnings, messages and errors from libtorrent). If no alerts have
│ │ │ been posted by libtorrent pop_alerts() will return an empty list.
│ │ │
By default, only errors are reported. settings_pack::alert_mask can be
│ │ │ used to specify which kinds of events should be reported. The alert mask is
│ │ │ a combination of the alert_category_t flags in the alert class.
│ │ │
Every alert belongs to one or more category. There is a cost associated with
│ │ │ @@ -9098,14 +8153,15 @@
│ │ │ alerts that are generated for a specific torrent are derived from
│ │ │ torrent_alert, and tracker events derive from tracker_alert.
│ │ │
Alerts returned by pop_alerts() are only valid until the next call to
│ │ │ pop_alerts(). You may not copy an alert object to access it after the next
│ │ │ call to pop_alerts(). Internal members of alerts also become invalid once
│ │ │ pop_alerts() is called again.
│ │ │
[report issue]
│ │ │ +
│ │ │
│ │ │
alert
│ │ │
Declared in "libtorrent/alert.hpp"
│ │ │
The alert class is the base class that specific messages are derived from.
│ │ │ alert types are not copyable, and cannot be constructed by the client. The
│ │ │ pointers returned by libtorrent are short lived (the details are described
│ │ │ under session_handle::pop_alerts())
│ │ │ @@ -9146,15 +8202,15 @@
│ │ │
[report issue]
│ │ │
timestamp()
│ │ │
│ │ │ time_point timestamp () const;
│ │ │
│ │ │
a timestamp is automatically created in the constructor
│ │ │
[report issue]
│ │ │ -
│ │ │ +
│ │ │
type()
│ │ │
│ │ │ virtual int type () const noexcept = 0;
│ │ │
│ │ │
returns an integer that is unique to this alert type. It can be
│ │ │ compared against a specific alert by querying a static constant called alert_type
│ │ │ in the alert. It can be used to determine the run-time type of an alert* in
│ │ │ @@ -9396,27 +8452,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* new_name () const;
│ │ │ char const* old_name () const;
│ │ │ + char const* new_name () const;
│ │ │
│ │ │ static constexpr alert_category_t static_category = alert_category::storage;
│ │ │ file_index_t const index;
│ │ │ };
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
old_name() new_name()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
new_name() old_name()
│ │ │
│ │ │ -char const* new_name () const;
│ │ │ char const* old_name () const;
│ │ │ +char const* new_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]
│ │ │ @@ -10139,26 +9195,26 @@
│ │ │
torrent_handle::move_storage. This is useful to synchronize with the
│ │ │ actual disk. The
storage_path() member return the new path of the
│ │ │ storage.
│ │ │
│ │ │ struct storage_moved_alert final : torrent_alert
│ │ │ {
│ │ │ std::string message () const override;
│ │ │ - char const* storage_path () const;
│ │ │ char const* old_path () const;
│ │ │ + char const* storage_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;
│ │ │ +char const* storage_path () const;
│ │ │
│ │ │
the path the torrent was moved to and from, respectively.
│ │ │
[report issue]
│ │ │
│ │ │
│ │ │
storage_moved_failed_alert
│ │ │
Declared in "libtorrent/alert_types.hpp"
│ │ │ @@ -11070,15 +10126,15 @@
│ │ │ {
│ │ │ std::string
message () const override;
│ │ │ span<std::int64_t const>
counters () const;
│ │ │
│ │ │ static constexpr alert_category_t
static_category = {};
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ +
[report issue]
│ │ │
counters()
│ │ │
│ │ │ span<std::int64_t const> counters () const;
│ │ │
│ │ │
An array are a mix of counters and gauges, which meanings can be
│ │ │ queries via the session_stats_metrics() function on the session. The
│ │ │ mapping from a specific metric to an index into this array is constant
│ │ │ @@ -11796,27 +10852,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()
│ │ │
│ │ │ -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]
│ │ │ @@ -11931,16 +10987,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
│ │ │ {
│ │ │ - std::string message () const override;
│ │ │ static_assert (num_alert_types <= abi_alert_count, "need to increase bitset. This is an ABI break");
│ │ │ + std::string message () const override;
│ │ │
│ │ │ static constexpr alert_category_t static_category = alert_category::error;
│ │ │ std::bitset<abi_alert_count> dropped_alerts;
│ │ │ };
│ │ │
│ │ │
[report issue]
│ │ │ - dropped_alerts
│ │ │ @@ -12146,14 +11202,23 @@
│ │ │ std::vector<announce_entry> trackers;
│ │ │ };
│ │ │
│ │ │ [report issue]
│ │ │ - trackers
│ │ │ - list of trackers and their status for the torrent
│ │ │
│ │ │ +[report issue]
│ │ │ +
│ │ │
│ │ │
alert_cast()
│ │ │
Declared in "libtorrent/alert.hpp"
│ │ │
│ │ │ template <typename T> T* alert_cast (alert* a);
│ │ │ template <typename T> T const* alert_cast (alert const* a);
│ │ │ @@ -12161,23 +11226,14 @@
│ │ │ When you get an alert, you can use alert_cast<> to attempt to cast the
│ │ │ pointer to a specific alert type, in order to query it for more
│ │ │ information.
│ │ │
│ │ │
Note
│ │ │
alert_cast<> can only cast to an exact alert type, not a base class
│ │ │
│ │ │ -
│ │ │
│ │ │
enum operation_t
│ │ │
Declared in "libtorrent/operations.hpp"
│ │ │
│ │ │
│ │ │
│ │ │ @@ -12242,2385 +11298,2416 @@
│ │ │ | 11 |
│ │ │ a socket read operation failed |
│ │ │
│ │ │ | sock_open |
│ │ │ 12 |
│ │ │ a call to open(), to create a socket socket failed |
│ │ │
│ │ │ -| sock_bind |
│ │ │ -13 |
│ │ │ -a call to bind() on a socket failed |
│ │ │ +
| sock_bind |
│ │ │ +13 |
│ │ │ +a call to bind() on a socket failed |
│ │ │ +
│ │ │ +| available |
│ │ │ +14 |
│ │ │ +an attempt to query the number of bytes available to read from a socket
│ │ │ +failed |
│ │ │ +
│ │ │ +| encryption |
│ │ │ +15 |
│ │ │ +a call related to bittorrent protocol encryption failed |
│ │ │ +
│ │ │ +| connect |
│ │ │ +16 |
│ │ │ +an attempt to connect a socket failed |
│ │ │ +
│ │ │ +| ssl_handshake |
│ │ │ +17 |
│ │ │ +establishing an SSL connection failed |
│ │ │ +
│ │ │ +| get_interface |
│ │ │ +18 |
│ │ │ +a connection failed to satisfy the bind interface setting |
│ │ │ +
│ │ │ +| sock_listen |
│ │ │ +19 |
│ │ │ +a call to listen() on a socket |
│ │ │ +
│ │ │ +| sock_bind_to_device |
│ │ │ +20 |
│ │ │ +a call to the ioctl to bind a socket to a specific network device or
│ │ │ +adapter |
│ │ │ +
│ │ │ +| sock_accept |
│ │ │ +21 |
│ │ │ +a call to accept() on a socket |
│ │ │ +
│ │ │ +| parse_address |
│ │ │ +22 |
│ │ │ +convert a string into a valid network address |
│ │ │ +
│ │ │ +| enum_if |
│ │ │ +23 |
│ │ │ +enumeration network devices or adapters |
│ │ │ +
│ │ │ +| file_stat |
│ │ │ +24 |
│ │ │ +invoking stat() on a file |
│ │ │ +
│ │ │ +| file_copy |
│ │ │ +25 |
│ │ │ +copying a file |
│ │ │ +
│ │ │ +| file_fallocate |
│ │ │ +26 |
│ │ │ +allocating storage for a file |
│ │ │ +
│ │ │ +| file_hard_link |
│ │ │ +27 |
│ │ │ +creating a hard link |
│ │ │ +
│ │ │ +| file_remove |
│ │ │ +28 |
│ │ │ +removing a file |
│ │ │ +
│ │ │ +| file_rename |
│ │ │ +29 |
│ │ │ +renaming a file |
│ │ │ +
│ │ │ +| file_open |
│ │ │ +30 |
│ │ │ +opening a file |
│ │ │ +
│ │ │ +| mkdir |
│ │ │ +31 |
│ │ │ +creating a directory |
│ │ │ +
│ │ │ +| check_resume |
│ │ │ +32 |
│ │ │ +check fast resume data against files on disk |
│ │ │ +
│ │ │ +| exception |
│ │ │ +33 |
│ │ │ +an unknown exception |
│ │ │ +
│ │ │ +| alloc_cache_piece |
│ │ │ +34 |
│ │ │ +allocate space for a piece in the cache |
│ │ │ +
│ │ │ +| partfile_move |
│ │ │ +35 |
│ │ │ +move a part-file |
│ │ │ +
│ │ │ +| partfile_read |
│ │ │ +36 |
│ │ │ +read from a part file |
│ │ │ +
│ │ │ +| partfile_write |
│ │ │ +37 |
│ │ │ +write to a part-file |
│ │ │ +
│ │ │ +| hostname_lookup |
│ │ │ +38 |
│ │ │ +a hostname lookup |
│ │ │ +
│ │ │ +| symlink |
│ │ │ +39 |
│ │ │ +create or read a symlink |
│ │ │ +
│ │ │ +| handshake |
│ │ │ +40 |
│ │ │ +handshake with a peer or server |
│ │ │ +
│ │ │ +| sock_option |
│ │ │ +41 |
│ │ │ +set socket option |
│ │ │ +
│ │ │ +| enum_route |
│ │ │ +42 |
│ │ │ +enumeration of network routes |
│ │ │ +
│ │ │ +| file_seek |
│ │ │ +43 |
│ │ │ +moving read/write position in a file, operation_t::hostname_lookup |
│ │ │ +
│ │ │ +| timer |
│ │ │ +44 |
│ │ │ +an async wait operation on a timer |
│ │ │ +
│ │ │ +| file_mmap |
│ │ │ +45 |
│ │ │ +call to mmap() (or windows counterpart) |
│ │ │ +
│ │ │ +| file_truncate |
│ │ │ +46 |
│ │ │ +call to ftruncate() (or SetEndOfFile() on windows) |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
alert_category_t
│ │ │ +
Declared in "libtorrent/alert.hpp"
│ │ │ +
│ │ │ +- error
│ │ │ +Enables alerts that report an error. This includes:
│ │ │ +
│ │ │ +- tracker errors
│ │ │ +- tracker warnings
│ │ │ +- file errors
│ │ │ +- resume data failures
│ │ │ +- web seed errors
│ │ │ +- .torrent files errors
│ │ │ +- listen socket errors
│ │ │ +- port mapping errors
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +- peer
│ │ │ +- Enables alerts when peers send invalid requests, get banned or
│ │ │ +snubbed.
│ │ │ +
│ │ │ +
│ │ │ +- port_mapping
│ │ │ +- Enables alerts for port mapping events. For NAT-PMP and UPnP.
│ │ │ +
│ │ │ +
│ │ │ +- storage
│ │ │ +- Enables alerts for events related to the storage. File errors and
│ │ │ +synchronization events for moving the storage, renaming files etc.
│ │ │ +
│ │ │ +
│ │ │ +- tracker
│ │ │ +- Enables all tracker events. Includes announcing to trackers,
│ │ │ +receiving responses, warnings and errors.
│ │ │ +
│ │ │ +
│ │ │ +- connect
│ │ │ +- Low level alerts for when peers are connected and disconnected.
│ │ │ +
│ │ │ +
│ │ │ +- status
│ │ │ +- Enables alerts for when a torrent or the session changes state.
│ │ │ +
│ │ │ +
│ │ │ +- ip_block
│ │ │ +- Alerts when a peer is blocked by the ip blocker or port blocker.
│ │ │ +
│ │ │ +
│ │ │ +- performance_warning
│ │ │ +- Alerts when some limit is reached that might limit the download
│ │ │ +or upload rate.
│ │ │ +
│ │ │ +
│ │ │ +- dht
│ │ │ +- Alerts on events in the DHT node. For incoming searches or
│ │ │ +bootstrapping being done etc.
│ │ │ +
│ │ │ +
│ │ │ +- stats
│ │ │ +- If you enable these alerts, you will receive a stats_alert
│ │ │ +approximately once every second, for every active torrent.
│ │ │ +These alerts contain all statistics counters for the interval since
│ │ │ +the lasts stats alert.
│ │ │ +
│ │ │ +
│ │ │ +- session_log
│ │ │ +- Enables debug logging alerts. These are available unless libtorrent
│ │ │ +was built with logging disabled (TORRENT_DISABLE_LOGGING). The
│ │ │ +alerts being posted are log_alert and are session wide.
│ │ │ +
│ │ │ +
│ │ │ +- torrent_log
│ │ │ +- Enables debug logging alerts for torrents. These are available
│ │ │ +unless libtorrent was built with logging disabled
│ │ │ +(TORRENT_DISABLE_LOGGING). The alerts being posted are
│ │ │ +torrent_log_alert and are torrent wide debug events.
│ │ │ +
│ │ │ +
│ │ │ +- peer_log
│ │ │ +- Enables debug logging alerts for peers. These are available unless
│ │ │ +libtorrent was built with logging disabled
│ │ │ +(TORRENT_DISABLE_LOGGING). The alerts being posted are
│ │ │ +peer_log_alert and low-level peer events and messages.
│ │ │ +
│ │ │ +
│ │ │ +- incoming_request
│ │ │ +- enables the incoming_request_alert.
│ │ │ +
│ │ │ +
│ │ │ +- dht_log
│ │ │ +- enables dht_log_alert, debug logging for the DHT
│ │ │ +
│ │ │ +
│ │ │ +- dht_operation
│ │ │ +- enable events from pure dht operations not related to torrents
│ │ │ +
│ │ │ +
│ │ │ +- port_mapping_log
│ │ │ +- enables port mapping log events. This log is useful
│ │ │ +for debugging the UPnP or NAT-PMP implementation
│ │ │ +
│ │ │ +
│ │ │ +- picker_log
│ │ │ +- enables verbose logging from the piece picker.
│ │ │ +
│ │ │ +
│ │ │ +- file_progress
│ │ │ +- alerts when files complete downloading
│ │ │ +
│ │ │ +
│ │ │ +- piece_progress
│ │ │ +- alerts when pieces complete downloading or fail hash check
│ │ │ +
│ │ │ +
│ │ │ +- upload
│ │ │ +- alerts when we upload blocks to other peers
│ │ │ +
│ │ │ +
│ │ │ +- block_progress
│ │ │ +- alerts on individual blocks being requested, downloading, finished,
│ │ │ +rejected, time-out and cancelled. This is likely to post alerts at a
│ │ │ +high rate.
│ │ │ +
│ │ │ +
│ │ │ +- all
│ │ │ +The full bitmask, representing all available categories.
│ │ │ +since the enum is signed, make sure this isn't
│ │ │ +interpreted as -1. For instance, boost.python
│ │ │ +does that and fails when assigning it to an
│ │ │ +unsigned parameter.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
int
│ │ │ +
Declared in "libtorrent/alert_types.hpp"
│ │ │ +
│ │ │ +- user_alert_id
│ │ │ +- user defined alerts should use IDs greater than this
│ │ │ +
│ │ │ +
│ │ │ +- num_alert_types
│ │ │ +- this constant represents "max_alert_index" + 1
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
storage_error
│ │ │ +
Declared in "libtorrent/error_code.hpp"
│ │ │ +
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;
│ │ │ +
│ │ │ + error_code ec;
│ │ │ + operation_t operation;
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
bool()
│ │ │ +
│ │ │ +explicit operator bool () const;
│ │ │ +
│ │ │ +
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;
│ │ │ +
│ │ │ +
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
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- operation
│ │ │ +- A code from operation_t enum, indicating what
│ │ │ +kind of operation failed.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
gzip_category()
│ │ │ +
Declared in "libtorrent/gzip.hpp"
│ │ │ +
│ │ │ +boost::system::error_category& gzip_category ();
│ │ │ +
│ │ │ +
get the error_category for zip errors
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
socks_category()
│ │ │ +
Declared in "libtorrent/socks5_stream.hpp"
│ │ │ +
│ │ │ +boost::system::error_category& socks_category ();
│ │ │ +
│ │ │ +
returns the error_category for SOCKS5 errors
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
i2p_category()
│ │ │ +
Declared in "libtorrent/i2p_stream.hpp"
│ │ │ +
│ │ │ +boost::system::error_category& i2p_category ();
│ │ │ +
│ │ │ +
returns the error category for I2P errors
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
libtorrent_category()
│ │ │ +
Declared in "libtorrent/error_code.hpp"
│ │ │ +
│ │ │ +boost::system::error_category& libtorrent_category ();
│ │ │ +
│ │ │ +
return the instance of the libtorrent_error_category which
│ │ │ +maps libtorrent error codes to human readable error messages.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
http_category()
│ │ │ +
Declared in "libtorrent/error_code.hpp"
│ │ │ +
│ │ │ +boost::system::error_category& http_category ();
│ │ │ +
│ │ │ +
returns the error_category for HTTP errors
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
upnp_category()
│ │ │ +
Declared in "libtorrent/upnp.hpp"
│ │ │ +
│ │ │ +boost::system::error_category& upnp_category ();
│ │ │ +
│ │ │ +
the boost.system error category for UPnP errors
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
enum error_code_enum
│ │ │ +
Declared in "libtorrent/gzip.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| no_error |
│ │ │ +0 |
│ │ │ +Not an error |
│ │ │ +
│ │ │ +| invalid_gzip_header |
│ │ │ +1 |
│ │ │ +the supplied gzip buffer has invalid header |
│ │ │ +
│ │ │ +| inflated_data_too_large |
│ │ │ +2 |
│ │ │ +the gzip buffer would inflate to more bytes than the specified
│ │ │ +maximum size, and was rejected. |
│ │ │ +
│ │ │ +| data_did_not_terminate |
│ │ │ +3 |
│ │ │ +available inflate data did not terminate |
│ │ │ +
│ │ │ +| space_exhausted |
│ │ │ +4 |
│ │ │ +output space exhausted before completing inflate |
│ │ │ +
│ │ │ +| invalid_block_type |
│ │ │ +5 |
│ │ │ +invalid block type (type == 3) |
│ │ │ +
│ │ │ +| invalid_stored_block_length |
│ │ │ +6 |
│ │ │ +stored block length did not match one's complement |
│ │ │ +
│ │ │ +| too_many_length_or_distance_codes |
│ │ │ +7 |
│ │ │ +dynamic block code description: too many length or distance codes |
│ │ │ +
│ │ │ +| code_lengths_codes_incomplete |
│ │ │ +8 |
│ │ │ +dynamic block code description: code lengths codes incomplete |
│ │ │ +
│ │ │ +| repeat_lengths_with_no_first_length |
│ │ │ +9 |
│ │ │ +dynamic block code description: repeat lengths with no first length |
│ │ │ +
│ │ │ +| repeat_more_than_specified_lengths |
│ │ │ +10 |
│ │ │ +dynamic block code description: repeat more than specified lengths |
│ │ │ +
│ │ │ +| invalid_literal_length_code_lengths |
│ │ │ +11 |
│ │ │ +dynamic block code description: invalid literal/length code lengths |
│ │ │ +
│ │ │ +| invalid_distance_code_lengths |
│ │ │ +12 |
│ │ │ +dynamic block code description: invalid distance code lengths |
│ │ │ +
│ │ │ +| invalid_literal_code_in_block |
│ │ │ +13 |
│ │ │ +invalid literal/length or distance code in fixed or dynamic block |
│ │ │ +
│ │ │ +| distance_too_far_back_in_block |
│ │ │ +14 |
│ │ │ +distance is too far back in fixed or dynamic block |
│ │ │ +
│ │ │ +| unknown_gzip_error |
│ │ │ +15 |
│ │ │ +an unknown error occurred during gzip inflation |
│ │ │ +
│ │ │ +| error_code_max |
│ │ │ +16 |
│ │ │ +the number of error codes |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum pcp_errors
│ │ │ +
Declared in "libtorrent/natpmp.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| pcp_success |
│ │ │ +0 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_unsupp_version |
│ │ │ +1 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_not_authorized |
│ │ │ +2 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_malformed_request |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_unsupp_opcode |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_unsupp_option |
│ │ │ +5 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_malformed_option |
│ │ │ +6 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_network_failure |
│ │ │ +7 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_no_resources |
│ │ │ +8 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_unsupp_protocol |
│ │ │ +9 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_user_ex_quota |
│ │ │ +10 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_cannot_provide_external |
│ │ │ +11 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_address_mismatch |
│ │ │ +12 |
│ │ │ + |
│ │ │ +
│ │ │ +| pcp_excessive_remote_peers |
│ │ │ +13 |
│ │ │ + |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum socks_error_code
│ │ │ +
Declared in "libtorrent/socks5_stream.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| no_error |
│ │ │ +0 |
│ │ │ + |
│ │ │ +
│ │ │ +| unsupported_version |
│ │ │ +1 |
│ │ │ + |
│ │ │ +
│ │ │ +| unsupported_authentication_method |
│ │ │ +2 |
│ │ │ + |
│ │ │ +
│ │ │ +| unsupported_authentication_version |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| authentication_error |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │ +| username_required |
│ │ │ +5 |
│ │ │ + |
│ │ │ +
│ │ │ +| general_failure |
│ │ │ +6 |
│ │ │ + |
│ │ │ +
│ │ │ +| command_not_supported |
│ │ │ +7 |
│ │ │ + |
│ │ │ +
│ │ │ +| no_identd |
│ │ │ +8 |
│ │ │ + |
│ │ │ +
│ │ │ +| identd_error |
│ │ │ +9 |
│ │ │ + |
│ │ │ +
│ │ │ +| num_errors |
│ │ │ +10 |
│ │ │ + |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum i2p_error_code
│ │ │ +
Declared in "libtorrent/i2p_stream.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| no_error |
│ │ │ +0 |
│ │ │ + |
│ │ │ +
│ │ │ +| parse_failed |
│ │ │ +1 |
│ │ │ + |
│ │ │ +
│ │ │ +| cant_reach_peer |
│ │ │ +2 |
│ │ │ + |
│ │ │ +
│ │ │ +| i2p_error |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| invalid_key |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │ +| invalid_id |
│ │ │ +5 |
│ │ │ + |
│ │ │ +
│ │ │ +| timeout |
│ │ │ +6 |
│ │ │ + |
│ │ │ +
│ │ │ +| key_not_found |
│ │ │ +7 |
│ │ │ + |
│ │ │ +
│ │ │ +| duplicated_id |
│ │ │ +8 |
│ │ │ + |
│ │ │ +
│ │ │ +| num_errors |
│ │ │ +9 |
│ │ │ + |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum error_code_enum
│ │ │ +
Declared in "libtorrent/error_code.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| no_error |
│ │ │ +0 |
│ │ │ +Not an error |
│ │ │ +
│ │ │ +| file_collision |
│ │ │ +1 |
│ │ │ +Two torrents has files which end up overwriting each other |
│ │ │ +
│ │ │ +| failed_hash_check |
│ │ │ +2 |
│ │ │ +A piece did not match its piece hash |
│ │ │ +
│ │ │ +| torrent_is_no_dict |
│ │ │ +3 |
│ │ │ +The .torrent file does not contain a bencoded dictionary at
│ │ │ +its top level |
│ │ │ +
│ │ │ +| torrent_missing_info |
│ │ │ +4 |
│ │ │ +The .torrent file does not have an info dictionary |
│ │ │ +
│ │ │ +| torrent_info_no_dict |
│ │ │ +5 |
│ │ │ +The .torrent file's info entry is not a dictionary |
│ │ │ +
│ │ │ +| torrent_missing_piece_length |
│ │ │ +6 |
│ │ │ +The .torrent file does not have a piece length entry |
│ │ │ +
│ │ │ +| torrent_missing_name |
│ │ │ +7 |
│ │ │ +The .torrent file does not have a name entry |
│ │ │ +
│ │ │ +| torrent_invalid_name |
│ │ │ +8 |
│ │ │ +The .torrent file's name entry is invalid |
│ │ │ +
│ │ │ +| torrent_invalid_length |
│ │ │ +9 |
│ │ │ +The length of a file, or of the whole .torrent file is invalid.
│ │ │ +Either negative or not an integer |
│ │ │ +
│ │ │ +| torrent_file_parse_failed |
│ │ │ +10 |
│ │ │ +Failed to parse a file entry in the .torrent |
│ │ │ +
│ │ │ +| torrent_missing_pieces |
│ │ │ +11 |
│ │ │ +The pieces field is missing or invalid in the .torrent file |
│ │ │ +
│ │ │ +| torrent_invalid_hashes |
│ │ │ +12 |
│ │ │ +The pieces string has incorrect length |
│ │ │ +
│ │ │ +| too_many_pieces_in_torrent |
│ │ │ +13 |
│ │ │ +The .torrent file has more pieces than is supported by libtorrent |
│ │ │ +
│ │ │ +| invalid_swarm_metadata |
│ │ │ +14 |
│ │ │ +The metadata (.torrent file) that was received from the swarm
│ │ │ +matched the info-hash, but failed to be parsed |
│ │ │ +
│ │ │ +| invalid_bencoding |
│ │ │ +15 |
│ │ │ +The file or buffer is not correctly bencoded |
│ │ │ +
│ │ │ +| no_files_in_torrent |
│ │ │ +16 |
│ │ │ +The .torrent file does not contain any files |
│ │ │ +
│ │ │ +| invalid_escaped_string |
│ │ │ +17 |
│ │ │ +The string was not properly url-encoded as expected |
│ │ │ +
│ │ │ +| session_is_closing |
│ │ │ +18 |
│ │ │ +Operation is not permitted since the session is shutting down |
│ │ │ +
│ │ │ +| duplicate_torrent |
│ │ │ +19 |
│ │ │ +There's already a torrent with that info-hash added to the
│ │ │ +session |
│ │ │ +
│ │ │ +| invalid_torrent_handle |
│ │ │ +20 |
│ │ │ +The supplied torrent_handle is not referring to a valid torrent |
│ │ │ +
│ │ │ +| invalid_entry_type |
│ │ │ +21 |
│ │ │ +The type requested from the entry did not match its type |
│ │ │ +
│ │ │ +| missing_info_hash_in_uri |
│ │ │ +22 |
│ │ │ +The specified URI does not contain a valid info-hash |
│ │ │ +
│ │ │ +| file_too_short |
│ │ │ +23 |
│ │ │ +One of the files in the torrent was unexpectedly small. This
│ │ │ +might be caused by files being changed by an external process |
│ │ │ +
│ │ │ +| unsupported_url_protocol |
│ │ │ +24 |
│ │ │ +The URL used an unknown protocol. Currently http and
│ │ │ +https (if built with openssl support) are recognized. For
│ │ │ +trackers udp is recognized as well. |
│ │ │ +
│ │ │ +| url_parse_error |
│ │ │ +25 |
│ │ │ +The URL did not conform to URL syntax and failed to be parsed |
│ │ │ +
│ │ │ +| peer_sent_empty_piece |
│ │ │ +26 |
│ │ │ +The peer sent a piece message of length 0 |
│ │ │ +
│ │ │ +| parse_failed |
│ │ │ +27 |
│ │ │ +A bencoded structure was corrupt and failed to be parsed |
│ │ │ +
│ │ │ +| invalid_file_tag |
│ │ │ +28 |
│ │ │ +The fast resume file was missing or had an invalid file version
│ │ │ +tag |
│ │ │ +
│ │ │ +| missing_info_hash |
│ │ │ +29 |
│ │ │ +The fast resume file was missing or had an invalid info-hash |
│ │ │ +
│ │ │ +| mismatching_info_hash |
│ │ │ +30 |
│ │ │ +The info-hash did not match the torrent |
│ │ │ +
│ │ │ +| invalid_hostname |
│ │ │ +31 |
│ │ │ +The URL contained an invalid hostname |
│ │ │ +
│ │ │ +| invalid_port |
│ │ │ +32 |
│ │ │ +The URL had an invalid port |
│ │ │ +
│ │ │ +| port_blocked |
│ │ │ +33 |
│ │ │ +The port is blocked by the port-filter, and prevented the
│ │ │ +connection |
│ │ │ +
│ │ │ +| expected_close_bracket_in_address |
│ │ │ +34 |
│ │ │ +The IPv6 address was expected to end with "]" |
│ │ │ +
│ │ │ +| destructing_torrent |
│ │ │ +35 |
│ │ │ +The torrent is being destructed, preventing the operation to
│ │ │ +succeed |
│ │ │ +
│ │ │ +| timed_out |
│ │ │ +36 |
│ │ │ +The connection timed out |
│ │ │ +
│ │ │ +| upload_upload_connection |
│ │ │ +37 |
│ │ │ +The peer is upload only, and we are upload only. There's no point
│ │ │ +in keeping the connection |
│ │ │ +
│ │ │ +| uninteresting_upload_peer |
│ │ │ +38 |
│ │ │ +The peer is upload only, and we're not interested in it. There's
│ │ │ +no point in keeping the connection |
│ │ │ +
│ │ │ +| invalid_info_hash |
│ │ │ +39 |
│ │ │ +The peer sent an unknown info-hash |
│ │ │ +
│ │ │ +| torrent_paused |
│ │ │ +40 |
│ │ │ +The torrent is paused, preventing the operation from succeeding |
│ │ │ +
│ │ │ +| invalid_have |
│ │ │ +41 |
│ │ │ +The peer sent an invalid have message, either wrong size or
│ │ │ +referring to a piece that doesn't exist in the torrent |
│ │ │ +
│ │ │ +| invalid_bitfield_size |
│ │ │ +42 |
│ │ │ +The bitfield message had the incorrect size |
│ │ │ +
│ │ │ +| too_many_requests_when_choked |
│ │ │ +43 |
│ │ │ +The peer kept requesting pieces after it was choked, possible
│ │ │ +abuse attempt. |
│ │ │ +
│ │ │ +| invalid_piece |
│ │ │ +44 |
│ │ │ +The peer sent a piece message that does not correspond to a
│ │ │ +piece request sent by the client |
│ │ │ +
│ │ │ +| no_memory |
│ │ │ +45 |
│ │ │ +memory allocation failed |
│ │ │ +
│ │ │ +| torrent_aborted |
│ │ │ +46 |
│ │ │ +The torrent is aborted, preventing the operation to succeed |
│ │ │ +
│ │ │ +| self_connection |
│ │ │ +47 |
│ │ │ +The peer is a connection to ourself, no point in keeping it |
│ │ │ +
│ │ │ +| invalid_piece_size |
│ │ │ +48 |
│ │ │ +The peer sent a piece message with invalid size, either negative
│ │ │ +or greater than one block |
│ │ │ +
│ │ │ +| timed_out_no_interest |
│ │ │ +49 |
│ │ │ +The peer has not been interesting or interested in us for too
│ │ │ +long, no point in keeping it around |
│ │ │ +
│ │ │ +| timed_out_inactivity |
│ │ │ +50 |
│ │ │ +The peer has not said anything in a long time, possibly dead |
│ │ │ +
│ │ │ +| timed_out_no_handshake |
│ │ │ +51 |
│ │ │ +The peer did not send a handshake within a reasonable amount of
│ │ │ +time, it might not be a bittorrent peer |
│ │ │ +
│ │ │ +| timed_out_no_request |
│ │ │ +52 |
│ │ │ +The peer has been unchoked for too long without requesting any
│ │ │ +data. It might be lying about its interest in us |
│ │ │ +
│ │ │ +| invalid_choke |
│ │ │ +53 |
│ │ │ +The peer sent an invalid choke message |
│ │ │ +
│ │ │ +| invalid_unchoke |
│ │ │ +54 |
│ │ │ +The peer send an invalid unchoke message |
│ │ │ +
│ │ │ +| invalid_interested |
│ │ │ +55 |
│ │ │ +The peer sent an invalid interested message |
│ │ │ +
│ │ │ +| invalid_not_interested |
│ │ │ +56 |
│ │ │ +The peer sent an invalid not-interested message |
│ │ │ +
│ │ │ +| invalid_request |
│ │ │ +57 |
│ │ │ +The peer sent an invalid piece request message |
│ │ │ +
│ │ │ +| invalid_hash_list |
│ │ │ +58 |
│ │ │ +The peer sent an invalid hash-list message (this is part of the
│ │ │ +merkle-torrent extension) |
│ │ │ +
│ │ │ +| invalid_hash_piece |
│ │ │ +59 |
│ │ │ +The peer sent an invalid hash-piece message (this is part of the
│ │ │ +merkle-torrent extension) |
│ │ │ +
│ │ │ +| invalid_cancel |
│ │ │ +60 |
│ │ │ +The peer sent an invalid cancel message |
│ │ │ +
│ │ │ +| invalid_dht_port |
│ │ │ +61 |
│ │ │ +The peer sent an invalid DHT port-message |
│ │ │ +
│ │ │ +| invalid_suggest |
│ │ │ +62 |
│ │ │ +The peer sent an invalid suggest piece-message |
│ │ │ +
│ │ │ +| invalid_have_all |
│ │ │ +63 |
│ │ │ +The peer sent an invalid have all-message |
│ │ │ +
│ │ │ +| invalid_have_none |
│ │ │ +64 |
│ │ │ +The peer sent an invalid have none-message |
│ │ │ +
│ │ │ +| invalid_reject |
│ │ │ +65 |
│ │ │ +The peer sent an invalid reject message |
│ │ │ +
│ │ │ +| invalid_allow_fast |
│ │ │ +66 |
│ │ │ +The peer sent an invalid allow fast-message |
│ │ │ +
│ │ │ +| invalid_extended |
│ │ │ +67 |
│ │ │ +The peer sent an invalid extension message ID |
│ │ │ +
│ │ │ +| invalid_message |
│ │ │ +68 |
│ │ │ +The peer sent an invalid message ID |
│ │ │ +
│ │ │ +| sync_hash_not_found |
│ │ │ +69 |
│ │ │ +The synchronization hash was not found in the encrypted handshake |
│ │ │ +
│ │ │ +| invalid_encryption_constant |
│ │ │ +70 |
│ │ │ +The encryption constant in the handshake is invalid |
│ │ │ +
│ │ │ +| no_plaintext_mode |
│ │ │ +71 |
│ │ │ +The peer does not support plain text, which is the selected mode |
│ │ │ +
│ │ │ +| no_rc4_mode |
│ │ │ +72 |
│ │ │ +The peer does not support RC4, which is the selected mode |
│ │ │ +
│ │ │ +| unsupported_encryption_mode |
│ │ │ +73 |
│ │ │ +The peer does not support any of the encryption modes that the
│ │ │ +client supports |
│ │ │ +
│ │ │ +| unsupported_encryption_mode_selected |
│ │ │ +74 |
│ │ │ +The peer selected an encryption mode that the client did not
│ │ │ +advertise and does not support |
│ │ │ +
│ │ │ +| invalid_pad_size |
│ │ │ +75 |
│ │ │ +The pad size used in the encryption handshake is of invalid size |
│ │ │ +
│ │ │ +| invalid_encrypt_handshake |
│ │ │ +76 |
│ │ │ +The encryption handshake is invalid |
│ │ │ +
│ │ │ +| no_incoming_encrypted |
│ │ │ +77 |
│ │ │ +The client is set to not support incoming encrypted connections
│ │ │ +and this is an encrypted connection |
│ │ │ +
│ │ │ +| no_incoming_regular |
│ │ │ +78 |
│ │ │ +The client is set to not support incoming regular bittorrent
│ │ │ +connections, and this is a regular connection |
│ │ │ +
│ │ │ +| duplicate_peer_id |
│ │ │ +79 |
│ │ │ +The client is already connected to this peer-ID |
│ │ │ +
│ │ │ +| torrent_removed |
│ │ │ +80 |
│ │ │ +Torrent was removed |
│ │ │ +
│ │ │ +| packet_too_large |
│ │ │ +81 |
│ │ │ +The packet size exceeded the upper sanity check-limit |
│ │ │ +
│ │ │ +| reserved |
│ │ │ +82 |
│ │ │ + |
│ │ │ +
│ │ │ +| http_error |
│ │ │ +83 |
│ │ │ +The web server responded with an error |
│ │ │ +
│ │ │ +| missing_location |
│ │ │ +84 |
│ │ │ +The web server response is missing a location header |
│ │ │ +
│ │ │ +| invalid_redirection |
│ │ │ +85 |
│ │ │ +The web seed redirected to a path that no longer matches the
│ │ │ +.torrent directory structure |
│ │ │ +
│ │ │ +| redirecting |
│ │ │ +86 |
│ │ │ +The connection was closed because it redirected to a different
│ │ │ +URL |
│ │ │ +
│ │ │ +| invalid_range |
│ │ │ +87 |
│ │ │ +The HTTP range header is invalid |
│ │ │ +
│ │ │ +| no_content_length |
│ │ │ +88 |
│ │ │ +The HTTP response did not have a content length |
│ │ │ +
│ │ │ +| banned_by_ip_filter |
│ │ │ +89 |
│ │ │ +The IP is blocked by the IP filter |
│ │ │ +
│ │ │ +| too_many_connections |
│ │ │ +90 |
│ │ │ +At the connection limit |
│ │ │ +
│ │ │ +| peer_banned |
│ │ │ +91 |
│ │ │ +The peer is marked as banned |
│ │ │ +
│ │ │ +| stopping_torrent |
│ │ │ +92 |
│ │ │ +The torrent is stopping, causing the operation to fail |
│ │ │ +
│ │ │ +| too_many_corrupt_pieces |
│ │ │ +93 |
│ │ │ +The peer has sent too many corrupt pieces and is banned |
│ │ │ +
│ │ │ +| torrent_not_ready |
│ │ │ +94 |
│ │ │ +The torrent is not ready to receive peers |
│ │ │ +
│ │ │ +| peer_not_constructed |
│ │ │ +95 |
│ │ │ +The peer is not completely constructed yet |
│ │ │ +
│ │ │ +| session_closing |
│ │ │ +96 |
│ │ │ +The session is closing, causing the operation to fail |
│ │ │ +
│ │ │ +| optimistic_disconnect |
│ │ │ +97 |
│ │ │ +The peer was disconnected in order to leave room for a
│ │ │ +potentially better peer |
│ │ │ +
│ │ │ +| torrent_finished |
│ │ │ +98 |
│ │ │ +The torrent is finished |
│ │ │ +
│ │ │ +| no_router |
│ │ │ +99 |
│ │ │ +No UPnP router found |
│ │ │ +
│ │ │ +| metadata_too_large |
│ │ │ +100 |
│ │ │ +The metadata message says the metadata exceeds the limit |
│ │ │ +
│ │ │ +| invalid_metadata_request |
│ │ │ +101 |
│ │ │ +The peer sent an invalid metadata request message |
│ │ │ +
│ │ │ +| invalid_metadata_size |
│ │ │ +102 |
│ │ │ +The peer advertised an invalid metadata size |
│ │ │ +
│ │ │ +| invalid_metadata_offset |
│ │ │ +103 |
│ │ │ +The peer sent a message with an invalid metadata offset |
│ │ │ +
│ │ │ +| invalid_metadata_message |
│ │ │ +104 |
│ │ │ +The peer sent an invalid metadata message |
│ │ │ +
│ │ │ +| pex_message_too_large |
│ │ │ +105 |
│ │ │ +The peer sent a peer exchange message that was too large |
│ │ │ +
│ │ │ +| invalid_pex_message |
│ │ │ +106 |
│ │ │ +The peer sent an invalid peer exchange message |
│ │ │ +
│ │ │ +| invalid_lt_tracker_message |
│ │ │ +107 |
│ │ │ +The peer sent an invalid tracker exchange message |
│ │ │ +
│ │ │ +| too_frequent_pex |
│ │ │ +108 |
│ │ │ +The peer sent an pex messages too often. This is a possible
│ │ │ +attempt of and attack |
│ │ │ +
│ │ │ +| no_metadata |
│ │ │ +109 |
│ │ │ +The operation failed because it requires the torrent to have
│ │ │ +the metadata (.torrent file) and it doesn't have it yet.
│ │ │ +This happens for magnet links before they have downloaded the
│ │ │ +metadata, and also torrents added by URL. |
│ │ │ +
│ │ │ +| invalid_dont_have |
│ │ │ +110 |
│ │ │ +The peer sent an invalid dont_have message. The don't have
│ │ │ +message is an extension to allow peers to advertise that the
│ │ │ +no longer has a piece they previously had. |
│ │ │ +
│ │ │ +| requires_ssl_connection |
│ │ │ +111 |
│ │ │ +The peer tried to connect to an SSL torrent without connecting
│ │ │ +over SSL. |
│ │ │ +
│ │ │ +| invalid_ssl_cert |
│ │ │ +112 |
│ │ │ +The peer tried to connect to a torrent with a certificate
│ │ │ +for a different torrent. |
│ │ │ +
│ │ │ +| not_an_ssl_torrent |
│ │ │ +113 |
│ │ │ +the torrent is not an SSL torrent, and the operation requires
│ │ │ +an SSL torrent |
│ │ │ +
│ │ │ +| banned_by_port_filter |
│ │ │ +114 |
│ │ │ +peer was banned because its listen port is within a banned port
│ │ │ +range, as specified by the port_filter. |
│ │ │ +
│ │ │ +| invalid_session_handle |
│ │ │ +115 |
│ │ │ +The session_handle is not referring to a valid session_impl |
│ │ │ +
│ │ │ +| invalid_listen_socket |
│ │ │ +116 |
│ │ │ +the listen socket associated with this request was closed |
│ │ │ +
│ │ │ +| invalid_hash_request |
│ │ │ +117 |
│ │ │ + |
│ │ │ +
│ │ │ +| invalid_hashes |
│ │ │ +118 |
│ │ │ + |
│ │ │ +
│ │ │ +| invalid_hash_reject |
│ │ │ +119 |
│ │ │ + |
│ │ │ +
│ │ │ +| deprecated_120 |
│ │ │ +120 |
│ │ │ + |
│ │ │ +
│ │ │ +| deprecated_121 |
│ │ │ +121 |
│ │ │ + |
│ │ │ +
│ │ │ +| deprecated_122 |
│ │ │ +122 |
│ │ │ + |
│ │ │ +
│ │ │ +| deprecated_123 |
│ │ │ +123 |
│ │ │ + |
│ │ │ +
│ │ │ +| deprecated_124 |
│ │ │ +124 |
│ │ │ + |
│ │ │ +
│ │ │ +| missing_file_sizes |
│ │ │ +130 |
│ │ │ +The resume data file is missing the file sizes entry |
│ │ │ +
│ │ │ +| no_files_in_resume_data |
│ │ │ +131 |
│ │ │ +The resume data file file sizes entry is empty |
│ │ │ +
│ │ │ +| missing_pieces |
│ │ │ +132 |
│ │ │ +The resume data file is missing the pieces and slots entry |
│ │ │ +
│ │ │ +| mismatching_number_of_files |
│ │ │ +133 |
│ │ │ +The number of files in the resume data does not match the number
│ │ │ +of files in the torrent |
│ │ │ +
│ │ │ +| mismatching_file_size |
│ │ │ +134 |
│ │ │ +One of the files on disk has a different size than in the fast
│ │ │ +resume file |
│ │ │ +
│ │ │ +| mismatching_file_timestamp |
│ │ │ +135 |
│ │ │ +One of the files on disk has a different timestamp than in the
│ │ │ +fast resume file |
│ │ │ +
│ │ │ +| not_a_dictionary |
│ │ │ +136 |
│ │ │ +The resume data file is not a dictionary |
│ │ │ +
│ │ │ +| invalid_blocks_per_piece |
│ │ │ +137 |
│ │ │ +The blocks per piece entry is invalid in the resume data file |
│ │ │ +
│ │ │ +| missing_slots |
│ │ │ +138 |
│ │ │ +The resume file is missing the slots entry, which is required
│ │ │ +for torrents with compact allocation. DEPRECATED |
│ │ │ +
│ │ │ +| too_many_slots |
│ │ │ +139 |
│ │ │ +The resume file contains more slots than the torrent |
│ │ │ +
│ │ │ +| invalid_slot_list |
│ │ │ +140 |
│ │ │ +The slot entry is invalid in the resume data |
│ │ │
│ │ │ -| available |
│ │ │ -14 |
│ │ │ -an attempt to query the number of bytes available to read from a socket
│ │ │ -failed |
│ │ │ +
| invalid_piece_index |
│ │ │ +141 |
│ │ │ +One index in the slot list is invalid |
│ │ │
│ │ │ -| encryption |
│ │ │ -15 |
│ │ │ -a call related to bittorrent protocol encryption failed |
│ │ │ +
| pieces_need_reorder |
│ │ │ +142 |
│ │ │ +The pieces on disk needs to be re-ordered for the specified
│ │ │ +allocation mode. This happens if you specify sparse allocation
│ │ │ +and the files on disk are using compact storage. The pieces needs
│ │ │ +to be moved to their right position. DEPRECATED |
│ │ │
│ │ │ -| connect |
│ │ │ -16 |
│ │ │ -an attempt to connect a socket failed |
│ │ │ +
| resume_data_not_modified |
│ │ │ +143 |
│ │ │ +this error is returned when asking to save resume data and
│ │ │ +specifying the flag to only save when there's anything new to save
│ │ │ +(torrent_handle::only_if_modified) and there wasn't anything changed. |
│ │ │
│ │ │ -| ssl_handshake |
│ │ │ -17 |
│ │ │ -establishing an SSL connection failed |
│ │ │ +
| invalid_save_path |
│ │ │ +144 |
│ │ │ +the save_path in add_torrent_params is not valid |
│ │ │
│ │ │ -| get_interface |
│ │ │ -18 |
│ │ │ -a connection failed to satisfy the bind interface setting |
│ │ │ +
| http_parse_error |
│ │ │ +150 |
│ │ │ +The HTTP header was not correctly formatted |
│ │ │
│ │ │ -| sock_listen |
│ │ │ -19 |
│ │ │ -a call to listen() on a socket |
│ │ │ +
| http_missing_location |
│ │ │ +151 |
│ │ │ +The HTTP response was in the 300-399 range but lacked a location
│ │ │ +header |
│ │ │
│ │ │ -| sock_bind_to_device |
│ │ │ -20 |
│ │ │ -a call to the ioctl to bind a socket to a specific network device or
│ │ │ -adapter |
│ │ │ +
| http_failed_decompress |
│ │ │ +152 |
│ │ │ +The HTTP response was encoded with gzip or deflate but
│ │ │ +decompressing it failed |
│ │ │
│ │ │ -| sock_accept |
│ │ │ -21 |
│ │ │ -a call to accept() on a socket |
│ │ │ +
| no_i2p_router |
│ │ │ +160 |
│ │ │ +The URL specified an i2p address, but no i2p router is configured |
│ │ │
│ │ │ -| parse_address |
│ │ │ -22 |
│ │ │ -convert a string into a valid network address |
│ │ │ +
| no_i2p_endpoint |
│ │ │ +161 |
│ │ │ +i2p acceptor is not available yet, can't announce without endpoint |
│ │ │
│ │ │ -| enum_if |
│ │ │ -23 |
│ │ │ -enumeration network devices or adapters |
│ │ │ +
| scrape_not_available |
│ │ │ +170 |
│ │ │ +The tracker URL doesn't support transforming it into a scrape
│ │ │ +URL. i.e. it doesn't contain "announce. |
│ │ │
│ │ │ -| file_stat |
│ │ │ -24 |
│ │ │ -invoking stat() on a file |
│ │ │ +
| invalid_tracker_response |
│ │ │ +171 |
│ │ │ +invalid tracker response |
│ │ │
│ │ │ -| file_copy |
│ │ │ -25 |
│ │ │ -copying a file |
│ │ │ +
| invalid_peer_dict |
│ │ │ +172 |
│ │ │ +invalid peer dictionary entry. Not a dictionary |
│ │ │
│ │ │ -| file_fallocate |
│ │ │ -26 |
│ │ │ -allocating storage for a file |
│ │ │ +
| tracker_failure |
│ │ │ +173 |
│ │ │ +tracker sent a failure message |
│ │ │
│ │ │ -| file_hard_link |
│ │ │ -27 |
│ │ │ -creating a hard link |
│ │ │ +
| invalid_files_entry |
│ │ │ +174 |
│ │ │ +missing or invalid files entry |
│ │ │
│ │ │ -| file_remove |
│ │ │ -28 |
│ │ │ -removing a file |
│ │ │ +
| invalid_hash_entry |
│ │ │ +175 |
│ │ │ +missing or invalid hash entry |
│ │ │
│ │ │ -| file_rename |
│ │ │ -29 |
│ │ │ -renaming a file |
│ │ │ +
| invalid_peers_entry |
│ │ │ +176 |
│ │ │ +missing or invalid peers and peers6 entry |
│ │ │
│ │ │ -| file_open |
│ │ │ -30 |
│ │ │ -opening a file |
│ │ │ +
| invalid_tracker_response_length |
│ │ │ +177 |
│ │ │ +UDP tracker response packet has invalid size |
│ │ │
│ │ │ -| mkdir |
│ │ │ -31 |
│ │ │ -creating a directory |
│ │ │ +
| invalid_tracker_transaction_id |
│ │ │ +178 |
│ │ │ +invalid transaction id in UDP tracker response |
│ │ │
│ │ │ -| check_resume |
│ │ │ -32 |
│ │ │ -check fast resume data against files on disk |
│ │ │ +
| invalid_tracker_action |
│ │ │ +179 |
│ │ │ +invalid action field in UDP tracker response |
│ │ │
│ │ │ -| exception |
│ │ │ -33 |
│ │ │ -an unknown exception |
│ │ │ +
| announce_skipped |
│ │ │ +180 |
│ │ │ +skipped announce (because it's assumed to be unreachable over the
│ │ │ +given source network interface) |
│ │ │
│ │ │ -| alloc_cache_piece |
│ │ │ -34 |
│ │ │ -allocate space for a piece in the cache |
│ │ │ +
| no_entropy |
│ │ │ +200 |
│ │ │ +random number generation failed |
│ │ │
│ │ │ -| partfile_move |
│ │ │ -35 |
│ │ │ -move a part-file |
│ │ │ +
| ssrf_mitigation |
│ │ │ +201 |
│ │ │ +blocked by SSRF mitigation |
│ │ │
│ │ │ -| partfile_read |
│ │ │ -36 |
│ │ │ -read from a part file |
│ │ │ +
| blocked_by_idna |
│ │ │ +202 |
│ │ │ +blocked because IDNA host names are banned |
│ │ │
│ │ │ -| partfile_write |
│ │ │ -37 |
│ │ │ -write to a part-file |
│ │ │ +
| torrent_unknown_version |
│ │ │ +210 |
│ │ │ +the torrent file has an unknown meta version |
│ │ │
│ │ │ -| hostname_lookup |
│ │ │ -38 |
│ │ │ -a hostname lookup |
│ │ │ +
| torrent_missing_file_tree |
│ │ │ +211 |
│ │ │ +the v2 torrent file has no file tree |
│ │ │
│ │ │ -| symlink |
│ │ │ -39 |
│ │ │ -create or read a symlink |
│ │ │ +
| torrent_missing_meta_version |
│ │ │ +212 |
│ │ │ +the torrent contains v2 keys but does not specify meta version 2 |
│ │ │
│ │ │ -| handshake |
│ │ │ -40 |
│ │ │ -handshake with a peer or server |
│ │ │ +
| torrent_inconsistent_files |
│ │ │ +213 |
│ │ │ +the v1 and v2 file metadata does not match |
│ │ │
│ │ │ -| sock_option |
│ │ │ -41 |
│ │ │ -set socket option |
│ │ │ +
| torrent_missing_piece_layer |
│ │ │ +214 |
│ │ │ +one or more files are missing piece layer hashes |
│ │ │
│ │ │ -| enum_route |
│ │ │ -42 |
│ │ │ -enumeration of network routes |
│ │ │ +
| torrent_invalid_piece_layer |
│ │ │ +215 |
│ │ │ +a piece layer has the wrong size or failed hash check |
│ │ │
│ │ │ -| file_seek |
│ │ │ -43 |
│ │ │ -moving read/write position in a file, operation_t::hostname_lookup |
│ │ │ +
| torrent_missing_pieces_root |
│ │ │ +216 |
│ │ │ +a v2 file entry has no root hash |
│ │ │
│ │ │ -| timer |
│ │ │ -44 |
│ │ │ -an async wait operation on a timer |
│ │ │ +
| torrent_inconsistent_hashes |
│ │ │ +217 |
│ │ │ +the v1 and v2 hashes do not describe the same data |
│ │ │
│ │ │ -| file_mmap |
│ │ │ -45 |
│ │ │ -call to mmap() (or windows counterpart) |
│ │ │ +
| torrent_invalid_pad_file |
│ │ │ +218 |
│ │ │ +a file in the v2 metadata has the pad attribute set |
│ │ │
│ │ │ -| file_truncate |
│ │ │ -46 |
│ │ │ -call to ftruncate() (or SetEndOfFile() on windows) |
│ │ │ +
| error_code_max |
│ │ │ +219 |
│ │ │ +the number of error codes |
│ │ │
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
alert_category_t
│ │ │ -
Declared in "libtorrent/alert.hpp"
│ │ │ -
│ │ │ -- error
│ │ │ -Enables alerts that report an error. This includes:
│ │ │ -
│ │ │ -- tracker errors
│ │ │ -- tracker warnings
│ │ │ -- file errors
│ │ │ -- resume data failures
│ │ │ -- web seed errors
│ │ │ -- .torrent files errors
│ │ │ -- listen socket errors
│ │ │ -- port mapping errors
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -- peer
│ │ │ -- Enables alerts when peers send invalid requests, get banned or
│ │ │ -snubbed.
│ │ │ -
│ │ │ -
│ │ │ -- port_mapping
│ │ │ -- Enables alerts for port mapping events. For NAT-PMP and UPnP.
│ │ │ -
│ │ │ -
│ │ │ -- storage
│ │ │ -- Enables alerts for events related to the storage. File errors and
│ │ │ -synchronization events for moving the storage, renaming files etc.
│ │ │ -
│ │ │ -
│ │ │ -- tracker
│ │ │ -- Enables all tracker events. Includes announcing to trackers,
│ │ │ -receiving responses, warnings and errors.
│ │ │ -
│ │ │ -
│ │ │ -- connect
│ │ │ -- Low level alerts for when peers are connected and disconnected.
│ │ │ -
│ │ │ -
│ │ │ -- status
│ │ │ -- Enables alerts for when a torrent or the session changes state.
│ │ │ -
│ │ │ -
│ │ │ -- ip_block
│ │ │ -- Alerts when a peer is blocked by the ip blocker or port blocker.
│ │ │ -
│ │ │ -
│ │ │ -- performance_warning
│ │ │ -- Alerts when some limit is reached that might limit the download
│ │ │ -or upload rate.
│ │ │ -
│ │ │ -
│ │ │ -- dht
│ │ │ -- Alerts on events in the DHT node. For incoming searches or
│ │ │ -bootstrapping being done etc.
│ │ │ -
│ │ │ -
│ │ │ -- stats
│ │ │ -- If you enable these alerts, you will receive a stats_alert
│ │ │ -approximately once every second, for every active torrent.
│ │ │ -These alerts contain all statistics counters for the interval since
│ │ │ -the lasts stats alert.
│ │ │ -
│ │ │ -
│ │ │ -- session_log
│ │ │ -- Enables debug logging alerts. These are available unless libtorrent
│ │ │ -was built with logging disabled (TORRENT_DISABLE_LOGGING). The
│ │ │ -alerts being posted are log_alert and are session wide.
│ │ │ -
│ │ │ -
│ │ │ -- torrent_log
│ │ │ -- Enables debug logging alerts for torrents. These are available
│ │ │ -unless libtorrent was built with logging disabled
│ │ │ -(TORRENT_DISABLE_LOGGING). The alerts being posted are
│ │ │ -torrent_log_alert and are torrent wide debug events.
│ │ │ -
│ │ │ -
│ │ │ -- peer_log
│ │ │ -- Enables debug logging alerts for peers. These are available unless
│ │ │ -libtorrent was built with logging disabled
│ │ │ -(TORRENT_DISABLE_LOGGING). The alerts being posted are
│ │ │ -peer_log_alert and low-level peer events and messages.
│ │ │ -
│ │ │ -
│ │ │ -- incoming_request
│ │ │ -- enables the incoming_request_alert.
│ │ │ -
│ │ │ -
│ │ │ -- dht_log
│ │ │ -- enables dht_log_alert, debug logging for the DHT
│ │ │ -
│ │ │ -
│ │ │ -- dht_operation
│ │ │ -- enable events from pure dht operations not related to torrents
│ │ │ -
│ │ │ -
│ │ │ -- port_mapping_log
│ │ │ -- enables port mapping log events. This log is useful
│ │ │ -for debugging the UPnP or NAT-PMP implementation
│ │ │ -
│ │ │ -
│ │ │ -- picker_log
│ │ │ -- enables verbose logging from the piece picker.
│ │ │ -
│ │ │ -
│ │ │ -- file_progress
│ │ │ -- alerts when files complete downloading
│ │ │ -
│ │ │ -
│ │ │ -- piece_progress
│ │ │ -- alerts when pieces complete downloading or fail hash check
│ │ │ -
│ │ │ -
│ │ │ -- upload
│ │ │ -- alerts when we upload blocks to other peers
│ │ │ -
│ │ │ -
│ │ │ -- block_progress
│ │ │ -- alerts on individual blocks being requested, downloading, finished,
│ │ │ -rejected, time-out and cancelled. This is likely to post alerts at a
│ │ │ -high rate.
│ │ │ -
│ │ │ -
│ │ │ -- all
│ │ │ -The full bitmask, representing all available categories.
│ │ │ -since the enum is signed, make sure this isn't
│ │ │ -interpreted as -1. For instance, boost.python
│ │ │ -does that and fails when assigning it to an
│ │ │ -unsigned parameter.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
int
│ │ │ -
Declared in "libtorrent/alert_types.hpp"
│ │ │ -
│ │ │ -- user_alert_id
│ │ │ -- user defined alerts should use IDs greater than this
│ │ │ -
│ │ │ -
│ │ │ -- num_alert_types
│ │ │ -- this constant represents "max_alert_index" + 1
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
counters
│ │ │ -
Declared in "libtorrent/performance_counters.hpp"
│ │ │ -
│ │ │ -struct counters
│ │ │ -{
│ │ │ - counters () ;
│ │ │ - counters& operator= (counters const&) & ;
│ │ │ - counters (counters const&) ;
│ │ │ - 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]
│ │ │ -
operator[]() inc_stats_counter()
│ │ │ -
│ │ │ -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"
│ │ │ -
describes one statistics metric from the session. For more information,
│ │ │ -see the session statistics section.
│ │ │ -
│ │ │ -struct stats_metric
│ │ │ -{
│ │ │ - char const* name;
│ │ │ - int value_index;
│ │ │ - metric_type_t type;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- name
│ │ │ -- the name of the counter or gauge
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- value_index type
│ │ │ -- the index into the session stats array, where the underlying value of
│ │ │ -this counter or gauge is found. The session stats array is part of the
│ │ │ -session_stats_alert object.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
session_stats_metrics()
│ │ │ -
Declared in "libtorrent/session_stats.hpp"
│ │ │ -
│ │ │ -std::vector<stats_metric> session_stats_metrics ();
│ │ │ -
│ │ │ -
This free function returns the list of available metrics exposed by
│ │ │ -libtorrent's statistics API. Each metric has a name and a value index.
│ │ │ -The value index is the index into the array in session_stats_alert where
│ │ │ -this metric's value can be found when the session stats is sampled (by
│ │ │ -calling post_session_stats()).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
find_metric_idx()
│ │ │ -
Declared in "libtorrent/session_stats.hpp"
│ │ │ -
│ │ │ -int find_metric_idx (string_view name);
│ │ │ -
│ │ │ -
given a name of a metric, this function returns the counter index of it,
│ │ │ -or -1 if it could not be found. The counter index is the index into the
│ │ │ -values array returned by session_stats_alert.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum http_errors
│ │ │ +
Declared in "libtorrent/error_code.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| counter |
│ │ │ -0 |
│ │ │ +
| cont |
│ │ │ +100 |
│ │ │ |
│ │ │
│ │ │ -| gauge |
│ │ │ -1 |
│ │ │ +
| ok |
│ │ │ +200 |
│ │ │ |
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
ip_filter
│ │ │ -
Declared in "libtorrent/ip_filter.hpp"
│ │ │ -
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 ip_filter does not filter any address.
│ │ │ -
│ │ │ -struct ip_filter
│ │ │ -{
│ │ │ - ip_filter& operator= (ip_filter&&);
│ │ │ - ~ip_filter ();
│ │ │ - ip_filter (ip_filter const&);
│ │ │ - ip_filter ();
│ │ │ - 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
│ │ │ - {
│ │ │ - blocked,
│ │ │ - };
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
empty()
│ │ │ -
│ │ │ -bool empty () const;
│ │ │ -
│ │ │ -
returns true if the filter does not contain any rules
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
add_rule()
│ │ │ -
│ │ │ -void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ -
│ │ │ -
Adds a rule to the filter. first and last defines a range of
│ │ │ -ip addresses that will be marked with the given flags. The flags
│ │ │ -can currently be 0, which means allowed, or ip_filter::blocked, which
│ │ │ -means disallowed.
│ │ │ -
precondition:
│ │ │ -first.is_v4() == last.is_v4() && first.is_v6() == last.is_v6()
│ │ │ -
postcondition:
│ │ │ -access(x) == flags for every x in the range [first, last]
│ │ │ -
This means that in a case of overlapping ranges, the last one applied takes
│ │ │ -precedence.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
access()
│ │ │ -
│ │ │ -std::uint32_t access (address const& addr) const;
│ │ │ -
│ │ │ -
Returns the access permissions for the given address (addr). The permission
│ │ │ -can currently be 0 or ip_filter::blocked. The complexity of this operation
│ │ │ -is O(log n), where n is the minimum number of non-overlapping ranges to describe
│ │ │ -the current filter.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
export_filter()
│ │ │ -
│ │ │ -filter_tuple_t export_filter () const;
│ │ │ -
│ │ │ -
This function will return the current state of the filter in the minimum number of
│ │ │ -ranges possible. They are sorted from ranges in low addresses to high addresses. Each
│ │ │ -entry in the returned vector is a range with the access control specified in its
│ │ │ -flags field.
│ │ │ -
The return value is a tuple containing two range-lists. One for IPv4 addresses
│ │ │ -and one for IPv6 addresses.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum access_flags
│ │ │ -
Declared in "libtorrent/ip_filter.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ +
|---|
| created |
│ │ │ +201 |
│ │ │ + |
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -| blocked |
│ │ │ -1 |
│ │ │ -indicates that IPs in this range should not be connected
│ │ │ -to nor accepted as incoming connections |
│ │ │ +
| accepted |
│ │ │ +202 |
│ │ │ + |
│ │ │ +
│ │ │ +| no_content |
│ │ │ +204 |
│ │ │ + |
│ │ │ +
│ │ │ +| multiple_choices |
│ │ │ +300 |
│ │ │ + |
│ │ │ +
│ │ │ +| moved_permanently |
│ │ │ +301 |
│ │ │ + |
│ │ │ +
│ │ │ +| moved_temporarily |
│ │ │ +302 |
│ │ │ + |
│ │ │ +
│ │ │ +| not_modified |
│ │ │ +304 |
│ │ │ + |
│ │ │ +
│ │ │ +| bad_request |
│ │ │ +400 |
│ │ │ + |
│ │ │ +
│ │ │ +| unauthorized |
│ │ │ +401 |
│ │ │ + |
│ │ │ +
│ │ │ +| forbidden |
│ │ │ +403 |
│ │ │ + |
│ │ │ +
│ │ │ +| not_found |
│ │ │ +404 |
│ │ │ + |
│ │ │ +
│ │ │ +| internal_server_error |
│ │ │ +500 |
│ │ │ + |
│ │ │ +
│ │ │ +| not_implemented |
│ │ │ +501 |
│ │ │ + |
│ │ │ +
│ │ │ +| bad_gateway |
│ │ │ +502 |
│ │ │ + |
│ │ │ +
│ │ │ +| service_unavailable |
│ │ │ +503 |
│ │ │ + |
│ │ │
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
port_filter
│ │ │ -
Declared in "libtorrent/ip_filter.hpp"
│ │ │ -
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&&);
│ │ │ - port_filter (port_filter const&);
│ │ │ - port_filter& operator= (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,
│ │ │ - };
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
add_rule()
│ │ │ -
│ │ │ -void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ -
│ │ │ -
set the flags for the specified port range (first, last) to
│ │ │ -flags overwriting any existing rule for those ports. The range
│ │ │ -is inclusive, i.e. the port last also has the flag set on it.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
access()
│ │ │ -
│ │ │ -std::uint32_t access (std::uint16_t port) const;
│ │ │ -
│ │ │ -
test the specified port (port) for whether it is blocked
│ │ │ -or not. The returned value is the flags set for this port.
│ │ │ -see access_flags.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum error_code_enum
│ │ │ +
Declared in "libtorrent/upnp.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| blocked |
│ │ │ -1 |
│ │ │ -this flag indicates that destination ports in the
│ │ │ -range should not be connected to |
│ │ │ +
| no_error |
│ │ │ +0 |
│ │ │ +No error |
│ │ │ +
│ │ │ +| invalid_argument |
│ │ │ +402 |
│ │ │ +One of the arguments in the request is invalid |
│ │ │ +
│ │ │ +| action_failed |
│ │ │ +501 |
│ │ │ +The request failed |
│ │ │ +
│ │ │ +| value_not_in_array |
│ │ │ +714 |
│ │ │ +The specified value does not exist in the array |
│ │ │ +
│ │ │ +| source_ip_cannot_be_wildcarded |
│ │ │ +715 |
│ │ │ +The source IP address cannot be wild-carded, but
│ │ │ +must be fully specified |
│ │ │ +
│ │ │ +| external_port_cannot_be_wildcarded |
│ │ │ +716 |
│ │ │ +The external port cannot be a wildcard, but must
│ │ │ +be specified |
│ │ │ +
│ │ │ +| port_mapping_conflict |
│ │ │ +718 |
│ │ │ +The port mapping entry specified conflicts with a
│ │ │ +mapping assigned previously to another client |
│ │ │ +
│ │ │ +| internal_port_must_match_external |
│ │ │ +724 |
│ │ │ +Internal and external port value must be the same |
│ │ │ +
│ │ │ +| only_permanent_leases_supported |
│ │ │ +725 |
│ │ │ +The NAT implementation only supports permanent
│ │ │ +lease times on port mappings |
│ │ │ +
│ │ │ +| remote_host_must_be_wildcard |
│ │ │ +726 |
│ │ │ +RemoteHost must be a wildcard and cannot be a
│ │ │ +specific IP address or DNS name |
│ │ │ +
│ │ │ +| external_port_must_be_wildcard |
│ │ │ +727 |
│ │ │ +ExternalPort must be a wildcard and cannot be a
│ │ │ +specific port |
│ │ │
│ │ │
│ │ │
│ │ │ -
Bencoding is a common representation in bittorrent used for dictionary,
│ │ │ -list, int and string hierarchies. It's used to encode .torrent files and
│ │ │ -some messages in the network protocol. libtorrent also uses it to store
│ │ │ -settings, resume data and other session state.
│ │ │ -
Strings in bencoded structures do not necessarily represent text.
│ │ │ -Strings are raw byte buffers of a certain length. If a string is meant to be
│ │ │ -interpreted as text, it is required to be UTF-8 encoded. See BEP 3.
│ │ │ -
The function for decoding bencoded data bdecode(), returning a bdecode_node.
│ │ │ -This function builds a tree that points back into the original buffer. The
│ │ │ -returned bdecode_node will not be valid once the buffer it was parsed out of
│ │ │ -is discarded.
│ │ │ -
It's possible to construct an entry from a bdecode_node, if a structure needs
│ │ │ -to be altered and re-encoded.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
entry
│ │ │ -
Declared in "libtorrent/entry.hpp"
│ │ │ -
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 (integer_type);
│ │ │ - entry (preformatted_type);
│ │ │ - entry (dictionary_type);
│ │ │ - entry (list_type);
│ │ │ - entry (span<char const>);
│ │ │ - entry (U v);
│ │ │ - entry (data_type t);
│ │ │ - entry (bdecode_node const& n);
│ │ │ - entry& operator= (bdecode_node const&) &;
│ │ │ - entry& operator= (integer_type) &;
│ │ │ - entry& operator= (entry&&) & noexcept;
│ │ │ - entry& operator= (entry const&) &;
│ │ │ - entry& operator= (list_type) &;
│ │ │ - entry& operator= (dictionary_type) &;
│ │ │ - entry& operator= (preformatted_type) &;
│ │ │ - entry& operator= (span<char const>) &;
│ │ │ - entry& operator= (U v) &;
│ │ │ - string_type const& string () const;
│ │ │ - preformatted_type& preformatted ();
│ │ │ - preformatted_type const& preformatted () const;
│ │ │ - integer_type const& integer () const;
│ │ │ - dictionary_type& dict ();
│ │ │ - integer_type& integer ();
│ │ │ - list_type const& list () const;
│ │ │ - dictionary_type const& dict () const;
│ │ │ - list_type& list ();
│ │ │ - string_type& string ();
│ │ │ - void swap (entry& e);
│ │ │ - entry& operator[] (string_view key);
│ │ │ - entry const& operator[] (string_view key) const;
│ │ │ - 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,
│ │ │ - dictionary_t,
│ │ │ - undefined_t,
│ │ │ - preformatted_t,
│ │ │ - };
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
type()
│ │ │ -
│ │ │ -data_type type () const;
│ │ │ -
│ │ │ -
returns the concrete type of the entry
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
entry()
│ │ │ -
│ │ │ -entry (integer_type);
│ │ │ -entry (preformatted_type);
│ │ │ -entry (dictionary_type);
│ │ │ -entry (list_type);
│ │ │ -entry (span<char const>);
│ │ │ -
│ │ │ -
constructors directly from a specific type.
│ │ │ -The content of the argument is copied into the
│ │ │ -newly constructed entry
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
entry()
│ │ │ -
│ │ │ -entry (data_type t);
│ │ │ -
│ │ │ -
construct an empty entry of the specified type.
│ │ │ -see data_type enum.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
entry()
│ │ │ -
│ │ │ -entry (bdecode_node const& n);
│ │ │ -
│ │ │ -
construct from bdecode_node parsed form (see bdecode())
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
operator=()
│ │ │ -
│ │ │ -entry& operator= (bdecode_node const&) &;
│ │ │ -entry& operator= (integer_type) &;
│ │ │ -entry& operator= (entry&&) & noexcept;
│ │ │ -entry& operator= (entry const&) &;
│ │ │ -entry& operator= (list_type) &;
│ │ │ -entry& operator= (dictionary_type) &;
│ │ │ -entry& operator= (preformatted_type) &;
│ │ │ -entry& operator= (span<char const>) &;
│ │ │ -
│ │ │ -
copies the structure of the right hand side into this
│ │ │ -entry.
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
swap()
│ │ │ -
│ │ │ -void swap (entry& e);
│ │ │ -
│ │ │ -
swaps the content of this with e.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
operator[]()
│ │ │ -
│ │ │ -entry& operator[] (string_view key);
│ │ │ -entry const& operator[] (string_view key) const;
│ │ │ -
│ │ │ -
All of these functions requires the entry to be a dictionary, if it
│ │ │ -isn't they will throw system_error.
│ │ │ -
The non-const versions of the operator[] will return a reference
│ │ │ -to either the existing element at the given key or, if there is no
│ │ │ -element with the given key, a reference to a newly inserted element at
│ │ │ -that key.
│ │ │ -
The const version of operator[] will only return a reference to an
│ │ │ -existing element at the given key. If the key is not found, it will
│ │ │ -throw system_error.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
find_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]
│ │ │ -
│ │ │ -
to_string()
│ │ │ -
│ │ │ -std::string to_string (bool single_line = false) const;
│ │ │ -
│ │ │ -
returns a pretty-printed string representation
│ │ │ -of the bencoded structure, with JSON-style syntax
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
enum error_code_enum
│ │ │ +
Declared in "libtorrent/bdecode.hpp"
│ │ │
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
│ │ │
│ │ │ | name |
│ │ │ value |
│ │ │ description |
│ │ │
|---|
│ │ │
│ │ │
│ │ │ -| int_t |
│ │ │ +
| no_error |
│ │ │ 0 |
│ │ │ - |
│ │ │ +Not an error |
│ │ │
│ │ │ -| string_t |
│ │ │ +
| expected_digit |
│ │ │ 1 |
│ │ │ - |
│ │ │ +expected digit in bencoded string |
│ │ │
│ │ │ -| list_t |
│ │ │ +
| expected_colon |
│ │ │ 2 |
│ │ │ - |
│ │ │ +expected colon in bencoded string |
│ │ │
│ │ │ -| dictionary_t |
│ │ │ +
| unexpected_eof |
│ │ │ 3 |
│ │ │ - |
│ │ │ +unexpected end of file in bencoded string |
│ │ │
│ │ │ -| undefined_t |
│ │ │ +
| expected_value |
│ │ │ 4 |
│ │ │ - |
│ │ │ +expected value (list, dict, int or string) in bencoded string |
│ │ │
│ │ │ -| preformatted_t |
│ │ │ +
| depth_exceeded |
│ │ │ 5 |
│ │ │ - |
│ │ │ +bencoded recursion depth limit exceeded |
│ │ │ +
│ │ │ +| limit_exceeded |
│ │ │ +6 |
│ │ │ +bencoded item count limit exceeded |
│ │ │ +
│ │ │ +| overflow |
│ │ │ +7 |
│ │ │ +integer overflow |
│ │ │ +
│ │ │ +| error_code_max |
│ │ │ +8 |
│ │ │ +the number of error codes |
│ │ │
│ │ │
│ │ │
│ │ │ -
[report issue]
│ │ │ +
libtorrent has a plugin interface for implementing extensions to the protocol.
│ │ │ +These can be general extensions for transferring metadata or peer exchange
│ │ │ +extensions, or it could be used to provide a way to customize the protocol
│ │ │ +to fit a particular (closed) network.
│ │ │ +
In short, the plugin interface makes it possible to:
│ │ │ +
│ │ │ +- register extension messages (sent in the extension handshake), see
│ │ │ +extensions.
│ │ │ +- add data and parse data from the extension handshake.
│ │ │ +- send extension messages and standard bittorrent messages.
│ │ │ +- override or block the handling of standard bittorrent messages.
│ │ │ +- save and restore state via the session state
│ │ │ +- see all alerts that are posted
│ │ │ +
│ │ │
│ │ │ -
│ │ │ -
operator<<()
│ │ │ -
Declared in "libtorrent/entry.hpp"
│ │ │ -
│ │ │ -inline std::ostream& operator<< (std::ostream& os, const entry& e);
│ │ │ -
│ │ │ -
prints the bencoded structure to the ostream as a JSON-style structure.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
bencode()
│ │ │ -
Declared in "libtorrent/bencode.hpp"
│ │ │ -
│ │ │ -template<class OutIt> int bencode (OutIt out, const entry& e);
│ │ │ +
│ │ │ +
a word of caution
│ │ │ +
Writing your own plugin is a very easy way to introduce serious bugs such as
│ │ │ +dead locks and race conditions. Since a plugin has access to internal
│ │ │ +structures it is also quite easy to sabotage libtorrent's operation.
│ │ │ +
All the callbacks are always called from the libtorrent network thread. In
│ │ │ +case portions of your plugin are called from other threads, typically the main
│ │ │ +thread, you cannot use any of the member functions on the internal structures
│ │ │ +in libtorrent, since those require being called from the libtorrent network
│ │ │ +thread . Furthermore, you also need to synchronize your own shared data
│ │ │ +within the plugin, to make sure it is not accessed at the same time from the
│ │ │ +libtorrent thread (through a callback). If you need to send out a message
│ │ │ +from another thread, it is advised to use an internal queue, and do the
│ │ │ +actual sending in tick().
│ │ │ +
Since the plugin interface gives you easy access to internal structures, it
│ │ │ +is not supported as a stable API. Plugins should be considered specific to a
│ │ │ +specific version of libtorrent. Although, in practice the internals mostly
│ │ │ +don't change that dramatically.
│ │ │ +
│ │ │ +
plugin-interface
│ │ │ +
The plugin interface consists of three base classes that the plugin may
│ │ │ +implement. These are called plugin, torrent_plugin and peer_plugin.
│ │ │ +They are found in the <libtorrent/extensions.hpp> header.
│ │ │ +
These plugins are instantiated for each session, torrent and possibly each peer,
│ │ │ +respectively.
│ │ │ +
For plugins that only need per torrent state, it is enough to only implement
│ │ │ +torrent_plugin and pass a constructor function or function object to
│ │ │ +session::add_extension() or torrent_handle::add_extension() (if the
│ │ │ +torrent has already been started and you want to hook in the extension at
│ │ │ +run-time).
│ │ │ +
The signature of the function is:
│ │ │ +
│ │ │ +std::shared_ptr<torrent_plugin> (*)(torrent_handle const&, client_data_t);
│ │ │
│ │ │ -
This function will encode data to bencoded form.
│ │ │ -
The entry class is the internal representation of the bencoded data
│ │ │ -and it can be used to retrieve information, an entry can also be build by
│ │ │ -the program and given to bencode() to encode it into the OutIt
│ │ │ -iterator.
│ │ │ -
OutIt is an OutputIterator. It's a template and usually
│ │ │ -instantiated as ostream_iterator or back_insert_iterator. This
│ │ │ -function assumes the value_type of the iterator is a char.
│ │ │ -In order to encode entry e into a buffer, do:
│ │ │ +
The second argument is the userdata passed to session::add_torrent() or
│ │ │ +torrent_handle::add_extension().
│ │ │ +
The function should return a std::shared_ptr<torrent_plugin> which
│ │ │ +may or may not be 0. If it is a nullptr, the extension is simply ignored
│ │ │ +for this torrent. If it is a valid pointer (to a class inheriting
│ │ │ +torrent_plugin), it will be associated with this torrent and callbacks
│ │ │ +will be made on torrent events.
│ │ │ +
For more elaborate plugins which require session wide state, you would
│ │ │ +implement plugin, construct an object (in a std::shared_ptr) and pass
│ │ │ +it in to session::add_extension().
│ │ │ +
│ │ │ +
custom alerts
│ │ │ +
Since plugins are running within internal libtorrent threads, one convenient
│ │ │ +way to communicate with the client is to post custom alerts.
│ │ │ +
The expected interface of any alert, apart from deriving from the alert
│ │ │ +base class, looks like this:
│ │ │
│ │ │ -std::vector<char> buf;
│ │ │ -bencode(std::back_inserter(buf), e);
│ │ │ -
│ │ │ -
This section describes the functions and classes that are used
│ │ │ -to create torrent files. It is a layered API with low level classes
│ │ │ -and higher level convenience functions. A torrent is created in 4
│ │ │ -steps:
│ │ │ -
│ │ │ -- first the files that will be part of the torrent are determined.
│ │ │ -- the torrent properties are set, such as tracker url, web seeds,
│ │ │ -DHT nodes etc.
│ │ │ -- Read through all the files in the torrent, SHA-1 all the data
│ │ │ -and set the piece hashes.
│ │ │ -- The torrent is bencoded into a file or buffer.
│ │ │ -
│ │ │ -
If there are a lot of files and or deep directory hierarchies to
│ │ │ -traverse, step one can be time consuming.
│ │ │ -
Typically step 3 is by far the most time consuming step, since it
│ │ │ -requires to read all the bytes from all the files in the torrent.
│ │ │ -
All of these classes and functions are declared by including
│ │ │ -libtorrent/create_torrent.hpp.
│ │ │ -
example:
│ │ │ -
│ │ │ -file_storage fs;
│ │ │ -
│ │ │ -add_files(fs, "./my_torrent");
│ │ │ -
│ │ │ -create_torrent t(fs);
│ │ │ -t.add_tracker("http://my.tracker.com/announce");
│ │ │ -t.set_creator("libtorrent example");
│ │ │ +static const int alert_type = <unique alert ID>;
│ │ │ +virtual int type() const { return alert_type; }
│ │ │
│ │ │ -set_piece_hashes(t, ".");
│ │ │ +virtual std::string message() const;
│ │ │
│ │ │ -ofstream out("my_torrent.torrent", std::ios_base::binary);
│ │ │ -std::vector<char> buf = t.generate_buf();
│ │ │ -out.write(buf.data(), buf.size());
│ │ │ +static const alert_category_t static_category = <bitmask of alert::category_t flags>;
│ │ │ +virtual alert_category_t category() const { return static_category; }
│ │ │
│ │ │ -bencode(std::ostream_iterator<char>(out), t.generate());
│ │ │ +virtual char const* what() const { return <string literal of the name of this alert>; }
│ │ │
│ │ │ -
[report issue]
│ │ │ -
create_torrent
│ │ │ -
Declared in "libtorrent/create_torrent.hpp"
│ │ │ -
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().
│ │ │ +
The alert_type is used for the type-checking in alert_cast. It must
│ │ │ +not collide with any other alert. The built-in alerts in libtorrent will
│ │ │ +not use alert type IDs greater than user_alert_id. When defining your
│ │ │ +own alert, make sure it's greater than this constant.
│ │ │ +
type() is the run-time equivalence of the alert_type.
│ │ │ +
The message() virtual function is expected to construct a useful
│ │ │ +string representation of the alert and the event or data it represents.
│ │ │ +Something convenient to put in a log file for instance.
│ │ │ +
clone() is used internally to copy alerts. The suggested implementation
│ │ │ +of simply allocating a new instance as a copy of *this is all that's
│ │ │ +expected.
│ │ │ +
The static category is required for checking whether or not the category
│ │ │ +for a specific alert is enabled or not, without instantiating the alert.
│ │ │ +The category virtual function is the run-time equivalence.
│ │ │ +
The what() virtual function may simply be a string literal of the class
│ │ │ +name of your alert.
│ │ │ +
For more information, see the alert section.
│ │ │ +
[report issue]
│ │ │ +
peer_connection_handle
│ │ │ +
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ +
the peer_connection_handle 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 create_torrent
│ │ │ +struct peer_connection_handle
│ │ │ {
│ │ │ - explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ - , create_flags_t flags = {});
│ │ │ - explicit create_torrent (torrent_info const& ti);
│ │ │ - entry generate () const;
│ │ │ - std::vector<char> generate_buf () const;
│ │ │ - file_storage const& files () const;
│ │ │ - void set_comment (char const* str);
│ │ │ - void set_creator (char const* str);
│ │ │ - void set_creation_date (std::time_t timestamp);
│ │ │ - void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ - void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ - void add_http_seed (string_view url);
│ │ │ - void add_url_seed (string_view url);
│ │ │ - void add_node (std::pair<std::string, int> node);
│ │ │ - void add_tracker (string_view url, int tier = 0);
│ │ │ - void set_root_cert (string_view cert);
│ │ │ - bool priv () const;
│ │ │ - void set_priv (bool p);
│ │ │ - bool is_v2_only () const;
│ │ │ - bool is_v1_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);
│ │ │ - void add_collection (string_view c);
│ │ │ -
│ │ │ - 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;
│ │ │ + explicit peer_connection_handle (std::weak_ptr<peer_connection> impl);
│ │ │ + connection_type type () const;
│ │ │ + void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ + peer_plugin const* find_plugin (string_view type) const;
│ │ │ + bool is_seed () const;
│ │ │ + bool upload_only () const;
│ │ │ + peer_id const& pid () const;
│ │ │ + bool has_piece (piece_index_t i) const;
│ │ │ + bool is_interesting () const;
│ │ │ + bool is_choked () const;
│ │ │ + bool is_peer_interested () const;
│ │ │ + bool has_peer_choked () 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 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_outgoing () const;
│ │ │ + bool is_disconnecting () 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;
│ │ │ + std::shared_ptr<peer_connection> native_handle () const;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
create_torrent()
│ │ │ -
│ │ │ -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.
│ │ │ -Piece sizes greater than 128 MiB are considered unreasonable and will
│ │ │ -be rejected (with an lt::system_error exception).
│ │ │ -
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
│ │ │ -their properties for the torrent to be created. Set this up first,
│ │ │ -before passing it to the create_torrent constructor.
│ │ │ -
The overload that takes a torrent_info object will make a verbatim
│ │ │ -copy of its info dictionary (to preserve the info-hash). The copy of
│ │ │ -the info dictionary will be used by create_torrent::generate(). This means
│ │ │ -that none of the member functions of create_torrent that affects
│ │ │ -the content of the info dictionary (such as set_hash()), will
│ │ │ -have any affect. Instead of using this overload, consider using
│ │ │ -write_torrent_file() instead.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
generate_buf() generate()
│ │ │ -
│ │ │ -entry generate () const;
│ │ │ -std::vector<char> generate_buf () const;
│ │ │ -
│ │ │ -
This function will generate the .torrent file as a bencode tree, or a
│ │ │ -bencoded into a buffer.
│ │ │ -In order to encode the entry into a flat file, use the bencode() function.
│ │ │ -
The function returning an entry may be useful to add custom entries
│ │ │ -to the torrent file before bencoding it and saving it to disk.
│ │ │ -
Whether the resulting torrent object is v1, v2 or hybrid depends on
│ │ │ -whether any of the v1_only or v2_only flags were set on the
│ │ │ -constructor. If neither were set, the resulting torrent depends on
│ │ │ -which hashes were set. If both v1 and v2 hashes were set, a hybrid
│ │ │ -torrent is created.
│ │ │ -
Any failure will cause this function to throw system_error, with an
│ │ │ -appropriate error message. These are the reasons this call may throw:
│ │ │ -
│ │ │ -- the file storage has 0 files
│ │ │ -- the total size of the file storage is 0 bytes (i.e. it only has
│ │ │ -empty files)
│ │ │ -- not all v1 hashes (set_hash()) and not all v2 hashes (set_hash2())
│ │ │ -were set
│ │ │ -- for v2 torrents, you may not have a directory with the same name as
│ │ │ -a file. If that's encountered in the file storage, generate()
│ │ │ -fails.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
files()
│ │ │ -
│ │ │ -file_storage const& files () const;
│ │ │ -
│ │ │ -
returns an immutable reference to the file_storage used to create
│ │ │ -the torrent from.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
set_creator()
│ │ │ -
│ │ │ -void set_creator (char const* str);
│ │ │ -
│ │ │ -
Sets the creator of the torrent. The string str should be utf-8 encoded.
│ │ │ -This is optional.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_creation_date()
│ │ │ -
│ │ │ -void set_creation_date (std::time_t timestamp);
│ │ │ -
│ │ │ -
sets the "creation time" field. Defaults to the system clock at the
│ │ │ -time of construction of the create_torrent object. The timestamp is
│ │ │ -specified in seconds, posix time. If the creation date is set to 0,
│ │ │ -the "creation date" field will be omitted from the generated torrent.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_hash()
│ │ │ -
│ │ │ -void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ -
│ │ │ -
This sets the SHA-1 hash for the specified piece (index). You are required
│ │ │ -to set the hash for every piece in the torrent before generating it. If you have
│ │ │ -the files on disk, you can use the high level convenience function to do this.
│ │ │ -See set_piece_hashes().
│ │ │ -A SHA-1 hash of all zeros is internally used to indicate a hash that
│ │ │ -has not been set. Setting such hash will not be considered set when
│ │ │ -calling generate().
│ │ │ -This function will throw std::system_error if it is called on an
│ │ │ -object constructed with the v2_only flag.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_hash2()
│ │ │ -
│ │ │ -void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ -
│ │ │ -
sets the bittorrent v2 hash for file file of the piece piece.
│ │ │ -piece is relative to the first piece of the file, starting at 0. The
│ │ │ -first piece in the file can be computed with
│ │ │ -file_storage::file_index_at_piece().
│ │ │ -The hash, h, is the root of the merkle tree formed by the piece's
│ │ │ -16 kiB blocks. Note that piece sizes must be powers-of-2, so all
│ │ │ -per-piece merkle trees are complete.
│ │ │ -A SHA-256 hash of all zeros is internally used to indicate a hash
│ │ │ -that has not been set. Setting such hash will not be considered set
│ │ │ -when calling generate().
│ │ │ -This function will throw std::system_error if it is called on an
│ │ │ -object constructed with the v1_only flag.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
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.
│ │ │
│ │ │ -void add_http_seed (string_view url);
│ │ │ -void add_url_seed (string_view url);
│ │ │ +struct bt_peer_connection_handle : peer_connection_handle
│ │ │ +{
│ │ │ + explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ + bool support_extensions () const;
│ │ │ + bool packet_finished () const;
│ │ │ + bool supports_encryption () const;
│ │ │ + void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ + void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ + std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ +};
│ │ │
│ │ │ -
This adds a url seed to the torrent. You can have any number of url seeds. For a
│ │ │ -single file torrent, this should be an HTTP url, pointing to a file with identical
│ │ │ -content as the file of the torrent. For a multi-file torrent, it should point to
│ │ │ -a directory containing a directory with the same name as this torrent, and all the
│ │ │ -files of the torrent in it.
│ │ │ -
The second function, add_http_seed() adds an HTTP seed instead.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
plugin
│ │ │ +
Declared in "libtorrent/extensions.hpp"
│ │ │ +
this is the base class for a session plugin. One primary feature
│ │ │ +is that it is notified of all torrents that are added to the session,
│ │ │ +and can add its own torrent_plugins.
│ │ │
│ │ │ -void add_node (std::pair<std::string, int> node);
│ │ │ +struct plugin
│ │ │ +{
│ │ │ + virtual feature_flags_t implemented_features ();
│ │ │ + virtual std::shared_ptr<torrent_plugin> new_torrent (torrent_handle const&, client_data_t);
│ │ │ + virtual void added (session_handle const&);
│ │ │ + virtual void abort ();
│ │ │ + virtual bool on_dht_request (string_view /* query */
│ │ │ + , udp::endpoint const& /* source */, bdecode_node const& /* message */
│ │ │ + , entry& /* response */);
│ │ │ + virtual void on_alert (alert const*);
│ │ │ + virtual bool on_unknown_torrent (info_hash_t const& /* info_hash */
│ │ │ + , peer_connection_handle const& /* pc */, add_torrent_params& /* p */);
│ │ │ + virtual void on_tick ();
│ │ │ + virtual uint64_t get_unchoke_priority (peer_connection_handle const& /* peer */);
│ │ │ + virtual std::map<std::string, std::string> save_state () const;
│ │ │ + virtual void load_state (std::map<std::string, std::string> const&);
│ │ │ +
│ │ │ + static constexpr feature_flags_t optimistic_unchoke_feature = 1_bit;
│ │ │ + static constexpr feature_flags_t tick_feature = 2_bit;
│ │ │ + static constexpr feature_flags_t dht_request_feature = 3_bit;
│ │ │ + static constexpr feature_flags_t alert_feature = 4_bit;
│ │ │ + static constexpr feature_flags_t unknown_torrent_feature = 5_bit;
│ │ │ +};
│ │ │
│ │ │ -
This adds a DHT node to the torrent. This especially useful if you're creating a
│ │ │ -tracker less torrent. It can be used by clients to bootstrap their DHT node from.
│ │ │ -The node is a hostname and a port number where there is a DHT node running.
│ │ │ -You can have any number of DHT nodes in a torrent.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
add_tracker()
│ │ │ +
[report issue]
│ │ │ +
implemented_features()
│ │ │
│ │ │ -void add_tracker (string_view url, int tier = 0);
│ │ │ +virtual feature_flags_t implemented_features ();
│ │ │
│ │ │ -
Adds a tracker to the torrent. This is not strictly required, but most torrents
│ │ │ -use a tracker as their main source of peers. The url should be an http:// or udp://
│ │ │ -url to a machine running a bittorrent tracker that accepts announces for this torrent's
│ │ │ -info-hash. The tier is the fallback priority of the tracker. All trackers with tier 0 are
│ │ │ -tried first (in any order). If all fail, trackers with tier 1 are tried. If all of those
│ │ │ -fail, trackers with tier 2 are tried, and so on.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_root_cert()
│ │ │ +
This function is expected to return a bitmask indicating which features
│ │ │ +this plugin implements. Some callbacks on this object may not be called
│ │ │ +unless the corresponding feature flag is returned here. Note that
│ │ │ +callbacks may still be called even if the corresponding feature is not
│ │ │ +specified in the return value here. See feature_flags_t for possible
│ │ │ +flags to return.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
new_torrent()
│ │ │
│ │ │ -void set_root_cert (string_view cert);
│ │ │ +virtual std::shared_ptr<torrent_plugin> new_torrent (torrent_handle const&, client_data_t);
│ │ │
│ │ │ -
This function sets an X.509 certificate in PEM format to the torrent. This makes the
│ │ │ -torrent an SSL torrent. An SSL torrent requires that each peer has a valid certificate
│ │ │ -signed by this root certificate. For SSL torrents, all peers are connecting over SSL
│ │ │ -connections. For more information, see the section on ssl torrents.
│ │ │ -
The string is not the path to the cert, it's the actual content of the
│ │ │ -certificate.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_priv() priv()
│ │ │ +
this is called by the session every time a new torrent is added.
│ │ │ +The torrent* points to the internal torrent object created
│ │ │ +for the new torrent. The client_data_t is the userdata pointer as
│ │ │ +passed in via add_torrent_params.
│ │ │ +
If the plugin returns a torrent_plugin instance, it will be added
│ │ │ +to the new torrent. Otherwise, return an empty shared_ptr to a
│ │ │ +torrent_plugin (the default).
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
added()
│ │ │
│ │ │ -bool priv () const;
│ │ │ -void set_priv (bool p);
│ │ │ +virtual void added (session_handle const&);
│ │ │
│ │ │ -
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]
│ │ │ -
│ │ │ +
│ │ │ +
abort()
│ │ │
│ │ │ -int num_pieces () const;
│ │ │ +virtual void abort ();
│ │ │
│ │ │ -
returns the number of pieces in the associated file_storage object.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
piece_range()
│ │ │ +
called when the session is aborted
│ │ │ +the plugin should perform any cleanup necessary to allow the session's
│ │ │ +destruction (e.g. cancel outstanding async operations)
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_dht_request()
│ │ │
│ │ │ -index_range<piece_index_t> piece_range () const noexcept;
│ │ │ +virtual bool on_dht_request (string_view /* query */
│ │ │ + , udp::endpoint const& /* source */, bdecode_node const& /* message */
│ │ │ + , entry& /* response */);
│ │ │
│ │ │ -
all piece indices in the torrent to be created
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
file_range()
│ │ │ +
called when a dht request is received.
│ │ │ +If your plugin expects this to be called, make sure to include the flag
│ │ │ +dht_request_feature in the return value from implemented_features().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_alert()
│ │ │
│ │ │ -index_range<file_index_t> file_range () const noexcept;
│ │ │ +virtual void on_alert (alert const*);
│ │ │
│ │ │ -
all file indices in the torrent to be created
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
file_piece_range()
│ │ │ +
called when an alert is posted alerts that are filtered are not posted.
│ │ │ +If your plugin expects this to be called, make sure to include the flag
│ │ │ +alert_feature in the return value from implemented_features().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_unknown_torrent()
│ │ │
│ │ │ -index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ +virtual bool on_unknown_torrent (info_hash_t const& /* info_hash */
│ │ │ + , peer_connection_handle const& /* pc */, add_torrent_params& /* p */);
│ │ │
│ │ │ -
for v2 and hybrid torrents only, the pieces in the
│ │ │ -specified file, specified as delta from the first piece in the file.
│ │ │ -i.e. the first index is 0.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
on_tick()
│ │ │
│ │ │ -std::int64_t total_size () const;
│ │ │ +virtual void on_tick ();
│ │ │
│ │ │ -
the total number of bytes of all files and pad files
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
piece_length() piece_size()
│ │ │ +
called once per second.
│ │ │ +If your plugin expects this to be called, make sure to include the flag
│ │ │ +tick_feature in the return value from implemented_features().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get_unchoke_priority()
│ │ │
│ │ │ -int piece_size (piece_index_t i) const;
│ │ │ -int piece_length () const;
│ │ │ +virtual uint64_t get_unchoke_priority (peer_connection_handle const& /* peer */);
│ │ │
│ │ │ -
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()
│ │ │ +
called when choosing peers to optimistically unchoke. The return value
│ │ │ +indicates the peer's priority for unchoking. Lower return values
│ │ │ +correspond to higher priority. Priorities above 2^63-1 are reserved.
│ │ │ +If your plugin has no priority to assign a peer it should return 2^64-1.
│ │ │ +If your plugin expects this to be called, make sure to include the flag
│ │ │ +optimistic_unchoke_feature in the return value from implemented_features().
│ │ │ +If multiple plugins implement this function the lowest return value
│ │ │ +(i.e. the highest priority) is used.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
load_state()
│ │ │
│ │ │ -void add_similar_torrent (sha1_hash ih);
│ │ │ -void add_collection (string_view c);
│ │ │ +virtual void load_state (std::map<std::string, std::string> const&);
│ │ │
│ │ │ -
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.
│ │ │ -
[report issue]
│ │ │ -- modification_time
│ │ │ -- This will include the file modification time as part of the torrent.
│ │ │ -This is not enabled by default, as it might cause problems when you
│ │ │ -create a torrent from separate files with the same content, hoping to
│ │ │ -yield the same info-hash. If the files have different modification times,
│ │ │ -with this option enabled, you would get different info-hashes for the
│ │ │ -files.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- symlinks
│ │ │ -- If this flag is set, files that are symlinks get a symlink attribute
│ │ │ -set on them and their data will not be included in the torrent. This
│ │ │ -is useful if you need to reconstruct a file hierarchy which contains
│ │ │ -symlinks.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- v2_only
│ │ │ -- Do not generate v1 metadata. The resulting torrent will only be usable by
│ │ │ -clients which support v2. This requires setting all v2 hashes, with
│ │ │ -set_hash2() before calling generate(). Setting v1 hashes (with
│ │ │ -set_hash()) is an error with this flag set.
│ │ │ +called on startup while loading settings state from the session_params
│ │ │ +[report issue]
│ │ │ +- optimistic_unchoke_feature
│ │ │ +- include this bit if your plugin needs to alter the order of the
│ │ │ +optimistic unchoke of peers. i.e. have the on_optimistic_unchoke()
│ │ │ +callback be called.
│ │ │
│ │ │ -[report issue]
│ │ │ -- v1_only
│ │ │ -- do not generate v2 metadata or enforce v2 alignment and padding rules
│ │ │ -this is mainly for tests, not recommended for production use. This
│ │ │ -requires setting all v1 hashes, with set_hash(), before calling
│ │ │ -generate(). Setting v2 hashes (with set_hash2()) is an error with
│ │ │ -this flag set.
│ │ │ +[report issue]
│ │ │ +- tick_feature
│ │ │ +- include this bit if your plugin needs to have on_tick() called
│ │ │
│ │ │ -[report issue]
│ │ │ -- canonical_files
│ │ │ -- This flag only affects v1-only torrents, and is only relevant
│ │ │ -together with the v1_only_flag. This flag will force the
│ │ │ -same file order and padding as a v2 (or hybrid) torrent would have.
│ │ │ -It has the effect of ordering files and inserting pad files to align
│ │ │ -them with piece boundaries.
│ │ │ +[report issue]
│ │ │ +- dht_request_feature
│ │ │ +- include this bit if your plugin needs to have on_dht_request()
│ │ │ +called
│ │ │
│ │ │ -[report issue]
│ │ │ -- no_attributes
│ │ │ -- passing this flag to add_files() will ignore file attributes (such as
│ │ │ -executable or hidden) when adding the files to the file storage.
│ │ │ -Since not all filesystems and operating systems support all file
│ │ │ -attributes the resulting torrent may differ depending on where it's
│ │ │ -created. If it's important for torrents to be created consistently
│ │ │ -across systems, this flag should be set.
│ │ │ +[report issue]
│ │ │ +- alert_feature
│ │ │ +- include this bit if your plugin needs to have on_alert()
│ │ │ +called
│ │ │
│ │ │ -[report issue]
│ │ │ -- canonical_files_no_tail_padding
│ │ │ -- this flag enforces the file layout to be canonical according to the
│ │ │ -bittorrent v2 specification (just like the canonical_files flag)
│ │ │ -with the one exception that tail padding is not added to the last
│ │ │ -file.
│ │ │ -This behavior deviates from the specification but was the way
│ │ │ -libtorrent created torrents in version up to and including 2.0.7.
│ │ │ -This flag is here for backwards compatibility.
│ │ │ +[report issue]
│ │ │ +- unknown_torrent_feature
│ │ │ +- include this bit if your plugin needs to have on_unknown_torrent()
│ │ │ +called even if there is no active torrent in the session
│ │ │
│ │ │ -[report issue]
│ │ │ +
[report issue]
│ │ │
│ │ │ -
add_files()
│ │ │ -
Declared in "libtorrent/create_torrent.hpp"
│ │ │ -
│ │ │ -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:
│ │ │ -
│ │ │ -bool Pred(std::string const& p);
│ │ │ -
│ │ │ -
The path that is passed in to the predicate is the full path of the file or
│ │ │ -directory. If no predicate is specified, all files are added, and all directories
│ │ │ -are traversed.
│ │ │ -
The ".." directory is never traversed.
│ │ │ -
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"
│ │ │ -
│ │ │ -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
│ │ │ - , std::function<void(piece_index_t)> const& f);
│ │ │ -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);
│ │ │ -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);
│ │ │ -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);
│ │ │ -
│ │ │ -
The overloads taking a settings_pack may be used to configure the
│ │ │ -underlying disk access. Such as settings_pack::aio_threads.
│ │ │ -
The overloads that don't take an error_code& may throw an exception in case of a
│ │ │ -file error, the other overloads sets the error code to reflect the error, if any.
│ │ │ -
[report issue]
│ │ │ -
bitfield
│ │ │ -
Declared in "libtorrent/bitfield.hpp"
│ │ │ -
The bitfield type stores any number of bits as a bitfield
│ │ │ -in a heap allocated array.
│ │ │ +
│ │ │ +
torrent_plugin
│ │ │ +
Declared in "libtorrent/extensions.hpp"
│ │ │ +
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 bitfield
│ │ │ +struct torrent_plugin
│ │ │ {
│ │ │ - bitfield (char const* b, int bits);
│ │ │ - bitfield (bitfield const& rhs);
│ │ │ - bitfield (int bits, bool val);
│ │ │ - bitfield () noexcept = default;
│ │ │ - bitfield (bitfield&& rhs) noexcept = default;
│ │ │ - explicit bitfield (int bits);
│ │ │ - void assign (char const* b, int const bits);
│ │ │ - 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;
│ │ │ - 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;
│ │ │ + 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 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;
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -
bitfield()
│ │ │ -
│ │ │ -bitfield (char const* b, int bits);
│ │ │ -bitfield (bitfield const& rhs);
│ │ │ -bitfield (int bits, bool val);
│ │ │ -bitfield () noexcept = default;
│ │ │ -bitfield (bitfield&& rhs) noexcept = default;
│ │ │ -explicit bitfield (int bits);
│ │ │ -
│ │ │ -
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
│ │ │ -the nearest byte boundary).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
assign()
│ │ │ +
[report issue]
│ │ │ +
new_connection()
│ │ │
│ │ │ -void assign (char const* b, int const bits);
│ │ │ +virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │
│ │ │ -
copy bitfield from buffer b of bits number of bits, rounded up to
│ │ │ -the nearest byte boundary.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
operator[]() get_bit()
│ │ │ +
This function is called each time a new peer is connected to the torrent. You
│ │ │ +may choose to ignore this by just returning a default constructed
│ │ │ +shared_ptr (in which case you don't need to override this member
│ │ │ +function).
│ │ │ +
If you need an extension to the peer connection (which most plugins do) you
│ │ │ +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_failed() on_piece_pass()
│ │ │
│ │ │ -bool get_bit (int index) const noexcept;
│ │ │ -bool operator[] (int index) const noexcept;
│ │ │ +virtual void on_piece_pass (piece_index_t);
│ │ │ +virtual void on_piece_failed (piece_index_t);
│ │ │
│ │ │ -
query bit at index. Returns true if bit is 1, otherwise false.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
set_bit() clear_bit()
│ │ │ +
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]
│ │ │ +
│ │ │ +
tick()
│ │ │
│ │ │ -void set_bit (int index) noexcept;
│ │ │ -void clear_bit (int index) noexcept;
│ │ │ +virtual void tick ();
│ │ │
│ │ │ -
set bit at index to 0 (clear_bit) or 1 (set_bit).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
all_set()
│ │ │ +
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()
│ │ │
│ │ │ -bool all_set () const noexcept;
│ │ │ +virtual bool on_resume ();
│ │ │ +virtual bool on_pause ();
│ │ │
│ │ │ -
returns true if all bits in the bitfield are set
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
none_set()
│ │ │ +
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.
│ │ │ +
Note that if you call pause() or resume() on the torrent from your
│ │ │ +handler it will recurse back into your handler, so in order to invoke the
│ │ │ +standard handler, you have to keep your own state on whether you want standard
│ │ │ +behavior or overridden behavior.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_files_checked()
│ │ │
│ │ │ -bool none_set () const noexcept;
│ │ │ +virtual void on_files_checked ();
│ │ │
│ │ │ -
returns true if no bit in the bitfield is set
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
size()
│ │ │ +
This function is called when the initial files of the torrent have been
│ │ │ +checked. If there are no files to check, this function is called immediately.
│ │ │ +
i.e. This function is always called when the torrent is in a state where it
│ │ │ +can start downloading.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_state()
│ │ │
│ │ │ -int size () const noexcept;
│ │ │ +virtual void on_state (torrent_status::state_t);
│ │ │
│ │ │ -
returns the size of the bitfield in bits.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ +
│ │ │ +
on_add_peer()
│ │ │
│ │ │ -int num_words () const noexcept;
│ │ │ +virtual void on_add_peer (tcp::endpoint const&,
│ │ │ + peer_source_flags_t, add_peer_flags_t);
│ │ │
│ │ │ -
returns the number of 32 bit words are needed to represent all bits in
│ │ │ -this bitfield.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
num_bytes()
│ │ │ +
called every time a new peer is added to the peer list.
│ │ │ +This is before the peer is connected to. For flags, see
│ │ │ +torrent_plugin::flags_t. The source argument refers to
│ │ │ +the source where we learned about this peer from. It's a
│ │ │ +bitmask, because many sources may have told us about the same
│ │ │ +peer. For peer source flags, see peer_info::peer_source_flags.
│ │ │ +
[report issue]
│ │ │ +- first_time
│ │ │ +- this is the first time we see this peer
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- filtered
│ │ │ +- this peer was not added because it was
│ │ │ +filtered by the IP filter
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
peer_plugin
│ │ │ +
Declared in "libtorrent/extensions.hpp"
│ │ │ +
peer plugins are associated with a specific peer. A peer could be
│ │ │ +both a regular bittorrent peer (bt_peer_connection) or one of the
│ │ │ +web seed connections (web_peer_connection or http_seed_connection).
│ │ │ +In order to only attach to certain peers, make your
│ │ │ +torrent_plugin::new_connection only return a plugin for certain peer
│ │ │ +connection types
│ │ │
│ │ │ -int num_bytes () const noexcept;
│ │ │ +struct peer_plugin
│ │ │ +{
│ │ │ + 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_not_interested ();
│ │ │ + virtual bool on_request (peer_request const&);
│ │ │ + virtual bool on_interested ();
│ │ │ + virtual bool on_dont_have (piece_index_t);
│ │ │ + virtual bool on_choke ();
│ │ │ + virtual bool on_allowed_fast (piece_index_t);
│ │ │ + virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ + virtual bool on_unchoke ();
│ │ │ + virtual bool on_have_none ();
│ │ │ + virtual bool on_have_all ();
│ │ │ + virtual bool on_have (piece_index_t);
│ │ │ + virtual bool on_piece (peer_request const& /*piece*/
│ │ │ + , span<char const> /*buf*/);
│ │ │ + virtual bool on_cancel (peer_request const&);
│ │ │ + virtual bool on_reject (peer_request const&);
│ │ │ + virtual bool on_suggest (piece_index_t);
│ │ │ + virtual void sent_choke ();
│ │ │ + virtual void sent_have_all ();
│ │ │ + virtual void sent_suggest (piece_index_t);
│ │ │ + virtual void sent_reject_request (peer_request const&);
│ │ │ + virtual void sent_cancel (peer_request const&);
│ │ │ + virtual void sent_request (peer_request const&);
│ │ │ + virtual void sent_allow_fast (piece_index_t);
│ │ │ + virtual void sent_have_none ();
│ │ │ + virtual void sent_have (piece_index_t);
│ │ │ + virtual void sent_not_interested ();
│ │ │ + virtual void sent_piece (peer_request const&);
│ │ │ + virtual void sent_interested ();
│ │ │ + virtual void sent_unchoke ();
│ │ │ + 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 tick ();
│ │ │ + virtual bool write_request (peer_request const&);
│ │ │ +};
│ │ │
│ │ │ -
returns the number of bytes needed to represent all bits in this
│ │ │ -bitfield
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
empty()
│ │ │ +
[report issue]
│ │ │ +
type()
│ │ │
│ │ │ -bool empty () const noexcept;
│ │ │ +virtual string_view type () const;
│ │ │
│ │ │ -
returns true if the bitfield has zero size.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
data()
│ │ │ +
This function is expected to return the name of
│ │ │ +the plugin.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_handshake()
│ │ │
│ │ │ -char const* data () const noexcept;
│ │ │ -char* data () noexcept;
│ │ │ +virtual void add_handshake (entry&);
│ │ │
│ │ │ -
returns a pointer to the internal buffer of the bitfield, or
│ │ │ -nullptr if it's empty.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
swap()
│ │ │ +
can add entries to the extension handshake
│ │ │ +this is not called for web seeds
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_disconnect()
│ │ │
│ │ │ -void swap (bitfield& rhs) noexcept;
│ │ │ +virtual void on_disconnect (error_code const&);
│ │ │
│ │ │ -
swaps the bit-fields two variables refer to
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
count()
│ │ │ +
called when the peer is being disconnected.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_connected()
│ │ │
│ │ │ -int count () const noexcept;
│ │ │ +virtual void on_connected ();
│ │ │
│ │ │ -
count the number of bits in the bitfield that are set to 1.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
find_first_set()
│ │ │ +
called when the peer is successfully connected. Note that
│ │ │ +incoming connections will have been connected by the time
│ │ │ +the peer plugin is attached to it, and won't have this hook
│ │ │ +called.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_handshake()
│ │ │
│ │ │ -int find_first_set () const noexcept;
│ │ │ +virtual bool on_handshake (span<char const>);
│ │ │
│ │ │ -
returns the index of the first set bit in the bitfield, i.e. 1 bit.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
find_last_clear()
│ │ │ +
this is called when the initial bittorrent handshake is received.
│ │ │ +Returning false means that the other end doesn't support this extension
│ │ │ +and will remove it from the list of plugins. this is not called for web
│ │ │ +seeds
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_extension_handshake()
│ │ │
│ │ │ -int find_last_clear () const noexcept;
│ │ │ +virtual bool on_extension_handshake (bdecode_node const&);
│ │ │
│ │ │ -
returns the index to the last cleared bit in the bitfield, i.e. 0 bit.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
hasher
│ │ │ -
Declared in "libtorrent/hasher.hpp"
│ │ │ -
this is a SHA-1 hash class.
│ │ │ -
You use it by first instantiating it, then call update() to feed it
│ │ │ -with data. i.e. you don't have to keep the entire buffer of which you want to
│ │ │ -create the hash in memory. You can feed the hasher parts of it at a time. When
│ │ │ -You have fed the hasher with all the data, you call final() and it
│ │ │ -will return the sha1-hash of the data.
│ │ │ -
The constructor that takes a char const* and an integer will construct the
│ │ │ -sha1 context and feed it the data passed in.
│ │ │ -
If you want to reuse the hasher 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.
│ │ │ +
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_allowed_fast() on_bitfield() on_interested() on_unchoke() on_choke() on_dont_have() on_request() on_have_all() on_not_interested() on_have()
│ │ │
│ │ │ -class hasher
│ │ │ -{
│ │ │ - hasher ();
│ │ │ - hasher& operator= (hasher const&) &;
│ │ │ - hasher (char const* data, int len);
│ │ │ - hasher (hasher const&);
│ │ │ - explicit hasher (span<char const> data);
│ │ │ - hasher& update (char const* data, int len);
│ │ │ - hasher& update (span<char const> data);
│ │ │ - sha1_hash final ();
│ │ │ - void reset ();
│ │ │ -};
│ │ │ +virtual bool on_not_interested ();
│ │ │ +virtual bool on_request (peer_request const&);
│ │ │ +virtual bool on_interested ();
│ │ │ +virtual bool on_dont_have (piece_index_t);
│ │ │ +virtual bool on_choke ();
│ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ +virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ +virtual bool on_unchoke ();
│ │ │ +virtual bool on_have_none ();
│ │ │ +virtual bool on_have_all ();
│ │ │ +virtual bool on_have (piece_index_t);
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
hasher() operator=()
│ │ │ +
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]
│ │ │ +
│ │ │ +
on_piece()
│ │ │
│ │ │ -hasher& operator= (hasher const&) &;
│ │ │ -hasher (char const* data, int len);
│ │ │ -hasher (hasher const&);
│ │ │ -explicit hasher (span<char const> data);
│ │ │ +virtual bool on_piece (peer_request const& /*piece*/
│ │ │ + , span<char const> /*buf*/);
│ │ │
│ │ │ -
this is the same as default constructing followed by a call to
│ │ │ -update(data, len).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
update()
│ │ │ +
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_unchoke() sent_have() sent_piece() sent_not_interested() sent_interested()
│ │ │
│ │ │ -hasher& update (char const* data, int len);
│ │ │ -hasher& update (span<char const> data);
│ │ │ +virtual void sent_have (piece_index_t);
│ │ │ +virtual void sent_not_interested ();
│ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ +virtual void sent_interested ();
│ │ │ +virtual void sent_unchoke ();
│ │ │
│ │ │ -
append the following bytes to what is being hashed
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
final()
│ │ │ +
called after a choke message has been sent to the peer
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
sent_payload()
│ │ │
│ │ │ -sha1_hash final ();
│ │ │ +virtual void sent_payload (int /* bytes */);
│ │ │
│ │ │ -
returns the SHA-1 digest of the buffers previously passed to
│ │ │ -update() and the hasher constructor.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
reset()
│ │ │ +
called after piece data has been sent to the peer
│ │ │ +this can be used for stats book keeping
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
can_disconnect()
│ │ │
│ │ │ -void reset ();
│ │ │ +virtual bool can_disconnect (error_code const& /*ec*/);
│ │ │
│ │ │ -
restore the hasher state to be as if the hasher has just been
│ │ │ -default constructed.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
│ │ │ -
hasher256
│ │ │ -
Declared in "libtorrent/hasher.hpp"
│ │ │ +
called when libtorrent think this peer should be disconnected.
│ │ │ +if the plugin returns false, the peer will not be disconnected.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_extended()
│ │ │
│ │ │ -class hasher256
│ │ │ -{
│ │ │ - hasher256 ();
│ │ │ - hasher256& operator= (hasher256 const&) &;
│ │ │ - hasher256 (char const* data, int len);
│ │ │ - hasher256 (hasher256 const&);
│ │ │ - explicit hasher256 (span<char const> data);
│ │ │ - hasher256& update (span<char const> data);
│ │ │ - hasher256& update (char const* data, int len);
│ │ │ - sha256_hash final ();
│ │ │ - void reset ();
│ │ │ - ~hasher256 ();
│ │ │ -};
│ │ │ +virtual bool on_extended (int /*length*/, int /*msg*/,
│ │ │ + span<char const> /*body*/);
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
hasher256() operator=()
│ │ │ +
called when an extended message is received. If returning true,
│ │ │ +the message is not processed by any other plugin and if false
│ │ │ +is returned the next plugin in the chain will receive it to
│ │ │ +be able to handle it. This is not called for web seeds.
│ │ │ +thus function may be called more than once per incoming message, but
│ │ │ +only the last of the calls will the body size equal the length.
│ │ │ +i.e. Every time another fragment of the message is received, this
│ │ │ +function will be called, until finally the whole message has been
│ │ │ +received. The purpose of this is to allow early disconnects for invalid
│ │ │ +messages and for reporting progress of receiving large messages.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_unknown_message()
│ │ │
│ │ │ -hasher256& operator= (hasher256 const&) &;
│ │ │ -hasher256 (char const* data, int len);
│ │ │ -hasher256 (hasher256 const&);
│ │ │ -explicit hasher256 (span<char const> data);
│ │ │ +virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ + span<char const> /*body*/);
│ │ │
│ │ │ -
this is the same as default constructing followed by a call to
│ │ │ -update(data, len).
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
update()
│ │ │ +
this is not called for web seeds
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
on_piece_failed() on_piece_pass()
│ │ │
│ │ │ -hasher256& update (span<char const> data);
│ │ │ -hasher256& update (char const* data, int len);
│ │ │ +virtual void on_piece_pass (piece_index_t);
│ │ │ +virtual void on_piece_failed (piece_index_t);
│ │ │
│ │ │ -
append the following bytes to what is being hashed
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
final()
│ │ │ +
called when a piece that this peer participated in either
│ │ │ +fails or passes the hash_check
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
tick()
│ │ │
│ │ │ -sha256_hash final ();
│ │ │ +virtual void tick ();
│ │ │
│ │ │ -
returns the SHA-1 digest of the buffers previously passed to
│ │ │ -update() and the hasher constructor.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
reset()
│ │ │ +
called approximately once every second
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
write_request()
│ │ │
│ │ │ -void reset ();
│ │ │ +virtual bool write_request (peer_request const&);
│ │ │
│ │ │ -
restore the hasher state to be as if the hasher has just been
│ │ │ -default constructed.
│ │ │ -
[report issue]
│ │ │ +
called each time a request message is to be sent. If true
│ │ │ +is returned, the original request message won't be sent and
│ │ │ +no other plugin will have this function called.
│ │ │ +
[report issue]
│ │ │
│ │ │ -
│ │ │ -
torrent_status
│ │ │ -
Declared in "libtorrent/torrent_status.hpp"
│ │ │ -
holds a snapshot of the status of a torrent, as queried by
│ │ │ -torrent_handle::status().
│ │ │ +
│ │ │ +
crypto_plugin
│ │ │ +
Declared in "libtorrent/extensions.hpp"
│ │ │
│ │ │ -struct torrent_status
│ │ │ +struct crypto_plugin
│ │ │ {
│ │ │ - bool operator== (torrent_status const& st) const;
│ │ │ -
│ │ │ - enum state_t
│ │ │ - {
│ │ │ - checking_files,
│ │ │ - downloading_metadata,
│ │ │ - downloading,
│ │ │ - finished,
│ │ │ - seeding,
│ │ │ - unused_enum_for_backwards_compatibility_allocating,
│ │ │ - checking_resume_data,
│ │ │ - };
│ │ │ -
│ │ │ - torrent_handle handle;
│ │ │ - error_code errc;
│ │ │ - file_index_t error_file = torrent_status::error_file_none;
│ │ │ - static constexpr file_index_t error_file_none {-1};
│ │ │ - static constexpr file_index_t error_file_ssl_ctx {-3};
│ │ │ - static constexpr file_index_t error_file_metadata {-4};
│ │ │ - static constexpr file_index_t error_file_exception {-5};
│ │ │ - static constexpr file_index_t error_file_partfile {-6};
│ │ │ - std::string save_path;
│ │ │ - std::string name;
│ │ │ - std::weak_ptr<const torrent_info> torrent_file;
│ │ │ - time_duration next_announce = seconds{0};
│ │ │ - std::string current_tracker;
│ │ │ - std::int64_t total_download = 0;
│ │ │ - std::int64_t total_upload = 0;
│ │ │ - std::int64_t total_payload_download = 0;
│ │ │ - std::int64_t total_payload_upload = 0;
│ │ │ - std::int64_t total_failed_bytes = 0;
│ │ │ - std::int64_t total_redundant_bytes = 0;
│ │ │ - typed_bitfield<piece_index_t> pieces;
│ │ │ - typed_bitfield<piece_index_t> verified_pieces;
│ │ │ - std::int64_t total_done = 0;
│ │ │ - std::int64_t total = 0;
│ │ │ - std::int64_t total_wanted_done = 0;
│ │ │ - std::int64_t total_wanted = 0;
│ │ │ - std::int64_t all_time_upload = 0;
│ │ │ - std::int64_t all_time_download = 0;
│ │ │ - std::time_t added_time = 0;
│ │ │ - std::time_t completed_time = 0;
│ │ │ - std::time_t last_seen_complete = 0;
│ │ │ - storage_mode_t storage_mode = storage_mode_sparse;
│ │ │ - float progress = 0.f;
│ │ │ - int progress_ppm = 0;
│ │ │ - queue_position_t queue_position {};
│ │ │ - int download_rate = 0;
│ │ │ - int upload_rate = 0;
│ │ │ - int download_payload_rate = 0;
│ │ │ - int upload_payload_rate = 0;
│ │ │ - int num_seeds = 0;
│ │ │ - int num_peers = 0;
│ │ │ - int num_complete = -1;
│ │ │ - int num_incomplete = -1;
│ │ │ - int list_seeds = 0;
│ │ │ - int list_peers = 0;
│ │ │ - int connect_candidates = 0;
│ │ │ - int num_pieces = 0;
│ │ │ - int distributed_full_copies = 0;
│ │ │ - int distributed_fraction = 0;
│ │ │ - float distributed_copies = 0.f;
│ │ │ - int block_size = 0;
│ │ │ - int num_uploads = 0;
│ │ │ - int num_connections = 0;
│ │ │ - int uploads_limit = 0;
│ │ │ - int connections_limit = 0;
│ │ │ - int up_bandwidth_queue = 0;
│ │ │ - int down_bandwidth_queue = 0;
│ │ │ - int seed_rank = 0;
│ │ │ - state_t state = checking_resume_data;
│ │ │ - bool need_save_resume = false;
│ │ │ - bool is_seeding = false;
│ │ │ - bool is_finished = false;
│ │ │ - bool has_metadata = false;
│ │ │ - bool has_incoming = false;
│ │ │ - bool moving_storage = false;
│ │ │ - bool announcing_to_trackers = false;
│ │ │ - bool announcing_to_lsd = false;
│ │ │ - bool announcing_to_dht = false;
│ │ │ - info_hash_t info_hashes;
│ │ │ - time_point last_upload;
│ │ │ - time_point last_download;
│ │ │ - seconds active_duration;
│ │ │ - seconds finished_duration;
│ │ │ - seconds seeding_duration;
│ │ │ - torrent_flags_t flags {};
│ │ │ + 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]
│ │ │ -
operator==()
│ │ │ +
[report issue]
│ │ │ +
decrypt()
│ │ │
│ │ │ -bool operator== (torrent_status const& st) const;
│ │ │ +virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │
│ │ │ -
compares if the torrent status objects come from the same torrent. i.e.
│ │ │ -only the torrent_handle field is compared.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
enum state_t
│ │ │ -
Declared in "libtorrent/torrent_status.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| checking_files |
│ │ │ -1 |
│ │ │ -The torrent has not started its download yet, and is
│ │ │ -currently checking existing files. |
│ │ │ -
│ │ │ -| downloading_metadata |
│ │ │ -2 |
│ │ │ -The torrent is trying to download metadata from peers.
│ │ │ -This implies the ut_metadata extension is in use. |
│ │ │ -
│ │ │ -| downloading |
│ │ │ -3 |
│ │ │ -The torrent is being downloaded. This is the state
│ │ │ -most torrents will be in most of the time. The progress
│ │ │ -meter will tell how much of the files that has been
│ │ │ -downloaded. |
│ │ │ -
│ │ │ -| finished |
│ │ │ -4 |
│ │ │ -In this state the torrent has finished downloading but
│ │ │ -still doesn't have the entire torrent. i.e. some pieces
│ │ │ -are filtered and won't get downloaded. |
│ │ │ -
│ │ │ -| seeding |
│ │ │ -5 |
│ │ │ -In this state the torrent has finished downloading and
│ │ │ -is a pure seeder. |
│ │ │ -
│ │ │ -| unused_enum_for_backwards_compatibility_allocating |
│ │ │ -6 |
│ │ │ -If the torrent was started in full allocation mode, this
│ │ │ -indicates that the (disk) storage for the torrent is
│ │ │ -allocated. |
│ │ │ -
│ │ │ -| checking_resume_data |
│ │ │ -7 |
│ │ │ -The torrent is currently checking the fast resume data and
│ │ │ -comparing it to the files on disk. This is typically
│ │ │ -completed in a fraction of a second, but if you add a
│ │ │ -large number of torrents at once, they will queue up. |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- handle
│ │ │ -- a handle to the torrent whose status the object represents.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- errc
│ │ │ -- may be set to an error code describing why the torrent was paused, in
│ │ │ -case it was paused by an error. If the torrent is not paused or if it's
│ │ │ -paused but not because of an error, this error_code is not set.
│ │ │ -if the error is attributed specifically to a file, error_file is set to
│ │ │ -the index of that file in the .torrent file.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- error_file
│ │ │ -- if the torrent is stopped because of an disk I/O error, this field
│ │ │ -contains the index of the file in the torrent that encountered the
│ │ │ -error. If the error did not originate in a file in the torrent, there
│ │ │ -are a few special values this can be set to: error_file_none,
│ │ │ -error_file_ssl_ctx, error_file_exception, error_file_partfile or
│ │ │ -error_file_metadata;
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- error_file_none
│ │ │ -- special values for error_file to describe which file or component
│ │ │ -encountered the error (errc).
│ │ │ -the error did not occur on a file
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- error_file_ssl_ctx
│ │ │ -- the error occurred setting up the SSL context
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- error_file_metadata
│ │ │ -- the error occurred while loading the metadata for the torrent
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- error_file_exception
│ │ │ -- there was a serious error reported in this torrent. The error code
│ │ │ -or a torrent log alert may provide more information.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- error_file_partfile
│ │ │ -- the error occurred with the partfile
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- save_path
│ │ │ -- the path to the directory where this torrent's files are stored.
│ │ │ -It's typically the path as was given to async_add_torrent() or
│ │ │ -add_torrent() when this torrent was started. This field is only
│ │ │ -included if the torrent status is queried with
│ │ │ -torrent_handle::query_save_path.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- name
│ │ │ -- the name of the torrent. Typically this is derived from the
│ │ │ -.torrent file. In case the torrent was started without metadata,
│ │ │ -and hasn't completely received it yet, it returns the name given
│ │ │ -to it when added to the session. See session::add_torrent.
│ │ │ -This field is only included if the torrent status is queried
│ │ │ -with torrent_handle::query_name.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- torrent_file
│ │ │ -- set to point to the torrent_info object for this torrent. It's
│ │ │ -only included if the torrent status is queried with
│ │ │ -torrent_handle::query_torrent_file.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- next_announce
│ │ │ -- the time until the torrent will announce itself to the tracker.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- current_tracker
│ │ │ -- the URL of the last working tracker. If no tracker request has
│ │ │ -been successful yet, it's set to an empty string.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_download total_upload
│ │ │ -- the number of bytes downloaded and uploaded to all peers, accumulated,
│ │ │ -this session only. The session is considered to restart when a
│ │ │ -torrent is paused and restarted again. When a torrent is paused, these
│ │ │ -counters are reset to 0. If you want complete, persistent, stats, see
│ │ │ -all_time_upload and all_time_download.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_payload_download total_payload_upload
│ │ │ -- counts the amount of bytes send and received this session, but only
│ │ │ -the actual payload data (i.e the interesting data), these counters
│ │ │ -ignore any protocol overhead. The session is considered to restart
│ │ │ -when a torrent is paused and restarted again. When a torrent is
│ │ │ -paused, these counters are reset to 0.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_failed_bytes
│ │ │ -- the number of bytes that has been downloaded and that has failed the
│ │ │ -piece hash test. In other words, this is just how much crap that has
│ │ │ -been downloaded since the torrent was last started. If a torrent is
│ │ │ -paused and then restarted again, this counter will be reset.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_redundant_bytes
│ │ │ -- the number of bytes that has been downloaded even though that data
│ │ │ -already was downloaded. The reason for this is that in some situations
│ │ │ -the same data can be downloaded by mistake. When libtorrent sends
│ │ │ -requests to a peer, and the peer doesn't send a response within a
│ │ │ -certain timeout, libtorrent will re-request that block. Another
│ │ │ -situation when libtorrent may re-request blocks is when the requests
│ │ │ -it sends out are not replied in FIFO-order (it will re-request blocks
│ │ │ -that are skipped by an out of order block). This is supposed to be as
│ │ │ -low as possible. This only counts bytes since the torrent was last
│ │ │ -started. If a torrent is paused and then restarted again, this counter
│ │ │ -will be reset.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- pieces
│ │ │ -- a bitmask that represents which pieces we have (set to true) and the
│ │ │ -pieces we don't have. It's a pointer and may be set to 0 if the
│ │ │ -torrent isn't downloading or seeding.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- verified_pieces
│ │ │ -- a bitmask representing which pieces has had their hash checked. This
│ │ │ -only applies to torrents in seed mode. If the torrent is not in seed
│ │ │ -mode, this bitmask may be empty.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_done
│ │ │ -- the total number of bytes of the file(s) that we have. All this does
│ │ │ -not necessarily has to be downloaded during this session (that's
│ │ │ -total_payload_download).
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total
│ │ │ -- the total number of bytes to download for this torrent. This
│ │ │ -may be less than the size of the torrent in case there are
│ │ │ -pad files. This number only counts bytes that will actually
│ │ │ -be requested from peers.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_wanted_done
│ │ │ -- the number of bytes we have downloaded, only counting the pieces that
│ │ │ -we actually want to download. i.e. excluding any pieces that we have
│ │ │ -but have priority 0 (i.e. not wanted).
│ │ │ -Once a torrent becomes seed, any piece- and file priorities are
│ │ │ -forgotten and all bytes are considered "wanted".
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- total_wanted
│ │ │ -- The total number of bytes we want to download. This may be smaller
│ │ │ -than the total torrent size in case any pieces are prioritized to 0,
│ │ │ -i.e. not wanted.
│ │ │ -Once a torrent becomes seed, any piece- and file priorities are
│ │ │ -forgotten and all bytes are considered "wanted".
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- all_time_upload all_time_download
│ │ │ -- are accumulated upload and download payload byte counters. They are
│ │ │ -saved in and restored from resume data to keep totals across sessions.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- added_time
│ │ │ -- the posix-time when this torrent was added. i.e. what time(nullptr)
│ │ │ -returned at the time.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- completed_time
│ │ │ -- the posix-time when this torrent was finished. If the torrent is not
│ │ │ -yet finished, this is 0.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- last_seen_complete
│ │ │ -- the time when we, or one of our peers, last saw a complete copy of
│ │ │ -this torrent.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- storage_mode
│ │ │ -- The allocation mode for the torrent. See storage_mode_t for the
│ │ │ -options. For more information, see storage allocation.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- progress
│ │ │ -- a value in the range [0, 1], that represents the progress of the
│ │ │ -torrent's current task. It may be checking files or downloading.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- progress_ppm
│ │ │ -progress parts per million (progress * 1000000) when disabling
│ │ │ -floating point operations, this is the only option to query progress
│ │ │ -reflects the same value as progress, but instead in a range [0,
│ │ │ -1000000] (ppm = parts per million). When floating point operations are
│ │ │ -disabled, this is the only alternative to the floating point value in
│ │ │ -progress.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- queue_position
│ │ │ -- the position this torrent has in the download
│ │ │ -queue. If the torrent is a seed or finished, this is -1.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- download_rate upload_rate
│ │ │ -- the total rates for all peers for this torrent. These will usually
│ │ │ -have better precision than summing the rates from all peers. The rates
│ │ │ -are given as the number of bytes per second.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- download_payload_rate upload_payload_rate
│ │ │ -- the total transfer rate of payload only, not counting protocol
│ │ │ -chatter. This might be slightly smaller than the other rates, but if
│ │ │ -projected over a long time (e.g. when calculating ETA:s) the
│ │ │ -difference may be noticeable.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- num_seeds
│ │ │ -- the number of peers that are seeding that this client is
│ │ │ -currently connected to.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- num_peers
│ │ │ -- the number of peers this torrent currently is connected to. Peer
│ │ │ -connections that are in the half-open state (is attempting to connect)
│ │ │ -or are queued for later connection attempt do not count. Although they
│ │ │ -are visible in the peer list when you call get_peer_info().
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- num_complete num_incomplete
│ │ │ -- if the tracker sends scrape info in its announce reply, these fields
│ │ │ -will be set to the total number of peers that have the whole file and
│ │ │ -the total number of peers that are still downloading. set to -1 if the
│ │ │ -tracker did not send any scrape data in its announce reply.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- list_seeds list_peers
│ │ │ -- the number of seeds in our peer list and the total number of peers
│ │ │ -(including seeds). We are not necessarily connected to all the peers
│ │ │ -in our peer list. This is the number of peers we know of in total,
│ │ │ -including banned peers and peers that we have failed to connect to.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- connect_candidates
│ │ │ -- the number of peers in this torrent's peer list that is a candidate to
│ │ │ -be connected to. i.e. It has fewer connect attempts than the max fail
│ │ │ -count, it is not a seed if we are a seed, it is not banned etc. If
│ │ │ -this is 0, it means we don't know of any more peers that we can try.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- num_pieces
│ │ │ -- the number of pieces that has been downloaded. It is equivalent to:
│ │ │ -std::accumulate(pieces->begin(), pieces->end()). So you don't have
│ │ │ -to count yourself. This can be used to see if anything has updated
│ │ │ -since last time if you want to keep a graph of the pieces up to date.
│ │ │ -Note that these pieces have not necessarily been written to disk yet,
│ │ │ -and there is a risk the write to disk will fail.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- distributed_full_copies
│ │ │ -- the number of distributed copies of the torrent. Note that one copy
│ │ │ -may be spread out among many peers. It tells how many copies there are
│ │ │ -currently of the rarest piece(s) among the peers this client is
│ │ │ -connected to.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- distributed_fraction
│ │ │ -tells the share of pieces that have more copies than the rarest
│ │ │ -piece(s). Divide this number by 1000 to get the fraction.
│ │ │ -For example, if distributed_full_copies is 2 and
│ │ │ -distributed_fraction is 500, it means that the rarest pieces have
│ │ │ -only 2 copies among the peers this torrent is connected to, and that
│ │ │ -50% of all the pieces have more than two copies.
│ │ │ -If we are a seed, the piece picker is deallocated as an optimization,
│ │ │ -and piece availability is no longer tracked. In this case the
│ │ │ -distributed copies members are set to -1.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- distributed_copies
│ │ │ -the number of distributed copies of the file. note that one copy may
│ │ │ -be spread out among many peers. This is a floating point
│ │ │ -representation of the distributed copies.
│ │ │ -
│ │ │ -- the integer part tells how many copies
│ │ │ -- there are of the rarest piece(s)
│ │ │ -- the fractional part tells the fraction of pieces that
│ │ │ -- have more copies than the rarest piece(s).
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- block_size
│ │ │ -- the size of a block, in bytes. A block is a sub piece, it is the
│ │ │ -number of bytes that each piece request asks for and the number of
│ │ │ -bytes that each bit in the partial_piece_info's bitset represents,
│ │ │ -see get_download_queue(). This is typically 16 kB, but it may be
│ │ │ -smaller, if the pieces are smaller.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- num_uploads
│ │ │ -- the number of unchoked peers in this torrent.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- num_connections
│ │ │ -- the number of peer connections this torrent has, including half-open
│ │ │ -connections that hasn't completed the bittorrent handshake yet. This
│ │ │ -is always >= num_peers.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- uploads_limit
│ │ │ -- the set limit of upload slots (unchoked peers) for this torrent.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- connections_limit
│ │ │ -- the set limit of number of connections for this torrent.
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- up_bandwidth_queue down_bandwidth_queue
│ │ │ -- the number of peers in this torrent that are waiting for more
│ │ │ -bandwidth quota from the torrent rate limiter. This can determine if
│ │ │ -the rate you get from this torrent is bound by the torrents limit or
│ │ │ -not. If there is no limit set on this torrent, the peers might still
│ │ │ -be waiting for bandwidth quota from the global limiter, but then they
│ │ │ -are counted in the session_status object.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- seed_rank
│ │ │ -- A rank of how important it is to seed the torrent, it is used to
│ │ │ -determine which torrents to seed and which to queue. It is based on
│ │ │ -the peer to seed ratio from the tracker scrape. For more information,
│ │ │ -see queuing. Higher value means more important to seed
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- state
│ │ │ -- the main state the torrent is in. See torrent_status::state_t.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- need_save_resume
│ │ │ -- true if this torrent has unsaved changes
│ │ │ -to its download state and statistics since the last resume data
│ │ │ -was saved.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- is_seeding
│ │ │ -- true if all pieces have been downloaded.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- is_finished
│ │ │ -- true if all pieces that have a priority > 0 are downloaded. There is
│ │ │ -only a distinction between finished and seeding if some pieces or
│ │ │ -files have been set to priority 0, i.e. are not downloaded.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- has_metadata
│ │ │ -- true if this torrent has metadata (either it was started from a
│ │ │ -.torrent file or the metadata has been downloaded). The only scenario
│ │ │ -where this can be false is when the torrent was started torrent-less
│ │ │ -(i.e. with just an info-hash and tracker ip, a magnet link for
│ │ │ -instance).
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- has_incoming
│ │ │ -- true if there has ever been an incoming connection attempt to this
│ │ │ -torrent.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- moving_storage
│ │ │ -- this is true if this torrent's storage is currently being moved from
│ │ │ -one location to another. This may potentially be a long operation
│ │ │ -if a large file ends up being copied from one drive to another.
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- announcing_to_trackers announcing_to_lsd announcing_to_dht
│ │ │ -- these are set to true if this torrent is allowed to announce to the
│ │ │ -respective peer source. Whether they are true or false is determined by
│ │ │ -the queue logic/auto manager. Torrents that are not auto managed will
│ │ │ -always be allowed to announce to all peer sources.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- info_hashes
│ │ │ -- the info-hash for this torrent
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- last_upload last_download
│ │ │ -- the timestamps of the last time this torrent uploaded or downloaded
│ │ │ -payload to any peer.
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- active_duration finished_duration seeding_duration
│ │ │ -- these are cumulative counters of for how long the torrent has been in
│ │ │ -different states. active means not paused and added to session. Whether
│ │ │ -it has found any peers or not is not relevant.
│ │ │ -finished means all selected files/pieces were downloaded and available
│ │ │ -to other peers (this is always a subset of active time).
│ │ │ -seeding means all files/pieces were downloaded and available to
│ │ │ -peers. Being available to peers does not imply there are other peers
│ │ │ -asking for the payload.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- flags
│ │ │ -- reflects several of the torrent's flags. For more
│ │ │ -information, see torrent_handle::flags().
│ │ │ -
│ │ │ -
[report issue]
│ │ │ +
decrypt the provided buffers.
│ │ │ +returns is a tuple representing the values
│ │ │ +(consume, produce, packet_size)
│ │ │ +
consume is set to the number of bytes which should be trimmed from the
│ │ │ +head of the buffers, default is 0
│ │ │ +
produce is set to the number of bytes of payload which are now ready to
│ │ │ +be sent to the upper layer. default is the number of bytes passed in receive_vec
│ │ │ +
packet_size is set to the minimum number of bytes which must be read to
│ │ │ +advance the next step of decryption. default is 0
│ │ │ +
[report issue]
│ │ │
│ │ │ -
│ │ │ -
announce_infohash
│ │ │ -
Declared in "libtorrent/announce_entry.hpp"
│ │ │ -
│ │ │ -struct announce_infohash
│ │ │ -{
│ │ │ - std::string message;
│ │ │ - error_code last_error;
│ │ │ - int scrape_incomplete = -1;
│ │ │ - int scrape_complete = -1;
│ │ │ - int scrape_downloaded = -1;
│ │ │ - std::uint8_t fails : 7;
│ │ │ - bool updating : 1;
│ │ │ - bool start_sent : 1;
│ │ │ - bool complete_sent : 1;
│ │ │ -};
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- message
│ │ │ -- if this tracker has returned an error or warning message
│ │ │ -that message is stored here
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- last_error
│ │ │ -- if this tracker failed the last time it was contacted
│ │ │ -this error code specifies what error occurred
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- scrape_incomplete scrape_complete scrape_downloaded
│ │ │ -- if this tracker has returned scrape data, these fields are filled in
│ │ │ -with valid numbers. Otherwise they are set to -1. incomplete counts
│ │ │ -the number of current downloaders. complete counts the number of
│ │ │ -current peers completed the download, or "seeds". downloaded is the
│ │ │ -cumulative number of completed downloads.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- fails
│ │ │ -- the number of times in a row we have failed to announce to this
│ │ │ -tracker.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- updating
│ │ │ -- true while we're waiting for a response from the tracker.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- start_sent
│ │ │ -- set to true when we get a valid response from an announce
│ │ │ -with event=started. If it is set, we won't send start in the subsequent
│ │ │ -announces.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- complete_sent
│ │ │ -- set to true when we send a event=completed.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
announce_endpoint
│ │ │ -
Declared in "libtorrent/announce_entry.hpp"
│ │ │ -
announces are sent to each tracker using every listen socket
│ │ │ -this class holds information about one listen socket for one tracker
│ │ │ +
│ │ │ +
create_smart_ban_plugin()
│ │ │ +
Declared in "libtorrent/extensions/smart_ban.hpp"
│ │ │
│ │ │ -struct announce_endpoint
│ │ │ -{
│ │ │ - announce_endpoint ();
│ │ │ -
│ │ │ - tcp::endpoint local_endpoint;
│ │ │ - aux::array<announce_infohash, num_protocols, protocol_version> info_hashes;
│ │ │ - bool enabled = true;
│ │ │ -};
│ │ │ +std::shared_ptr<torrent_plugin> create_smart_ban_plugin (torrent_handle const&, client_data_t);
│ │ │
│ │ │ -
[report issue]
│ │ │ -- local_endpoint
│ │ │ -- the local endpoint of the listen interface associated with this endpoint
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- info_hashes
│ │ │ -- info_hashes[0] is the v1 info hash (SHA1)
│ │ │ -info_hashes[1] is the v2 info hash (truncated SHA-256)
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- enabled
│ │ │ -- set to false to not announce from this endpoint
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
announce_entry
│ │ │ -
Declared in "libtorrent/announce_entry.hpp"
│ │ │ -
this class holds information about one bittorrent tracker, as it
│ │ │ -relates to a specific torrent.
│ │ │ +
constructor function for the smart ban extension. The extension keeps
│ │ │ +track of the data peers have sent us for failing pieces and once the
│ │ │ +piece completes and passes the hash check bans the peers that turned
│ │ │ +out to have sent corrupt data.
│ │ │ +This function can either be passed in the add_torrent_params::extensions
│ │ │ +field, or via torrent_handle::add_extension().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
create_ut_pex_plugin()
│ │ │ +
Declared in "libtorrent/extensions/ut_pex.hpp"
│ │ │
│ │ │ -struct announce_entry
│ │ │ -{
│ │ │ - announce_entry (announce_entry const&);
│ │ │ - announce_entry& operator= (announce_entry const&) &;
│ │ │ - announce_entry ();
│ │ │ - ~announce_entry ();
│ │ │ - explicit announce_entry (string_view u);
│ │ │ -
│ │ │ - enum tracker_source
│ │ │ - {
│ │ │ - source_torrent,
│ │ │ - source_client,
│ │ │ - source_magnet_link,
│ │ │ - source_tex,
│ │ │ - };
│ │ │ -
│ │ │ - std::string url;
│ │ │ - std::string trackerid;
│ │ │ - std::vector<announce_endpoint> endpoints;
│ │ │ - std::uint8_t tier = 0;
│ │ │ - std::uint8_t fail_limit = 0;
│ │ │ - std::uint8_t source:4;
│ │ │ - bool verified:1;
│ │ │ -};
│ │ │ +std::shared_ptr<torrent_plugin> create_ut_pex_plugin (torrent_handle const&, client_data_t);
│ │ │
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
~announce_entry() operator=() announce_entry()
│ │ │ +
constructor function for the ut_pex extension. The ut_pex
│ │ │ +extension allows peers to gossip about their connections, allowing
│ │ │ +the swarm stay well connected and peers aware of more peers in the
│ │ │ +swarm. This extension is enabled by default unless explicitly disabled in
│ │ │ +the session constructor.
│ │ │ +
This can either be passed in the add_torrent_params::extensions field, or
│ │ │ +via torrent_handle::add_extension().
│ │ │ +
[report issue]
│ │ │ +
│ │ │ -
│ │ │ -
enum tracker_source
│ │ │ -
Declared in "libtorrent/announce_entry.hpp"
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -| name |
│ │ │ -value |
│ │ │ -description |
│ │ │ -
|---|
│ │ │ -
│ │ │ -
│ │ │ -| source_torrent |
│ │ │ -1 |
│ │ │ -the tracker was part of the .torrent file |
│ │ │ -
│ │ │ -| source_client |
│ │ │ -2 |
│ │ │ -the tracker was added programmatically via the add_tracker() function |
│ │ │ -
│ │ │ -| source_magnet_link |
│ │ │ -4 |
│ │ │ -the tracker was part of a magnet link |
│ │ │ -
│ │ │ -| source_tex |
│ │ │ -8 |
│ │ │ -the tracker was received from the swarm via tracker exchange |
│ │ │ -
│ │ │ -
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- url
│ │ │ -- tracker URL as it appeared in the torrent file
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- trackerid
│ │ │ -- the current &trackerid= argument passed to the tracker.
│ │ │ -this is optional and is normally empty (in which case no
│ │ │ -trackerid is sent).
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- endpoints
│ │ │ -- each local listen socket (endpoint) will announce to the tracker. This
│ │ │ -list contains state per endpoint.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- tier
│ │ │ -- the tier this tracker belongs to
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- fail_limit
│ │ │ -- the max number of failures to announce to this tracker in
│ │ │ -a row, before this tracker is not used anymore. 0 means unlimited
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- source
│ │ │ -- a bitmask specifying which sources we got this tracker from.
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- verified
│ │ │ -- set to true the first time we receive a valid response
│ │ │ -from this tracker.
│ │ │ -
│ │ │ +
constructor function for the ut_metadata extension. The ut_metadata
│ │ │ +extension allows peers to request the .torrent file (or more
│ │ │ +specifically the info-dictionary of the .torrent file) from each
│ │ │ +other. This is the main building block in making magnet links work.
│ │ │ +This extension is enabled by default unless explicitly disabled in
│ │ │ +the session constructor.
│ │ │ +
This can either be passed in the add_torrent_params::extensions field, or
│ │ │ +via torrent_handle::add_extension().
│ │ │
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
│ │ │ to the session when passed to session::apply_settings(). It's empty when
│ │ │ constructed.
│ │ │
You have control over proxy and authorization settings and also the user-agent
│ │ │ that will be sent to the tracker. The user-agent will also be used to identify the
│ │ │ client with other peers.
│ │ │
Each configuration option is named with an enum value inside the
│ │ │ settings_pack class. These are the available settings:
│ │ │
[report issue]
│ │ │ -
│ │ │
│ │ │
settings_pack
│ │ │
Declared in "libtorrent/settings_pack.hpp"
│ │ │
The settings_pack struct, contains the names of all settings as
│ │ │ enum values. These values are passed in to the set_str(),
│ │ │ set_int(), set_bool() functions, to specify the setting to
│ │ │ change.
│ │ │ @@ -19149,22 +18236,22 @@
│ │ │
│ │ │ 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_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,
│ │ │ @@ -19235,23 +18322,23 @@
│ │ │ socks5,
│ │ │ socks5_pw,
│ │ │ http,
│ │ │ http_pw,
│ │ │ };
│ │ │ };
│ │ │
│ │ │ -
│ │ │ +
│ │ │
│ │ │ -
[report issue]
│ │ │ -
set_str() set_int() set_bool()
│ │ │ +
[report issue]
│ │ │ +
set_bool() set_int() set_str()
│ │ │
│ │ │ 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_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()
│ │ │ @@ -19272,21 +18359,21 @@
│ │ │
│ │ │
clear()
│ │ │
│ │ │ void clear (int name);
│ │ │
│ │ │
clear a specific setting from the pack
│ │ │
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
get_str() get_int() get_bool()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
get_str() get_bool() get_int()
│ │ │
│ │ │ -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.
│ │ │ @@ -19704,22 +18791,41 @@
│ │ │
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]
│ │ │ +
│ │ │ +
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.
│ │ │ +
[report issue]
│ │ │ +
│ │ │
│ │ │ -
│ │ │ -
name_for_setting() setting_by_name()
│ │ │ -
Declared in "libtorrent/settings_pack.hpp"
│ │ │ +
This section describes the functions and classes that are used
│ │ │ +to create torrent files. It is a layered API with low level classes
│ │ │ +and higher level convenience functions. A torrent is created in 4
│ │ │ +steps:
│ │ │ +
│ │ │ +- first the files that will be part of the torrent are determined.
│ │ │ +- the torrent properties are set, such as tracker url, web seeds,
│ │ │ +DHT nodes etc.
│ │ │ +- Read through all the files in the torrent, SHA-1 all the data
│ │ │ +and set the piece hashes.
│ │ │ +- The torrent is bencoded into a file or buffer.
│ │ │ +
│ │ │ +
If there are a lot of files and or deep directory hierarchies to
│ │ │ +traverse, step one can be time consuming.
│ │ │ +
Typically step 3 is by far the most time consuming step, since it
│ │ │ +requires to read all the bytes from all the files in the torrent.
│ │ │ +
All of these classes and functions are declared by including
│ │ │ +libtorrent/create_torrent.hpp.
│ │ │ +
example:
│ │ │ +
│ │ │ +file_storage fs;
│ │ │ +
│ │ │ +add_files(fs, "./my_torrent");
│ │ │ +
│ │ │ +create_torrent t(fs);
│ │ │ +t.add_tracker("http://my.tracker.com/announce");
│ │ │ +t.set_creator("libtorrent example");
│ │ │ +
│ │ │ +set_piece_hashes(t, ".");
│ │ │ +
│ │ │ +ofstream out("my_torrent.torrent", std::ios_base::binary);
│ │ │ +std::vector<char> buf = t.generate_buf();
│ │ │ +out.write(buf.data(), buf.size());
│ │ │ +
│ │ │ +bencode(std::ostream_iterator<char>(out), t.generate());
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
create_torrent
│ │ │ +
Declared in "libtorrent/create_torrent.hpp"
│ │ │ +
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().
│ │ │
│ │ │ -int setting_by_name (string_view name);
│ │ │ -char const* name_for_setting (int s);
│ │ │ +struct create_torrent
│ │ │ +{
│ │ │ + explicit create_torrent (torrent_info const& ti);
│ │ │ + explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ + , create_flags_t flags = {});
│ │ │ + std::vector<char> generate_buf () const;
│ │ │ + entry generate () const;
│ │ │ + file_storage const& files () const;
│ │ │ + void set_comment (char const* str);
│ │ │ + void set_creator (char const* str);
│ │ │ + void set_creation_date (std::time_t timestamp);
│ │ │ + void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ + void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ + void add_http_seed (string_view url);
│ │ │ + void add_url_seed (string_view url);
│ │ │ + void add_node (std::pair<std::string, int> node);
│ │ │ + void add_tracker (string_view url, int tier = 0);
│ │ │ + void set_root_cert (string_view cert);
│ │ │ + bool priv () 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_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;
│ │ │ +};
│ │ │
│ │ │ -
converts a setting integer (from the enums string_types, int_types or
│ │ │ -bool_types) to a string, and vice versa.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
default_settings()
│ │ │ -
Declared in "libtorrent/settings_pack.hpp"
│ │ │ +
[report issue]
│ │ │ +
create_torrent()
│ │ │
│ │ │ -settings_pack default_settings ();
│ │ │ +explicit create_torrent (torrent_info const& ti);
│ │ │ +explicit create_torrent (file_storage& fs, int piece_size = 0
│ │ │ + , create_flags_t flags = {});
│ │ │
│ │ │ -
returns a settings_pack with every setting set to its default value
│ │ │ +
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.
│ │ │ +Piece sizes greater than 128 MiB are considered unreasonable and will
│ │ │ +be rejected (with an lt::system_error exception).
│ │ │ +
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
│ │ │ +their properties for the torrent to be created. Set this up first,
│ │ │ +before passing it to the create_torrent constructor.
│ │ │ +
The overload that takes a torrent_info object will make a verbatim
│ │ │ +copy of its info dictionary (to preserve the info-hash). The copy of
│ │ │ +the info dictionary will be used by create_torrent::generate(). This means
│ │ │ +that none of the member functions of create_torrent that affects
│ │ │ +the content of the info dictionary (such as set_hash()), will
│ │ │ +have any affect. Instead of using this overload, consider using
│ │ │ +write_torrent_file() instead.
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
generate_buf() generate()
│ │ │ +
│ │ │ +std::vector<char> generate_buf () const;
│ │ │ +entry generate () const;
│ │ │ +
│ │ │ +
This function will generate the .torrent file as a bencode tree, or a
│ │ │ +bencoded into a buffer.
│ │ │ +In order to encode the entry into a flat file, use the bencode() function.
│ │ │ +
The function returning an entry may be useful to add custom entries
│ │ │ +to the torrent file before bencoding it and saving it to disk.
│ │ │ +
Whether the resulting torrent object is v1, v2 or hybrid depends on
│ │ │ +whether any of the v1_only or v2_only flags were set on the
│ │ │ +constructor. If neither were set, the resulting torrent depends on
│ │ │ +which hashes were set. If both v1 and v2 hashes were set, a hybrid
│ │ │ +torrent is created.
│ │ │ +
Any failure will cause this function to throw system_error, with an
│ │ │ +appropriate error message. These are the reasons this call may throw:
│ │ │ +
│ │ │ +- the file storage has 0 files
│ │ │ +- the total size of the file storage is 0 bytes (i.e. it only has
│ │ │ +empty files)
│ │ │ +- not all v1 hashes (set_hash()) and not all v2 hashes (set_hash2())
│ │ │ +were set
│ │ │ +- for v2 torrents, you may not have a directory with the same name as
│ │ │ +a file. If that's encountered in the file storage, generate()
│ │ │ +fails.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
files()
│ │ │ +
│ │ │ +file_storage const& files () const;
│ │ │ +
│ │ │ +
returns an immutable reference to the file_storage used to create
│ │ │ +the torrent from.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
set_creator()
│ │ │ +
│ │ │ +void set_creator (char const* str);
│ │ │ +
│ │ │ +
Sets the creator of the torrent. The string str should be utf-8 encoded.
│ │ │ +This is optional.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_creation_date()
│ │ │ +
│ │ │ +void set_creation_date (std::time_t timestamp);
│ │ │ +
│ │ │ +
sets the "creation time" field. Defaults to the system clock at the
│ │ │ +time of construction of the create_torrent object. The timestamp is
│ │ │ +specified in seconds, posix time. If the creation date is set to 0,
│ │ │ +the "creation date" field will be omitted from the generated torrent.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_hash()
│ │ │ +
│ │ │ +void set_hash (piece_index_t index, sha1_hash const& h);
│ │ │ +
│ │ │ +
This sets the SHA-1 hash for the specified piece (index). You are required
│ │ │ +to set the hash for every piece in the torrent before generating it. If you have
│ │ │ +the files on disk, you can use the high level convenience function to do this.
│ │ │ +See set_piece_hashes().
│ │ │ +A SHA-1 hash of all zeros is internally used to indicate a hash that
│ │ │ +has not been set. Setting such hash will not be considered set when
│ │ │ +calling generate().
│ │ │ +This function will throw std::system_error if it is called on an
│ │ │ +object constructed with the v2_only flag.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_hash2()
│ │ │ +
│ │ │ +void set_hash2 (file_index_t file, piece_index_t::diff_type piece, sha256_hash const& h);
│ │ │ +
│ │ │ +
sets the bittorrent v2 hash for file file of the piece piece.
│ │ │ +piece is relative to the first piece of the file, starting at 0. The
│ │ │ +first piece in the file can be computed with
│ │ │ +file_storage::file_index_at_piece().
│ │ │ +The hash, h, is the root of the merkle tree formed by the piece's
│ │ │ +16 kiB blocks. Note that piece sizes must be powers-of-2, so all
│ │ │ +per-piece merkle trees are complete.
│ │ │ +A SHA-256 hash of all zeros is internally used to indicate a hash
│ │ │ +that has not been set. Setting such hash will not be considered set
│ │ │ +when calling generate().
│ │ │ +This function will throw std::system_error if it is called on an
│ │ │ +object constructed with the v1_only flag.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_url_seed() add_http_seed()
│ │ │ +
│ │ │ +void add_http_seed (string_view url);
│ │ │ +void add_url_seed (string_view url);
│ │ │ +
│ │ │ +
This adds a url seed to the torrent. You can have any number of url seeds. For a
│ │ │ +single file torrent, this should be an HTTP url, pointing to a file with identical
│ │ │ +content as the file of the torrent. For a multi-file torrent, it should point to
│ │ │ +a directory containing a directory with the same name as this torrent, and all the
│ │ │ +files of the torrent in it.
│ │ │ +
The second function, add_http_seed() adds an HTTP seed instead.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_node()
│ │ │ +
│ │ │ +void add_node (std::pair<std::string, int> node);
│ │ │ +
│ │ │ +
This adds a DHT node to the torrent. This especially useful if you're creating a
│ │ │ +tracker less torrent. It can be used by clients to bootstrap their DHT node from.
│ │ │ +The node is a hostname and a port number where there is a DHT node running.
│ │ │ +You can have any number of DHT nodes in a torrent.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_tracker()
│ │ │ +
│ │ │ +void add_tracker (string_view url, int tier = 0);
│ │ │ +
│ │ │ +
Adds a tracker to the torrent. This is not strictly required, but most torrents
│ │ │ +use a tracker as their main source of peers. The url should be an http:// or udp://
│ │ │ +url to a machine running a bittorrent tracker that accepts announces for this torrent's
│ │ │ +info-hash. The tier is the fallback priority of the tracker. All trackers with tier 0 are
│ │ │ +tried first (in any order). If all fail, trackers with tier 1 are tried. If all of those
│ │ │ +fail, trackers with tier 2 are tried, and so on.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_root_cert()
│ │ │ +
│ │ │ +void set_root_cert (string_view cert);
│ │ │ +
│ │ │ +
This function sets an X.509 certificate in PEM format to the torrent. This makes the
│ │ │ +torrent an SSL torrent. An SSL torrent requires that each peer has a valid certificate
│ │ │ +signed by this root certificate. For SSL torrents, all peers are connecting over SSL
│ │ │ +connections. For more information, see the section on ssl torrents.
│ │ │ +
The string is not the path to the cert, it's the actual content of the
│ │ │ +certificate.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
set_priv() priv()
│ │ │ +
│ │ │ +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]
│ │ │ +
│ │ │ +
num_pieces()
│ │ │ +
│ │ │ +int num_pieces () const;
│ │ │ +
│ │ │ +
returns the number of pieces in the associated file_storage object.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
piece_range()
│ │ │ +
│ │ │ +index_range<piece_index_t> piece_range () const noexcept;
│ │ │ +
│ │ │ +
all piece indices in the torrent to be created
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
file_range()
│ │ │ +
│ │ │ +index_range<file_index_t> file_range () const noexcept;
│ │ │ +
│ │ │ +
all file indices in the torrent to be created
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
file_piece_range()
│ │ │ +
│ │ │ +index_range<piece_index_t::diff_type> file_piece_range (file_index_t f);
│ │ │ +
│ │ │ +
for v2 and hybrid torrents only, the pieces in the
│ │ │ +specified file, specified as delta from the first piece in the file.
│ │ │ +i.e. the first index is 0.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
total_size()
│ │ │ +
│ │ │ +std::int64_t total_size () const;
│ │ │ +
│ │ │ +
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;
│ │ │ +
│ │ │ +
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_similar_torrent() add_collection()
│ │ │ +
│ │ │ +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.
│ │ │ +
[report issue]
│ │ │ +- modification_time
│ │ │ +- This will include the file modification time as part of the torrent.
│ │ │ +This is not enabled by default, as it might cause problems when you
│ │ │ +create a torrent from separate files with the same content, hoping to
│ │ │ +yield the same info-hash. If the files have different modification times,
│ │ │ +with this option enabled, you would get different info-hashes for the
│ │ │ +files.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- symlinks
│ │ │ +- If this flag is set, files that are symlinks get a symlink attribute
│ │ │ +set on them and their data will not be included in the torrent. This
│ │ │ +is useful if you need to reconstruct a file hierarchy which contains
│ │ │ +symlinks.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- v2_only
│ │ │ +- Do not generate v1 metadata. The resulting torrent will only be usable by
│ │ │ +clients which support v2. This requires setting all v2 hashes, with
│ │ │ +set_hash2() before calling generate(). Setting v1 hashes (with
│ │ │ +set_hash()) is an error with this flag set.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- v1_only
│ │ │ +- do not generate v2 metadata or enforce v2 alignment and padding rules
│ │ │ +this is mainly for tests, not recommended for production use. This
│ │ │ +requires setting all v1 hashes, with set_hash(), before calling
│ │ │ +generate(). Setting v2 hashes (with set_hash2()) is an error with
│ │ │ +this flag set.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- canonical_files
│ │ │ +- This flag only affects v1-only torrents, and is only relevant
│ │ │ +together with the v1_only_flag. This flag will force the
│ │ │ +same file order and padding as a v2 (or hybrid) torrent would have.
│ │ │ +It has the effect of ordering files and inserting pad files to align
│ │ │ +them with piece boundaries.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- no_attributes
│ │ │ +- passing this flag to add_files() will ignore file attributes (such as
│ │ │ +executable or hidden) when adding the files to the file storage.
│ │ │ +Since not all filesystems and operating systems support all file
│ │ │ +attributes the resulting torrent may differ depending on where it's
│ │ │ +created. If it's important for torrents to be created consistently
│ │ │ +across systems, this flag should be set.
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- canonical_files_no_tail_padding
│ │ │ +- this flag enforces the file layout to be canonical according to the
│ │ │ +bittorrent v2 specification (just like the canonical_files flag)
│ │ │ +with the one exception that tail padding is not added to the last
│ │ │ +file.
│ │ │ +This behavior deviates from the specification but was the way
│ │ │ +libtorrent created torrents in version up to and including 2.0.7.
│ │ │ +This flag is here for backwards compatibility.
│ │ │ +
│ │ │ +
[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 = {});
│ │ │ +
│ │ │ +
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:
│ │ │ +
│ │ │ +bool Pred(std::string const& p);
│ │ │ +
│ │ │ +
The path that is passed in to the predicate is the full path of the file or
│ │ │ +directory. If no predicate is specified, all files are added, and all directories
│ │ │ +are traversed.
│ │ │ +
The ".." directory is never traversed.
│ │ │ +
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"
│ │ │ +
│ │ │ +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
│ │ │ + , std::function<void(piece_index_t)> const& f);
│ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ + , settings_interface const& settings
│ │ │ + , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p);
│ │ │ +void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ + , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ + , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ +
│ │ │ +
This function will assume that the files added to the torrent file exists at path
│ │ │ +p, read those files and hash the content and set the hashes in the create_torrent
│ │ │ +object. The optional function f is called in between every hash that is set. f
│ │ │ +must have the following signature:
│ │ │ +
│ │ │ +void Fun(piece_index_t);
│ │ │ +
│ │ │ +
The overloads taking a settings_pack may be used to configure the
│ │ │ +underlying disk access. Such as settings_pack::aio_threads.
│ │ │ +
The overloads that don't take an error_code& may throw an exception in case of a
│ │ │ +file error, the other overloads sets the error code to reflect the error, if any.
│ │ │ +
Bencoding is a common representation in bittorrent used for dictionary,
│ │ │ +list, int and string hierarchies. It's used to encode .torrent files and
│ │ │ +some messages in the network protocol. libtorrent also uses it to store
│ │ │ +settings, resume data and other session state.
│ │ │ +
Strings in bencoded structures do not necessarily represent text.
│ │ │ +Strings are raw byte buffers of a certain length. If a string is meant to be
│ │ │ +interpreted as text, it is required to be UTF-8 encoded. See BEP 3.
│ │ │ +
The function for decoding bencoded data bdecode(), returning a bdecode_node.
│ │ │ +This function builds a tree that points back into the original buffer. The
│ │ │ +returned bdecode_node will not be valid once the buffer it was parsed out of
│ │ │ +is discarded.
│ │ │ +
It's possible to construct an entry from a bdecode_node, if a structure needs
│ │ │ +to be altered and re-encoded.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
entry
│ │ │ +
Declared in "libtorrent/entry.hpp"
│ │ │ +
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 (integer_type);
│ │ │ + entry (preformatted_type);
│ │ │ + entry (span<char const>);
│ │ │ + entry (list_type);
│ │ │ + entry (dictionary_type);
│ │ │ + entry (U v);
│ │ │ + entry (data_type t);
│ │ │ + entry (bdecode_node const& n);
│ │ │ + entry& operator= (entry&&) & noexcept;
│ │ │ + entry& operator= (dictionary_type) &;
│ │ │ + entry& operator= (preformatted_type) &;
│ │ │ + entry& operator= (bdecode_node const&) &;
│ │ │ + entry& operator= (integer_type) &;
│ │ │ + entry& operator= (entry const&) &;
│ │ │ + entry& operator= (span<char const>) &;
│ │ │ + entry& operator= (list_type) &;
│ │ │ + entry& operator= (U v) &;
│ │ │ + integer_type& integer ();
│ │ │ + dictionary_type& dict ();
│ │ │ + preformatted_type& preformatted ();
│ │ │ + integer_type const& integer () const;
│ │ │ + string_type const& string () const;
│ │ │ + list_type const& list () const;
│ │ │ + string_type& string ();
│ │ │ + preformatted_type const& preformatted () const;
│ │ │ + list_type& list ();
│ │ │ + dictionary_type const& dict () const;
│ │ │ + void swap (entry& e);
│ │ │ + entry& operator[] (string_view key);
│ │ │ + entry const& operator[] (string_view key) const;
│ │ │ + 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,
│ │ │ + dictionary_t,
│ │ │ + undefined_t,
│ │ │ + preformatted_t,
│ │ │ + };
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
type()
│ │ │ +
│ │ │ +data_type type () const;
│ │ │ +
│ │ │ +
returns the concrete type of the entry
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
entry()
│ │ │ +
│ │ │ +entry (integer_type);
│ │ │ +entry (preformatted_type);
│ │ │ +entry (span<char const>);
│ │ │ +entry (list_type);
│ │ │ +entry (dictionary_type);
│ │ │ +
│ │ │ +
constructors directly from a specific type.
│ │ │ +The content of the argument is copied into the
│ │ │ +newly constructed entry
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
entry()
│ │ │ +
│ │ │ +entry (data_type t);
│ │ │ +
│ │ │ +
construct an empty entry of the specified type.
│ │ │ +see data_type enum.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
entry()
│ │ │ +
│ │ │ +entry (bdecode_node const& n);
│ │ │ +
│ │ │ +
construct from bdecode_node parsed form (see bdecode())
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
operator=()
│ │ │ +
│ │ │ +entry& operator= (entry&&) & noexcept;
│ │ │ +entry& operator= (dictionary_type) &;
│ │ │ +entry& operator= (preformatted_type) &;
│ │ │ +entry& operator= (bdecode_node const&) &;
│ │ │ +entry& operator= (integer_type) &;
│ │ │ +entry& operator= (entry const&) &;
│ │ │ +entry& operator= (span<char const>) &;
│ │ │ +entry& operator= (list_type) &;
│ │ │ +
│ │ │ +
copies the structure of the right hand side into this
│ │ │ +entry.
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
swap()
│ │ │ +
│ │ │ +void swap (entry& e);
│ │ │ +
│ │ │ +
swaps the content of this with e.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
operator[]()
│ │ │ +
│ │ │ +entry& operator[] (string_view key);
│ │ │ +entry const& operator[] (string_view key) const;
│ │ │ +
│ │ │ +
All of these functions requires the entry to be a dictionary, if it
│ │ │ +isn't they will throw system_error.
│ │ │ +
The non-const versions of the operator[] will return a reference
│ │ │ +to either the existing element at the given key or, if there is no
│ │ │ +element with the given key, a reference to a newly inserted element at
│ │ │ +that key.
│ │ │ +
The const version of operator[] will only return a reference to an
│ │ │ +existing element at the given key. If the key is not found, it will
│ │ │ +throw system_error.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
find_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]
│ │ │ +
│ │ │ +
to_string()
│ │ │ +
│ │ │ +std::string to_string (bool single_line = false) const;
│ │ │ +
│ │ │ +
returns a pretty-printed string representation
│ │ │ +of the bencoded structure, with JSON-style syntax
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum data_type
│ │ │ +
Declared in "libtorrent/entry.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| int_t |
│ │ │ +0 |
│ │ │ + |
│ │ │ +
│ │ │ +| string_t |
│ │ │ +1 |
│ │ │ + |
│ │ │ +
│ │ │ +| list_t |
│ │ │ +2 |
│ │ │ + |
│ │ │ +
│ │ │ +| dictionary_t |
│ │ │ +3 |
│ │ │ + |
│ │ │ +
│ │ │ +| undefined_t |
│ │ │ +4 |
│ │ │ + |
│ │ │ +
│ │ │ +| preformatted_t |
│ │ │ +5 |
│ │ │ + |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
bencode()
│ │ │ +
Declared in "libtorrent/bencode.hpp"
│ │ │ +
│ │ │ +template<class OutIt> int bencode (OutIt out, const entry& e);
│ │ │ +
│ │ │ +
This function will encode data to bencoded form.
│ │ │ +
The entry class is the internal representation of the bencoded data
│ │ │ +and it can be used to retrieve information, an entry can also be build by
│ │ │ +the program and given to bencode() to encode it into the OutIt
│ │ │ +iterator.
│ │ │ +
OutIt is an OutputIterator. It's a template and usually
│ │ │ +instantiated as ostream_iterator or back_insert_iterator. This
│ │ │ +function assumes the value_type of the iterator is a char.
│ │ │ +In order to encode entry e into a buffer, do:
│ │ │ +
│ │ │ +std::vector<char> buf;
│ │ │ +bencode(std::back_inserter(buf), e);
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
operator<<()
│ │ │ +
Declared in "libtorrent/entry.hpp"
│ │ │ +
│ │ │ +inline std::ostream& operator<< (std::ostream& os, const entry& e);
│ │ │ +
│ │ │ +
prints the bencoded structure to the ostream as a JSON-style structure.
│ │ │
[report issue]
│ │ │
│ │ │
bdecode_node
│ │ │
Declared in "libtorrent/bdecode.hpp"
│ │ │
Sometimes it's important to get a non-owning reference to the root node (
│ │ │ to be able to copy it as a reference for instance). For that, use the
│ │ │ non_owning() member function.
│ │ │ @@ -19774,36 +19607,36 @@
│ │ │ bdecode_node&
operator= (bdecode_node&&) & = default;
│ │ │ type_t
type () const noexcept;
│ │ │ explicit operator
bool () const noexcept;
│ │ │ bdecode_node
non_owning () const;
│ │ │ 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;
│ │ │ string_view
list_string_value_at (int i
│ │ │ , string_view default_val = string_view()) const;
│ │ │ int
list_size () const;
│ │ │ + std::int64_t
list_int_value_at (int i
│ │ │ + , std::int64_t default_val = 0) const;
│ │ │ + std::int64_t
dict_find_int_value (string_view key
│ │ │ + , std::int64_t default_val = 0) const;
│ │ │ + bdecode_node
dict_find_list (string_view key) const;
│ │ │ + bdecode_node
dict_find (string_view key) const;
│ │ │ bdecode_node
dict_find_int (string_view key) const;
│ │ │ + bdecode_node
dict_find_dict (string_view key) const;
│ │ │ string_view
dict_find_string_value (string_view key
│ │ │ , string_view default_value = string_view()) const;
│ │ │ - bdecode_node
dict_find_list (string_view key) const;
│ │ │ - bdecode_node
dict_find_dict (string_view key) const;
│ │ │ - std::int64_t
dict_find_int_value (string_view key
│ │ │ - , std::int64_t default_val = 0) const;
│ │ │ int
dict_size () const;
│ │ │ - std::pair<string_view, bdecode_node>
dict_at (int i) const;
│ │ │ bdecode_node
dict_find_string (string_view key) 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;
│ │ │ std::int64_t
int_value () 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;
│ │ │ - string_view
string_value () 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
│ │ │ @@ -19866,57 +19699,57 @@
│ │ │
│ │ │
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_size() list_int_value_at() list_string_value_at() list_at()
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
list_at() list_size() list_int_value_at() list_string_value_at()
│ │ │
│ │ │ bdecode_node list_at (int i) const;
│ │ │ -std::int64_t list_int_value_at (int i
│ │ │ - , std::int64_t default_val = 0) const;
│ │ │ string_view list_string_value_at (int i
│ │ │ , string_view default_val = string_view()) const;
│ │ │ int list_size () const;
│ │ │ +std::int64_t list_int_value_at (int i
│ │ │ + , std::int64_t default_val = 0) 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_int_value() dict_find_int() dict_find_list() dict_find() dict_at_node() dict_find_string() dict_find_dict() dict_size() dict_at() dict_find_string_value()
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dict_at() dict_find_int() dict_find_dict() dict_find_int_value() dict_find() dict_at_node() dict_size() dict_find_string_value() dict_find_list() dict_find_string()
│ │ │
│ │ │ +std::int64_t dict_find_int_value (string_view key
│ │ │ + , std::int64_t default_val = 0) const;
│ │ │ +bdecode_node dict_find_list (string_view key) const;
│ │ │ +bdecode_node dict_find (string_view key) const;
│ │ │ bdecode_node dict_find_int (string_view key) const;
│ │ │ +bdecode_node dict_find_dict (string_view key) const;
│ │ │ string_view dict_find_string_value (string_view key
│ │ │ , string_view default_value = string_view()) const;
│ │ │ -bdecode_node dict_find_list (string_view key) const;
│ │ │ -bdecode_node dict_find_dict (string_view key) const;
│ │ │ -std::int64_t dict_find_int_value (string_view key
│ │ │ - , std::int64_t default_val = 0) const;
│ │ │ int dict_size () const;
│ │ │ -std::pair<string_view, bdecode_node> dict_at (int i) const;
│ │ │ bdecode_node dict_find_string (string_view key) 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;
│ │ │
│ │ │
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.
│ │ │ @@ -19931,25 +19764,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_ptr() string_value() string_offset() string_length()
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
string_value() string_length() string_ptr() string_offset()
│ │ │
│ │ │ +string_view string_value () const;
│ │ │ +int string_length () const;
│ │ │ std::ptrdiff_t string_offset () const;
│ │ │ char const* string_ptr () const;
│ │ │ -int string_length () const;
│ │ │ -string_view string_value () 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]
│ │ │ @@ -20050,19 +19883,19 @@
│ │ │
│ │ │
bdecode()
│ │ │
Declared in "libtorrent/bdecode.hpp"
│ │ │
│ │ │ bdecode_node bdecode (span<char const> buffer
│ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ , int token_limit = 2000000);
│ │ │ +bdecode_node bdecode (span<char const> buffer
│ │ │ + , int depth_limit = 100, int token_limit = 2000000);
│ │ │ int bdecode (char const* start, char const* end, bdecode_node& ret
│ │ │ , error_code& ec, int* error_pos = nullptr, int depth_limit = 100
│ │ │ , int token_limit = 2000000);
│ │ │ -bdecode_node bdecode (span<char const> buffer
│ │ │ - , int depth_limit = 100, int token_limit = 2000000);
│ │ │
│ │ │
This function decodes/parses bdecoded data (for example a .torrent file).
│ │ │ The data structure is returned in the ret argument. the buffer to parse
│ │ │ is specified by the start of the buffer as well as the end, i.e. one
│ │ │ byte past the end. If the buffer fails to parse, the function returns a
│ │ │ non-zero value and fills in ec with the error code. The optional
│ │ │ argument error_pos, if set to non-nullptr, will be set to the byte offset
│ │ │ @@ -20077,41 +19910,182 @@
│ │ │ those bdecode_node objects will simply have references to the root or
│ │ │ owning bdecode_node. If the root node is destructed, all other nodes
│ │ │ that refer to anything in that tree become invalid.
│ │ │
However, the underlying buffer passed in to this function (start, end)
│ │ │ must also remain valid while the bdecoded tree is used. The parsed tree
│ │ │ produced by this function does not copy any data out of the buffer, but
│ │ │ simply produces references back into it.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_state
│ │ │ -
Declared in "libtorrent/kademlia/dht_state.hpp"
│ │ │ -
This structure helps to store and load the state
│ │ │ -of the dht_tracker.
│ │ │ -At this moment the library is only a dual stack
│ │ │ -implementation of the DHT. See BEP 32
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
ip_filter
│ │ │ +
Declared in "libtorrent/ip_filter.hpp"
│ │ │ +
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 ip_filter does not filter any address.
│ │ │
│ │ │ -struct dht_state
│ │ │ +struct ip_filter
│ │ │ {
│ │ │ - void clear ();
│ │ │ + ip_filter (ip_filter&&);
│ │ │ + ip_filter ();
│ │ │ + ip_filter& operator= (ip_filter&&);
│ │ │ + ip_filter (ip_filter const&);
│ │ │ + ~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;
│ │ │
│ │ │ - node_ids_t nids;
│ │ │ - std::vector<udp::endpoint> nodes;
│ │ │ - std::vector<udp::endpoint> nodes6;
│ │ │ + enum access_flags
│ │ │ + {
│ │ │ + blocked,
│ │ │ + };
│ │ │ };
│ │ │
│ │ │ -
[report issue]
│ │ │ -- nodes
│ │ │ -- the bootstrap nodes saved from the buckets node
│ │ │ -
│ │ │ -
[report issue]
│ │ │ -- nodes6
│ │ │ -- the bootstrap nodes saved from the IPv6 buckets node
│ │ │ -
│ │ │ +
[report issue]
│ │ │ +
empty()
│ │ │ +
│ │ │ +bool empty () const;
│ │ │ +
│ │ │ +
returns true if the filter does not contain any rules
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
add_rule()
│ │ │ +
│ │ │ +void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ +
│ │ │ +
Adds a rule to the filter. first and last defines a range of
│ │ │ +ip addresses that will be marked with the given flags. The flags
│ │ │ +can currently be 0, which means allowed, or ip_filter::blocked, which
│ │ │ +means disallowed.
│ │ │ +
precondition:
│ │ │ +first.is_v4() == last.is_v4() && first.is_v6() == last.is_v6()
│ │ │ +
postcondition:
│ │ │ +access(x) == flags for every x in the range [first, last]
│ │ │ +
This means that in a case of overlapping ranges, the last one applied takes
│ │ │ +precedence.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
access()
│ │ │ +
│ │ │ +std::uint32_t access (address const& addr) const;
│ │ │ +
│ │ │ +
Returns the access permissions for the given address (addr). The permission
│ │ │ +can currently be 0 or ip_filter::blocked. The complexity of this operation
│ │ │ +is O(log n), where n is the minimum number of non-overlapping ranges to describe
│ │ │ +the current filter.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
export_filter()
│ │ │ +
│ │ │ +filter_tuple_t export_filter () const;
│ │ │ +
│ │ │ +
This function will return the current state of the filter in the minimum number of
│ │ │ +ranges possible. They are sorted from ranges in low addresses to high addresses. Each
│ │ │ +entry in the returned vector is a range with the access control specified in its
│ │ │ +flags field.
│ │ │ +
The return value is a tuple containing two range-lists. One for IPv4 addresses
│ │ │ +and one for IPv6 addresses.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum access_flags
│ │ │ +
Declared in "libtorrent/ip_filter.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| blocked |
│ │ │ +1 |
│ │ │ +indicates that IPs in this range should not be connected
│ │ │ +to nor accepted as incoming connections |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
│ │ │ +
port_filter
│ │ │ +
Declared in "libtorrent/ip_filter.hpp"
│ │ │ +
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 const&);
│ │ │ + port_filter& operator= (port_filter&&);
│ │ │ + port_filter& operator= (port_filter const&);
│ │ │ + ~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,
│ │ │ + };
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
add_rule()
│ │ │ +
│ │ │ +void add_rule (std::uint16_t first, std::uint16_t last, std::uint32_t flags);
│ │ │ +
│ │ │ +
set the flags for the specified port range (first, last) to
│ │ │ +flags overwriting any existing rule for those ports. The range
│ │ │ +is inclusive, i.e. the port last also has the flag set on it.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
access()
│ │ │ +
│ │ │ +std::uint32_t access (std::uint16_t port) const;
│ │ │ +
│ │ │ +
test the specified port (port) for whether it is blocked
│ │ │ +or not. The returned value is the flags set for this port.
│ │ │ +see access_flags.
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
enum access_flags
│ │ │ +
Declared in "libtorrent/ip_filter.hpp"
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │ +| name |
│ │ │ +value |
│ │ │ +description |
│ │ │ +
|---|
│ │ │ +
│ │ │ +
│ │ │ +| blocked |
│ │ │ +1 |
│ │ │ +this flag indicates that destination ports in the
│ │ │ +range should not be connected to |
│ │ │ +
│ │ │ +
│ │ │ +
│ │ │
[report issue]
│ │ │ +
│ │ │
│ │ │
│ │ │
counters()
│ │ │
│ │ │ virtual dht_storage_counters counters () const = 0;
│ │ │
│ │ │
return stats counters for the store
│ │ │ -
[report issue]
│ │ │ +
[report issue]
│ │ │
│ │ │ +
│ │ │ +
dht_state
│ │ │ +
Declared in "libtorrent/kademlia/dht_state.hpp"
│ │ │ +
This structure helps to store and load the state
│ │ │ +of the dht_tracker.
│ │ │ +At this moment the library is only a dual stack
│ │ │ +implementation of the DHT. See BEP 32
│ │ │ +
│ │ │ +struct dht_state
│ │ │ +{
│ │ │ + void clear ();
│ │ │ +
│ │ │ + node_ids_t nids;
│ │ │ + std::vector<udp::endpoint> nodes;
│ │ │ + std::vector<udp::endpoint> nodes6;
│ │ │ +};
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- nodes
│ │ │ +- the bootstrap nodes saved from the buckets node
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +- nodes6
│ │ │ +- the bootstrap nodes saved from the IPv6 buckets node
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
dht_default_storage_constructor()
│ │ │ +
Declared in "libtorrent/kademlia/dht_storage.hpp"
│ │ │ +
│ │ │ +std::unique_ptr<dht_storage_interface> dht_default_storage_constructor (
│ │ │ + settings_interface const& settings);
│ │ │ +
│ │ │ +
constructor for the default DHT storage. The DHT storage is responsible
│ │ │ +for maintaining peers and mutable and immutable items announced and
│ │ │ +stored/put to the DHT node.
│ │ │ +
[report issue]
│ │ │
│ │ │
sign_mutable_item()
│ │ │
Declared in "libtorrent/kademlia/item.hpp"
│ │ │
│ │ │ signature sign_mutable_item (
│ │ │ span<char const> v
│ │ │ , span<char const> salt
│ │ │ @@ -20353,25 +20364,14 @@
│ │ │
│ │ │
given a byte range v and an optional byte range salt, a
│ │ │ sequence number, public key pk (must be 32 bytes) and a secret key
│ │ │ sk (must be 64 bytes), this function produces a signature which
│ │ │ is written into a 64 byte buffer pointed to by sig. The caller
│ │ │ is responsible for allocating the destination buffer that's passed in
│ │ │ as the sig argument. Typically it would be allocated on the stack.
│ │ │ -
[report issue]
│ │ │ -
│ │ │ -
dht_default_storage_constructor()
│ │ │ -
Declared in "libtorrent/kademlia/dht_storage.hpp"
│ │ │ -
│ │ │ -std::unique_ptr<dht_storage_interface> dht_default_storage_constructor (
│ │ │ - settings_interface const& settings);
│ │ │ -
│ │ │ -
constructor for the default DHT storage. The DHT storage is responsible
│ │ │ -for maintaining peers and mutable and immutable items announced and
│ │ │ -stored/put to the DHT node.
│ │ │
[report issue]
│ │ │
│ │ │
announce_flags_t
│ │ │
Declared in "libtorrent/kademlia/announce_flags.hpp"
│ │ │
│ │ │ - seed
│ │ │ - announce to DHT as a seed
│ │ │ @@ -20387,22 +20387,22 @@
│ │ │ - Specify the port number for the SSL listen socket in the DHT announce.
│ │ │
│ │ │
[report issue]
│ │ │
│ │ │
read_resume_data()
│ │ │
Declared in "libtorrent/read_resume_data.hpp"
│ │ │
│ │ │ +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
│ │ │ , error_code& ec, int piece_limit = 0x200000);
│ │ │ -add_torrent_params read_resume_data (bdecode_node const& rd
│ │ │ - , 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
│ │ │ @@ -20410,35 +20410,35 @@
│ │ │
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"
│ │ │
│ │ │ -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()
│ │ │ +
│ │ │ +
[report issue]
│ │ │ +
│ │ │ +
write_torrent_file() write_torrent_file_buf()
│ │ │
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);
│ │ │ 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, 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 {}
│ │ │ │ @@ -1,341 +1,313 @@
│ │ │ │ >
│ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ VVeerrssiioonn:: 2.0.11
│ │ │ │ _h_o_m_e
│ │ │ │ Table of contents
│ │ │ │ - * _s_t_o_r_a_g_e___e_r_r_o_r
│ │ │ │ + * _c_o_u_n_t_e_r_s
│ │ │ │ + o _i_n_c___s_t_a_t_s___c_o_u_n_t_e_r_(_)_ _o_p_e_r_a_t_o_r_[_]_(_)
│ │ │ │ + * _s_t_a_t_s___m_e_t_r_i_c
│ │ │ │ + * _s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_)
│ │ │ │ + * _f_i_n_d___m_e_t_r_i_c___i_d_x_(_)
│ │ │ │ + * _e_n_u_m_ _m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ + * _p_e_e_r___r_e_q_u_e_s_t
│ │ │ │ + o _o_p_e_r_a_t_o_r_=_=_(_)
│ │ │ │ + * _i_n_f_o___h_a_s_h___t
│ │ │ │ + o _i_n_f_o___h_a_s_h___t_(_)
│ │ │ │ + o _h_a_s___v_1_(_)_ _h_a_s___v_2_(_)_ _h_a_s_(_)
│ │ │ │ + o _g_e_t_(_)
│ │ │ │ + o _g_e_t___b_e_s_t_(_)
│ │ │ │ + o _f_o_r___e_a_c_h_(_)
│ │ │ │ + * _p_e_e_r___i_n_f_o
│ │ │ │ + o _i_2_p___d_e_s_t_i_n_a_t_i_o_n_(_)
│ │ │ │ + * _p_i_e_c_e___b_l_o_c_k
│ │ │ │ + * _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___f_i_l_e_(_)_ _l_o_a_d___t_o_r_r_e_n_t___p_a_r_s_e_d_(_)
│ │ │ │ + * _t_r_u_n_c_a_t_e___f_i_l_e_s_(_)
│ │ │ │ + * _t_o_r_r_e_n_t___p_e_e_r___e_q_u_a_l_(_)
│ │ │ │ + * _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_(_)
│ │ │ │ + * _v_e_r_s_i_o_n_(_)
│ │ │ │ + * _e_n_u_m_ _c_o_n_n_e_c_t_i_o_n___t_y_p_e
│ │ │ │ + * _e_n_u_m_ _p_r_o_t_o_c_o_l___v_e_r_s_i_o_n
│ │ │ │ + * _e_n_u_m_ _e_v_e_n_t___t
│ │ │ │ + * _e_n_u_m_ _s_o_c_k_e_t___t_y_p_e___t
│ │ │ │ + * _e_n_u_m_ _p_o_r_t_m_a_p___t_r_a_n_s_p_o_r_t
│ │ │ │ + * _e_n_u_m_ _p_o_r_t_m_a_p___p_r_o_t_o_c_o_l
│ │ │ │ + * _d_o_w_n_l_o_a_d___p_r_i_o_r_i_t_y___t
│ │ │ │ + * _p_e_x___f_l_a_g_s___t
│ │ │ │ + * _i_n_t
│ │ │ │ + * _c_h_a_r_ _c_o_n_s_t_*
│ │ │ │ + * _s_t_d_:_:_u_i_n_t_6_4___t
│ │ │ │ + * _t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ + * _d_i_s_k___o_b_s_e_r_v_e_r
│ │ │ │ + o _o_n___d_i_s_k_(_)
│ │ │ │ + * _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
│ │ │ │ + o _n_e_w___t_o_r_r_e_n_t_(_)
│ │ │ │ + o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ + o _a_s_y_n_c___r_e_a_d_(_)_ _a_s_y_n_c___w_r_i_t_e_(_)
│ │ │ │ + o _a_s_y_n_c___h_a_s_h_(_)
│ │ │ │ + o _a_s_y_n_c___h_a_s_h_2_(_)
│ │ │ │ + o _a_s_y_n_c___m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ + o _a_s_y_n_c___r_e_l_e_a_s_e___f_i_l_e_s_(_)
│ │ │ │ + o _a_s_y_n_c___c_h_e_c_k___f_i_l_e_s_(_)
│ │ │ │ + o _a_s_y_n_c___s_t_o_p___t_o_r_r_e_n_t_(_)
│ │ │ │ + o _a_s_y_n_c___r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ + o _a_s_y_n_c___d_e_l_e_t_e___f_i_l_e_s_(_)
│ │ │ │ + o _a_s_y_n_c___s_e_t___f_i_l_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ + o _a_s_y_n_c___c_l_e_a_r___p_i_e_c_e_(_)
│ │ │ │ + o _u_p_d_a_t_e___s_t_a_t_s___c_o_u_n_t_e_r_s_(_)
│ │ │ │ + o _g_e_t___s_t_a_t_u_s_(_)
│ │ │ │ + o _a_b_o_r_t_(_)
│ │ │ │ + o _s_u_b_m_i_t___j_o_b_s_(_)
│ │ │ │ + o _s_e_t_t_i_n_g_s___u_p_d_a_t_e_d_(_)
│ │ │ │ + * _s_t_o_r_a_g_e___h_o_l_d_e_r
│ │ │ │ + * _s_e_t_t_i_n_g_s___i_n_t_e_r_f_a_c_e
│ │ │ │ + * _b_u_f_f_e_r___a_l_l_o_c_a_t_o_r___i_n_t_e_r_f_a_c_e
│ │ │ │ + * _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r
│ │ │ │ + o _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_(_)
│ │ │ │ + o _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_(_)
│ │ │ │ + o _~_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_(_)
│ │ │ │ + o _d_a_t_a_(_)
│ │ │ │ + o _r_e_s_e_t_(_)
│ │ │ │ + o _s_w_a_p_(_)
│ │ │ │ + o _i_s___m_u_t_a_b_l_e_(_)
│ │ │ │ o _b_o_o_l_(_)
│ │ │ │ - o _f_i_l_e_(_)
│ │ │ │ - * _l_i_b_t_o_r_r_e_n_t___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _h_t_t_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _g_z_i_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _u_p_n_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _i_2_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _s_o_c_k_s___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _p_c_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _b_d_e_c_o_d_e___c_a_t_e_g_o_r_y_(_)
│ │ │ │ - * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ - * _e_n_u_m_ _h_t_t_p___e_r_r_o_r_s
│ │ │ │ - * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ - * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ - * _e_n_u_m_ _i_2_p___e_r_r_o_r___c_o_d_e
│ │ │ │ - * _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
│ │ │ │ + * _f_i_l_e___o_p_e_n___m_o_d_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 _o_p_e_r_a_t_o_r_=_(_)_ _~_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 _e_n_u_m_ _t_r_a_c_k_e_r___s_o_u_r_c_e
│ │ │ │ * _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_(_)_ _~_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
│ │ │ │ - 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 _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 _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 _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_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 _i_s___p_a_u_s_e_d_(_)_ _r_e_s_u_m_e_(_)_ _p_a_u_s_e_(_)
│ │ │ │ + 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 _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 _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 _s_s_l___l_i_s_t_e_n___p_o_r_t_(_)_ _i_s___l_i_s_t_e_n_i_n_g_(_)_ _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 _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 _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 _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 _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 _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_(_)_ _p_o_p___a_l_e_r_t_s_(_)
│ │ │ │ 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_(_)_ _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_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 _a_d_d___t_r_a_c_k_e_r_(_)_ _t_r_a_c_k_e_r_s_(_)_ _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 _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ - o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ - o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ - 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 _i_n_f_o___h_a_s_h_(_)_ _i_n_f_o___h_a_s_h_e_s_(_)
│ │ │ │ - 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___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_(_)
│ │ │ │ - o _i_n_f_o_(_)
│ │ │ │ - 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___v_2_(_)_ _h_a_s_(_)_ _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___f_i_l_e_(_)_ _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_(_)
│ │ │ │ - * _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
│ │ │ │ - * _e_n_u_m_ _p_o_r_t_m_a_p___t_r_a_n_s_p_o_r_t
│ │ │ │ - * _e_n_u_m_ _p_o_r_t_m_a_p___p_r_o_t_o_c_o_l
│ │ │ │ - * _e_n_u_m_ _e_v_e_n_t___t
│ │ │ │ - * _e_n_u_m_ _c_o_n_n_e_c_t_i_o_n___t_y_p_e
│ │ │ │ - * _d_o_w_n_l_o_a_d___p_r_i_o_r_i_t_y___t
│ │ │ │ - * _i_n_t
│ │ │ │ - * _c_h_a_r_ _c_o_n_s_t_*
│ │ │ │ - * _s_t_d_:_:_u_i_n_t_6_4___t
│ │ │ │ - * _p_e_x___f_l_a_g_s___t
│ │ │ │ - * _t_o_r_r_e_n_t___f_l_a_g_s___t
│ │ │ │ - * _a_ _w_o_r_d_ _o_f_ _c_a_u_t_i_o_n
│ │ │ │ - * _p_l_u_g_i_n_-_i_n_t_e_r_f_a_c_e
│ │ │ │ - * _c_u_s_t_o_m_ _a_l_e_r_t_s
│ │ │ │ - * _p_l_u_g_i_n
│ │ │ │ - o _i_m_p_l_e_m_e_n_t_e_d___f_e_a_t_u_r_e_s_(_)
│ │ │ │ - o _n_e_w___t_o_r_r_e_n_t_(_)
│ │ │ │ - o _a_d_d_e_d_(_)
│ │ │ │ + * _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ + o _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___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_(_)
│ │ │ │ - o _o_n___d_h_t___r_e_q_u_e_s_t_(_)
│ │ │ │ - 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___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___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___r_e_q_u_e_s_t_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___h_a_v_e___a_l_l_(_)_ _o_n___c_h_o_k_e_(_)
│ │ │ │ - _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___u_n_c_h_o_k_e_(_)_ _o_n___a_l_l_o_w_e_d___f_a_s_t_(_)
│ │ │ │ - _o_n___h_a_v_e___n_o_n_e_(_)_ _o_n___h_a_v_e_(_)_ _o_n___b_i_t_f_i_e_l_d_(_)
│ │ │ │ - o _o_n___p_i_e_c_e_(_)
│ │ │ │ - o _s_e_n_t___h_a_v_e_(_)_ _s_e_n_t___u_n_c_h_o_k_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___p_i_e_c_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_(_)
│ │ │ │ - * _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_(_)
│ │ │ │ - * _c_r_e_a_t_e___s_m_a_r_t___b_a_n___p_l_u_g_i_n_(_)
│ │ │ │ - * _c_r_e_a_t_e___u_t___m_e_t_a_d_a_t_a___p_l_u_g_i_n_(_)
│ │ │ │ + * _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___b_u_f_(_)
│ │ │ │ + * _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 _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
│ │ │ │ + * _p_e_e_r___c_l_a_s_s___i_n_f_o
│ │ │ │ * _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_(_)_ _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)
│ │ │ │ + o _a_d_d___f_i_l_e___b_o_r_r_o_w_(_)_ _a_d_d___f_i_l_e_(_)
│ │ │ │ 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_(_)
│ │ │ │ o _s_e_t___n_u_m___p_i_e_c_e_s_(_)_ _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 _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 _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___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 _f_i_l_e___p_a_t_h_(_)_ _f_i_l_e___o_f_f_s_e_t_(_)_ _m_t_i_m_e_(_)_ _f_i_l_e___n_a_m_e_(_)_ _f_i_l_e___s_i_z_e_(_)_ _h_a_s_h_(_)
│ │ │ │ - _s_y_m_l_i_n_k_(_)_ _r_o_o_t___p_t_r_(_)_ _p_a_d___f_i_l_e___a_t_(_)_ _r_o_o_t_(_)
│ │ │ │ - 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 _m_t_i_m_e_(_)_ _f_i_l_e___n_a_m_e_(_)_ _s_y_m_l_i_n_k_(_)_ _f_i_l_e___p_a_t_h_(_)_ _r_o_o_t___p_t_r_(_)_ _h_a_s_h_(_)
│ │ │ │ + _f_i_l_e___o_f_f_s_e_t_(_)_ _f_i_l_e___s_i_z_e_(_)_ _r_o_o_t_(_)_ _p_a_d___f_i_l_e___a_t_(_)
│ │ │ │ + o _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_(_)_ _f_i_l_e___n_u_m___p_i_e_c_e_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___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_(_)
│ │ │ │ * _p_o_s_i_x___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_(_)
│ │ │ │ * _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
│ │ │ │ + * _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 _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 _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 _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_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s
│ │ │ │ * _c_l_i_e_n_t___d_a_t_a___t
│ │ │ │ o _c_l_i_e_n_t___d_a_t_a___t_(_)
│ │ │ │ o _o_p_e_r_a_t_o_r_=_(_)_ _v_o_i_d_*_(_)_ _c_o_n_s_t_*_(_)
│ │ │ │ - * _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 _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
│ │ │ │ * _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 _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 _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 _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 _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_(_)_ _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 _r_e_m_o_v_e___h_t_t_p___s_e_e_d_(_)_ _h_t_t_p___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ + o _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_(_)_ _t_r_a_c_k_e_r_s_(_)_ _p_o_s_t___t_r_a_c_k_e_r_s_(_)
│ │ │ │ + o _a_d_d___u_r_l___s_e_e_d_(_)_ _r_e_m_o_v_e___u_r_l___s_e_e_d_(_)_ _u_r_l___s_e_e_d_s_(_)
│ │ │ │ + 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 _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 _s_e_t___f_l_a_g_s_(_)_ _f_l_a_g_s_(_)_ _u_n_s_e_t___f_l_a_g_s_(_)
│ │ │ │ + o _p_a_u_s_e_(_)_ _r_e_s_u_m_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___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_(_)_ _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___d_o_w_n_(_)_ _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___t_o_p_(_)_ _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___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 _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_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___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_(_)_ _f_o_r_c_e___d_h_t___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_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 _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_(_)_ _p_r_i_o_r_i_t_i_z_e___f_i_l_e_s_(_)
│ │ │ │ + o _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_(_)_ _f_o_r_c_e___r_e_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_(_)_ _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_(_)_ _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_(_)
│ │ │ │ _d_o_w_n_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 _s_e_t___m_a_x___u_p_l_o_a_d_s_(_)_ _m_a_x___u_p_l_o_a_d_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_(_)
│ │ │ │ - * _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
│ │ │ │ - o _n_e_w___t_o_r_r_e_n_t_(_)
│ │ │ │ - o _r_e_m_o_v_e___t_o_r_r_e_n_t_(_)
│ │ │ │ - o _a_s_y_n_c___w_r_i_t_e_(_)_ _a_s_y_n_c___r_e_a_d_(_)
│ │ │ │ - o _a_s_y_n_c___h_a_s_h_(_)
│ │ │ │ - o _a_s_y_n_c___h_a_s_h_2_(_)
│ │ │ │ - o _a_s_y_n_c___m_o_v_e___s_t_o_r_a_g_e_(_)
│ │ │ │ - o _a_s_y_n_c___r_e_l_e_a_s_e___f_i_l_e_s_(_)
│ │ │ │ - o _a_s_y_n_c___c_h_e_c_k___f_i_l_e_s_(_)
│ │ │ │ - o _a_s_y_n_c___s_t_o_p___t_o_r_r_e_n_t_(_)
│ │ │ │ - o _a_s_y_n_c___r_e_n_a_m_e___f_i_l_e_(_)
│ │ │ │ - o _a_s_y_n_c___d_e_l_e_t_e___f_i_l_e_s_(_)
│ │ │ │ - o _a_s_y_n_c___s_e_t___f_i_l_e___p_r_i_o_r_i_t_y_(_)
│ │ │ │ - o _a_s_y_n_c___c_l_e_a_r___p_i_e_c_e_(_)
│ │ │ │ - o _u_p_d_a_t_e___s_t_a_t_s___c_o_u_n_t_e_r_s_(_)
│ │ │ │ - o _g_e_t___s_t_a_t_u_s_(_)
│ │ │ │ - o _a_b_o_r_t_(_)
│ │ │ │ - o _s_u_b_m_i_t___j_o_b_s_(_)
│ │ │ │ - o _s_e_t_t_i_n_g_s___u_p_d_a_t_e_d_(_)
│ │ │ │ - * _s_t_o_r_a_g_e___h_o_l_d_e_r
│ │ │ │ - * _d_i_s_k___o_b_s_e_r_v_e_r
│ │ │ │ - o _o_n___d_i_s_k_(_)
│ │ │ │ - * _b_u_f_f_e_r___a_l_l_o_c_a_t_o_r___i_n_t_e_r_f_a_c_e
│ │ │ │ - * _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r
│ │ │ │ - o _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_(_)
│ │ │ │ - o _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_(_)
│ │ │ │ - o _~_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_(_)
│ │ │ │ - o _d_a_t_a_(_)
│ │ │ │ - o _r_e_s_e_t_(_)
│ │ │ │ - o _s_w_a_p_(_)
│ │ │ │ - o _i_s___m_u_t_a_b_l_e_(_)
│ │ │ │ - o _b_o_o_l_(_)
│ │ │ │ - * _s_e_t_t_i_n_g_s___i_n_t_e_r_f_a_c_e
│ │ │ │ - * _f_i_l_e___o_p_e_n___m_o_d_e___t
│ │ │ │ + * _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 _a_d_d___t_r_a_c_k_e_r_(_)_ _t_r_a_c_k_e_r_s_(_)_ _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 _a_d_d___u_r_l___s_e_e_d_(_)_ _w_e_b___s_e_e_d_s_(_)_ _s_e_t___w_e_b___s_e_e_d_s_(_)_ _a_d_d___h_t_t_p___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 _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___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_(_)
│ │ │ │ + o _i_n_f_o_(_)
│ │ │ │ + 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_(_)
│ │ │ │ * _a_l_e_r_t
│ │ │ │ o _t_i_m_e_s_t_a_m_p_(_)
│ │ │ │ o _t_y_p_e_(_)
│ │ │ │ o _w_h_a_t_(_)
│ │ │ │ o _m_e_s_s_a_g_e_(_)
│ │ │ │ o _c_a_t_e_g_o_r_y_(_)
│ │ │ │ * _d_h_t___r_o_u_t_i_n_g___b_u_c_k_e_t
│ │ │ │ @@ -344,15 +316,15 @@
│ │ │ │ * _p_e_e_r___a_l_e_r_t
│ │ │ │ * _t_r_a_c_k_e_r___a_l_e_r_t
│ │ │ │ o _t_r_a_c_k_e_r___u_r_l_(_)
│ │ │ │ * _t_o_r_r_e_n_t___r_e_m_o_v_e_d___a_l_e_r_t
│ │ │ │ * _r_e_a_d___p_i_e_c_e___a_l_e_r_t
│ │ │ │ * _f_i_l_e___c_o_m_p_l_e_t_e_d___a_l_e_r_t
│ │ │ │ * _f_i_l_e___r_e_n_a_m_e_d___a_l_e_r_t
│ │ │ │ - o _o_l_d___n_a_m_e_(_)_ _n_e_w___n_a_m_e_(_)
│ │ │ │ + o _n_e_w___n_a_m_e_(_)_ _o_l_d___n_a_m_e_(_)
│ │ │ │ * _f_i_l_e___r_e_n_a_m_e___f_a_i_l_e_d___a_l_e_r_t
│ │ │ │ * _p_e_r_f_o_r_m_a_n_c_e___a_l_e_r_t
│ │ │ │ o _e_n_u_m_ _p_e_r_f_o_r_m_a_n_c_e___w_a_r_n_i_n_g___t
│ │ │ │ * _s_t_a_t_e___c_h_a_n_g_e_d___a_l_e_r_t
│ │ │ │ * _t_r_a_c_k_e_r___e_r_r_o_r___a_l_e_r_t
│ │ │ │ o _f_a_i_l_u_r_e___r_e_a_s_o_n_(_)
│ │ │ │ * _t_r_a_c_k_e_r___w_a_r_n_i_n_g___a_l_e_r_t
│ │ │ │ @@ -376,15 +348,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
│ │ │ │ @@ -466,49 +438,107 @@
│ │ │ │ * _o_v_e_r_s_i_z_e_d___f_i_l_e___a_l_e_r_t
│ │ │ │ * _t_o_r_r_e_n_t___c_o_n_f_l_i_c_t___a_l_e_r_t
│ │ │ │ * _p_e_e_r___i_n_f_o___a_l_e_r_t
│ │ │ │ * _f_i_l_e___p_r_o_g_r_e_s_s___a_l_e_r_t
│ │ │ │ * _p_i_e_c_e___i_n_f_o___a_l_e_r_t
│ │ │ │ * _p_i_e_c_e___a_v_a_i_l_a_b_i_l_i_t_y___a_l_e_r_t
│ │ │ │ * _t_r_a_c_k_e_r___l_i_s_t___a_l_e_r_t
│ │ │ │ - * _a_l_e_r_t___c_a_s_t_(_)
│ │ │ │ * _o_p_e_r_a_t_i_o_n___n_a_m_e_(_)
│ │ │ │ + * _a_l_e_r_t___c_a_s_t_(_)
│ │ │ │ * _e_n_u_m_ _o_p_e_r_a_t_i_o_n___t
│ │ │ │ * _a_l_e_r_t___c_a_t_e_g_o_r_y___t
│ │ │ │ * _i_n_t
│ │ │ │ - * _c_o_u_n_t_e_r_s
│ │ │ │ - o _o_p_e_r_a_t_o_r_[_]_(_)_ _i_n_c___s_t_a_t_s___c_o_u_n_t_e_r_(_)
│ │ │ │ - * _s_t_a_t_s___m_e_t_r_i_c
│ │ │ │ - * _s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_)
│ │ │ │ - * _f_i_n_d___m_e_t_r_i_c___i_d_x_(_)
│ │ │ │ - * _e_n_u_m_ _m_e_t_r_i_c___t_y_p_e___t
│ │ │ │ - * _i_p___f_i_l_t_e_r
│ │ │ │ - o _e_m_p_t_y_(_)
│ │ │ │ - o _a_d_d___r_u_l_e_(_)
│ │ │ │ - o _a_c_c_e_s_s_(_)
│ │ │ │ - o _e_x_p_o_r_t___f_i_l_t_e_r_(_)
│ │ │ │ - o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ - * _p_o_r_t___f_i_l_t_e_r
│ │ │ │ - o _a_d_d___r_u_l_e_(_)
│ │ │ │ - o _a_c_c_e_s_s_(_)
│ │ │ │ - o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ - * _e_n_t_r_y
│ │ │ │ + * _s_t_o_r_a_g_e___e_r_r_o_r
│ │ │ │ + o _b_o_o_l_(_)
│ │ │ │ + o _f_i_l_e_(_)
│ │ │ │ + * _g_z_i_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _p_c_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _s_o_c_k_s___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _i_2_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _l_i_b_t_o_r_r_e_n_t___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _h_t_t_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _u_p_n_p___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _b_d_e_c_o_d_e___c_a_t_e_g_o_r_y_(_)
│ │ │ │ + * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ + * _e_n_u_m_ _p_c_p___e_r_r_o_r_s
│ │ │ │ + * _e_n_u_m_ _s_o_c_k_s___e_r_r_o_r___c_o_d_e
│ │ │ │ + * _e_n_u_m_ _i_2_p___e_r_r_o_r___c_o_d_e
│ │ │ │ + * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ + * _e_n_u_m_ _h_t_t_p___e_r_r_o_r_s
│ │ │ │ + * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ + * _e_n_u_m_ _e_r_r_o_r___c_o_d_e___e_n_u_m
│ │ │ │ + * _a_ _w_o_r_d_ _o_f_ _c_a_u_t_i_o_n
│ │ │ │ + * _p_l_u_g_i_n_-_i_n_t_e_r_f_a_c_e
│ │ │ │ + * _c_u_s_t_o_m_ _a_l_e_r_t_s
│ │ │ │ + * _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
│ │ │ │ + * _p_l_u_g_i_n
│ │ │ │ + o _i_m_p_l_e_m_e_n_t_e_d___f_e_a_t_u_r_e_s_(_)
│ │ │ │ + o _n_e_w___t_o_r_r_e_n_t_(_)
│ │ │ │ + o _a_d_d_e_d_(_)
│ │ │ │ + o _a_b_o_r_t_(_)
│ │ │ │ + o _o_n___d_h_t___r_e_q_u_e_s_t_(_)
│ │ │ │ + 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___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___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 _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 _l_i_s_t_(_)_ _d_i_c_t_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _s_t_r_i_n_g_(_)_ _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_(_)
│ │ │ │ + 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___a_l_l_o_w_e_d___f_a_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___u_n_c_h_o_k_e_(_)_ _o_n___c_h_o_k_e_(_)_ _o_n___d_o_n_t___h_a_v_e_(_)_ _o_n___r_e_q_u_e_s_t_(_)_ _o_n___h_a_v_e___a_l_l_(_)
│ │ │ │ + _o_n___n_o_t___i_n_t_e_r_e_s_t_e_d_(_)_ _o_n___h_a_v_e_(_)
│ │ │ │ + o _o_n___p_i_e_c_e_(_)
│ │ │ │ + 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___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_(_)
│ │ │ │ + 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_(_)
│ │ │ │ + * _c_r_y_p_t_o___p_l_u_g_i_n
│ │ │ │ + o _d_e_c_r_y_p_t_(_)
│ │ │ │ + * _c_r_e_a_t_e___s_m_a_r_t___b_a_n___p_l_u_g_i_n_(_)
│ │ │ │ + * _c_r_e_a_t_e___u_t___p_e_x___p_l_u_g_i_n_(_)
│ │ │ │ + * _c_r_e_a_t_e___u_t___m_e_t_a_d_a_t_a___p_l_u_g_i_n_(_)
│ │ │ │ + * _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ + o _s_e_t___b_o_o_l_(_)_ _s_e_t___i_n_t_(_)_ _s_e_t___s_t_r_(_)
│ │ │ │ + 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 _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_(_)
│ │ │ │ + * _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_(_)
│ │ │ │ + * _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_(_)
│ │ │ │ * _c_r_e_a_t_e___t_o_r_r_e_n_t
│ │ │ │ o _c_r_e_a_t_e___t_o_r_r_e_n_t_(_)
│ │ │ │ o _g_e_n_e_r_a_t_e___b_u_f_(_)_ _g_e_n_e_r_a_t_e_(_)
│ │ │ │ o _f_i_l_e_s_(_)
│ │ │ │ o _s_e_t___c_o_m_m_e_n_t_(_)
│ │ │ │ o _s_e_t___c_r_e_a_t_o_r_(_)
│ │ │ │ o _s_e_t___c_r_e_a_t_i_o_n___d_a_t_e_(_)
│ │ │ │ @@ -520,2005 +550,237 @@
│ │ │ │ o _s_e_t___r_o_o_t___c_e_r_t_(_)
│ │ │ │ o _s_e_t___p_r_i_v_(_)_ _p_r_i_v_(_)
│ │ │ │ o _n_u_m___p_i_e_c_e_s_(_)
│ │ │ │ o _p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ o _f_i_l_e___r_a_n_g_e_(_)
│ │ │ │ o _f_i_l_e___p_i_e_c_e___r_a_n_g_e_(_)
│ │ │ │ o _t_o_t_a_l___s_i_z_e_(_)
│ │ │ │ - o _p_i_e_c_e___l_e_n_g_t_h_(_)_ _p_i_e_c_e___s_i_z_e_(_)
│ │ │ │ - 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_(_)
│ │ │ │ + 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___s_i_m_i_l_a_r___t_o_r_r_e_n_t_(_)_ _a_d_d___c_o_l_l_e_c_t_i_o_n_(_)
│ │ │ │ * _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 _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_(_)
│ │ │ │ + * _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 _i_n_t_e_g_e_r_(_)_ _l_i_s_t_(_)_ _s_t_r_i_n_g_(_)_ _p_r_e_f_o_r_m_a_t_t_e_d_(_)_ _d_i_c_t_(_)
│ │ │ │ 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 _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 _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_(_)_ _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___s_t_r_(_)_ _s_e_t___i_n_t_(_)_ _s_e_t___b_o_o_l_(_)
│ │ │ │ - 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
│ │ │ │ - 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_(_)
│ │ │ │ - * _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_(_)
│ │ │ │ + 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
│ │ │ │ + * _b_e_n_c_o_d_e_(_)
│ │ │ │ + * _o_p_e_r_a_t_o_r_<_<_(_)
│ │ │ │ * _b_d_e_c_o_d_e___n_o_d_e
│ │ │ │ o _b_d_e_c_o_d_e___n_o_d_e_(_)
│ │ │ │ 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___s_i_z_e_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)_ _l_i_s_t___a_t_(_)
│ │ │ │ - o _d_i_c_t___f_i_n_d___i_n_t___v_a_l_u_e_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___f_i_n_d___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d_(_)
│ │ │ │ - _d_i_c_t___a_t___n_o_d_e_(_)_ _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___s_i_z_e_(_)
│ │ │ │ - _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g___v_a_l_u_e_(_)
│ │ │ │ + o _l_i_s_t___a_t_(_)_ _l_i_s_t___s_i_z_e_(_)_ _l_i_s_t___i_n_t___v_a_l_u_e___a_t_(_)_ _l_i_s_t___s_t_r_i_n_g___v_a_l_u_e___a_t_(_)
│ │ │ │ + o _d_i_c_t___a_t_(_)_ _d_i_c_t___f_i_n_d___i_n_t_(_)_ _d_i_c_t___f_i_n_d___d_i_c_t_(_)_ _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___a_t___n_o_d_e_(_)_ _d_i_c_t___s_i_z_e_(_)_ _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___l_i_s_t_(_)_ _d_i_c_t___f_i_n_d___s_t_r_i_n_g_(_)
│ │ │ │ o _i_n_t___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___o_f_f_s_e_t_(_)_ _s_t_r_i_n_g___l_e_n_g_t_h_(_)
│ │ │ │ + o _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___p_t_r_(_)_ _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_(_)
│ │ │ │ * _b_d_e_c_o_d_e_(_)
│ │ │ │ - * _d_h_t___s_t_a_t_e
│ │ │ │ + * _i_p___f_i_l_t_e_r
│ │ │ │ + o _e_m_p_t_y_(_)
│ │ │ │ + o _a_d_d___r_u_l_e_(_)
│ │ │ │ + o _a_c_c_e_s_s_(_)
│ │ │ │ + o _e_x_p_o_r_t___f_i_l_t_e_r_(_)
│ │ │ │ + o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ + * _p_o_r_t___f_i_l_t_e_r
│ │ │ │ + o _a_d_d___r_u_l_e_(_)
│ │ │ │ + o _a_c_c_e_s_s_(_)
│ │ │ │ + o _e_n_u_m_ _a_c_c_e_s_s___f_l_a_g_s
│ │ │ │ * _d_h_t___s_t_o_r_a_g_e___c_o_u_n_t_e_r_s
│ │ │ │ o _r_e_s_e_t_(_)
│ │ │ │ * _d_h_t___s_t_o_r_a_g_e___i_n_t_e_r_f_a_c_e
│ │ │ │ o _u_p_d_a_t_e___n_o_d_e___i_d_s_(_)
│ │ │ │ o _g_e_t___p_e_e_r_s_(_)
│ │ │ │ o _a_n_n_o_u_n_c_e___p_e_e_r_(_)
│ │ │ │ o _g_e_t___i_m_m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ o _p_u_t___i_m_m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ o _g_e_t___m_u_t_a_b_l_e___i_t_e_m___s_e_q_(_)
│ │ │ │ o _g_e_t___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ o _p_u_t___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ 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___s_t_a_t_e
│ │ │ │ * _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_(_)
│ │ │ │ + * _s_i_g_n___m_u_t_a_b_l_e___i_t_e_m_(_)
│ │ │ │ * _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___b_u_f_(_)_ _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_)
│ │ │ │ + * _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_(_)_ _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_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_(_)
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ 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;
│ │ │ │ - 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(()) **********
│ │ │ │ -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
│ │ │ │ - A code from _o_p_e_r_a_t_i_o_n___t enum, indicating what kind of operation failed.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ lliibbttoorrrreenntt__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ -boost::system::error_category& lliibbttoorrrreenntt__ccaatteeggoorryy ();
│ │ │ │ -return the instance of the libtorrent_error_category which maps libtorrent
│ │ │ │ -error codes to human readable error messages.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ hhttttpp__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ -boost::system::error_category& hhttttpp__ccaatteeggoorryy ();
│ │ │ │ -returns the error_category for HTTP errors
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ggzziipp__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_g_z_i_p_._h_p_p"
│ │ │ │ -boost::system::error_category& ggzziipp__ccaatteeggoorryy ();
│ │ │ │ -get the error_category for zip errors
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ uuppnnpp__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_u_p_n_p_._h_p_p"
│ │ │ │ -boost::system::error_category& uuppnnpp__ccaatteeggoorryy ();
│ │ │ │ -the boost.system error category for UPnP errors
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ii22pp__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_2_p___s_t_r_e_a_m_._h_p_p"
│ │ │ │ -boost::system::error_category& ii22pp__ccaatteeggoorryy ();
│ │ │ │ -returns the error category for I2P errors
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ssoocckkss__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_o_c_k_s_5___s_t_r_e_a_m_._h_p_p"
│ │ │ │ -boost::system::error_category& ssoocckkss__ccaatteeggoorryy ();
│ │ │ │ -returns the error_category for SOCKS5 errors
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ppccpp__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_n_a_t_p_m_p_._h_p_p"
│ │ │ │ -boost::system::error_category& ppccpp__ccaatteeggoorryy ();
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ bbddeeccooddee__ccaatteeggoorryy(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_d_e_c_o_d_e_._h_p_p"
│ │ │ │ -boost::system::error_category& bbddeeccooddee__ccaatteeggoorryy ();
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm eerrrroorr__ccooddee__eennuumm ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_0_ _ _ _ _|_N_o_t_ _a_n_ _e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|file_collision |1 |Two torrents has files which end |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_u_p_ _o_v_e_r_w_r_i_t_i_n_g_ _e_a_c_h_ _o_t_h_e_r_ _ _ _ _ _ _ _ _ |
│ │ │ │ -|failed_hash_check |2 |A piece did not match its piece |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_h_a_s_h_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The .torrent file does not contain|
│ │ │ │ -|torrent_is_no_dict |3 |a bencoded dictionary at its top |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_l_e_v_e_l_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_info |4 |The .torrent file does not have an|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_f_o_ _d_i_c_t_i_o_n_a_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_info_no_dict |5 |The .torrent file's info _e_n_t_r_y is |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_n_o_t_ _a_ _d_i_c_t_i_o_n_a_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_piece_length |6 |The .torrent file does not have a |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_i_e_c_e_ _l_e_n_g_t_h_ _e_n_t_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_name |7 |The .torrent file does not have a |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_n_a_m_e_ _e_n_t_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_invalid_name |8 |The .torrent file's name _e_n_t_r_y is |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The length of a file, or of the |
│ │ │ │ -|torrent_invalid_length |9 |whole .torrent file is invalid. |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_E_i_t_h_e_r_ _n_e_g_a_t_i_v_e_ _o_r_ _n_o_t_ _a_n_ _i_n_t_e_g_e_r_ |
│ │ │ │ -|torrent_file_parse_failed |10 |Failed to parse a file _e_n_t_r_y in |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _._t_o_r_r_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_pieces |11 |The pieces field is missing or |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _i_n_ _t_h_e_ _._t_o_r_r_e_n_t_ _f_i_l_e_ _ _ _ _ _ |
│ │ │ │ -|torrent_invalid_hashes |12 |The pieces string has incorrect |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_l_e_n_g_t_h_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|too_many_pieces_in_torrent |13 |The .torrent file has more pieces |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_a_n_ _i_s_ _s_u_p_p_o_r_t_e_d_ _b_y_ _l_i_b_t_o_r_r_e_n_t_ _ _ |
│ │ │ │ -| | |The metadata (.torrent file) that |
│ │ │ │ -|invalid_swarm_metadata |14 |was received from the swarm |
│ │ │ │ -| | |matched the info-hash, but failed |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_o_ _b_e_ _p_a_r_s_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_bencoding |15 |The file or buffer is not |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_r_r_e_c_t_l_y_ _b_e_n_c_o_d_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|no_files_in_torrent |16 |The .torrent file does not contain|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_n_y_ _f_i_l_e_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_escaped_string |17 |The string was not properly url- |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_n_c_o_d_e_d_ _a_s_ _e_x_p_e_c_t_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|session_is_closing |18 |Operation is not permitted since |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _s_e_s_s_i_o_n_ _i_s_ _s_h_u_t_t_i_n_g_ _d_o_w_n_ _ _ _ _ _ |
│ │ │ │ -| | |There's already a torrent with |
│ │ │ │ -|duplicate_torrent |19 |that info-hash added to the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_e_s_s_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_torrent_handle |20 |The supplied _t_o_r_r_e_n_t___h_a_n_d_l_e is not|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_f_e_r_r_i_n_g_ _t_o_ _a_ _v_a_l_i_d_ _t_o_r_r_e_n_t_ _ _ _ _ _ |
│ │ │ │ -|invalid_entry_type |21 |The type requested from the _e_n_t_r_y |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_d_i_d_ _n_o_t_ _m_a_t_c_h_ _i_t_s_ _t_y_p_e_ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|missing_info_hash_in_uri |22 |The specified URI does not contain|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_ _v_a_l_i_d_ _i_n_f_o_-_h_a_s_h_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |One of the files in the torrent |
│ │ │ │ -|file_too_short |23 |was unexpectedly small. This might|
│ │ │ │ -| | |be caused by files being changed |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_b_y_ _a_n_ _e_x_t_e_r_n_a_l_ _p_r_o_c_e_s_s_ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The URL used an unknown protocol. |
│ │ │ │ -| | |Currently http and https (if built|
│ │ │ │ -|unsupported_url_protocol |24 |with openssl support) are |
│ │ │ │ -| | |recognized. For trackers udp is |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_c_o_g_n_i_z_e_d_ _a_s_ _w_e_l_l_._ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|url_parse_error |25 |The URL did not conform to URL |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_y_n_t_a_x_ _a_n_d_ _f_a_i_l_e_d_ _t_o_ _b_e_ _p_a_r_s_e_d_ _ _ _ |
│ │ │ │ -|peer_sent_empty_piece |26 |The peer sent a piece message of |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_l_e_n_g_t_h_ _0_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|parse_failed |27 |A bencoded structure was corrupt |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_n_d_ _f_a_i_l_e_d_ _t_o_ _b_e_ _p_a_r_s_e_d_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_file_tag |28 |The fast resume file was missing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_r_ _h_a_d_ _a_n_ _i_n_v_a_l_i_d_ _f_i_l_e_ _v_e_r_s_i_o_n_ _t_a_g|
│ │ │ │ -|missing_info_hash |29 |The fast resume file was missing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_r_ _h_a_d_ _a_n_ _i_n_v_a_l_i_d_ _i_n_f_o_-_h_a_s_h_ _ _ _ _ _ _ |
│ │ │ │ -|mismatching_info_hash |30 |The info-hash did not match the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_o_r_r_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_hostname |31 |The URL contained an invalid |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_h_o_s_t_n_a_m_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___p_o_r_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_3_2_ _ _ _|_T_h_e_ _U_R_L_ _h_a_d_ _a_n_ _i_n_v_a_l_i_d_ _p_o_r_t_ _ _ _ _ _ _ |
│ │ │ │ -| | |The port is blocked by the port- |
│ │ │ │ -|port_blocked |33 |filter, and prevented the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_n_n_e_c_t_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|expected_close_bracket_in_address |34 |The IPv6 address was expected to |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_n_d_ _w_i_t_h_ _"_]_"_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The torrent is being destructed, |
│ │ │ │ -|destructing_torrent |35 |preventing the operation to |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_u_c_c_e_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_t_i_m_e_d___o_u_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_3_6_ _ _ _|_T_h_e_ _c_o_n_n_e_c_t_i_o_n_ _t_i_m_e_d_ _o_u_t_ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer is upload only, and we |
│ │ │ │ -|upload_upload_connection |37 |are upload only. There's no point |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_ _k_e_e_p_i_n_g_ _t_h_e_ _c_o_n_n_e_c_t_i_o_n_ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer is upload only, and we're|
│ │ │ │ -|uninteresting_upload_peer |38 |not interested in it. There's no |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_o_i_n_t_ _i_n_ _k_e_e_p_i_n_g_ _t_h_e_ _c_o_n_n_e_c_t_i_o_n_ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___i_n_f_o___h_a_s_h_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_3_9_ _ _ _|_T_h_e_ _p_e_e_r_ _s_e_n_t_ _a_n_ _u_n_k_n_o_w_n_ _i_n_f_o_-_h_a_s_h|
│ │ │ │ -|torrent_paused |40 |The torrent is paused, preventing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _o_p_e_r_a_t_i_o_n_ _f_r_o_m_ _s_u_c_c_e_e_d_i_n_g_ _ _ _ _ |
│ │ │ │ -| | |The peer sent an invalid have |
│ │ │ │ -|invalid_have |41 |message, either wrong size or |
│ │ │ │ -| | |referring to a piece that doesn't |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_x_i_s_t_ _i_n_ _t_h_e_ _t_o_r_r_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_bitfield_size |42 |The _b_i_t_f_i_e_l_d message had the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_c_o_r_r_e_c_t_ _s_i_z_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer kept requesting pieces |
│ │ │ │ -|too_many_requests_when_choked |43 |after it was choked, possible |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_b_u_s_e_ _a_t_t_e_m_p_t_._ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer sent a piece message that|
│ │ │ │ -|invalid_piece |44 |does not correspond to a piece |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_q_u_e_s_t_ _s_e_n_t_ _b_y_ _t_h_e_ _c_l_i_e_n_t_ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___m_e_m_o_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_4_5_ _ _ _|_m_e_m_o_r_y_ _a_l_l_o_c_a_t_i_o_n_ _f_a_i_l_e_d_ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_aborted |46 |The torrent is aborted, preventing|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _o_p_e_r_a_t_i_o_n_ _t_o_ _s_u_c_c_e_e_d_ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|self_connection |47 |The peer is a connection to |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_u_r_s_e_l_f_,_ _n_o_ _p_o_i_n_t_ _i_n_ _k_e_e_p_i_n_g_ _i_t_ _ _ |
│ │ │ │ -| | |The peer sent a piece message with|
│ │ │ │ -|invalid_piece_size |48 |invalid size, either negative or |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_g_r_e_a_t_e_r_ _t_h_a_n_ _o_n_e_ _b_l_o_c_k_ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer has not been interesting |
│ │ │ │ -|timed_out_no_interest |49 |or interested in us for too long, |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_n_o_ _p_o_i_n_t_ _i_n_ _k_e_e_p_i_n_g_ _i_t_ _a_r_o_u_n_d_ _ _ _ _ |
│ │ │ │ -|timed_out_inactivity |50 |The peer has not said anything in |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_ _l_o_n_g_ _t_i_m_e_,_ _p_o_s_s_i_b_l_y_ _d_e_a_d_ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer did not send a handshake |
│ │ │ │ -|timed_out_no_handshake |51 |within a reasonable amount of |
│ │ │ │ -| | |time, it might not be a bittorrent|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_e_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer has been unchoked for too|
│ │ │ │ -|timed_out_no_request |52 |long without requesting any data. |
│ │ │ │ -| | |It might be lying about its |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_t_e_r_e_s_t_ _i_n_ _u_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_choke |53 |The peer sent an invalid choke |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_unchoke |54 |The peer send an invalid unchoke |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_interested |55 |The peer sent an invalid |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_t_e_r_e_s_t_e_d_ _m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_not_interested |56 |The peer sent an invalid not- |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_t_e_r_e_s_t_e_d_ _m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_request |57 |The peer sent an invalid piece |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_q_u_e_s_t_ _m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer sent an invalid hash-list|
│ │ │ │ -|invalid_hash_list |58 |message (this is part of the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_r_k_l_e_-_t_o_r_r_e_n_t_ _e_x_t_e_n_s_i_o_n_)_ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer sent an invalid hash- |
│ │ │ │ -|invalid_hash_piece |59 |piece message (this is part of the|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_r_k_l_e_-_t_o_r_r_e_n_t_ _e_x_t_e_n_s_i_o_n_)_ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_cancel |60 |The peer sent an invalid cancel |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_dht_port |61 |The peer sent an invalid DHT port-|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_suggest |62 |The peer sent an invalid suggest |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_i_e_c_e_-_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_have_all |63 |The peer sent an invalid have all-|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_have_none |64 |The peer sent an invalid have |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_n_o_n_e_-_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_reject |65 |The peer sent an invalid reject |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_allow_fast |66 |The peer sent an invalid allow |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_f_a_s_t_-_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_extended |67 |The peer sent an invalid extension|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _I_D_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_message |68 |The peer sent an invalid message |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_I_D_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|sync_hash_not_found |69 |The synchronization hash was not |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_f_o_u_n_d_ _i_n_ _t_h_e_ _e_n_c_r_y_p_t_e_d_ _h_a_n_d_s_h_a_k_e_ _ |
│ │ │ │ -|invalid_encryption_constant |70 |The encryption constant in the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_h_a_n_d_s_h_a_k_e_ _i_s_ _i_n_v_a_l_i_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|no_plaintext_mode |71 |The peer does not support plain |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_e_x_t_,_ _w_h_i_c_h_ _i_s_ _t_h_e_ _s_e_l_e_c_t_e_d_ _m_o_d_e_ _ |
│ │ │ │ -|no_rc4_mode |72 |The peer does not support RC4, |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_w_h_i_c_h_ _i_s_ _t_h_e_ _s_e_l_e_c_t_e_d_ _m_o_d_e_ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer does not support any of |
│ │ │ │ -|unsupported_encryption_mode |73 |the encryption modes that the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_l_i_e_n_t_ _s_u_p_p_o_r_t_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer selected an encryption |
│ │ │ │ -|unsupported_encryption_mode_selected|74 |mode that the client did not |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_d_v_e_r_t_i_s_e_ _a_n_d_ _d_o_e_s_ _n_o_t_ _s_u_p_p_o_r_t_ _ _ _ |
│ │ │ │ -| | |The pad size used in the |
│ │ │ │ -|invalid_pad_size |75 |encryption handshake is of invalid|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_i_z_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_encrypt_handshake |76 |The encryption handshake is |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The client is set to not support |
│ │ │ │ -|no_incoming_encrypted |77 |incoming encrypted connections and|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_i_s_ _i_s_ _a_n_ _e_n_c_r_y_p_t_e_d_ _c_o_n_n_e_c_t_i_o_n_ _ _ |
│ │ │ │ -| | |The client is set to not support |
│ │ │ │ -|no_incoming_regular |78 |incoming regular bittorrent |
│ │ │ │ -| | |connections, and this is a regular|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_n_n_e_c_t_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|duplicate_peer_id |79 |The client is already connected to|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_i_s_ _p_e_e_r_-_I_D_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_t_o_r_r_e_n_t___r_e_m_o_v_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_8_0_ _ _ _|_T_o_r_r_e_n_t_ _w_a_s_ _r_e_m_o_v_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|packet_too_large |81 |The packet size exceeded the upper|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_a_n_i_t_y_ _c_h_e_c_k_-_l_i_m_i_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_r_e_s_e_r_v_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_8_2_ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|http_error |83 |The web server responded with an |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|missing_location |84 |The web server response is missing|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_ _l_o_c_a_t_i_o_n_ _h_e_a_d_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The web seed redirected to a path |
│ │ │ │ -|invalid_redirection |85 |that no longer matches the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_._t_o_r_r_e_n_t_ _d_i_r_e_c_t_o_r_y_ _s_t_r_u_c_t_u_r_e_ _ _ _ _ _ |
│ │ │ │ -|redirecting |86 |The connection was closed because |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_t_ _r_e_d_i_r_e_c_t_e_d_ _t_o_ _a_ _d_i_f_f_e_r_e_n_t_ _U_R_L_ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___r_a_n_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_8_7_ _ _ _|_T_h_e_ _H_T_T_P_ _r_a_n_g_e_ _h_e_a_d_e_r_ _i_s_ _i_n_v_a_l_i_d_ _ |
│ │ │ │ -|no_content_length |88 |The HTTP response did not have a |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_n_t_e_n_t_ _l_e_n_g_t_h_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_b_a_n_n_e_d___b_y___i_p___f_i_l_t_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_8_9_ _ _ _|_T_h_e_ _I_P_ _i_s_ _b_l_o_c_k_e_d_ _b_y_ _t_h_e_ _I_P_ _f_i_l_t_e_r|
│ │ │ │ -|_t_o_o___m_a_n_y___c_o_n_n_e_c_t_i_o_n_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_9_0_ _ _ _|_A_t_ _t_h_e_ _c_o_n_n_e_c_t_i_o_n_ _l_i_m_i_t_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_e_e_r___b_a_n_n_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_9_1_ _ _ _|_T_h_e_ _p_e_e_r_ _i_s_ _m_a_r_k_e_d_ _a_s_ _b_a_n_n_e_d_ _ _ _ _ _ |
│ │ │ │ -|stopping_torrent |92 |The torrent is stopping, causing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _o_p_e_r_a_t_i_o_n_ _t_o_ _f_a_i_l_ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|too_many_corrupt_pieces |93 |The peer has sent too many corrupt|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_i_e_c_e_s_ _a_n_d_ _i_s_ _b_a_n_n_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_not_ready |94 |The torrent is not ready to |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_c_e_i_v_e_ _p_e_e_r_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|peer_not_constructed |95 |The peer is not completely |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_n_s_t_r_u_c_t_e_d_ _y_e_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|session_closing |96 |The _s_e_s_s_i_o_n is closing, causing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _o_p_e_r_a_t_i_o_n_ _t_o_ _f_a_i_l_ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer was disconnected in order|
│ │ │ │ -|optimistic_disconnect |97 |to leave room for a potentially |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_b_e_t_t_e_r_ _p_e_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_t_o_r_r_e_n_t___f_i_n_i_s_h_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_9_8_ _ _ _|_T_h_e_ _t_o_r_r_e_n_t_ _i_s_ _f_i_n_i_s_h_e_d_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___r_o_u_t_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_9_9_ _ _ _|_N_o_ _U_P_n_P_ _r_o_u_t_e_r_ _f_o_u_n_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|metadata_too_large |100 |The metadata message says the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_t_a_d_a_t_a_ _e_x_c_e_e_d_s_ _t_h_e_ _l_i_m_i_t_ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_metadata_request |101 |The peer sent an invalid metadata |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_q_u_e_s_t_ _m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_metadata_size |102 |The peer advertised an invalid |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_t_a_d_a_t_a_ _s_i_z_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_metadata_offset |103 |The peer sent a message with an |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _m_e_t_a_d_a_t_a_ _o_f_f_s_e_t_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_metadata_message |104 |The peer sent an invalid metadata |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|pex_message_too_large |105 |The peer sent a peer exchange |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_s_s_a_g_e_ _t_h_a_t_ _w_a_s_ _t_o_o_ _l_a_r_g_e_ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_pex_message |106 |The peer sent an invalid peer |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_x_c_h_a_n_g_e_ _m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_lt_tracker_message |107 |The peer sent an invalid tracker |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_x_c_h_a_n_g_e_ _m_e_s_s_a_g_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer sent an pex messages too |
│ │ │ │ -|too_frequent_pex |108 |often. This is a possible attempt |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_f_ _a_n_d_ _a_t_t_a_c_k_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The operation failed because it |
│ │ │ │ -| | |requires the torrent to have the |
│ │ │ │ -| | |metadata (.torrent file) and it |
│ │ │ │ -|no_metadata |109 |doesn't have it yet. This happens |
│ │ │ │ -| | |for magnet links before they have |
│ │ │ │ -| | |downloaded the metadata, and also |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_o_r_r_e_n_t_s_ _a_d_d_e_d_ _b_y_ _U_R_L_._ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer sent an invalid dont_have|
│ │ │ │ -| | |message. The don't have message is|
│ │ │ │ -|invalid_dont_have |110 |an extension to allow peers to |
│ │ │ │ -| | |advertise that the no longer has a|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_i_e_c_e_ _t_h_e_y_ _p_r_e_v_i_o_u_s_l_y_ _h_a_d_._ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer tried to connect to an |
│ │ │ │ -|requires_ssl_connection |111 |SSL torrent without connecting |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_v_e_r_ _S_S_L_._ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The peer tried to connect to a |
│ │ │ │ -|invalid_ssl_cert |112 |torrent with a certificate for a |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_d_i_f_f_e_r_e_n_t_ _t_o_r_r_e_n_t_._ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |the torrent is not an SSL torrent,|
│ │ │ │ -|not_an_ssl_torrent |113 |and the operation requires an SSL |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_o_r_r_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |peer was banned because its listen|
│ │ │ │ -|banned_by_port_filter |114 |port is within a banned port |
│ │ │ │ -| | |range, as specified by the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_o_r_t___f_i_l_t_e_r_._ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_session_handle |115 |The _s_e_s_s_i_o_n___h_a_n_d_l_e is not |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_f_e_r_r_i_n_g_ _t_o_ _a_ _v_a_l_i_d_ _s_e_s_s_i_o_n___i_m_p_l_ |
│ │ │ │ -|invalid_listen_socket |116 |the listen socket associated with |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_i_s_ _r_e_q_u_e_s_t_ _w_a_s_ _c_l_o_s_e_d_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___h_a_s_h___r_e_q_u_e_s_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_1_7_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___h_a_s_h_e_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_1_8_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___h_a_s_h___r_e_j_e_c_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_1_9_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_e_p_r_e_c_a_t_e_d___1_2_0_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_2_0_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_e_p_r_e_c_a_t_e_d___1_2_1_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_2_1_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_e_p_r_e_c_a_t_e_d___1_2_2_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_2_2_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_e_p_r_e_c_a_t_e_d___1_2_3_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_2_3_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_e_p_r_e_c_a_t_e_d___1_2_4_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_2_4_ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|missing_file_sizes |130 |The resume data file is missing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _f_i_l_e_ _s_i_z_e_s_ _e_n_t_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|no_files_in_resume_data |131 |The resume data file file sizes |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_e_n_t_r_y_ _i_s_ _e_m_p_t_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|missing_pieces |132 |The resume data file is missing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_h_e_ _p_i_e_c_e_s_ _a_n_d_ _s_l_o_t_s_ _e_n_t_r_y_ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The number of files in the resume |
│ │ │ │ -|mismatching_number_of_files |133 |data does not match the number of |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_f_i_l_e_s_ _i_n_ _t_h_e_ _t_o_r_r_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |One of the files on disk has a |
│ │ │ │ -|mismatching_file_size |134 |different size than in the fast |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_s_u_m_e_ _f_i_l_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |One of the files on disk has a |
│ │ │ │ -|mismatching_file_timestamp |135 |different timestamp than in the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_f_a_s_t_ _r_e_s_u_m_e_ _f_i_l_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|not_a_dictionary |136 |The resume data file is not a |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_d_i_c_t_i_o_n_a_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_blocks_per_piece |137 |The blocks per piece _e_n_t_r_y is |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _i_n_ _t_h_e_ _r_e_s_u_m_e_ _d_a_t_a_ _f_i_l_e_ _ _ |
│ │ │ │ -| | |The resume file is missing the |
│ │ │ │ -|missing_slots |138 |slots _e_n_t_r_y, which is required for|
│ │ │ │ -| | |torrents with compact allocation. |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_DD_EE_PP_RR_EE_CC_AA_TT_EE_DD_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|too_many_slots |139 |The resume file contains more |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_l_o_t_s_ _t_h_a_n_ _t_h_e_ _t_o_r_r_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_slot_list |140 |The slot _e_n_t_r_y is invalid in the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_s_u_m_e_ _d_a_t_a_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_piece_index |141 |One index in the slot list is |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The pieces on disk needs to be re-|
│ │ │ │ -| | |ordered for the specified |
│ │ │ │ -| | |allocation mode. This happens if |
│ │ │ │ -|pieces_need_reorder |142 |you specify sparse allocation and |
│ │ │ │ -| | |the files on disk are using |
│ │ │ │ -| | |compact storage. The pieces needs |
│ │ │ │ -| | |to be moved to their right |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_o_s_i_t_i_o_n_._ _DD_EE_PP_RR_EE_CC_AA_TT_EE_DD_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |this error is returned when asking|
│ │ │ │ -| | |to save resume data and specifying|
│ │ │ │ -|resume_data_not_modified |143 |the flag to only save when there's|
│ │ │ │ -| | |anything new to save |
│ │ │ │ -| | |(_t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_o_n_l_y___i_f___m_o_d_i_f_i_e_d)|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_n_d_ _t_h_e_r_e_ _w_a_s_n_'_t_ _a_n_y_t_h_i_n_g_ _c_h_a_n_g_e_d_.|
│ │ │ │ -|invalid_save_path |144 |the save_path in |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s_ _i_s_ _n_o_t_ _v_a_l_i_d_ _ _ |
│ │ │ │ -|http_parse_error |150 |The HTTP header was not correctly |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_f_o_r_m_a_t_t_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The HTTP response was in the 300- |
│ │ │ │ -|http_missing_location |151 |399 range but lacked a location |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_h_e_a_d_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The HTTP response was encoded with|
│ │ │ │ -|http_failed_decompress |152 |gzip or deflate but decompressing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_t_ _f_a_i_l_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|no_i2p_router |160 |The URL specified an i2p address, |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_b_u_t_ _n_o_ _i_2_p_ _r_o_u_t_e_r_ _i_s_ _c_o_n_f_i_g_u_r_e_d_ _ _ |
│ │ │ │ -|no_i2p_endpoint |161 |i2p acceptor is not available yet,|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_a_n_'_t_ _a_n_n_o_u_n_c_e_ _w_i_t_h_o_u_t_ _e_n_d_p_o_i_n_t_ _ _ |
│ │ │ │ -| | |The tracker URL doesn't support |
│ │ │ │ -|scrape_not_available |170 |transforming it into a scrape URL.|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_._e_._ _i_t_ _d_o_e_s_n_'_t_ _c_o_n_t_a_i_n_ _"_a_n_n_o_u_n_c_e_.|
│ │ │ │ -|_i_n_v_a_l_i_d___t_r_a_c_k_e_r___r_e_s_p_o_n_s_e_ _ _ _ _ _ _ _ _ _ _ _ _|_1_7_1_ _ _|_i_n_v_a_l_i_d_ _t_r_a_c_k_e_r_ _r_e_s_p_o_n_s_e_ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_peer_dict |172 |invalid peer dictionary _e_n_t_r_y. Not|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_ _d_i_c_t_i_o_n_a_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_t_r_a_c_k_e_r___f_a_i_l_u_r_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_7_3_ _ _|_t_r_a_c_k_e_r_ _s_e_n_t_ _a_ _f_a_i_l_u_r_e_ _m_e_s_s_a_g_e_ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___f_i_l_e_s___e_n_t_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_7_4_ _ _|_m_i_s_s_i_n_g_ _o_r_ _i_n_v_a_l_i_d_ _f_i_l_e_s_ _e_n_t_r_y_ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___h_a_s_h___e_n_t_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_7_5_ _ _|_m_i_s_s_i_n_g_ _o_r_ _i_n_v_a_l_i_d_ _h_a_s_h_ _e_n_t_r_y_ _ _ _ _ |
│ │ │ │ -|invalid_peers_entry |176 |missing or invalid peers and |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_e_e_r_s_6_ _e_n_t_r_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_tracker_response_length |177 |UDP tracker response packet has |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _s_i_z_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_tracker_transaction_id |178 |invalid transaction id in UDP |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_r_a_c_k_e_r_ _r_e_s_p_o_n_s_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_tracker_action |179 |invalid action field in UDP |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_r_a_c_k_e_r_ _r_e_s_p_o_n_s_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |skipped announce (because it's |
│ │ │ │ -|announce_skipped |180 |assumed to be unreachable over the|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_g_i_v_e_n_ _s_o_u_r_c_e_ _n_e_t_w_o_r_k_ _i_n_t_e_r_f_a_c_e_)_ _ _ |
│ │ │ │ -|_n_o___e_n_t_r_o_p_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_2_0_0_ _ _|_r_a_n_d_o_m_ _n_u_m_b_e_r_ _g_e_n_e_r_a_t_i_o_n_ _f_a_i_l_e_d_ _ _ |
│ │ │ │ -|_s_s_r_f___m_i_t_i_g_a_t_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_2_0_1_ _ _|_b_l_o_c_k_e_d_ _b_y_ _S_S_R_F_ _m_i_t_i_g_a_t_i_o_n_ _ _ _ _ _ _ _ |
│ │ │ │ -|blocked_by_idna |202 |blocked because IDNA host names |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_a_r_e_ _b_a_n_n_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_unknown_version |210 |the torrent file has an unknown |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_e_t_a_ _v_e_r_s_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_file_tree |211 |the v2 torrent file has no file |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_r_e_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_meta_version |212 |the torrent contains v2 keys but |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_d_o_e_s_ _n_o_t_ _s_p_e_c_i_f_y_ _m_e_t_a_ _v_e_r_s_i_o_n_ _2_ _ _ |
│ │ │ │ -|torrent_inconsistent_files |213 |the v1 and v2 file metadata does |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_n_o_t_ _m_a_t_c_h_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_missing_piece_layer |214 |one or more files are missing |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_i_e_c_e_ _l_a_y_e_r_ _h_a_s_h_e_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_invalid_piece_layer |215 |a piece layer has the wrong size |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_r_ _f_a_i_l_e_d_ _h_a_s_h_ _c_h_e_c_k_ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_t_o_r_r_e_n_t___m_i_s_s_i_n_g___p_i_e_c_e_s___r_o_o_t_ _ _ _ _ _ _ _ _ _|_2_1_6_ _ _|_a_ _v_2_ _f_i_l_e_ _e_n_t_r_y_ _h_a_s_ _n_o_ _r_o_o_t_ _h_a_s_h_ _ |
│ │ │ │ -|torrent_inconsistent_hashes |217 |the v1 and v2 hashes do not |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_d_e_s_c_r_i_b_e_ _t_h_e_ _s_a_m_e_ _d_a_t_a_ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|torrent_invalid_pad_file |218 |a file in the v2 metadata has the |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_a_d_ _a_t_t_r_i_b_u_t_e_ _s_e_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_e_r_r_o_r___c_o_d_e___m_a_x_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_2_1_9_ _ _|_t_h_e_ _n_u_m_b_e_r_ _o_f_ _e_r_r_o_r_ _c_o_d_e_s_ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm hhttttpp__eerrrroorrss ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_e_r_r_o_r___c_o_d_e_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_c_o_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_0_0_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_o_k_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_2_0_0_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_c_r_e_a_t_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_2_0_1_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_a_c_c_e_p_t_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _|_2_0_2_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___c_o_n_t_e_n_t_ _ _ _ _ _ _ _ _ _ _ _|_2_0_4_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_m_u_l_t_i_p_l_e___c_h_o_i_c_e_s_ _ _ _ _ _|_3_0_0_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_m_o_v_e_d___p_e_r_m_a_n_e_n_t_l_y_ _ _ _ _|_3_0_1_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_m_o_v_e_d___t_e_m_p_o_r_a_r_i_l_y_ _ _ _ _|_3_0_2_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o_t___m_o_d_i_f_i_e_d_ _ _ _ _ _ _ _ _ _|_3_0_4_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_b_a_d___r_e_q_u_e_s_t_ _ _ _ _ _ _ _ _ _ _|_4_0_0_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_n_a_u_t_h_o_r_i_z_e_d_ _ _ _ _ _ _ _ _ _|_4_0_1_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_f_o_r_b_i_d_d_e_n_ _ _ _ _ _ _ _ _ _ _ _ _|_4_0_3_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o_t___f_o_u_n_d_ _ _ _ _ _ _ _ _ _ _ _ _|_4_0_4_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_t_e_r_n_a_l___s_e_r_v_e_r___e_r_r_o_r_|_5_0_0_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o_t___i_m_p_l_e_m_e_n_t_e_d_ _ _ _ _ _ _|_5_0_1_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_b_a_d___g_a_t_e_w_a_y_ _ _ _ _ _ _ _ _ _ _|_5_0_2_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_s_e_r_v_i_c_e___u_n_a_v_a_i_l_a_b_l_e_ _ _|_5_0_3_ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm eerrrroorr__ccooddee__eennuumm ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_g_z_i_p_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_0_ _ _ _ _|_N_o_t_ _a_n_ _e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_gzip_header |1 |the supplied gzip buffer has |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _h_e_a_d_e_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |the gzip buffer would inflate to |
│ │ │ │ -|inflated_data_too_large |2 |more bytes than the specified |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_a_x_i_m_u_m_ _s_i_z_e_,_ _a_n_d_ _w_a_s_ _r_e_j_e_c_t_e_d_._ _ _ _ |
│ │ │ │ -|data_did_not_terminate |3 |available inflate data did not |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_t_e_r_m_i_n_a_t_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|space_exhausted |4 |output space exhausted before |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_m_p_l_e_t_i_n_g_ _i_n_f_l_a_t_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___b_l_o_c_k___t_y_p_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_5_ _ _ _ _|_i_n_v_a_l_i_d_ _b_l_o_c_k_ _t_y_p_e_ _(_t_y_p_e_ _=_=_ _3_)_ _ _ _ _ |
│ │ │ │ -|invalid_stored_block_length |6 |stored block length did not match |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_n_e_'_s_ _c_o_m_p_l_e_m_e_n_t_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|too_many_length_or_distance_codes |7 |dynamic block code description: too|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_a_n_y_ _l_e_n_g_t_h_ _o_r_ _d_i_s_t_a_n_c_e_ _c_o_d_e_s_ _ _ _ _ _ |
│ │ │ │ -|code_lengths_codes_incomplete |8 |dynamic block code description: |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_d_e_ _l_e_n_g_t_h_s_ _c_o_d_e_s_ _i_n_c_o_m_p_l_e_t_e_ _ _ _ _ _ |
│ │ │ │ -|repeat_lengths_with_no_first_length|9 |dynamic block code description: |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_p_e_a_t_ _l_e_n_g_t_h_s_ _w_i_t_h_ _n_o_ _f_i_r_s_t_ _l_e_n_g_t_h|
│ │ │ │ -|repeat_more_than_specified_lengths |10 |dynamic block code description: |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_r_e_p_e_a_t_ _m_o_r_e_ _t_h_a_n_ _s_p_e_c_i_f_i_e_d_ _l_e_n_g_t_h_s_ |
│ │ │ │ -|invalid_literal_length_code_lengths|11 |dynamic block code description: |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _l_i_t_e_r_a_l_/_l_e_n_g_t_h_ _c_o_d_e_ _l_e_n_g_t_h_s|
│ │ │ │ -|invalid_distance_code_lengths |12 |dynamic block code description: |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_v_a_l_i_d_ _d_i_s_t_a_n_c_e_ _c_o_d_e_ _l_e_n_g_t_h_s_ _ _ _ _ _ |
│ │ │ │ -|invalid_literal_code_in_block |13 |invalid literal/length or distance |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_o_d_e_ _i_n_ _f_i_x_e_d_ _o_r_ _d_y_n_a_m_i_c_ _b_l_o_c_k_ _ _ _ _ |
│ │ │ │ -|distance_too_far_back_in_block |14 |distance is too far back in fixed |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_o_r_ _d_y_n_a_m_i_c_ _b_l_o_c_k_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|unknown_gzip_error |15 |an unknown error occurred during |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_g_z_i_p_ _i_n_f_l_a_t_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_e_r_r_o_r___c_o_d_e___m_a_x_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_6_ _ _ _|_t_h_e_ _n_u_m_b_e_r_ _o_f_ _e_r_r_o_r_ _c_o_d_e_s_ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm eerrrroorr__ccooddee__eennuumm ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_u_p_n_p_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_0_ _ _ _ _|_N_o_ _e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|invalid_argument |402 |One of the arguments in the request |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_s_ _i_n_v_a_l_i_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_a_c_t_i_o_n___f_a_i_l_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_5_0_1_ _ _|_T_h_e_ _r_e_q_u_e_s_t_ _f_a_i_l_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|value_not_in_array |714 |The specified value does not exist |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_i_n_ _t_h_e_ _a_r_r_a_y_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The source IP address cannot be |
│ │ │ │ -|source_ip_cannot_be_wildcarded |715 |wild-carded, but must be fully |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_p_e_c_i_f_i_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|external_port_cannot_be_wildcarded|716 |The external port cannot be a |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_w_i_l_d_c_a_r_d_,_ _b_u_t_ _m_u_s_t_ _b_e_ _s_p_e_c_i_f_i_e_d_ _ _ _ _ |
│ │ │ │ -| | |The port mapping _e_n_t_r_y specified |
│ │ │ │ -|port_mapping_conflict |718 |conflicts with a mapping assigned |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_p_r_e_v_i_o_u_s_l_y_ _t_o_ _a_n_o_t_h_e_r_ _c_l_i_e_n_t_ _ _ _ _ _ _ _ |
│ │ │ │ -|internal_port_must_match_external |724 |Internal and external port value |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_u_s_t_ _b_e_ _t_h_e_ _s_a_m_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |The NAT implementation only supports|
│ │ │ │ -|only_permanent_leases_supported |725 |permanent lease times on port |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_m_a_p_p_i_n_g_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -| | |RemoteHost must be a wildcard and |
│ │ │ │ -|remote_host_must_be_wildcard |726 |cannot be a specific IP address or |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_D_N_S_ _n_a_m_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|external_port_must_be_wildcard |727 |ExternalPort must be a wildcard and |
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_c_a_n_n_o_t_ _b_e_ _a_ _s_p_e_c_i_f_i_c_ _p_o_r_t_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm ii22pp__eerrrroorr__ccooddee ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_2_p___s_t_r_e_a_m_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_n_o___e_r_r_o_r_ _ _ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_a_r_s_e___f_a_i_l_e_d_ _ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_c_a_n_t___r_e_a_c_h___p_e_e_r_|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_2_p___e_r_r_o_r_ _ _ _ _ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___k_e_y_ _ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_n_v_a_l_i_d___i_d_ _ _ _ _ _|_5_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_t_i_m_e_o_u_t_ _ _ _ _ _ _ _ _|_6_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_k_e_y___n_o_t___f_o_u_n_d_ _ _|_7_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_u_p_l_i_c_a_t_e_d___i_d_ _ _|_8_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_u_m___e_r_r_o_r_s_ _ _ _ _ _|_9_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm ssoocckkss__eerrrroorr__ccooddee ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_o_c_k_s_5___s_t_r_e_a_m_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_n_o___e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_n_s_u_p_p_o_r_t_e_d___v_e_r_s_i_o_n_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_n_s_u_p_p_o_r_t_e_d___a_u_t_h_e_n_t_i_c_a_t_i_o_n___m_e_t_h_o_d_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_n_s_u_p_p_o_r_t_e_d___a_u_t_h_e_n_t_i_c_a_t_i_o_n___v_e_r_s_i_o_n_|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_a_u_t_h_e_n_t_i_c_a_t_i_o_n___e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_s_e_r_n_a_m_e___r_e_q_u_i_r_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_5_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_g_e_n_e_r_a_l___f_a_i_l_u_r_e_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_6_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_c_o_m_m_a_n_d___n_o_t___s_u_p_p_o_r_t_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _|_7_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___i_d_e_n_t_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_8_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_i_d_e_n_t_d___e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_9_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_u_m___e_r_r_o_r_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_1_0_ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm ppccpp__eerrrroorrss ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_n_a_t_p_m_p_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_p_c_p___s_u_c_c_e_s_s_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___u_n_s_u_p_p___v_e_r_s_i_o_n_ _ _ _ _ _ _ _ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___n_o_t___a_u_t_h_o_r_i_z_e_d_ _ _ _ _ _ _ _ _ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___m_a_l_f_o_r_m_e_d___r_e_q_u_e_s_t_ _ _ _ _ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___u_n_s_u_p_p___o_p_c_o_d_e_ _ _ _ _ _ _ _ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___u_n_s_u_p_p___o_p_t_i_o_n_ _ _ _ _ _ _ _ _ _ _|_5_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___m_a_l_f_o_r_m_e_d___o_p_t_i_o_n_ _ _ _ _ _ _ _|_6_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___n_e_t_w_o_r_k___f_a_i_l_u_r_e_ _ _ _ _ _ _ _ _|_7_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___n_o___r_e_s_o_u_r_c_e_s_ _ _ _ _ _ _ _ _ _ _ _|_8_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___u_n_s_u_p_p___p_r_o_t_o_c_o_l_ _ _ _ _ _ _ _ _|_9_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___u_s_e_r___e_x___q_u_o_t_a_ _ _ _ _ _ _ _ _ _ _|_1_0_ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___c_a_n_n_o_t___p_r_o_v_i_d_e___e_x_t_e_r_n_a_l_|_1_1_ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___a_d_d_r_e_s_s___m_i_s_m_a_t_c_h_ _ _ _ _ _ _ _|_1_2_ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_c_p___e_x_c_e_s_s_i_v_e___r_e_m_o_t_e___p_e_e_r_s_ _|_1_3_ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm eerrrroorr__ccooddee__eennuumm ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_b_d_e_c_o_d_e_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_n_o___e_r_r_o_r_ _ _ _ _ _ _|_0_ _ _ _ _|_N_o_t_ _a_n_ _e_r_r_o_r_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_e_x_p_e_c_t_e_d___d_i_g_i_t_|_1_ _ _ _ _|_e_x_p_e_c_t_e_d_ _d_i_g_i_t_ _i_n_ _b_e_n_c_o_d_e_d_ _s_t_r_i_n_g_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_e_x_p_e_c_t_e_d___c_o_l_o_n_|_2_ _ _ _ _|_e_x_p_e_c_t_e_d_ _c_o_l_o_n_ _i_n_ _b_e_n_c_o_d_e_d_ _s_t_r_i_n_g_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_n_e_x_p_e_c_t_e_d___e_o_f_|_3_ _ _ _ _|_u_n_e_x_p_e_c_t_e_d_ _e_n_d_ _o_f_ _f_i_l_e_ _i_n_ _b_e_n_c_o_d_e_d_ _s_t_r_i_n_g_ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|expected_value|4 |expected value (list, dict, _i_n_t or string) in bencoded|
│ │ │ │ -|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _|_ _ _ _ _ _|_s_t_r_i_n_g_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_d_e_p_t_h___e_x_c_e_e_d_e_d_|_5_ _ _ _ _|_b_e_n_c_o_d_e_d_ _r_e_c_u_r_s_i_o_n_ _d_e_p_t_h_ _l_i_m_i_t_ _e_x_c_e_e_d_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_l_i_m_i_t___e_x_c_e_e_d_e_d_|_6_ _ _ _ _|_b_e_n_c_o_d_e_d_ _i_t_e_m_ _c_o_u_n_t_ _l_i_m_i_t_ _e_x_c_e_e_d_e_d_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_o_v_e_r_f_l_o_w_ _ _ _ _ _ _|_7_ _ _ _ _|_i_n_t_e_g_e_r_ _o_v_e_r_f_l_o_w_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_e_r_r_o_r___c_o_d_e___m_a_x_|_8_ _ _ _ _|_t_h_e_ _n_u_m_b_e_r_ _o_f_ _e_r_r_o_r_ _c_o_d_e_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&& sp);
│ │ │ │ - sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ - sseessssiioonn__ppaarraammss ();
│ │ │ │ - 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&& sp);
│ │ │ │ -sseessssiioonn__ppaarraammss (settings_pack const& sp);
│ │ │ │ -sseessssiioonn__ppaarraammss ();
│ │ │ │ -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
│ │ │ │ - , 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
│ │ │ │ - the plugins to add to the _s_e_s_s_i_o_n as it is constructed
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - dht_state
│ │ │ │ - DHT node ID and node addresses to bootstrap the DHT with.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - dht_storage_constructor
│ │ │ │ - function object to construct the storage object for DHT items.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - disk_io_constructor
│ │ │ │ - function object to create the disk I/O subsystem. Defaults to
│ │ │ │ - default_disk_io_constructor.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - ext_state
│ │ │ │ - this container can be used by extensions/plugins to store settings. It's
│ │ │ │ - primarily here to make it convenient to save and restore state across
│ │ │ │ - sessions, using _r_e_a_d___s_e_s_s_i_o_n___p_a_r_a_m_s_(_) and _w_r_i_t_e___s_e_s_s_i_o_n___p_a_r_a_m_s_(_).
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - ip_filter
│ │ │ │ - the IP filter to use for the _s_e_s_s_i_o_n. This restricts which peers are
│ │ │ │ - allowed to connect. As if passed to _s_e_t___i_p___f_i_l_t_e_r_(_).
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ sseessssiioonn__pprrooxxyy ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n_._h_p_p"
│ │ │ │ -this is a holder for the internal _s_e_s_s_i_o_n implementation object. Once the
│ │ │ │ -_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 const&) &;
│ │ │ │ - sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ - sseessssiioonn__pprrooxxyy ();
│ │ │ │ - ~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ - sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ - session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ -};
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** sseessssiioonn__pprrooxxyy(()) ~~sseessssiioonn__pprrooxxyy(()) ooppeerraattoorr==(()) **********
│ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy const&) &;
│ │ │ │ -sseessssiioonn__pprrooxxyy (session_proxy&&) noexcept;
│ │ │ │ -sseessssiioonn__pprrooxxyy ();
│ │ │ │ -~~sseessssiioonn__pprrooxxyy ();
│ │ │ │ -sseessssiioonn__pprrooxxyy (session_proxy const&);
│ │ │ │ -session_proxy& ooppeerraattoorr== (session_proxy&&) & noexcept;
│ │ │ │ -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
│ │ │ │ -will be idle as long it doesn't have any torrents to participate in.
│ │ │ │ -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
│ │ │ │ +************ 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
│ │ │ │ {
│ │ │ │ - sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ - sseessssiioonn ();
│ │ │ │ - explicit sseessssiioonn (session_params const& params);
│ │ │ │ - sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ - explicit sseessssiioonn (session_params&& params);
│ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios, session_flags_t);
│ │ │ │ - sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ - sseessssiioonn (session_params const& params, io_context& ios, session_flags_t);
│ │ │ │ - ~~sseessssiioonn ();
│ │ │ │ - session_proxy aabboorrtt ();
│ │ │ │ + ccoouunntteerrss () ;
│ │ │ │ + counters& ooppeerraattoorr== (counters const&) & ;
│ │ │ │ + ccoouunntteerrss (counters const&) ;
│ │ │ │ + std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ + std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ + 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]
│ │ │ │ -********** sseessssiioonn(()) **********
│ │ │ │ -sseessssiioonn (session_params const& params, session_flags_t flags);
│ │ │ │ -sseessssiioonn ();
│ │ │ │ -explicit sseessssiioonn (session_params const& params);
│ │ │ │ -sseessssiioonn (session_params&& params, session_flags_t flags);
│ │ │ │ -explicit sseessssiioonn (session_params&& 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, session_flags_t);
│ │ │ │ -sseessssiioonn (session_params&& params, io_context& ios);
│ │ │ │ -sseessssiioonn (session_params const& params, io_context& ios);
│ │ │ │ -sseessssiioonn (session_params const& 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.
│ │ │ │ -Warning
│ │ │ │ -The _s_e_s_s_i_o_n object does not cleanly terminate with an external io_context. The
│ │ │ │ -io_context::run() call mmuusstt have returned before it's safe to destruct the
│ │ │ │ -_s_e_s_s_i_o_n. Which means you MMUUSSTT call _s_e_s_s_i_o_n_:_:_a_b_o_r_t_(_) and save the _s_e_s_s_i_o_n___p_r_o_x_y
│ │ │ │ -first, then destruct the _s_e_s_s_i_o_n object, then sync with the io_context, then
│ │ │ │ -destruct the _s_e_s_s_i_o_n___p_r_o_x_y object.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ~~sseessssiioonn(()) **********
│ │ │ │ -~~sseessssiioonn ();
│ │ │ │ -The destructor of _s_e_s_s_i_o_n will notify all trackers that our torrents have been
│ │ │ │ -shut down. If some trackers are down, they will time out. All this before the
│ │ │ │ -destructor of _s_e_s_s_i_o_n returns. So, it's advised that any kind of interface
│ │ │ │ -(such as windows) are closed before destructing the _s_e_s_s_i_o_n object. Because it
│ │ │ │ -can take a few second for it to finish. The timeout can be set with
│ │ │ │ -_a_p_p_l_y___s_e_t_t_i_n_g_s_(_).
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** aabboorrtt(()) **********
│ │ │ │ -session_proxy aabboorrtt ();
│ │ │ │ -In case you want to destruct the _s_e_s_s_i_o_n asynchronously, you can request a
│ │ │ │ -_s_e_s_s_i_o_n destruction proxy. If you don't do this, the destructor of the _s_e_s_s_i_o_n
│ │ │ │ -object will block while the trackers are contacted. If you keep one
│ │ │ │ -session_proxy to the _s_e_s_s_i_o_n when destructing it, the destructor will not
│ │ │ │ -block, but start to close down the _s_e_s_s_i_o_n, the destructor of the proxy will
│ │ │ │ -then synchronize the threads. So, the destruction of the _s_e_s_s_i_o_n is performed
│ │ │ │ -from the session destructor call until the session_proxy destructor call. The
│ │ │ │ -session_proxy does not have any operations on it (since the _s_e_s_s_i_o_n is being
│ │ │ │ -closed down, no operations are allowed on it). The only valid operation is
│ │ │ │ -calling the destructor:
│ │ │ │ -struct session_proxy {};
│ │ │ │ +********** iinncc__ssttaattss__ccoouunntteerr(()) ooppeerraattoorr[[]](()) **********
│ │ │ │ +std::int64_t iinncc__ssttaattss__ccoouunntteerr (int c, std::int64_t value = 1) ;
│ │ │ │ +std::int64_t ooppeerraattoorr[[]] (int i) const ;
│ │ │ │ +returns the new value
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ sseessssiioonn__hhaannddllee ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_s_s_i_o_n___h_a_n_d_l_e_._h_p_p"
│ │ │ │ -this class provides a non-owning handle to a _s_e_s_s_i_o_n and a subset of the
│ │ │ │ -interface of the _s_e_s_s_i_o_n class. If the underlying _s_e_s_s_i_o_n is destructed any
│ │ │ │ -handle to it will no longer be valid. _i_s___v_a_l_i_d_(_) will return false and any
│ │ │ │ -operation on it will throw a system_error exception, with error code
│ │ │ │ -invalid_session_handle.
│ │ │ │ -struct session_handle
│ │ │ │ +************ 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
│ │ │ │ {
│ │ │ │ - bool iiss__vvaalliidd () const;
│ │ │ │ - session_params sseessssiioonn__ssttaattee (save_state_flags_t flags =
│ │ │ │ -save_state_flags_t::all()) 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);
│ │ │ │ - torrent_handle ffiinndd__ttoorrrreenntt (sha1_hash const& info_hash) const;
│ │ │ │ - std::vector ggeett__ttoorrrreennttss () const;
│ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ - void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code&
│ │ │ │ -ec);
│ │ │ │ - torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ - bool iiss__ppaauusseedd () const;
│ │ │ │ - void rreessuummee ();
│ │ │ │ - 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__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);
│ │ │ │ - ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ - void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ - void sseett__ppoorrtt__ffiilltteerr (port_filter const& f);
│ │ │ │ - unsigned short ssssll__lliisstteenn__ppoorrtt () const;
│ │ │ │ - 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 rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ - void aappppllyy__sseettttiinnggss (settings_pack&&);
│ │ │ │ - void aappppllyy__sseettttiinnggss (settings_pack const&);
│ │ │ │ - settings_pack ggeett__sseettttiinnggss () const;
│ │ │ │ - void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ - void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ - alert* wwaaiitt__ffoorr__aalleerrtt (time_duration max_wait);
│ │ │ │ - void ddeelleettee__ppoorrtt__mmaappppiinngg (port_mapping_t handle);
│ │ │ │ - std::vector aadddd__ppoorrtt__mmaappppiinngg (portmap_protocol t, int
│ │ │ │ -external_port, int local_port);
│ │ │ │ - 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;
│ │ │ │ - static constexpr save_state_flags_t ssaavvee__iipp__ffiilltteerr = 12_bit;
│ │ │ │ - static constexpr peer_class_t gglloobbaall__ppeeeerr__ccllaassss__iidd {0};
│ │ │ │ - static constexpr peer_class_t ttccpp__ppeeeerr__ccllaassss__iidd {1};
│ │ │ │ - static constexpr peer_class_t llooccaall__ppeeeerr__ccllaassss__iidd {2};
│ │ │ │ - static constexpr remove_flags_t ddeelleettee__ffiilleess = 0_bit;
│ │ │ │ - static constexpr remove_flags_t ddeelleettee__ppaarrttffiillee = 1_bit;
│ │ │ │ - static constexpr session_flags_t ppaauusseedd = 2_bit;
│ │ │ │ - static constexpr portmap_protocol uuddpp = portmap_protocol::udp;
│ │ │ │ - static constexpr portmap_protocol ttccpp = portmap_protocol::tcp;
│ │ │ │ - static constexpr reopen_network_flags_t rreeooppeenn__mmaapp__ppoorrttss = 0_bit;
│ │ │ │ + char const* name;
│ │ │ │ + int value_index;
│ │ │ │ + metric_type_t type;
│ │ │ │ };
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** iiss__vvaalliidd(()) **********
│ │ │ │ -bool iiss__vvaalliidd () const;
│ │ │ │ -returns true if this handle refers to a valid _s_e_s_s_i_o_n object. If the _s_e_s_s_i_o_n
│ │ │ │ -has been destroyed, all _s_e_s_s_i_o_n___h_a_n_d_l_e objects will expire and not be valid.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** sseessssiioonn__ssttaattee(()) **********
│ │ │ │ -session_params sseessssiioonn__ssttaattee (save_state_flags_t flags = save_state_flags_t::
│ │ │ │ -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]
│ │ │ │ -********** rreeffrreesshh__ttoorrrreenntt__ssttaattuuss(()) ggeett__ttoorrrreenntt__ssttaattuuss(()) **********
│ │ │ │ -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
│ │ │ │ -should be included and false means excluded. The flags argument is the same as
│ │ │ │ -to _t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_s_t_a_t_u_s_(_). Since pred is guaranteed to be called for every
│ │ │ │ -torrent, it may be used to count the number of torrents of different categories
│ │ │ │ -as well.
│ │ │ │ -refresh_torrent_status takes a vector of _t_o_r_r_e_n_t___s_t_a_t_u_s structs (for instance
│ │ │ │ -the same vector that was returned by _g_e_t___t_o_r_r_e_n_t___s_t_a_t_u_s_(_) ) and refreshes the
│ │ │ │ -status based on the handle member. It is possible to use this function by first
│ │ │ │ -setting up a vector of default constructed torrent_status objects, only
│ │ │ │ -initializing the handle member, in order to request the torrent status for
│ │ │ │ -multiple torrents in a single call. This can save a significant amount of time
│ │ │ │ -if you have a lot of torrents.
│ │ │ │ -Any _t_o_r_r_e_n_t___s_t_a_t_u_s object whose handle member is not referring to a valid
│ │ │ │ -torrent are ignored.
│ │ │ │ -The intended use of these functions is to start off by calling
│ │ │ │ -get_torrent_status() to get a list of all torrents that match your criteria.
│ │ │ │ -Then call refresh_torrent_status() on that list. This will only refresh the
│ │ │ │ -status for the torrents in your list, and thus ignore all other torrents you
│ │ │ │ -might be running. This may save a significant amount of time, especially if the
│ │ │ │ -number of torrents you're interested in is small. In order to keep your list of
│ │ │ │ -interested torrents up to date, you can either call get_torrent_status() from
│ │ │ │ -time to time, to include torrents you might have become interested in since the
│ │ │ │ -last time. In order to stop refreshing a certain torrent, simply remove it from
│ │ │ │ -the list.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ppoosstt__ttoorrrreenntt__uuppddaatteess(()) **********
│ │ │ │ -void ppoosstt__ttoorrrreenntt__uuppddaatteess (status_flags_t flags = status_flags_t::all());
│ │ │ │ -This functions instructs the _s_e_s_s_i_o_n to post the _s_t_a_t_e___u_p_d_a_t_e___a_l_e_r_t, containing
│ │ │ │ -the status of all torrents whose state changed since the last time this
│ │ │ │ -function was called.
│ │ │ │ -Only torrents who has the state subscription flag set will be included. This
│ │ │ │ -flag is on by default. See _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s. the flags argument is the same
│ │ │ │ -as for _t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_s_t_a_t_u_s_(_). see status_flags_t in _t_o_r_r_e_n_t___h_a_n_d_l_e.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ppoosstt__sseessssiioonn__ssttaattss(()) **********
│ │ │ │ -void ppoosstt__sseessssiioonn__ssttaattss ();
│ │ │ │ -This function will post a _s_e_s_s_i_o_n___s_t_a_t_s___a_l_e_r_t object, containing a snapshot of
│ │ │ │ -the performance _c_o_u_n_t_e_r_s from the internals of libtorrent. To interpret these
│ │ │ │ -_c_o_u_n_t_e_r_s, query the _s_e_s_s_i_o_n via _s_e_s_s_i_o_n___s_t_a_t_s___m_e_t_r_i_c_s_(_).
│ │ │ │ -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);
│ │ │ │ -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(()) **********
│ │ │ │ -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]
│ │ │ │ -********** aadddd__ttoorrrreenntt(()) aassyynncc__aadddd__ttoorrrreenntt(()) **********
│ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params&& params, error_code& ec);
│ │ │ │ -void aassyynncc__aadddd__ttoorrrreenntt (add_torrent_params&& params);
│ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params, error_code& ec);
│ │ │ │ -torrent_handle aadddd__ttoorrrreenntt (add_torrent_params const& params);
│ │ │ │ -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 save_path field in _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s must be set to a valid path where the
│ │ │ │ -files for the torrent will be saved. Even when using a custom storage, this
│ │ │ │ -needs to be set to something. If the save_path is empty, the call to
│ │ │ │ -_a_d_d___t_o_r_r_e_n_t_(_) will throw a system_error exception.
│ │ │ │ -The overload that does not take an error_code throws an exception on error and
│ │ │ │ -is not available when building without exception support. The _t_o_r_r_e_n_t___h_a_n_d_l_e
│ │ │ │ -returned by _a_d_d___t_o_r_r_e_n_t_(_) can be used to retrieve information about the
│ │ │ │ -torrent's progress, its peers etc. It is also used to abort a torrent.
│ │ │ │ -If the torrent you are trying to add already exists in the _s_e_s_s_i_o_n (is either
│ │ │ │ -queued for checking, being checked or downloading) add_torrent() will throw
│ │ │ │ -system_error which derives from std::exception unless duplicate_is_error is set
│ │ │ │ -to false. In that case, _a_d_d___t_o_r_r_e_n_t_(_) will return the handle to the existing
│ │ │ │ -torrent.
│ │ │ │ -The _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s class has a flags field. It can be used to control what
│ │ │ │ -state the new torrent will be added in. Common flags to 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 _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]
│ │ │ │ -********** iiss__ppaauusseedd(()) rreessuummee(()) ppaauussee(()) **********
│ │ │ │ -bool iiss__ppaauusseedd () const;
│ │ │ │ -void rreessuummee ();
│ │ │ │ -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]
│ │ │ │ -********** iiss__ddhhtt__rruunnnniinngg(()) **********
│ │ │ │ -bool iiss__ddhhtt__rruunnnniinngg () const;
│ │ │ │ -is_dht_running() returns true if the DHT support has been started and false
│ │ │ │ -otherwise.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** sseett__ddhhtt__ssttoorraaggee(()) **********
│ │ │ │ -void sseett__ddhhtt__ssttoorraaggee (dht::dht_storage_constructor_type sc);
│ │ │ │ -set_dht_storage set a dht custom storage constructor function to be used
│ │ │ │ -internally when the dht is created.
│ │ │ │ -Since the dht storage is a critical component for the dht behavior, this
│ │ │ │ -function will only be effective the next time the dht is started. If you never
│ │ │ │ -touch this feature, a default map-memory based storage is used.
│ │ │ │ -If you want to make sure the dht is initially created with your custom storage,
│ │ │ │ -create a _s_e_s_s_i_o_n with the setting settings_pack::enable_dht to false, set your
│ │ │ │ -constructor function and call apply_settings with settings_pack::enable_dht to
│ │ │ │ -true.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** aadddd__ddhhtt__nnooddee(()) **********
│ │ │ │ -void aadddd__ddhhtt__nnooddee (std::pair const& node);
│ │ │ │ -add_dht_node takes a host name and port pair. That endpoint will be pinged, and
│ │ │ │ -if a valid DHT reply is received, the node will be added to the routing table.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ddhhtt__ggeett__iitteemm(()) **********
│ │ │ │ -void ddhhtt__ggeett__iitteemm (sha1_hash const& target);
│ │ │ │ -query the DHT for an immutable item at the target hash. the result is posted as
│ │ │ │ -a _d_h_t___i_m_m_u_t_a_b_l_e___i_t_e_m___a_l_e_r_t.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ddhhtt__ggeett__iitteemm(()) **********
│ │ │ │ -void ddhhtt__ggeett__iitteemm (std::array key
│ │ │ │ - , std::string salt = std::string());
│ │ │ │ -query the DHT for a mutable item under the public key key. this is an ed25519
│ │ │ │ -key. salt is optional and may be left as an empty string if no salt is to be
│ │ │ │ -used. if the item is found in the DHT, a _d_h_t___m_u_t_a_b_l_e___i_t_e_m___a_l_e_r_t is posted.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ddhhtt__ppuutt__iitteemm(()) **********
│ │ │ │ -sha1_hash ddhhtt__ppuutt__iitteemm (entry data);
│ │ │ │ -store the given bencoded data as an immutable item in the DHT. the returned
│ │ │ │ -hash is the key that is to be used to look the item up again. It's just the
│ │ │ │ -SHA-1 hash of the bencoded form of the structure.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ddhhtt__ppuutt__iitteemm(()) **********
│ │ │ │ -void ddhhtt__ppuutt__iitteemm (std::array key
│ │ │ │ - , std::function&
│ │ │ │ - , std::int64_t&, std::string const&)> cb
│ │ │ │ - , std::string salt = std::string());
│ │ │ │ -store a mutable item. The key is the public key the blob is to be stored under.
│ │ │ │ -The optional salt argument is a string that is to be mixed in with the key when
│ │ │ │ -determining where in the DHT the value is to be stored. The callback function
│ │ │ │ -is called from within the libtorrent network thread once we've found where to
│ │ │ │ -store the blob, possibly with the current value stored under the key. The
│ │ │ │ -values passed to the callback functions are:
│ │ │ │ - entry& value
│ │ │ │ - the current value stored under the key (may be empty). Also expected to
│ │ │ │ - be set to the value to be stored by the function.
│ │ │ │ - std::array& signature
│ │ │ │ - the signature authenticating the current value. This may be zeros if
│ │ │ │ - there is currently no value stored. The function is expected to fill in
│ │ │ │ - this buffer with the signature of the new value to store. To generate the
│ │ │ │ - signature, you may want to use the sign_mutable_item function.
│ │ │ │ - std::int64_t& seq
│ │ │ │ - current sequence number. May be zero if there is no current value. The
│ │ │ │ - function is expected to set this to the new sequence number of the value
│ │ │ │ - that is to be stored. Sequence numbers must be monotonically increasing.
│ │ │ │ - Attempting to overwrite a value with a lower or equal sequence number
│ │ │ │ - will fail, even if the signature is correct.
│ │ │ │ - std::string const& salt
│ │ │ │ - this is the salt that was used for this put call.
│ │ │ │ -Since the callback function cb is called from within libtorrent, it is critical
│ │ │ │ -to not perform any blocking operations. Ideally not even locking a mutex. Pass
│ │ │ │ -any data required for this function along 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 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 = {});
│ │ │ │ -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). dht_announce() is not affected by the
│ │ │ │ -announce_port override setting.
│ │ │ │ -Both these functions are exposed for advanced custom use of the DHT. All
│ │ │ │ -torrents eligible to be announce to the DHT will be automatically, by
│ │ │ │ -libtorrent.
│ │ │ │ -For possible flags, see _a_n_n_o_u_n_c_e___f_l_a_g_s___t.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ddhhtt__lliivvee__nnooddeess(()) **********
│ │ │ │ -void ddhhtt__lliivvee__nnooddeess (sha1_hash const& nid);
│ │ │ │ -Retrieve all the live DHT (identified by nid) nodes. All the nodes id and
│ │ │ │ -endpoint will be returned in the list of nodes in the _a_l_e_r_t
│ │ │ │ -dht_live_nodes_alert. 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]
│ │ │ │ -********** ddhhtt__ssaammppllee__iinnffoohhaasshheess(()) **********
│ │ │ │ -void ddhhtt__ssaammppllee__iinnffoohhaasshheess (udp::endpoint const& ep, sha1_hash const& target);
│ │ │ │ -Query the DHT node specified by ep to retrieve a sample of the info-hashes that
│ │ │ │ -the node currently have in their storage. The target is included for iterative
│ │ │ │ -lookups so that indexing nodes can perform a key space traversal with a single
│ │ │ │ -RPC per node by adjusting the target value for each RPC. It has no effect on
│ │ │ │ -the returned sample value. The result is posted as a
│ │ │ │ -dht_sample_infohashes_alert.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ddhhtt__ddiirreecctt__rreeqquueesstt(()) **********
│ │ │ │ -void ddhhtt__ddiirreecctt__rreeqquueesstt (udp::endpoint const& ep, entry const& e, client_data_t
│ │ │ │ -userdata = {});
│ │ │ │ -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);
│ │ │ │ -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
│ │ │ │ - directly. Makes it possible to join a swarm with just a tracker and info-
│ │ │ │ - hash.
│ │ │ │ -#include
│ │ │ │ -ses.add_extension(<::create_ut_metadata_plugin);
│ │ │ │ - uTorrent peer exchange
│ │ │ │ - Exchanges peers between clients.
│ │ │ │ -#include
│ │ │ │ -ses.add_extension(<::create_ut_pex_plugin);
│ │ │ │ - smart ban _p_l_u_g_i_n
│ │ │ │ - A _p_l_u_g_i_n that, with a small overhead, can ban peers that sends bad data
│ │ │ │ - with very high accuracy. Should eliminate most problems on poisoned
│ │ │ │ - torrents.
│ │ │ │ -#include
│ │ │ │ -ses.add_extension(<::create_smart_ban_plugin);
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** sseett__iipp__ffiilltteerr(()) ggeett__iipp__ffiilltteerr(()) **********
│ │ │ │ -ip_filter ggeett__iipp__ffiilltteerr () const;
│ │ │ │ -void sseett__iipp__ffiilltteerr (ip_filter f);
│ │ │ │ -Sets a filter that will be used to reject and accept incoming as well as
│ │ │ │ -outgoing connections based on their originating ip address. The default filter
│ │ │ │ -will allow connections to any ip address. To build a set of rules for which
│ │ │ │ -addresses are accepted and not, see _i_p___f_i_l_t_e_r.
│ │ │ │ -Each time a peer is blocked because of the IP filter, a _p_e_e_r___b_l_o_c_k_e_d___a_l_e_r_t is
│ │ │ │ -generated. get_ip_filter() Returns the _i_p___f_i_l_t_e_r currently in the _s_e_s_s_i_o_n. See
│ │ │ │ -_i_p___f_i_l_t_e_r.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** 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]
│ │ │ │ -********** ssssll__lliisstteenn__ppoorrtt(()) iiss__lliisstteenniinngg(()) lliisstteenn__ppoorrtt(()) **********
│ │ │ │ -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(()) **********
│ │ │ │ -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.
│ │ │ │ -For example, to make all peers in the range 200.1.1.0 - 200.1.255.255 belong to
│ │ │ │ -their own peer class, apply the following filter:
│ │ │ │ -ip_filter f = ses.get_peer_class_filter();
│ │ │ │ -peer_class_t my_class = ses.create_peer_class("200.1.x.x IP range");
│ │ │ │ -f.add_rule(make_address("200.1.1.0"), make_address("200.1.255.255")
│ │ │ │ - , 1 << static_cast(my_class));
│ │ │ │ -ses.set_peer_class_filter(f);
│ │ │ │ -This setting only applies to new connections, it won't affect existing peer
│ │ │ │ -connections.
│ │ │ │ -This function is limited to only peer class 0-31, since there are only 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 _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(()) **********
│ │ │ │ -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
│ │ │ │ - 3. peer-class type filter, adding classes
│ │ │ │ -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]
│ │ │ │ -********** ccrreeaattee__ppeeeerr__ccllaassss(()) **********
│ │ │ │ -peer_class_t ccrreeaattee__ppeeeerr__ccllaassss (char const* name);
│ │ │ │ -Creates a new peer class (see _p_e_e_r_ _c_l_a_s_s_e_s) with the given name. The returned
│ │ │ │ -integer is the new peer class identifier. Peer classes may have the same name,
│ │ │ │ -so each invocation of this function creates a new class and returns a unique
│ │ │ │ -identifier.
│ │ │ │ -Identifiers are assigned from low numbers to higher. So if you plan on using
│ │ │ │ -certain peer classes in a call to _s_e_t___p_e_e_r___c_l_a_s_s___f_i_l_t_e_r_(_), make sure to create
│ │ │ │ -those early on, to get low identifiers.
│ │ │ │ -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]
│ │ │ │ -********** ddeelleettee__ppeeeerr__ccllaassss(()) **********
│ │ │ │ -void ddeelleettee__ppeeeerr__ccllaassss (peer_class_t cid);
│ │ │ │ -This call dereferences the reference count of the specified peer class. When
│ │ │ │ -creating a peer class it's automatically referenced by 1. If you want to
│ │ │ │ -recycle a peer class, you may call this function. You may only call this
│ │ │ │ -function oonnccee per peer class you create. Calling it more than once for the same
│ │ │ │ -class will lead to memory corruption.
│ │ │ │ -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(()) **********
│ │ │ │ -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
│ │ │ │ -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
│ │ │ │ -any of its classes is the one that is taken into account.
│ │ │ │ -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]
│ │ │ │ -********** rreemmoovvee__ttoorrrreenntt(()) **********
│ │ │ │ -void rreemmoovvee__ttoorrrreenntt (const torrent_handle&, remove_flags_t = {});
│ │ │ │ -remove_torrent() will close all peer connections associated with the torrent
│ │ │ │ -and tell the tracker that we've stopped participating in the swarm. This
│ │ │ │ -operation cannot fail. When it completes, you will receive a
│ │ │ │ -_t_o_r_r_e_n_t___r_e_m_o_v_e_d___a_l_e_r_t.
│ │ │ │ -_r_e_m_o_v_e___t_o_r_r_e_n_t_(_) is non-blocking, but will remove the torrent from the _s_e_s_s_i_o_n
│ │ │ │ -synchronously. Calling _s_e_s_s_i_o_n___h_a_n_d_l_e_:_:_a_d_d___t_o_r_r_e_n_t_(_) immediately afterward with
│ │ │ │ -the same torrent will succeed. Note that this creates a new handle which is not
│ │ │ │ -equal to the removed one.
│ │ │ │ -The optional second argument options can be used to delete all the files
│ │ │ │ -downloaded by this torrent. To do so, pass in the value session_handle::
│ │ │ │ -delete_files. Once the torrent is deleted, a _t_o_r_r_e_n_t___d_e_l_e_t_e_d___a_l_e_r_t is posted.
│ │ │ │ -The _t_o_r_r_e_n_t___h_a_n_d_l_e remains valid for some time after _r_e_m_o_v_e___t_o_r_r_e_n_t_(_) is
│ │ │ │ -called. It will become invalid only after all libtorrent tasks (such as I/
│ │ │ │ -O tasks) release their references to the torrent. Until this happens,
│ │ │ │ -_t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_i_s___v_a_l_i_d_(_) will return true, and other calls such as
│ │ │ │ -_t_o_r_r_e_n_t___h_a_n_d_l_e_:_:_s_t_a_t_u_s_(_) will succeed. Because of this, and because
│ │ │ │ -_r_e_m_o_v_e___t_o_r_r_e_n_t_(_) is non-blocking, the following sequence usually succeeds (does
│ │ │ │ -not throw system_error): .. code:: c++
│ │ │ │ - session.remove_handle(handle); handle.save_resume_data();
│ │ │ │ -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&&);
│ │ │ │ -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]
│ │ │ │ -********** wwaaiitt__ffoorr__aalleerrtt(()) sseett__aalleerrtt__nnoottiiffyy(()) ppoopp__aalleerrttss(()) **********
│ │ │ │ -void ppoopp__aalleerrttss (std::vector* alerts);
│ │ │ │ -void sseett__aalleerrtt__nnoottiiffyy (std::function const& fun);
│ │ │ │ -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.
│ │ │ │ -wait_for_alert will block the current thread for max_wait time duration, or
│ │ │ │ -until another _a_l_e_r_t is posted. If an _a_l_e_r_t is available at the time of the
│ │ │ │ -call, it returns immediately. The returned _a_l_e_r_t pointer is the head of the
│ │ │ │ -_a_l_e_r_t queue. wait_for_alert does not pop alerts from the queue, it merely peeks
│ │ │ │ -at it. The returned _a_l_e_r_t will stay valid until pop_alerts is called twice. The
│ │ │ │ -first time will pop it and the second will free it.
│ │ │ │ -If there is no _a_l_e_r_t in the queue and no _a_l_e_r_t arrives within the specified
│ │ │ │ -timeout, wait_for_alert returns nullptr.
│ │ │ │ -In the python binding, wait_for_alert takes the number of milliseconds to wait
│ │ │ │ -as an integer.
│ │ │ │ -The _a_l_e_r_t queue in the _s_e_s_s_i_o_n will not grow indefinitely. Make sure to pop
│ │ │ │ -periodically to not miss notifications. To control the max number of alerts
│ │ │ │ -that's queued by the _s_e_s_s_i_o_n, see settings_pack::alert_queue_size.
│ │ │ │ -Some alerts are considered so important that they are posted even when the
│ │ │ │ -_a_l_e_r_t queue is full. Some alerts are considered mandatory and cannot be
│ │ │ │ -disabled by the alert_mask. For instance, _s_a_v_e___r_e_s_u_m_e___d_a_t_a___a_l_e_r_t and
│ │ │ │ -_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 are always posted, regardless of the _a_l_e_r_t mask.
│ │ │ │ -To control which alerts are posted, set the alert_mask (_s_e_t_t_i_n_g_s___p_a_c_k_:_:
│ │ │ │ -_a_l_e_r_t___m_a_s_k).
│ │ │ │ -If the _a_l_e_r_t queue fills up to the point where alerts are dropped, this will be
│ │ │ │ -indicated by a _a_l_e_r_t_s___d_r_o_p_p_e_d___a_l_e_r_t, which contains a bitmask of which types of
│ │ │ │ -alerts were dropped. Generally it is a good idea to make sure the _a_l_e_r_t queue
│ │ │ │ -is large enough, the alert_mask doesn't have unnecessary categories enabled and
│ │ │ │ -to call pop_alert() frequently, to avoid alerts being dropped.
│ │ │ │ -the set_alert_notify function lets the client set a function object to be
│ │ │ │ -invoked every time the _a_l_e_r_t queue goes from having 0 alerts to 1 _a_l_e_r_t. This
│ │ │ │ -function is called from within libtorrent, it may be the main thread, or it may
│ │ │ │ -be from within a user call. The intention of of the function is that the client
│ │ │ │ -wakes up its main thread, to poll for more alerts using pop_alerts(). If the
│ │ │ │ -notify function fails to do so, it won't be called again, until pop_alerts is
│ │ │ │ -called for some other reason. For instance, it could signal an eventfd, post a
│ │ │ │ -message to an HWND or some other main message pump. The actual retrieval of
│ │ │ │ -alerts should not be done in the callback. In fact, the callback should not
│ │ │ │ -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);
│ │ │ │ -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 =
│ │ │ │ -reopen_map_ports);
│ │ │ │ -Instructs the _s_e_s_s_i_o_n to reopen all listen and outgoing sockets.
│ │ │ │ -It's useful in the case your platform doesn't support the built in IP notifier
│ │ │ │ -mechanism, or if you have a better more reliable way to detect changes in the
│ │ │ │ -IP routing table.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** nnaattiivvee__hhaannddllee(()) **********
│ │ │ │ -std::shared_ptr nnaattiivvee__hhaannddllee () const;
│ │ │ │ -This function is intended only for use by plugins. This type does not have a
│ │ │ │ -stable API and should be relied on as little as possible.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - save_settings
│ │ │ │ - saves settings (i.e. the _s_e_t_t_i_n_g_s___p_a_c_k)
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - save_dht_state
│ │ │ │ - saves dht state such as nodes and node-id, possibly accelerating joining
│ │ │ │ - the DHT if provided at next _s_e_s_s_i_o_n startup.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - save_extension_state
│ │ │ │ - load or save state from plugins
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - save_ip_filter
│ │ │ │ - load or save the IP filter set on the _s_e_s_s_i_o_n
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - global_peer_class_id tcp_peer_class_id local_peer_class_id
│ │ │ │ - built-in peer classes
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - delete_files
│ │ │ │ - delete the files belonging to the torrent from disk. including the part-
│ │ │ │ - file, if there is one
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - delete_partfile
│ │ │ │ - delete just the part-file associated with this torrent
│ │ │ │ + name
│ │ │ │ + the name of the counter or gauge
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - paused
│ │ │ │ - when set, the _s_e_s_s_i_o_n will start paused. Call _s_e_s_s_i_o_n___h_a_n_d_l_e_:_:_r_e_s_u_m_e_(_) to
│ │ │ │ - start
│ │ │ │ + value_index type
│ │ │ │ + the index into the _s_e_s_s_i_o_n stats array, where the underlying value of
│ │ │ │ + this counter or gauge is found. The _s_e_s_s_i_o_n stats array is part of the
│ │ │ │ + _s_e_s_s_i_o_n___s_t_a_t_s___a_l_e_r_t object.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - udp tcp
│ │ │ │ - protocols used by _a_d_d___p_o_r_t___m_a_p_p_i_n_g_(_)
│ │ │ │ +************ sseessssiioonn__ssttaattss__mmeettrriiccss(()) ************
│ │ │ │ +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"
│ │ │ │ +std::vector sseessssiioonn__ssttaattss__mmeettrriiccss ();
│ │ │ │ +This free function returns the list of available metrics exposed by
│ │ │ │ +libtorrent's statistics API. Each metric has a name and a vvaalluuee iinnddeexx. The
│ │ │ │ +value index is the index into the array in _s_e_s_s_i_o_n___s_t_a_t_s___a_l_e_r_t where this
│ │ │ │ +metric's value can be found when the _s_e_s_s_i_o_n stats is sampled (by calling
│ │ │ │ +_p_o_s_t___s_e_s_s_i_o_n___s_t_a_t_s_(_)).
│ │ │ │ [_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.
│ │ │ │ +************ ffiinndd__mmeettrriicc__iiddxx(()) ************
│ │ │ │ +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"
│ │ │ │ +int ffiinndd__mmeettrriicc__iiddxx (string_view name);
│ │ │ │ +given a name of a metric, this function returns the counter index of it, or -
│ │ │ │ +1 if it could not be found. The counter index is the index into the values
│ │ │ │ +array returned by _s_e_s_s_i_o_n___s_t_a_t_s___a_l_e_r_t.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ wwrriittee__sseessssiioonn__ppaarraammss(()) rreeaadd__sseessssiioonn__ppaarraammss(()) wwrriittee__sseessssiioonn__ppaarraammss__bbuuff(())
│ │ │ │ -************
│ │ │ │ -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());
│ │ │ │ -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());
│ │ │ │ -std::vector wwrriittee__sseessssiioonn__ppaarraammss__bbuuff (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
│ │ │ │ -_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
│ │ │ │ -separately.
│ │ │ │ +************ eennuumm mmeettrriicc__ttyyppee__tt ************
│ │ │ │ +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"
│ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ +|_nn_aa_mm_ee_ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ +|_c_o_u_n_t_e_r_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_g_a_u_g_e_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ wweebb__sseeeedd__eennttrryy ************
│ │ │ │ -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 _w_e_b___s_e_e_d___e_n_t_r_y holds information about a web seed (also known as URL seed
│ │ │ │ -or HTTP seed). It is essentially a URL with some state associated with it. For
│ │ │ │ -more information, see _B_E_P_ _1_7 and _B_E_P_ _1_9.
│ │ │ │ -struct web_seed_entry
│ │ │ │ +************ ppeeeerr__rreeqquueesstt ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___r_e_q_u_e_s_t_._h_p_p"
│ │ │ │ +represents a byte range within a piece. Internally this is is used for incoming
│ │ │ │ +piece requests.
│ │ │ │ +struct peer_request
│ │ │ │ {
│ │ │ │ - bool ooppeerraattoorr==== (web_seed_entry const& e) const;
│ │ │ │ - bool ooppeerraattoorr<< (web_seed_entry const& e) const;
│ │ │ │ -
│ │ │ │ - enum type_t
│ │ │ │ - {
│ │ │ │ - url_seed,
│ │ │ │ - http_seed,
│ │ │ │ - };
│ │ │ │ + bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │
│ │ │ │ - std::string url;
│ │ │ │ - std::string auth;
│ │ │ │ - headers_t extra_headers;
│ │ │ │ - std::uint8_t type;
│ │ │ │ + piece_index_t piece;
│ │ │ │ + int start;
│ │ │ │ + int length;
│ │ │ │ };
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ********** ooppeerraattoorr====(()) **********
│ │ │ │ -bool ooppeerraattoorr==== (web_seed_entry const& e) const;
│ │ │ │ -URL and type comparison
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ooppeerraattoorr<<(()) **********
│ │ │ │ -bool ooppeerraattoorr<< (web_seed_entry const& e) const;
│ │ │ │ -URL and type less-than comparison
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** eennuumm ttyyppee__tt **********
│ │ │ │ -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"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_u_r_l___s_e_e_d_ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_h_t_t_p___s_e_e_d_|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - url
│ │ │ │ - The URL of the web seed
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - auth
│ │ │ │ - Optional authentication. If this is set, it's passed in as HTTP basic
│ │ │ │ - auth to the web seed. The format is: username:password.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - extra_headers
│ │ │ │ - Any extra HTTP headers that need to be passed to the web seed
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - type
│ │ │ │ - The type of web seed (see _t_y_p_e___t)
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ llooaadd__ttoorrrreenntt__lliimmiittss ************
│ │ │ │ -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"
│ │ │ │ -this object holds configuration options for limits to use when loading
│ │ │ │ -torrents. They are meant to prevent loading potentially malicious torrents that
│ │ │ │ -cause excessive memory allocations.
│ │ │ │ -struct load_torrent_limits
│ │ │ │ -{
│ │ │ │ - int mmaaxx__bbuuffffeerr__ssiizzee = 10000000;
│ │ │ │ - int mmaaxx__ppiieecceess = 0x200000;
│ │ │ │ - int mmaaxx__ddeeccooddee__ddeepptthh = 100;
│ │ │ │ - int mmaaxx__ddeeccooddee__ttookkeennss = 3000000;
│ │ │ │ -};
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - max_buffer_size
│ │ │ │ - the max size of a .torrent file to load into RAM
│ │ │ │ +bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ +returns true if the right hand side _p_e_e_r___r_e_q_u_e_s_t refers to the same range as
│ │ │ │ +this does.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - max_pieces
│ │ │ │ - the max number of pieces allowed in the torrent
│ │ │ │ + piece
│ │ │ │ + The index of the piece in which the range starts.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - max_decode_depth
│ │ │ │ - the max recursion depth in the bdecoded structure
│ │ │ │ + start
│ │ │ │ + The byte offset within that piece where the range starts.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - max_decode_tokens
│ │ │ │ - the max number of bdecode tokens
│ │ │ │ + length
│ │ │ │ + The size of the range, in bytes.
│ │ │ │ [_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
│ │ │ │ +************ iinnffoo__hhaasshh__tt ************
│ │ │ │ +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
│ │ │ │ {
│ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ - ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ - explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ - explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ - ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ - ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, 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 (char const* buffer, int size);
│ │ │ │ - ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ - ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ -from_span_t);
│ │ │ │ - ~~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);
│ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ - std::vector const& ttrraacckkeerrss () const;
│ │ │ │ - void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ - , announce_entry::tracker_source source);
│ │ │ │ - void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ - std::vector ssiimmiillaarr__ttoorrrreennttss () const;
│ │ │ │ - std::vector ccoolllleeccttiioonnss () const;
│ │ │ │ - std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ - void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ - 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::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ - int nnuumm__ppiieecceess () const;
│ │ │ │ - int ppiieeccee__lleennggtthh () const;
│ │ │ │ - int bblloocckkss__ppeerr__ppiieeccee () const;
│ │ │ │ - index_range ppiieeccee__rraannggee () const;
│ │ │ │ - piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ - piece_index_t llaasstt__ppiieeccee () const;
│ │ │ │ - info_hash_t const& iinnffoo__hhaasshheess () 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;
│ │ │ │ - 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);
│ │ │ │ - bool ppaarrssee__iinnffoo__sseeccttiioonn (bdecode_node const& info, error_code& ec, int
│ │ │ │ -max_pieces);
│ │ │ │ - bdecode_node iinnffoo (char const* key) const;
│ │ │ │ - span iinnffoo__sseeccttiioonn () const;
│ │ │ │ - span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ - void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ + iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ + explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ + iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ + bool hhaass__vv22 () const;
│ │ │ │ + bool hhaass__vv11 () const;
│ │ │ │ + bool hhaass (protocol_version v) 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;
│ │ │ │ + bool ooppeerraattoorr<< (info_hash_t const& o) const;
│ │ │ │ + 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]
│ │ │ │ -********** ttoorrrreenntt__iinnffoo(()) **********
│ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -ttoorrrreenntt__iinnffoo (std::string const& filename, error_code& ec);
│ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, error_code& ec, from_span_t);
│ │ │ │ -explicit ttoorrrreenntt__iinnffoo (std::string const& filename);
│ │ │ │ -explicit ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file);
│ │ │ │ -ttoorrrreenntt__iinnffoo (char const* buffer, int size, error_code& ec);
│ │ │ │ -ttoorrrreenntt__iinnffoo (bdecode_node const& torrent_file, 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 (char const* buffer, int size);
│ │ │ │ -ttoorrrreenntt__iinnffoo (torrent_info const& t);
│ │ │ │ -ttoorrrreenntt__iinnffoo (span buffer, load_torrent_limits const& cfg,
│ │ │ │ -from_span_t);
│ │ │ │ -The constructor that takes an info-hash will initialize the info-hash to the
│ │ │ │ -given value, but leave all other fields empty. This is used internally when
│ │ │ │ -downloading torrents without the metadata. The metadata will be created by
│ │ │ │ -libtorrent as soon as it has been downloaded from the swarm.
│ │ │ │ -The constructor that takes a _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
│ │ │ │ -into a _b_d_e_c_o_d_e___n_o_d_e, use _b_d_e_c_o_d_e_(_).
│ │ │ │ -The version that takes a buffer pointer and a size will decode it as a .torrent
│ │ │ │ -file and initialize the _t_o_r_r_e_n_t___i_n_f_o object for you.
│ │ │ │ -The version that takes a filename will simply load the torrent file and decode
│ │ │ │ -it inside the constructor, for convenience. This might not be the most suitable
│ │ │ │ -for applications that want to be able to report detailed errors on what might
│ │ │ │ -go wrong.
│ │ │ │ -There is an upper limit on the size of the torrent file that will be loaded by
│ │ │ │ -the overload taking a filename. If it's important that even very large torrent
│ │ │ │ -files are loaded, use one of the other overloads.
│ │ │ │ -The overloads that takes an error_code const& never throws if an error occur,
│ │ │ │ -they will simply set the error code to describe what went wrong and not fully
│ │ │ │ -initialize the _t_o_r_r_e_n_t___i_n_f_o object. The overloads that do not take the extra
│ │ │ │ -error_code parameter will always throw if an error occurs. These overloads are
│ │ │ │ -not available when building without exception support.
│ │ │ │ -The overload that takes a span also needs an extra parameter of type
│ │ │ │ -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]
│ │ │ │ -********** ffiilleess(()) oorriigg__ffiilleess(()) **********
│ │ │ │ -file_storage const& ffiilleess () const;
│ │ │ │ -file_storage const& oorriigg__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
│ │ │ │ -file.
│ │ │ │ -orig_files() returns the original (unmodified) file storage for this torrent.
│ │ │ │ -This is used by the web server connection, which needs to request files with
│ │ │ │ -the original names. Filename may be changed using torrent_info::rename_file().
│ │ │ │ -For more information on the _f_i_l_e___s_t_o_r_a_g_e object, see the separate document on
│ │ │ │ -how to create torrents.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** rreennaammee__ffiillee(()) **********
│ │ │ │ -void rreennaammee__ffiillee (file_index_t index, std::string const& new_filename);
│ │ │ │ -Renames the file with the specified index to the new name. The new filename is
│ │ │ │ -reflected by the file_storage returned by files() but not by the one returned
│ │ │ │ -by orig_files().
│ │ │ │ -If you want to rename the base name of the torrent (for a multi file torrent),
│ │ │ │ -you can copy the file_storage (see _f_i_l_e_s_(_) and _o_r_i_g___f_i_l_e_s_(_) ), change the name,
│ │ │ │ -and then use _r_e_m_a_p___f_i_l_e_s_(_).
│ │ │ │ -The new_filename can both be a relative path, in which case the file name is
│ │ │ │ -relative to the save_path of the torrent. If the new_filename is an absolute
│ │ │ │ -path (i.e. is_complete(new_filename) == true), then the file is detached from
│ │ │ │ -the save_path of the torrent. In this case the file is not moved when
│ │ │ │ -_m_o_v_e___s_t_o_r_a_g_e_(_) is invoked.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** rreemmaapp__ffiilleess(()) **********
│ │ │ │ -void rreemmaapp__ffiilleess (file_storage const& f);
│ │ │ │ -Warning
│ │ │ │ -Usingremap_files()is discouraged as it's incompatible with v2 torrents. This is
│ │ │ │ -because the piece boundaries and piece hashes in v2 torrents are intimately
│ │ │ │ -tied to the file boundaries. Instead, just rename individual files, or
│ │ │ │ -implement a custom _d_i_s_k___i_n_t_e_r_f_a_c_e to customize how to store files.
│ │ │ │ -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]
│ │ │ │ -********** aadddd__ttrraacckkeerr(()) ttrraacckkeerrss(()) cclleeaarr__ttrraacckkeerrss(()) **********
│ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier = 0);
│ │ │ │ -std::vector const& ttrraacckkeerrss () const;
│ │ │ │ -void aadddd__ttrraacckkeerr (std::string const& url, int tier
│ │ │ │ - , announce_entry::tracker_source source);
│ │ │ │ -void cclleeaarr__ttrraacckkeerrss ();
│ │ │ │ -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;
│ │ │ │ -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]
│ │ │ │ -********** sseett__wweebb__sseeeeddss(()) aadddd__uurrll__sseeeedd(()) wweebb__sseeeeddss(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ -std::vector const& wweebb__sseeeeddss () const;
│ │ │ │ -void sseett__wweebb__sseeeeddss (std::vector seeds);
│ │ │ │ -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());
│ │ │ │ -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
│ │ │ │ -the URL itself. The string will be sent as the HTTP authorization header's
│ │ │ │ -value (without specifying "Basic").
│ │ │ │ -The extra_headers argument defaults to an empty list, but can be used to insert
│ │ │ │ -custom HTTP headers in the requests to a specific web seed.
│ │ │ │ -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]
│ │ │ │ -********** ttoottaall__ssiizzee(()) **********
│ │ │ │ -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]
│ │ │ │ -********** ppiieeccee__lleennggtthh(()) nnuumm__ppiieecceess(()) **********
│ │ │ │ -int nnuumm__ppiieecceess () const;
│ │ │ │ -int ppiieeccee__lleennggtthh () 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]
│ │ │ │ -********** ppiieeccee__rraannggee(()) llaasstt__ppiieeccee(()) eenndd__ppiieeccee(()) **********
│ │ │ │ -index_range ppiieeccee__rraannggee () const;
│ │ │ │ -piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ -piece_index_t llaasstt__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(()) **********
│ │ │ │ -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 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
│ │ │ │ -file_path(), file_size()-family of functions to access files using indices.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** mmaapp__bblloocckk(()) **********
│ │ │ │ -std::vector mmaapp__bblloocckk (piece_index_t const piece
│ │ │ │ - , std::int64_t offset, int size) const;
│ │ │ │ -This function will map a piece index, a byte offset within that piece and a
│ │ │ │ -size (in bytes) into the corresponding files with offsets where that data for
│ │ │ │ -that piece is supposed to be stored. See _f_i_l_e___s_l_i_c_e.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** mmaapp__ffiillee(()) **********
│ │ │ │ -peer_request mmaapp__ffiillee (file_index_t const file, std::int64_t offset, int size)
│ │ │ │ -const;
│ │ │ │ -This function will map a range in a specific file into a range in the torrent.
│ │ │ │ -The file_offset parameter is the offset in the file, given in bytes, where 0 is
│ │ │ │ -the start of the file. See _p_e_e_r___r_e_q_u_e_s_t.
│ │ │ │ -The input range is assumed to be valid within the torrent. file_offset + size
│ │ │ │ -is not allowed to be greater than the file size. file_index must refer to a
│ │ │ │ -valid file, i.e. it cannot be >= num_files().
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ssssll__cceerrtt(()) **********
│ │ │ │ -string_view ssssll__cceerrtt () const;
│ │ │ │ -Returns the SSL root certificate for the torrent, if it is an SSL torrent.
│ │ │ │ -Otherwise returns an empty string. The certificate is the public certificate in
│ │ │ │ -x509 format.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** iiss__vvaalliidd(()) **********
│ │ │ │ -bool iiss__vvaalliidd () const;
│ │ │ │ -returns true if this _t_o_r_r_e_n_t___i_n_f_o object has a torrent loaded. This is
│ │ │ │ -primarily used to determine if a magnet link has had its metadata resolved yet
│ │ │ │ -or not.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** pprriivv(()) **********
│ │ │ │ -bool pprriivv () const;
│ │ │ │ -returns true if this torrent is private. i.e., the client should not advertise
│ │ │ │ -itself on the trackerless network (the Kademlia DHT) for this torrent.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** iiss__ii22pp(()) **********
│ │ │ │ -bool iiss__ii22pp () const;
│ │ │ │ -returns true if this is an i2p torrent. This is determined by whether or not it
│ │ │ │ -has a tracker whose URL domain name ends with ".i2p". i2p torrents disable the
│ │ │ │ -DHT and local peer discovery as well as talking to peers over anything other
│ │ │ │ -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(()) **********
│ │ │ │ -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;
│ │ │ │ -name() returns the name of the torrent. name contains UTF-8 encoded string.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ccrreeaattiioonn__ddaattee(()) **********
│ │ │ │ -std::time_t ccrreeaattiioonn__ddaattee () const;
│ │ │ │ -creation_date() returns the creation date of the torrent as time_t (_p_o_s_i_x
│ │ │ │ -_t_i_m_e). If there's no time stamp in the torrent file, 0 is returned. .. posix
│ │ │ │ -time: _h_t_t_p_:_/_/_w_w_w_._o_p_e_n_g_r_o_u_p_._o_r_g_/_o_n_l_i_n_e_p_u_b_s_/_0_0_9_6_9_5_3_9_9_/_f_u_n_c_t_i_o_n_s_/_t_i_m_e_._h_t_m_l
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ccrreeaattoorr(()) **********
│ │ │ │ -const std::string& ccrreeaattoorr () const;
│ │ │ │ -creator() returns the creator string in the torrent. If there is no creator
│ │ │ │ -string it will return an empty string.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ccoommmmeenntt(()) **********
│ │ │ │ -const std::string& ccoommmmeenntt () const;
│ │ │ │ -comment() returns the comment associated with the torrent. If there's no
│ │ │ │ -comment, it will return an empty string. comment contains UTF-8 encoded string.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** nnooddeess(()) **********
│ │ │ │ -std::vector> const& nnooddeess () const;
│ │ │ │ -If this torrent contains any DHT nodes, they are put in this vector in their
│ │ │ │ -original form (host name and port number).
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** aadddd__nnooddee(()) **********
│ │ │ │ -void aadddd__nnooddee (std::pair const& node);
│ │ │ │ -This is used when creating torrent. Use this to add a known DHT node. It may be
│ │ │ │ -used, by the client, to bootstrap into the DHT network.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ppaarrssee__iinnffoo__sseeccttiioonn(()) **********
│ │ │ │ -bool ppaarrssee__iinnffoo__sseeccttiioonn (bdecode_node const& info, error_code& ec, int
│ │ │ │ -max_pieces);
│ │ │ │ -populates the _t_o_r_r_e_n_t___i_n_f_o by providing just the info-dict buffer. This is used
│ │ │ │ -when loading a torrent from a magnet link for instance, where we only have the
│ │ │ │ -info-dict. The _b_d_e_c_o_d_e___n_o_d_e e points to a parsed info-dictionary. ec returns an
│ │ │ │ -error code if something fails (typically if the info dictionary is malformed).
│ │ │ │ -Themax_piecesparameter allows limiting the amount of memory dedicated to
│ │ │ │ -loading the torrent, and fails for torrents that exceed the limit. To load
│ │ │ │ -large torrents, this limit may also need to be raised in _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 and in calls to _r_e_a_d___r_e_s_u_m_e___d_a_t_a_(_).
│ │ │ │ +********** iinnffoo__hhaasshh__tt(()) **********
│ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ +iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ +explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ +iinnffoo__hhaasshh__tt (sha1_hash h1, 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]
│ │ │ │ -********** iinnffoo(()) **********
│ │ │ │ -bdecode_node iinnffoo (char const* key) const;
│ │ │ │ -This function looks up keys from the info-dictionary of the loaded torrent
│ │ │ │ -file. It can be used to access extension values put in the .torrent file. If
│ │ │ │ -the specified key cannot be found, it returns nullptr.
│ │ │ │ +********** hhaass__vv11(()) hhaass__vv22(()) hhaass(()) **********
│ │ │ │ +bool hhaass__vv22 () const;
│ │ │ │ +bool hhaass__vv11 () const;
│ │ │ │ +bool hhaass (protocol_version v) const;
│ │ │ │ +returns true if the corresponding info hash is present in this object.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** iinnffoo__sseeccttiioonn(()) **********
│ │ │ │ -span iinnffoo__sseeccttiioonn () const;
│ │ │ │ -returns a the raw info section of the torrent file. The underlying buffer is
│ │ │ │ -still owned by the _t_o_r_r_e_n_t___i_n_f_o object
│ │ │ │ +********** 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]
│ │ │ │ -********** ppiieeccee__llaayyeerr(()) **********
│ │ │ │ -span ppiieeccee__llaayyeerr (file_index_t) const;
│ │ │ │ -return the bytes of the piece layer hashes for the specified file. If the file
│ │ │ │ -doesn't have a piece layer, an empty span is returned. The span size is
│ │ │ │ -divisible by 32, the size of a SHA-256 hash. If the size of the file is smaller
│ │ │ │ -than or equal to the piece size, the files "root hash" is the hash of the file
│ │ │ │ -and is not saved separately in the "piece layers" field, but this function
│ │ │ │ -still returns the root hash of the file in that case.
│ │ │ │ +********** ggeett__bbeesstt(()) **********
│ │ │ │ +sha1_hash ggeett__bbeesstt () const;
│ │ │ │ +returns the v2 (truncated) info-hash, if there is one, otherwise returns the v1
│ │ │ │ +info-hash
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ffrreeee__ppiieeccee__llaayyeerrss(()) **********
│ │ │ │ -void ffrreeee__ppiieeccee__llaayyeerrss ();
│ │ │ │ -clears the piece layers from the _t_o_r_r_e_n_t___i_n_f_o. This is done by the _s_e_s_s_i_o_n when
│ │ │ │ -a torrent is added, to avoid storing it twice. The piece layer (or other hashes
│ │ │ │ -part of the merkle tree) are stored in the internal torrent object.
│ │ │ │ +********** ffoorr__eeaacchh(()) **********
│ │ │ │ +template void ffoorr__eeaacchh (F f) const;
│ │ │ │ +calls the function object f for each hash that is available. starting with v1.
│ │ │ │ +The signature of F is:
│ │ │ │ +void(sha1_hash const&, protocol_version);
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ ppeeeerr__iinnffoo ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___i_n_f_o_._h_p_p"
│ │ │ │ holds information and statistics about one peer that libtorrent is connected to
│ │ │ │ struct peer_info
│ │ │ │ {
│ │ │ │ sha256_hash ii22pp__ddeessttiinnaattiioonn () const;
│ │ │ │ @@ -2888,137 +1150,63 @@
│ │ │ │ to disk before downloading more.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ read_state write_state
│ │ │ │ bitmasks indicating what state this peer is in with regards to sending
│ │ │ │ and receiving data. The states are defined as independent flags of type
│ │ │ │ bandwidth_state_flags_t, in this class.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ iinnffoo__hhaasshh__tt ************
│ │ │ │ -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
│ │ │ │ -{
│ │ │ │ - iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ - iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ - explicit iinnffoo__hhaasshh__tt (sha1_hash h1) noexcept;
│ │ │ │ - bool hhaass (protocol_version v) const;
│ │ │ │ - bool hhaass__vv22 () const;
│ │ │ │ - bool hhaass__vv11 () 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;
│ │ │ │ - bool ooppeerraattoorr<< (info_hash_t const& o) const;
│ │ │ │ - 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(()) **********
│ │ │ │ -iinnffoo__hhaasshh__tt () noexcept = default;
│ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha256_hash h2) noexcept;
│ │ │ │ -iinnffoo__hhaasshh__tt (sha1_hash h1, sha256_hash h2) noexcept;
│ │ │ │ -explicit iinnffoo__hhaasshh__tt (sha1_hash h1) 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__vv22(()) hhaass(()) hhaass__vv11(()) **********
│ │ │ │ -bool hhaass (protocol_version v) const;
│ │ │ │ -bool hhaass__vv22 () const;
│ │ │ │ -bool hhaass__vv11 () 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]
│ │ │ │ -********** ggeett__bbeesstt(()) **********
│ │ │ │ -sha1_hash ggeett__bbeesstt () const;
│ │ │ │ -returns the v2 (truncated) info-hash, if there is one, otherwise returns the v1
│ │ │ │ -info-hash
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ffoorr__eeaacchh(()) **********
│ │ │ │ -template void ffoorr__eeaacchh (F f) const;
│ │ │ │ -calls the function object f for each hash that is available. starting with v1.
│ │ │ │ -The signature of F is:
│ │ │ │ -void(sha1_hash const&, protocol_version);
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ ppiieeccee__bblloocckk ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_i_e_c_e___b_l_o_c_k_._h_p_p"
│ │ │ │ struct piece_block
│ │ │ │ {
│ │ │ │ - ppiieeccee__bblloocckk (piece_index_t p_index, int b_index);
│ │ │ │ ppiieeccee__bblloocckk () = default;
│ │ │ │ + ppiieeccee__bblloocckk (piece_index_t p_index, int b_index);
│ │ │ │ bool ooppeerraattoorr<< (piece_block const& b) const;
│ │ │ │ bool ooppeerraattoorr==== (piece_block const& b) const;
│ │ │ │ bool ooppeerraattoorr!!== (piece_block const& b) const;
│ │ │ │
│ │ │ │ static const piece_block invalid;
│ │ │ │ piece_index_t piece_index {0};
│ │ │ │ int bblloocckk__iinnddeexx = 0;
│ │ │ │ };
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ppeeeerr__rreeqquueesstt ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___r_e_q_u_e_s_t_._h_p_p"
│ │ │ │ -represents a byte range within a piece. Internally this is is used for incoming
│ │ │ │ -piece requests.
│ │ │ │ -struct peer_request
│ │ │ │ -{
│ │ │ │ - bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ -
│ │ │ │ - piece_index_t piece;
│ │ │ │ - int start;
│ │ │ │ - int length;
│ │ │ │ -};
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** ooppeerraattoorr====(()) **********
│ │ │ │ -bool ooppeerraattoorr==== (peer_request const& r) const;
│ │ │ │ -returns true if the right hand side _p_e_e_r___r_e_q_u_e_s_t refers to the same range as
│ │ │ │ -this does.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ - piece
│ │ │ │ - The index of the piece in which the range starts.
│ │ │ │ -[_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__ffiillee(()) llooaadd__ttoorrrreenntt__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ppaarrsseedd(()) ************
│ │ │ │ +************ llooaadd__ttoorrrreenntt__bbuuffffeerr(()) llooaadd__ttoorrrreenntt__ffiillee(()) llooaadd__ttoorrrreenntt__ppaarrsseedd(()) ************
│ │ │ │ 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);
│ │ │ │ -add_torrent_params llooaadd__ttoorrrreenntt__ffiillee (
│ │ │ │ - std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ -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__ffiillee (
│ │ │ │ - std::string const& filename);
│ │ │ │ + std::string const& filename, load_torrent_limits const& cfg);
│ │ │ │ add_torrent_params llooaadd__ttoorrrreenntt__ppaarrsseedd (
│ │ │ │ bdecode_node const& torrent_file);
│ │ │ │ +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]
│ │ │ │ +************ ttrruunnccaattee__ffiilleess(()) ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_u_n_c_a_t_e_._h_p_p"
│ │ │ │ +void ttrruunnccaattee__ffiilleess (file_storage const& fs, std::string const& save_path,
│ │ │ │ +storage_error& ec);
│ │ │ │ +Truncates files larger than specified in the _f_i_l_e___s_t_o_r_a_g_e, saved under the
│ │ │ │ +specified save_path.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ ttoorrrreenntt__ppeeeerr__eeqquuaall(()) ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___p_e_e_r_._h_p_p"
│ │ │ │ +inline bool ttoorrrreenntt__ppeeeerr__eeqquuaall (torrent_peer const* lhs, torrent_peer const*
│ │ │ │ +rhs);
│ │ │ │ +[_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 (add_torrent_params const& atp);
│ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_handle const& handle);
│ │ │ │ std::string mmaakkee__mmaaggnneett__uurrii (torrent_info const& info);
│ │ │ │ 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
│ │ │ │ @@ -3039,62 +1227,68 @@
│ │ │ │ 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);
│ │ │ │ +void ppaarrssee__mmaaggnneett__uurrii (string_view uri, add_torrent_params& p, error_code& ec);
│ │ │ │ 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]
│ │ │ │ -************ ttoorrrreenntt__ppeeeerr__eeqquuaall(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___p_e_e_r_._h_p_p"
│ │ │ │ -inline bool ttoorrrreenntt__ppeeeerr__eeqquuaall (torrent_peer const* lhs, torrent_peer const*
│ │ │ │ -rhs);
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ttrruunnccaattee__ffiilleess(()) ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_u_n_c_a_t_e_._h_p_p"
│ │ │ │ -void ttrruunnccaattee__ffiilleess (file_storage const& fs, std::string const& save_path,
│ │ │ │ -storage_error& ec);
│ │ │ │ -Truncates files larger than specified in the _f_i_l_e___s_t_o_r_a_g_e, saved under the
│ │ │ │ -specified save_path.
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ vveerrssiioonn(()) ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ char const* vveerrssiioonn ();
│ │ │ │ returns the libtorrent version as string form in this format:
│ │ │ │ "..."
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ eennuumm ccoonnnneeccttiioonn__ttyyppee ************
│ │ │ │ +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_p_p"
│ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ +|_nn_aa_mm_ee_ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ +|_b_i_t_t_o_r_r_e_n_t_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_u_r_l___s_e_e_d_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_h_t_t_p___s_e_e_d_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ eennuumm pprroottooccooll__vveerrssiioonn ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p"
│ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ +|_nn_aa_mm_ee_|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_V_1_ _ _|_0_ _ _ _ _|_T_h_e_ _o_r_i_g_i_n_a_l_ _B_i_t_T_o_r_r_e_n_t_ _v_e_r_s_i_o_n_,_ _u_s_i_n_g_ _S_H_A_-_1_ _h_a_s_h_e_s_ _ _ _ _ _ _ |
│ │ │ │ +|_V_2_ _ _|_1_ _ _ _ _|_V_e_r_s_i_o_n_ _2_ _o_f_ _t_h_e_ _B_i_t_T_o_r_r_e_n_t_ _p_r_o_t_o_c_o_l_,_ _u_s_i_n_g_ _S_H_A_-_2_5_6_ _h_a_s_h_e_s|
│ │ │ │ +|_N_U_M_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ eennuumm eevveenntt__tt ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_a_c_k_e_r___m_a_n_a_g_e_r_._h_p_p"
│ │ │ │ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ +|_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ +|_n_o_n_e_ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_c_o_m_p_l_e_t_e_d_|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_s_t_a_r_t_e_d_ _ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_s_t_o_p_p_e_d_ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +|_p_a_u_s_e_d_ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ eennuumm ssoocckkeett__ttyyppee__tt ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_o_c_k_e_t___t_y_p_e_._h_p_p"
│ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ |_nn_aa_mm_ee_ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ |_t_c_p_ _ _ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_s_o_c_k_s_5_ _ _ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_h_t_t_p_ _ _ _ _ _ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_u_t_p_ _ _ _ _ _ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_i_2_p_ _ _ _ _ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_t_c_p___s_s_l_ _ _ _|_5_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_s_o_c_k_s_5___s_s_l_|_6_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_h_t_t_p___s_s_l_ _ _|_7_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_u_t_p___s_s_l_ _ _ _|_8_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm pprroottooccooll__vveerrssiioonn ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_n_f_o___h_a_s_h_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_V_1_ _ _|_0_ _ _ _ _|_T_h_e_ _o_r_i_g_i_n_a_l_ _B_i_t_T_o_r_r_e_n_t_ _v_e_r_s_i_o_n_,_ _u_s_i_n_g_ _S_H_A_-_1_ _h_a_s_h_e_s_ _ _ _ _ _ _ |
│ │ │ │ -|_V_2_ _ _|_1_ _ _ _ _|_V_e_r_s_i_o_n_ _2_ _o_f_ _t_h_e_ _B_i_t_T_o_r_r_e_n_t_ _p_r_o_t_o_c_o_l_,_ _u_s_i_n_g_ _S_H_A_-_2_5_6_ _h_a_s_h_e_s|
│ │ │ │ -|_N_U_M_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ eennuumm ppoorrttmmaapp__ttrraannssppoorrtt ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_o_r_t_m_a_p_._h_p_p"
│ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ |_nn_aa_mm_ee_ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_n_a_t_p_m_p_|_0_ _ _ _ _|_n_a_t_p_m_p_ _c_a_n_ _b_e_ _N_A_T_-_P_M_P_ _o_r_ _P_C_P|
│ │ │ │ |_u_p_n_p_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ @@ -3102,44 +1296,41 @@
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_o_r_t_m_a_p_._h_p_p"
│ │ │ │ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ |_nn_aa_mm_ee_|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ |_n_o_n_e_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_t_c_p_ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ |_u_d_p_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm eevveenntt__tt ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_r_a_c_k_e_r___m_a_n_a_g_e_r_._h_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_n_o_n_e_ _ _ _ _ _|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_c_o_m_p_l_e_t_e_d_|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_s_t_a_r_t_e_d_ _ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_s_t_o_p_p_e_d_ _ _|_3_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_p_a_u_s_e_d_ _ _ _|_4_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ eennuumm ccoonnnneeccttiioonn__ttyyppee ************
│ │ │ │ -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_p_p"
│ │ │ │ - _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
│ │ │ │ -|_nn_aa_mm_ee_ _ _ _ _ _ _|_vv_aa_ll_uu_ee_|_dd_ee_ss_cc_rr_ii_pp_tt_ii_oo_nn|
│ │ │ │ -|_b_i_t_t_o_r_r_e_n_t_|_0_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_u_r_l___s_e_e_d_ _ _|_1_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -|_h_t_t_p___s_e_e_d_ _|_2_ _ _ _ _|_ _ _ _ _ _ _ _ _ _ _ |
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ ddoowwnnllooaadd__pprriioorriittyy__tt ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_o_w_n_l_o_a_d___p_r_i_o_r_i_t_y_._h_p_p"
│ │ │ │ dont_download
│ │ │ │ Don't download the file or piece. Partial pieces may still be downloaded
│ │ │ │ when setting file priorities.
│ │ │ │ default_priority
│ │ │ │ The default priority for files and pieces.
│ │ │ │ low_priority
│ │ │ │ The lowest priority for files and pieces.
│ │ │ │ top_priority
│ │ │ │ The highest priority for files and pieces.
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ ppeexx__ffllaaggss__tt ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_x___f_l_a_g_s_._h_p_p"
│ │ │ │ + pex_encryption
│ │ │ │ + the peer supports protocol encryption
│ │ │ │ + pex_seed
│ │ │ │ + the peer is a seed
│ │ │ │ + pex_utp
│ │ │ │ + the peer supports the uTP, transport protocol over UDP.
│ │ │ │ + pex_holepunch
│ │ │ │ + the peer supports the holepunch extension If this flag is received from a
│ │ │ │ + peer, it can be used as a rendezvous point in case direct connections to
│ │ │ │ + the peer fail
│ │ │ │ + pex_lt_v2
│ │ │ │ + protocol v2 this is not a standard flag, it is only used internally
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ iinntt ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ version_major
│ │ │ │ the major, minor and tiny versions of libtorrent
│ │ │ │ version_minor
│ │ │ │ the major, minor and tiny versions of libtorrent
│ │ │ │ version_tiny
│ │ │ │ @@ -3151,29 +1342,14 @@
│ │ │ │ the libtorrent version in string form
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ ssttdd::::uuiinntt6644__tt ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_v_e_r_s_i_o_n_._h_p_p"
│ │ │ │ version_revision
│ │ │ │ the git commit of this libtorrent version
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ ppeexx__ffllaaggss__tt ************
│ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_x___f_l_a_g_s_._h_p_p"
│ │ │ │ - pex_encryption
│ │ │ │ - the peer supports protocol encryption
│ │ │ │ - pex_seed
│ │ │ │ - the peer is a seed
│ │ │ │ - pex_utp
│ │ │ │ - the peer supports the uTP, transport protocol over UDP.
│ │ │ │ - pex_holepunch
│ │ │ │ - the peer supports the holepunch extension If this flag is received from a
│ │ │ │ - peer, it can be used as a rendezvous point in case direct connections to
│ │ │ │ - the peer fail
│ │ │ │ - pex_lt_v2
│ │ │ │ - protocol v2 this is not a standard flag, it is only used internally
│ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ************ ttoorrrreenntt__ffllaaggss__tt ************
│ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_t_o_r_r_e_n_t___f_l_a_g_s_._h_p_p"
│ │ │ │ seed_mode
│ │ │ │ If seed_mode is set, libtorrent will assume that all files are present
│ │ │ │ for this torrent and that they all match the hashes in the torrent file.
│ │ │ │ Each time a peer requests to download a block, the piece is verified
│ │ │ │ against the hash, unless it has been verified already. If a hash fails,
│ │ │ │ @@ -3341,592 +1517,1529 @@
│ │ │ │ tracker return them and the _s_e_s_s_i_o_n is configured with a SAM connection).
│ │ │ │ This flag is set automatically when adding a torrent that has at least
│ │ │ │ one tracker whose hostname ends with .i2p. It's also set by
│ │ │ │ _p_a_r_s_e___m_a_g_n_e_t___u_r_i_(_) if the tracker list contains such URL.
│ │ │ │ all
│ │ │ │ all torrent flags combined. Can conveniently be used when creating masks
│ │ │ │ for flags
│ │ │ │ -libtorrent has a _p_l_u_g_i_n interface for implementing extensions to the protocol.
│ │ │ │ -These can be general extensions for transferring metadata or peer exchange
│ │ │ │ -extensions, or it could be used to provide a way to customize the protocol to
│ │ │ │ -fit a particular (closed) network.
│ │ │ │ -In short, the _p_l_u_g_i_n interface makes it possible to:
│ │ │ │ - * register extension messages (sent in the extension handshake), see
│ │ │ │ - _e_x_t_e_n_s_i_o_n_s.
│ │ │ │ - * add data and parse data from the extension handshake.
│ │ │ │ - * send extension messages and standard bittorrent messages.
│ │ │ │ - * override or block the handling of standard bittorrent messages.
│ │ │ │ - * save and restore state via the _s_e_s_s_i_o_n state
│ │ │ │ - * see all alerts that are posted
│ │ │ │ -************ aa wwoorrdd ooff ccaauuttiioonn ************
│ │ │ │ -Writing your own _p_l_u_g_i_n is a very easy way to introduce serious bugs such as
│ │ │ │ -dead locks and race conditions. Since a _p_l_u_g_i_n has access to internal
│ │ │ │ -structures it is also quite easy to sabotage libtorrent's operation.
│ │ │ │ -All the callbacks are always called from the libtorrent network thread. In case
│ │ │ │ -portions of your _p_l_u_g_i_n are called from other threads, typically the main
│ │ │ │ -thread, you cannot use any of the member functions on the internal structures
│ │ │ │ -in libtorrent, since those require being called from the libtorrent network
│ │ │ │ -thread . Furthermore, you also need to synchronize your own shared data within
│ │ │ │ -the _p_l_u_g_i_n, to make sure it is not accessed at the same time from the
│ │ │ │ -libtorrent thread (through a callback). If you need to send out a message from
│ │ │ │ -another thread, it is advised to use an internal queue, and do the actual
│ │ │ │ -sending in tick().
│ │ │ │ -Since the _p_l_u_g_i_n interface gives you easy access to internal structures, it is
│ │ │ │ -not supported as a stable API. Plugins should be considered specific to a
│ │ │ │ -specific version of libtorrent. Although, in practice the internals mostly
│ │ │ │ -don't change that dramatically.
│ │ │ │ -************ pplluuggiinn--iinntteerrffaaccee ************
│ │ │ │ -The _p_l_u_g_i_n interface consists of three base classes that the _p_l_u_g_i_n may
│ │ │ │ -implement. These are called _p_l_u_g_i_n, _t_o_r_r_e_n_t___p_l_u_g_i_n and _p_e_e_r___p_l_u_g_i_n. They are
│ │ │ │ -found in the header.
│ │ │ │ -These plugins are instantiated for each _s_e_s_s_i_o_n, torrent and possibly each
│ │ │ │ -peer, respectively.
│ │ │ │ -For plugins that only need per torrent state, it is enough to only implement
│ │ │ │ -torrent_plugin and pass a constructor function or function object to session::
│ │ │ │ -add_extension() or torrent_handle::add_extension() (if the torrent has already
│ │ │ │ -been started and you want to hook in the extension at run-time).
│ │ │ │ -The signature of the function is:
│ │ │ │ -std::shared_ptr (*)(torrent_handle const&, client_data_t);
│ │ │ │ -The second argument is the userdata passed to session::add_torrent() or
│ │ │ │ -torrent_handle::add_extension().
│ │ │ │ -The function should return a std::shared_ptr which may or may
│ │ │ │ -not be 0. If it is a nullptr, the extension is simply ignored for this torrent.
│ │ │ │ -If it is a valid pointer (to a class inheriting torrent_plugin), it will be
│ │ │ │ -associated with this torrent and callbacks will be made on torrent events.
│ │ │ │ -For more elaborate plugins which require _s_e_s_s_i_o_n wide state, you would
│ │ │ │ -implement plugin, construct an object (in a std::shared_ptr) and pass it in to
│ │ │ │ -session::add_extension().
│ │ │ │ -************ ccuussttoomm aalleerrttss ************
│ │ │ │ -Since plugins are running within internal libtorrent threads, one convenient
│ │ │ │ -way to communicate with the client is to post custom alerts.
│ │ │ │ -The expected interface of any _a_l_e_r_t, apart from deriving from the _a_l_e_r_t base
│ │ │ │ -class, looks like this:
│ │ │ │ -static const int alert_type = <>;
│ │ │ │ -virtual int type() const { return alert_type; }
│ │ │ │ -
│ │ │ │ -virtual std::string message() const;
│ │ │ │ -
│ │ │ │ -static const alert_category_t static_category = <>;
│ │ │ │ -virtual alert_category_t category() const { return static_category; }
│ │ │ │ -
│ │ │ │ -virtual char const* what() const { return <>; }
│ │ │ │ -The alert_type is used for the type-checking in alert_cast. It must not collide
│ │ │ │ -with any other _a_l_e_r_t. The built-in alerts in libtorrent will not use _a_l_e_r_t type
│ │ │ │ -IDs greater than user_alert_id. When defining your own _a_l_e_r_t, make sure it's
│ │ │ │ -greater than this constant.
│ │ │ │ -type() is the run-time equivalence of the alert_type.
│ │ │ │ -The message() virtual function is expected to construct a useful string
│ │ │ │ -representation of the _a_l_e_r_t and the event or data it represents. Something
│ │ │ │ -convenient to put in a log file for instance.
│ │ │ │ -clone() is used internally to copy alerts. The suggested implementation of
│ │ │ │ -simply allocating a new instance as a copy of *this is all that's expected.
│ │ │ │ -The static category is required for checking whether or not the category for a
│ │ │ │ -specific _a_l_e_r_t is enabled or not, without instantiating the _a_l_e_r_t. The category
│ │ │ │ -virtual function is the run-time equivalence.
│ │ │ │ -The what() virtual function may simply be a string literal of the class name of
│ │ │ │ -your _a_l_e_r_t.
│ │ │ │ -For more information, see the _a_l_e_r_t_ _s_e_c_t_i_o_n.
│ │ │ │ +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
│ │ │ │ +constructed.
│ │ │ │ +You have control over proxy and authorization settings and also the user-agent
│ │ │ │ +that will be sent to the tracker. The user-agent will also be used to identify
│ │ │ │ +the client with other peers.
│ │ │ │ +Each configuration option is named with an enum value inside the _s_e_t_t_i_n_g_s___p_a_c_k
│ │ │ │ +class. These are the available settings:
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -************ 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"
│ │ │ │ -this is the base class for a _s_e_s_s_i_o_n _p_l_u_g_i_n. One primary feature is that it is
│ │ │ │ -notified of all torrents that are added to the _s_e_s_s_i_o_n, and can add its own
│ │ │ │ -torrent_plugins.
│ │ │ │ -struct plugin
│ │ │ │ +************ ddiisskk__oobbsseerrvveerr ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___o_b_s_e_r_v_e_r_._h_p_p"
│ │ │ │ +struct disk_observer
│ │ │ │ {
│ │ │ │ - virtual feature_flags_t iimmpplleemmeenntteedd__ffeeaattuurreess ();
│ │ │ │ - virtual std::shared_ptr nneeww__ttoorrrreenntt (torrent_handle const&,
│ │ │ │ -client_data_t);
│ │ │ │ - virtual void aaddddeedd (session_handle const&);
│ │ │ │ - virtual void aabboorrtt ();
│ │ │ │ - virtual bool oonn__ddhhtt__rreeqquueesstt (string_view //** qquueerryy **//
│ │ │ │ - , udp::endpoint const& //** ssoouurrccee **//, bdecode_node const& //** mmeessssaaggee **//
│ │ │ │ - , entry& //** rreessppoonnssee **//);
│ │ │ │ - virtual void oonn__aalleerrtt (alert const*);
│ │ │ │ - virtual bool oonn__uunnkknnoowwnn__ttoorrrreenntt (info_hash_t const& //** iinnffoo__hhaasshh **//
│ │ │ │ - , peer_connection_handle const& //** ppcc **//, add_torrent_params& //** pp **//);
│ │ │ │ - virtual void oonn__ttiicckk ();
│ │ │ │ - virtual uint64_t ggeett__uunncchhookkee__pprriioorriittyy (peer_connection_handle const& //** ppeeeerr
│ │ │ │ -**//);
│ │ │ │ - virtual std::map ssaavvee__ssttaattee () const;
│ │ │ │ - virtual void llooaadd__ssttaattee (std::map const&);
│ │ │ │ -
│ │ │ │ - static constexpr feature_flags_t ooppttiimmiissttiicc__uunncchhookkee__ffeeaattuurree = 1_bit;
│ │ │ │ - static constexpr feature_flags_t ttiicckk__ffeeaattuurree = 2_bit;
│ │ │ │ - static constexpr feature_flags_t ddhhtt__rreeqquueesstt__ffeeaattuurree = 3_bit;
│ │ │ │ - static constexpr feature_flags_t aalleerrtt__ffeeaattuurree = 4_bit;
│ │ │ │ - static constexpr feature_flags_t uunnkknnoowwnn__ttoorrrreenntt__ffeeaattuurree = 5_bit;
│ │ │ │ + virtual void oonn__ddiisskk () = 0;
│ │ │ │ };
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** iimmpplleemmeenntteedd__ffeeaattuurreess(()) **********
│ │ │ │ -virtual feature_flags_t iimmpplleemmeenntteedd__ffeeaattuurreess ();
│ │ │ │ -This function is expected to return a bitmask indicating which features this
│ │ │ │ -_p_l_u_g_i_n implements. Some callbacks on this object may not be called unless the
│ │ │ │ -corresponding feature flag is returned here. Note that callbacks may still be
│ │ │ │ -called even if the corresponding feature is not specified in the return value
│ │ │ │ -here. See feature_flags_t for possible flags to return.
│ │ │ │ +********** oonn__ddiisskk(()) **********
│ │ │ │ +virtual void oonn__ddiisskk () = 0;
│ │ │ │ +called when the disk cache size has dropped below the low watermark again and
│ │ │ │ +we can resume downloading from peers
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ ooppeenn__ffiillee__ssttaattee ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___i_n_t_e_r_f_a_c_e_._h_p_p"
│ │ │ │ +this contains information about a file that's currently open by the libtorrent
│ │ │ │ +disk I/O subsystem. It's associated with a single torrent.
│ │ │ │ +struct open_file_state
│ │ │ │ +{
│ │ │ │ + file_index_t file_index;
│ │ │ │ + file_open_mode_t open_mode;
│ │ │ │ + time_point last_use;
│ │ │ │ +};
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ + file_index
│ │ │ │ + the index of the file this _e_n_t_r_y refers to into the file_storage file
│ │ │ │ + list of this torrent. This starts indexing at 0.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ + open_mode
│ │ │ │ + open_mode is a bitmask of the file flags this file is currently opened
│ │ │ │ + with. For possible flags, see _f_i_l_e___o_p_e_n___m_o_d_e___t.
│ │ │ │ + Note that the read/write mode is not a bitmask. The two least significant
│ │ │ │ + bits are used to represent the read/write mode. Those bits can be masked
│ │ │ │ + out using the rw_mask constant.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ + last_use
│ │ │ │ + a (high precision) timestamp of when the file was last used.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +************ ddiisskk__iinntteerrffaaccee ************
│ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___i_n_t_e_r_f_a_c_e_._h_p_p"
│ │ │ │ +The _d_i_s_k___i_n_t_e_r_f_a_c_e is the customization point for disk I/O in libtorrent.
│ │ │ │ +implement this interface and provide a factory function to the _s_e_s_s_i_o_n
│ │ │ │ +constructor use custom disk I/O. All functions on the disk subsystem
│ │ │ │ +(implementing _d_i_s_k___i_n_t_e_r_f_a_c_e) are called from within libtorrent's network
│ │ │ │ +thread. For disk I/O to be performed in a separate thread, the disk subsystem
│ │ │ │ +has to manage that itself.
│ │ │ │ +Although the functions are called async_*, they do not technically hhaavvee to be
│ │ │ │ +asynchronous, but they support being asynchronous, by expecting the result
│ │ │ │ +passed back into a callback. The callbacks must be posted back onto the network
│ │ │ │ +thread via the io_context object passed into the constructor. The callbacks
│ │ │ │ +will be run in the network thread.
│ │ │ │ +struct disk_interface
│ │ │ │ +{
│ │ │ │ + virtual storage_holder nneeww__ttoorrrreenntt (storage_params const& p
│ │ │ │ + , std::shared_ptr const& torrent) = 0;
│ │ │ │ + virtual void rreemmoovvee__ttoorrrreenntt (storage_index_t) = 0;
│ │ │ │ + virtual bool aassyynncc__wwrriittee (storage_index_t storage, peer_request const& r
│ │ │ │ + , char const* buf, std::shared_ptr o
│ │ │ │ + , std::function handler
│ │ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ │ + virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r
│ │ │ │ + , std::function handler
│ │ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ │ + virtual void aassyynncc__hhaasshh (storage_index_t storage, piece_index_t piece,
│ │ │ │ +span v2
│ │ │ │ + , disk_job_flags_t flags
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ + virtual void aassyynncc__hhaasshh22 (storage_index_t storage, piece_index_t piece, int
│ │ │ │ +offset, disk_job_flags_t flags
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ + virtual void aassyynncc__mmoovvee__ssttoorraaggee (storage_index_t storage, std::string p,
│ │ │ │ +move_flags_t flags
│ │ │ │ + , std::function
│ │ │ │ +handler) = 0;
│ │ │ │ + virtual void aassyynncc__rreelleeaassee__ffiilleess (storage_index_t storage
│ │ │ │ + , std::function handler = std::function()) = 0;
│ │ │ │ + virtual void aassyynncc__cchheecckk__ffiilleess (storage_index_t storage
│ │ │ │ + , add_torrent_params const* resume_data
│ │ │ │ + , aux::vector links
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ + virtual void aassyynncc__ssttoopp__ttoorrrreenntt (storage_index_t storage
│ │ │ │ + , std::function handler = std::function()) = 0;
│ │ │ │ + virtual void aassyynncc__rreennaammee__ffiillee (storage_index_t storage
│ │ │ │ + , file_index_t index, std::string name
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ + virtual void aassyynncc__ddeelleettee__ffiilleess (storage_index_t storage, remove_flags_t
│ │ │ │ +options
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ + virtual void aassyynncc__sseett__ffiillee__pprriioorriittyy (storage_index_t storage
│ │ │ │ + , aux::vector prio
│ │ │ │ + , std::function)> handler) = 0;
│ │ │ │ + virtual void aassyynncc__cclleeaarr__ppiieeccee (storage_index_t storage, piece_index_t index
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ + virtual void uuppddaattee__ssttaattss__ccoouunntteerrss (counters& c) const = 0;
│ │ │ │ + virtual std::vector ggeett__ssttaattuuss (storage_index_t) const = 0;
│ │ │ │ + virtual void aabboorrtt (bool wait) = 0;
│ │ │ │ + virtual void ssuubbmmiitt__jjoobbss () = 0;
│ │ │ │ + virtual void sseettttiinnggss__uuppddaatteedd () = 0;
│ │ │ │ +
│ │ │ │ + static constexpr disk_job_flags_t ffoorrccee__ccooppyy = 0_bit;
│ │ │ │ + static constexpr disk_job_flags_t sseeqquueennttiiaall__aacccceessss = 3_bit;
│ │ │ │ + static constexpr disk_job_flags_t vvoollaattiillee__rreeaadd = 4_bit;
│ │ │ │ + static constexpr disk_job_flags_t vv11__hhaasshh = 5_bit;
│ │ │ │ + static constexpr disk_job_flags_t fflluusshh__ppiieeccee = 7_bit;
│ │ │ │ +};
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ ********** nneeww__ttoorrrreenntt(()) **********
│ │ │ │ -virtual std::shared_ptr nneeww__ttoorrrreenntt (torrent_handle const&,
│ │ │ │ -client_data_t);
│ │ │ │ -this is called by the _s_e_s_s_i_o_n every time a new torrent is added. The torrent*
│ │ │ │ -points to the internal torrent object created for the new torrent. The
│ │ │ │ -_c_l_i_e_n_t___d_a_t_a___t is the userdata pointer as passed in via _a_d_d___t_o_r_r_e_n_t___p_a_r_a_m_s.
│ │ │ │ -If the _p_l_u_g_i_n returns a _t_o_r_r_e_n_t___p_l_u_g_i_n instance, it will be added to the new
│ │ │ │ -torrent. Otherwise, return an empty shared_ptr to a _t_o_r_r_e_n_t___p_l_u_g_i_n (the
│ │ │ │ -default).
│ │ │ │ +virtual storage_holder nneeww__ttoorrrreenntt (storage_params const& p
│ │ │ │ + , std::shared_ptr const& torrent) = 0;
│ │ │ │ +this is called when a new torrent is added. The shared_ptr can be used to hold
│ │ │ │ +the internal torrent object alive as long as there are outstanding disk
│ │ │ │ +operations on the storage. The returned _s_t_o_r_a_g_e___h_o_l_d_e_r is an owning reference
│ │ │ │ +to the underlying storage that was just created. It is fundamentally a
│ │ │ │ +storage_index_t
│ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ -********** aaddddeedd(()) **********
│ │ │ │ -virtual void aaddddeedd (session_handle const&);
│ │ │ │ -called when _p_l_u_g_i_n is added to a _s_e_s_s_i_o_n
│ │ │ │ +********** rreemmoovvee__ttoorrrreenntt(()) **********
│ │ │ │ +virtual void rreemmoovvee__ttoorrrreenntt (storage_index_t) = 0;
│ │ │ │ +remove the storage with the specified index. This is not expected to delete any
│ │ │ │ +files from disk, just to clean up any resources associated with the specified
│ │ │ │ +storage.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__rreeaadd(()) aassyynncc__wwrriittee(()) **********
│ │ │ │ +virtual bool aassyynncc__wwrriittee (storage_index_t storage, peer_request const& r
│ │ │ │ + , char const* buf, std::shared_ptr o
│ │ │ │ + , std::function handler
│ │ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ │ +virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r
│ │ │ │ + , std::function handler
│ │ │ │ + , disk_job_flags_t flags = {}) = 0;
│ │ │ │ +perform a read or write operation from/to the specified storage index and the
│ │ │ │ +specified request. When the operation completes, call handler possibly with a
│ │ │ │ +_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r, holding the buffer with the result. Flags may be set to
│ │ │ │ +affect the read operation. See disk_job_flags_t.
│ │ │ │ +The _d_i_s_k___o_b_s_e_r_v_e_r is a callback to indicate that the store buffer/disk write
│ │ │ │ +queue is below the watermark to let peers start writing buffers to disk again.
│ │ │ │ +When async_write() returns true, indicating the write queue is full, the peer
│ │ │ │ +will stop further writes and wait for the passed-in disk_observer to be
│ │ │ │ +notified before resuming.
│ │ │ │ +Note that for async_read, the _p_e_e_r___r_e_q_u_e_s_t (r) is not necessarily aligned to
│ │ │ │ +blocks (but it is most of the time). However, all writes (passed to
│ │ │ │ +async_write) are guaranteed to be block aligned.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__hhaasshh(()) **********
│ │ │ │ +virtual void aassyynncc__hhaasshh (storage_index_t storage, piece_index_t piece,
│ │ │ │ +span v2
│ │ │ │ + , disk_job_flags_t flags
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ +Compute hash(es) for the specified piece. Unless the v1_hash flag is set (in
│ │ │ │ +flags), the SHA-1 hash of the whole piece does not need to be computed.
│ │ │ │ +Thev2span is optional and can be empty, which means v2 hashes should not be
│ │ │ │ +computed. If v2 is non-empty it must be at least large enough to hold all v2
│ │ │ │ +blocks in the piece, and this function will fill in the span with the SHA-256
│ │ │ │ +block hashes of the piece.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__hhaasshh22(()) **********
│ │ │ │ +virtual void aassyynncc__hhaasshh22 (storage_index_t storage, piece_index_t piece, int
│ │ │ │ +offset, disk_job_flags_t flags
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ +computes the v2 hash (SHA-256) of a single block. The block at offset in piece
│ │ │ │ +piece.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__mmoovvee__ssttoorraaggee(()) **********
│ │ │ │ +virtual void aassyynncc__mmoovvee__ssttoorraaggee (storage_index_t storage, std::string p,
│ │ │ │ +move_flags_t flags
│ │ │ │ + , std::function
│ │ │ │ +handler) = 0;
│ │ │ │ +called to request the files for the specified storage/torrent be moved to a new
│ │ │ │ +location. It is the disk I/O object's responsibility to synchronize this with
│ │ │ │ +any currently outstanding disk operations to the storage. Whether files are
│ │ │ │ +replaced at the destination path or not is controlled by flags (see
│ │ │ │ +_m_o_v_e___f_l_a_g_s___t).
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__rreelleeaassee__ffiilleess(()) **********
│ │ │ │ +virtual void aassyynncc__rreelleeaassee__ffiilleess (storage_index_t storage
│ │ │ │ + , std::function handler = std::function()) = 0;
│ │ │ │ +This is called on disk I/O objects to request they close all open files for the
│ │ │ │ +specified storage/torrent. If file handles are not pooled/cached, it can be a
│ │ │ │ +no-op. For truly asynchronous disk I/O, this should provide at least one point
│ │ │ │ +in time when all files are closed. It is possible that later asynchronous
│ │ │ │ +operations will re-open some of the files, by the time this completion handler
│ │ │ │ +is called, that's fine.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__cchheecckk__ffiilleess(()) **********
│ │ │ │ +virtual void aassyynncc__cchheecckk__ffiilleess (storage_index_t storage
│ │ │ │ + , add_torrent_params const* resume_data
│ │ │ │ + , aux::vector links
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ +this is called when torrents are added to validate their resume data against
│ │ │ │ +the files on disk. This function is expected to do a few things:
│ │ │ │ +if links is non-empty, it contains a string for each file in the torrent. The
│ │ │ │ +string being a path to an existing identical file. The default behavior is to
│ │ │ │ +create hard links of those files into the storage of the new torrent (specified
│ │ │ │ +by storage). An empty string indicates that there is no known identical file.
│ │ │ │ +This is part of the "mutable torrent" feature, where files can be reused from
│ │ │ │ +other torrents.
│ │ │ │ +The resume_data points the resume data passed in by the client.
│ │ │ │ +If the resume_data->flags field has the seed_mode flag set, all files/pieces
│ │ │ │ +are expected to be on disk already. This should be verified. Not just the
│ │ │ │ +existence of the file, but also that it has the correct size.
│ │ │ │ +Any file with a piece set in the resume_data->have_pieces bitmask should exist
│ │ │ │ +on disk, this should be verified. Pad files and files with zero priority may be
│ │ │ │ +skipped.
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__ssttoopp__ttoorrrreenntt(()) **********
│ │ │ │ +virtual void aassyynncc__ssttoopp__ttoorrrreenntt (storage_index_t storage
│ │ │ │ + , std::function handler = std::function()) = 0;
│ │ │ │ +This is called when a torrent is stopped. It gives the disk I/O object an
│ │ │ │ +opportunity to flush any data to disk that's currently kept cached. This
│ │ │ │ +function should at least do the same thing as _a_s_y_n_c___r_e_l_e_a_s_e___f_i_l_e_s_(_).
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__rreennaammee__ffiillee(()) **********
│ │ │ │ +virtual void aassyynncc__rreennaammee__ffiillee (storage_index_t storage
│ │ │ │ + , file_index_t index, std::string name
│ │ │ │ + , std::function handler) = 0;
│ │ │ │ +This function is called when the name of a file in the specified storage has
│ │ │ │ +been requested to be renamed. The disk I/O object is responsible for renaming
│ │ │ │ +the file without racing with other potentially outstanding operations against
│ │ │ │ +the file (such as read, write, move, etc.).
│ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ +********** aassyynncc__ddeelleettee__ffiilleess(()) **********
│ │ │ │ +virtual void aassyynncc__ddeelleettee__ffiilleess (storage_index_t storage, remove_flags_t
│ │ │ │ +options
│ │ │ │ + , std::function