Version: 2.0.0

home

[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;

   enum block_state_t
   {
      none,
      requested,
      writing,
      finished,
   };

   unsigned bytes_progress:15;
   unsigned block_size:15;
   unsigned state:2;
   unsigned num_peers:14;
};
[report issue]

set_peer() peer()

void set_peer (tcp::endpoint const& ep);
tcp::endpoint peer () const;

The peer is the ip address of the peer this block was downloaded from.

[report issue]

enum block_state_t

Declared in "libtorrent/torrent_handle.hpp"

name value description
none 0 This block has not been downloaded or requested form any peer.
requested 1 The block has been requested, but not completely downloaded yet.
writing 2 The block has been downloaded and is currently queued for being written to disk.
finished 3 The block has been written to disk.
[report issue]
bytes_progress
the number of bytes that have been received for this block
[report issue]
block_size
the total number of bytes in this block.
[report issue]
state
the state this block is in (see block_state_t)
[report issue]
num_peers
the number of peers that is currently requesting this block. Typically this is 0 or 1, but at the end of the torrent blocks may be requested by more peers in parallel to speed things up.
[report issue]

partial_piece_info

Declared in "libtorrent/torrent_handle.hpp"

This class holds information about pieces that have outstanding requests or outstanding writes

struct partial_piece_info
{
   piece_index_t piece_index;
   int blocks_in_piece;
   int finished;
   int writing;
   int requested;
   block_info* blocks;
};
[report issue]
piece_index
the index of the piece in question. blocks_in_piece is the number of blocks in this particular piece. This number will be the same for most pieces, but the last piece may have fewer blocks than the standard pieces.
[report issue]
blocks_in_piece
the number of blocks in this piece
[report issue]
finished
the number of blocks that are in the finished state
[report issue]
writing
the number of blocks that are in the writing state
[report issue]
requested
the number of blocks that are in the requested state
[report issue]
blocks

this is an array of blocks_in_piece number of items. One for each block in the piece.

Warning

This is a pointer that points to an array that's owned by the session object. The next time get_download_queue() is called, it will be invalidated.

[report issue]

torrent_handle

Declared in "libtorrent/torrent_handle.hpp"

You will usually have to store your torrent handles somewhere, since it's the object through which you retrieve information about the torrent and aborts the torrent.

Warning

Any member function that returns a value or fills in a value has to be made synchronously. This means it has to wait for the main thread to complete the query before it can return. This might potentially be expensive if done from within a GUI thread that needs to stay responsive. Try to avoid querying for information you don't need, and try to do it in as few calls as possible. You can get most of the interesting information about a torrent from the torrent_handle::status() call.

The default constructor will initialize the handle to an invalid state. Which means you cannot perform any operation on it, unless you first assign it a valid handle. If you try to perform any operation on an uninitialized handle, it will throw invalid_handle.

Warning

