premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

move torrent_status documentation into the header

This commit is contained in:
Arvid Norberg 2013-08-07 06:37:51 +00:00
parent 6beb14f2a8
commit 6abfce3970
4 changed files with 238 additions and 521 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

427
docs/manual.rst
View File

@ -93,433 +93,6 @@ For documentation on these types, please refer to the `asio documentation`_.
.. _`asio documentation`: http://asio.sourceforge.net/asio-0.3.8/doc/asio/reference.html
torrent_status
==============
It contains the following fields::
struct torrent_status
{
enum state_t
{
queued_for_checking,
checking_files,
downloading_metadata,
downloading,
finished,
seeding,
allocating,
checking_resume_data
};
torrent_handle handle;
state_t state;
bool paused;
bool auto_managed;
bool sequential_download;
bool seeding;
bool finished;
float progress;
int progress_ppm;
std::string error;
std::string save_path;
std::string name;
boost::intrusive_ptr<const torrent_info> torrent_file;
boost::posix_time::time_duration next_announce;
boost::posix_time::time_duration announce_interval;
std::string current_tracker;
size_type total_download;
size_type total_upload;
size_type total_payload_download;
size_type total_payload_upload;
size_type total_failed_bytes;
size_type total_redundant_bytes;
int download_rate;
int upload_rate;
int download_payload_rate;
int upload_payload_rate;
int num_peers;
int num_complete;
int num_incomplete;
int list_seeds;
int list_peers;
int connect_candidates;
bitfield pieces;
bitfield verified_pieces;
int num_pieces;
size_type total_done;
size_type total_wanted_done;
size_type total_wanted;
int num_seeds;
int distributed_full_copies;
int distributed_fraction;
float distributed_copies;
int block_size;
int num_uploads;
int num_connections;
int uploads_limit;
int connections_limit;
storage_mode_t storage_mode;
int up_bandwidth_queue;
int down_bandwidth_queue;
size_type all_time_upload;
size_type all_time_download;
int active_time;
int finished_time;
int seeding_time;
int seed_rank;
int last_scrape;
bool has_incoming;
int sparse_regions;
bool seed_mode;
bool upload_mode;
bool share_mode;
bool super_seeding;
int priority;
time_t added_time;
time_t completed_time;
time_t last_seen_complete;
int time_since_upload;
int time_since_download;
int queue_position;
bool need_save_resume;
bool ip_filter_applies;
sha1_hash info_hash;
int listen_port;
};
``handle`` is a handle to the torrent whose status the object represents.
``progress`` is a value in the range [0, 1], that represents the progress of the
torrent's current task. It may be checking files or downloading.
``progress_ppm`` reflects the same value as ``progress``, but instead in a range
[0, 1000000] (ppm = parts per million). When floating point operations are disabled,
this is the only alternative to the floating point value in ``progress``.
The torrent's current task is in the ``state`` member, it will be one of the following:
+--------------------------+----------------------------------------------------------+
|``checking_resume_data`` |The torrent is currently checking the fastresume data and |
| |comparing it to the files on disk. This is typically |
| |completed in a fraction of a second, but if you add a |
| |large number of torrents at once, they will queue up. |
+--------------------------+----------------------------------------------------------+
|``queued_for_checking`` |The torrent is in the queue for being checked. But there |
| |currently is another torrent that are being checked. |
| |This torrent will wait for its turn. |
+--------------------------+----------------------------------------------------------+
|``checking_files`` |The torrent has not started its download yet, and is |
| |currently checking existing files. |
+--------------------------+----------------------------------------------------------+
|``downloading_metadata`` |The torrent is trying to download metadata from peers. |
| |This assumes the metadata_transfer extension is in use. |
+--------------------------+----------------------------------------------------------+
|``downloading`` |The torrent is being downloaded. This is the state |
| |most torrents will be in most of the time. The progress |
| |meter will tell how much of the files that has been |
| |downloaded. |
+--------------------------+----------------------------------------------------------+
|``finished`` |In this state the torrent has finished downloading but |
| |still doesn't have the entire torrent. i.e. some pieces |
| |are filtered and won't get downloaded. |
+--------------------------+----------------------------------------------------------+
|``seeding`` |In this state the torrent has finished downloading and |
| |is a pure seeder. |
+--------------------------+----------------------------------------------------------+
|``allocating`` |If the torrent was started in full allocation mode, this |
| |indicates that the (disk) storage for the torrent is |
| |allocated. |
+--------------------------+----------------------------------------------------------+
When downloading, the progress is ``total_wanted_done`` / ``total_wanted``. This takes
into account files whose priority have been set to 0. They are not considered.
``paused`` is set to true if the torrent is paused and false otherwise. It's only true
if the torrent itself is paused. If the torrent is not running because the session is
paused, this is still false. To know if a torrent is active or not, you need to inspect
both ``torrent_status::paused`` and ``session::is_paused()``.
``auto_managed`` is set to true if the torrent is auto managed, i.e. libtorrent is
responsible for determining whether it should be started or queued. For more info
see queuing_
``sequential_download`` is true when the torrent is in sequential download mode. In
this mode pieces are downloaded in order rather than rarest first.
``is_seeding`` is true if all pieces have been downloaded.
``is_finished`` is true if all pieces that have a priority > 0 are downloaded. There is
only a distinction between finished and seeding if some pieces or files have been
set to priority 0, i.e. are not downloaded.
``has_metadata`` is true if this torrent has metadata (either it was started from a
.torrent file or the metadata has been downloaded). The only scenario where this can be
false is when the torrent was started torrent-less (i.e. with just an info-hash and tracker
ip, a magnet link for instance).
``error`` may be set to an error message describing why the torrent was paused, in
case it was paused by an error. If the torrent is not paused or if it's paused but
not because of an error, this string is empty.
``save_path`` is the path to the directory where this torrent's files are stored.
It's typically the path as was given to `async_add_torrent() add_torrent()`_ when this torrent
was started. This field is only included if the torrent status is queried with
``torrent_handle::query_save_path``.
``name`` is the name of the torrent. Typically this is derived from the .torrent file.
In case the torrent was started without metadata, and hasn't completely received it yet,
it returns the name given to it when added to the session. See ``session::add_torrent``.
This field is only included if the torrent status is queried with ``torrent_handle::query_name``.
``torrent_file`` is set to point to the ``torrent_info`` object for this torrent. It's
only included if the torrent status is queried with ``torrent_handle::query_torrent_file``.
``next_announce`` is the time until the torrent will announce itself to the tracker. And
``announce_interval`` is the time the tracker want us to wait until we announce ourself
again the next time.
``current_tracker`` is the URL of the last working tracker. If no tracker request has
been successful yet, it's set to an empty string.
``total_download`` and ``total_upload`` is the number of bytes downloaded and
uploaded to all peers, accumulated, *this session* only. The session is considered
to restart when a torrent is paused and restarted again. When a torrent is paused,
these counters are reset to 0. If you want complete, persistent, stats, see
``all_time_upload`` and ``all_time_download``.
``total_payload_download`` and ``total_payload_upload`` counts the amount of bytes
send and received this session, but only the actual payload data (i.e the interesting
data), these counters ignore any protocol overhead.
``total_failed_bytes`` is the number of bytes that has been downloaded and that
has failed the piece hash test. In other words, this is just how much crap that
has been downloaded.
``total_redundant_bytes`` is the number of bytes that has been downloaded even
though that data already was downloaded. The reason for this is that in some
situations the same data can be downloaded by mistake. When libtorrent sends
requests to a peer, and the peer doesn't send a response within a certain
timeout, libtorrent will re-request that block. Another situation when
libtorrent may re-request blocks is when the requests it sends out are not
replied in FIFO-order (it will re-request blocks that are skipped by an out of
order block). This is supposed to be as low as possible.
``pieces`` is the bitmask that represents which pieces we have (set to true) and
the pieces we don't have. It's a pointer and may be set to 0 if the torrent isn't
downloading or seeding.
``verified_pieces`` is a bitmask representing which pieces has had their hash
checked. This only applies to torrents in *seed mode*. If the torrent is not
in seed mode, this bitmask may be empty.
``num_pieces`` is the number of pieces that has been downloaded. It is equivalent
to: ``std::accumulate(pieces->begin(), pieces->end())``. So you don't have to
count yourself. This can be used to see if anything has updated since last time
if you want to keep a graph of the pieces up to date.
``download_rate`` and ``upload_rate`` are the total rates for all peers for this
torrent. These will usually have better precision than summing the rates from
all peers. The rates are given as the number of bytes per second. The
``download_payload_rate`` and ``upload_payload_rate`` respectively is the
total transfer rate of payload only, not counting protocol chatter. This might
be slightly smaller than the other rates, but if projected over a long time
(e.g. when calculating ETA:s) the difference may be noticeable.
``num_peers`` is the number of peers this torrent currently is connected to.
Peer connections that are in the half-open state (is attempting to connect)
or are queued for later connection attempt do not count. Although they are
visible in the peer list when you call `get_peer_info()`_.
``num_complete`` and ``num_incomplete`` are set to -1 if the tracker did not
send any scrape data in its announce reply. This data is optional and may
not be available from all trackers. If these are not -1, they are the total
number of peers that are seeding (complete) and the total number of peers
that are still downloading (incomplete) this torrent.
``list_seeds`` and ``list_peers`` are the number of seeds in our peer list
and the total number of peers (including seeds) respectively. We are not
necessarily connected to all the peers in our peer list. This is the number
of peers we know of in total, including banned peers and peers that we have
failed to connect to.
``connect_candidates`` is the number of peers in this torrent's peer list
that is a candidate to be connected to. i.e. It has fewer connect attempts
than the max fail count, it is not a seed if we are a seed, it is not banned
etc. If this is 0, it means we don't know of any more peers that we can try.
``total_done`` is the total number of bytes of the file(s) that we have. All
this does not necessarily has to be downloaded during this session (that's
``total_payload_download``).
``total_wanted_done`` is the number of bytes we have downloaded, only counting the
pieces that we actually want to download. i.e. excluding any pieces that we have but
have priority 0 (i.e. not wanted).
``total_wanted`` is the total number of bytes we want to download. This is also
excluding pieces whose priorities have been set to 0.
``num_seeds`` is the number of peers that are seeding that this client is
currently connected to.
``distributed_full_copies`` is the number of distributed copies of the torrent.
Note that one copy may be spread out among many peers. It tells how many copies
there are currently of the rarest piece(s) among the peers this client is
connected to.
``distributed_fraction`` tells the share of pieces that have more copies than
the rarest piece(s). Divide this number by 1000 to get the fraction.
For example, if ``distributed_full_copies`` is 2 and ``distrbuted_fraction``
is 500, it means that the rarest pieces have only 2 copies among the peers
this torrent is connected to, and that 50% of all the pieces have more than
two copies.
If we are a seed, the piece picker is deallocated as an optimization, and
piece availability is no longer tracked. In this case the distributed
copies members are set to -1.
``distributed_copies`` is a floating point representation of the
``distributed_full_copies`` as the integer part and ``distributed_fraction``
/ 1000 as the fraction part. If floating point operations are disabled
this value is always -1.
``block_size`` is the size of a block, in bytes. A block is a sub piece, it
is the number of bytes that each piece request asks for and the number of
bytes that each bit in the ``partial_piece_info``'s bitset represents
(see `get_download_queue()`_). This is typically 16 kB, but it may be
larger if the pieces are larger.
``num_uploads`` is the number of unchoked peers in this torrent.
``num_connections`` is the number of peer connections this torrent has, including
half-open connections that hasn't completed the bittorrent handshake yet. This is
always >= ``num_peers``.
``uploads_limit`` is the set limit of upload slots (unchoked peers) for this torrent.
``connections_limit`` is the set limit of number of connections for this torrent.
``storage_mode`` is one of ``storage_mode_allocate``, ``storage_mode_sparse`` or
``storage_mode_compact``. Identifies which storage mode this torrent is being saved
with. See `Storage allocation`_.
``up_bandwidth_queue`` and ``down_bandwidth_queue`` are the number of peers in this
torrent that are waiting for more bandwidth quota from the torrent rate limiter.
This can determine if the rate you get from this torrent is bound by the torrents
limit or not. If there is no limit set on this torrent, the peers might still be
waiting for bandwidth quota from the global limiter, but then they are counted in
the ``session_status`` object.
``all_time_upload`` and ``all_time_download`` are accumulated upload and download
payload byte counters. They are saved in and restored from resume data to keep totals
across sessions.
``active_time``, ``finished_time`` and ``seeding_time`` are second counters.
They keep track of the number of seconds this torrent has been active (not
paused) and the number of seconds it has been active while being finished and
active while being a seed. ``seeding_time`` should be <= ``finished_time`` which
should be <= ``active_time``. They are all saved in and restored from resume data,
to keep totals across sessions.
``seed_rank`` is a rank of how important it is to seed the torrent, it is used
to determine which torrents to seed and which to queue. It is based on the peer
to seed ratio from the tracker scrape. For more information, see queuing_.
``last_scrape`` is the number of seconds since this torrent acquired scrape data.
If it has never done that, this value is -1.
``has_incoming`` is true if there has ever been an incoming connection attempt
to this torrent.'
``sparse_regions`` the number of regions of non-downloaded pieces in the
torrent. This is an interesting metric on windows vista, since there is
a limit on the number of sparse regions in a single file there.
``seed_mode`` is true if the torrent is in seed_mode. If the torrent was
started in seed mode, it will leave seed mode once all pieces have been
checked or as soon as one piece fails the hash check.
``upload_mode`` is true if the torrent is blocked from downloading. This
typically happens when a disk write operation fails. If the torrent is
auto-managed, it will periodically be taken out of this state, in the
hope that the disk condition (be it disk full or permission errors) has
been resolved. If the torrent is not auto-managed, you have to explicitly
take it out of the upload mode by calling `set_upload_mode()`_ on the
torrent_handle_.
``share_mode`` is true if the torrent is currently in share-mode, i.e.
not downloading the torrent, but just helping the swarm out.
``super_seeding`` is true if the torrent is in super seeding mode.
``added_time`` is the posix-time when this torrent was added. i.e. what
``time(NULL)`` returned at the time.
``completed_time`` is the posix-time when this torrent was finished. If
the torrent is not yet finished, this is 0.
``last_seen_complete`` is the time when we, or one of our peers, last
saw a complete copy of this torrent.
``time_since_upload`` and ``time_since_download`` are the number of
seconds since any peer last uploaded from this torrent and the last
time a downloaded piece passed the hash check, respectively.
``queue_position`` is the position this torrent has in the download
queue. If the torrent is a seed or finished, this is -1.
``need_save_resume`` is true if this torrent has unsaved changes
to its download state and statistics since the last resume data
was saved.
``ip_filter_applies`` is true if the session global IP filter applies
to this torrent. This defaults to true.
``info_hash`` is the info-hash of the torrent.
``listen_port`` is the listen port this torrent is listening on for new
connections, if the torrent has its own listen socket. Only SSL torrents
have their own listen sockets. If the torrent doesn't have one, and is
accepting connections on the single listen socket, this is 0.
peer_info
=========

