│ │ │ │
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);
│ │ │ │ +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
│ │ │ │ + , settings_interface const& settings
│ │ │ │ , std::function<void(piece_index_t)> const& f);
│ │ │ │ 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);
│ │ │ │ -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);
│ │ │ │ +inline void set_piece_hashes (create_torrent& t, std::string const& p, error_code& ec);
│ │ │ │ void set_piece_hashes (create_torrent& t, std::string const& p
│ │ │ │ , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ , std::function<void(piece_index_t)> const& f, error_code& ec);
│ │ │ │
│ │ │ │
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
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -8,26 +8,26 @@
│ │ │ │ │ o _g_e_n_e_r_a_t_e_(_)_ _g_e_n_e_r_a_t_e___b_u_f_(_)
│ │ │ │ │ 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_(_)
│ │ │ │ │ o _s_e_t___h_a_s_h_(_)
│ │ │ │ │ o _s_e_t___h_a_s_h_2_(_)
│ │ │ │ │ - o _a_d_d___h_t_t_p___s_e_e_d_(_)_ _a_d_d___u_r_l___s_e_e_d_(_)
│ │ │ │ │ + o _a_d_d___u_r_l___s_e_e_d_(_)_ _a_d_d___h_t_t_p___s_e_e_d_(_)
│ │ │ │ │ o _a_d_d___n_o_d_e_(_)
│ │ │ │ │ o _a_d_d___t_r_a_c_k_e_r_(_)
│ │ │ │ │ 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_(_)
│ │ │ │ │ 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:
│ │ │ │ │ 1. first the files that will be part of the torrent are determined.
│ │ │ │ │ 2. the torrent properties are set, such as tracker url, web seeds, DHT nodes
│ │ │ │ │ @@ -69,41 +69,41 @@
│ │ │ │ │ _e_n_t_r_y that's returned can then be bencoded into a .torrent file using _b_e_n_c_o_d_e
│ │ │ │ │ _(_).
│ │ │ │ │ struct create_torrent
│ │ │ │ │ {
│ │ │ │ │ explicit ccrreeaattee__ttoorrrreenntt (torrent_info const& ti);
│ │ │ │ │ explicit ccrreeaattee__ttoorrrreenntt (file_storage& fs, int piece_size = 0
│ │ │ │ │ , create_flags_t flags = {});
│ │ │ │ │ - entry ggeenneerraattee () const;
│ │ │ │ │ std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │ + entry ggeenneerraattee () const;
│ │ │ │ │ file_storage const& ffiilleess () const;
│ │ │ │ │ void sseett__ccoommmmeenntt (char const* str);
│ │ │ │ │ void sseett__ccrreeaattoorr (char const* str);
│ │ │ │ │ void sseett__ccrreeaattiioonn__ddaattee (std::time_t timestamp);
│ │ │ │ │ void sseett__hhaasshh (piece_index_t index, sha1_hash const& h);
│ │ │ │ │ void sseett__hhaasshh22 (file_index_t file, piece_index_t::diff_type piece,
│ │ │ │ │ sha256_hash const& h);
│ │ │ │ │ - void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │ + void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ void aadddd__nnooddee (std::pair node);
│ │ │ │ │ void aadddd__ttrraacckkeerr (string_view url, int tier = 0);
│ │ │ │ │ void sseett__rroooott__cceerrtt (string_view cert);
│ │ │ │ │ bool pprriivv () const;
│ │ │ │ │ void sseett__pprriivv (bool p);
│ │ │ │ │ bool iiss__vv11__oonnllyy () const;
│ │ │ │ │ bool iiss__vv22__oonnllyy () const;
│ │ │ │ │ int nnuumm__ppiieecceess () const;
│ │ │ │ │ piece_index_t eenndd__ppiieeccee () const;
│ │ │ │ │ index_range ppiieeccee__rraannggee () const noexcept;
│ │ │ │ │ file_index_t eenndd__ffiillee () const;
│ │ │ │ │ index_range ffiillee__rraannggee () const noexcept;
│ │ │ │ │ index_range ffiillee__ppiieeccee__rraannggee (file_index_t f);
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ - int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │ + int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │ void aadddd__ssiimmiillaarr__ttoorrrreenntt (sha1_hash ih);
│ │ │ │ │
│ │ │ │ │ static constexpr create_flags_t mmooddiiffiiccaattiioonn__ttiimmee = 2_bit;
│ │ │ │ │ static constexpr create_flags_t ssyymmlliinnkkss = 3_bit;
│ │ │ │ │ static constexpr create_flags_t vv22__oonnllyy = 5_bit;
│ │ │ │ │ static constexpr create_flags_t vv11__oonnllyy = 6_bit;
│ │ │ │ │ @@ -131,16 +131,16 @@
│ │ │ │ │ (such as _s_e_t___h_a_s_h_(_)), will have any affect. Instead of using this overload,
│ │ │ │ │ consider using _w_r_i_t_e___t_o_r_r_e_n_t___f_i_l_e_(_) instead.
│ │ │ │ │ Warning
│ │ │ │ │ The _f_i_l_e___s_t_o_r_a_g_e and _t_o_r_r_e_n_t___i_n_f_o objects must stay alive for the entire
│ │ │ │ │ duration of the _c_r_e_a_t_e___t_o_r_r_e_n_t object.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ggeenneerraattee(()) ggeenneerraattee__bbuuff(()) **********
│ │ │ │ │ -entry ggeenneerraattee () const;
│ │ │ │ │ std::vector ggeenneerraattee__bbuuff () const;
│ │ │ │ │ +entry ggeenneerraattee () const;
│ │ │ │ │ This function will generate the .torrent file as a bencode tree, or a bencoded
│ │ │ │ │ into a buffer. In order to encode the _e_n_t_r_y into a flat file, use the _b_e_n_c_o_d_e_(_)
│ │ │ │ │ function.
│ │ │ │ │ The function returning an _e_n_t_r_y 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
│ │ │ │ │ @@ -197,17 +197,17 @@
│ │ │ │ │ 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 _g_e_n_e_r_a_t_e_(_). This function
│ │ │ │ │ will throw std::system_error if it is called on an object constructed with the
│ │ │ │ │ v1_only flag.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__hhttttpp__sseeeedd(()) aadddd__uurrll__sseeeedd(()) **********
│ │ │ │ │ -void aadddd__hhttttpp__sseeeedd (string_view url);
│ │ │ │ │ +********** aadddd__uurrll__sseeeedd(()) aadddd__hhttttpp__sseeeedd(()) **********
│ │ │ │ │ void aadddd__uurrll__sseeeedd (string_view url);
│ │ │ │ │ +void aadddd__hhttttpp__sseeeedd (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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ @@ -262,22 +262,22 @@
│ │ │ │ │ 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.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ttoottaall__ssiizzee(()) **********
│ │ │ │ │ std::int64_t ttoottaall__ssiizzee () const;
│ │ │ │ │ the total number of bytes of all files and pad files
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ppiieeccee__lleennggtthh(()) ppiieeccee__ssiizzee(()) **********
│ │ │ │ │ -int ppiieeccee__lleennggtthh () const;
│ │ │ │ │ +********** ppiieeccee__ssiizzee(()) ppiieeccee__lleennggtthh(()) **********
│ │ │ │ │ int ppiieeccee__ssiizzee (piece_index_t i) const;
│ │ │ │ │ +int ppiieeccee__lleennggtthh () 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 _f_i_l_e___s_t_o_r_a_g_e.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd__ccoolllleeccttiioonn(()) aadddd__ssiimmiillaarr__ttoorrrreenntt(()) **********
│ │ │ │ │ +********** aadddd__ssiimmiillaarr__ttoorrrreenntt(()) aadddd__ccoolllleeccttiioonn(()) **********
│ │ │ │ │ void aadddd__ccoolllleeccttiioonn (string_view c);
│ │ │ │ │ void aadddd__ssiimmiillaarr__ttoorrrreenntt (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 _B_E_P_ _3_8.
│ │ │ │ │ @@ -347,27 +347,27 @@
│ │ │ │ │ directories are traversed.
│ │ │ │ │ The ".." directory is never traversed.
│ │ │ │ │ The flags argument should be the same as the flags passed to the _c_r_e_a_t_e___t_o_r_r_e_n_t
│ │ │ │ │ constructor.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ sseett__ppiieeccee__hhaasshheess(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_c_r_e_a_t_e___t_o_r_r_e_n_t_._h_p_p"
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p,
│ │ │ │ │ -error_code& ec);
│ │ │ │ │ -inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │ +void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ + , settings_interface const& settings
│ │ │ │ │ + , std::function const& f, error_code& ec);
│ │ │ │ │ inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ + , settings_interface const& settings
│ │ │ │ │ , std::function const& f);
│ │ │ │ │ inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ - , settings_interface const& settings
│ │ │ │ │ , std::function const& f);
│ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ , std::function const& f, error_code& ec);
│ │ │ │ │ -void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ - , settings_interface const& settings
│ │ │ │ │ - , std::function const& f, error_code& ec);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p);
│ │ │ │ │ +inline void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p,
│ │ │ │ │ +error_code& ec);
│ │ │ │ │ void sseett__ppiieeccee__hhaasshheess (create_torrent& t, std::string const& p
│ │ │ │ │ , settings_interface const& settings, disk_io_constructor_type disk_io
│ │ │ │ │ , std::function 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:
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Custom_Storage.html
│ │ │ │ @@ -28,36 +28,36 @@
│ │ │ │ | 2.0.10 |
│ │ │ │
│ │ │ │
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │ -- disk_observer
│ │ │ │ -- on_disk()
│ │ │ │ +- settings_interface
│ │ │ │ +- buffer_allocator_interface
│ │ │ │ +- disk_buffer_holder
│ │ │ │
│ │ │ │ -- buffer_allocator_interface
│ │ │ │ -- disk_buffer_holder
│ │ │ │ -- disk_buffer_holder()
│ │ │ │ -- disk_buffer_holder()
│ │ │ │ -- ~disk_buffer_holder()
│ │ │ │ -- data()
│ │ │ │ -- reset()
│ │ │ │ -- swap()
│ │ │ │ -- is_mutable()
│ │ │ │ -- bool()
│ │ │ │ +- disk_observer
│ │ │ │
│ │ │ │ -- settings_interface
│ │ │ │ - open_file_state
│ │ │ │ - disk_interface
│ │ │ │ - new_torrent()
│ │ │ │ - remove_torrent()
│ │ │ │ -- async_write() async_read()
│ │ │ │ +- async_read() async_write()
│ │ │ │ - async_hash()
│ │ │ │ - async_hash2()
│ │ │ │ - async_move_storage()
│ │ │ │ - async_release_files()
│ │ │ │ - async_check_files()
│ │ │ │ - async_stop_torrent()
│ │ │ │ - async_rename_file()
│ │ │ │ @@ -340,33 +340,32 @@
│ │ │ │
│ │ │ │ std::unique_ptr<lt::disk_interface> temp_disk_constructor(
│ │ │ │ lt::io_context& ioc, lt::settings_interface const&, lt::counters&)
│ │ │ │ {
│ │ │ │ return std::make_unique<temp_disk_io>(ioc);
│ │ │ │ }
│ │ │ │
│ │ │ │ -[report issue]
│ │ │ │ -
disk_observer
│ │ │ │ -
Declared in "libtorrent/disk_observer.hpp"
│ │ │ │ +
[report issue]
│ │ │ │ +
settings_interface
│ │ │ │ +
Declared in "libtorrent/settings_pack.hpp"
│ │ │ │ +
the common interface to settings_pack and the internal representation of
│ │ │ │ +settings.
│ │ │ │
│ │ │ │ -struct disk_observer
│ │ │ │ +struct settings_interface
│ │ │ │ {
│ │ │ │ - virtual void on_disk () = 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 void set_int (int name, int val) = 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;
│ │ │ │ };
│ │ │ │
│ │ │ │ -
[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]
│ │ │ │ -
│ │ │ │
│ │ │ │
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
│ │ │ │
│ │ │ │ @@ -458,34 +457,35 @@
│ │ │ │
│ │ │ │
bool()
│ │ │ │
│ │ │ │ explicit operator bool () const noexcept;
│ │ │ │
│ │ │ │
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.
│ │ │ │ +
│ │ │ │ +
disk_observer
│ │ │ │ +
Declared in "libtorrent/disk_observer.hpp"
│ │ │ │
│ │ │ │ -struct settings_interface
│ │ │ │ +struct disk_observer
│ │ │ │ {
│ │ │ │ - virtual bool has_val (int name) const = 0;
│ │ │ │ - virtual void set_bool (int name, bool val) = 0;
│ │ │ │ - virtual void set_str (int name, std::string val) = 0;
│ │ │ │ - virtual void set_int (int name, int val) = 0;
│ │ │ │ - virtual int get_int (int name) const = 0;
│ │ │ │ - virtual std::string const& get_str (int name) const = 0;
│ │ │ │ - virtual bool get_bool (int name) const = 0;
│ │ │ │ + virtual void on_disk () = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │ +
[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]
│ │ │ │ +
│ │ │ │
│ │ │ │
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.
│ │ │ │
│ │ │ │ struct open_file_state
│ │ │ │ @@ -529,21 +529,21 @@
│ │ │ │ the constructor. The callbacks will be run in the network thread.
│ │ │ │
│ │ │ │ struct disk_interface
│ │ │ │ {
│ │ │ │ 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_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;
│ │ │ │ @@ -595,26 +595,26 @@
│ │ │ │ remove_torrent()
│ │ │ │
│ │ │ │ virtual void remove_torrent (storage_index_t) = 0;
│ │ │ │
│ │ │ │ remove the storage with the specified index. This is not expected to
│ │ │ │ delete any files from disk, just to clean up any resources associated
│ │ │ │ with the specified storage.
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
│ │ │ │ -
async_write() async_read()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
async_read() async_write()
│ │ │ │
│ │ │ │ +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_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;
│ │ │ │
│ │ │ │
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
│ │ │ │ @@ -865,17 +865,17 @@
│ │ │ │ internal libtorrent torrent object to tie the storage object allocated
│ │ │ │ for a torrent to the lifetime of the internal torrent object. When a
│ │ │ │ torrent is removed from the session, this holder is destructed and will
│ │ │ │ inform the disk object.
│ │ │ │
│ │ │ │ struct storage_holder
│ │ │ │ {
│ │ │ │ - storage_holder () = default;
│ │ │ │ - storage_holder (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ ~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;
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,30 +1,30 @@
│ │ │ │ │ >
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ - * _d_i_s_k___o_b_s_e_r_v_e_r
│ │ │ │ │ - o _o_n___d_i_s_k_(_)
│ │ │ │ │ + * _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_(_)
│ │ │ │ │ - * _s_e_t_t_i_n_g_s___i_n_t_e_r_f_a_c_e
│ │ │ │ │ + * _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___w_r_i_t_e_(_)_ _a_s_y_n_c___r_e_a_d_(_)
│ │ │ │ │ + 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_(_)
│ │ │ │ │ @@ -327,26 +327,29 @@
│ │ │ │ │
│ │ │ │ │ std::unique_ptr temp_disk_constructor(
│ │ │ │ │ lt::io_context& ioc, lt::settings_interface const&, lt::counters&)
│ │ │ │ │ {
│ │ │ │ │ return std::make_unique(ioc);
│ │ │ │ │ }
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ 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
│ │ │ │ │ +************ sseettttiinnggss__iinntteerrffaaccee ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │ +the common interface to _s_e_t_t_i_n_g_s___p_a_c_k and the internal representation of
│ │ │ │ │ +settings.
│ │ │ │ │ +struct settings_interface
│ │ │ │ │ {
│ │ │ │ │ - virtual void oonn__ddiisskk () = 0;
│ │ │ │ │ + virtual void sseett__bbooooll (int name, bool val) = 0;
│ │ │ │ │ + virtual void sseett__ssttrr (int name, std::string val) = 0;
│ │ │ │ │ + virtual bool hhaass__vvaall (int name) const = 0;
│ │ │ │ │ + virtual void sseett__iinntt (int name, int val) = 0;
│ │ │ │ │ + virtual bool ggeett__bbooooll (int name) const = 0;
│ │ │ │ │ + virtual std::string const& ggeett__ssttrr (int name) const = 0;
│ │ │ │ │ + virtual int ggeett__iinntt (int name) const = 0;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** 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]
│ │ │ │ │ ************ bbuuffffeerr__aallllooccaattoorr__iinntteerrffaaccee ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r_._h_p_p"
│ │ │ │ │ the interface for freeing disk buffers, used by the _d_i_s_k___b_u_f_f_e_r___h_o_l_d_e_r. when
│ │ │ │ │ implementing _d_i_s_k___i_n_t_e_r_f_a_c_e, this must also be implemented in order to return
│ │ │ │ │ disk buffers back to libtorrent
│ │ │ │ │ struct buffer_allocator_interface
│ │ │ │ │ {
│ │ │ │ │ @@ -408,29 +411,26 @@
│ │ │ │ │ bool iiss__mmuuttaabbllee () const noexcept;
│ │ │ │ │ if this returns true, the buffer may not be modified in place
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** bbooooll(()) **********
│ │ │ │ │ explicit operator bbooooll () const noexcept;
│ │ │ │ │ implicitly convertible to true if the object is currently holding a buffer
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ sseettttiinnggss__iinntteerrffaaccee ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_s_e_t_t_i_n_g_s___p_a_c_k_._h_p_p"
│ │ │ │ │ -the common interface to _s_e_t_t_i_n_g_s___p_a_c_k and the internal representation of
│ │ │ │ │ -settings.
│ │ │ │ │ -struct settings_interface
│ │ │ │ │ +************ 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 bool hhaass__vvaall (int name) const = 0;
│ │ │ │ │ - virtual void sseett__bbooooll (int name, bool val) = 0;
│ │ │ │ │ - virtual void sseett__ssttrr (int name, std::string val) = 0;
│ │ │ │ │ - virtual void sseett__iinntt (int name, int val) = 0;
│ │ │ │ │ - virtual int ggeett__iinntt (int name) const = 0;
│ │ │ │ │ - virtual std::string const& ggeett__ssttrr (int name) const = 0;
│ │ │ │ │ - virtual bool ggeett__bbooooll (int name) const = 0;
│ │ │ │ │ + virtual void oonn__ddiisskk () = 0;
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ +********** 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;
│ │ │ │ │ @@ -466,21 +466,21 @@
│ │ │ │ │ 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 void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r
│ │ │ │ │ + , std::function handler
│ │ │ │ │ + , disk_job_flags_t flags = {}) = 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
│ │ │ │ │ @@ -535,22 +535,22 @@
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** 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__wwrriittee(()) aassyynncc__rreeaadd(()) **********
│ │ │ │ │ +********** aassyynncc__rreeaadd(()) aassyynncc__wwrriittee(()) **********
│ │ │ │ │ +virtual void aassyynncc__rreeaadd (storage_index_t storage, peer_request const& r
│ │ │ │ │ + , std::function handler
│ │ │ │ │ + , disk_job_flags_t flags = {}) = 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;
│ │ │ │ │ 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
│ │ │ │ │ @@ -737,17 +737,17 @@
│ │ │ │ │ a unique, owning, reference to the storage of a torrent in a disk io subsystem
│ │ │ │ │ (class that implements _d_i_s_k___i_n_t_e_r_f_a_c_e). 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
│ │ │ │ │ _s_e_s_s_i_o_n, this holder is destructed and will inform the disk object.
│ │ │ │ │ struct storage_holder
│ │ │ │ │ {
│ │ │ │ │ - ssttoorraaggee__hhoollddeerr () = default;
│ │ │ │ │ - ssttoorraaggee__hhoollddeerr (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ │ ~~ssttoorraaggee__hhoollddeerr ();
│ │ │ │ │ + ssttoorraaggee__hhoollddeerr (storage_index_t idx, disk_interface& disk_io);
│ │ │ │ │ + ssttoorraaggee__hhoollddeerr () = default;
│ │ │ │ │ explicit operator bbooooll () const;
│ │ │ │ │ operator ssttoorraaggee__iinnddeexx__tt () const;
│ │ │ │ │ void rreesseett ();
│ │ │ │ │ ssttoorraaggee__hhoollddeerr (storage_holder const&) = delete;
│ │ │ │ │ storage_holder& ooppeerraattoorr== (storage_holder const&) = delete;
│ │ │ │ │ ssttoorraaggee__hhoollddeerr (storage_holder&& rhs) noexcept;
│ │ │ │ │ storage_holder& ooppeerraattoorr== (storage_holder&& rhs) noexcept;
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-DHT.html
│ │ │ │ @@ -28,65 +28,39 @@
│ │ │ │ | 2.0.10 |
│ │ │ │
│ │ │ │
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │ -
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]
│ │ │ │ +
[report issue]
│ │ │ │
dht_storage_counters
│ │ │ │
Declared in "libtorrent/kademlia/dht_storage.hpp"
│ │ │ │
This structure hold the relevant counters for the storage
│ │ │ │
│ │ │ │ struct dht_storage_counters
│ │ │ │ {
│ │ │ │ void reset ();
│ │ │ │ @@ -308,16 +282,42 @@
│ │ │ │ [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);
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,50 +1,31 @@
│ │ │ │ │ >
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ - * _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
│ │ │ │ │ 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_(_)
│ │ │ │ │ + * _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_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -************ ddhhtt__ssttaattee ************
│ │ │ │ │ -Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_d_h_t___s_t_a_t_e_._h_p_p"
│ │ │ │ │ -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 _B_E_P_ _3_2
│ │ │ │ │ -struct dht_state
│ │ │ │ │ -{
│ │ │ │ │ - void cclleeaarr ();
│ │ │ │ │ -
│ │ │ │ │ - node_ids_t nids;
│ │ │ │ │ - std::vector
nodes;
│ │ │ │ │ - std::vector nodes6;
│ │ │ │ │ -};
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ - nodes
│ │ │ │ │ - the bootstrap nodes saved from the buckets node
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ - nodes6
│ │ │ │ │ - the bootstrap nodes saved from the IPv6 buckets node
│ │ │ │ │ -[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ddhhtt__ssttoorraaggee__ccoouunntteerrss ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_d_h_t___s_t_o_r_a_g_e_._h_p_p"
│ │ │ │ │ This structure hold the relevant _c_o_u_n_t_e_r_s for the storage
│ │ │ │ │ struct dht_storage_counters
│ │ │ │ │ {
│ │ │ │ │ void rreesseett ();
│ │ │ │ │
│ │ │ │ │ @@ -210,14 +191,33 @@
│ │ │ │ │ For implementers: Use this functions for expire peers or items or any other
│ │ │ │ │ storage cleanup.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ********** ccoouunntteerrss(()) **********
│ │ │ │ │ virtual dht_storage_counters ccoouunntteerrss () const = 0;
│ │ │ │ │ return stats _c_o_u_n_t_e_r_s for the store
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ +************ ddhhtt__ssttaattee ************
│ │ │ │ │ +Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_d_h_t___s_t_a_t_e_._h_p_p"
│ │ │ │ │ +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 _B_E_P_ _3_2
│ │ │ │ │ +struct dht_state
│ │ │ │ │ +{
│ │ │ │ │ + void cclleeaarr ();
│ │ │ │ │ +
│ │ │ │ │ + node_ids_t nids;
│ │ │ │ │ + std::vector nodes;
│ │ │ │ │ + std::vector nodes6;
│ │ │ │ │ +};
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ + nodes
│ │ │ │ │ + the bootstrap nodes saved from the buckets node
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ + nodes6
│ │ │ │ │ + the bootstrap nodes saved from the IPv6 buckets node
│ │ │ │ │ +[_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ddhhtt__ddeeffaauulltt__ssttoorraaggee__ccoonnssttrruuccttoorr(()) ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_k_a_d_e_m_l_i_a_/_d_h_t___s_t_o_r_a_g_e_._h_p_p"
│ │ │ │ │ std::unique_ptr ddhhtt__ddeeffaauulltt__ssttoorraaggee__ccoonnssttrruuccttoorr (
│ │ │ │ │ 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.
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Error_Codes.html
│ │ │ │ @@ -33,30 +33,30 @@
│ │ │ │ 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
│ │ │ │ @@ -94,16 +94,31 @@
│ │ │ │
- the error that occurred
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │ - operation
│ │ │ │ - A code from operation_t enum, indicating what
│ │ │ │ kind of operation failed.
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ +
[report issue]
│ │ │ │ +
bdecode_category()
│ │ │ │ +
Declared in "libtorrent/bdecode.hpp"
│ │ │ │ +
│ │ │ │ +boost::system::error_category& bdecode_category ();
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
gzip_category()
│ │ │ │ +
Declared in "libtorrent/gzip.hpp"
│ │ │ │ +
│ │ │ │ +boost::system::error_category& gzip_category ();
│ │ │ │ +
│ │ │ │ +
get the error_category for zip 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
│ │ │ │ @@ -112,63 +127,191 @@
│ │ │ │
│ │ │ │
http_category()
│ │ │ │
Declared in "libtorrent/error_code.hpp"
│ │ │ │
│ │ │ │ boost::system::error_category& http_category ();
│ │ │ │
│ │ │ │
returns the error_category for HTTP errors
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
pcp_category()
│ │ │ │ -
Declared in "libtorrent/natpmp.hpp"
│ │ │ │ -
│ │ │ │ -boost::system::error_category& pcp_category ();
│ │ │ │ -
│ │ │ │
[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]
│ │ │ │ -
│ │ │ │ -
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]
│ │ │ │ -
│ │ │ │ -
bdecode_category()
│ │ │ │ -
Declared in "libtorrent/bdecode.hpp"
│ │ │ │ -
│ │ │ │ -boost::system::error_category& bdecode_category ();
│ │ │ │ -
│ │ │ │
[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]
│ │ │ │ +
│ │ │ │ +
pcp_category()
│ │ │ │ +
Declared in "libtorrent/natpmp.hpp"
│ │ │ │ +
│ │ │ │ +boost::system::error_category& pcp_category ();
│ │ │ │ +
│ │ │ │
[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]
│ │ │ │ +
│ │ │ │ +
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/error_code.hpp"
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -987,89 +1130,14 @@
│ │ │ │
│ │ │ │ | service_unavailable |
│ │ │ │ 503 |
│ │ │ │ |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
[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"
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -1126,103 +1194,15 @@
│ │ │ │ | num_errors |
│ │ │ │ 10 |
│ │ │ │ |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
[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"
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ @@ -1282,126 +1262,146 @@
│ │ │ │ | 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 |
│ │ │ │ -Not an error |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| expected_digit |
│ │ │ │ +
| parse_failed |
│ │ │ │ 1 |
│ │ │ │ -expected digit in bencoded string |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| expected_colon |
│ │ │ │ +
| cant_reach_peer |
│ │ │ │ 2 |
│ │ │ │ -expected colon in bencoded string |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| unexpected_eof |
│ │ │ │ +
| i2p_error |
│ │ │ │ 3 |
│ │ │ │ -unexpected end of file in bencoded string |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| expected_value |
│ │ │ │ +
| invalid_key |
│ │ │ │ 4 |
│ │ │ │ -expected value (list, dict, int or string) in bencoded string |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| depth_exceeded |
│ │ │ │ +
| invalid_id |
│ │ │ │ 5 |
│ │ │ │ -bencoded recursion depth limit exceeded |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| limit_exceeded |
│ │ │ │ +
| timeout |
│ │ │ │ 6 |
│ │ │ │ -bencoded item count limit exceeded |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| overflow |
│ │ │ │ +
| key_not_found |
│ │ │ │ 7 |
│ │ │ │ -integer overflow |
│ │ │ │ + |
│ │ │ │
│ │ │ │ -| error_code_max |
│ │ │ │ +
| duplicated_id |
│ │ │ │ 8 |
│ │ │ │ -the number of error codes |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| num_errors |
│ │ │ │ +9 |
│ │ │ │ + |
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
enum pcp_errors
│ │ │ │ +
Declared in "libtorrent/natpmp.hpp"
│ │ │ │
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │ | name |
│ │ │ │ value |
│ │ │ │ description |
│ │ │ │
|---|
│ │ │ │
│ │ │ │
│ │ │ │ -| no_error |
│ │ │ │ +
| pcp_success |
│ │ │ │ 0 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| parse_failed |
│ │ │ │ +
| pcp_unsupp_version |
│ │ │ │ 1 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| cant_reach_peer |
│ │ │ │ +
| pcp_not_authorized |
│ │ │ │ 2 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| i2p_error |
│ │ │ │ +
| pcp_malformed_request |
│ │ │ │ 3 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| invalid_key |
│ │ │ │ +
| pcp_unsupp_opcode |
│ │ │ │ 4 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| invalid_id |
│ │ │ │ +
| pcp_unsupp_option |
│ │ │ │ 5 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| timeout |
│ │ │ │ +
| pcp_malformed_option |
│ │ │ │ 6 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| key_not_found |
│ │ │ │ +
| pcp_network_failure |
│ │ │ │ 7 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| duplicated_id |
│ │ │ │ +
| pcp_no_resources |
│ │ │ │ 8 |
│ │ │ │ |
│ │ │ │
│ │ │ │ -| num_errors |
│ │ │ │ +
| pcp_unsupp_protocol |
│ │ │ │ 9 |
│ │ │ │ |
│ │ │ │
│ │ │ │ +| pcp_user_ex_quota |
│ │ │ │ +10 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| pcp_cannot_provide_external |
│ │ │ │ +11 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| pcp_address_mismatch |
│ │ │ │ +12 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │ +| pcp_excessive_remote_peers |
│ │ │ │ +13 |
│ │ │ │ + |
│ │ │ │ +
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
A default constructed ip_filter does not filter any address.
│ │ │ │
│ │ │ │ struct ip_filter
│ │ │ │ {
│ │ │ │ + ~ip_filter ();
│ │ │ │ ip_filter ();
│ │ │ │ ip_filter (ip_filter const&);
│ │ │ │ - ip_filter (ip_filter&&);
│ │ │ │ - ip_filter& operator= (ip_filter const&);
│ │ │ │ ip_filter& operator= (ip_filter&&);
│ │ │ │ - ~ip_filter ();
│ │ │ │ + ip_filter& operator= (ip_filter const&);
│ │ │ │ + ip_filter (ip_filter&&);
│ │ │ │ bool empty () const;
│ │ │ │ void add_rule (address const& first, address const& last, std::uint32_t flags);
│ │ │ │ std::uint32_t access (address const& addr) const;
│ │ │ │ filter_tuple_t export_filter () const;
│ │ │ │
│ │ │ │ enum access_flags
│ │ │ │ {
│ │ │ │ @@ -153,20 +153,20 @@
│ │ │ │ the port filter maps non-overlapping port ranges to flags. This
│ │ │ │ is primarily used to indicate whether a range of ports should
│ │ │ │ be connected to or not. The default is to have the full port
│ │ │ │ range (0-65535) set to flag 0.
│ │ │ │
│ │ │ │ class port_filter
│ │ │ │ {
│ │ │ │ - port_filter& operator= (port_filter&&);
│ │ │ │ port_filter& operator= (port_filter const&);
│ │ │ │ - ~port_filter ();
│ │ │ │ - port_filter (port_filter&&);
│ │ │ │ port_filter (port_filter const&);
│ │ │ │ + port_filter (port_filter&&);
│ │ │ │ port_filter ();
│ │ │ │ + port_filter& operator= (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,
│ │ │ │ };
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -19,20 +19,20 @@
│ │ │ │ │ The ip_filter class is a set of rules that uniquely categorizes all ip
│ │ │ │ │ addresses as allowed or disallowed. The default constructor creates a single
│ │ │ │ │ rule that allows all addresses (0.0.0.0 - 255.255.255.255 for the IPv4 range,
│ │ │ │ │ and the equivalent range covering all addresses for the IPv6 range).
│ │ │ │ │ A default constructed _i_p___f_i_l_t_e_r does not filter any address.
│ │ │ │ │ struct ip_filter
│ │ │ │ │ {
│ │ │ │ │ + ~~iipp__ffiilltteerr ();
│ │ │ │ │ iipp__ffiilltteerr ();
│ │ │ │ │ iipp__ffiilltteerr (ip_filter const&);
│ │ │ │ │ - iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ - ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │ ip_filter& ooppeerraattoorr== (ip_filter&&);
│ │ │ │ │ - ~~iipp__ffiilltteerr ();
│ │ │ │ │ + ip_filter& ooppeerraattoorr== (ip_filter const&);
│ │ │ │ │ + iipp__ffiilltteerr (ip_filter&&);
│ │ │ │ │ bool eemmppttyy () const;
│ │ │ │ │ void aadddd__rruullee (address const& first, address const& last, std::uint32_t
│ │ │ │ │ flags);
│ │ │ │ │ std::uint32_t aacccceessss (address const& addr) const;
│ │ │ │ │ filter_tuple_t eexxppoorrtt__ffiilltteerr () const;
│ │ │ │ │
│ │ │ │ │ enum access_flags
│ │ │ │ │ @@ -81,20 +81,20 @@
│ │ │ │ │ ************ ppoorrtt__ffiilltteerr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_i_p___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │ the port filter maps non-overlapping port ranges to flags. This is primarily
│ │ │ │ │ used to indicate whether a range of ports should be connected to or not. The
│ │ │ │ │ default is to have the full port range (0-65535) set to flag 0.
│ │ │ │ │ class port_filter
│ │ │ │ │ {
│ │ │ │ │ - port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ port_filter& ooppeerraattoorr== (port_filter const&);
│ │ │ │ │ - ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │ - ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ ppoorrtt__ffiilltteerr (port_filter const&);
│ │ │ │ │ + ppoorrtt__ffiilltteerr (port_filter&&);
│ │ │ │ │ ppoorrtt__ffiilltteerr ();
│ │ │ │ │ + port_filter& ooppeerraattoorr== (port_filter&&);
│ │ │ │ │ + ~~ppoorrtt__ffiilltteerr ();
│ │ │ │ │ void aadddd__rruullee (std::uint16_t first, std::uint16_t last, std::uint32_t
│ │ │ │ │ flags);
│ │ │ │ │ std::uint32_t aacccceessss (std::uint16_t port) const;
│ │ │ │ │
│ │ │ │ │ enum access_flags
│ │ │ │ │ {
│ │ │ │ │ blocked,
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-PeerClass.html
│ │ │ │ @@ -29,16 +29,16 @@
│ │ │ │
│ │ │ │
│ │ │ │ home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │
Declared in "libtorrent/peer_class_type_filter.hpp"
│ │ │ │ peer_class_type_filter is a simple container for rules for adding and subtracting
│ │ │ │ peer-classes from peers. It is applied after the peer class filter is applied (which
│ │ │ │ is based on the peer's IP address).
│ │ │ │
│ │ │ │ struct peer_class_type_filter
│ │ │ │ {
│ │ │ │ - void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ + void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ std::uint32_t apply (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ friend bool operator== (peer_class_type_filter const& lhs
│ │ │ │ , peer_class_type_filter const& rhs);
│ │ │ │
│ │ │ │ enum socket_type_t
│ │ │ │ @@ -66,27 +66,27 @@
│ │ │ │ ssl_tcp_socket,
│ │ │ │ ssl_utp_socket,
│ │ │ │ i2p_socket,
│ │ │ │ num_socket_types,
│ │ │ │ };
│ │ │ │ };
│ │ │ │
│ │ │ │ -
│ │ │ │ -[report issue]
│ │ │ │ -
add() remove()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
remove() add()
│ │ │ │
│ │ │ │ -void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void add (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ +void remove (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │
│ │ │ │
add() and remove() adds and removes a peer class to be added
│ │ │ │ to new peers based on socket type.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
disallow() allow()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
allow() disallow()
│ │ │ │
│ │ │ │ void disallow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ void allow (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │
│ │ │ │
disallow() and allow() adds and removes a peer class to be
│ │ │ │ removed from new peers based on socket type.
│ │ │ │
The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,28 +1,28 @@
│ │ │ │ │ >
│ │ │ │ │ _[_l_i_b_t_o_r_r_e_n_t_ _l_o_g_o_]
│ │ │ │ │ VVeerrssiioonn:: 2.0.10
│ │ │ │ │ _h_o_m_e
│ │ │ │ │ Table of contents
│ │ │ │ │ * _p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r
│ │ │ │ │ - o _a_d_d_(_)_ _r_e_m_o_v_e_(_)
│ │ │ │ │ - o _d_i_s_a_l_l_o_w_(_)_ _a_l_l_o_w_(_)
│ │ │ │ │ + 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
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ ************ ppeeeerr__ccllaassss__ttyyppee__ffiilltteerr ************
│ │ │ │ │ Declared in "_l_i_b_t_o_r_r_e_n_t_/_p_e_e_r___c_l_a_s_s___t_y_p_e___f_i_l_t_e_r_._h_p_p"
│ │ │ │ │ peer_class_type_filter is a simple container for rules for adding and
│ │ │ │ │ subtracting peer-classes from peers. It is applied aafftteerr the peer class filter
│ │ │ │ │ is applied (which is based on the peer's IP address).
│ │ │ │ │ struct peer_class_type_filter
│ │ │ │ │ {
│ │ │ │ │ - void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ + void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ std::uint32_t aappppllyy (socket_type_t const st, std::uint32_t peer_class_mask);
│ │ │ │ │ friend bool ooppeerraattoorr==== (peer_class_type_filter const& lhs
│ │ │ │ │ , peer_class_type_filter const& rhs);
│ │ │ │ │
│ │ │ │ │ enum socket_type_t
│ │ │ │ │ @@ -32,21 +32,21 @@
│ │ │ │ │ ssl_tcp_socket,
│ │ │ │ │ ssl_utp_socket,
│ │ │ │ │ i2p_socket,
│ │ │ │ │ num_socket_types,
│ │ │ │ │ };
│ │ │ │ │ };
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** aadddd(()) rreemmoovvee(()) **********
│ │ │ │ │ -void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +********** rreemmoovvee(()) aadddd(()) **********
│ │ │ │ │ void aadddd (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ +void rreemmoovvee (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ add() and remove() adds and removes a peer class to be added to new peers based
│ │ │ │ │ on socket type.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ │ │ -********** ddiissaallllooww(()) aallllooww(()) **********
│ │ │ │ │ +********** aallllooww(()) ddiissaallllooww(()) **********
│ │ │ │ │ void ddiissaallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ void aallllooww (socket_type_t const st, peer_class_t const peer_class);
│ │ │ │ │ disallow() and allow() adds and removes a peer class to be removed from new
│ │ │ │ │ peers based on socket type.
│ │ │ │ │ The peer_class argument cannot be greater than 31. The bitmasks representing
│ │ │ │ │ peer classes in the peer_class_type_filter are 32 bits.
│ │ │ │ │ [_r_e_p_o_r_t_ _i_s_s_u_e]
│ │ │ ├── ./usr/share/doc/libtorrent-rasterbar-doc/html/reference-Plugins.html
│ │ │ │ @@ -31,65 +31,65 @@
│ │ │ │
home
│ │ │ │
│ │ │ │
Table of contents
│ │ │ │
│ │ │ │
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:
│ │ │ │ @@ -178,84 +178,14 @@
│ │ │ │ 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 peer_connection_handle
│ │ │ │ -{
│ │ │ │ - explicit peer_connection_handle (std::weak_ptr<peer_connection> impl);
│ │ │ │ - connection_type type () const;
│ │ │ │ - peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ - void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ - 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 choke_this_peer ();
│ │ │ │ - void maybe_unchoke_this_peer ();
│ │ │ │ - void get_peer_info (peer_info& p) const;
│ │ │ │ - torrent_handle associated_torrent () const;
│ │ │ │ - tcp::endpoint const& remote () const;
│ │ │ │ - tcp::endpoint local_endpoint () const;
│ │ │ │ - bool is_connecting () const;
│ │ │ │ - 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 ignore_unchoke_slots () const;
│ │ │ │ - bool on_local_network () 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;
│ │ │ │ -};
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
bt_peer_connection_handle
│ │ │ │ -
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ │ -
The bt_peer_connection_handle provides a handle to the internal bittorrent
│ │ │ │ -peer connection object to plugins. It's low level and may not be a stable API
│ │ │ │ -across libtorrent versions.
│ │ │ │ -
│ │ │ │ -struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ -{
│ │ │ │ - explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │ - bool packet_finished () const;
│ │ │ │ - bool support_extensions () 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;
│ │ │ │ -};
│ │ │ │ -
│ │ │ │
[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.
│ │ │ │ @@ -415,19 +345,19 @@
│ │ │ │
Torrent plugins are associated with a single torrent and have a number
│ │ │ │ of functions called at certain events. Many of its functions have the
│ │ │ │ ability to change or override the default libtorrent behavior.
│ │ │ │
│ │ │ │ struct torrent_plugin
│ │ │ │ {
│ │ │ │ virtual std::shared_ptr<peer_plugin> new_connection (peer_connection_handle const&);
│ │ │ │ - virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void on_piece_pass (piece_index_t);
│ │ │ │ + virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void tick ();
│ │ │ │ - virtual bool on_pause ();
│ │ │ │ virtual bool on_resume ();
│ │ │ │ + virtual 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;
│ │ │ │ @@ -446,41 +376,41 @@
│ │ │ │ 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]
│ │ │ │ +
│ │ │ │ +
on_piece_pass() on_piece_failed()
│ │ │ │
│ │ │ │ -virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void on_piece_pass (piece_index_t);
│ │ │ │ +virtual void on_piece_failed (piece_index_t);
│ │ │ │
│ │ │ │
These hooks are called when a piece passes the hash check or fails the hash
│ │ │ │ check, respectively. The index is the piece index that was downloaded.
│ │ │ │ It is possible to access the list of peers that participated in sending the
│ │ │ │ piece through the torrent and the piece_picker.
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
tick()
│ │ │ │
│ │ │ │ virtual void tick ();
│ │ │ │
│ │ │ │
This hook is called approximately once per second. It is a way of making it
│ │ │ │ easy for plugins to do timed events, for sending messages or whatever.
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
on_resume() on_pause()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_pause() on_resume()
│ │ │ │
│ │ │ │ -virtual bool on_pause ();
│ │ │ │ virtual bool on_resume ();
│ │ │ │ +virtual bool on_pause ();
│ │ │ │
│ │ │ │
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.
│ │ │ │ @@ -546,50 +476,50 @@
│ │ │ │ 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_bitfield (bitfield const&
/*bitfield*/);
│ │ │ │ - virtual bool
on_have_none ();
│ │ │ │ - virtual bool
on_request (peer_request const&);
│ │ │ │ - virtual bool
on_choke ();
│ │ │ │ - virtual bool
on_unchoke ();
│ │ │ │ - virtual bool
on_interested ();
│ │ │ │ - virtual bool
on_not_interested ();
│ │ │ │ - virtual bool
on_allowed_fast (piece_index_t);
│ │ │ │ virtual bool
on_have_all ();
│ │ │ │ + virtual bool
on_request (peer_request const&);
│ │ │ │ + virtual bool
on_have_none ();
│ │ │ │ virtual bool
on_have (piece_index_t);
│ │ │ │ + virtual bool
on_allowed_fast (piece_index_t);
│ │ │ │ + virtual bool
on_interested ();
│ │ │ │ virtual bool
on_dont_have (piece_index_t);
│ │ │ │ + virtual bool
on_unchoke ();
│ │ │ │ + virtual bool
on_not_interested ();
│ │ │ │ + virtual bool
on_choke ();
│ │ │ │ virtual bool
on_piece (peer_request const&
/*piece*/
│ │ │ │ , span<char const>
/*buf*/);
│ │ │ │ + virtual bool
on_cancel (peer_request const&);
│ │ │ │ virtual bool
on_suggest (piece_index_t);
│ │ │ │ virtual bool
on_reject (peer_request const&);
│ │ │ │ - virtual bool
on_cancel (peer_request const&);
│ │ │ │ + virtual void
sent_allow_fast (piece_index_t);
│ │ │ │ + virtual void
sent_reject_request (peer_request const&);
│ │ │ │ + virtual void
sent_request (peer_request const&);
│ │ │ │ virtual void
sent_suggest (piece_index_t);
│ │ │ │ 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_all ();
│ │ │ │ virtual void
sent_have_none ();
│ │ │ │ - virtual void
sent_reject_request (peer_request const&);
│ │ │ │ virtual void
sent_choke ();
│ │ │ │ + virtual void
sent_have_all ();
│ │ │ │ virtual void
sent_not_interested ();
│ │ │ │ - virtual void
sent_have (piece_index_t);
│ │ │ │ - virtual void
sent_unchoke ();
│ │ │ │ - virtual void
sent_piece (peer_request const&);
│ │ │ │ virtual void
sent_interested ();
│ │ │ │ + virtual void
sent_piece (peer_request const&);
│ │ │ │ + virtual void
sent_unchoke ();
│ │ │ │ + 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
on_piece_failed (piece_index_t);
│ │ │ │ virtual void
tick ();
│ │ │ │ virtual bool
write_request (peer_request const&);
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
type()
│ │ │ │
│ │ │ │ @@ -639,39 +569,39 @@
│ │ │ │ virtual bool on_extension_handshake (bdecode_node const&);
│ │ │ │
│ │ │ │
called when the extension handshake from the other end is received
│ │ │ │ if this returns false, it means that this extension isn't
│ │ │ │ supported by this peer. It will result in this peer_plugin
│ │ │ │ being removed from the peer_connection and destructed.
│ │ │ │ this is not called for web seeds
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │ +
│ │ │ │
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
on_request() on_interested() on_have() on_not_interested() on_have_all() on_have_none() on_bitfield() on_unchoke() on_choke() on_dont_have() on_allowed_fast()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
on_choke() on_not_interested() on_have() on_unchoke() on_allowed_fast() on_bitfield() on_have_none() on_interested() on_dont_have() on_have_all() on_request()
│ │ │ │
│ │ │ │ virtual bool on_bitfield (bitfield const& /*bitfield*/);
│ │ │ │ -virtual bool on_have_none ();
│ │ │ │ -virtual bool on_request (peer_request const&);
│ │ │ │ -virtual bool on_choke ();
│ │ │ │ -virtual bool on_unchoke ();
│ │ │ │ -virtual bool on_interested ();
│ │ │ │ -virtual bool on_not_interested ();
│ │ │ │ -virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ virtual bool on_have_all ();
│ │ │ │ +virtual bool on_request (peer_request const&);
│ │ │ │ +virtual bool on_have_none ();
│ │ │ │ virtual bool on_have (piece_index_t);
│ │ │ │ +virtual bool on_allowed_fast (piece_index_t);
│ │ │ │ +virtual bool on_interested ();
│ │ │ │ virtual bool on_dont_have (piece_index_t);
│ │ │ │ +virtual bool on_unchoke ();
│ │ │ │ +virtual bool on_not_interested ();
│ │ │ │ +virtual bool on_choke ();
│ │ │ │
│ │ │ │
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]
│ │ │ │ @@ -683,27 +613,27 @@
│ │ │ │
│ │ │ │
This function is called when the peer connection is receiving
│ │ │ │ a piece. buf points (non-owning pointer) to the data in an
│ │ │ │ internal immutable disk buffer. The length of the data is specified
│ │ │ │ in the length member of the piece parameter.
│ │ │ │ returns true to indicate that the piece is handled and the
│ │ │ │ rest of the logic should be ignored.
│ │ │ │ -
│ │ │ │ +
│ │ │ │
│ │ │ │ +
│ │ │ │
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
│ │ │ │ -
sent_unchoke() sent_not_interested() sent_piece() sent_have() sent_interested()
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
sent_have() sent_not_interested() sent_unchoke() sent_piece() sent_interested()
│ │ │ │
│ │ │ │ virtual void sent_not_interested ();
│ │ │ │ -virtual void sent_have (piece_index_t);
│ │ │ │ -virtual void sent_unchoke ();
│ │ │ │ -virtual void sent_piece (peer_request const&);
│ │ │ │ virtual void sent_interested ();
│ │ │ │ +virtual void sent_piece (peer_request const&);
│ │ │ │ +virtual void sent_unchoke ();
│ │ │ │ +virtual void sent_have (piece_index_t);
│ │ │ │
│ │ │ │
called after a choke message has been sent to the peer
│ │ │ │
[report issue]
│ │ │ │
│ │ │ │
sent_payload()
│ │ │ │
│ │ │ │ virtual void sent_payload (int /* bytes */);
│ │ │ │ @@ -739,21 +669,21 @@
│ │ │ │
│ │ │ │
on_unknown_message()
│ │ │ │
│ │ │ │ virtual bool on_unknown_message (int /*length*/, int /*msg*/,
│ │ │ │ span<char const> /*body*/);
│ │ │ │
│ │ │ │
this is not called for web seeds
│ │ │ │ -
│ │ │ │ -
[report issue]
│ │ │ │ -
on_piece_failed() on_piece_pass()
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
on_piece_pass() on_piece_failed()
│ │ │ │
│ │ │ │ -virtual void on_piece_failed (piece_index_t);
│ │ │ │ virtual void on_piece_pass (piece_index_t);
│ │ │ │ +virtual void on_piece_failed (piece_index_t);
│ │ │ │
│ │ │ │
called when a piece that this peer participated in either
│ │ │ │ fails or passes the hash_check
│ │ │ │
[report issue]
│ │ │ │
tick()
│ │ │ │
│ │ │ │ @@ -773,16 +703,16 @@
│ │ │ │
│ │ │ │
crypto_plugin
│ │ │ │
Declared in "libtorrent/extensions.hpp"
│ │ │ │
│ │ │ │ struct crypto_plugin
│ │ │ │ {
│ │ │ │ - virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │ virtual void set_incoming_key (span<char const> key) = 0;
│ │ │ │ + virtual void set_outgoing_key (span<char const> key) = 0;
│ │ │ │ encrypt (span<span<char>> /*send_vec*/) = 0;
│ │ │ │ virtual std::tuple<int, int, int> decrypt (span<span<char>> /*receive_vec*/) = 0;
│ │ │ │ };
│ │ │ │
│ │ │ │
[report issue]
│ │ │ │
decrypt()
│ │ │ │
│ │ │ │ @@ -793,29 +723,112 @@
│ │ │ │ (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]
│ │ │ │ +
[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 peer_connection_handle
│ │ │ │ +{
│ │ │ │ + explicit peer_connection_handle (std::weak_ptr<peer_connection> impl);
│ │ │ │ + connection_type type () const;
│ │ │ │ + peer_plugin const* find_plugin (string_view type) const;
│ │ │ │ + void add_extension (std::shared_ptr<peer_plugin>);
│ │ │ │ + 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 has_peer_choked () const;
│ │ │ │ + bool is_peer_interested () const;
│ │ │ │ + void maybe_unchoke_this_peer ();
│ │ │ │ + void choke_this_peer ();
│ │ │ │ + void get_peer_info (peer_info& p) const;
│ │ │ │ + torrent_handle associated_torrent () const;
│ │ │ │ + tcp::endpoint local_endpoint () const;
│ │ │ │ + tcp::endpoint const& remote () const;
│ │ │ │ + void disconnect (error_code const& ec, operation_t op
│ │ │ │ + , disconnect_severity_t = peer_connection_interface::normal);
│ │ │ │ + bool is_connecting () const;
│ │ │ │ + bool is_disconnecting () const;
│ │ │ │ + bool is_outgoing () const;
│ │ │ │ + bool ignore_unchoke_slots () const;
│ │ │ │ + bool on_local_network () 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;
│ │ │ │ +};
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │ +
│ │ │ │ +
bt_peer_connection_handle
│ │ │ │ +
Declared in "libtorrent/peer_connection_handle.hpp"
│ │ │ │ +
The bt_peer_connection_handle provides a handle to the internal bittorrent
│ │ │ │ +peer connection object to plugins. It's low level and may not be a stable API
│ │ │ │ +across libtorrent versions.
│ │ │ │ +
│ │ │ │ +struct bt_peer_connection_handle : peer_connection_handle
│ │ │ │ +{
│ │ │ │ + explicit bt_peer_connection_handle (peer_connection_handle pc);
│ │ │ │ + bool packet_finished () const;
│ │ │ │ + bool support_extensions () const;
│ │ │ │ + bool supports_encryption () const;
│ │ │ │ + void switch_recv_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ + void switch_send_crypto (std::shared_ptr<crypto_plugin> crypto);
│ │ │ │ + std::shared_ptr<bt_peer_connection> native_handle () const;
│ │ │ │ +};
│ │ │ │ +
│ │ │ │ +
[report issue]
│ │ │ │
│ │ │ │
create_ut_pex_plugin()
│ │ │ │
Declared in "libtorrent/extensions/ut_pex.hpp"
│ │ │ │
│ │ │ │ std::shared_ptr<torrent_plugin> create_ut_pex_plugin (torrent_handle const&, client_data_t);
│ │ │ │
│ │ │ │
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"
│ │ │ │ +
│ │ │ │ +std::shared_ptr<torrent_plugin> create_smart_ban_plugin (torrent_handle const&, client_data_t);
│ │ │ │ +
│ │ │ │ +
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_smart_ban_plugin()
│ │ │ │ -
Declared in "libtorrent/extensions/smart_ban.hpp"
│ │ │ │ -
│ │ │ │ -std::shared_ptr<torrent_plugin> create_smart_ban_plugin (torrent_handle const&, client_data_t);
│ │ │ │ -
│ │ │ │ -
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().
│ │ │ │
│ │ │ │
│ │ │ │