All operations on a torrent_handle may throw system_error exception, in case the handle is no longer referring to a torrent. There is one exception is_valid() 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 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 read_piece (piece_index_t piece) const;
   bool have_piece (piece_index_t piece) const;
   void get_peer_info (std::vector<peer_info>& v) const;
   torrent_status status (status_flags_t flags = status_flags_t::all()) const;
   void get_download_queue (std::vector<partial_piece_info>& queue) const;
   std::vector<partial_piece_info> get_download_queue () const;
   void reset_piece_deadline (piece_index_t index) const;
   void clear_piece_deadlines () 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 file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;
   std::vector<open_file_state> file_status () const;
   void clear_error () const;
   void add_tracker (announce_entry const&) const;
   std::vector<announce_entry> trackers () const;
   void replace_trackers (std::vector<announce_entry> const&) 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> http_seeds () const;
   void remove_http_seed (std::string const& url) const;
   void add_http_seed (std::string const& url) const;
   void add_extension (
      std::function<std::shared_ptr<torrent_plugin>(torrent_handle const&, client_data_t)> const& ext
      , client_data_t userdata = client_data_t{});
   bool set_metadata (span<char const> metadata) const;
   bool is_valid () const;
   void pause (pause_flags_t flags = {}) const;
   void resume () const;
   void unset_flags (torrent_flags_t flags) const;
   torrent_flags_t flags () const;
   void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
   void set_flags (torrent_flags_t flags) const;
   void flush_cache () const;
   void force_recheck () const;
   void save_resume_data (resume_data_flags_t flags = {}) const;
   bool need_save_resume_data () const;
   void queue_position_bottom () const;
   void queue_position_top () const;
   void queue_position_down () const;
   queue_position_t queue_position () const;
   void queue_position_up () 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;
   void piece_availability (std::vector<int>& avail) const;
   void piece_priority (piece_index_t index, download_priority_t priority) const;
   download_priority_t piece_priority (piece_index_t index) const;
   void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
   void prioritize_pieces (std::vector<download_priority_t> const& pieces) const;
   std::vector<download_priority_t> get_piece_priorities () const;
   std::vector<download_priority_t> get_file_priorities () const;
   void prioritize_files (std::vector<download_priority_t> const& files) const;
   download_priority_t file_priority (file_index_t index) const;
   void file_priority (file_index_t index, download_priority_t priority) const;
   void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
   void force_dht_announce () const;
   void force_lsd_announce () const;
   void scrape_tracker (int idx = -1) const;
   int download_limit () const;
   void set_download_limit (int limit) const;
   void set_upload_limit (int limit) const;
   int upload_limit () const;
   void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
      , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;
   void clear_peers ();
   void set_max_uploads (int max_uploads) const;
   int max_uploads () const;
   int max_connections () const;
   void set_max_connections (int max_connections) const;
   void move_storage (std::string const& save_path
      , move_flags_t flags = move_flags_t::always_replace_files
      ) const;
   void rename_file (file_index_t index, std::string const& new_name) const;
   sha1_hash info_hash () const;
   info_hash_t info_hashes () const;
   bool operator!= (const torrent_handle& h) const;
   bool operator< (const torrent_handle& h) const;
   bool operator== (const torrent_handle& h) const;
   std::uint32_t id () const;
   std::shared_ptr<torrent> native_handle () const;
   client_data_t userdata () const;

   static constexpr add_piece_flags_t overwrite_existing  = 0_bit;
   static constexpr status_flags_t query_distributed_copies  = 0_bit;
   static constexpr status_flags_t query_accurate_download_counters  = 1_bit;
   static constexpr status_flags_t query_last_seen_complete  = 2_bit;
   static constexpr status_flags_t query_pieces  = 3_bit;
   static constexpr status_flags_t query_verified_pieces  = 4_bit;
   static constexpr status_flags_t query_torrent_file  = 5_bit;
   static constexpr status_flags_t query_name  = 6_bit;
   static constexpr status_flags_t query_save_path  = 7_bit;
   static constexpr deadline_flags_t alert_when_available  = 0_bit;
   static constexpr file_progress_flags_t piece_granularity  = 0_bit;
   static constexpr pause_flags_t graceful_pause  = 0_bit;
   static constexpr pause_flags_t clear_disk_cache  = 1_bit;
   static constexpr resume_data_flags_t flush_disk_cache  = 0_bit;
   static constexpr resume_data_flags_t save_info_dict  = 1_bit;
   static constexpr resume_data_flags_t only_if_modified  = 2_bit;
   static constexpr reannounce_flags_t ignore_min_interval  = 0_bit;
};
[report issue]

torrent_handle()

torrent_handle () noexcept = default;

constructs a torrent handle that does not refer to a torrent. i.e. is_valid() will return false.

[report issue]

add_piece()

