remove whitespace at end of line (#1245)

This commit is contained in:
Arvid Norberg 2016-10-22 11:47:24 -04:00 committed by GitHub
parent 31d34fec41
commit 6148984426
58 changed files with 473 additions and 472 deletions

View File

@ -123,7 +123,7 @@ script:
- cd .. - cd ..
- 'if [ "$lint" == "1" ]; then - 'if [ "$lint" == "1" ]; then
python ~/cpplint.py --extensions=cpp --headers=hpp --filter=-,+runtime/explicit --linelength=90 test/*.{cpp,hpp} src/*.cpp include/libtorrent/*.hpp include/libtorrent/kademlia/*.hpp src/kademlia/*.cpp include/libtorrent/aux_/*.hpp include/libtorrent/extensions/*.hpp simulation/*.{cpp,hpp} tools/*.{cpp,hpp} examples/*.{cpp,hpp}; python ~/cpplint.py --extensions=cpp --headers=hpp --filter=-,+runtime/explicit,+whitespace/end_of_line --linelength=90 test/*.{cpp,hpp} src/*.cpp include/libtorrent/*.hpp include/libtorrent/kademlia/*.hpp src/kademlia/*.cpp include/libtorrent/aux_/*.hpp include/libtorrent/extensions/*.hpp simulation/*.{cpp,hpp} tools/*.{cpp,hpp} examples/*.{cpp,hpp};
fi' fi'
# if variant is not set, we do not want to build anything # if variant is not set, we do not want to build anything

View File

@ -80,8 +80,9 @@ for l in f:
mode = '' mode = ''
continue continue
if l.startswith('// '): if l.startswith('//'):
description += l[3:] if l[2] == ' ': description += l[3:]
else: description += l[2:]
continue continue
l = l.strip() l = l.strip()

View File

@ -81,7 +81,7 @@ names = []
types = [] types = []
for l in f: for l in f:
description_line = l.lstrip().startswith('// ') description_line = l.lstrip().startswith('//')
l = l.strip() l = l.strip()

View File

@ -112,10 +112,10 @@ namespace libtorrent
// if a torrent is created and seeded, or if the user already know // if a torrent is created and seeded, or if the user already know
// that the files are complete, this is a way to avoid the initial // that the files are complete, this is a way to avoid the initial
// file checks, and significantly reduce the startup time. // file checks, and significantly reduce the startup time.
// //
// Setting ``flag_seed_mode`` on a torrent without metadata (a // Setting ``flag_seed_mode`` on a torrent without metadata (a
// .torrent file) is a no-op and will be ignored. // .torrent file) is a no-op and will be ignored.
// //
// If resume data is passed in with this torrent, the seed mode saved // If resume data is passed in with this torrent, the seed mode saved
// in there will override the seed mode you set here. // in there will override the seed mode you set here.
flag_seed_mode = 0x001, flag_seed_mode = 0x001,
@ -127,7 +127,7 @@ namespace libtorrent
// periodically. This mode can be used to avoid race conditions when // periodically. This mode can be used to avoid race conditions when
// adjusting priorities of pieces before allowing the torrent to start // adjusting priorities of pieces before allowing the torrent to start
// downloading. // downloading.
// //
// If the torrent is auto-managed (``flag_auto_managed``), the torrent // If the torrent is auto-managed (``flag_auto_managed``), the torrent
// will eventually be taken out of upload-mode, regardless of how it // will eventually be taken out of upload-mode, regardless of how it
// got there. If it's important to manually control when the torrent // got there. If it's important to manually control when the torrent
@ -143,13 +143,13 @@ namespace libtorrent
// download anything. This mode is intended to be safe to add any // download anything. This mode is intended to be safe to add any
// number of torrents to, without manual screening, without the risk // number of torrents to, without manual screening, without the risk
// of downloading more than is uploaded. // of downloading more than is uploaded.
// //
// A torrent in share mode sets the priority to all pieces to 0, // A torrent in share mode sets the priority to all pieces to 0,
// except for the pieces that are downloaded, when pieces are decided // except for the pieces that are downloaded, when pieces are decided
// to be downloaded. This affects the progress bar, which might be set // to be downloaded. This affects the progress bar, which might be set
// to "100% finished" most of the time. Do not change file or piece // to "100% finished" most of the time. Do not change file or piece
// priorities for torrents in share mode, it will make it not work. // priorities for torrents in share mode, it will make it not work.
// //
// The share mode has one setting, the share ratio target, see // The share mode has one setting, the share ratio target, see
// ``settings_pack::share_mode_target`` for more info. // ``settings_pack::share_mode_target`` for more info.
flag_share_mode = 0x008, flag_share_mode = 0x008,
@ -172,13 +172,13 @@ namespace libtorrent
// may be resumed at any point, regardless of how it paused. If it's // may be resumed at any point, regardless of how it paused. If it's
// important to manually control when the torrent is paused and // important to manually control when the torrent is paused and
// resumed, don't make it auto managed. // resumed, don't make it auto managed.
// //
// If ``flag_auto_managed`` is set, the torrent will be queued, // If ``flag_auto_managed`` is set, the torrent will be queued,
// started and seeded automatically by libtorrent. When this is set, // started and seeded automatically by libtorrent. When this is set,
// the torrent should also be started as paused. The default queue // the torrent should also be started as paused. The default queue
// order is the order the torrents were added. They are all downloaded // order is the order the torrents were added. They are all downloaded
// in that order. For more details, see queuing_. // in that order. For more details, see queuing_.
// //
// If you pass in resume data, the auto_managed state of the torrent // If you pass in resume data, the auto_managed state of the torrent
// when the resume data was saved will override the auto_managed state // when the resume data was saved will override the auto_managed state
// you pass in here. You can override this by setting // you pass in here. You can override this by setting
@ -305,7 +305,7 @@ namespace libtorrent
std::string name; std::string name;
// the path where the torrent is or will be stored. // the path where the torrent is or will be stored.
// //
// .. note:: // .. note::
// On windows this path (and other paths) are interpreted as UNC // On windows this path (and other paths) are interpreted as UNC
// paths. This means they must use backslashes as directory separators // paths. This means they must use backslashes as directory separators
@ -358,7 +358,7 @@ namespace libtorrent
// flags controlling aspects of this torrent and how it's added. See // flags controlling aspects of this torrent and how it's added. See
// flags_t for details. // flags_t for details.
// //
// .. note:: // .. note::
// The ``flags`` field is initialized with default flags by the // The ``flags`` field is initialized with default flags by the
// constructor. In order to preserve default behavior when clearing or // constructor. In order to preserve default behavior when clearing or
@ -377,7 +377,7 @@ namespace libtorrent
// ``set_download_limit()`` functions on torrent_handle. These values let // ``set_download_limit()`` functions on torrent_handle. These values let
// you initialize these settings when the torrent is added, instead of // you initialize these settings when the torrent is added, instead of
// calling these functions immediately following adding it. // calling these functions immediately following adding it.
// //
// -1 means unlimited on these settings just like their counterpart // -1 means unlimited on these settings just like their counterpart
// functions on torrent_handle // functions on torrent_handle
int max_uploads; int max_uploads;
@ -418,7 +418,7 @@ namespace libtorrent
// every piece. ``num_downloaded`` is the number of times the torrent has // every piece. ``num_downloaded`` is the number of times the torrent has
// been downloaded (not initiated, but the number of times a download has // been downloaded (not initiated, but the number of times a download has
// completed). // completed).
// //
// Leaving any of these values set to -1 indicates we don't know, or we // Leaving any of these values set to -1 indicates we don't know, or we
// have not received any scrape data. // have not received any scrape data.
int num_complete; int num_complete;
@ -429,10 +429,10 @@ namespace libtorrent
// seeds to be used by the torrent. If the ``flag_override_web_seeds`` // seeds to be used by the torrent. If the ``flag_override_web_seeds``
// is set, these will be the _only_ ones to be used. i.e. any web seeds // is set, these will be the _only_ ones to be used. i.e. any web seeds
// found in the .torrent file will be overridden. // found in the .torrent file will be overridden.
// //
// http_seeds expects URLs to web servers implementing the original HTTP // http_seeds expects URLs to web servers implementing the original HTTP
// seed specification `BEP 17`_. // seed specification `BEP 17`_.
// //
// url_seeds expects URLs to regular web servers, aka "get right" style, // url_seeds expects URLs to regular web servers, aka "get right" style,
// specified in `BEP 19`_. // specified in `BEP 19`_.
std::vector<std::string> http_seeds; std::vector<std::string> http_seeds;

View File

@ -40,18 +40,18 @@ POSSIBILITY OF SUCH DAMAGE.
// The pop_alerts() function on session is the main interface for retrieving // The pop_alerts() function on session is the main interface for retrieving
// alerts (warnings, messages and errors from libtorrent). If no alerts have // alerts (warnings, messages and errors from libtorrent). If no alerts have
// been posted by libtorrent pop_alerts() will return an empty list. // been posted by libtorrent pop_alerts() will return an empty list.
// //
// By default, only errors are reported. settings_pack::alert_mask can be // By default, only errors are reported. settings_pack::alert_mask can be
// used to specify which kinds of events should be reported. The alert mask is // used to specify which kinds of events should be reported. The alert mask is
// comprised by bits from the category_t enum. // comprised by bits from the category_t enum.
// //
// Every alert belongs to one or more category. There is a cost associated with // Every alert belongs to one or more category. There is a cost associated with
// posting alerts. Only alerts that belong to an enabled category are // posting alerts. Only alerts that belong to an enabled category are
// posted. Setting the alert bitmask to 0 will disable all alerts (except those // posted. Setting the alert bitmask to 0 will disable all alerts (except those
// that are non-discardable). Alerts that are responses to API calls such as // that are non-discardable). Alerts that are responses to API calls such as
// save_resume_data() and post_session_stats() are non-discardable and will be // save_resume_data() and post_session_stats() are non-discardable and will be
// posted even if their category is disabled. // posted even if their category is disabled.
// //
// There are other alert base classes that some alerts derive from, all the // There are other alert base classes that some alerts derive from, all the
// alerts that are generated for a specific torrent are derived from // alerts that are generated for a specific torrent are derived from
// torrent_alert, and tracker events derive from tracker_alert. // torrent_alert, and tracker events derive from tracker_alert.
@ -88,7 +88,7 @@ namespace libtorrent {
enum category_t enum category_t
{ {
// Enables alerts that report an error. This includes: // Enables alerts that report an error. This includes:
// //
// * tracker errors // * tracker errors
// * tracker warnings // * tracker warnings
// * file errors // * file errors
@ -202,7 +202,7 @@ namespace libtorrent {
// compared against a specific alert by querying a static constant called ``alert_type`` // compared against a specific alert by querying a static constant called ``alert_type``
// in the alert. It can be used to determine the run-time type of an alert* in // in the alert. It can be used to determine the run-time type of an alert* in
// order to cast to that alert type and access specific members. // order to cast to that alert type and access specific members.
// //
// e.g: // e.g:
// //
// .. code:: c++ // .. code:: c++
@ -211,7 +211,7 @@ namespace libtorrent {
// ses.pop_alerts(&alerts); // ses.pop_alerts(&alerts);
// for (alert* i : alerts) { // for (alert* i : alerts) {
// switch (a->type()) { // switch (a->type()) {
// //
// case read_piece_alert::alert_type: // case read_piece_alert::alert_type:
// { // {
// read_piece_alert* p = (read_piece_alert*)a; // read_piece_alert* p = (read_piece_alert*)a;
@ -268,7 +268,7 @@ namespace libtorrent {
// When you get an alert, you can use ``alert_cast<>`` to attempt to cast the // When you get an alert, you can use ``alert_cast<>`` to attempt to cast the
// pointer to a specific alert type, in order to query it for more // pointer to a specific alert type, in order to query it for more
// information. // information.
// //
// .. note:: // .. note::
// ``alert_cast<>`` can only cast to an exact alert type, not a base class // ``alert_cast<>`` can only cast to an exact alert type, not a base class
template <class T> T* alert_cast(alert* a) template <class T> T* alert_cast(alert* a)

View File

@ -185,11 +185,11 @@ namespace libtorrent
// the torrent handle in its base class will always be invalid (since the torrent // the torrent handle in its base class will always be invalid (since the torrent
// is already removed) it has the info hash as a member, to identify it. // is already removed) it has the info hash as a member, to identify it.
// It's posted when the ``status_notification`` bit is set in the alert_mask. // It's posted when the ``status_notification`` bit is set in the alert_mask.
// //
// Even though the ``handle`` member doesn't point to an existing torrent anymore, // Even though the ``handle`` member doesn't point to an existing torrent anymore,
// it is still useful for comparing to other handles, which may also no // it is still useful for comparing to other handles, which may also no
// longer point to existing torrents, but to the same non-existing torrents. // longer point to existing torrents, but to the same non-existing torrents.
// //
// The ``torrent_handle`` acts as a ``weak_ptr``, even though its object no // The ``torrent_handle`` acts as a ``weak_ptr``, even though its object no
// longer exists, it can still compare equal to another weak pointer which // longer exists, it can still compare equal to another weak pointer which
// points to the same non-existent object. // points to the same non-existent object.
@ -211,7 +211,7 @@ namespace libtorrent
// is 0. If successful, ``buffer`` points to a buffer containing all the data // is 0. If successful, ``buffer`` points to a buffer containing all the data
// of the piece. ``piece`` is the piece index that was read. ``size`` is the // of the piece. ``piece`` is the piece index that was read. ``size`` is the
// number of bytes that was read. // number of bytes that was read.
// //
// If the operation fails, ``error`` will indicate what went wrong. // If the operation fails, ``error`` will indicate what went wrong.
struct TORRENT_EXPORT read_piece_alert final : torrent_alert struct TORRENT_EXPORT read_piece_alert final : torrent_alert
{ {
@ -350,9 +350,9 @@ namespace libtorrent
// send it all before the disk gets back to us. // send it all before the disk gets back to us.
// The number of bytes that we keep outstanding, requested from the disk, is calculated // The number of bytes that we keep outstanding, requested from the disk, is calculated
// as follows:: // as follows::
// //
// min(512, max(upload_rate * send_buffer_watermark_factor / 100, send_buffer_watermark)) // min(512, max(upload_rate * send_buffer_watermark_factor / 100, send_buffer_watermark))
// //
// If you receive this alert, you might want to either increase your ``send_buffer_watermark`` // If you receive this alert, you might want to either increase your ``send_buffer_watermark``
// or ``send_buffer_watermark_factor``. // or ``send_buffer_watermark_factor``.
send_buffer_watermark_too_low, send_buffer_watermark_too_low,
@ -927,12 +927,12 @@ namespace libtorrent
}; };
// This alert is generated when a request to delete the files of a torrent complete. // This alert is generated when a request to delete the files of a torrent complete.
// //
// The ``info_hash`` is the info-hash of the torrent that was just deleted. Most of // The ``info_hash`` is the info-hash of the torrent that was just deleted. Most of
// the time the torrent_handle in the ``torrent_alert`` will be invalid by the time // the time the torrent_handle in the ``torrent_alert`` will be invalid by the time
// this alert arrives, since the torrent is being deleted. The ``info_hash`` member // this alert arrives, since the torrent is being deleted. The ``info_hash`` member
// is hence the main way of identifying which torrent just completed the delete. // is hence the main way of identifying which torrent just completed the delete.
// //
// This alert is posted in the ``storage_notification`` category, and that bit // This alert is posted in the ``storage_notification`` category, and that bit
// needs to be set in the alert_mask. // needs to be set in the alert_mask.
struct TORRENT_EXPORT torrent_deleted_alert final : torrent_alert struct TORRENT_EXPORT torrent_deleted_alert final : torrent_alert
@ -1149,13 +1149,13 @@ namespace libtorrent
// This alert is generated when the metadata has been completely received and the torrent // This alert is generated when the metadata has been completely received and the torrent
// can start downloading. It is not generated on torrents that are started with metadata, but // can start downloading. It is not generated on torrents that are started with metadata, but
// only those that needs to download it from peers (when utilizing the libtorrent extension). // only those that needs to download it from peers (when utilizing the libtorrent extension).
// //
// There are no additional data members in this alert. // There are no additional data members in this alert.
// //
// Typically, when receiving this alert, you would want to save the torrent file in order // Typically, when receiving this alert, you would want to save the torrent file in order
// to load it back up again when the session is restarted. Here's an example snippet of // to load it back up again when the session is restarted. Here's an example snippet of
// code to do that:: // code to do that::
// //
// torrent_handle h = alert->handle(); // torrent_handle h = alert->handle();
// if (h.is_valid()) { // if (h.is_valid()) {
// std::shared_ptr<torrent_info const> ti = h.torrent_file(); // std::shared_ptr<torrent_info const> ti = h.torrent_file();
@ -1169,7 +1169,7 @@ namespace libtorrent
// fclose(f); // fclose(f);
// } // }
// } // }
// //
struct TORRENT_EXPORT metadata_received_alert final : torrent_alert struct TORRENT_EXPORT metadata_received_alert final : torrent_alert
{ {
// internal // internal
@ -1494,7 +1494,7 @@ namespace libtorrent
// This alert is posted when an incoming peer connection, or a peer that's about to be added // This alert is posted when an incoming peer connection, or a peer that's about to be added
// to our peer list, is blocked for some reason. This could be any of: // to our peer list, is blocked for some reason. This could be any of:
// //
// * the IP filter // * the IP filter
// * i2p mixed mode restrictions (a normal peer is not allowed on an i2p swarm) // * i2p mixed mode restrictions (a normal peer is not allowed on an i2p swarm)
// * the port filter // * the port filter
@ -1769,7 +1769,7 @@ namespace libtorrent
// tells you what kind of socket the connection was accepted // tells you what kind of socket the connection was accepted
// as: // as:
// //
// 0. none (no socket instantiated) // 0. none (no socket instantiated)
// 1. TCP // 1. TCP
// 2. Socks5 // 2. Socks5
@ -1780,7 +1780,7 @@ namespace libtorrent
// 7. SSL/Socks5 // 7. SSL/Socks5
// 8. HTTPS (SSL/HTTP) // 8. HTTPS (SSL/HTTP)
// 9. SSL/uTP // 9. SSL/uTP
// //
int const socket_type; int const socket_type;
// is the IP address and port the connection came from. // is the IP address and port the connection came from.
@ -1880,7 +1880,7 @@ namespace libtorrent
// happens in very specific cases. For instance, when a torrent is // happens in very specific cases. For instance, when a torrent is
// downloaded from a URL, the true info hash is not known immediately. First // downloaded from a URL, the true info hash is not known immediately. First
// the .torrent file must be downloaded and parsed. // the .torrent file must be downloaded and parsed.
// //
// Once this download completes, the ``torrent_update_alert`` is posted to // Once this download completes, the ``torrent_update_alert`` is posted to
// notify the client of the info-hash changing. // notify the client of the info-hash changing.
struct TORRENT_EXPORT torrent_update_alert final : torrent_alert struct TORRENT_EXPORT torrent_update_alert final : torrent_alert

View File

@ -72,7 +72,7 @@ namespace libtorrent
// returns the number of seconds to the next announce on this tracker. // returns the number of seconds to the next announce on this tracker.
// ``min_announce_in()`` returns the number of seconds until we are // ``min_announce_in()`` returns the number of seconds until we are
// allowed to force another tracker update with this tracker. // allowed to force another tracker update with this tracker.
// //
// If the last time this tracker was contacted failed, ``last_error`` is // If the last time this tracker was contacted failed, ``last_error`` is
// the error code describing what error occurred. // the error code describing what error occurred.
int next_announce_in() const; int next_announce_in() const;

View File

@ -224,11 +224,11 @@ struct bdecode_token
// a ``bdecode_node`` is used to traverse and hold the tree structure defined // a ``bdecode_node`` is used to traverse and hold the tree structure defined
// by bencoded data after it has been parse by bdecode(). // by bencoded data after it has been parse by bdecode().
// //
// There are primarily two kinds of bdecode_nodes. The ones that own the tree // There are primarily two kinds of bdecode_nodes. The ones that own the tree
// structure, and defines its lifetime, and nodes that are child nodes in the // structure, and defines its lifetime, and nodes that are child nodes in the
// tree, pointing back into the root's tree. // tree, pointing back into the root's tree.
// //
// The ``bdecode_node`` passed in to ``bdecode()`` becomes the one owning the // The ``bdecode_node`` passed in to ``bdecode()`` becomes the one owning the
// tree structure. Make sure not to destruct that object for as long as you // tree structure. Make sure not to destruct that object for as long as you
// use any of its child nodes. Also, keep in mind that the buffer originally // use any of its child nodes. Also, keep in mind that the buffer originally
@ -307,7 +307,7 @@ struct TORRENT_EXPORT bdecode_node
// but have to use ``std::string`` instead. ``dict_find_list`` will return a // but have to use ``std::string`` instead. ``dict_find_list`` will return a
// valid ``bdecode_node`` if the key is found _and_ it is a list. Otherwise // valid ``bdecode_node`` if the key is found _and_ it is a list. Otherwise
// it will return a default-constructed bdecode_node. // it will return a default-constructed bdecode_node.
// //
// Functions with the ``_value`` suffix return the value of the node // Functions with the ``_value`` suffix return the value of the node
// directly, rather than the nodes. In case the node is not found, or it has // directly, rather than the nodes. In case the node is not found, or it has
// a different type, a default value is returned (which can be specified). // a different type, a default value is returned (which can be specified).
@ -397,20 +397,20 @@ TORRENT_EXPORT std::string print_entry(bdecode_node const& e
// non-zero value and fills in ``ec`` with the error code. The optional // non-zero value and fills in ``ec`` with the error code. The optional
// argument ``error_pos``, if set to non-nullptr, will be set to the byte offset // argument ``error_pos``, if set to non-nullptr, will be set to the byte offset
// into the buffer where the parse failure occurred. // into the buffer where the parse failure occurred.
// //
// ``depth_limit`` specifies the max number of nested lists or dictionaries are // ``depth_limit`` specifies the max number of nested lists or dictionaries are
// allowed in the data structure. (This affects the stack usage of the // allowed in the data structure. (This affects the stack usage of the
// function, be careful not to set it too high). // function, be careful not to set it too high).
// //
// ``token_limit`` is the max number of tokens allowed to be parsed from the // ``token_limit`` is the max number of tokens allowed to be parsed from the
// buffer. This is simply a sanity check to not have unbounded memory usage. // buffer. This is simply a sanity check to not have unbounded memory usage.
// //
// The resulting ``bdecode_node`` is an *owning* node. That means it will // The resulting ``bdecode_node`` is an *owning* node. That means it will
// be holding the whole parsed tree. When iterating lists and dictionaries, // be holding the whole parsed tree. When iterating lists and dictionaries,
// those ``bdecode_node`` objects will simply have references to the root or // those ``bdecode_node`` objects will simply have references to the root or
// owning ``bdecode_node``. If the root node is destructed, all other nodes // owning ``bdecode_node``. If the root node is destructed, all other nodes
// that refer to anything in that tree become invalid. // that refer to anything in that tree become invalid.
// //
// However, the underlying buffer passed in to this function (``start``, ``end``) // However, the underlying buffer passed in to this function (``start``, ``end``)
// must also remain valid while the bdecoded tree is used. The parsed tree // must also remain valid while the bdecoded tree is used. The parsed tree
// produced by this function does not copy any data out of the buffer, but // produced by this function does not copy any data out of the buffer, but

View File

@ -34,7 +34,7 @@ POSSIBILITY OF SUCH DAMAGE.
#define TORRENT_BENCODE_HPP_INCLUDED #define TORRENT_BENCODE_HPP_INCLUDED
// OVERVIEW // OVERVIEW
// //
// Bencoding is a common representation in bittorrent used for for dictionary, // Bencoding is a common representation in bittorrent used for for dictionary,
// list, int and string hierarchies. It's used to encode .torrent files and // list, int and string hierarchies. It's used to encode .torrent files and
// some messages in the network protocol. libtorrent also uses it to store // some messages in the network protocol. libtorrent also uses it to store
@ -367,15 +367,15 @@ namespace libtorrent
} }
// These functions will encode data to bencoded or decode bencoded data. // These functions will encode data to bencoded or decode bencoded data.
// //
// If possible, ``bdecode()`` producing a bdecode_node should be preferred // If possible, ``bdecode()`` producing a bdecode_node should be preferred
// over this function. // over this function.
// //
// The entry_ class is the internal representation of the bencoded data // The entry_ class is the internal representation of the bencoded data
// and it can be used to retrieve information, an entry_ can also be build by // and it can be used to retrieve information, an entry_ can also be build by
// the program and given to ``bencode()`` to encode it into the ``OutIt`` // the program and given to ``bencode()`` to encode it into the ``OutIt``
// iterator. // iterator.
// //
// The ``OutIt`` and ``InIt`` are iterators // The ``OutIt`` and ``InIt`` are iterators
// (InputIterator_ and OutputIterator_ respectively). They // (InputIterator_ and OutputIterator_ respectively). They
// are templates and are usually instantiated as ostream_iterator_, // are templates and are usually instantiated as ostream_iterator_,
@ -383,30 +383,30 @@ namespace libtorrent
// functions will assume that the iterator refers to a character // functions will assume that the iterator refers to a character
// (``char``). So, if you want to encode entry ``e`` into a buffer // (``char``). So, if you want to encode entry ``e`` into a buffer
// in memory, you can do it like this:: // in memory, you can do it like this::
// //
// std::vector<char> buffer; // std::vector<char> buffer;
// bencode(std::back_inserter(buf), e); // bencode(std::back_inserter(buf), e);
// //
// .. _InputIterator: http://www.sgi.com/tech/stl/InputIterator.html // .. _InputIterator: http://www.sgi.com/tech/stl/InputIterator.html
// .. _OutputIterator: http://www.sgi.com/tech/stl/OutputIterator.html // .. _OutputIterator: http://www.sgi.com/tech/stl/OutputIterator.html
// .. _ostream_iterator: http://www.sgi.com/tech/stl/ostream_iterator.html // .. _ostream_iterator: http://www.sgi.com/tech/stl/ostream_iterator.html
// .. _back_insert_iterator: http://www.sgi.com/tech/stl/back_insert_iterator.html // .. _back_insert_iterator: http://www.sgi.com/tech/stl/back_insert_iterator.html
// .. _istream_iterator: http://www.sgi.com/tech/stl/istream_iterator.html // .. _istream_iterator: http://www.sgi.com/tech/stl/istream_iterator.html
// //
// If you want to decode a torrent file from a buffer in memory, you can do it like this:: // If you want to decode a torrent file from a buffer in memory, you can do it like this::
// //
// std::vector<char> buffer; // std::vector<char> buffer;
// // ... // // ...
// entry e = bdecode(buf.begin(), buf.end()); // entry e = bdecode(buf.begin(), buf.end());
// //
// Or, if you have a raw char buffer:: // Or, if you have a raw char buffer::
// //
// const char* buf; // const char* buf;
// // ... // // ...
// entry e = bdecode(buf, buf + data_size); // entry e = bdecode(buf, buf + data_size);
// //
// Now we just need to know how to retrieve information from the entry. // Now we just need to know how to retrieve information from the entry.
// //
// If ``bdecode()`` encounters invalid encoded data in the range given to it // If ``bdecode()`` encounters invalid encoded data in the range given to it
// it will return a default constructed ``entry`` object. // it will return a default constructed ``entry`` object.
template<class OutIt> int bencode(OutIt out, const entry& e) template<class OutIt> int bencode(OutIt out, const entry& e)

View File

@ -142,5 +142,5 @@ namespace libtorrent
bool m_abort; bool m_abort;
}; };
} }
#endif #endif

View File

@ -54,7 +54,7 @@ POSSIBILITY OF SUCH DAMAGE.
// to create torrent files. It is a layered API with low level classes // to create torrent files. It is a layered API with low level classes
// and higher level convenience functions. A torrent is created in 4 // and higher level convenience functions. A torrent is created in 4
// steps: // steps:
// //
// 1. first the files that will be part of the torrent are determined. // 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, // 2. the torrent properties are set, such as tracker url, web seeds,
// DHT nodes etc. // DHT nodes etc.
@ -64,22 +64,22 @@ POSSIBILITY OF SUCH DAMAGE.
// //
// If there are a lot of files and or deep directory hierarchies to // If there are a lot of files and or deep directory hierarchies to
// traverse, step one can be time consuming. // traverse, step one can be time consuming.
// //
// Typically step 3 is by far the most time consuming step, since it // Typically step 3 is by far the most time consuming step, since it
// requires to read all the bytes from all the files in the torrent. // requires to read all the bytes from all the files in the torrent.
// //
// All of these classes and functions are declared by including // All of these classes and functions are declared by including
// ``libtorrent/create_torrent.hpp``. // ``libtorrent/create_torrent.hpp``.
// //
// example: // example:
// //
// .. code:: c++ // .. code:: c++
// //
// file_storage fs; // file_storage fs;
// //
// // recursively adds files in directories // // recursively adds files in directories
// add_files(fs, "./my_torrent"); // add_files(fs, "./my_torrent");
// //
// create_torrent t(fs); // create_torrent t(fs);
// t.add_tracker("http://my.tracker.com/announce"); // t.add_tracker("http://my.tracker.com/announce");
// t.set_creator("libtorrent example"); // t.set_creator("libtorrent example");
@ -89,7 +89,7 @@ POSSIBILITY OF SUCH DAMAGE.
// //
// ofstream out("my_torrent.torrent", std::ios_base::binary); // ofstream out("my_torrent.torrent", std::ios_base::binary);
// bencode(std::ostream_iterator<char>(out), t.generate()); // bencode(std::ostream_iterator<char>(out), t.generate());
// //
namespace libtorrent namespace libtorrent
{ {
class torrent_info; class torrent_info;
@ -140,7 +140,7 @@ namespace libtorrent
// to create a torrent that can be updated via a *mutable torrent* // to create a torrent that can be updated via a *mutable torrent*
// (see BEP38_). This also needs to be enabled for torrents that update // (see BEP38_). This also needs to be enabled for torrents that update
// another torrent. // another torrent.
// //
// .. _BEP38: http://www.bittorrent.org/beps/bep_0038.html // .. _BEP38: http://www.bittorrent.org/beps/bep_0038.html
mutable_torrent_support = 16 mutable_torrent_support = 16
}; };
@ -148,23 +148,23 @@ namespace libtorrent
// The ``piece_size`` is the size of each piece in bytes. It must // The ``piece_size`` is the size of each piece in bytes. It must
// be a multiple of 16 kiB. If a piece size of 0 is specified, a // be a multiple of 16 kiB. If a piece size of 0 is specified, a
// piece_size will be calculated such that the torrent file is roughly 40 kB. // piece_size will be calculated such that the torrent file is roughly 40 kB.
// //
// If a ``pad_file_limit`` is specified (other than -1), any file larger than // If a ``pad_file_limit`` is specified (other than -1), any file larger than
// the specified number of bytes will be preceded by a pad file to align it // the specified number of bytes will be preceded by a pad file to align it
// with the start of a piece. The pad_file_limit is ignored unless the // with the start of a piece. The pad_file_limit is ignored unless the
// ``optimize_alignment`` flag is passed. Typically it doesn't make sense // ``optimize_alignment`` flag is passed. Typically it doesn't make sense
// to set this any lower than 4kiB. // to set this any lower than 4kiB.
// //
// The overload that takes a ``torrent_info`` object will make a verbatim // The overload that takes a ``torrent_info`` object will make a verbatim
// copy of its info dictionary (to preserve the info-hash). The copy of // copy of its info dictionary (to preserve the info-hash). The copy of
// the info dictionary will be used by create_torrent::generate(). This means // the info dictionary will be used by create_torrent::generate(). This means
// that none of the member functions of create_torrent that affects // that none of the member functions of create_torrent that affects
// the content of the info dictionary (such as ``set_hash()``), will // the content of the info dictionary (such as ``set_hash()``), will
// have any affect. // have any affect.
// //
// The ``flags`` arguments specifies options for the torrent creation. It can // The ``flags`` arguments specifies options for the torrent creation. It can
// be any combination of the flags defined by create_torrent::flags_t. // be any combination of the flags defined by create_torrent::flags_t.
// //
// ``alignment`` is used when pad files are enabled. This is the size // ``alignment`` is used when pad files are enabled. This is the size
// eligible files are aligned to. The default is -1, which means the // eligible files are aligned to. The default is -1, which means the
// piece size of the torrent. // piece size of the torrent.
@ -178,16 +178,16 @@ namespace libtorrent
// This function will generate the .torrent file as a bencode tree. In order to // This function will generate the .torrent file as a bencode tree. In order to
// generate the flat file, use the bencode() function. // generate the flat file, use the bencode() function.
// //
// It may be useful to add custom entries to the torrent file before bencoding it // It may be useful to add custom entries to the torrent file before bencoding it
// and saving it to disk. // and saving it to disk.
// //
// If anything goes wrong during torrent generation, this function will return // If anything goes wrong during torrent generation, this function will return
// an empty ``entry`` structure. You can test for this condition by querying the // an empty ``entry`` structure. You can test for this condition by querying the
// type of the entry: // type of the entry:
// //
// .. code:: c++ // .. code:: c++
// //
// file_storage fs; // file_storage fs;
// // add file ... // // add file ...
// create_torrent t(fs); // create_torrent t(fs);
@ -198,7 +198,7 @@ namespace libtorrent
// { // {
// // something went wrong // // something went wrong
// } // }
// //
// For instance, you cannot generate a torrent with 0 files in it. If you don't add // For instance, you cannot generate a torrent with 0 files in it. If you don't add
// any files to the ``file_storage``, torrent generation will fail. // any files to the ``file_storage``, torrent generation will fail.
entry generate() const; entry generate() const;
@ -231,7 +231,7 @@ namespace libtorrent
// content as the file of the torrent. For a multi-file torrent, it should point to // 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 // a directory containing a directory with the same name as this torrent, and all the
// files of the torrent in it. // files of the torrent in it.
// //
// The second function, ``add_http_seed()`` adds an HTTP seed instead. // The second function, ``add_http_seed()`` adds an HTTP seed instead.
void add_url_seed(string_view url); void add_url_seed(string_view url);
void add_http_seed(string_view url); void add_http_seed(string_view url);
@ -254,7 +254,7 @@ namespace libtorrent
// torrent an *SSL torrent*. An SSL torrent requires that each peer has a valid certificate // torrent an *SSL torrent*. An SSL torrent requires that each peer has a valid certificate
// signed by this root certificate. For SSL torrents, all peers are connecting over SSL // signed by this root certificate. For SSL torrents, all peers are connecting over SSL
// connections. For more information, see the section on ssl-torrents_. // connections. For more information, see the section on ssl-torrents_.
// //
// The string is not the path to the cert, it's the actual content of the // The string is not the path to the cert, it's the actual content of the
// certificate. // certificate.
void set_root_cert(string_view pem); void set_root_cert(string_view pem);
@ -289,7 +289,7 @@ namespace libtorrent
// to share files with this torrent. A torrent may have more than one // to share files with this torrent. A torrent may have more than one
// collection and more than one similar torrents. For more information, // collection and more than one similar torrents. For more information,
// see `BEP 38`_. // see `BEP 38`_.
// //
// .. _`BEP 38`: http://www.bittorrent.org/beps/bep_0038.html // .. _`BEP 38`: http://www.bittorrent.org/beps/bep_0038.html
void add_similar_torrent(sha1_hash ih); void add_similar_torrent(sha1_hash ih);
void add_collection(string_view c); void add_collection(string_view c);
@ -352,7 +352,7 @@ namespace libtorrent
// or not. e.g. test/test there's one file and one directory // or not. e.g. test/test there's one file and one directory
// and they have the same name. // and they have the same name.
bool m_multifile:1; bool m_multifile:1;
// this is true if the torrent is private. i.e., is should not // this is true if the torrent is private. i.e., is should not
// be announced on the dht // be announced on the dht
bool m_private:1; bool m_private:1;
@ -377,33 +377,33 @@ namespace libtorrent
// Adds the file specified by ``path`` to the file_storage object. In case ``path`` // Adds the file specified by ``path`` to the file_storage object. In case ``path``
// refers to a directory, files will be added recursively from the directory. // refers to a directory, files will be added recursively from the directory.
// //
// If specified, the predicate ``p`` is called once for every file and directory that // If specified, the predicate ``p`` is called once for every file and directory that
// is encountered. Files for which ``p`` returns true are added, and directories for // is encountered. Files for which ``p`` returns true are added, and directories for
// which ``p`` returns true are traversed. ``p`` must have the following signature:: // which ``p`` returns true are traversed. ``p`` must have the following signature::
// //
// bool Pred(std::string const& p); // bool Pred(std::string const& p);
// //
// The path that is passed in to the predicate is the full path of the file or // The path that is passed in to the predicate is the full path of the file or
// directory. If no predicate is specified, all files are added, and all directories // directory. If no predicate is specified, all files are added, and all directories
// are traversed. // are traversed.
// //
// The ".." directory is never traversed. // The ".." directory is never traversed.
// //
// The ``flags`` argument should be the same as the flags passed to the `create_torrent`_ // The ``flags`` argument should be the same as the flags passed to the `create_torrent`_
// constructor. // constructor.
TORRENT_EXPORT void add_files(file_storage& fs, std::string const& file TORRENT_EXPORT void add_files(file_storage& fs, std::string const& file
, std::function<bool(std::string)> p, std::uint32_t flags = 0); , std::function<bool(std::string)> p, std::uint32_t flags = 0);
TORRENT_EXPORT void add_files(file_storage& fs, std::string const& file TORRENT_EXPORT void add_files(file_storage& fs, std::string const& file
, std::uint32_t flags = 0); , std::uint32_t flags = 0);
// This function will assume that the files added to the torrent file exists at path // 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`` // ``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`` // object. The optional function ``f`` is called in between every hash that is set. ``f``
// must have the following signature:: // must have the following signature::
// //
// void Fun(int); // void Fun(int);
// //
// The overloads that don't take an ``error_code&`` may throw an exception in case of a // The overloads that don't take an ``error_code&`` may throw an exception in case of a
// file error, the other overloads sets the error code to reflect the error, if any. // file error, the other overloads sets the error code to reflect the error, if any.
TORRENT_EXPORT void set_piece_hashes(create_torrent& t, std::string const& p TORRENT_EXPORT void set_piece_hashes(create_torrent& t, std::string const& p
@ -443,7 +443,7 @@ namespace libtorrent
TORRENT_DEPRECATED TORRENT_DEPRECATED
TORRENT_EXPORT void add_files(file_storage& fs, std::wstring const& wfile TORRENT_EXPORT void add_files(file_storage& fs, std::wstring const& wfile
, std::uint32_t flags = 0); , std::uint32_t flags = 0);
TORRENT_DEPRECATED TORRENT_DEPRECATED
TORRENT_EXPORT void set_piece_hashes(create_torrent& t, std::wstring const& p TORRENT_EXPORT void set_piece_hashes(create_torrent& t, std::wstring const& p
, std::function<void(int)> f, error_code& ec); , std::function<void(int)> f, error_code& ec);
@ -478,7 +478,7 @@ namespace libtorrent
, std::wstring const& p, error_code& ec) , std::wstring const& p, error_code& ec)
{ {
set_piece_hashes_deprecated(t, p, detail::nop, ec); set_piece_hashes_deprecated(t, p, detail::nop, ec);
} }
#endif // TORRENT_NO_DEPRECATE #endif // TORRENT_NO_DEPRECATE
#endif // TORRENT_USE_WSTRING #endif // TORRENT_USE_WSTRING

View File

@ -60,7 +60,7 @@ namespace libtorrent
// The disk buffer holder acts like a ``unique_ptr`` that frees a disk buffer // The disk buffer holder acts like a ``unique_ptr`` that frees a disk buffer
// when it's destructed, unless it's released. ``release`` returns the disk // when it's destructed, unless it's released. ``release`` returns the disk
// buffer and transfers ownership and responsibility to free it to the caller. // buffer and transfers ownership and responsibility to free it to the caller.
// //
// ``get()`` returns the pointer without transferring ownership. If // ``get()`` returns the pointer without transferring ownership. If
// this buffer has been released, ``get()`` will return nullptr. // this buffer has been released, ``get()`` will return nullptr.
struct TORRENT_EXTRA_EXPORT disk_buffer_holder struct TORRENT_EXTRA_EXPORT disk_buffer_holder

View File

@ -150,7 +150,7 @@ namespace libtorrent
// the total number of write operations performed since this // the total number of write operations performed since this
// session was started. // session was started.
// //
// The ratio (``blocks_written`` - ``writes``) / ``blocks_written`` represents // The ratio (``blocks_written`` - ``writes``) / ``blocks_written`` represents
// the number of saved write operations per total write operations. i.e. a kind // the number of saved write operations per total write operations. i.e. a kind
// of cache hit ratio for the write cahe. // of cache hit ratio for the write cahe.

View File

@ -204,20 +204,20 @@ namespace libtorrent
// isn't of the type you request, the accessor will throw // isn't of the type you request, the accessor will throw
// system_error. You can ask an ``entry`` for its type through the // system_error. You can ask an ``entry`` for its type through the
// ``type()`` function. // ``type()`` function.
// //
// If you want to create an ``entry`` you give it the type you want it to // If you want to create an ``entry`` you give it the type you want it to
// have in its constructor, and then use one of the non-const accessors // have in its constructor, and then use one of the non-const accessors
// to get a reference which you then can assign the value you want it to // to get a reference which you then can assign the value you want it to
// have. // have.
// //
// The typical code to get info from a torrent file will then look like // The typical code to get info from a torrent file will then look like
// this: // this:
// //
// .. code:: c++ // .. code:: c++
// //
// entry torrent_file; // entry torrent_file;
// // ... // // ...
// //
// // throws if this is not a dictionary // // throws if this is not a dictionary
// entry::dictionary_type const& dict = torrent_file.dict(); // entry::dictionary_type const& dict = torrent_file.dict();
// entry::dictionary_type::const_iterator i; // entry::dictionary_type::const_iterator i;
@ -227,23 +227,23 @@ namespace libtorrent
// std::string tracker_url = i->second.string(); // std::string tracker_url = i->second.string();
// std::cout << tracker_url << "\n"; // std::cout << tracker_url << "\n";
// } // }
// //
// //
// The following code is equivalent, but a little bit shorter: // The following code is equivalent, but a little bit shorter:
// //
// .. code:: c++ // .. code:: c++
// //
// entry torrent_file; // entry torrent_file;
// // ... // // ...
// //
// // throws if this is not a dictionary // // throws if this is not a dictionary
// if (entry* i = torrent_file.find_key("announce")) // if (entry* i = torrent_file.find_key("announce"))
// { // {
// std::string tracker_url = i->string(); // std::string tracker_url = i->string();
// std::cout << tracker_url << "\n"; // std::cout << tracker_url << "\n";
// } // }
// //
// //
// To make it easier to extract information from a torrent file, the // To make it easier to extract information from a torrent file, the
// class torrent_info exists. // class torrent_info exists.
integer_type& integer(); integer_type& integer();

View File

@ -34,14 +34,14 @@ POSSIBILITY OF SUCH DAMAGE.
#define TORRENT_EXTENSIONS_HPP_INCLUDED #define TORRENT_EXTENSIONS_HPP_INCLUDED
// OVERVIEW // OVERVIEW
// //
// libtorrent has a plugin interface for implementing extensions to the protocol. // libtorrent has a plugin interface for implementing extensions to the protocol.
// These can be general extensions for transferring metadata or peer exchange // 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 // extensions, or it could be used to provide a way to customize the protocol
// to fit a particular (closed) network. // to fit a particular (closed) network.
// //
// In short, the plugin interface makes it possible to: // In short, the plugin interface makes it possible to:
// //
// * register extension messages (sent in the extension handshake), see // * register extension messages (sent in the extension handshake), see
// extensions_. // extensions_.
// * add data and parse data from the extension handshake. // * add data and parse data from the extension handshake.
@ -49,16 +49,16 @@ POSSIBILITY OF SUCH DAMAGE.
// * override or block the handling of standard bittorrent messages. // * override or block the handling of standard bittorrent messages.
// * save and restore state via the session state // * save and restore state via the session state
// * see all alerts that are posted // * see all alerts that are posted
// //
// .. _extensions: extension_protocol.html // .. _extensions: extension_protocol.html
// //
// a word of caution // a word of caution
// ----------------- // -----------------
// //
// Writing your own plugin is a very easy way to introduce serious bugs such as // Writing your own plugin is a very easy way to introduce serious bugs such as
// dead locks and race conditions. Since a plugin has access to internal // dead locks and race conditions. Since a plugin has access to internal
// structures it is also quite easy to sabotage libtorrent's operation. // structures it is also quite easy to sabotage libtorrent's operation.
// //
// All the callbacks are always called from the libtorrent network thread. In // All the callbacks are always called from the libtorrent network thread. In
// case portions of your plugin are called from other threads, typically the main // case portions of your plugin are called from other threads, typically the main
// thread, you cannot use any of the member functions on the internal structures // thread, you cannot use any of the member functions on the internal structures
@ -67,91 +67,91 @@ POSSIBILITY OF SUCH DAMAGE.
// sure it is not accessed at the same time from the libtorrent thread (through a // sure it is not accessed at the same time from the libtorrent thread (through a
// callback). If you need to send out a message from another thread, it is // callback). If you need to send out a message from another thread, it is
// advised to use an internal queue, and do the actual sending in ``tick()``. // advised to use an internal queue, and do the actual sending in ``tick()``.
// //
// Since the plugin interface gives you easy access to internal structures, it // Since the plugin interface gives you easy access to internal structures, it
// is not supported as a stable API. Plugins should be considered specific to a // is not supported as a stable API. Plugins should be considered specific to a
// specific version of libtorrent. Although, in practice the internals mostly // specific version of libtorrent. Although, in practice the internals mostly
// don't change that dramatically. // don't change that dramatically.
// //
// //
// plugin-interface // plugin-interface
// ================ // ================
// //
// The plugin interface consists of three base classes that the plugin may // The plugin interface consists of three base classes that the plugin may
// implement. These are called plugin, torrent_plugin and peer_plugin. // implement. These are called plugin, torrent_plugin and peer_plugin.
// They are found in the ``<libtorrent/extensions.hpp>`` header. // They are found in the ``<libtorrent/extensions.hpp>`` header.
// //
// These plugins are instantiated for each session, torrent and possibly each peer, // These plugins are instantiated for each session, torrent and possibly each peer,
// respectively. // respectively.
// //
// For plugins that only need per torrent state, it is enough to only implement // For plugins that only need per torrent state, it is enough to only implement
// ``torrent_plugin`` and pass a constructor function or function object to // ``torrent_plugin`` and pass a constructor function or function object to
// ``session::add_extension()`` or ``torrent_handle::add_extension()`` (if the // ``session::add_extension()`` or ``torrent_handle::add_extension()`` (if the
// torrent has already been started and you want to hook in the extension at // torrent has already been started and you want to hook in the extension at
// run-time). // run-time).
// //
// The signature of the function is:: // The signature of the function is::
// //
// std::shared_ptr<torrent_plugin> (*)(torrent_handle const&, void*); // std::shared_ptr<torrent_plugin> (*)(torrent_handle const&, void*);
// //
// The second argument is the userdata passed to ``session::add_torrent()`` or // The second argument is the userdata passed to ``session::add_torrent()`` or
// ``torrent_handle::add_extension()``. // ``torrent_handle::add_extension()``.
// //
// The function should return a ``std::shared_ptr<torrent_plugin>`` which // The function should return a ``std::shared_ptr<torrent_plugin>`` which
// may or may not be 0. If it is a nullptr, the extension is simply ignored // may or may not be 0. If it is a nullptr, the extension is simply ignored
// for this torrent. If it is a valid pointer (to a class inheriting // for this torrent. If it is a valid pointer (to a class inheriting
// ``torrent_plugin``), it will be associated with this torrent and callbacks // ``torrent_plugin``), it will be associated with this torrent and callbacks
// will be made on torrent events. // will be made on torrent events.
// //
// For more elaborate plugins which require session wide state, you would // For more elaborate plugins which require session wide state, you would
// implement ``plugin``, construct an object (in a ``std::shared_ptr``) and pass // implement ``plugin``, construct an object (in a ``std::shared_ptr``) and pass
// it in to ``session::add_extension()``. // it in to ``session::add_extension()``.
// //
// custom alerts // custom alerts
// ============= // =============
// //
// Since plugins are running within internal libtorrent threads, one convenient // Since plugins are running within internal libtorrent threads, one convenient
// way to communicate with the client is to post custom alerts. // way to communicate with the client is to post custom alerts.
// //
// The expected interface of any alert, apart from deriving from the alert // The expected interface of any alert, apart from deriving from the alert
// base class, looks like this: // base class, looks like this:
// //
// .. parsed-literal:: // .. parsed-literal::
// //
// static const int alert_type = *<unique alert ID>*; // static const int alert_type = *<unique alert ID>*;
// virtual int type() const { return alert_type; } // virtual int type() const { return alert_type; }
// //
// virtual std::string message() const; // virtual std::string message() const;
// //
// static const int static_category = *<bitmask of alert::category_t flags>*; // static const int static_category = *<bitmask of alert::category_t flags>*;
// virtual int category() const { return static_category; } // virtual int category() const { return static_category; }
// //
// virtual char const* what() const { return *<string literal of the name of this alert>*; } // virtual char const* what() const { return *<string literal of the name of this alert>*; }
// //
// The ``alert_type`` is used for the type-checking in ``alert_cast``. It must // The ``alert_type`` is used for the type-checking in ``alert_cast``. It must
// not collide with any other alert. The built-in alerts in libtorrent will // not collide with any other alert. The built-in alerts in libtorrent will
// not use alert type IDs greater than ``user_alert_id``. When defining your // not use alert type IDs greater than ``user_alert_id``. When defining your
// own alert, make sure it's greater than this constant. // own alert, make sure it's greater than this constant.
// //
// ``type()`` is the run-time equivalence of the ``alert_type``. // ``type()`` is the run-time equivalence of the ``alert_type``.
// //
// The ``message()`` virtual function is expected to construct a useful // The ``message()`` virtual function is expected to construct a useful
// string representation of the alert and the event or data it represents. // string representation of the alert and the event or data it represents.
// Something convenient to put in a log file for instance. // Something convenient to put in a log file for instance.
// //
// ``clone()`` is used internally to copy alerts. The suggested implementation // ``clone()`` is used internally to copy alerts. The suggested implementation
// of simply allocating a new instance as a copy of ``*this`` is all that's // of simply allocating a new instance as a copy of ``*this`` is all that's
// expected. // expected.
// //
// The static category is required for checking whether or not the category // The static category is required for checking whether or not the category
// for a specific alert is enabled or not, without instantiating the alert. // for a specific alert is enabled or not, without instantiating the alert.
// The ``category`` virtual function is the run-time equivalence. // The ``category`` virtual function is the run-time equivalence.
// //
// The ``what()`` virtual function may simply be a string literal of the class // The ``what()`` virtual function may simply be a string literal of the class
// name of your alert. // name of your alert.
// //
// For more information, see the `alert section`_. // For more information, see the `alert section`_.
// //
// .. _`alert section`: reference-Alerts.html // .. _`alert section`: reference-Alerts.html
@ -283,16 +283,16 @@ namespace libtorrent
// may choose to ignore this by just returning a default constructed // may choose to ignore this by just returning a default constructed
// ``shared_ptr`` (in which case you don't need to override this member // ``shared_ptr`` (in which case you don't need to override this member
// function). // function).
// //
// If you need an extension to the peer connection (which most plugins do) you // If you need an extension to the peer connection (which most plugins do) you
// are supposed to return an instance of your peer_plugin class. Which in // 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. // 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`` // 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 // 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 // keep a ``shared_ptr`` to your own peer_plugin. If you want to keep references
// to it, use ``weak_ptr``. // to it, use ``weak_ptr``.
// //
// If this function throws an exception, the connection will be closed. // If this function throws an exception, the connection will be closed.
virtual std::shared_ptr<peer_plugin> new_connection(peer_connection_handle const&) virtual std::shared_ptr<peer_plugin> new_connection(peer_connection_handle const&)
{ return std::shared_ptr<peer_plugin>(); } { return std::shared_ptr<peer_plugin>(); }
@ -314,7 +314,7 @@ namespace libtorrent
// will have this hook function called, and the standard handler will also not be // will have this hook function called, and the standard handler will also not be
// invoked. So, returning true effectively overrides the standard behavior of // invoked. So, returning true effectively overrides the standard behavior of
// pause or unpause. // pause or unpause.
// //
// Note that if you call ``pause()`` or ``resume()`` on the torrent from your // Note that if you call ``pause()`` or ``resume()`` on the torrent from your
// handler it will recurse back into your handler, so in order to invoke the // handler it will recurse back into your handler, so in order to invoke the
// standard handler, you have to keep your own state on whether you want standard // standard handler, you have to keep your own state on whether you want standard
@ -324,7 +324,7 @@ namespace libtorrent
// This function is called when the initial files of the torrent have been // This function is called when the initial files of the torrent have been
// checked. If there are no files to check, this function is called immediately. // checked. If there are no files to check, this function is called immediately.
// //
// i.e. This function is always called when the torrent is in a state where it // i.e. This function is always called when the torrent is in a state where it
// can start downloading. // can start downloading.
virtual void on_files_checked() {} virtual void on_files_checked() {}
@ -392,7 +392,7 @@ namespace libtorrent
// called when the extension handshake from the other end is received // called when the extension handshake from the other end is received
// if this returns false, it means that this extension isn't // if this returns false, it means that this extension isn't
// supported by this peer. It will result in this peer_plugin // supported by this peer. It will result in this peer_plugin
// being removed from the peer_connection and destructed. // being removed from the peer_connection and destructed.
// this is not called for web seeds // this is not called for web seeds
virtual bool on_extension_handshake(bdecode_node const&) { return true; } virtual bool on_extension_handshake(bdecode_node const&) { return true; }

View File

@ -50,7 +50,7 @@ namespace libtorrent
// other. This is the main building block in making magnet links work. // other. This is the main building block in making magnet links work.
// This extension is enabled by default unless explicitly disabled in // This extension is enabled by default unless explicitly disabled in
// the session constructor. // the session constructor.
// //
// This can either be passed in the add_torrent_params::extensions field, or // This can either be passed in the add_torrent_params::extensions field, or
// via torrent_handle::add_extension(). // via torrent_handle::add_extension().
TORRENT_EXPORT std::shared_ptr<torrent_plugin> create_ut_metadata_plugin(torrent_handle const&, void*); TORRENT_EXPORT std::shared_ptr<torrent_plugin> create_ut_metadata_plugin(torrent_handle const&, void*);

View File

@ -49,7 +49,7 @@ namespace libtorrent
// the swarm stay well connected and peers aware of more peers in the // the swarm stay well connected and peers aware of more peers in the
// swarm. This extension is enabled by default unless explicitly disabled in // swarm. This extension is enabled by default unless explicitly disabled in
// the session constructor. // the session constructor.
// //
// This can either be passed in the add_torrent_params::extensions field, or // This can either be passed in the add_torrent_params::extensions field, or
// via torrent_handle::add_extension(). // via torrent_handle::add_extension().
TORRENT_EXPORT std::shared_ptr<torrent_plugin> create_ut_pex_plugin(torrent_handle const&, void*); TORRENT_EXPORT std::shared_ptr<torrent_plugin> create_ut_pex_plugin(torrent_handle const&, void*);

View File

@ -51,9 +51,9 @@ namespace libtorrent
// ``open_mode`` is a bitmask of the file flags this file is currently opened with. These // ``open_mode`` is a bitmask of the file flags this file is currently opened with. These
// are the flags used in the ``file::open()`` function. This enum is defined as a member // are the flags used in the ``file::open()`` function. This enum is defined as a member
// of the ``file`` class. // of the ``file`` class.
// //
// :: // ::
// //
// enum // enum
// { // {
// read_only = 0, // read_only = 0,
@ -66,7 +66,7 @@ namespace libtorrent
// random_access = 32, // random_access = 32,
// lock_file = 64, // lock_file = 64,
// }; // };
// //
// Note that the read/write mode is not a bitmask. The two least significant bits are used // Note that the read/write mode is not a bitmask. The two least significant bits are used
// to represent the read/write mode. Those bits can be masked out using the ``rw_mask`` constant. // to represent the read/write mode. Those bits can be masked out using the ``rw_mask`` constant.
int open_mode; int open_mode;

View File

@ -251,32 +251,32 @@ namespace libtorrent
// of this file_storage object or any copy of it. The same thing applies // of this file_storage object or any copy of it. The same thing applies
// to ``filehash``, which is an optional pointer to a 20 byte binary // to ``filehash``, which is an optional pointer to a 20 byte binary
// SHA-1 hash of the file. // SHA-1 hash of the file.
// //
// if ``filename`` is nullptr, the filename from ``path`` is used and not // if ``filename`` is nullptr, the filename from ``path`` is used and not
// borrowed. In this case ``filename_len`` is ignored. // borrowed. In this case ``filename_len`` is ignored.
// //
// The ``path`` argument is the full path (in the torrent file) to // The ``path`` argument is the full path (in the torrent file) to
// the file to add. Note that this is not supposed to be an absolute // the file to add. Note that this is not supposed to be an absolute
// path, but it is expected to include the name of the torrent as the // path, but it is expected to include the name of the torrent as the
// first path element. // first path element.
// //
// ``file_size`` is the size of the file in bytes. // ``file_size`` is the size of the file in bytes.
// //
// The ``file_flags`` argument sets attributes on the file. The file // The ``file_flags`` argument sets attributes on the file. The file
// attributes is an extension and may not work in all bittorrent clients. // attributes is an extension and may not work in all bittorrent clients.
// //
// For possible file attributes, see file_storage::flags_t. // For possible file attributes, see file_storage::flags_t.
// //
// The ``mtime`` argument is optional and can be set to 0. If non-zero, // The ``mtime`` argument is optional and can be set to 0. If non-zero,
// it is the posix time of the last modification time of this file. // it is the posix time of the last modification time of this file.
// //
// ``symlink_path`` is the path the file is a symlink to. To make this a // ``symlink_path`` is the path the file is a symlink to. To make this a
// symlink you also need to set the file_storage::flag_symlink file flag. // symlink you also need to set the file_storage::flag_symlink file flag.
// //
// If more files than one are added, certain restrictions to their paths // If more files than one are added, certain restrictions to their paths
// apply. In a multi-file file storage (torrent), all files must share // apply. In a multi-file file storage (torrent), all files must share
// the same root directory. // the same root directory.
// //
// That is, the first path element of all files must be the same. // That is, the first path element of all files must be the same.
// This shared path element is also set to the name of the torrent. It // This shared path element is also set to the name of the torrent. It
// can be changed by calling ``set_name``. // can be changed by calling ``set_name``.
@ -317,9 +317,9 @@ namespace libtorrent
// //
// Preconditions of this function is that the input range is within the // Preconditions of this function is that the input range is within the
// torrents address space. ``piece`` may not be negative and // torrents address space. ``piece`` may not be negative and
// //
// ``piece`` * piece_size + ``offset`` + ``size`` // ``piece`` * piece_size + ``offset`` + ``size``
// //
// may not exceed the total size of the torrent. // may not exceed the total size of the torrent.
std::vector<file_slice> map_block(int piece, std::int64_t offset std::vector<file_slice> map_block(int piece, std::int64_t offset
, int size) const; , int size) const;
@ -437,19 +437,19 @@ namespace libtorrent
// These functions are used to query attributes of files at // These functions are used to query attributes of files at
// a given index. // a given index.
// //
// The ``hash()`` is a sha-1 hash of the file, or 0 if none was // The ``hash()`` is a sha-1 hash of the file, or 0 if none was
// provided in the torrent file. This can potentially be used to // provided in the torrent file. This can potentially be used to
// join a bittorrent network with other file sharing networks. // join a bittorrent network with other file sharing networks.
// //
// The ``mtime()`` is the modification time is the posix // The ``mtime()`` is the modification time is the posix
// time when a file was last modified when the torrent // time when a file was last modified when the torrent
// was created, or 0 if it was not included in the torrent file. // was created, or 0 if it was not included in the torrent file.
// //
// ``file_path()`` returns the full path to a file. // ``file_path()`` returns the full path to a file.
// //
// ``file_size()`` returns the size of a file. // ``file_size()`` returns the size of a file.
// //
// ``pad_file_at()`` returns true if the file at the given // ``pad_file_at()`` returns true if the file at the given
// index is a pad-file. // index is a pad-file.
// //

View File

@ -52,7 +52,7 @@ namespace libtorrent
// The constructor takes a ``char const*`` that should point to a string constant containing // The constructor takes a ``char const*`` that should point to a string constant containing
// exactly two characters. These are the characters that should be unique for your client. Make // exactly two characters. These are the characters that should be unique for your client. Make
// sure not to clash with anybody else. Here are some taken id's: // sure not to clash with anybody else. Here are some taken id's:
// //
// +----------+-----------------------+ // +----------+-----------------------+
// | id chars | client | // | id chars | client |
// +==========+=======================+ // +==========+=======================+
@ -70,9 +70,9 @@ namespace libtorrent
// +----------+-----------------------+ // +----------+-----------------------+
// | 'XT' | Xan Torrent | // | 'XT' | Xan Torrent |
// +----------+-----------------------+ // +----------+-----------------------+
// //
// There's an informal directory of client id's here_. // There's an informal directory of client id's here_.
// //
// .. _here: http://wiki.theory.org/BitTorrentSpecification#peer_id // .. _here: http://wiki.theory.org/BitTorrentSpecification#peer_id
// //
// The ``major``, ``minor``, ``revision`` and ``tag`` parameters are used to identify the // The ``major``, ``minor``, ``revision`` and ``tag`` parameters are used to identify the

View File

@ -64,19 +64,19 @@ extern "C" {
namespace libtorrent namespace libtorrent
{ {
// this is a SHA-1 hash class. // this is a SHA-1 hash class.
// //
// You use it by first instantiating it, then call ``update()`` to feed it // You use it by first instantiating it, then call ``update()`` to feed it
// with data. i.e. you don't have to keep the entire buffer of which you want to // with data. i.e. you don't have to keep the entire buffer of which you want to
// create the hash in memory. You can feed the hasher parts of it at a time. When // create the hash in memory. You can feed the hasher parts of it at a time. When
// You have fed the hasher with all the data, you call ``final()`` and it // You have fed the hasher with all the data, you call ``final()`` and it
// will return the sha1-hash of the data. // will return the sha1-hash of the data.
// //
// The constructor that takes a ``char const*`` and an integer will construct the // The constructor that takes a ``char const*`` and an integer will construct the
// sha1 context and feed it the data passed in. // sha1 context and feed it the data passed in.
// //
// If you want to reuse the hasher object once you have created a hash, you have to // If you want to reuse the hasher object once you have created a hash, you have to
// call ``reset()`` to reinitialize it. // call ``reset()`` to reinitialize it.
// //
// The built-in software version of sha1-algorithm was implemented // The built-in software version of sha1-algorithm was implemented
// by Steve Reid and released as public domain. // by Steve Reid and released as public domain.
// For more info, see ``src/sha1.cpp``. // For more info, see ``src/sha1.cpp``.

View File

@ -46,7 +46,7 @@ POSSIBILITY OF SUCH DAMAGE.
namespace libtorrent namespace libtorrent
{ {
struct http_connection; struct http_connection;
class entry; class entry;
class http_parser; class http_parser;

View File

@ -94,7 +94,7 @@ namespace detail
} }
inline std::uint16_t plus_one(std::uint16_t val) { return val + 1; } inline std::uint16_t plus_one(std::uint16_t val) { return val + 1; }
template<class Addr> template<class Addr>
Addr minus_one(Addr const& a) Addr minus_one(Addr const& a)
{ {
@ -270,13 +270,13 @@ struct TORRENT_EXPORT ip_filter
// ip addresses that will be marked with the given flags. The ``flags`` // ip addresses that will be marked with the given flags. The ``flags``
// can currently be 0, which means allowed, or ``ip_filter::blocked``, which // can currently be 0, which means allowed, or ``ip_filter::blocked``, which
// means disallowed. // means disallowed.
// //
// precondition: // precondition:
// ``first.is_v4() == last.is_v4() && first.is_v6() == last.is_v6()`` // ``first.is_v4() == last.is_v4() && first.is_v6() == last.is_v6()``
// //
// postcondition: // postcondition:
// ``access(x) == flags`` for every ``x`` in the range [``first``, ``last``] // ``access(x) == flags`` for every ``x`` in the range [``first``, ``last``]
// //
// This means that in a case of overlapping ranges, the last one applied takes // This means that in a case of overlapping ranges, the last one applied takes
// precedence. // precedence.
void add_rule(address first, address last, std::uint32_t flags); void add_rule(address first, address last, std::uint32_t flags);

View File

@ -109,7 +109,7 @@ namespace dht
// must be stored as a string in peers["n"] // must be stored as a string in peers["n"]
// //
// If the scrape parameter is true, you should fill these keys: // If the scrape parameter is true, you should fill these keys:
// //
// peers["BFpe"] - with the standard bit representation of a // peers["BFpe"] - with the standard bit representation of a
// 256 bloom filter containing the downloaders // 256 bloom filter containing the downloaders
// peers["BFsd"] - with the standard bit representation of a // peers["BFsd"] - with the standard bit representation of a

View File

@ -51,12 +51,12 @@ namespace libtorrent
struct lazy_entry; struct lazy_entry;
// This function decodes bencoded_ data. // This function decodes bencoded_ data.
// //
// .. _bencoded: http://wiki.theory.org/index.php/BitTorrentSpecification // .. _bencoded: http://wiki.theory.org/index.php/BitTorrentSpecification
// //
// The lazy bdecoder and lazy_entry has been deprecated in favour of // The lazy bdecoder and lazy_entry has been deprecated in favour of
// bdecode_node and its corresponding bdecode() function. // bdecode_node and its corresponding bdecode() function.
// //
// *lazy* refers to the fact that it doesn't copy any actual data out of the // *lazy* refers to the fact that it doesn't copy any actual data out of the
// bencoded buffer. It builds a tree of ``lazy_entry`` which has pointers into // bencoded buffer. It builds a tree of ``lazy_entry`` which has pointers into
// the bencoded buffer. This makes it very fast and efficient. On top of that, // the bencoded buffer. This makes it very fast and efficient. On top of that,
@ -75,7 +75,7 @@ namespace libtorrent
// upper limit for desktop computers. Very few torrents have more items in them. // upper limit for desktop computers. Very few torrents have more items in them.
// The limit corresponds to about 25 MB, which might be a bit much for embedded // The limit corresponds to about 25 MB, which might be a bit much for embedded
// systems. // systems.
// //
// ``start`` and ``end`` defines the bencoded buffer to be decoded. ``ret`` is // ``start`` and ``end`` defines the bencoded buffer to be decoded. ``ret`` is
// the ``lazy_entry`` which is filled in with the whole decoded tree. ``ec`` // the ``lazy_entry`` which is filled in with the whole decoded tree. ``ec``
// is a reference to an ``error_code`` which is set to describe the error encountered // is a reference to an ``error_code`` which is set to describe the error encountered

View File

@ -45,9 +45,9 @@ namespace libtorrent
// Generates a magnet URI from the specified torrent. If the torrent // Generates a magnet URI from the specified torrent. If the torrent
// handle is invalid, an empty string is returned. // handle is invalid, an empty string is returned.
// //
// For more information about magnet links, see magnet-links_. // For more information about magnet links, see magnet-links_.
// //
std::string TORRENT_EXPORT make_magnet_uri(torrent_handle const& handle); std::string TORRENT_EXPORT make_magnet_uri(torrent_handle const& handle);
std::string TORRENT_EXPORT make_magnet_uri(torrent_info const& info); std::string TORRENT_EXPORT make_magnet_uri(torrent_info const& info);

View File

@ -88,7 +88,7 @@ namespace libtorrent
// ``disallow()`` and ``allow()`` adds and removes a peer class to be // ``disallow()`` and ``allow()`` adds and removes a peer class to be
// removed from new peers based on socket type. // removed from new peers based on socket type.
// //
// The ``peer_class`` argument cannot be greater than 31. The bitmasks representing // The ``peer_class`` argument cannot be greater than 31. The bitmasks representing
// peer classes in the ``peer_class_type_filter`` are 32 bits. // peer classes in the ``peer_class_type_filter`` are 32 bits.
void disallow(socket_type_t st, int peer_class) void disallow(socket_type_t st, int peer_class)

View File

@ -91,7 +91,7 @@ namespace libtorrent
// means that this peer supports the // means that this peer supports the
// `extension protocol`__. // `extension protocol`__.
// //
// __ extension_protocol.html // __ extension_protocol.html
supports_extensions = 0x10, supports_extensions = 0x10,

View File

@ -45,7 +45,7 @@ namespace libtorrent
// fields in an add_torrent_params object. This object can then be used to add // fields in an add_torrent_params object. This object can then be used to add
// the actual torrent_info object to and pass to session::add_torrent() or // the actual torrent_info object to and pass to session::add_torrent() or
// session::async_add_torrent(). // session::async_add_torrent().
// //
// If the client wants to override any field that was loaded from the resume // If the client wants to override any field that was loaded from the resume
// data, e.g. save_path, those fields must be changed after loading resume // data, e.g. save_path, those fields must be changed after loading resume
// data but before adding the torrent. // data but before adding the torrent.

View File

@ -58,7 +58,7 @@ namespace libtorrent
// can set the session settings to pre set settings for other environments. // can set the session settings to pre set settings for other environments.
// These can be used for the basis, and should be tweaked to fit your needs // These can be used for the basis, and should be tweaked to fit your needs
// better. // better.
// //
// ``min_memory_usage`` returns settings that will use the minimal amount of // ``min_memory_usage`` returns settings that will use the minimal amount of
// RAM, at the potential expense of upload and download performance. It // RAM, at the potential expense of upload and download performance. It
// adjusts the socket buffer sizes, disables the disk cache, lowers the send // adjusts the socket buffer sizes, disables the disk cache, lowers the send
@ -68,10 +68,10 @@ namespace libtorrent
// to disk at any given time. It lowers the max number of peers in the peer // to disk at any given time. It lowers the max number of peers in the peer
// list for torrents. It performs multiple smaller reads when it hashes // list for torrents. It performs multiple smaller reads when it hashes
// pieces, instead of reading it all into memory before hashing. // pieces, instead of reading it all into memory before hashing.
// //
// This configuration is intended to be the starting point for embedded // This configuration is intended to be the starting point for embedded
// devices. It will significantly reduce memory usage. // devices. It will significantly reduce memory usage.
// //
// ``high_performance_seed`` returns settings optimized for a seed box, // ``high_performance_seed`` returns settings optimized for a seed box,
// serving many peers and that doesn't do any downloading. It has a 128 MB // serving many peers and that doesn't do any downloading. It has a 128 MB
// disk cache and has a limit of 400 files in its file pool. It support fast // disk cache and has a limit of 400 files in its file pool. It support fast
@ -170,7 +170,7 @@ namespace libtorrent
// ``session_handle::apply_settings()`` member function. To change one or more // ``session_handle::apply_settings()`` member function. To change one or more
// configuration options, create a settings_pack. object and fill it with // configuration options, create a settings_pack. object and fill it with
// the settings to be set and pass it in to ``session::apply_settings()``. // the settings to be set and pass it in to ``session::apply_settings()``.
// //
// see apply_settings(). // see apply_settings().
class TORRENT_EXPORT session : public session_handle class TORRENT_EXPORT session : public session_handle
{ {
@ -213,7 +213,7 @@ namespace libtorrent
// starting the session and configuring it, you can pass in a // starting the session and configuring it, you can pass in a
// settings_pack object. Its settings will take effect before the session // settings_pack object. Its settings will take effect before the session
// starts up. // starts up.
// //
// The ``flags`` parameter can be used to start default features (upnp & // The ``flags`` parameter can be used to start default features (upnp &
// nat-pmp) and default plugins (ut_metadata, ut_pex and smart_ban). The // nat-pmp) and default plugins (ut_metadata, ut_pex and smart_ban). The
// default is to start those features. If you do not want them to start, // default is to start those features. If you do not want them to start,
@ -239,7 +239,7 @@ namespace libtorrent
// to run multiple sessions on a single io_service, or low resource // to run multiple sessions on a single io_service, or low resource
// systems where additional threads are expensive and sharing an // systems where additional threads are expensive and sharing an
// io_service with other events is fine. // io_service with other events is fine.
// //
// .. warning:: // .. warning::
// The session object does not cleanly terminate with an external // The session object does not cleanly terminate with an external
// ``io_service``. The ``io_service::run()`` call _must_ have returned // ``io_service``. The ``io_service::run()`` call _must_ have returned
@ -330,7 +330,7 @@ namespace libtorrent
// call. The ``session_proxy`` does not have any operations on it (since // call. The ``session_proxy`` does not have any operations on it (since
// the session is being closed down, no operations are allowed on it). // the session is being closed down, no operations are allowed on it).
// The only valid operation is calling the destructor:: // The only valid operation is calling the destructor::
// //
// class session_proxy // class session_proxy
// { // {
// public: // public:

View File

@ -40,15 +40,15 @@ POSSIBILITY OF SUCH DAMAGE.
#include <memory> #include <memory>
// OVERVIEW // OVERVIEW
// //
// You have some control over session configuration through the session::apply_settings() // You have some control over session configuration through the session::apply_settings()
// member function. To change one or more configuration options, create a settings_pack. // member function. To change one or more configuration options, create a settings_pack.
// object and fill it with the settings to be set and pass it in to session::apply_settings(). // object and fill it with the settings to be set and pass it in to session::apply_settings().
// //
// You have control over proxy and authorization settings and also the user-agent // You have control over proxy and authorization settings and also the user-agent
// that will be sent to the tracker. The user-agent will also be used to identify the // that will be sent to the tracker. The user-agent will also be used to identify the
// client with other peers. // client with other peers.
// //
namespace libtorrent namespace libtorrent
{ {
namespace aux { struct session_impl; struct session_settings; } namespace aux { struct session_impl; struct session_settings; }
@ -74,9 +74,9 @@ namespace libtorrent
// enum values. These values are passed in to the ``set_str()``, // enum values. These values are passed in to the ``set_str()``,
// ``set_int()``, ``set_bool()`` functions, to specify the setting to // ``set_int()``, ``set_bool()`` functions, to specify the setting to
// change. // change.
// //
// These are the available settings: // These are the available settings:
// //
// .. include:: settings-ref.rst // .. include:: settings-ref.rst
// //
struct TORRENT_EXPORT settings_pack struct TORRENT_EXPORT settings_pack
@ -137,7 +137,7 @@ namespace libtorrent
// file specified will be created and truncated to the disk cache size // file specified will be created and truncated to the disk cache size
// (``cache_size``). Any existing file with the same name will be // (``cache_size``). Any existing file with the same name will be
// replaced. // replaced.
// //
// This feature requires the ``mmap`` system call, on systems that // This feature requires the ``mmap`` system call, on systems that
// don't have ``mmap`` this setting is ignored. // don't have ``mmap`` this setting is ignored.
mmap_cache, mmap_cache,
@ -166,24 +166,24 @@ namespace libtorrent
// multiple ports. Binding to port 0 will make the operating system // multiple ports. Binding to port 0 will make the operating system
// pick the port. The default is "0.0.0.0:6881,[::]:6881", which binds // pick the port. The default is "0.0.0.0:6881,[::]:6881", which binds
// to all interfaces on port 6881. // to all interfaces on port 6881.
// //
// a port that has an "s" suffix will accept SSL connections. (note // a port that has an "s" suffix will accept SSL connections. (note
// that SSL sockets are not enabled by default). // that SSL sockets are not enabled by default).
// //
// if binding fails, the listen_failed_alert is posted. If or once a // if binding fails, the listen_failed_alert is posted. If or once a
// socket binding succeeds, the listen_succeeded_alert is posted. There // socket binding succeeds, the listen_succeeded_alert is posted. There
// may be multiple failures before a success. // may be multiple failures before a success.
// //
// For example: // For example:
// ``[::1]:8888`` - will only accept connections on the IPv6 loopback // ``[::1]:8888`` - will only accept connections on the IPv6 loopback
// address on port 8888. // address on port 8888.
// //
// ``eth0:4444,eth1:4444`` - will accept connections on port 4444 on // ``eth0:4444,eth1:4444`` - will accept connections on port 4444 on
// any IP address bound to device ``eth0`` or ``eth1``. // any IP address bound to device ``eth0`` or ``eth1``.
// //
// ``[::]:0s`` - will accept SSL connections on a port chosen by the // ``[::]:0s`` - will accept SSL connections on a port chosen by the
// OS. And not accept non-SSL connections at all. // OS. And not accept non-SSL connections at all.
// //
// .. note:: // .. note::
// The current support for opening arbitrary UDP sockets is limited. // The current support for opening arbitrary UDP sockets is limited.
// In this version of libtorrent, there will only ever be two UDP // In this version of libtorrent, there will only ever be two UDP
@ -201,7 +201,7 @@ namespace libtorrent
// sets the i2p_ SAM bridge to connect to. set the port with the // sets the i2p_ SAM bridge to connect to. set the port with the
// ``i2p_port`` setting. // ``i2p_port`` setting.
// //
// .. _i2p: http://www.i2p2.de // .. _i2p: http://www.i2p2.de
i2p_hostname, i2p_hostname,
@ -214,7 +214,7 @@ namespace libtorrent
// to the DHT node (if it's enabled) as back-up nodes in case we don't // to the DHT node (if it's enabled) as back-up nodes in case we don't
// know of any. This setting will contain one or more bootstrap nodes // know of any. This setting will contain one or more bootstrap nodes
// by default. // by default.
// //
// Changing these after the DHT has been started may not have any // Changing these after the DHT has been started may not have any
// effect until the DHT is restarted. // effect until the DHT is restarted.
dht_bootstrap_nodes, dht_bootstrap_nodes,
@ -334,7 +334,7 @@ namespace libtorrent
// behavior is as defined by the multi tracker specification. It // behavior is as defined by the multi tracker specification. It
// defaults to false, which is the same behavior previous versions of // defaults to false, which is the same behavior previous versions of
// libtorrent has had as well. // libtorrent has had as well.
// //
// ``announce_to_all_tiers`` also controls how multi tracker torrents // ``announce_to_all_tiers`` also controls how multi tracker torrents
// are treated. When this is set to true, one tracker from each tier // are treated. When this is set to true, one tracker from each tier
// is announced to. This is the uTorrent behavior. This is false by // is announced to. This is the uTorrent behavior. This is false by
@ -492,7 +492,7 @@ namespace libtorrent
// tracker proxy). Since no incoming connections are accepted, // tracker proxy). Since no incoming connections are accepted,
// NAT-PMP, UPnP, DHT and local peer discovery are all turned off when // NAT-PMP, UPnP, DHT and local peer discovery are all turned off when
// this setting is enabled. // this setting is enabled.
// //
// If you're using I2P, it might make sense to enable anonymous mode // If you're using I2P, it might make sense to enable anonymous mode
// as well. // as well.
anonymous_mode, anonymous_mode,
@ -636,7 +636,7 @@ namespace libtorrent
// Starts and stops the UPnP service. When started, the listen port // Starts and stops the UPnP service. When started, the listen port
// and the DHT port are attempted to be forwarded on local UPnP router // and the DHT port are attempted to be forwarded on local UPnP router
// devices. // devices.
// //
// The upnp object returned by ``start_upnp()`` can be used to add and // The upnp object returned by ``start_upnp()`` can be used to add and
// remove arbitrary port mappings. Mapping status is returned through // remove arbitrary port mappings. Mapping status is returned through
// the portmap_alert and the portmap_error_alert. The object will be // the portmap_alert and the portmap_error_alert. The object will be
@ -646,7 +646,7 @@ namespace libtorrent
// Starts and stops the NAT-PMP service. When started, the listen port // Starts and stops the NAT-PMP service. When started, the listen port
// and the DHT port are attempted to be forwarded on the router // and the DHT port are attempted to be forwarded on the router
// through NAT-PMP. // through NAT-PMP.
// //
// The natpmp object returned by ``start_natpmp()`` can be used to add // The natpmp object returned by ``start_natpmp()`` can be used to add
// and remove arbitrary port mappings. Mapping status is returned // and remove arbitrary port mappings. Mapping status is returned
// through the portmap_alert and the portmap_error_alert. The object // through the portmap_alert and the portmap_error_alert. The object
@ -844,7 +844,7 @@ namespace libtorrent
// ``suggest_mode`` controls whether or not libtorrent will send out // ``suggest_mode`` controls whether or not libtorrent will send out
// suggest messages to create a bias of its peers to request certain // suggest messages to create a bias of its peers to request certain
// pieces. The modes are: // pieces. The modes are:
// //
// * ``no_piece_suggestions`` which is the default and will not send // * ``no_piece_suggestions`` which is the default and will not send
// out suggest messages. // out suggest messages.
// * ``suggest_read_cache`` which will send out suggest messages for // * ``suggest_read_cache`` which will send out suggest messages for
@ -870,13 +870,13 @@ namespace libtorrent
// and snappy seeding performance, set this fairly high, to at least // and snappy seeding performance, set this fairly high, to at least
// fit a few blocks. This is essentially the initial window size which // fit a few blocks. This is essentially the initial window size which
// will determine how fast we can ramp up the send rate // will determine how fast we can ramp up the send rate
// //
// if the send buffer has fewer bytes than ``send_buffer_watermark``, // if the send buffer has fewer bytes than ``send_buffer_watermark``,
// we'll read another 16kB block onto it. If set too small, upload // we'll read another 16kB block onto it. If set too small, upload
// rate capacity will suffer. If set too high, memory will be wasted. // rate capacity will suffer. If set too high, memory will be wasted.
// The actual watermark may be lower than this in case the upload rate // The actual watermark may be lower than this in case the upload rate
// is low, this is the upper limit. // is low, this is the upper limit.
// //
// the current upload rate to a peer is multiplied by this factor to // the current upload rate to a peer is multiplied by this factor to
// get the send buffer watermark. The factor is specified as a // get the send buffer watermark. The factor is specified as a
// percentage. i.e. 50 -> 0.5 This product is clamped to the // percentage. i.e. 50 -> 0.5 This product is clamped to the
@ -891,17 +891,17 @@ namespace libtorrent
// ``choking_algorithm`` specifies which algorithm to use to determine // ``choking_algorithm`` specifies which algorithm to use to determine
// which peers to unchoke. // which peers to unchoke.
// //
// The options for choking algorithms are: // The options for choking algorithms are:
// //
// * ``fixed_slots_choker`` is the traditional choker with a fixed // * ``fixed_slots_choker`` is the traditional choker with a fixed
// number of unchoke slots (as specified by // number of unchoke slots (as specified by
// ``session::set_max_uploads()``). // ``session::set_max_uploads()``).
// //
// * ``rate_based_choker`` opens up unchoke slots based on the upload // * ``rate_based_choker`` opens up unchoke slots based on the upload
// rate achieved to peers. The more slots that are opened, the // rate achieved to peers. The more slots that are opened, the
// marginal upload rate required to open up another slot increases. // marginal upload rate required to open up another slot increases.
// //
// * ``bittyrant_choker`` attempts to optimize download rate by // * ``bittyrant_choker`` attempts to optimize download rate by
// finding the reciprocation rate of each peer individually and // finding the reciprocation rate of each peer individually and
// prefers peers that gives the highest *return on investment*. It // prefers peers that gives the highest *return on investment*. It
@ -911,21 +911,21 @@ namespace libtorrent
// (``session::set_upload_rate_limit()``). For more information // (``session::set_upload_rate_limit()``). For more information
// about this choker, see the paper_. This choker is not fully // about this choker, see the paper_. This choker is not fully
// implemented nor tested. // implemented nor tested.
// //
// .. _paper: http://bittyrant.cs.washington.edu/#papers // .. _paper: http://bittyrant.cs.washington.edu/#papers
// //
// ``seed_choking_algorithm`` controls the seeding unchoke behavior. // ``seed_choking_algorithm`` controls the seeding unchoke behavior.
// The available options are: // The available options are:
// //
// * ``round_robin`` which round-robins the peers that are unchoked // * ``round_robin`` which round-robins the peers that are unchoked
// when seeding. This distributes the upload bandwidht uniformly and // when seeding. This distributes the upload bandwidht uniformly and
// fairly. It minimizes the ability for a peer to download everything // fairly. It minimizes the ability for a peer to download everything
// without redistributing it. // without redistributing it.
// //
// * ``fastest_upload`` unchokes the peers we can send to the fastest. // * ``fastest_upload`` unchokes the peers we can send to the fastest.
// This might be a bit more reliable in utilizing all available // This might be a bit more reliable in utilizing all available
// capacity. // capacity.
// //
// * ``anti_leech`` prioritizes peers who have just started or are // * ``anti_leech`` prioritizes peers who have just started or are
// just about to finish the download. The intention is to force // just about to finish the download. The intention is to force
// peers in the middle of the download to trade with each other. // peers in the middle of the download to trade with each other.
@ -940,7 +940,7 @@ namespace libtorrent
// to -1, the cache size is automatically set to the amount of // to -1, the cache size is automatically set to the amount of
// physical RAM available in the machine divided by 8. If the amount // physical RAM available in the machine divided by 8. If the amount
// of physical RAM cannot be determined, it's set to 1024 (= 16 MiB). // of physical RAM cannot be determined, it's set to 1024 (= 16 MiB).
// //
// Disk buffers are allocated using a pool allocator, the number of // Disk buffers are allocated using a pool allocator, the number of
// blocks that are allocated at a time when the pool needs to grow can // blocks that are allocated at a time when the pool needs to grow can
// be specified in ``cache_buffer_chunk_size``. Lower numbers saves // be specified in ``cache_buffer_chunk_size``. Lower numbers saves
@ -950,7 +950,7 @@ namespace libtorrent
// usage. It defaults to 0. ``cache_expiry`` is the number of seconds // usage. It defaults to 0. ``cache_expiry`` is the number of seconds
// from the last cached write to a piece in the write cache, to when // from the last cached write to a piece in the write cache, to when
// it's forcefully flushed to disk. Default is 60 second. // it's forcefully flushed to disk. Default is 60 second.
// //
// On 32 bit builds, the effective cache size will be limited to 3/4 of // On 32 bit builds, the effective cache size will be limited to 3/4 of
// 2 GiB to avoid exceeding the virtual address space limit. // 2 GiB to avoid exceeding the virtual address space limit.
cache_size, cache_size,
@ -959,7 +959,7 @@ namespace libtorrent
// determines how files are opened when they're in read only mode // determines how files are opened when they're in read only mode
// versus read and write mode. The options are: // versus read and write mode. The options are:
// //
// enable_os_cache // enable_os_cache
// This is the default and files are opened normally, with the OS // This is the default and files are opened normally, with the OS
// caching reads and writes. // caching reads and writes.
@ -970,7 +970,7 @@ namespace libtorrent
// potentially evict all other processes' cache by simply handling // potentially evict all other processes' cache by simply handling
// high throughput and large files. If libtorrent's read cache is // high throughput and large files. If libtorrent's read cache is
// disabled, enabling this may reduce performance. // disabled, enabling this may reduce performance.
// //
// One reason to disable caching is that it may help the operating // One reason to disable caching is that it may help the operating
// system from growing its file cache indefinitely. // system from growing its file cache indefinitely.
disk_io_write_mode, disk_io_write_mode,
@ -981,13 +981,13 @@ namespace libtorrent
// based on local port. when binding outgoing connections to specific // based on local port. when binding outgoing connections to specific
// ports, ``num_outgoing_ports`` is the size of the range. It should // ports, ``num_outgoing_ports`` is the size of the range. It should
// be more than a few // be more than a few
// //
// .. warning:: setting outgoing ports will limit the ability to keep // .. warning:: setting outgoing ports will limit the ability to keep
// multiple connections to the same client, even for different // multiple connections to the same client, even for different
// torrents. It is not recommended to change this setting. Its main // torrents. It is not recommended to change this setting. Its main
// purpose is to use as an escape hatch for cheap routers with QoS // purpose is to use as an escape hatch for cheap routers with QoS
// capability but can only classify flows based on port numbers. // capability but can only classify flows based on port numbers.
// //
// It is a range instead of a single port because of the problems with // It is a range instead of a single port because of the problems with
// failing to reconnect to peers if a previous socket to that peer and // failing to reconnect to peers if a previous socket to that peer and
// port is in ``TIME_WAIT`` state. // port is in ``TIME_WAIT`` state.
@ -999,7 +999,7 @@ namespace libtorrent
// this is ``0x0`` (no marking). One potentially useful TOS mark is // this is ``0x0`` (no marking). One potentially useful TOS mark is
// ``0x20``, this represents the *QBone scavenger service*. For more // ``0x20``, this represents the *QBone scavenger service*. For more
// details, see QBSS_. // details, see QBSS_.
// //
// .. _`QBSS`: http://qbone.internet2.edu/qbss/ // .. _`QBSS`: http://qbone.internet2.edu/qbss/
peer_tos, peer_tos,
@ -1020,32 +1020,32 @@ namespace libtorrent
// then there will be 2 downloading torrents and 4 seeding torrents // then there will be 2 downloading torrents and 4 seeding torrents
// active. Torrents that are not auto managed are not counted against // active. Torrents that are not auto managed are not counted against
// these limits. // these limits.
// //
// ``active_checking`` is the limit of number of simultaneous checking // ``active_checking`` is the limit of number of simultaneous checking
// torrents. // torrents.
// //
// ``active_limit`` is a hard limit on the number of active (auto // ``active_limit`` is a hard limit on the number of active (auto
// managed) torrents. This limit also applies to slow torrents. // managed) torrents. This limit also applies to slow torrents.
// //
// ``active_dht_limit`` is the max number of torrents to announce to // ``active_dht_limit`` is the max number of torrents to announce to
// the DHT. By default this is set to 88, which is no more than one // the DHT. By default this is set to 88, which is no more than one
// DHT announce every 10 seconds. // DHT announce every 10 seconds.
// //
// ``active_tracker_limit`` is the max number of torrents to announce // ``active_tracker_limit`` is the max number of torrents to announce
// to their trackers. By default this is 360, which is no more than // to their trackers. By default this is 360, which is no more than
// one announce every 5 seconds. // one announce every 5 seconds.
// //
// ``active_lsd_limit`` is the max number of torrents to announce to // ``active_lsd_limit`` is the max number of torrents to announce to
// the local network over the local service discovery protocol. By // the local network over the local service discovery protocol. By
// default this is 80, which is no more than one announce every 5 // default this is 80, which is no more than one announce every 5
// seconds (assuming the default announce interval of 5 minutes). // seconds (assuming the default announce interval of 5 minutes).
// //
// You can have more torrents *active*, even though they are not // You can have more torrents *active*, even though they are not
// announced to the DHT, lsd or their tracker. If some peer knows // announced to the DHT, lsd or their tracker. If some peer knows
// about you for any reason and tries to connect, it will still be // about you for any reason and tries to connect, it will still be
// accepted, unless the torrent is paused, which means it won't accept // accepted, unless the torrent is paused, which means it won't accept
// any connections. // any connections.
// //
// ``active_loaded_limit`` is the number of torrents that are allowed // ``active_loaded_limit`` is the number of torrents that are allowed
// to be *loaded* at any given time. Note that a torrent can be active // to be *loaded* at any given time. Note that a torrent can be active
// even though it's not loaded. If an unloaded torrents finds a peer // even though it's not loaded. If an unloaded torrents finds a peer
@ -1077,7 +1077,7 @@ namespace libtorrent
// torrents that are paused, are scraped regularly in order to keep // torrents that are paused, are scraped regularly in order to keep
// track of their downloader/seed ratio. This ratio is used to // track of their downloader/seed ratio. This ratio is used to
// determine which torrents to seed and which to pause. // determine which torrents to seed and which to pause.
// //
// ``auto_scrape_min_interval`` is the minimum number of seconds // ``auto_scrape_min_interval`` is the minimum number of seconds
// between any automatic scrape (regardless of torrent). In case there // between any automatic scrape (regardless of torrent). In case there
// are a large number of paused auto managed torrents, this puts a // are a large number of paused auto managed torrents, this puts a
@ -1092,7 +1092,7 @@ namespace libtorrent
// 90% of this limit, and once the size hits the limit, peers are no // 90% of this limit, and once the size hits the limit, peers are no
// longer added to the list. If this limit is set to 0, there is no // longer added to the list. If this limit is set to 0, there is no
// limit on how many peers we'll keep in the peer list. // limit on how many peers we'll keep in the peer list.
// //
// ``max_paused_peerlist_size`` is the max peer list size used for // ``max_paused_peerlist_size`` is the max peer list size used for
// torrents that are paused. This default to the same as // torrents that are paused. This default to the same as
// ``max_peerlist_size``, but can be used to save memory for paused // ``max_peerlist_size``, but can be used to save memory for paused
@ -1151,7 +1151,7 @@ namespace libtorrent
// essentially the same thing as disabling read cache. The number of // essentially the same thing as disabling read cache. The number of
// blocks read into the read cache is always capped by the piece // blocks read into the read cache is always capped by the piece
// boundary. // boundary.
// //
// When a piece in the write cache has ``write_cache_line_size`` // When a piece in the write cache has ``write_cache_line_size``
// contiguous blocks in it, they will be flushed. Setting this to 1 // contiguous blocks in it, they will be flushed. Setting this to 1
// effectively disables the write cache. // effectively disables the write cache.
@ -1161,10 +1161,10 @@ namespace libtorrent
// ``optimistic_disk_retry`` is the number of seconds from a disk // ``optimistic_disk_retry`` is the number of seconds from a disk
// write errors occur on a torrent until libtorrent will take it out // write errors occur on a torrent until libtorrent will take it out
// of the upload mode, to test if the error condition has been fixed. // of the upload mode, to test if the error condition has been fixed.
// //
// libtorrent will only do this automatically for auto managed // libtorrent will only do this automatically for auto managed
// torrents. // torrents.
// //
// You can explicitly take a torrent out of upload only mode using // You can explicitly take a torrent out of upload only mode using
// set_upload_mode(). // set_upload_mode().
optimistic_disk_retry, optimistic_disk_retry,
@ -1219,12 +1219,12 @@ namespace libtorrent
// more altruistic while finding the true reciprocation rate, if it's // more altruistic while finding the true reciprocation rate, if it's
// set too low, you'll be too stingy and waste finding the true // set too low, you'll be too stingy and waste finding the true
// reciprocation rate. // reciprocation rate.
// //
// ``increase_est_reciprocation_rate`` specifies how many percent the // ``increase_est_reciprocation_rate`` specifies how many percent the
// estimated reciprocation rate should be increased by each unchoke // estimated reciprocation rate should be increased by each unchoke
// interval a peer is still choking us back. This defaults to 20%. // interval a peer is still choking us back. This defaults to 20%.
// This only applies to the BitTyrant choker. // This only applies to the BitTyrant choker.
// //
// ``decrease_est_reciprocation_rate`` specifies how many percent the // ``decrease_est_reciprocation_rate`` specifies how many percent the
// estimated reciprocation rate should be decreased by each unchoke // estimated reciprocation rate should be decreased by each unchoke
// interval a peer unchokes us. This default to 3%. This only applies // interval a peer unchokes us. This default to 3%. This only applies
@ -1264,14 +1264,14 @@ namespace libtorrent
// bytes per second. The local rates refer to peers on the local // bytes per second. The local rates refer to peers on the local
// network. By default peers on the local network are not rate // network. By default peers on the local network are not rate
// limited. // limited.
// //
// These rate limits are only used for local peers (peers within the // These rate limits are only used for local peers (peers within the
// same subnet as the client itself) and it is only used when // same subnet as the client itself) and it is only used when
// ``ignore_limits_on_local_network`` is set to true (which it is by // ``ignore_limits_on_local_network`` is set to true (which it is by
// default). These rate limits default to unthrottled, but can be // default). These rate limits default to unthrottled, but can be
// useful in case you want to treat local peers preferentially, but // useful in case you want to treat local peers preferentially, but
// not quite unthrottled. // not quite unthrottled.
// //
// A value of 0 means unlimited. // A value of 0 means unlimited.
upload_rate_limit, upload_rate_limit,
download_rate_limit, download_rate_limit,
@ -1344,7 +1344,7 @@ namespace libtorrent
// than this value. A connection times out when every packet in a // than this value. A connection times out when every packet in a
// window is lost, or when a packet is lost twice in a row (i.e. the // window is lost, or when a packet is lost twice in a row (i.e. the
// resent packet is lost as well). // resent packet is lost as well).
// //
// The shorter the timeout is, the faster the connection will recover // The shorter the timeout is, the faster the connection will recover
// from this situation, assuming the RTT is low enough. // from this situation, assuming the RTT is low enough.
// ``utp_syn_resends`` is the number of SYN packets that are sent (and // ``utp_syn_resends`` is the number of SYN packets that are sent (and
@ -1447,7 +1447,7 @@ namespace libtorrent
aio_max, aio_max,
// .. note:: This is not implemented // .. note:: This is not implemented
// //
// ``network_threads`` is the number of threads to use to call // ``network_threads`` is the number of threads to use to call
// ``async_write_some`` (i.e. send) on peer connection sockets. When // ``async_write_some`` (i.e. send) on peer connection sockets. When
// seeding at extremely high rates, this may become a bottleneck, and // seeding at extremely high rates, this may become a bottleneck, and
@ -1473,9 +1473,9 @@ namespace libtorrent
// retrying failing trackers. This value determines *x* in the // retrying failing trackers. This value determines *x* in the
// following formula, determining the number of seconds to wait until // following formula, determining the number of seconds to wait until
// the next retry: // the next retry:
// //
// delay = 5 + 5 * x / 100 * fails^2 // delay = 5 + 5 * x / 100 * fails^2
// //
// This setting may be useful to make libtorrent more or less // This setting may be useful to make libtorrent more or less
// aggressive in hitting trackers. // aggressive in hitting trackers.
tracker_backoff, tracker_backoff,
@ -1531,7 +1531,7 @@ namespace libtorrent
// respectively. see enc_policy enum for the available options. // respectively. see enc_policy enum for the available options.
// Keep in mind that protocol encryption degrades performance in // Keep in mind that protocol encryption degrades performance in
// several respects: // several respects:
// //
// 1. It prevents "zero copy" disk buffers being sent to peers, since // 1. It prevents "zero copy" disk buffers being sent to peers, since
// each peer needs to mutate the data (i.e. encrypt it) the data // each peer needs to mutate the data (i.e. encrypt it) the data
// must be copied per peer connection rather than sending the same // must be copied per peer connection rather than sending the same
@ -1567,7 +1567,7 @@ namespace libtorrent
// sets the i2p_ SAM bridge port to connect to. set the hostname with // sets the i2p_ SAM bridge port to connect to. set the hostname with
// the ``i2p_hostname`` setting. // the ``i2p_hostname`` setting.
// //
// .. _i2p: http://www.i2p2.de // .. _i2p: http://www.i2p2.de
i2p_port, i2p_port,

View File

@ -67,13 +67,13 @@ POSSIBILITY OF SUCH DAMAGE.
// general conventions of bittorrent clients, mimicking the original file layout // general conventions of bittorrent clients, mimicking the original file layout
// when the torrent was created. The libtorrent user may define a custom // when the torrent was created. The libtorrent user may define a custom
// storage to store piece data in a different way. // storage to store piece data in a different way.
// //
// A custom storage implementation must derive from and implement the // A custom storage implementation must derive from and implement the
// storage_interface. You must also provide a function that constructs the // storage_interface. You must also provide a function that constructs the
// custom storage object and provide this function to the add_torrent() call // custom storage object and provide this function to the add_torrent() call
// via add_torrent_params. Either passed in to the constructor or by setting // via add_torrent_params. Either passed in to the constructor or by setting
// the add_torrent_params::storage field. // the add_torrent_params::storage field.
// //
// This is an example storage implementation that stores all pieces in a // This is an example storage implementation that stores all pieces in a
// ``std::map``, i.e. in RAM. It's not necessarily very useful in practice, but // ``std::map``, i.e. in RAM. It's not necessarily very useful in practice, but
// illustrates the basics of implementing a custom storage. // illustrates the basics of implementing a custom storage.
@ -128,7 +128,7 @@ POSSIBILITY OF SUCH DAMAGE.
// } // }
// virtual bool release_files() { return false; } // virtual bool release_files() { return false; }
// virtual bool delete_files() { return false; } // virtual bool delete_files() { return false; }
// //
// std::map<int, std::vector<char> > m_file_data; // std::map<int, std::vector<char> > m_file_data;
// file_storage m_files; // file_storage m_files;
// }; // };
@ -181,16 +181,16 @@ namespace libtorrent
// data in RAM, or in some optimized order on disk (the order the pieces are // data in RAM, or in some optimized order on disk (the order the pieces are
// received for instance), or saving multifile torrents in a single file in // received for instance), or saving multifile torrents in a single file in
// order to be able to take advantage of optimized disk-I/O. // order to be able to take advantage of optimized disk-I/O.
// //
// It is also possible to write a thin class that uses the default storage // It is also possible to write a thin class that uses the default storage
// but modifies some particular behavior, for instance encrypting the data // but modifies some particular behavior, for instance encrypting the data
// before it's written to disk, and decrypting it when it's read again. // before it's written to disk, and decrypting it when it's read again.
// //
// The storage interface is based on pieces. Avery read and write operation // The storage interface is based on pieces. Avery read and write operation
// happens in the piece-space. Each piece fits 'piece_size' number // happens in the piece-space. Each piece fits 'piece_size' number
// of bytes. All access is done by writing and reading whole or partial // of bytes. All access is done by writing and reading whole or partial
// pieces. // pieces.
// //
// libtorrent comes with two built-in storage implementations; // libtorrent comes with two built-in storage implementations;
// ``default_storage`` and ``disabled_storage``. Their constructor functions // ``default_storage`` and ``disabled_storage``. Their constructor functions
// are called default_storage_constructor() and // are called default_storage_constructor() and
@ -232,12 +232,12 @@ namespace libtorrent
// allocated buffer can be assumed to fit a fully page aligned number of // allocated buffer can be assumed to fit a fully page aligned number of
// bytes though. This is useful when reading and writing the last piece // bytes though. This is useful when reading and writing the last piece
// of a file in unbuffered mode. // of a file in unbuffered mode.
// //
// The ``offset`` is aligned to 16 kiB boundaries *most of the time*, but // The ``offset`` is aligned to 16 kiB boundaries *most of the time*, but
// there are rare exceptions when it's not. Specifically if the read // there are rare exceptions when it's not. Specifically if the read
// cache is disabled/or full and a peer requests unaligned data. Most // cache is disabled/or full and a peer requests unaligned data. Most
// clients request aligned data. // clients request aligned data.
// //
// The number of bytes read or written should be returned, or -1 on // The number of bytes read or written should be returned, or -1 on
// error. If there's an error, the ``storage_error`` must be filled out // error. If there's an error, the ``storage_error`` must be filled out
// to represent the error that occurred. // to represent the error that occurred.
@ -250,7 +250,7 @@ namespace libtorrent
// storage for a torrent. It should return true if any of the files that // storage for a torrent. It should return true if any of the files that
// is used in this storage exists on disk. If so, the storage will be // is used in this storage exists on disk. If so, the storage will be
// checked for existing pieces before starting the download. // checked for existing pieces before starting the download.
// //
// If an error occurs, ``storage_error`` should be set to reflect it. // If an error occurs, ``storage_error`` should be set to reflect it.
virtual bool has_any_file(storage_error& ec) = 0; virtual bool has_any_file(storage_error& ec) = 0;
@ -263,12 +263,12 @@ namespace libtorrent
// This function should move all the files belonging to the storage to // This function should move all the files belonging to the storage to
// the new save_path. The default storage moves the single file or the // the new save_path. The default storage moves the single file or the
// directory of the torrent. // directory of the torrent.
// //
// Before moving the files, any open file handles may have to be closed, // Before moving the files, any open file handles may have to be closed,
// like ``release_files()``. // like ``release_files()``.
// //
//If an error occurs, ``storage_error`` should be set to reflect it. //If an error occurs, ``storage_error`` should be set to reflect it.
// //
// returns one of: // returns one of:
// | no_error = 0 // | no_error = 0
// | fatal_disk_error = -1 // | fatal_disk_error = -1
@ -280,15 +280,15 @@ namespace libtorrent
// This function should verify the resume data ``rd`` with the files // This function should verify the resume data ``rd`` with the files
// on disk. If the resume data seems to be up-to-date, return true. If // on disk. If the resume data seems to be up-to-date, return true. If
// not, set ``error`` to a description of what mismatched and return false. // not, set ``error`` to a description of what mismatched and return false.
// //
// The default storage may compare file sizes and time stamps of the files. // The default storage may compare file sizes and time stamps of the files.
// //
// If an error occurs, ``storage_error`` should be set to reflect it. // If an error occurs, ``storage_error`` should be set to reflect it.
// //
// This function should verify the resume data ``rd`` with the files // This function should verify the resume data ``rd`` with the files
// on disk. If the resume data seems to be up-to-date, return true. If // on disk. If the resume data seems to be up-to-date, return true. If
// not, set ``error`` to a description of what mismatched and return false. // not, set ``error`` to a description of what mismatched and return false.
// //
// If the ``links`` pointer is non-empty, it has the same number // If the ``links`` pointer is non-empty, it has the same number
// of elements as there are files. Each element is either empty or contains // of elements as there are files. Each element is either empty or contains
// the absolute path to a file identical to the corresponding file in this // the absolute path to a file identical to the corresponding file in this
@ -301,15 +301,15 @@ namespace libtorrent
// This function should release all the file handles that it keeps open // This function should release all the file handles that it keeps open
// to files belonging to this storage. The default implementation just // to files belonging to this storage. The default implementation just
// calls file_pool::release_files(). // calls file_pool::release_files().
// //
// If an error occurs, ``storage_error`` should be set to reflect it. // If an error occurs, ``storage_error`` should be set to reflect it.
// //
virtual void release_files(storage_error& ec) = 0; virtual void release_files(storage_error& ec) = 0;
// Rename file with index ``index`` to the name ``new_filename``. // Rename file with index ``index`` to the name ``new_filename``.
// //
// If an error occurs, ``storage_error`` should be set to reflect it. // If an error occurs, ``storage_error`` should be set to reflect it.
// //
virtual void rename_file(int index, std::string const& new_filename virtual void rename_file(int index, std::string const& new_filename
, storage_error& ec) = 0; , storage_error& ec) = 0;
@ -317,12 +317,12 @@ namespace libtorrent
// The ``options`` parameter specifies whether to delete all files or just // The ``options`` parameter specifies whether to delete all files or just
// the partfile. ``options`` are set to the same value as the options // the partfile. ``options`` are set to the same value as the options
// passed to session::remove_torrent(). // passed to session::remove_torrent().
// //
// If an error occurs, ``storage_error`` should be set to reflect it. // If an error occurs, ``storage_error`` should be set to reflect it.
// //
// The ``disk_buffer_pool`` is used to allocate and free disk buffers. It // The ``disk_buffer_pool`` is used to allocate and free disk buffers. It
// has the following members:: // has the following members::
// //
// struct disk_buffer_pool : boost::noncopyable // struct disk_buffer_pool : boost::noncopyable
// { // {
// char* allocate_buffer(char const* category); // char* allocate_buffer(char const* category);
@ -335,21 +335,21 @@ namespace libtorrent
// //
// void release_memory(); // void release_memory();
// }; // };
// //
virtual void delete_files(int options, storage_error& ec) = 0; virtual void delete_files(int options, storage_error& ec) = 0;
#ifndef TORRENT_NO_DEPRECATE #ifndef TORRENT_NO_DEPRECATE
// This function is called each time a file is completely downloaded. The // This function is called each time a file is completely downloaded. The
// storage implementation can perform last operations on a file. The file // storage implementation can perform last operations on a file. The file
// will not be opened for writing after this. // will not be opened for writing after this.
// //
// ``index`` is the index of the file that completed. // ``index`` is the index of the file that completed.
// //
// On windows the default storage implementation clears the sparse file // On windows the default storage implementation clears the sparse file
// flag on the specified file. // flag on the specified file.
// //
// If an error occurs, ``storage_error`` should be set to reflect it. // If an error occurs, ``storage_error`` should be set to reflect it.
// //
virtual void finalize_file(int, storage_error&) {} virtual void finalize_file(int, storage_error&) {}
#endif #endif

View File

@ -184,7 +184,7 @@ namespace libtorrent
// the download speed class this piece falls into. // the download speed class this piece falls into.
// this is used internally to cluster peers of the same // this is used internally to cluster peers of the same
// speed class together when requesting blocks. // speed class together when requesting blocks.
// //
// set to either ``fast``, ``medium``, ``slow`` or ``none``. It tells // set to either ``fast``, ``medium``, ``slow`` or ``none``. It tells
// which download rate category the peers downloading this piece falls // which download rate category the peers downloading this piece falls
// into. ``none`` means that no peer is currently downloading any part of // into. ``none`` means that no peer is currently downloading any part of
@ -202,7 +202,7 @@ namespace libtorrent
// You will usually have to store your torrent handles somewhere, since it's // You will usually have to store your torrent handles somewhere, since it's
// the object through which you retrieve information about the torrent and // the object through which you retrieve information about the torrent and
// aborts the torrent. // aborts the torrent.
// //
// .. warning:: // .. warning::
// Any member function that returns a value or fills in a value has to be // 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 // made synchronously. This means it has to wait for the main thread to
@ -212,19 +212,19 @@ namespace libtorrent
// try to do it in as few calls as possible. You can get most of the // try to do it in as few calls as possible. You can get most of the
// interesting information about a torrent from the // interesting information about a torrent from the
// torrent_handle::status() call. // torrent_handle::status() call.
// //
// The default constructor will initialize the handle to an invalid state. // The default constructor will initialize the handle to an invalid state.
// Which means you cannot perform any operation on it, unless you first // 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 // assign it a valid handle. If you try to perform any operation on an
// uninitialized handle, it will throw ``invalid_handle``. // uninitialized handle, it will throw ``invalid_handle``.
// //
// .. warning:: // .. warning::
// All operations on a torrent_handle may throw system_error // All operations on a torrent_handle may throw system_error
// exception, in case the handle is no longer referring to a torrent. // exception, in case the handle is no longer referring to a torrent.
// There is one exception is_valid() will never throw. Since the torrents // There is one exception is_valid() will never throw. Since the torrents
// are processed by a background thread, there is no guarantee that a // are processed by a background thread, there is no guarantee that a
// handle will remain valid between two calls. // handle will remain valid between two calls.
// //
struct TORRENT_EXPORT torrent_handle struct TORRENT_EXPORT torrent_handle
{ {
// TODO: 3 consider replacing all the setters and getters for pause, // TODO: 3 consider replacing all the setters and getters for pause,
@ -272,11 +272,11 @@ namespace libtorrent
// This function starts an asynchronous read operation of the specified // This function starts an asynchronous read operation of the specified
// piece from this torrent. You must have completed the download of the // piece from this torrent. You must have completed the download of the
// specified piece before calling this function. // specified piece before calling this function.
// //
// When the read operation is completed, it is passed back through an // 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 // alert, read_piece_alert. Since this alert is a response to an explicit
// call, it will always be posted, regardless of the alert mask. // call, it will always be posted, regardless of the alert mask.
// //
// Note that if you read multiple pieces, the read operations are not // Note that if you read multiple pieces, the read operations are not
// guaranteed to finish in the same order as you initiated them. // guaranteed to finish in the same order as you initiated them.
void read_piece(int piece) const; void read_piece(int piece) const;
@ -335,7 +335,7 @@ namespace libtorrent
// Some information in there is relatively expensive to calculate, and if // Some information in there is relatively expensive to calculate, and if
// you're not interested in it (and see performance issues), you can // you're not interested in it (and see performance issues), you can
// filter them out. // filter them out.
// //
// By default everything is included. The flags you can use to decide // By default everything is included. The flags you can use to decide
// what to *include* are defined in the status_flags_t enum. // what to *include* are defined in the status_flags_t enum.
torrent_status status(std::uint32_t flags = 0xffffffff) const; torrent_status status(std::uint32_t flags = 0xffffffff) const;
@ -356,23 +356,23 @@ namespace libtorrent
// prioritized over pieces with a deadline further ahead in time. The // prioritized over pieces with a deadline further ahead in time. The
// deadline (and flags) of a piece can be changed by calling this // deadline (and flags) of a piece can be changed by calling this
// function again. // function again.
// //
// The ``flags`` parameter can be used to ask libtorrent to send an alert // The ``flags`` parameter can be used to ask libtorrent to send an alert
// once the piece has been downloaded, by passing alert_when_available. // once the piece has been downloaded, by passing alert_when_available.
// When set, the read_piece_alert alert will be delivered, with the piece // When set, the read_piece_alert alert will be delivered, with the piece
// data, when it's downloaded. // data, when it's downloaded.
// //
// If the piece is already downloaded when this call is made, nothing // 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 // happens, unless the alert_when_available flag is set, in which case it
// will do the same thing as calling read_piece() for ``index``. // will do the same thing as calling read_piece() for ``index``.
// //
// ``deadline`` is the number of milliseconds until this piece should be // ``deadline`` is the number of milliseconds until this piece should be
// completed. // completed.
// //
// ``reset_piece_deadline`` removes the deadline from the piece. If it // ``reset_piece_deadline`` removes the deadline from the piece. If it
// hasn't already been downloaded, it will no longer be considered a // hasn't already been downloaded, it will no longer be considered a
// priority. // priority.
// //
// ``clear_piece_deadlines()`` removes deadlines on all pieces in // ``clear_piece_deadlines()`` removes deadlines on all pieces in
// the torrent. As if reset_piece_deadline() was called on all pieces. // the torrent. As if reset_piece_deadline() was called on all pieces.
void set_piece_deadline(int index, int deadline, int flags = 0) const; void set_piece_deadline(int index, int deadline, int flags = 0) const;
@ -384,18 +384,18 @@ namespace libtorrent
// torrent determines how much bandwidth its peers are assigned when // torrent determines how much bandwidth its peers are assigned when
// distributing upload and download rate quotas. A high number gives more // distributing upload and download rate quotas. A high number gives more
// bandwidth. The priority must be within the range [0, 255]. // bandwidth. The priority must be within the range [0, 255].
// //
// The default priority is 0, which is the lowest priority. // The default priority is 0, which is the lowest priority.
// //
// To query the priority of a torrent, use the // To query the priority of a torrent, use the
// ``torrent_handle::status()`` call. // ``torrent_handle::status()`` call.
// //
// Torrents with higher priority will not necessarily get as much // Torrents with higher priority will not necessarily get as much
// bandwidth as they can consume, even if there's is more quota. Other // bandwidth as they can consume, even if there's is more quota. Other
// peers will still be weighed in when bandwidth is being distributed. // peers will still be weighed in when bandwidth is being distributed.
// With other words, bandwidth is not distributed strictly in order of // With other words, bandwidth is not distributed strictly in order of
// priority, but the priority is used as a weight. // priority, but the priority is used as a weight.
// //
// Peers whose Torrent has a higher priority will take precedence when // Peers whose Torrent has a higher priority will take precedence when
// distributing unchoke slots. This is a strict prioritization where // distributing unchoke slots. This is a strict prioritization where
// every interested peer on a high priority torrent will be unchoked // every interested peer on a high priority torrent will be unchoked
@ -432,7 +432,7 @@ namespace libtorrent
// not very cheap. Its complexity is *O(n + mj)*. Where *n* is the number // not very cheap. Its complexity is *O(n + mj)*. Where *n* is the number
// of files, *m* is the number of downloading pieces and *j* is the // of files, *m* is the number of downloading pieces and *j* is the
// number of blocks in a piece. // number of blocks in a piece.
// //
// The ``flags`` parameter can be used to specify the granularity of the // 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 // 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 // as accurate as possible, but also more expensive to calculate. If
@ -465,12 +465,12 @@ namespace libtorrent
// one returned from ``trackers()`` and will replace it. If you want an // one returned from ``trackers()`` and will replace it. If you want an
// immediate effect, you have to call force_reannounce(). See // immediate effect, you have to call force_reannounce(). See
// announce_entry. // announce_entry.
// //
// ``add_tracker()`` will look if the specified tracker is already in the // ``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 // 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 // of trackers, it will insert it in the tier specified in the
// announce_entry. // announce_entry.
// //
// The updated set of trackers will be saved in the resume data, and when // 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 // a torrent is started with resume data, the trackers from the resume
// data will replace the original ones. // data will replace the original ones.
@ -489,7 +489,7 @@ namespace libtorrent
// ``url_seeds()`` return a set of the url seeds currently in this // ``url_seeds()`` return a set of the url seeds currently in this
// torrent. Note that urls that fails may be removed automatically from // torrent. Note that urls that fails may be removed automatically from
// the list. // the list.
// //
// See http-seeding_ for more information. // See http-seeding_ for more information.
void add_url_seed(std::string const& url) const; void add_url_seed(std::string const& url) const;
void remove_url_seed(std::string const& url) const; void remove_url_seed(std::string const& url) const;
@ -497,7 +497,7 @@ namespace libtorrent
// These functions are identical as the ``*_url_seed()`` variants, but // These functions are identical as the ``*_url_seed()`` variants, but
// they operate on `BEP 17`_ web seeds instead of `BEP 19`_. // they operate on `BEP 17`_ web seeds instead of `BEP 19`_.
// //
// See http-seeding_ for more information. // See http-seeding_ for more information.
void add_http_seed(std::string const& url) const; void add_http_seed(std::string const& url) const;
void remove_http_seed(std::string const& url) const; void remove_http_seed(std::string const& url) const;
@ -546,10 +546,10 @@ namespace libtorrent
// connected) peers. Torrents may be paused automatically if there is a // connected) peers. Torrents may be paused automatically if there is a
// file error (e.g. disk full) or something similar. See // file error (e.g. disk full) or something similar. See
// file_error_alert. // file_error_alert.
// //
// To know if a torrent is paused or not, call // To know if a torrent is paused or not, call
// ``torrent_handle::status()`` and inspect ``torrent_status::paused``. // ``torrent_handle::status()`` and inspect ``torrent_status::paused``.
// //
// The ``flags`` argument to pause can be set to // The ``flags`` argument to pause can be set to
// ``torrent_handle::graceful_pause`` which will delay the disconnect of // ``torrent_handle::graceful_pause`` which will delay the disconnect of
// peers that we're still downloading outstanding requests from. The // peers that we're still downloading outstanding requests from. The
@ -557,13 +557,13 @@ namespace libtorrent
// peers. As soon as a peer is done transferring the blocks that were // 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 // requested from it, it is disconnected. This is a graceful shut down of
// the torrent in the sense that no downloaded bytes are wasted. // the torrent in the sense that no downloaded bytes are wasted.
// //
// .. note:: // .. note::
// Torrents that are auto-managed may be automatically resumed again. It // Torrents that are auto-managed may be automatically resumed again. It
// does not make sense to pause an auto-managed torrent without making it // does not make sense to pause an auto-managed torrent without making it
// not automanaged first. Torrents are auto-managed by default when added // not automanaged first. Torrents are auto-managed by default when added
// to the session. For more information, see queuing_. // to the session. For more information, see queuing_.
// //
void pause(int flags = 0) const; void pause(int flags = 0) const;
void resume() const; void resume() const;
@ -575,23 +575,23 @@ namespace libtorrent
// to do so. A torrent may need to have its files checked for instance, so // to do so. A torrent may need to have its files checked for instance, so
// it needs to be started and possibly queued for checking (auto-managed // it needs to be started and possibly queued for checking (auto-managed
// and started) but as soon as it's done, it should be stopped. // and started) but as soon as it's done, it should be stopped.
// //
// *Force stopped* means auto-managed is set to false and it's paused. As // *Force stopped* means auto-managed is set to false and it's paused. As
// if auto_manage(false) and pause() were called on the torrent. // if auto_manage(false) and pause() were called on the torrent.
// //
// Note that the torrent may transition into a downloading state while // Note that the torrent may transition into a downloading state while
// calling this function, and since the logic is edge triggered you may // calling this function, and since the logic is edge triggered you may
// miss the edge. To avoid this race, if the torrent already is in a // miss the edge. To avoid this race, if the torrent already is in a
// downloading state when this call is made, it will trigger the // downloading state when this call is made, it will trigger the
// stop-when-ready immediately. // stop-when-ready immediately.
// //
// When the stop-when-ready logic fires, the flag is cleared. Any // When the stop-when-ready logic fires, the flag is cleared. Any
// subsequent transitions between downloading and non-downloading states // subsequent transitions between downloading and non-downloading states
// will not be affected, until this function is used to set it again. // will not be affected, until this function is used to set it again.
// //
// The behavior is more robust when setting this flag as part of adding // The behavior is more robust when setting this flag as part of adding
// the torrent. See add_torrent_params. // the torrent. See add_torrent_params.
// //
// The stop-when-ready flag fixes the inherent race condition of waiting // The stop-when-ready flag fixes the inherent race condition of waiting
// for the state_changed_alert and then call pause(). The download/seeding // for the state_changed_alert and then call pause(). The download/seeding
// will most likely start in between posting the alert and receiving the // will most likely start in between posting the alert and receiving the
@ -604,9 +604,9 @@ namespace libtorrent
// ``settings_pack::optimistic_disk_retry``). Torrents are // ``settings_pack::optimistic_disk_retry``). Torrents are
// automatically put in upload mode whenever they encounter a disk write // automatically put in upload mode whenever they encounter a disk write
// error. // error.
// //
// ``m`` should be true to enter upload mode, and false to leave it. // ``m`` should be true to enter upload mode, and false to leave it.
// //
// To test if a torrent is in upload mode, call // To test if a torrent is in upload mode, call
// ``torrent_handle::status()`` and inspect // ``torrent_handle::status()`` and inspect
// ``torrent_status::upload_mode``. // ``torrent_status::upload_mode``.
@ -622,7 +622,7 @@ namespace libtorrent
// Instructs libtorrent to flush all the disk caches for this torrent and // Instructs libtorrent to flush all the disk caches for this torrent and
// close all file handles. This is done asynchronously and you will be // close all file handles. This is done asynchronously and you will be
// notified that it's complete through cache_flushed_alert. // notified that it's complete through cache_flushed_alert.
// //
// Note that by the time you get the alert, libtorrent may have cached // 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 // more data for the torrent, but you are guaranteed that whatever cached
// data libtorrent had by the time you called // data libtorrent had by the time you called
@ -667,32 +667,32 @@ namespace libtorrent
// ``save_resume_data()`` asks libtorrent to generate fast-resume data for // ``save_resume_data()`` asks libtorrent to generate fast-resume data for
// this torrent. // this torrent.
// //
// The ``flags`` argument is a bitmask of flags ORed together. see // The ``flags`` argument is a bitmask of flags ORed together. see
// save_resume_flags_t // save_resume_flags_t
// //
// This operation is asynchronous, ``save_resume_data`` will return // This operation is asynchronous, ``save_resume_data`` will return
// immediately. The resume data is delivered when it's done through an // immediately. The resume data is delivered when it's done through an
// save_resume_data_alert. // save_resume_data_alert.
// //
// The fast resume data will be empty in the following cases: // The fast resume data will be empty in the following cases:
// //
// 1. The torrent handle is invalid. // 1. The torrent handle is invalid.
// 2. The torrent hasn't received valid metadata and was started without // 2. The torrent hasn't received valid metadata and was started without
// metadata (see libtorrent's metadata-from-peers_ extension) // metadata (see libtorrent's metadata-from-peers_ extension)
// //
// Note that by the time you receive the fast resume data, it may already // Note that by the time you receive the fast resume data, it may already
// be invalid if the torrent is still downloading! The recommended // be invalid if the torrent is still downloading! The recommended
// practice is to first pause the session, then generate the fast resume // 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 // 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 // you receive the save_resume_data_alert though. There's no need to
// pause when saving intermittent resume data. // pause when saving intermittent resume data.
// //
//.. warning:: //.. warning::
// If you pause every torrent individually instead of pausing the // If you pause every torrent individually instead of pausing the
// session, every torrent will have its paused state saved in the // session, every torrent will have its paused state saved in the
// resume data! // resume data!
// //
//.. warning:: //.. warning::
// The resume data contains the modification timestamps for all files. // The resume data contains the modification timestamps for all files.
// If one file has been modified when the torrent is added again, the // If one file has been modified when the torrent is added again, the
@ -701,7 +701,7 @@ namespace libtorrent
// file timestamps are up to date and won't be modified after saving // file timestamps are up to date and won't be modified after saving
// the resume data. The recommended way to do this is to pause the // the resume data. The recommended way to do this is to pause the
// torrent, which will flush the cache and disconnect all peers. // torrent, which will flush the cache and disconnect all peers.
// //
//.. note:: //.. note::
// It is typically a good idea to save resume data whenever a torrent // 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 // is completed or paused. In those cases you don't need to pause the
@ -711,26 +711,26 @@ namespace libtorrent
// data again for paused torrents. Completed torrents should have their // data again for paused torrents. Completed torrents should have their
// resume data saved when they complete and on exit, since their // resume data saved when they complete and on exit, since their
// statistics might be updated. // statistics might be updated.
// //
// In full allocation mode the resume data is never invalidated by // In full allocation mode the resume data is never invalidated by
// subsequent writes to the files, since pieces won't move around. This // 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 // 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 // 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. // you saved resume data and before the session closed is lost.
// //
// It also means that if the resume data is out dated, libtorrent will // 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 // 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 // assumption is that it's better to loose a little bit than to re-check
// the entire file. // the entire file.
// //
// It is still a good idea to save resume data periodically during // It is still a good idea to save resume data periodically during
// download as well as when closing down. // download as well as when closing down.
// //
// Example code to pause and save resume data for all torrents and wait // Example code to pause and save resume data for all torrents and wait
// for the alerts: // for the alerts:
// //
// .. code:: c++ // .. code:: c++
// //
// extern int outstanding_resume_data; // global counter of outstanding resume data // extern int outstanding_resume_data; // global counter of outstanding resume data
// std::vector<torrent_handle> handles = ses.get_torrents(); // std::vector<torrent_handle> handles = ses.get_torrents();
// ses.pause(); // ses.pause();
@ -752,7 +752,7 @@ namespace libtorrent
// //
// // if we don't get an alert within 10 seconds, abort // // if we don't get an alert within 10 seconds, abort
// if (a == 0) break; // if (a == 0) break;
// //
// std::vector<alert*> alerts; // std::vector<alert*> alerts;
// ses.pop_alerts(&alerts); // ses.pop_alerts(&alerts);
// //
@ -771,7 +771,7 @@ namespace libtorrent
// process_alert(a); // process_alert(a);
// continue; // continue;
// } // }
// //
// torrent_handle h = rd->handle; // torrent_handle h = rd->handle;
// torrent_status st = h.status(torrent_handle::query_save_path // torrent_status st = h.status(torrent_handle::query_save_path
// | torrent_handle::query_name); // | torrent_handle::query_name);
@ -783,7 +783,7 @@ namespace libtorrent
// --outstanding_resume_data; // --outstanding_resume_data;
// } // }
// } // }
// //
//.. note:: //.. note::
// Note how ``outstanding_resume_data`` is a global counter in this // Note how ``outstanding_resume_data`` is a global counter in this
// example. This is deliberate, otherwise there is a race condition for // example. This is deliberate, otherwise there is a race condition for
@ -813,18 +813,18 @@ namespace libtorrent
// greater than the greatest queue position of all existing torrents. // greater than the greatest queue position of all existing torrents.
// Torrents that are being seeded have -1 as their queue position, since // Torrents that are being seeded have -1 as their queue position, since
// they're no longer in line to be downloaded. // they're no longer in line to be downloaded.
// //
// When a torrent is removed or turns into a seed, all torrents with // When a torrent is removed or turns into a seed, all torrents with
// greater queue positions have their positions decreased to fill in the // greater queue positions have their positions decreased to fill in the
// space in the sequence. // space in the sequence.
// //
// ``queue_position()`` returns the torrent's position in the download // ``queue_position()`` returns the torrent's position in the download
// queue. The torrents with the smallest numbers are the ones that are // queue. The torrents with the smallest numbers are the ones that are
// being downloaded. The smaller number, the closer the torrent is to the // being downloaded. The smaller number, the closer the torrent is to the
// front of the line to be started. // front of the line to be started.
// //
// The queue position is also available in the torrent_status. // The queue position is also available in the torrent_status.
// //
// The ``queue_position_*()`` functions adjust the torrents position in // The ``queue_position_*()`` functions adjust the torrents position in
// the queue. Up means closer to the front and down means closer to the // 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 // back of the queue. Top and bottom refers to the front and the back of
@ -843,26 +843,26 @@ namespace libtorrent
// private key and DH params as strings, rather than paths to files. This // private key and DH params as strings, rather than paths to files. This
// overload is only available when libtorrent is built against boost // overload is only available when libtorrent is built against boost
// 1.54 or later. // 1.54 or later.
// //
// ``cert`` is a path to the (signed) certificate in .pem format // ``cert`` is a path to the (signed) certificate in .pem format
// corresponding to this torrent. // corresponding to this torrent.
// //
// ``private_key`` is a path to the private key for the specified // ``private_key`` is a path to the private key for the specified
// certificate. This must be in .pem format. // certificate. This must be in .pem format.
// //
// ``dh_params`` is a path to the Diffie-Hellman parameter file, which // ``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 // needs to be in .pem format. You can generate this file using the
// openssl command like this: ``openssl dhparam -outform PEM -out // openssl command like this: ``openssl dhparam -outform PEM -out
// dhparams.pem 512``. // dhparams.pem 512``.
// //
// ``passphrase`` may be specified if the private key is encrypted and // ``passphrase`` may be specified if the private key is encrypted and
// requires a passphrase to be decrypted. // requires a passphrase to be decrypted.
// //
// Note that when a torrent first starts up, and it needs a certificate, // 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 // it will suspend connecting to any peers until it has one. It's
// typically desirable to resume the torrent after setting the ssl // typically desirable to resume the torrent after setting the ssl
// certificate. // certificate.
// //
// If you receive a torrent_need_cert_alert, you need to call this to // 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 // provide a valid cert. If you don't have a cert you won't be allowed to
// connect to any peers. // connect to any peers.
@ -977,7 +977,7 @@ namespace libtorrent
// each piece in this torrent. libtorrent does not keep track of // each piece in this torrent. libtorrent does not keep track of
// availability for seeds, so if the torrent is seeding the availability // availability for seeds, so if the torrent is seeding the availability
// for all pieces is reported as 0. // for all pieces is reported as 0.
// //
// The piece availability is the number of peers that we are connected // The piece availability is the number of peers that we are connected
// that has advertised having a particular piece. This is the information // that has advertised having a particular piece. This is the information
// that libtorrent uses in order to prefer picking rare pieces. // that libtorrent uses in order to prefer picking rare pieces.
@ -991,15 +991,15 @@ namespace libtorrent
// lower priority values means less likely to be picked. Piece priority // lower priority values means less likely to be picked. Piece priority
// takes precedence over piece availability. Every priority-7 piece will // takes precedence over piece availability. Every priority-7 piece will
// be attempted to be picked before a priority 6 piece and so on. // be attempted to be picked before a priority 6 piece and so on.
// //
// Piece priorities can not be changed for torrents that have not // Piece priorities can not be changed for torrents that have not
// downloaded the metadata yet. For instance, magnet links and torrents // downloaded the metadata yet. For instance, magnet links and torrents
// added by URL won't have metadata immediately. see the // added by URL won't have metadata immediately. see the
// metadata_received_alert. // metadata_received_alert.
// //
// ``piece_priority`` sets or gets the priority for an individual piece, // ``piece_priority`` sets or gets the priority for an individual piece,
// specified by ``index``. // specified by ``index``.
// //
// ``prioritize_pieces`` takes a vector of integers, one integer per // ``prioritize_pieces`` takes a vector of integers, one integer per
// piece in the torrent. All the piece priorities will be updated with // piece in the torrent. All the piece priorities will be updated with
// the priorities in the vector. // the priorities in the vector.
@ -1009,7 +1009,7 @@ namespace libtorrent
// the piece index and the second item is the priority of that piece. // 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 // Invalid entries, where the piece index or priority is out of range, are
// not allowed. // not allowed.
// //
// ``piece_priorities`` returns a vector with one element for each piece // ``piece_priorities`` returns a vector with one element for each piece
// in the torrent. Each element is the current priority of that piece. // in the torrent. Each element is the current priority of that piece.
void piece_priority(int index, int priority) const; void piece_priority(int index, int priority) const;
@ -1019,24 +1019,24 @@ namespace libtorrent
std::vector<int> piece_priorities() const; std::vector<int> piece_priorities() const;
// ``index`` must be in the range [0, number_of_files). // ``index`` must be in the range [0, number_of_files).
// //
// ``file_priority()`` queries or sets the priority of file ``index``. // ``file_priority()`` queries or sets the priority of file ``index``.
// //
// ``prioritize_files()`` takes a vector that has at as many elements as // ``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 // 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 // file. The function sets the priorities of all the pieces in the
// torrent based on the vector. // torrent based on the vector.
// //
// ``file_priorities()`` returns a vector with the priorities of all // ``file_priorities()`` returns a vector with the priorities of all
// files. // files.
// //
// The priority values are the same as for piece_priority(). // The priority values are the same as for piece_priority().
// //
// Whenever a file priority is changed, all other piece priorities are // Whenever a file priority is changed, all other piece priorities are
// reset to match the file priorities. In order to maintain special // reset to match the file priorities. In order to maintain special
// priorities for particular pieces, piece_priority() has to be called // priorities for particular pieces, piece_priority() has to be called
// again for those pieces. // again for those pieces.
// //
// You cannot set the file priorities on a torrent that does not yet have // 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 // metadata or a torrent that is a seed. ``file_priority(int, int)`` and
// prioritize_files() are both no-ops for such torrents. // prioritize_files() are both no-ops for such torrents.
@ -1048,7 +1048,7 @@ namespace libtorrent
// ``force_reannounce()`` will force this torrent to do another tracker // ``force_reannounce()`` will force this torrent to do another tracker
// request, to receive new peers. The ``seconds`` argument specifies how // request, to receive new peers. The ``seconds`` argument specifies how
// many seconds from now to issue the tracker announces. // many seconds from now to issue the tracker announces.
// //
// If the tracker's ``min_interval`` has not passed since the last // If the tracker's ``min_interval`` has not passed since the last
// announce, the forced announce will be scheduled to happen immediately // announce, the forced announce will be scheduled to happen immediately
// as the ``min_interval`` expires. This is to honor trackers minimum // as the ``min_interval`` expires. This is to honor trackers minimum
@ -1056,7 +1056,7 @@ namespace libtorrent
// //
// The ``tracker_index`` argument specifies which tracker to re-announce. // The ``tracker_index`` argument specifies which tracker to re-announce.
// If set to -1 (which is the default), all trackers are re-announce. // If set to -1 (which is the default), all trackers are re-announce.
// //
// ``force_dht_announce`` will announce the torrent to the DHT // ``force_dht_announce`` will announce the torrent to the DHT
// immediately. // immediately.
void force_reannounce(int seconds = 0, int tracker_index = -1) const; void force_reannounce(int seconds = 0, int tracker_index = -1) const;
@ -1074,10 +1074,10 @@ namespace libtorrent
// ``scrape_tracker()`` will send a scrape request to a tracker. By // ``scrape_tracker()`` will send a scrape request to a tracker. By
// default (``idx`` = -1) it will scrape the last working tracker. If // default (``idx`` = -1) it will scrape the last working tracker. If
// ``idx`` is >= 0, the tracker with the specified index will scraped. // ``idx`` is >= 0, the tracker with the specified index will scraped.
// //
// A scrape request queries the tracker for statistics such as total // A scrape request queries the tracker for statistics such as total
// number of incomplete peers, complete peers, number of downloads etc. // number of incomplete peers, complete peers, number of downloads etc.
// //
// This request will specifically update the ``num_complete`` and // This request will specifically update the ``num_complete`` and
// ``num_incomplete`` fields in the torrent_status struct once it // ``num_incomplete`` fields in the torrent_status struct once it
// completes. When it completes, it will generate a scrape_reply_alert. // completes. When it completes, it will generate a scrape_reply_alert.
@ -1093,7 +1093,7 @@ namespace libtorrent
// (``settings_pack::upload_rate_limit``) will not override the global // (``settings_pack::upload_rate_limit``) will not override the global
// rate limit. The torrent can never upload more than the global rate // rate limit. The torrent can never upload more than the global rate
// limit. // limit.
// //
// ``upload_limit`` and ``download_limit`` will return the current limit // ``upload_limit`` and ``download_limit`` will return the current limit
// setting, for upload and download, respectively. // setting, for upload and download, respectively.
void set_upload_limit(int limit) const; void set_upload_limit(int limit) const;
@ -1106,16 +1106,16 @@ namespace libtorrent
// loading and unloading of torrents is enabled (by setting a load // loading and unloading of torrents is enabled (by setting a load
// function on the session), this can be used to exempt certain torrents // function on the session), this can be used to exempt certain torrents
// from the unloading logic. // from the unloading logic.
// //
// Magnet links, and other torrents that start out without having // Magnet links, and other torrents that start out without having
// metadata are pinned automatically. This is to give the client a chance // metadata are pinned automatically. This is to give the client a chance
// to get the metadata and save it before it's unloaded. In this case, it // to get the metadata and save it before it's unloaded. In this case, it
// may be useful to un-pin the torrent once its metadata has been saved // may be useful to un-pin the torrent once its metadata has been saved
// to disk. // to disk.
// //
// For more information about dynamically loading and unloading torrents, // For more information about dynamically loading and unloading torrents,
// see dynamic-loading-of-torrent-files_. // see dynamic-loading-of-torrent-files_.
// //
void set_pinned(bool p) const; void set_pinned(bool p) const;
#endif #endif
@ -1124,7 +1124,7 @@ namespace libtorrent
// instead of rarest first. In this mode, piece priorities are ignored, // instead of rarest first. In this mode, piece priorities are ignored,
// with the exception of priority 7, which are still preferred over the // with the exception of priority 7, which are still preferred over the
// sequential piece order. // sequential piece order.
// //
// Enabling sequential download will affect the piece distribution // Enabling sequential download will affect the piece distribution
// negatively in the swarm. It should be used sparingly. // negatively in the swarm. It should be used sparingly.
void set_sequential_download(bool sd) const; void set_sequential_download(bool sd) const;
@ -1143,12 +1143,12 @@ namespace libtorrent
// //
// ==== ========================================== // ==== ==========================================
// 0x01 peer supports encryption. // 0x01 peer supports encryption.
// //
// 0x02 peer is a seed // 0x02 peer is a seed
// //
// 0x04 supports uTP. If this is not set, the peer will only be contacted // 0x04 supports uTP. If this is not set, the peer will only be contacted
// over TCP. // over TCP.
// //
// 0x08 supports holepunching protocol. If this // 0x08 supports holepunching protocol. If this
// flag is received from a peer, it can be // flag is received from a peer, it can be
// used as a rendezvous point in case direct // used as a rendezvous point in case direct
@ -1162,7 +1162,7 @@ namespace libtorrent
// no limit. This defaults to infinite. The primary setting controlling // no limit. This defaults to infinite. The primary setting controlling
// this is the global unchoke slots limit, set by unchoke_slots_limit in // this is the global unchoke slots limit, set by unchoke_slots_limit in
// settings_pack. // settings_pack.
// //
// ``max_uploads()`` returns the current settings. // ``max_uploads()`` returns the current settings.
void set_max_uploads(int max_uploads) const; void set_max_uploads(int max_uploads) const;
int max_uploads() const; int max_uploads() const;
@ -1174,7 +1174,7 @@ namespace libtorrent
// -1 is given to the function, it means unlimited. There is also a // -1 is given to the function, it means unlimited. There is also a
// global limit of the number of connections, set by // global limit of the number of connections, set by
// ``connections_limit`` in settings_pack. // ``connections_limit`` in settings_pack.
// //
// ``max_connections()`` returns the current settings. // ``max_connections()`` returns the current settings.
void set_max_connections(int max_connections) const; void set_max_connections(int max_connections) const;
int max_connections() const; int max_connections() const;
@ -1193,24 +1193,24 @@ namespace libtorrent
// drive and removed from their original location. This will block all // drive and removed from their original location. This will block all
// other disk IO, and other torrents download and upload rates may drop // other disk IO, and other torrents download and upload rates may drop
// while copying the file. // while copying the file.
// //
// Since disk IO is performed in a separate thread, this operation is // Since disk IO is performed in a separate thread, this operation is
// also asynchronous. Once the operation completes, the // also asynchronous. Once the operation completes, the
// ``storage_moved_alert`` is generated, with the new path as the // ``storage_moved_alert`` is generated, with the new path as the
// message. If the move fails for some reason, // message. If the move fails for some reason,
// ``storage_moved_failed_alert`` is generated instead, containing the // ``storage_moved_failed_alert`` is generated instead, containing the
// error message. // error message.
// //
// The ``flags`` argument determines the behavior of the copying/moving // The ``flags`` argument determines the behavior of the copying/moving
// of the files in the torrent. see move_flags_t. // of the files in the torrent. see move_flags_t.
// //
// * always_replace_files = 0 // * always_replace_files = 0
// * fail_if_exist = 1 // * fail_if_exist = 1
// * dont_replace = 2 // * dont_replace = 2
// //
// ``always_replace_files`` is the default and replaces any file that // ``always_replace_files`` is the default and replaces any file that
// exist in both the source directory and the target directory. // exist in both the source directory and the target directory.
// //
// ``fail_if_exist`` first check to see that none of the copy operations // ``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 // 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 // proceed as if it was in ``always_replace_files`` mode. Note that there
@ -1220,15 +1220,15 @@ namespace libtorrent
// already existing in the target path, the ``error`` of // already existing in the target path, the ``error`` of
// ``move_storage_failed_alert`` is set to // ``move_storage_failed_alert`` is set to
// ``boost::system::errc::file_exists``. // ``boost::system::errc::file_exists``.
// //
// The intention is that a client may use this as a probe, and if it // 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 // fails, ask the user which mode to use. The client may then re-issue
// the ``move_storage`` call with one of the other modes. // the ``move_storage`` call with one of the other modes.
// //
// ``dont_replace`` always takes the existing file in the target // ``dont_replace`` always takes the existing file in the target
// directory, if there is one. The source files will still be removed in // directory, if there is one. The source files will still be removed in
// that case. // that case.
// //
// Files that have been renamed to have absolute paths are not moved by // 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 // 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 // torrent but are stored in the torrent's directory may be moved as

View File

@ -120,15 +120,15 @@ namespace libtorrent
// internally when downloading torrents without the metadata. The // internally when downloading torrents without the metadata. The
// metadata will be created by libtorrent as soon as it has been // metadata will be created by libtorrent as soon as it has been
// downloaded from the swarm. // downloaded from the swarm.
// //
// The constructor that takes a bdecode_node will create a torrent_info // The constructor that takes a bdecode_node will create a torrent_info
// object from the information found in the given torrent_file. The // object from the information found in the given torrent_file. The
// bdecode_node represents a tree node in an bencoded file. To load an // bdecode_node represents a tree node in an bencoded file. To load an
// ordinary .torrent file into a bdecode_node, use bdecode(). // ordinary .torrent file into a bdecode_node, use bdecode().
// //
// The version that takes a buffer pointer and a size will decode it as a // The version that takes a buffer pointer and a size will decode it as a
// .torrent file and initialize the torrent_info object for you. // .torrent file and initialize the torrent_info object for you.
// //
// The version that takes a filename will simply load the torrent file // The version that takes a filename will simply load the torrent file
// and decode it inside the constructor, for convenience. This might not // and decode it inside the constructor, for convenience. This might not
// be the most suitable for applications that want to be able to report // be the most suitable for applications that want to be able to report
@ -137,14 +137,14 @@ namespace libtorrent
// There is an upper limit on the size of the torrent file that will be // There is an upper limit on the size of the torrent file that will be
// loaded by the overload taking a filename. If it's important that even // loaded by the overload taking a filename. If it's important that even
// very large torrent files are loaded, use one of the other overloads. // very large torrent files are loaded, use one of the other overloads.
// //
// The overloads that takes an ``error_code const&`` never throws if an // The overloads that takes an ``error_code const&`` never throws if an
// error occur, they will simply set the error code to describe what went // error occur, they will simply set the error code to describe what went
// wrong and not fully initialize the torrent_info object. The overloads // wrong and not fully initialize the torrent_info object. The overloads
// that do not take the extra error_code parameter will always throw if // that do not take the extra error_code parameter will always throw if
// an error occurs. These overloads are not available when building // an error occurs. These overloads are not available when building
// without exception support. // without exception support.
// //
// The ``flags`` argument is currently unused. // The ``flags`` argument is currently unused.
#ifndef BOOST_NO_EXCEPTIONS #ifndef BOOST_NO_EXCEPTIONS
explicit torrent_info(bdecode_node const& torrent_file, int flags = 0); explicit torrent_info(bdecode_node const& torrent_file, int flags = 0);
@ -182,12 +182,12 @@ namespace libtorrent
// having a torrent file. When renaming files in a storage, the storage // having a torrent file. When renaming files in a storage, the storage
// needs to make its own copy of the file_storage in order to make its // needs to make its own copy of the file_storage in order to make its
// mapping differ from the one in the torrent file. // mapping differ from the one in the torrent file.
// //
// ``orig_files()`` returns the original (unmodified) file storage for // ``orig_files()`` returns the original (unmodified) file storage for
// this torrent. This is used by the web server connection, which needs // this torrent. This is used by the web server connection, which needs
// to request files with the original names. Filename may be changed using // to request files with the original names. Filename may be changed using
// ``torrent_info::rename_file()``. // ``torrent_info::rename_file()``.
// //
// For more information on the file_storage object, see the separate // For more information on the file_storage object, see the separate
// document on how to create torrents. // document on how to create torrents.
file_storage const& files() const { return m_files; } file_storage const& files() const { return m_files; }
@ -200,11 +200,11 @@ namespace libtorrent
// Renames a the file with the specified index to the new name. The new // Renames a the file with the specified index to the new name. The new
// filename is reflected by the ``file_storage`` returned by ``files()`` // filename is reflected by the ``file_storage`` returned by ``files()``
// but not by the one returned by ``orig_files()``. // but not by the one returned by ``orig_files()``.
// //
// If you want to rename the base name of the torrent (for a multifile // If you want to rename the base name of the torrent (for a multifile
// torrent), you can copy the ``file_storage`` (see files() and // torrent), you can copy the ``file_storage`` (see files() and
// orig_files() ), change the name, and then use `remap_files()`_. // orig_files() ), change the name, and then use `remap_files()`_.
// //
// The ``new_filename`` can both be a relative path, in which case the // The ``new_filename`` can both be a relative path, in which case the
// file name is relative to the ``save_path`` of the torrent. If the // file name is relative to the ``save_path`` of the torrent. If the
// ``new_filename`` is an absolute path (i.e. ``is_complete(new_filename) // ``new_filename`` is an absolute path (i.e. ``is_complete(new_filename)
@ -232,7 +232,7 @@ namespace libtorrent
// instance, download all data in a torrent to a single file, or to a // instance, download all data in a torrent to a single file, or to a
// number of fixed size sector aligned files, regardless of the number // number of fixed size sector aligned files, regardless of the number
// and sizes of the files in the torrent. // and sizes of the files in the torrent.
// //
// The new specified ``file_storage`` must have the exact same size as // The new specified ``file_storage`` must have the exact same size as
// the current one. // the current one.
void remap_files(file_storage const& f); void remap_files(file_storage const& f);
@ -254,7 +254,7 @@ namespace libtorrent
// "collections" keys in the .torrent file. Both info-hashes and // "collections" keys in the .torrent file. Both info-hashes and
// collections from within the info-dict and from outside of it are // collections from within the info-dict and from outside of it are
// included. // included.
// //
// .. _BEP38: http://www.bittorrent.org/beps/bep_0038.html // .. _BEP38: http://www.bittorrent.org/beps/bep_0038.html
std::vector<sha1_hash> similar_torrents() const; std::vector<sha1_hash> similar_torrents() const;
std::vector<std::string> collections() const; std::vector<std::string> collections() const;
@ -275,23 +275,23 @@ namespace libtorrent
// ``web_seeds()`` returns all url seeds and http seeds in the torrent. // ``web_seeds()`` returns all url seeds and http seeds in the torrent.
// Each entry is a ``web_seed_entry`` and may refer to either a url seed // Each entry is a ``web_seed_entry`` and may refer to either a url seed
// or http seed. // or http seed.
// //
// ``add_url_seed()`` and ``add_http_seed()`` adds one url to the list of // ``add_url_seed()`` and ``add_http_seed()`` adds one url to the list of
// url/http seeds. Currently, the only transport protocol supported for // url/http seeds. Currently, the only transport protocol supported for
// the url is http. // the url is http.
// //
// ``set_web_seeds()`` replaces all web seeds with the ones specified in // ``set_web_seeds()`` replaces all web seeds with the ones specified in
// the ``seeds`` vector. // the ``seeds`` vector.
// //
// The ``extern_auth`` argument can be used for other authorization // The ``extern_auth`` argument can be used for other authorization
// schemes than basic HTTP authorization. If set, it will override any // schemes than basic HTTP authorization. If set, it will override any
// username and password found in the URL itself. The string will be sent // username and password found in the URL itself. The string will be sent
// as the HTTP authorization header's value (without specifying "Basic"). // as the HTTP authorization header's value (without specifying "Basic").
// //
// The ``extra_headers`` argument defaults to an empty list, but can be // The ``extra_headers`` argument defaults to an empty list, but can be
// used to insert custom HTTP headers in the requests to a specific web // used to insert custom HTTP headers in the requests to a specific web
// seed. // seed.
// //
// See http-seeding_ for more information. // See http-seeding_ for more information.
void add_url_seed(std::string const& url void add_url_seed(std::string const& url
, std::string const& extern_auth = std::string() , std::string const& extern_auth = std::string()
@ -328,7 +328,7 @@ namespace libtorrent
// ``end_files()``, ``rbegin_files()`` and ``rend_files()``. These will // ``end_files()``, ``rbegin_files()`` and ``rend_files()``. These will
// give you standard vector iterators with the type // give you standard vector iterators with the type
// ``internal_file_entry``, which is an internal type. // ``internal_file_entry``, which is an internal type.
// //
// You can resolve it into the public representation of a file // You can resolve it into the public representation of a file
// (``file_entry``) using the ``file_storage::at`` function, which takes // (``file_entry``) using the ``file_storage::at`` function, which takes
// an index and an iterator. // an index and an iterator.
@ -364,7 +364,7 @@ namespace libtorrent
// This function will map a range in a specific file into a range in the // This function will map a range in a specific file into a range in the
// torrent. The ``file_offset`` parameter is the offset in the file, // torrent. The ``file_offset`` parameter is the offset in the file,
// given in bytes, where 0 is the start of the file. See peer_request. // given in bytes, where 0 is the start of the file. See peer_request.
// //
// The input range is assumed to be valid within the torrent. // The input range is assumed to be valid within the torrent.
// ``file_offset`` + ``size`` is not allowed to be greater than the file // ``file_offset`` + ``size`` is not allowed to be greater than the file
// size. ``file_index`` must refer to a valid file, i.e. it cannot be >= // size. ``file_index`` must refer to a valid file, i.e. it cannot be >=
@ -438,7 +438,7 @@ namespace libtorrent
// ``merkle_tree()`` returns a reference to the merkle tree for this // ``merkle_tree()`` returns a reference to the merkle tree for this
// torrent, if any. // torrent, if any.
// //
// ``set_merkle_tree()`` moves the passed in merkle tree into the // ``set_merkle_tree()`` moves the passed in merkle tree into the
// torrent_info object. i.e. ``h`` will not be identical after the call. // torrent_info object. i.e. ``h`` will not be identical after the call.
// You need to set the merkle tree for a torrent that you've just created // You need to set the merkle tree for a torrent that you've just created
@ -451,18 +451,18 @@ namespace libtorrent
{ TORRENT_ASSERT(h.size() == m_merkle_tree.size() ); m_merkle_tree.swap(h); } { TORRENT_ASSERT(h.size() == m_merkle_tree.size() ); m_merkle_tree.swap(h); }
// ``name()`` returns the name of the torrent. // ``name()`` returns the name of the torrent.
// //
// ``comment()`` returns the comment associated with the torrent. If // ``comment()`` returns the comment associated with the torrent. If
// there's no comment, it will return an empty string. // there's no comment, it will return an empty string.
// ``creation_date()`` returns the creation date of the torrent as time_t // ``creation_date()`` returns the creation date of the torrent as time_t
// (`posix time`_). If there's no time stamp in the torrent file, the // (`posix time`_). If there's no time stamp in the torrent file, the
// optional object will be uninitialized. // optional object will be uninitialized.
// //
// Both the name and the comment is UTF-8 encoded strings. // Both the name and the comment is UTF-8 encoded strings.
// //
// ``creator()`` returns the creator string in the torrent. If there is // ``creator()`` returns the creator string in the torrent. If there is
// no creator string it will return an empty string. // no creator string it will return an empty string.
// //
// .. _`posix time`: http://www.opengroup.org/onlinepubs/009695399/functions/time.html // .. _`posix time`: http://www.opengroup.org/onlinepubs/009695399/functions/time.html
const std::string& name() const { return m_files.name(); } const std::string& name() const { return m_files.name(); }
time_t creation_date() const time_t creation_date() const

View File

@ -74,7 +74,7 @@ namespace libtorrent
int live_allocations() const { return m_live_allocations; } int live_allocations() const { return m_live_allocations; }
private: private:
// this is a shared pool where torrent_peer objects // this is a shared pool where torrent_peer objects
// are allocated. It's a pool since we're likely // are allocated. It's a pool since we're likely
// to have tens of thousands of peers, and a pool // to have tens of thousands of peers, and a pool

View File

@ -271,7 +271,7 @@ namespace libtorrent
// progress parts per million (progress * 1000000) when disabling // progress parts per million (progress * 1000000) when disabling
// floating point operations, this is the only option to query progress // floating point operations, this is the only option to query progress
// //
// reflects the same value as ``progress``, but instead in a range [0, // reflects the same value as ``progress``, but instead in a range [0,
// 1000000] (ppm = parts per million). When floating point operations are // 1000000] (ppm = parts per million). When floating point operations are
// disabled, this is the only alternative to the floating point value in // disabled, this is the only alternative to the floating point value in
@ -339,12 +339,12 @@ namespace libtorrent
// tells the share of pieces that have more copies than the rarest // tells the share of pieces that have more copies than the rarest
// piece(s). Divide this number by 1000 to get the fraction. // piece(s). Divide this number by 1000 to get the fraction.
// //
// For example, if ``distributed_full_copies`` is 2 and // For example, if ``distributed_full_copies`` is 2 and
// ``distributed_fraction`` is 500, it means that the rarest pieces have // ``distributed_fraction`` is 500, it means that the rarest pieces have
// only 2 copies among the peers this torrent is connected to, and that // only 2 copies among the peers this torrent is connected to, and that
// 50% of all the pieces have more than two copies. // 50% of all the pieces have more than two copies.
// //
// If we are a seed, the piece picker is deallocated as an optimization, // If we are a seed, the piece picker is deallocated as an optimization,
// and piece availability is no longer tracked. In this case the // and piece availability is no longer tracked. In this case the
// distributed copies members are set to -1. // distributed copies members are set to -1.

View File

@ -82,7 +82,7 @@ namespace libtorrent
{ {
return m_queued_bytes; return m_queued_bytes;
} }
// non prioritized means that, if there's a line for bandwidth, // non prioritized means that, if there's a line for bandwidth,
// others will cut in front of the non-prioritized peers. // others will cut in front of the non-prioritized peers.
// this is used by web seeds // this is used by web seeds

View File

@ -140,7 +140,7 @@ namespace libtorrent
return ret ^ 0xffffffff; return ret ^ 0xffffffff;
} }
#endif #endif
boost::crc_optimal<32, 0x1EDC6F41, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc; boost::crc_optimal<32, 0x1EDC6F41, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc;
crc.process_bytes(buf, num_words * 8); crc.process_bytes(buf, num_words * 8);
return crc.checksum(); return crc.checksum();

View File

@ -1568,7 +1568,7 @@ namespace libtorrent
// one and it sets outstanding_read flag and possibly queues // one and it sets outstanding_read flag and possibly queues
// up the job in the piece read job list // up the job in the piece read job list
// the cache std::mutex must be held when calling this // the cache std::mutex must be held when calling this
// //
// returns 0 if the job succeeded immediately // returns 0 if the job succeeded immediately
// 1 if it needs to be added to the job queue // 1 if it needs to be added to the job queue
// 2 if it was deferred and will be performed later (no need to // 2 if it was deferred and will be performed later (no need to

View File

@ -385,7 +385,7 @@ namespace libtorrent
{ {
unsigned char inbuf[8]; unsigned char inbuf[8];
unsigned char outbuf[5]; unsigned char outbuf[5];
std::string ret; std::string ret;
for (std::string::const_iterator i = s.begin(); i != s.end();) for (std::string::const_iterator i = s.begin(); i != s.end();)
{ {

View File

@ -384,7 +384,7 @@ restart_response:
{ {
m_partial_chunk_header += incoming; m_partial_chunk_header += incoming;
header_size = incoming; header_size = incoming;
// std::fprintf(stderr, "parse_chunk_header(%d, -> %d, -> %d) -> %d\n" // std::fprintf(stderr, "parse_chunk_header(%d, -> %d, -> %d) -> %d\n"
// " incoming = %d\n m_recv_pos = %d\n m_cur_chunk_end = %d\n" // " incoming = %d\n m_recv_pos = %d\n m_cur_chunk_end = %d\n"
// " content-length = %d\n" // " content-length = %d\n"

View File

@ -89,7 +89,7 @@ namespace libtorrent { namespace dht
// from this node. Ignore it until it's silent for 5 minutes // from this node. Ignore it until it's silent for 5 minutes
match->limit = now + seconds(m_block_timeout); match->limit = now + seconds(m_block_timeout);
} }
return false; return false;
} }

View File

@ -44,7 +44,7 @@ POSSIBILITY OF SUCH DAMAGE.
// the size of the torrent (and can be used to calculate the size // the size of the torrent (and can be used to calculate the size
// of the file header) // of the file header)
uint32_t num_pieces; uint32_t num_pieces;
// the number of bytes in each piece. This determines the size of // the number of bytes in each piece. This determines the size of
// each slot in the part file. This is typically an even power of 2, // each slot in the part file. This is typically an even power of 2,
// but it is not guaranteed to be. // but it is not guaranteed to be.
@ -58,7 +58,7 @@ POSSIBILITY OF SUCH DAMAGE.
// unused, n is defined as the number to align the size of this // unused, n is defined as the number to align the size of this
// header to an even multiple of 1024 bytes. // header to an even multiple of 1024 bytes.
uint8_t padding[n]; uint8_t padding[n];
*/ */
#include "libtorrent/part_file.hpp" #include "libtorrent/part_file.hpp"

View File

@ -419,7 +419,7 @@ namespace libtorrent
// the number of incoming DHT requests that were dropped. There are a few // the number of incoming DHT requests that were dropped. There are a few
// different reasons why incoming DHT packets may be dropped: // different reasons why incoming DHT packets may be dropped:
// //
// 1. there wasn't enough send quota to respond to them. // 1. there wasn't enough send quota to respond to them.
// 2. the Denial of service logic kicked in, blocking the peer // 2. the Denial of service logic kicked in, blocking the peer
// 3. ignore_dark_internet is enabled, and the packet came from a // 3. ignore_dark_internet is enabled, and the packet came from a

View File

@ -241,7 +241,7 @@ void SHA1_final(u8* digest, sha1_ctx* context)
/************************************************************ /************************************************************
----------------- -----------------
Modified 7/98 Modified 7/98
By James H. Brown <jbrown@burgoyne.com> By James H. Brown <jbrown@burgoyne.com>
Still 100% Public Domain Still 100% Public Domain
@ -263,7 +263,7 @@ Since the file IO in main() reads 16K at a time, any file 8K or larger would
be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
"a"s). "a"s).
I also changed the declaration of variables i & j in SHA1Update to I also changed the declaration of variables i & j in SHA1Update to
unsigned long from unsigned int for the same reason. unsigned long from unsigned int for the same reason.
These changes should make no difference to any 32 bit implementations since These changes should make no difference to any 32 bit implementations since
@ -290,7 +290,7 @@ Still 100% public domain
Modified 4/01 Modified 4/01
By Saul Kravitz <Saul.Kravitz@celera.com> By Saul Kravitz <Saul.Kravitz@celera.com>
Still 100% PD Still 100% PD
Modified to run on Compaq Alpha hardware. Modified to run on Compaq Alpha hardware.
----------------- -----------------
Converted to C++ 6/04 Converted to C++ 6/04

View File

@ -30,45 +30,45 @@ namespace libtorrent
/* the K array */ /* the K array */
static const u64 K[80] = { static const u64 K[80] = {
UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd), UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd),
UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc), UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019), UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019),
UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118), UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe), UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe),
UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2), UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1), UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1),
UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694), UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3), UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3),
UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65), UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483), UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483),
UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5), UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210), UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210),
UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4), UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725), UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725),
UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70), UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926), UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926),
UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df), UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8), UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8),
UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b), UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001), UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001),
UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30), UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910), UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910),
UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8), UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53), UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53),
UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8), UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb), UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb),
UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3), UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60), UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60),
UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec), UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9), UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9),
UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b), UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207), UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207),
UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178), UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6), UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6),
UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b), UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493), UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493),
UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c), UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a), UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a),
UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817) UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817)
}; };
@ -92,7 +92,7 @@ static const u64 K[80] = {
#define Ch(x,y,z) (z ^ (x & (y ^ z))) #define Ch(x,y,z) (z ^ (x & (y ^ z)))
#define Maj(x,y,z) (((x | y) & z) | (x & y)) #define Maj(x,y,z) (((x | y) & z) | (x & y))
#define S(x, n) ROR64c(x, n) #define S(x, n) ROR64c(x, n)
#define R(x, n) (((x) &UINT64_C(0xFFFFFFFFFFFFFFFF))>>((u64)n)) #define R(x, n) (((x) &UINT64_C(0xFFFFFFFFFFFFFFFF))>>((u64)n))
#define Sigma0(x) (S(x, 28) ^ S(x, 34) ^ S(x, 39)) #define Sigma0(x) (S(x, 28) ^ S(x, 34) ^ S(x, 39))
@ -122,7 +122,7 @@ static int sha512_compress(sha512_ctx *md, unsigned char *buf)
/* fill W[16..79] */ /* fill W[16..79] */
for (i = 16; i < 80; i++) { for (i = 16; i < 80; i++) {
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16]; W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
} }
/* Compress */ /* Compress */
#define RND(a,b,c,d,e,f,g,h,i) \ #define RND(a,b,c,d,e,f,g,h,i) \
@ -185,24 +185,24 @@ int SHA512_init(sha512_ctx* md) {
@return 0 if successful @return 0 if successful
*/ */
int SHA512_update(sha512_ctx* md, std::uint8_t const* in, std::uint32_t inlen) int SHA512_update(sha512_ctx* md, std::uint8_t const* in, std::uint32_t inlen)
{ {
size_t n; size_t n;
size_t i; size_t i;
int err; int err;
if (md == NULL) return 1; if (md == NULL) return 1;
if (in == NULL) return 1; if (in == NULL) return 1;
if (md->curlen > sizeof(md->buf)) { if (md->curlen > sizeof(md->buf)) {
return 1; return 1;
} }
while (inlen > 0) { while (inlen > 0) {
if (md->curlen == 0 && inlen >= 128) { if (md->curlen == 0 && inlen >= 128) {
if ((err = sha512_compress (md, (unsigned char *)in)) != 0) { if ((err = sha512_compress (md, (unsigned char *)in)) != 0) {
return err; return err;
} }
md->length += 128 * 8; md->length += 128 * 8;
in += 128; in += 128;
inlen -= 128; inlen -= 128;
} else { } else {
n = MIN(inlen, (128 - md->curlen)); n = MIN(inlen, (128 - md->curlen));
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
@ -210,19 +210,19 @@ int SHA512_update(sha512_ctx* md, std::uint8_t const* in, std::uint32_t inlen)
} }
md->curlen += n; md->curlen += n;
in += n; in += n;
inlen -= n; inlen -= n;
if (md->curlen == 128) { if (md->curlen == 128) {
if ((err = sha512_compress (md, md->buf)) != 0) { if ((err = sha512_compress (md, md->buf)) != 0) {
return err; return err;
} }
md->length += 8*128; md->length += 8*128;
md->curlen = 0; md->curlen = 0;
} }
} }
} }
return 0; return 0;
} }
/** /**
@ -260,7 +260,7 @@ int SHA512_final(std::uint8_t* out, sha512_ctx* md)
md->curlen = 0; md->curlen = 0;
} }
/* pad upto 120 bytes of zeroes /* pad upto 120 bytes of zeroes
* note: that from 112 to 120 is the 64 MSB of the length. We assume that you won't hash * note: that from 112 to 120 is the 64 MSB of the length. We assume that you won't hash
* > 2^64 bits of data... :-) * > 2^64 bits of data... :-)
*/ */