326
include/libtorrent/torrent_handle.hpp
View File

@ -1031,205 +1031,349 @@ namespace libtorrent
bool operator==(torrent_status const& st) const
{ return handle == st.handle; }
// handle to the torrent
// a handle to the torrent whose status the object represents.
torrent_handle handle;
enum state_t
{
// The torrent is in the queue for being checked. But there
// currently is another torrent that are being checked.
// This torrent will wait for its turn.
queued_for_checking,
// The torrent has not started its download yet, and is
// currently checking existing files.
checking_files,
// The torrent is trying to download metadata from peers.
// This assumes the metadata_transfer extension is in use.
downloading_metadata,
// The torrent is being downloaded. This is the state
// most torrents will be in most of the time. The progress
// meter will tell how much of the files that has been
// downloaded.
downloading,
// In this state the torrent has finished downloading but
// still doesn't have the entire torrent. i.e. some pieces
// are filtered and won't get downloaded.
finished,
// In this state the torrent has finished downloading and
// is a pure seeder.
seeding,
// If the torrent was started in full allocation mode, this
// indicates that the (disk) storage for the torrent is
// allocated.
allocating,
// The torrent is currently checking the fastresume data and
// comparing it to the files on disk. This is typically
// completed in a fraction of a second, but if you add a
// large number of torrents at once, they will queue up.
checking_resume_data
};
state_t state;
// set to true if the torrent is paused and false otherwise. It's only true
// if the torrent itself is paused. If the torrent is not running because the session is
// paused, this is still false. To know if a torrent is active or not, you need to inspect
// both ``torrent_status::paused`` and ``session::is_paused()``.
bool paused;
// set to true if the torrent is auto managed, i.e. libtorrent is
// responsible for determining whether it should be started or queued. For more info
// see queuing_
bool auto_managed;
// true when the torrent is in sequential download mode. In
// this mode pieces are downloaded in order rather than rarest first.
bool sequential_download;
// true if all pieces have been downloaded.
bool is_seeding;
// true if all pieces that have a priority > 0 are downloaded. There is
// only a distinction between finished and seeding if some pieces or files have been
// set to priority 0, i.e. are not downloaded.
bool is_finished;
// true if this torrent has metadata (either it was started from a
// .torrent file or the metadata has been downloaded). The only scenario where this can be
// false is when the torrent was started torrent-less (i.e. with just an info-hash and tracker
// ip, a magnet link for instance).
bool has_metadata;
// a value in the range [0, 1], that represents the progress of the
// torrent's current task. It may be checking files or downloading.
float progress;
// progress parts per million (progress * 1000000)
// when disabling floating point operations, this is
// the only option to query progress
// reflects the same value as ``progress``, but instead in a range
// [0, 1000000] (ppm = parts per million). When floating point operations are disabled,
// this is the only alternative to the floating point value in progress.
int progress_ppm;
// may be set to an error message describing why the torrent was paused, in
// case it was paused by an error. If the torrent is not paused or if it's paused but
// not because of an error, this string is empty.
std::string error;
// save path of where the torrent's files are saved
// only set when status is queried with query_save_path
// the path to the directory where this torrent's files are stored.
// It's typically the path as was given to `async_add_torrent() add_torrent()`_ when this torrent
// was started. This field is only included if the torrent status is queried with
// ``torrent_handle::query_save_path``.
std::string save_path;
// name of the torrent, or empty if the torrent's name
// cannot be established yet
// only set when status is queried with query_name
// the name of the torrent. Typically this is derived from the .torrent file.
// In case the torrent was started without metadata, and hasn't completely received it yet,
// it returns the name given to it when added to the session. See ``session::add_torrent``.
// This field is only included if the torrent status is queried with ``torrent_handle::query_name``.
std::string name;
// the torrent file for this torrent
// only set when status is queried with query_torrent_file
// set to point to the ``torrent_info`` object for this torrent. It's
// only included if the torrent status is queried with ``torrent_handle::query_torrent_file``.
boost::intrusive_ptr<const torrent_info> torrent_file;
// the time until the torrent will announce itself to the tracker.
boost::posix_time::time_duration next_announce;
// the time the tracker want us to wait until we announce ourself
// again the next time.
boost::posix_time::time_duration announce_interval;
// the URL of the last working tracker. If no tracker request has
// been successful yet, it's set to an empty string.
std::string current_tracker;
// transferred this session!
// total, payload plus protocol
// the number of bytes downloaded and
// uploaded to all peers, accumulated, *this session* only. The session is considered
// to restart when a torrent is paused and restarted again. When a torrent is paused,
// these counters are reset to 0. If you want complete, persistent, stats, see
// ``all_time_upload`` and ``all_time_download``.
size_type total_download;
size_type total_upload;
// payload only
// counts the amount of bytes
// send and received this session, but only the actual payload data (i.e the interesting
// data), these counters ignore any protocol overhead.
size_type total_payload_download;
size_type total_payload_upload;
// the amount of payload bytes that
// has failed their hash test
// the number of bytes that has been downloaded and that
// has failed the piece hash test. In other words, this is just how much crap that
// has been downloaded.
size_type total_failed_bytes;
// the number of payload bytes that
// has been received redundantly.
// the number of bytes that has been downloaded even
// though that data already was downloaded. The reason for this is that in some
// situations the same data can be downloaded by mistake. When libtorrent sends
// requests to a peer, and the peer doesn't send a response within a certain
// timeout, libtorrent will re-request that block. Another situation when
// libtorrent may re-request blocks is when the requests it sends out are not
// replied in FIFO-order (it will re-request blocks that are skipped by an out of
// order block). This is supposed to be as low as possible.
size_type total_redundant_bytes;
// current transfer rate
// payload plus protocol
// the total rates for all peers for this
// torrent. These will usually have better precision than summing the rates from
// all peers. The rates are given as the number of bytes per second.
int download_rate;
int upload_rate;
// the rate of payload that is
// sent and received
// the total transfer rate of payload only, not counting protocol chatter. This might
// be slightly smaller than the other rates, but if projected over a long time
// (e.g. when calculating ETA:s) the difference may be noticeable.
int download_payload_rate;
int upload_payload_rate;
// the number of peers this torrent is connected to
// that are seeding.
// the number of peers that are seeding that this client is
// currently connected to.
int num_seeds;
// the number of peers this torrent
// is connected to (including seeds).
// the number of peers this torrent currently is connected to.
// Peer connections that are in the half-open state (is attempting to connect)
// or are queued for later connection attempt do not count. Although they are
// visible in the peer list when you call get_peer_info().
int num_peers;
// if the tracker sends scrape info in its
// announce reply, these fields will be
// set to the total number of peers that
// have the whole file and the total number
// of peers that are still downloading
// of peers that are still downloading.
// set to -1 if the tracker did not
// send any scrape data in its announce reply.
int num_complete;
int num_incomplete;
// this is the number of seeds whose IP we know
// but are not necessarily connected to
// the number of seeds in our peer list
// and the total number of peers (including seeds). We are not
// necessarily connected to all the peers in our peer list. This is the number
// of peers we know of in total, including banned peers and peers that we have
// failed to connect to.
int list_seeds;
// this is the number of peers whose IP we know
// (including seeds), but are not necessarily
// connected to
int list_peers;
// the number of peers in our peerlist that
// we potentially could connect to
// the number of peers in this torrent's peer list
// that is a candidate to be connected to. i.e. It has fewer connect attempts
// than the max fail count, it is not a seed if we are a seed, it is not banned
// etc. If this is 0, it means we don't know of any more peers that we can try.
int connect_candidates;
// a bitmask that represents which pieces we have (set to true) and
// the pieces we don't have. It's a pointer and may be set to 0 if the torrent isn't
// downloading or seeding.
bitfield pieces;
// a bitmask representing which pieces has had their hash
// checked. This only applies to torrents in *seed mode*. If the torrent is not
// in seed mode, this bitmask may be empty.
bitfield verified_pieces;
// this is the number of pieces the client has
// downloaded. it is equal to:
// std::accumulate(pieces->begin(), pieces->end());
// the number of pieces that has been downloaded. It is equivalent
// to: ``std::accumulate(pieces->begin(), pieces->end())``. So you don't have to
// count yourself. This can be used to see if anything has updated since last time
// if you want to keep a graph of the pieces up to date.
int num_pieces;
// the number of bytes of the file we have
// including pieces that may have been filtered
// after we downloaded them
// the total number of bytes of the file(s) that we have. All
// this does not necessarily has to be downloaded during this session (that's
// ``total_payload_download``).
size_type total_done;
// the number of bytes we have of those that we
// want. i.e. not counting bytes from pieces that
// are filtered as not wanted.
// the number of bytes we have downloaded, only counting the
// pieces that we actually want to download. i.e. excluding any pieces that we have but
// have priority 0 (i.e. not wanted).
size_type total_wanted_done;
// the total number of bytes we want to download
// this may be smaller than the total torrent size
// in case any pieces are filtered as not wanted
// The total number of bytes we want to download.
// This may be smaller than the total torrent size
// in case any pieces are prioritized to 0, i.e. not wanted
size_type total_wanted;
// the number of distributed copies of the torrent.
// Note that one copy may be spread out among many peers. It tells how many copies
// there are currently of the rarest piece(s) among the peers this client is
// connected to.
int distributed_full_copies;
// tells the share of pieces that have more copies than
// the rarest piece(s). Divide this number by 1000 to get the fraction.
//
// For example, if ``distributed_full_copies`` is 2 and ``distrbuted_fraction``
// is 500, it means that the rarest pieces have only 2 copies among the peers
// this torrent is connected to, and that 50% of all the pieces have more than
// two copies.
//
// If we are a seed, the piece picker is deallocated as an optimization, and
// piece availability is no longer tracked. In this case the distributed
// copies members are set to -1.
int distributed_fraction;
// the number of distributed copies of the file.
// note that one copy may be spread out among many peers.
// This is a floating point representation of the
// distributed copies.
//
// the integer part tells how many copies
// there are of the rarest piece(s)
//
// the fractional part tells the fraction of pieces that
// have more copies than the rarest piece(s).
// the number of full distributed copies (i.e. the number
// of peers that have the rarest piece)
int distributed_full_copies;
// the fraction of pieces that more peers has than the
// rarest pieces. This indicates how close the swarm is
// to have one more full distributed copy
int distributed_fraction;
float distributed_copies;
// the block size that is used in this torrent. i.e.
// the number of bytes each piece request asks for
// and each bit in the download queue bitfield represents
// the size of a block, in bytes. A block is a sub piece, it
// is the number of bytes that each piece request asks for and the number of
// bytes that each bit in the ``partial_piece_info``'s bitset represents
// (see `get_download_queue()`_). This is typically 16 kB, but it may be
// larger if the pieces are larger.
int block_size;
// the number of unchoked peers in this torrent.
int num_uploads;
// the number of peer connections this torrent has, including
// half-open connections that hasn't completed the bittorrent handshake yet. This is
// always >= ``num_peers``.
int num_connections;
// the set limit of upload slots (unchoked peers) for this torrent.
int uploads_limit;
// the set limit of number of connections for this torrent.
int connections_limit;
// true if the torrent is saved in compact mode
// false if it is saved in full allocation mode
// The allocation mode for the torrent. See storage_mode_t for the options.
// For more information, see `Storage allocation`_.
storage_mode_t storage_mode;
// the number of peers in this
// torrent that are waiting for more bandwidth quota from the torrent rate limiter.
// This can determine if the rate you get from this torrent is bound by the torrents
// limit or not. If there is no limit set on this torrent, the peers might still be
// waiting for bandwidth quota from the global limiter, but then they are counted in
// the ``session_status`` object.
int up_bandwidth_queue;
int down_bandwidth_queue;
// number of bytes downloaded since torrent was started
// saved and restored from resume data
// are accumulated upload and download
// payload byte counters. They are saved in and restored from resume data to keep totals
// across sessions.
size_type all_time_upload;
size_type all_time_download;
// the number of seconds of being active
// and as being a seed, saved and restored
// from resume data
int active_time;
// These keep track of the number of seconds this torrent has been active (not
// paused) and the number of seconds it has been active while being finished and
// active while being a seed. ``seeding_time`` should be <= ``finished_time`` which
// should be <= ``active_time``. They are all saved in and restored from resume data,
// to keep totals across sessions.
int active_time;
int finished_time;
int seeding_time;
// higher value means more important to seed
// A rank of how important it is to seed the torrent, it is used
// to determine which torrents to seed and which to queue. It is based on the peer
// to seed ratio from the tracker scrape. For more information, see queuing_.
// Higher value means more important to seed
int seed_rank;
// number of seconds since last scrape, or -1 if
// there hasn't been a scrape
// the number of seconds since this torrent acquired scrape data.
// If it has never done that, this value is -1.
int last_scrape;
// true if there are incoming connections to this
// torrent
// true if there has ever been an incoming connection attempt
// to this torrent.
bool has_incoming;
// the number of "holes" in the torrent
// the number of regions of non-downloaded pieces in the
// torrent. This is an interesting metric on windows vista, since there is
// a limit on the number of sparse regions in a single file there.
int sparse_regions;
// is true if this torrent is (still) in seed_mode
// true if the torrent is in seed_mode. If the torrent was
// started in seed mode, it will leave seed mode once all pieces have been
// checked or as soon as one piece fails the hash check.
bool seed_mode;
// this is set to true when the torrent is blocked
// from downloading, typically caused by a file
// write operation failing
// true if the torrent is blocked from downloading. This
// typically happens when a disk write operation fails. If the torrent is
// auto-managed, it will periodically be taken out of this state, in the
// hope that the disk condition (be it disk full or permission errors) has
// been resolved. If the torrent is not auto-managed, you have to explicitly
// take it out of the upload mode by calling `set_upload_mode()`_ on the
// torrent_handle_.
bool upload_mode;
// this is true if the torrent is in share-mode
// true if the torrent is currently in share-mode, i.e.
// not downloading the torrent, but just helping the swarm out.
bool share_mode;
// true if the torrent is in super seeding mode
@ -1238,33 +1382,39 @@ namespace libtorrent
// the priority of this torrent
int priority;
// the time this torrent was added and completed
// the posix-time when this torrent was added. i.e. what
// ``time(NULL)`` returned at the time.
time_t added_time;
// the posix-time when this torrent was finished. If
// the torrent is not yet finished, this is 0.
time_t completed_time;
// the time when we, or one of our peers, last
// saw a complete copy of this torrent.
time_t last_seen_complete;
// number of seconds since last upload or download activity
// the number of
// seconds since any peer last uploaded from this torrent and the last
// time a downloaded piece passed the hash check, respectively.
int time_since_upload;
int time_since_download;
// the position in the download queue where this torrent is
// this is -1 for seeds and finished torrents
// the position this torrent has in the download
// queue. If the torrent is a seed or finished, this is -1.
int queue_position;
// true if this torrent has had changes since the last
// time resume data was saved
// true if this torrent has unsaved changes
// to its download state and statistics since the last resume data
// was saved.
bool need_save_resume;
// defaults to true. Determines whether the session
// IP filter applies to this torrent or not
// true if the session global IP filter applies
// to this torrent. This defaults to true.
bool ip_filter_applies;
// the info-hash for this torrent
sha1_hash info_hash;
// if this torrent has its own listen socket, this is
// the port it's listening on. Otherwise it's 0
int listen_port;
};
}

5
src/torrent.cpp
View File

@ -8725,11 +8725,6 @@ namespace libtorrent
if (flags & torrent_handle::query_torrent_file)
st->torrent_file = m_torrent_file;
st->listen_port = 0;
#ifdef TORRENT_USE_OPENSSL
if (is_ssl_torrent()) st->listen_port = m_ses.ssl_listen_port();
#endif
st->has_incoming = m_has_incoming;
if (m_error) st->error = convert_from_native(m_error.message()) + ": " + m_error_file;
st->seed_mode = m_seed_mode;

1
src/torrent_handle.cpp
View File

@ -141,7 +141,6 @@ namespace libtorrent
, need_save_resume(false)
, ip_filter_applies(true)
, info_hash(0)
, listen_port(0)
{}
torrent_status::~torrent_status() {}