void add_piece (piece_index_t piece, char const* 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. data is expected to point to a buffer of as many bytes as the size of the specified piece. The data in the buffer is copied and passed on to the disk IO thread to be written at a later point.

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 the hash check by waiting for piece_finished_alert or hash_failed_alert.

Adding pieces while the torrent is being checked (i.e. in torrent_status::checking_files state) is not supported.

[report issue]

read_piece()

void read_piece (piece_index_t piece) const;

This function starts an asynchronous read operation of the specified piece from this torrent. You must have completed the download of the specified piece before calling this function.

When the read operation is completed, it is passed back through an alert, read_piece_alert. Since this alert is a response to an explicit call, it will always be posted, regardless of the alert mask.

Note that if you read multiple pieces, the read operations are not guaranteed to finish in the same order as you initiated them.

[report issue]

have_piece()

bool have_piece (piece_index_t piece) const;

Returns true if this piece has been completely downloaded and written to disk, and false otherwise.

[report issue]

get_peer_info()

void get_peer_info (std::vector<peer_info>& v) const;

takes a reference to a vector that will be cleared and filled with one entry for each peer connected to this torrent, given the handle is valid. If the torrent_handle is invalid, it will throw system_error exception. Each entry in the vector contains information about that particular peer. See peer_info.

[report issue]

status()

torrent_status status (status_flags_t flags = status_flags_t::all()) const;

status() will return a structure with information about the status of this torrent. If the torrent_handle is invalid, it will throw system_error exception. See torrent_status. The flags argument filters what information is returned in the torrent_status. Some information in there is relatively expensive to calculate, and if you're not interested in it (and see performance issues), you can filter them out.

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()

void get_download_queue (std::vector<partial_piece_info>& queue) const;
std::vector<partial_piece_info> get_download_queue () const;

get_download_queue() returns a vector with information about pieces that are partially downloaded or not downloaded but partially requested. See partial_piece_info for the fields in the returned vector.

[report issue]

reset_piece_deadline() clear_piece_deadlines() set_piece_deadline()

void reset_piece_deadline (piece_index_t index) const;
void clear_piece_deadlines () 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 function again.

If the piece is already downloaded when this call is made, nothing happens, unless the alert_when_available flag is set, in which case it will have the same effect as calling read_piece() 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 reset_piece_deadline() was called on all pieces.

[report issue]

file_progress()

std::vector<std::int64_t> file_progress (file_progress_flags_t flags = {}) const;
void file_progress (std::vector<std::int64_t>& progress, file_progress_flags_t flags = {}) const;

This function fills in the supplied vector, or returns a vector, with the number of bytes downloaded of each file in this torrent. The progress values are ordered the same as the files in the torrent_info.

This operation is not very cheap. Its complexity is O(n + mj). Where n is the number of files, m is the number of currently downloading pieces and j is the number of blocks in a piece.

The flags parameter can be used to specify the granularity of the file progress. If left at the default value of 0, the progress will be as accurate as possible, but also more expensive to calculate. If torrent_handle::piece_granularity is specified, the progress will be specified in piece granularity. i.e. only pieces that have been fully downloaded and passed the hash check count. When specifying piece granularity, the operation is a lot cheaper, since libtorrent already keeps track of this internally and no calculation is required.

[report issue]

file_status()

std::vector<open_file_state> file_status () const;

This function returns a vector with status about files that are open for this torrent. Any file that is not open will not be reported in the vector, i.e. it's possible that the vector is empty when returning, if none of the files in the torrent are currently open.

See open_file_state

[report issue]

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]

replace_trackers() trackers() add_tracker()

void add_tracker (announce_entry const&) const;
std::vector<announce_entry> trackers () const;
void replace_trackers (std::vector<announce_entry> const&) const;

trackers() will return the list of trackers for this torrent. The announce entry contains both a string url which specify the announce url for the tracker as well as an int tier, which is specifies the order in which this tracker is tried. If you want libtorrent to use another list of trackers for this torrent, you can 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.

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() add_url_seed() remove_url_seed()

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;