View File

@ -67,7 +67,7 @@ namespace libtorrent
// the lower 64 bits are always unmasked // the lower 64 bits are always unmasked
// //
// * for IPv6 addresses, compare /32 and /48 instead of /16 and /24 // * for IPv6 addresses, compare /32 and /48 instead of /16 and /24
// //
// * the two IP addresses that are used to calculate the rank must // * the two IP addresses that are used to calculate the rank must
// always be of the same address family // always be of the same address family
// //

View File

@ -221,7 +221,7 @@ namespace libtorrent
for (std::vector<tcp::endpoint>::iterator k = m_endpoints.begin(); for (std::vector<tcp::endpoint>::iterator k = m_endpoints.begin();
k != m_endpoints.end();) k != m_endpoints.end();)
{ {
if (tracker_req().filter->access(k->address()) == ip_filter::blocked) if (tracker_req().filter->access(k->address()) == ip_filter::blocked)
{ {
#ifndef TORRENT_DISABLE_LOGGING #ifndef TORRENT_DISABLE_LOGGING
if (cb && cb->should_log()) if (cb && cb->should_log())
@ -243,7 +243,7 @@ namespace libtorrent
fail(error_code(errors::banned_by_ip_filter)); fail(error_code(errors::banned_by_ip_filter));
return; return;
} }
m_target = pick_target_endpoint(); m_target = pick_target_endpoint();
start_announce(); start_announce();

View File

@ -60,7 +60,7 @@ namespace libtorrent { namespace
{ {
// don't send out those peers that we haven't connected to // don't send out those peers that we haven't connected to
// (that have connected to us) and that aren't sharing their // (that have connected to us) and that aren't sharing their
// listening port // listening port
if (!p.is_outgoing() && !p.received_listen_port()) return false; if (!p.is_outgoing() && !p.received_listen_port()) return false;
// don't send out peers that we haven't successfully connected to // don't send out peers that we haven't successfully connected to
if (p.is_connecting()) return false; if (p.is_connecting()) return false;
@ -202,7 +202,7 @@ namespace libtorrent { namespace
for (std::set<tcp::endpoint>::const_iterator i = dropped.begin() for (std::set<tcp::endpoint>::const_iterator i = dropped.begin()
, end(dropped.end()); i != end; ++i) , end(dropped.end()); i != end; ++i)
{ {
if (i->address().is_v4()) if (i->address().is_v4())
detail::write_endpoint(*i, pld_out); detail::write_endpoint(*i, pld_out);
#if TORRENT_USE_IPV6 #if TORRENT_USE_IPV6

View File

@ -95,7 +95,7 @@ void test_swarm()
torrent_handle tor2; torrent_handle tor2;
torrent_handle tor3; torrent_handle tor3;
std::tie(tor1, tor2, tor3) = setup_transfer(&ses1, &ses2, &ses3, true, false, true, "_unchoke"); std::tie(tor1, tor2, tor3) = setup_transfer(&ses1, &ses2, &ses3, true, false, true, "_unchoke");
std::map<std::string, std::int64_t> cnt = get_counters(ses1); std::map<std::string, std::int64_t> cnt = get_counters(ses1);

View File

@ -814,7 +814,7 @@ TORRENT_TEST(dict_find_funs)
TEST_EQUAL(e.type(), bdecode_node::dict_t); TEST_EQUAL(e.type(), bdecode_node::dict_t);
// dict_find_int* // dict_find_int*
TEST_EQUAL(e.dict_find_int_value("a"), 1); TEST_EQUAL(e.dict_find_int_value("a"), 1);
TEST_EQUAL(e.dict_find_int("a").type(), bdecode_node::int_t); TEST_EQUAL(e.dict_find_int("a").type(), bdecode_node::int_t);

View File

@ -53,7 +53,7 @@ TORRENT_TEST(create_verbatim_torrent)
info.add_tracker("http://test.com"); info.add_tracker("http://test.com");
info.add_tracker("http://test.com"); info.add_tracker("http://test.com");
TEST_EQUAL(info.trackers().size(), 1); TEST_EQUAL(info.trackers().size(), 1);
lt::create_torrent t(info); lt::create_torrent t(info);
std::vector<char> buffer; std::vector<char> buffer;

View File

@ -240,7 +240,7 @@ void send_dht_request(node& node, char const* msg, udp::endpoint const& ep
dht::msg m(decoded, ep); dht::msg m(decoded, ep);
node.incoming(m); node.incoming(m);
// If the request is supposed to get a response, by now the node should have // If the request is supposed to get a response, by now the node should have
// invoked the send function and put the response in g_sent_packets // invoked the send function and put the response in g_sent_packets
std::list<std::pair<udp::endpoint, entry> >::iterator i = find_packet(ep); std::list<std::pair<udp::endpoint, entry> >::iterator i = find_packet(ep);
if (has_response) if (has_response)

View File

@ -105,7 +105,7 @@ TORRENT_TEST(set_name)
// torrent, the path of the files should change too // torrent, the path of the files should change too
file_storage st; file_storage st;
setup_test_storage(st); setup_test_storage(st);
st.set_name("test_2"); st.set_name("test_2");
TEST_EQUAL(st.file_path(0, "."), combine_path(".", combine_path("test_2" TEST_EQUAL(st.file_path(0, "."), combine_path(".", combine_path("test_2"
, "a"))); , "a")));

View File

@ -98,7 +98,7 @@ TORRENT_TEST(part_file)
{ {
// load the part file back in // load the part file back in
part_file pf(combine_path(cwd, "partfile_test_dir2"), "partfile.parts", 100, piece_size); part_file pf(combine_path(cwd, "partfile_test_dir2"), "partfile.parts", 100, piece_size);
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
file::iovec_t v = {&buf, 1024}; file::iovec_t v = {&buf, 1024};

View File

@ -363,7 +363,7 @@ TORRENT_TEST(update_peer_port_collide)
auto c = std::make_shared<mock_peer_connection>(&t, true, ep("10.0.0.1", 8080)); auto c = std::make_shared<mock_peer_connection>(&t, true, ep("10.0.0.1", 8080));
p.new_connection(*c, 0, &st); p.new_connection(*c, 0, &st);
TEST_EQUAL(p.num_connect_candidates(), 1); TEST_EQUAL(p.num_connect_candidates(), 1);
// at this point we have two peers, because we think they have different // at this point we have two peers, because we think they have different
// ports // ports
TEST_EQUAL(p.num_peers(), 2); TEST_EQUAL(p.num_peers(), 2);
st.erased.clear(); st.erased.clear();

View File

@ -1310,7 +1310,7 @@ TORRENT_TEST(storage_paths_string_pooling)
file_storage.add_file(combine_path("test_storage", combine_path("sub", "test2.txt")), 0x4000); file_storage.add_file(combine_path("test_storage", combine_path("sub", "test2.txt")), 0x4000);
file_storage.add_file(combine_path("test_storage", combine_path("sub", "test3.txt")), 0x4000); file_storage.add_file(combine_path("test_storage", combine_path("sub", "test3.txt")), 0x4000);
// "sub" paths should point to same string item, so paths.size() must not grow // "sub" paths should point to same string item, so paths.size() must not grow
TEST_CHECK(file_storage.paths().size() <= 2); TEST_CHECK(file_storage.paths().size() <= 2);
} }

View File

@ -164,7 +164,7 @@ int main(int argc, char* argv[])
"set style line 2 lc rgb \"#88ff88\"\n" "set style line 2 lc rgb \"#88ff88\"\n"
"set style arrow 1 nohead ls 1\n" "set style arrow 1 nohead ls 1\n"
"set style arrow 2 nohead ls 2\n" "set style arrow 2 nohead ls 2\n"
"plot \"writes.log\" using 1:2:3:(0) title \"writes\" with vectors arrowstyle 1, " "plot \"writes.log\" using 1:2:3:(0) title \"writes\" with vectors arrowstyle 1, "
"\"reads.log\" using 1:2:3:(0) title \"reads\" with vectors arrowstyle 2\n"; "\"reads.log\" using 1:2:3:(0) title \"reads\" with vectors arrowstyle 2\n";
std::fwrite(gnuplot_file, strlen(gnuplot_file), 1, gnuplot); std::fwrite(gnuplot_file, strlen(gnuplot_file), 1, gnuplot);