add_url_seed() adds another url to the torrent's list of url seeds. If the given url already exists in that list, the call has no effect. The torrent will connect to the server and try to download pieces from it, unless it's paused, queued, checking or seeding. remove_url_seed() removes the given url if it exists already. url_seeds() return a set of the url seeds currently in this torrent. Note that URLs that fails may be removed automatically from the list.

See http seeding for more information.

[report issue]

add_http_seed() remove_http_seed() http_seeds()

std::set<std::string> http_seeds () const;
void remove_http_seed (std::string const& url) const;
void add_http_seed (std::string const& url) const;

These functions are identical as the *_url_seed() variants, but they operate on BEP 17 web seeds instead of BEP 19.

See http seeding for more information.

[report issue]

add_extension()

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{});

add the specified extension to this torrent. The ext argument is a function that will be called from within libtorrent's context passing in the internal torrent object and the specified userdata pointer. The function is expected to return a shared pointer to a torrent_plugin instance.

[report issue]

set_metadata()

bool set_metadata (span<char const> metadata) const;

set_metadata expects the info section of metadata. i.e. The 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 aborted. Note that a handle may become invalid after it has been added to the session. Usually this is because the storage for the torrent is somehow invalid or if the filenames are not allowed (and hence cannot be opened/created) on your filesystem. If such an error occurs, a file_error_alert is generated and all handles that refers to that torrent will become invalid.

[report issue]

resume() pause()

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.

To know if a torrent is paused or not, call torrent_handle::status() and inspect torrent_status::paused.

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]

flags() set_flags() unset_flags()

void unset_flags (torrent_flags_t flags) const;
torrent_flags_t flags () const;
void set_flags (torrent_flags_t flags, torrent_flags_t mask) const;
void set_flags (torrent_flags_t flags) const;

sets and gets the torrent state flags. See torrent_flags_t. The set_flags overload that take a mask will affect all flags part of the mask, and set their values to what the flags argument is set to. This allows clearing and setting flags in a single function call. The set_flags overload that just takes flags, sets all the specified flags and leave any other flags unchanged. unset_flags clears the specified flags, while leaving any other flags unchanged.

The seed_mode flag is special, it can only be cleared once the torrent has been added, and it can only be set as part of the add_torrent_params flags, when adding the torrent.

[report issue]

flush_cache()

void flush_cache () const;

Instructs libtorrent to flush all the disk caches for this torrent and close all file handles. This is done asynchronously and you will be notified that it's complete through cache_flushed_alert.

Note that by the time you get the alert, libtorrent may have cached more data for the torrent, but you are guaranteed that whatever cached data libtorrent had by the time you called torrent_handle::flush_cache() has been written to disk.

[report issue]

force_recheck()

void force_recheck () const;

force_recheck puts the torrent back in a state where it assumes to have no resume data. All peers will be disconnected and the torrent will stop announcing to the tracker. The torrent will be added to the checking queue, and will be checked (all the files will be read and compared to the piece hashes). Once the check is complete, the torrent will start connecting to peers again, as normal. The torrent will be placed last in queue, i.e. its queue position will be the highest of all torrents in the session.

[report issue]

save_resume_data()

void save_resume_data (resume_data_flags_t flags = {}) const;

save_resume_data() asks libtorrent to generate fast-resume data for this torrent.

This operation is asynchronous, save_resume_data will return immediately. The resume data is delivered when it's done through an save_resume_data_alert.

The fast resume data will be empty in the following cases:

  1. The torrent handle is invalid.
  2. The torrent hasn't received valid metadata and was started without metadata (see libtorrent's metadata from peers extension)

Note that by the time you receive the fast resume data, it may already be invalid if the torrent is still downloading! The recommended practice is to first pause the session, then generate the fast resume data, and then close it down. Make sure to not remove_torrent() before you receive the save_resume_data_alert though. There's no need to pause when saving intermittent resume data.

Warning

If you pause every torrent individually instead of pausing the session, every torrent will have its paused state saved in the resume data!

Note

It is typically a good idea to save resume data whenever a torrent is completed or paused. In those cases you don't need to pause the torrent or the session, since the torrent will do no more writing to its files. If you save resume data for torrents when they are paused, you can accelerate the shutdown process by not saving resume data again for paused torrents. Completed torrents should have their resume data saved when they complete and on exit, since their statistics might be updated.

In full allocation mode the resume data is never invalidated by subsequent writes to the files, since pieces won't move around. This means that you don't need to pause before writing resume data in full or sparse mode. If you don't, however, any data written to disk after you saved resume data and before the session closed is lost.

It also means that if the resume data is out dated, libtorrent will not re-check the files, but assume that it is fairly recent. The assumption is that it's better to loose a little bit than to re-check the entire file.

It is still a good idea to save resume data periodically during download as well as when closing down.

Example code to pause and save resume data for all torrents and wait for the alerts:

extern int outstanding_resume_data; // global counter of outstanding resume data
std::vector<torrent_handle> handles = ses.get_torrents();
ses.pause();
for (torrent_handle const& h : handles)
{
        if (!h.is_valid()) continue;
        torrent_status s = h.status();
        if (!s.has_metadata || !s.need_save_resume_data()) continue;

        h.save_resume_data();
        ++outstanding_resume_data;
}

while (outstanding_resume_data > 0)
{
        alert const* a = ses.wait_for_alert(seconds(10));

        // if we don't get an alert within 10 seconds, abort
        if (a == nullptr) break;

        std::vector<alert*> alerts;
        ses.pop_alerts(&alerts);

        for (alert* i : alerts)
        {
                if (alert_cast<save_resume_data_failed_alert>(i))
                {
                        process_alert(i);
                        --outstanding_resume_data;
                        continue;
                }

                save_resume_data_alert const* rd = alert_cast<save_resume_data_alert>(i);
                if (rd == nullptr)
                {
                        process_alert(i);
                        continue;
                }

                torrent_handle h = rd->handle;
                torrent_status st = h.status(torrent_handle::query_save_path
                        | torrent_handle::query_name);
                std::ofstream out((st.save_path
                        + "/" + st.name + ".fastresume").c_str()
                        , std::ios_base::binary);
                std::vector<char> buf = write_resume_data_buf(rd->params);
                out.write(buf.data(), buf.size());
                --outstanding_resume_data;
        }
}

Note

Note how outstanding_resume_data is a global counter in this example. This is deliberate, otherwise there is a race condition for torrents that was just asked to save their resume data, they posted the alert, but it has not been received yet. Those torrents would report that they don't need to save resume data again, and skipped by the initial loop, and thwart the counter otherwise.

[report issue]

need_save_resume_data()

bool need_save_resume_data () const;

This function returns true if any whole chunk has been downloaded since the torrent was first loaded or since the last time the resume data was saved. When saving resume data periodically, it makes sense to skip any torrent which hasn't downloaded anything since the last time.

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_up() queue_position() queue_position_down() queue_position_bottom()

void queue_position_bottom () const;
void queue_position_top () const;
void queue_position_down () const;
queue_position_t queue_position () const;
void queue_position_up () 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 torrents with the smallest numbers are the ones that are being downloaded. The smaller number, the closer the torrent is to the front of the line to be started.

The queue position is also available in the torrent_status.

The queue_position_*() functions adjust the torrents position in the queue. Up means closer to the front and down means closer to the back of the queue. Top and bottom refers to the front and the back of the queue respectively.

[report issue]

queue_position_set()

void queue_position_set (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

[report issue]

set_ssl_certificate() set_ssl_certificate_buffer()

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 = "");

For SSL torrents, use this to specify a path to a .pem file to use as this client's certificate. The certificate must be signed by the certificate in the .torrent file to be valid.

The set_ssl_certificate_buffer() overload takes the actual certificate, private key and DH params as strings, rather than paths to files.

cert is a path to the (signed) certificate in .pem format corresponding to this torrent.

private_key is a path to the private key for the specified certificate. This must be in .pem format.

dh_params is a path to the Diffie-Hellman parameter file, which needs to be in .pem format. You can generate this file using the openssl command like this: openssl dhparam -outform PEM -out dhparams.pem 512.

passphrase may be specified if the private key is encrypted and requires a passphrase to be decrypted.

Note that when a torrent first starts up, and it needs a certificate, it will suspend connecting to any peers until it has one. It's typically desirable to resume the torrent after setting the SSL certificate.

If you receive a torrent_need_cert_alert, you need to call this to provide a valid cert. If you don't have a cert you won't be allowed to connect to any peers.

[report issue]

torrent_file()

std::shared_ptr<const torrent_info> torrent_file () const;

Returns a pointer to the torrent_info object associated with this torrent. The torrent_info object may be a copy of the internal object. If the torrent doesn't have metadata, the 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

[report issue]

piece_availability()

void piece_availability (std::vector<int>& avail) const;

Fills the specified std::vector<int> with the availability for each piece in this torrent. libtorrent does not keep track of availability for seeds, so if the torrent is seeding the availability for all pieces is reported as 0.

The piece availability is the number of peers that we are connected that has advertised having a particular piece. This is the information that libtorrent uses in order to prefer picking rare pieces.

[report issue]

get_piece_priorities() piece_priority() prioritize_pieces()

void piece_priority (piece_index_t index, download_priority_t priority) const;
download_priority_t piece_priority (piece_index_t index) const;
void prioritize_pieces (std::vector<std::pair<piece_index_t, download_priority_t>> const& pieces) const;
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 takes precedence over piece availability. Every piece with priority 7 will be attempted to be picked before a priority 6 piece and so on.

The default priority of pieces is 4.

Piece priorities can not be changed for torrents that have not downloaded the metadata yet. Magnet links won't have metadata immediately. see the metadata_received_alert.

piece_priority sets or gets the priority for an individual piece, specified by index.

prioritize_pieces takes a vector of integers, one integer per piece in the torrent. All the piece priorities will be updated with the priorities in the vector. The second overload of prioritize_pieces that takes a vector of pairs will update the priorities of only select pieces, and leave all other unaffected. Each pair is (piece, priority). That is, the first item is the piece index and the second item is the priority of that piece. Invalid entries, where the piece index or priority is out of range, are not allowed.

get_piece_priorities returns a vector with one element for each piece in the torrent. Each element is the current priority of that piece.

It's possible to cancel the effect of file priorities by setting the priorities for the affected pieces. Care has to be taken when mixing usage of file- and piece priorities.

[report issue]

get_file_priorities() prioritize_files() file_priority()

std::vector<download_priority_t> get_file_priorities () 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.

get_file_priorities() returns a vector with the priorities of all files.

The priority values are the same as for piece_priority(). See download_priority_t.

Whenever a file priority is changed, all other piece priorities are reset to match the file priorities. In order to maintain special priorities for particular pieces, piece_priority() has to be called again for those pieces.

You cannot set the file priorities on a torrent that does not yet have metadata or a torrent that is a seed. file_priority(int, int) and prioritize_files() are both no-ops for such torrents.

Since changing file priorities may involve disk operations (of moving files in- and out of the part file), the internal accounting of file priorities happen asynchronously. i.e. setting file priorities and then immediately querying them may not yield the same priorities just set. However, the piece priorities are updated immediately.

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.

[report issue]

force_lsd_announce() force_reannounce() force_dht_announce()

void force_reannounce (int seconds = 0, int idx = -1, reannounce_flags_t = {}) const;
void force_dht_announce () const;
void force_lsd_announce () const;

force_reannounce() will force this torrent to do another tracker request, to receive new peers. The seconds argument specifies how many seconds from now to issue the tracker announces.

If the tracker's min_interval has not passed since the last announce, the forced announce will be scheduled to happen immediately as the min_interval expires. This is to honor trackers minimum re-announce interval settings.

The tracker_index argument specifies which tracker to re-announce. If set to -1 (which is the default), all trackers are re-announce.

The flags argument can be used to affect the re-announce. See ignore_min_interval.

force_dht_announce will announce the torrent to the DHT immediately.

force_lsd_announce will announce the torrent on LSD immediately.

[report issue]

scrape_tracker()

void scrape_tracker (int idx = -1) const;

scrape_tracker() will send a scrape request to a tracker. By default (idx = -1) it will scrape the last working tracker. If 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]

upload_limit() set_upload_limit() set_download_limit() download_limit()

int download_limit () const;
void set_download_limit (int limit) const;
void set_upload_limit (int limit) const;
int upload_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.

upload_limit and download_limit will return the current limit setting, for upload and download, respectively.

Local peers are not rate limited by default. see peer classes.

[report issue]

connect_peer()

void connect_peer (tcp::endpoint const& adr, peer_source_flags_t source = {}
      , pex_flags_t flags = pex_encryption | pex_utp | pex_holepunch) const;

connect_peer() is a way to manually connect to peers that one believe is a part of the torrent. If the peer does not respond, or is not a member of this torrent, it will simply be disconnected. No harm can be done by using this other than an unnecessary connection attempt is made. If the torrent is uninitialized or in queued or checking mode, this will throw system_error. The second (optional) argument will be bitwise ORed into the source mask of this peer. Typically this is one of the source flags in peer_info. i.e. tracker, pex, dht etc.

For possible values of flags, see pex_flags_t.

[report issue]

clear_peers()

void clear_peers ();

This will disconnect all peers and clear the peer list for this torrent. New peers will have to be acquired before resuming, from trackers, DHT or local service discovery, for example.

[report issue]

max_uploads() set_max_uploads()

void set_max_uploads (int max_uploads) const;
int max_uploads () const;

set_max_uploads() sets the maximum number of peers that's unchoked at the same time on this torrent. If you set this to -1, there will be no limit. This defaults to infinite. The primary setting controlling this is the global unchoke slots limit, set by unchoke_slots_limit in settings_pack.

max_uploads() returns the current settings.

[report issue]

max_connections() set_max_connections()

int max_connections () const;
void set_max_connections (int max_connections) const;

set_max_connections() sets the maximum number of connection this torrent will open. If all connections are used up, incoming connections may be refused or poor connections may be closed. This must be at least 2. The default is unlimited number of connections. If -1 is given to the function, it means unlimited. There is also a global limit of the number of connections, set by connections_limit in settings_pack.

max_connections() returns the current settings.

[report issue]

move_storage()

void move_storage (std::string const& save_path
      , move_flags_t flags = move_flags_t::always_replace_files
      ) const;

Moves the file(s) that this torrent are currently seeding from or downloading to. If the given save_path is not located on the same drive as the original save path, the files will be copied to the new drive and removed from their original location. This will block all other disk IO, and other torrents download and upload rates may drop while copying the file.

Since disk IO is performed in a separate thread, this operation is also asynchronous. Once the operation completes, the storage_moved_alert is generated, with the new path as the message. If the move fails for some reason, storage_moved_failed_alert is generated instead, containing the error message.

The flags argument determines the behavior of the copying/moving of the files in the torrent. see move_flags_t.

always_replace_files is the default and replaces any file that exist in both the source directory and the target directory.

fail_if_exist first check to see that none of the copy operations would cause an overwrite. If it would, it will fail. Otherwise it will proceed as if it was in always_replace_files mode. Note that there is an inherent race condition here. If the files in the target directory appear after the check but before the copy or move completes, they will be overwritten. When failing because of files already existing in the target path, the error of move_storage_failed_alert is set to boost::system::errc::file_exists.

The intention is that a client may use this as a probe, and if it fails, ask the user which mode to use. The client may then re-issue the move_storage call with one of the other modes.

dont_replace always keeps the existing file in the target directory, if there is one. The source files will still be removed in that case. Note that it won't automatically re-check files. If an incomplete torrent is moved into a directory with the complete files, pause, move, force-recheck and resume. Without the re-checking, the torrent will keep downloading and files in the new download directory will be overwritten.

Files that have been renamed to have absolute paths are not moved by this function. Keep in mind that files that don't belong to the torrent but are stored in the torrent's directory may be moved as well. This goes for files that have been renamed to absolute paths that still end up inside the save path.

[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;

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]

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.

[report issue]

id()

std::uint32_t id () const;

returns a unique identifier for this torrent. It's not a dense index. It's not preserved across sessions.

[report issue]

native_handle()

std::shared_ptr<torrent> native_handle () const;

This function is intended only for use by plugins and the alert dispatch function. This type does not have a stable ABI and should be relied on as little as possible. Accessing the handle returned by this function is not thread safe outside of libtorrent's internal thread (which is used to invoke plugin callbacks). The torrent class is not only eligible for changing ABI across minor versions of libtorrent, its layout is also dependent on build configuration. This adds additional requirements on a client to be built with the exact same build configuration as libtorrent itself. i.e. the TORRENT_ macros must match between libtorrent and the client builds.

[report issue]

userdata()

client_data_t userdata () const;

returns the userdata pointer as set in add_torrent_params

[report issue]
overwrite_existing
instruct libtorrent to overwrite any data that may already have been downloaded with the data of the new piece being added.
[report issue]
query_distributed_copies
calculates distributed_copies, distributed_full_copies and distributed_fraction.
[report issue]
query_accurate_download_counters
includes partial downloaded blocks in total_done and total_wanted_done.
[report issue]
query_last_seen_complete
includes last_seen_complete.
[report issue]
query_pieces
populate the pieces field in torrent_status.
[report issue]
query_verified_pieces
includes verified_pieces (only applies to torrents in seed mode).
[report issue]
query_torrent_file
includes torrent_file, which is all the static information from the .torrent file.
[report issue]
query_name
includes name, the name of the torrent. This is either derived from the .torrent file, or from the &dn= magnet link argument or possibly some other source. If the name of the torrent is not known, this is an empty string.
[report issue]
query_save_path
includes save_path, the path to the directory the files of the torrent are saved to.
[report issue]
alert_when_available
used to ask libtorrent to send an alert once the piece has been downloaded, by passing alert_when_available. When set, the read_piece_alert alert will be delivered, with the piece data, when it's downloaded.
[report issue]
piece_granularity
only calculate file progress at piece granularity. This makes the file_progress() call cheaper and also only takes bytes that have passed the hash check into account, so progress cannot regress in this mode.
[report issue]
graceful_pause clear_disk_cache
will delay the disconnect of peers that we're still downloading outstanding requests from. The torrent will not accept any more requests and will disconnect all idle peers. As soon as a peer is done transferring the blocks that were requested from it, it is disconnected. This is a graceful shut down of the torrent in the sense that no downloaded bytes are wasted.
[report issue]
flush_disk_cache
the disk cache will be flushed before creating the resume data. This avoids a problem with file timestamps in the resume data in case the cache hasn't been flushed yet.
[report issue]
save_info_dict
the resume data will contain the metadata from the torrent file as well. This is default for any torrent that's added without a torrent file (such as a magnet link or a URL).
[report issue]
only_if_modified
if nothing significant has changed in the torrent since the last time resume data was saved, fail this attempt. Significant changes primarily include more data having been downloaded, file or piece priorities having changed etc. If the resume data doesn't need saving, a save_resume_data_failed_alert is posted with the error resume_data_not_modified.
[report issue]
ignore_min_interval
by default, force-reannounce will still honor the min-interval published by the tracker. If this flag is set, it will be ignored and the tracker is announced immediately.
[report issue]

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.)