forked from premiere/premiere-libtorrent
1482 lines
80 KiB
HTML
1482 lines
80 KiB
HTML
<?xml version="1.0" encoding="utf-8" ?>
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
|
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
|
<meta name="generator" content="Docutils 0.12: http://docutils.sourceforge.net/" />
|
|
<title>Session</title>
|
|
<meta name="author" content="Arvid Norberg, arvid@libtorrent.org" />
|
|
<link rel="stylesheet" type="text/css" href="rst.css" />
|
|
<script type="text/javascript">
|
|
/* <![CDATA[ */
|
|
(function() {
|
|
var s = document.createElement('script'), t = document.getElementsByTagName('script')[0];
|
|
s.type = 'text/javascript';
|
|
s.async = true;
|
|
s.src = 'http://api.flattr.com/js/0.6/load.js?mode=auto';
|
|
t.parentNode.insertBefore(s, t);
|
|
})();
|
|
/* ]]> */
|
|
</script>
|
|
<link rel="stylesheet" href="style.css" type="text/css" />
|
|
<style type="text/css">
|
|
/* Hides from IE-mac \*/
|
|
* html pre { height: 1%; }
|
|
/* End hide from IE-mac */
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div class="document" id="session">
|
|
<div id="container">
|
|
<table id="header">
|
|
<tr><td id="orange"></td>
|
|
<td id="logo">libtorrent</td></tr>
|
|
</table>
|
|
<div id="main">
|
|
<h1 class="title">Session</h1>
|
|
<table class="docinfo" frame="void" rules="none">
|
|
<col class="docinfo-name" />
|
|
<col class="docinfo-content" />
|
|
<tbody valign="top">
|
|
<tr><th class="docinfo-name">Author:</th>
|
|
<td>Arvid Norberg, <a class="last reference external" href="mailto:arvid@libtorrent.org">arvid@libtorrent.org</a></td></tr>
|
|
<tr><th class="docinfo-name">Version:</th>
|
|
<td>1.1.0</td></tr>
|
|
</tbody>
|
|
</table>
|
|
<div class="contents topic" id="table-of-contents">
|
|
<p class="topic-title first">Table of contents</p>
|
|
<ul class="simple">
|
|
<li><a class="reference internal" href="#add-torrent-params" id="id166">add_torrent_params</a></li>
|
|
<li><a class="reference internal" href="#cache-status" id="id167">cache_status</a></li>
|
|
<li><a class="reference internal" href="#stats-metric" id="id168">stats_metric</a></li>
|
|
<li><a class="reference internal" href="#session-proxy" id="id169">session_proxy</a></li>
|
|
<li><a class="reference internal" href="#id38" id="id170">session</a></li>
|
|
</ul>
|
|
</div>
|
|
<a name="add_torrent_params"></a><div class="section" id="add-torrent-params">
|
|
<h1>add_torrent_params</h1>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/add_torrent_params.hpp">libtorrent/add_torrent_params.hpp</a>"</p>
|
|
<p>The <a class="reference external" href="reference-Session.html#add_torrent_params">add_torrent_params</a> is a parameter pack for adding torrents to a
|
|
<a class="reference external" href="reference-Session.html#session">session</a>. The key fields when adding a torrent are:</p>
|
|
<ul class="simple">
|
|
<li>ti - when you have a .torrent file</li>
|
|
<li>url - when you have a magnet link or http URL to the .torrent file</li>
|
|
<li>info_hash - when all you have is an info-hash (this is similar to a
|
|
magnet link)</li>
|
|
</ul>
|
|
<p>one of those fields need to be set. Another mandatory field is
|
|
<tt class="docutils literal">save_path</tt>. The <a class="reference external" href="reference-Session.html#add_torrent_params">add_torrent_params</a> object is passed into one of the
|
|
<tt class="docutils literal"><span class="pre">session::add_torrent()</span></tt> overloads or <tt class="docutils literal"><span class="pre">session::async_add_torrent()</span></tt>.</p>
|
|
<p>If you only specify the info-hash, the torrent file will be downloaded
|
|
from peers, which requires them to support the metadata extension. For
|
|
the metadata extension to work, libtorrent must be built with extensions
|
|
enabled (<tt class="docutils literal">TORRENT_DISABLE_EXTENSIONS</tt> must not be defined). It also
|
|
takes an optional <tt class="docutils literal">name</tt> argument. This may be left empty in case no
|
|
name should be assigned to the torrent. In case it's not, the name is
|
|
used for the torrent as long as it doesn't have metadata. See
|
|
<tt class="docutils literal"><span class="pre">torrent_handle::name</span></tt>.</p>
|
|
<pre class="literal-block">
|
|
struct add_torrent_params
|
|
{
|
|
<strong>add_torrent_params</strong> (storage_constructor_type sc = default_storage_constructor);
|
|
|
|
enum flags_t
|
|
{
|
|
flag_seed_mode,
|
|
flag_override_resume_data,
|
|
flag_upload_mode,
|
|
flag_share_mode,
|
|
flag_apply_ip_filter,
|
|
flag_paused,
|
|
flag_auto_managed,
|
|
flag_duplicate_is_error,
|
|
flag_merge_resume_trackers,
|
|
flag_update_subscribe,
|
|
flag_super_seeding,
|
|
flag_sequential_download,
|
|
flag_use_resume_save_path,
|
|
flag_pinned,
|
|
| flag_auto_managed | flag_paused | flag_apply_ip_filter,
|
|
};
|
|
|
|
int version;
|
|
boost::shared_ptr<torrent_info> ti;
|
|
std::vector<std::string> trackers;
|
|
std::vector<std::string> url_seeds;
|
|
std::vector<std::pair<std::string, int> > dht_nodes;
|
|
std::string name;
|
|
std::string save_path;
|
|
std::vector<char> resume_data;
|
|
storage_mode_t storage_mode;
|
|
storage_constructor_type storage;
|
|
void* userdata;
|
|
std::vector<boost::uint8_t> file_priorities;
|
|
std::string trackerid;
|
|
std::string url;
|
|
std::string uuid;
|
|
std::string source_feed_url;
|
|
boost::uint64_t flags;
|
|
sha1_hash info_hash;
|
|
int max_uploads;
|
|
int max_connections;
|
|
int upload_limit;
|
|
int download_limit;
|
|
};
|
|
</pre>
|
|
<a name="add_torrent_params()"></a><div class="section" id="id5">
|
|
<h2>add_torrent_params()</h2>
|
|
<pre class="literal-block">
|
|
<strong>add_torrent_params</strong> (storage_constructor_type sc = default_storage_constructor);
|
|
</pre>
|
|
<p>The constructor can be used to initialize the storage constructor,
|
|
which determines the storage mechanism for the downloaded or seeding
|
|
data for the torrent. For more information, see the <tt class="docutils literal">storage</tt> field.</p>
|
|
<a name="flags_t"></a></div>
|
|
<div class="section" id="enum-flags-t">
|
|
<h2>enum flags_t</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/add_torrent_params.hpp">libtorrent/add_torrent_params.hpp</a>"</p>
|
|
<table border="1" class="docutils">
|
|
<colgroup>
|
|
<col width="41%" />
|
|
<col width="5%" />
|
|
<col width="54%" />
|
|
</colgroup>
|
|
<thead valign="bottom">
|
|
<tr><th class="head">name</th>
|
|
<th class="head">value</th>
|
|
<th class="head">description</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody valign="top">
|
|
<tr><td>flag_seed_mode</td>
|
|
<td>1</td>
|
|
<td><p class="first">If <tt class="docutils literal">flag_seed_mode</tt> is set, libtorrent will assume that all files
|
|
are present for this torrent and that they all match the hashes in
|
|
the torrent file. Each time a peer requests to download a block,
|
|
the piece is verified against the hash, unless it has been verified
|
|
already. If a hash fails, the torrent will automatically leave the
|
|
seed mode and recheck all the files. The use case for this mode is
|
|
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
|
|
file checks, and significantly reduce the startup time.</p>
|
|
<p>Setting <tt class="docutils literal">flag_seed_mode</tt> on a torrent without metadata (a
|
|
.torrent file) is a no-op and will be ignored.</p>
|
|
<p class="last">If resume data is passed in with this torrent, the seed mode saved
|
|
in there will override the seed mode you set here.</p>
|
|
</td>
|
|
</tr>
|
|
<tr><td>flag_override_resume_data</td>
|
|
<td>2</td>
|
|
<td>If <tt class="docutils literal">flag_override_resume_data</tt> is set, flags set for this torrent
|
|
in this <tt class="docutils literal">add_torrent_params</tt> object will take precedence over
|
|
whatever states are saved in the resume data. For instance, the
|
|
<tt class="docutils literal">paused</tt>, <tt class="docutils literal">auto_managed</tt>, <tt class="docutils literal">sequential_download</tt>, <tt class="docutils literal">seed_mode</tt>,
|
|
<tt class="docutils literal">super_seeding</tt>, <tt class="docutils literal">max_uploads</tt>, <tt class="docutils literal">max_connections</tt>,
|
|
<tt class="docutils literal">upload_limit</tt> and <tt class="docutils literal">download_limit</tt> are all affected by this
|
|
flag. The intention of this flag is to have any field in
|
|
<a class="reference external" href="reference-Session.html#add_torrent_params">add_torrent_params</a> configuring the torrent override the corresponding
|
|
configuration from the resume file, with the one exception of save
|
|
resume data, which has its own flag (for historic reasons).</td>
|
|
</tr>
|
|
<tr><td>flag_upload_mode</td>
|
|
<td>4</td>
|
|
<td><p class="first">If <tt class="docutils literal">flag_upload_mode</tt> is set, the torrent will be initialized in
|
|
upload-mode, which means it will not make any piece requests. This
|
|
state is typically entered on disk I/O errors, and if the torrent
|
|
is also auto managed, it will be taken out of this state
|
|
periodically. This mode can be used to avoid race conditions when
|
|
adjusting priorities of pieces before allowing the torrent to start
|
|
downloading.</p>
|
|
<p class="last">If the torrent is auto-managed (<tt class="docutils literal">flag_auto_managed</tt>), the torrent
|
|
will eventually be taken out of upload-mode, regardless of how it
|
|
got there. If it's important to manually control when the torrent
|
|
leaves upload mode, don't make it auto managed.</p>
|
|
</td>
|
|
</tr>
|
|
<tr><td>flag_share_mode</td>
|
|
<td>8</td>
|
|
<td><p class="first">determines if the torrent should be added in <em>share mode</em> or not.
|
|
Share mode indicates that we are not interested in downloading the
|
|
torrent, but merley want to improve our share ratio (i.e. increase
|
|
it). A torrent started in share mode will do its best to never
|
|
download more than it uploads to the swarm. If the swarm does not
|
|
have enough demand for upload capacity, the torrent will not
|
|
download anything. This mode is intended to be safe to add any
|
|
number of torrents to, without manual screening, without the risk
|
|
of downloading more than is uploaded.</p>
|
|
<p>A torrent in share mode sets the priority to all pieces to 0,
|
|
except for the pieces that are downloaded, when pieces are decided
|
|
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
|
|
priorities for torrents in share mode, it will make it not work.</p>
|
|
<p class="last">The share mode has one setting, the share ratio target, see
|
|
<tt class="docutils literal"><span class="pre">session_settings::share_mode_target</span></tt> for more info.</p>
|
|
</td>
|
|
</tr>
|
|
<tr><td>flag_apply_ip_filter</td>
|
|
<td>16</td>
|
|
<td>determines if the IP filter should apply to this torrent or not. By
|
|
default all torrents are subject to filtering by the IP filter
|
|
(i.e. this flag is set by default). This is useful if certain
|
|
torrents needs to be excempt for some reason, being an auto-update
|
|
torrent for instance.</td>
|
|
</tr>
|
|
<tr><td>flag_paused</td>
|
|
<td>32</td>
|
|
<td>specifies whether or not the torrent is to be started in a paused
|
|
state. I.e. it won't connect to the tracker or any of the peers
|
|
until it's resumed. This is typically a good way of avoiding race
|
|
conditions when setting configuration options on torrents before
|
|
starting them.</td>
|
|
</tr>
|
|
<tr><td>flag_auto_managed</td>
|
|
<td>64</td>
|
|
<td><p class="first">If the torrent is auto-managed (<tt class="docutils literal">flag_auto_managed</tt>), the torrent
|
|
may be resumed at any point, regardless of how it paused. If it's
|
|
important to manually control when the torrent is paused and
|
|
resumed, don't make it auto managed.</p>
|
|
<p>If <tt class="docutils literal">flag_auto_managed</tt> is set, the torrent will be queued,
|
|
started and seeded automatically by libtorrent. When this is set,
|
|
the torrent should also be started as paused. The default queue
|
|
order is the order the torrents were added. They are all downloaded
|
|
in that order. For more details, see <a class="reference external" href="manual-ref.html#queuing">queuing</a>.</p>
|
|
<p class="last">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
|
|
you pass in here. You can override this by setting
|
|
<tt class="docutils literal">override_resume_data</tt>.</p>
|
|
</td>
|
|
</tr>
|
|
<tr><td>flag_duplicate_is_error</td>
|
|
<td>128</td>
|
|
<td> </td>
|
|
</tr>
|
|
<tr><td>flag_merge_resume_trackers</td>
|
|
<td>256</td>
|
|
<td>defaults to off and specifies whether tracker URLs loaded from
|
|
resume data should be added to the trackers in the torrent or
|
|
replace the trackers.</td>
|
|
</tr>
|
|
<tr><td>flag_update_subscribe</td>
|
|
<td>512</td>
|
|
<td>on by default and means that this torrent will be part of state
|
|
updates when calling <a class="reference external" href="reference-Session.html#post_torrent_updates()">post_torrent_updates()</a>.</td>
|
|
</tr>
|
|
<tr><td>flag_super_seeding</td>
|
|
<td>1024</td>
|
|
<td>sets the torrent into super seeding mode. If the torrent is not a
|
|
seed, this flag has no effect. It has the same effect as calling
|
|
<tt class="docutils literal"><span class="pre">torrent_handle::super_seeding(true)</span></tt> on the torrent handle
|
|
immediately after adding it.</td>
|
|
</tr>
|
|
<tr><td>flag_sequential_download</td>
|
|
<td>2048</td>
|
|
<td>sets the sequential download state for the torrent. It has the same
|
|
effect as calling <tt class="docutils literal"><span class="pre">torrent_handle::sequential_download(true)</span></tt> on
|
|
the torrent handle immediately after adding it.</td>
|
|
</tr>
|
|
<tr><td>flag_use_resume_save_path</td>
|
|
<td>4096</td>
|
|
<td>if this flag is set, the save path from the resume data file, if
|
|
present, is honored. This defaults to not being set, in which
|
|
case the save_path specified in <a class="reference external" href="reference-Session.html#add_torrent_params">add_torrent_params</a> is always used.</td>
|
|
</tr>
|
|
<tr><td>flag_pinned</td>
|
|
<td>8192</td>
|
|
<td>indicates that this torrent should never be unloaded from RAM, even
|
|
if unloading torrents are allowed in general. Setting this makes
|
|
the torrent exempt from loading/unloading management.</td>
|
|
</tr>
|
|
<tr><td><div class="first last line-block">
|
|
<div class="line">flag_auto_managed | flag_paused | flag_apply_ip_filter</div>
|
|
</div>
|
|
</td>
|
|
<td>8194</td>
|
|
<td> </td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<a name="version"></a><dl class="docutils">
|
|
<dt>version</dt>
|
|
<dd>filled in by the constructor and should be left untouched. It is used
|
|
for forward binary compatibility.</dd>
|
|
</dl>
|
|
<a name="ti"></a><dl class="docutils">
|
|
<dt>ti</dt>
|
|
<dd><a class="reference external" href="reference-Core.html#torrent_info">torrent_info</a> object with the torrent to add. Unless the url or
|
|
info_hash is set, this is required to be initiazlied.</dd>
|
|
</dl>
|
|
<a name="trackers"></a><dl class="docutils">
|
|
<dt>trackers</dt>
|
|
<dd>If the torrent doesn't have a tracker, but relies on the DHT to find
|
|
peers, the <tt class="docutils literal">trackers</tt> can specify tracker URLs for the torrent.</dd>
|
|
</dl>
|
|
<a name="url_seeds"></a><dl class="docutils">
|
|
<dt>url_seeds</dt>
|
|
<dd>url seeds to be added to the torrent (<a class="reference external" href="http://bittorrent.org/beps/bep_0017.html">BEP 17</a>).</dd>
|
|
</dl>
|
|
<a name="dht_nodes"></a>
|
|
<a name="name"></a><dl class="docutils">
|
|
<dt>dht_nodes name</dt>
|
|
<dd>a list of hostname and port pairs, representing DHT nodes to be added
|
|
to the <a class="reference external" href="reference-Session.html#session">session</a> (if DHT is enabled). The hostname may be an IP address.</dd>
|
|
</dl>
|
|
<a name="save_path"></a><dl class="docutils">
|
|
<dt>save_path</dt>
|
|
<dd><p class="first">the path where the torrent is or will be stored. Note that this may
|
|
alos be stored in resume data. If you want the save path saved in
|
|
the resume data to be used, you need to set the
|
|
flag_use_resume_save_path flag.</p>
|
|
<div class="note last">
|
|
<p class="first admonition-title">Note</p>
|
|
<p class="last">On windows this path (and other paths) are interpreted as UNC
|
|
paths. This means they must use backslashes as directory separators
|
|
and may not contain the special directories "." or "..".</p>
|
|
</div>
|
|
</dd>
|
|
</dl>
|
|
<a name="resume_data"></a><dl class="docutils">
|
|
<dt>resume_data</dt>
|
|
<dd>The optional parameter, <tt class="docutils literal">resume_data</tt> can be given if up to date
|
|
fast-resume data is available. The fast-resume data can be acquired
|
|
from a running torrent by calling <a class="reference external" href="reference-Core.html#save_resume_data()">save_resume_data()</a> on
|
|
<a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a>. See <a class="reference external" href="manual-ref.html#fast-resume">fast resume</a>. The <tt class="docutils literal">vector</tt> that is passed in
|
|
will be swapped into the running torrent instance with
|
|
<tt class="docutils literal"><span class="pre">std::vector::swap()</span></tt>.</dd>
|
|
</dl>
|
|
<a name="storage_mode"></a><dl class="docutils">
|
|
<dt>storage_mode</dt>
|
|
<dd>One of the values from <a class="reference external" href="reference-Storage.html#storage_mode_t">storage_mode_t</a>. For more information, see
|
|
<a class="reference external" href="manual-ref.html#storage-allocation">storage allocation</a>.</dd>
|
|
</dl>
|
|
<a name="storage"></a><dl class="docutils">
|
|
<dt>storage</dt>
|
|
<dd>can be used to customize how the data is stored. The default storage
|
|
will simply write the data to the files it belongs to, but it could be
|
|
overridden to save everything to a single file at a specific location
|
|
or encrypt the content on disk for instance. For more information
|
|
about the <a class="reference external" href="reference-Custom_Storage.html#storage_interface">storage_interface</a> that needs to be implemented for a custom
|
|
storage, see <a class="reference external" href="reference-Custom_Storage.html#storage_interface">storage_interface</a>.</dd>
|
|
</dl>
|
|
<a name="userdata"></a><dl class="docutils">
|
|
<dt>userdata</dt>
|
|
<dd>The <tt class="docutils literal">userdata</tt> parameter is optional and will be passed on to the
|
|
extension constructor functions, if any (see <a class="reference internal" href="#add-extension">add_extension()</a>).</dd>
|
|
</dl>
|
|
<a name="file_priorities"></a><dl class="docutils">
|
|
<dt>file_priorities</dt>
|
|
<dd>can be set to control the initial file priorities when adding a
|
|
torrent. The semantics are the same as for
|
|
<tt class="docutils literal"><span class="pre">torrent_handle::prioritize_files()</span></tt>.</dd>
|
|
</dl>
|
|
<a name="trackerid"></a><dl class="docutils">
|
|
<dt>trackerid</dt>
|
|
<dd>the default tracker id to be used when announcing to trackers. By
|
|
default this is empty, and no tracker ID is used, since this is an
|
|
optional argument. If a tracker returns a tracker ID, that ID is used
|
|
instead of this.</dd>
|
|
</dl>
|
|
<a name="url"></a><dl class="docutils">
|
|
<dt>url</dt>
|
|
<dd><p class="first">If you specify a <tt class="docutils literal">url</tt>, the torrent will be set in
|
|
<tt class="docutils literal">downloading_metadata</tt> state until the .torrent file has been
|
|
downloaded. If there's any error while downloading, the torrent will
|
|
be stopped and the torrent error state (<tt class="docutils literal"><span class="pre">torrent_status::error</span></tt>)
|
|
will indicate what went wrong. The <tt class="docutils literal">url</tt> may refer to a magnet link
|
|
or a regular http URL.</p>
|
|
<p>If it refers to an HTTP URL, the info-hash for the added torrent will
|
|
not be the true info-hash of the .torrent. Instead a placeholder,
|
|
unique, info-hash is used which is later updated once the .torrent
|
|
file has been downloaded.</p>
|
|
<p class="last">Once the info-hash change happens, a <a class="reference external" href="reference-Alerts.html#torrent_update_alert">torrent_update_alert</a> is posted.</p>
|
|
</dd>
|
|
</dl>
|
|
<a name="uuid"></a><dl class="docutils">
|
|
<dt>uuid</dt>
|
|
<dd>if <tt class="docutils literal">uuid</tt> is specified, it is used to find duplicates. If another
|
|
torrent is already running with the same UUID as the one being added,
|
|
it will be considered a duplicate. This is mainly useful for RSS feed
|
|
items which has UUIDs specified.</dd>
|
|
</dl>
|
|
<a name="source_feed_url"></a><dl class="docutils">
|
|
<dt>source_feed_url</dt>
|
|
<dd>should point to the URL of the RSS feed this torrent comes from, if it
|
|
comes from an RSS feed.</dd>
|
|
</dl>
|
|
<a name="flags"></a><dl class="docutils">
|
|
<dt>flags</dt>
|
|
<dd>flags controlling aspects of this torrent and how it's added. See
|
|
<a class="reference external" href="reference-Core.html#flags_t">flags_t</a> for details.</dd>
|
|
</dl>
|
|
<a name="info_hash"></a><dl class="docutils">
|
|
<dt>info_hash</dt>
|
|
<dd>set this to the info hash of the torrent to add in case the info-hash
|
|
is the only known property of the torrent. i.e. you don't have a
|
|
.torrent file nor a magnet link.</dd>
|
|
</dl>
|
|
<a name="max_uploads"></a>
|
|
<a name="max_connections"></a>
|
|
<a name="upload_limit"></a>
|
|
<a name="download_limit"></a><dl class="docutils">
|
|
<dt>max_uploads max_connections upload_limit download_limit</dt>
|
|
<dd><p class="first"><tt class="docutils literal">max_uploads</tt>, <tt class="docutils literal">max_connections</tt>, <tt class="docutils literal">upload_limit</tt>,
|
|
<tt class="docutils literal">download_limit</tt> correspond to the <tt class="docutils literal">set_max_uploads()</tt>,
|
|
<tt class="docutils literal">set_max_connections()</tt>, <tt class="docutils literal">set_upload_limit()</tt> and
|
|
<tt class="docutils literal">set_download_limit()</tt> functions on <a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a>. These values let
|
|
you initialize these settings when the torrent is added, instead of
|
|
calling these functions immediately following adding it.</p>
|
|
<p class="last">-1 means unlimited on these settings just like their counterpart
|
|
functions on <a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a></p>
|
|
</dd>
|
|
</dl>
|
|
<a name="cache_status"></a></div>
|
|
</div>
|
|
<div class="section" id="cache-status">
|
|
<h1>cache_status</h1>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/disk_io_thread.hpp">libtorrent/disk_io_thread.hpp</a>"</p>
|
|
<p>this struct holds a number of statistics counters
|
|
relevant for the disk io thread and disk cache.</p>
|
|
<pre class="literal-block">
|
|
struct cache_status
|
|
{
|
|
<strong>cache_status</strong> ();
|
|
|
|
std::vector<cached_piece_info> pieces;
|
|
};
|
|
</pre>
|
|
<a name="cache_status()"></a><div class="section" id="id25">
|
|
<h2>cache_status()</h2>
|
|
<pre class="literal-block">
|
|
<strong>cache_status</strong> ();
|
|
</pre>
|
|
<p>initializes all counters to 0</p>
|
|
<a name="stats_metric"></a></div>
|
|
</div>
|
|
<div class="section" id="stats-metric">
|
|
<h1>stats_metric</h1>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<p>describes one statistics metric from the <a class="reference external" href="reference-Session.html#session">session</a>. For more information,
|
|
see the <a class="reference external" href="manual-ref.html#session-statistics">session statistics</a> section.</p>
|
|
<pre class="literal-block">
|
|
struct stats_metric
|
|
{
|
|
char const* name;
|
|
int value_index;
|
|
int type;
|
|
};
|
|
</pre>
|
|
<a name="session_proxy"></a></div>
|
|
<div class="section" id="session-proxy">
|
|
<h1>session_proxy</h1>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<p>this is a holder for the internal <a class="reference external" href="reference-Session.html#session">session</a> implementation object. Once the
|
|
<a class="reference external" href="reference-Session.html#session">session</a> destruction is explicitly initiated, this holder is used to
|
|
synchronize the completion of the shutdown. The lifetime of this object
|
|
may outlive <a class="reference external" href="reference-Session.html#session">session</a>, causing the <a class="reference external" href="reference-Session.html#session">session</a> destructor to not block. The
|
|
<a class="reference external" href="reference-Session.html#session_proxy">session_proxy</a> destructor will block however, until the underlying <a class="reference external" href="reference-Session.html#session">session</a>
|
|
is done shutting down.</p>
|
|
<pre class="literal-block">
|
|
class session_proxy
|
|
{
|
|
<strong>session_proxy</strong> ();
|
|
};
|
|
</pre>
|
|
<a name="session_proxy()"></a><div class="section" id="id36">
|
|
<h2>session_proxy()</h2>
|
|
<pre class="literal-block">
|
|
<strong>session_proxy</strong> ();
|
|
</pre>
|
|
<p>default constructor, does not refer to any <a class="reference external" href="reference-Session.html#session">session</a>
|
|
implementation object.</p>
|
|
<a name="session"></a></div>
|
|
</div>
|
|
<div class="section" id="id38">
|
|
<h1>session</h1>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<p>The <a class="reference external" href="reference-Session.html#session">session</a> holds all state that spans multiple torrents. Among other
|
|
things it runs the network loop and manages all torrents. Once it's
|
|
created, the <a class="reference external" href="reference-Session.html#session">session</a> object will spawn the main thread that will do all
|
|
the work. The main thread will be idle as long it doesn't have any
|
|
torrents to participate in.</p>
|
|
<p>You have some control over <a class="reference external" href="reference-Session.html#session">session</a> configuration through the
|
|
<tt class="docutils literal"><span class="pre">session::apply_settings()</span></tt> member function. To change one or more
|
|
configuration options, create a <a class="reference external" href="reference-Settings.html#settings_pack">settings_pack</a>. object and fill it with
|
|
the settings to be set and pass it in to <tt class="docutils literal"><span class="pre">session::apply_settings()</span></tt>.</p>
|
|
<p>see <a class="reference external" href="reference-Session.html#apply_settings()">apply_settings()</a>.</p>
|
|
<pre class="literal-block">
|
|
class session: public boost::noncopyable
|
|
{
|
|
<strong>session</strong> (fingerprint const& print = fingerprint("LT"
|
|
, LIBTORRENT_VERSION_MAJOR, LIBTORRENT_VERSION_MINOR, 0, 0)
|
|
, int flags = start_default_features | add_default_plugins
|
|
, boost::uint32_t alert_mask = alert::error_notification);
|
|
<strong>session</strong> (fingerprint const& print
|
|
, std::pair<int, int> listen_port_range
|
|
, char const* listen_interface = "0.0.0.0"
|
|
, int flags = start_default_features | add_default_plugins
|
|
, int alert_mask = alert::error_notification);
|
|
<strong>session</strong> (settings_pack const& pack
|
|
, int flags = start_default_features | add_default_plugins);
|
|
<strong>~session</strong> ();
|
|
void <strong>load_state</strong> (lazy_entry const& e);
|
|
void <strong>save_state</strong> (entry& e, boost::uint32_t flags = 0xffffffff) const;
|
|
void <strong>refresh_torrent_status</strong> (std::vector<torrent_status>* ret
|
|
, boost::uint32_t flags = 0) const;
|
|
void <strong>get_torrent_status</strong> (std::vector<torrent_status>* ret
|
|
, boost::function<bool(torrent_status const&)> const& pred
|
|
, boost::uint32_t flags = 0) const;
|
|
void <strong>post_torrent_updates</strong> (boost::uint32_t flags = 0xffffffff);
|
|
void <strong>post_session_stats</strong> ();
|
|
void <strong>post_dht_stats</strong> ();
|
|
torrent_handle <strong>find_torrent</strong> (sha1_hash const& info_hash) const;
|
|
std::vector<torrent_handle> <strong>get_torrents</strong> () const;
|
|
void <strong>async_add_torrent</strong> (add_torrent_params const& params);
|
|
torrent_handle <strong>add_torrent</strong> (add_torrent_params const& params, error_code& ec);
|
|
torrent_handle <strong>add_torrent</strong> (add_torrent_params const& params);
|
|
session_proxy <strong>abort</strong> ();
|
|
void <strong>resume</strong> ();
|
|
void <strong>pause</strong> ();
|
|
bool <strong>is_paused</strong> () const;
|
|
void <strong>set_load_function</strong> (user_load_function_t fun);
|
|
void <strong>get_cache_info</strong> (cache_status* ret, torrent_handle h = torrent_handle(), int flags = 0) const;
|
|
feed_handle <strong>add_feed</strong> (feed_settings const& feed);
|
|
void <strong>remove_feed</strong> (feed_handle h);
|
|
void <strong>get_feeds</strong> (std::vector<feed_handle>& f) const;
|
|
bool <strong>is_dht_running</strong> () const;
|
|
void <strong>set_dht_settings</strong> (dht_settings const& settings);
|
|
void <strong>add_dht_router</strong> (std::pair<std::string, int> const& node);
|
|
void <strong>add_dht_node</strong> (std::pair<std::string, int> const& node);
|
|
void <strong>dht_get_item</strong> (sha1_hash const& target);
|
|
void <strong>dht_get_item</strong> (boost::array<char, 32> key
|
|
, std::string salt = std::string());
|
|
sha1_hash <strong>dht_put_item</strong> (entry data);
|
|
void <strong>dht_put_item</strong> (boost::array<char, 32> key
|
|
, boost::function<void(entry&, boost::array<char,64>&
|
|
, boost::uint64_t&, std::string const&)> cb
|
|
, std::string salt = std::string());
|
|
void <strong>add_extension</strong> (boost::function<boost::shared_ptr<torrent_plugin>(
|
|
torrent*, void*)> ext);
|
|
void <strong>add_extension</strong> (boost::shared_ptr<plugin> ext);
|
|
ip_filter <strong>get_ip_filter</strong> () const;
|
|
void <strong>set_ip_filter</strong> (ip_filter const& f);
|
|
void <strong>set_port_filter</strong> (port_filter const& f);
|
|
peer_id <strong>id</strong> () const;
|
|
void <strong>set_key</strong> (int key);
|
|
bool <strong>is_listening</strong> () const;
|
|
unsigned short <strong>listen_port</strong> () const;
|
|
unsigned short <strong>ssl_listen_port</strong> () const;
|
|
void <strong>set_peer_class_filter</strong> (ip_filter const& f);
|
|
void <strong>set_peer_class_type_filter</strong> (peer_class_type_filter const& f);
|
|
int <strong>create_peer_class</strong> (char const* name);
|
|
void <strong>delete_peer_class</strong> (int cid);
|
|
peer_class_info <strong>get_peer_class</strong> (int cid);
|
|
void <strong>set_peer_class</strong> (int cid, peer_class_info const& pci);
|
|
void <strong>remove_torrent</strong> (const torrent_handle& h, int options = 0);
|
|
aux::session_settings <strong>get_settings</strong> () const;
|
|
void <strong>apply_settings</strong> (settings_pack const& s);
|
|
void <strong>pop_alerts</strong> (std::deque<alert*>* alerts);
|
|
std::auto_ptr<alert> <strong>pop_alert</strong> ();
|
|
alert const* <strong>wait_for_alert</strong> (time_duration max_wait);
|
|
void <strong>set_alert_dispatch</strong> (boost::function<void(std::auto_ptr<alert>)> const& fun);
|
|
void <strong>delete_port_mapping</strong> (int handle);
|
|
int <strong>add_port_mapping</strong> (protocol_type t, int external_port, int local_port);
|
|
|
|
enum save_state_flags_t
|
|
{
|
|
save_settings,
|
|
save_dht_settings,
|
|
save_dht_state,
|
|
save_encryption_settings,
|
|
save_feeds,
|
|
};
|
|
|
|
enum options_t
|
|
{
|
|
delete_files,
|
|
};
|
|
|
|
enum session_flags_t
|
|
{
|
|
add_default_plugins,
|
|
start_default_features,
|
|
};
|
|
|
|
enum protocol_type
|
|
{
|
|
udp,
|
|
tcp,
|
|
};
|
|
};
|
|
</pre>
|
|
<a name="~session()"></a><div class="section" id="id45">
|
|
<h2>~session()</h2>
|
|
<pre class="literal-block">
|
|
<strong>~session</strong> ();
|
|
</pre>
|
|
<p>The destructor of <a class="reference external" href="reference-Session.html#session">session</a> will notify all trackers that our torrents
|
|
have been shut down. If some trackers are down, they will time out.
|
|
All this before the destructor of <a class="reference external" href="reference-Session.html#session">session</a> returns. So, it's advised
|
|
that any kind of interface (such as windows) are closed before
|
|
destructing the <a class="reference external" href="reference-Session.html#session">session</a> object. Because it can take a few second for
|
|
it to finish. The timeout can be set with <a class="reference external" href="reference-Session.html#apply_settings()">apply_settings()</a>.</p>
|
|
<a name="load_state()"></a>
|
|
<a name="save_state()"></a></div>
|
|
<div class="section" id="load-state-save-state">
|
|
<h2>load_state() save_state()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>load_state</strong> (lazy_entry const& e);
|
|
void <strong>save_state</strong> (entry& e, boost::uint32_t flags = 0xffffffff) const;
|
|
</pre>
|
|
<p>loads and saves all <a class="reference external" href="reference-Session.html#session">session</a> settings, including <a class="reference external" href="reference-Settings.html#dht_settings">dht_settings</a>,
|
|
encryption settings and proxy settings. <tt class="docutils literal">save_state</tt> writes all keys
|
|
to the <tt class="docutils literal">entry</tt> that's passed in, which needs to either not be
|
|
initialized, or initialized as a dictionary.</p>
|
|
<p><tt class="docutils literal">load_state</tt> expects a <a class="reference external" href="reference-Bencoding.html#lazy_entry">lazy_entry</a> which can be built from a bencoded
|
|
buffer with <a class="reference external" href="reference-Bencoding.html#lazy_bdecode()">lazy_bdecode()</a>.</p>
|
|
<p>The <tt class="docutils literal">flags</tt> arguments passed in to <tt class="docutils literal">save_state</tt> can be used to
|
|
filter which parts of the <a class="reference external" href="reference-Session.html#session">session</a> state to save. By default, all state
|
|
is saved (except for the individual torrents). see <a class="reference external" href="reference-Session.html#save_state_flags_t">save_state_flags_t</a></p>
|
|
<a name="get_torrent_status()"></a>
|
|
<a name="refresh_torrent_status()"></a></div>
|
|
<div class="section" id="get-torrent-status-refresh-torrent-status">
|
|
<h2>get_torrent_status() refresh_torrent_status()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>refresh_torrent_status</strong> (std::vector<torrent_status>* ret
|
|
, boost::uint32_t flags = 0) const;
|
|
void <strong>get_torrent_status</strong> (std::vector<torrent_status>* ret
|
|
, boost::function<bool(torrent_status const&)> const& pred
|
|
, boost::uint32_t flags = 0) const;
|
|
</pre>
|
|
<div class="note">
|
|
<p class="first admonition-title">Note</p>
|
|
<p class="last">these calls are potentially expensive and won't scale well with
|
|
lots of torrents. If you're concerned about performance, consider
|
|
using <tt class="docutils literal">post_torrent_updates()</tt> instead.</p>
|
|
</div>
|
|
<p><tt class="docutils literal">get_torrent_status</tt> returns a vector of the <a class="reference external" href="reference-Core.html#torrent_status">torrent_status</a> for
|
|
every torrent which satisfies <tt class="docutils literal">pred</tt>, which is a predicate function
|
|
which determines if a torrent should be included in the returned set
|
|
or not. Returning true means it should be included and false means
|
|
excluded. The <tt class="docutils literal">flags</tt> argument is the same as to
|
|
<tt class="docutils literal"><span class="pre">torrent_handle::status()</span></tt>. Since <tt class="docutils literal">pred</tt> is guaranteed to be
|
|
called for every torrent, it may be used to count the number of
|
|
torrents of different categories as well.</p>
|
|
<p><tt class="docutils literal">refresh_torrent_status</tt> takes a vector of <a class="reference external" href="reference-Core.html#torrent_status">torrent_status</a> structs
|
|
(for instance the same vector that was returned by
|
|
<a class="reference external" href="reference-Session.html#get_torrent_status()">get_torrent_status()</a> ) and refreshes the status based on the
|
|
<tt class="docutils literal">handle</tt> member. It is possible to use this function by first
|
|
setting up a vector of default constructed <tt class="docutils literal">torrent_status</tt> objects,
|
|
only initializing the <tt class="docutils literal">handle</tt> member, in order to request the
|
|
torrent status for multiple torrents in a single call. This can save a
|
|
significant amount of time if you have a lot of torrents.</p>
|
|
<p>Any <a class="reference external" href="reference-Core.html#torrent_status">torrent_status</a> object whose <tt class="docutils literal">handle</tt> member is not referring to
|
|
a valid torrent are ignored.</p>
|
|
<a name="post_torrent_updates()"></a></div>
|
|
<div class="section" id="post-torrent-updates">
|
|
<h2>post_torrent_updates()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>post_torrent_updates</strong> (boost::uint32_t flags = 0xffffffff);
|
|
</pre>
|
|
<p>This functions instructs the <a class="reference external" href="reference-Session.html#session">session</a> to post the <a class="reference external" href="reference-Alerts.html#state_update_alert">state_update_alert</a>,
|
|
containing the status of all torrents whose state changed since the
|
|
last time this function was called.</p>
|
|
<p>Only torrents who has the state subscription flag set will be
|
|
included. This flag is on by default. See <a class="reference external" href="reference-Session.html#add_torrent_params">add_torrent_params</a>.
|
|
the <tt class="docutils literal">flags</tt> argument is the same as for <a class="reference external" href="reference-Core.html#status()">torrent_handle::status()</a>.
|
|
see <a class="reference external" href="reference-Core.html#status_flags_t">torrent_handle::status_flags_t</a>.</p>
|
|
<a name="post_session_stats()"></a></div>
|
|
<div class="section" id="post-session-stats">
|
|
<h2>post_session_stats()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>post_session_stats</strong> ();
|
|
</pre>
|
|
<p>This function will post a <a class="reference external" href="reference-Alerts.html#session_stats_alert">session_stats_alert</a> object, containing a
|
|
snapshot of the performance counters from the internals of libtorrent.
|
|
To interpret these counters, query the <a class="reference external" href="reference-Session.html#session">session</a> via
|
|
<a class="reference external" href="reference-Session.html#session_stats_metrics()">session_stats_metrics()</a>.</p>
|
|
<p>For more information, see the <a class="reference external" href="manual-ref.html#session-statistics">session statistics</a> section.</p>
|
|
<a name="post_dht_stats()"></a></div>
|
|
<div class="section" id="post-dht-stats">
|
|
<h2>post_dht_stats()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>post_dht_stats</strong> ();
|
|
</pre>
|
|
<p>This will cause a <a class="reference external" href="reference-Alerts.html#dht_stats_alert">dht_stats_alert</a> to be posted.</p>
|
|
<a name="find_torrent()"></a>
|
|
<a name="get_torrents()"></a></div>
|
|
<div class="section" id="find-torrent-get-torrents">
|
|
<h2>find_torrent() get_torrents()</h2>
|
|
<pre class="literal-block">
|
|
torrent_handle <strong>find_torrent</strong> (sha1_hash const& info_hash) const;
|
|
std::vector<torrent_handle> <strong>get_torrents</strong> () const;
|
|
</pre>
|
|
<p><tt class="docutils literal">find_torrent()</tt> looks for a torrent with the given info-hash. In
|
|
case there is such a torrent in the <a class="reference external" href="reference-Session.html#session">session</a>, a <a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a> to that
|
|
torrent is returned. In case the torrent cannot be found, an invalid
|
|
<a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a> is returned.</p>
|
|
<p>See <tt class="docutils literal"><span class="pre">torrent_handle::is_valid()</span></tt> to know if the torrent was found or
|
|
not.</p>
|
|
<p><tt class="docutils literal">get_torrents()</tt> returns a vector of torrent_handles to all the
|
|
torrents currently in the <a class="reference external" href="reference-Session.html#session">session</a>.</p>
|
|
<a name="add_torrent()"></a>
|
|
<a name="async_add_torrent()"></a></div>
|
|
<div class="section" id="add-torrent-async-add-torrent">
|
|
<h2>add_torrent() async_add_torrent()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>async_add_torrent</strong> (add_torrent_params const& params);
|
|
torrent_handle <strong>add_torrent</strong> (add_torrent_params const& params, error_code& ec);
|
|
torrent_handle <strong>add_torrent</strong> (add_torrent_params const& params);
|
|
</pre>
|
|
<p>You add torrents through the <a class="reference external" href="reference-Session.html#add_torrent()">add_torrent()</a> function where you give an
|
|
object with all the parameters. The <a class="reference external" href="reference-Session.html#add_torrent()">add_torrent()</a> overloads will block
|
|
until the torrent has been added (or failed to be added) and returns
|
|
an error code and a <a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a>. In order to add torrents more
|
|
efficiently, consider using <a class="reference external" href="reference-Session.html#async_add_torrent()">async_add_torrent()</a> which returns
|
|
immediately, without waiting for the torrent to add. Notification of
|
|
the torrent being added is sent as <a class="reference external" href="reference-Alerts.html#add_torrent_alert">add_torrent_alert</a>.</p>
|
|
<p>The overload that does not take an error_code throws an exception on
|
|
error and is not available when building without exception support.
|
|
The <a class="reference external" href="reference-Core.html#torrent_handle">torrent_handle</a> returned by <a class="reference external" href="reference-Session.html#add_torrent()">add_torrent()</a> can be used to retrieve
|
|
information about the torrent's progress, its peers etc. It is also
|
|
used to abort a torrent.</p>
|
|
<p>If the torrent you are trying to add already exists in the <a class="reference external" href="reference-Session.html#session">session</a> (is
|
|
either queued for checking, being checked or downloading)
|
|
<tt class="docutils literal">add_torrent()</tt> will throw <a class="reference external" href="reference-Error_Codes.html#libtorrent_exception">libtorrent_exception</a> which derives from
|
|
<tt class="docutils literal"><span class="pre">std::exception</span></tt> unless duplicate_is_error is set to false. In that
|
|
case, <a class="reference external" href="reference-Session.html#add_torrent()">add_torrent()</a> will return the handle to the existing torrent.</p>
|
|
<p>all torrent_handles must be destructed before the <a class="reference external" href="reference-Session.html#session">session</a> is destructed!</p>
|
|
<a name="abort()"></a></div>
|
|
<div class="section" id="abort">
|
|
<h2>abort()</h2>
|
|
<pre class="literal-block">
|
|
session_proxy <strong>abort</strong> ();
|
|
</pre>
|
|
<p>In case you want to destruct the <a class="reference external" href="reference-Session.html#session">session</a> asynchrounously, you can
|
|
request a <a class="reference external" href="reference-Session.html#session">session</a> destruction proxy. If you don't do this, the
|
|
destructor of the <a class="reference external" href="reference-Session.html#session">session</a> object will block while the trackers are
|
|
contacted. If you keep one <tt class="docutils literal">session_proxy</tt> to the <a class="reference external" href="reference-Session.html#session">session</a> when
|
|
destructing it, the destructor will not block, but start to close down
|
|
the <a class="reference external" href="reference-Session.html#session">session</a>, the destructor of the proxy will then synchronize the
|
|
threads. So, the destruction of the <a class="reference external" href="reference-Session.html#session">session</a> is performed from the
|
|
<tt class="docutils literal">session</tt> destructor call until the <tt class="docutils literal">session_proxy</tt> destructor
|
|
call. The <tt class="docutils literal">session_proxy</tt> does not have any operations on it (since
|
|
the <a class="reference external" href="reference-Session.html#session">session</a> is being closed down, no operations are allowed on it).
|
|
The only valid operation is calling the destructor:</p>
|
|
<pre class="literal-block">
|
|
class session_proxy
|
|
{
|
|
public:
|
|
session_proxy();
|
|
~session_proxy()
|
|
};
|
|
</pre>
|
|
<a name="pause()"></a>
|
|
<a name="resume()"></a>
|
|
<a name="is_paused()"></a></div>
|
|
<div class="section" id="pause-resume-is-paused">
|
|
<h2>pause() resume() is_paused()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>resume</strong> ();
|
|
void <strong>pause</strong> ();
|
|
bool <strong>is_paused</strong> () const;
|
|
</pre>
|
|
<p>Pausing the <a class="reference external" href="reference-Session.html#session">session</a> has the same effect as pausing every torrent in
|
|
it, except that torrents will not be resumed by the auto-manage
|
|
mechanism. Resuming will restore the torrents to their previous paused
|
|
state. i.e. the <a class="reference external" href="reference-Session.html#session">session</a> pause state is separate from the torrent pause
|
|
state. A torrent is inactive if it is paused or if the <a class="reference external" href="reference-Session.html#session">session</a> is
|
|
paused.</p>
|
|
<a name="set_load_function()"></a></div>
|
|
<div class="section" id="set-load-function">
|
|
<h2>set_load_function()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>set_load_function</strong> (user_load_function_t fun);
|
|
</pre>
|
|
<p>This function enables <a class="reference external" href="manual-ref.html#dynamic-loading-of-torrent-files">dynamic loading of torrent files</a>. When a
|
|
torrent is unloaded but needs to be availabe in memory, this function
|
|
is called <strong>from within the libtorrent network thread</strong>. From within
|
|
this thread, you can <strong>not</strong> use any of the public APIs of libtorrent
|
|
itself. The the info-hash of the torrent is passed in to the function
|
|
and it is expected to fill in the passed in <tt class="docutils literal">vector<char></tt> with the
|
|
.torrent file corresponding to it.</p>
|
|
<p>If there is an error loading the torrent file, the <tt class="docutils literal">error_code</tt>
|
|
(<tt class="docutils literal">ec</tt>) should be set to reflect the error. In such case, the torrent
|
|
itself is stopped and set to an error state with the corresponding
|
|
error code.</p>
|
|
<p>Given that the function is called from the internal network thread of
|
|
libtorrent, it's important to not stall. libtorrent will not be able
|
|
to send nor receive any data until the function call returns.</p>
|
|
<p>The signature of the function to pass in is:</p>
|
|
<pre class="literal-block">
|
|
void fun(sha1_hash const& info_hash, std::vector<char>& buf, error_code& ec);
|
|
</pre>
|
|
<a name="get_cache_info()"></a></div>
|
|
<div class="section" id="get-cache-info">
|
|
<h2>get_cache_info()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>get_cache_info</strong> (cache_status* ret, torrent_handle h = torrent_handle(), int flags = 0) const;
|
|
</pre>
|
|
<p>Fills in the <a class="reference external" href="reference-Session.html#cache_status">cache_status</a> struct with information about the given torrent.
|
|
If <tt class="docutils literal">flags</tt> is <tt class="docutils literal"><span class="pre">session::disk_cache_no_pieces</span></tt> the <tt class="docutils literal"><span class="pre">cache_status::pieces</span></tt> field
|
|
will not be set. This may significantly reduce the cost of this call.</p>
|
|
<a name="add_feed()"></a></div>
|
|
<div class="section" id="add-feed">
|
|
<h2>add_feed()</h2>
|
|
<pre class="literal-block">
|
|
feed_handle <strong>add_feed</strong> (feed_settings const& feed);
|
|
</pre>
|
|
<p>This adds an RSS feed to the <a class="reference external" href="reference-Session.html#session">session</a>. The feed will be refreshed
|
|
regularly and optionally add all torrents from the feed, as they
|
|
appear.</p>
|
|
<p>Before adding the feed, you must set the <tt class="docutils literal">url</tt> field to the feed's
|
|
url. It may point to an RSS or an atom feed. The returned <a class="reference external" href="reference-RSS.html#feed_handle">feed_handle</a>
|
|
is a handle which is used to interact with the feed, things like
|
|
forcing a refresh or querying for information about the items in the
|
|
feed. For more information, see <a class="reference external" href="reference-RSS.html#feed_handle">feed_handle</a>.</p>
|
|
<a name="remove_feed()"></a></div>
|
|
<div class="section" id="remove-feed">
|
|
<h2>remove_feed()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>remove_feed</strong> (feed_handle h);
|
|
</pre>
|
|
<p>Removes a feed from being watched by the <a class="reference external" href="reference-Session.html#session">session</a>. When this
|
|
call returns, the feed handle is invalid and won't refer
|
|
to any feed.</p>
|
|
<a name="get_feeds()"></a></div>
|
|
<div class="section" id="get-feeds">
|
|
<h2>get_feeds()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>get_feeds</strong> (std::vector<feed_handle>& f) const;
|
|
</pre>
|
|
<p>Returns a list of all RSS feeds that are being watched by the <a class="reference external" href="reference-Session.html#session">session</a>.</p>
|
|
<a name="is_dht_running()"></a>
|
|
<a name="set_dht_settings()"></a></div>
|
|
<div class="section" id="is-dht-running-set-dht-settings">
|
|
<h2>is_dht_running() set_dht_settings()</h2>
|
|
<pre class="literal-block">
|
|
bool <strong>is_dht_running</strong> () const;
|
|
void <strong>set_dht_settings</strong> (dht_settings const& settings);
|
|
</pre>
|
|
<p><tt class="docutils literal">set_dht_settings</tt> sets some parameters availavle to the dht node.
|
|
See <a class="reference external" href="reference-Settings.html#dht_settings">dht_settings</a> for more information.</p>
|
|
<p><tt class="docutils literal">is_dht_running()</tt> returns true if the DHT support has been started
|
|
and false
|
|
otherwise.</p>
|
|
<a name="add_dht_router()"></a>
|
|
<a name="add_dht_node()"></a></div>
|
|
<div class="section" id="add-dht-router-add-dht-node">
|
|
<h2>add_dht_router() add_dht_node()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>add_dht_router</strong> (std::pair<std::string, int> const& node);
|
|
void <strong>add_dht_node</strong> (std::pair<std::string, int> const& node);
|
|
</pre>
|
|
<p><tt class="docutils literal">add_dht_node</tt> takes a host name and port pair. That endpoint will be
|
|
pinged, and if a valid DHT reply is received, the node will be added to
|
|
the routing table.</p>
|
|
<p><tt class="docutils literal">add_dht_router</tt> adds the given endpoint to a list of DHT router
|
|
nodes. If a search is ever made while the routing table is empty,
|
|
those nodes will be used as backups. Nodes in the router node list
|
|
will also never be added to the regular routing table, which
|
|
effectively means they are only used for bootstrapping, to keep the
|
|
load off them.</p>
|
|
<p>An example routing node that you could typically add is
|
|
<tt class="docutils literal">router.bittorrent.com</tt>.</p>
|
|
<a name="dht_get_item()"></a></div>
|
|
<div class="section" id="dht-get-item">
|
|
<h2>dht_get_item()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>dht_get_item</strong> (sha1_hash const& target);
|
|
</pre>
|
|
<p>query the DHT for an immutable item at the <tt class="docutils literal">target</tt> hash.
|
|
the result is posted as a <a class="reference external" href="reference-Alerts.html#dht_immutable_item_alert">dht_immutable_item_alert</a>.</p>
|
|
<a name="dht_get_item()"></a></div>
|
|
<div class="section" id="id104">
|
|
<h2>dht_get_item()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>dht_get_item</strong> (boost::array<char, 32> key
|
|
, std::string salt = std::string());
|
|
</pre>
|
|
<p>query the DHT for a mutable item under the public key <tt class="docutils literal">key</tt>.
|
|
this is an ed25519 key. <tt class="docutils literal">salt</tt> is optional and may be left
|
|
as an empty string if no salt is to be used.
|
|
if the item is found in the DHT, a <a class="reference external" href="reference-Alerts.html#dht_mutable_item_alert">dht_mutable_item_alert</a> is
|
|
posted.</p>
|
|
<a name="dht_put_item()"></a></div>
|
|
<div class="section" id="dht-put-item">
|
|
<h2>dht_put_item()</h2>
|
|
<pre class="literal-block">
|
|
sha1_hash <strong>dht_put_item</strong> (entry data);
|
|
</pre>
|
|
<p>store the given bencoded data as an immutable item in the DHT.
|
|
the returned hash is the key that is to be used to look the item
|
|
up agan. It's just the sha-1 hash of the bencoded form of the
|
|
structure.</p>
|
|
<a name="dht_put_item()"></a></div>
|
|
<div class="section" id="id106">
|
|
<h2>dht_put_item()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>dht_put_item</strong> (boost::array<char, 32> key
|
|
, boost::function<void(entry&, boost::array<char,64>&
|
|
, boost::uint64_t&, std::string const&)> cb
|
|
, std::string salt = std::string());
|
|
</pre>
|
|
<p>store a mutable item. The <tt class="docutils literal">key</tt> is the public key the blob is
|
|
to be stored under. The optional <tt class="docutils literal">salt</tt> argument is a string that
|
|
is to be mixed in with the key when determining where in the DHT
|
|
the value is to be stored. The callback function is called from within
|
|
the libtorrent network thread once we've found where to store the blob,
|
|
possibly with the current value stored under the key.
|
|
The values passed to the callback functions are:</p>
|
|
<dl class="docutils">
|
|
<dt>entry& value</dt>
|
|
<dd>the current value stored under the key (may be empty). Also expected
|
|
to be set to the value to be stored by the function.</dd>
|
|
<dt>boost::array<char,64>& signature</dt>
|
|
<dd>the signature authenticating the current value. This may be zeroes
|
|
if there is currently no value stored. The functon is expected to
|
|
fill in this buffer with the signature of the new value to store.
|
|
To generate the signature, you may want to use the
|
|
<tt class="docutils literal">sign_mutable_item</tt> function.</dd>
|
|
<dt>boost::uint64_t& seq</dt>
|
|
<dd>current sequence number. May be zero if there is no current value.
|
|
The function is expected to set this to the new sequence number of
|
|
the value that is to be stored. Sequence numbers must be monotonically
|
|
increasing. Attempting to overwrite a value with a lower or equal
|
|
sequence number will fail, even if the signature is correct.</dd>
|
|
<dt>std::string const& salt</dt>
|
|
<dd>this is the salt that was used for this put call.</dd>
|
|
</dl>
|
|
<p>Since the callback function <tt class="docutils literal">cb</tt> is called from within libtorrent,
|
|
it is critical to not perform any blocking operations. Ideally not
|
|
even locking a mutex. Pass any data required for this function along
|
|
with the function object's context and make the function entirely
|
|
self-contained. The only reason data blobs' values are computed
|
|
via a function instead of just passing in the new value is to avoid
|
|
race conditions. If you want to <em>update</em> the value in the DHT, you
|
|
must first retrieve it, then modify it, then write it back. The way
|
|
the DHT works, it is natural to always do a lookup before storing and
|
|
calling the callback in between is convenient.</p>
|
|
<a name="add_extension()"></a></div>
|
|
<div class="section" id="add-extension">
|
|
<h2>add_extension()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>add_extension</strong> (boost::function<boost::shared_ptr<torrent_plugin>(
|
|
torrent*, void*)> ext);
|
|
void <strong>add_extension</strong> (boost::shared_ptr<plugin> ext);
|
|
</pre>
|
|
<p>This function adds an extension to this <a class="reference external" href="reference-Session.html#session">session</a>. The argument is a
|
|
function object that is called with a <tt class="docutils literal">torrent*</tt> and which should
|
|
return a <tt class="docutils literal"><span class="pre">boost::shared_ptr<torrent_plugin></span></tt>. To write custom
|
|
plugins, see <a class="reference external" href="libtorrent_plugins.html">libtorrent plugins</a>. For the typical bittorrent client
|
|
all of these extensions should be added. The main plugins implemented
|
|
in libtorrent are:</p>
|
|
<dl class="docutils">
|
|
<dt>metadata extension</dt>
|
|
<dd>Allows peers to download the metadata (.torren files) from the swarm
|
|
directly. Makes it possible to join a swarm with just a tracker and
|
|
info-hash.</dd>
|
|
</dl>
|
|
<pre class="literal-block">
|
|
#include <libtorrent/extensions/metadata_transfer.hpp>
|
|
ses.add_extension(&libtorrent::create_metadata_plugin);
|
|
</pre>
|
|
<dl class="docutils">
|
|
<dt>uTorrent metadata</dt>
|
|
<dd>Same as <tt class="docutils literal">metadata extension</tt> but compatible with uTorrent.</dd>
|
|
</dl>
|
|
<pre class="literal-block">
|
|
#include <libtorrent/extensions/ut_metadata.hpp>
|
|
ses.add_extension(&libtorrent::create_ut_metadata_plugin);
|
|
</pre>
|
|
<dl class="docutils">
|
|
<dt>uTorrent peer exchange</dt>
|
|
<dd>Exchanges peers between clients.</dd>
|
|
</dl>
|
|
<pre class="literal-block">
|
|
#include <libtorrent/extensions/ut_pex.hpp>
|
|
ses.add_extension(&libtorrent::create_ut_pex_plugin);
|
|
</pre>
|
|
<dl class="docutils">
|
|
<dt>smart ban <a class="reference external" href="reference-Plugins.html#plugin">plugin</a></dt>
|
|
<dd>A <a class="reference external" href="reference-Plugins.html#plugin">plugin</a> that, with a small overhead, can ban peers
|
|
that sends bad data with very high accuracy. Should
|
|
eliminate most problems on poisoned torrents.</dd>
|
|
</dl>
|
|
<pre class="literal-block">
|
|
#include <libtorrent/extensions/smart_ban.hpp>
|
|
ses.add_extension(&libtorrent::create_smart_ban_plugin);
|
|
</pre>
|
|
<a name="get_ip_filter()"></a>
|
|
<a name="set_ip_filter()"></a></div>
|
|
<div class="section" id="get-ip-filter-set-ip-filter">
|
|
<h2>get_ip_filter() set_ip_filter()</h2>
|
|
<pre class="literal-block">
|
|
ip_filter <strong>get_ip_filter</strong> () const;
|
|
void <strong>set_ip_filter</strong> (ip_filter const& f);
|
|
</pre>
|
|
<p>Sets a filter that will be used to reject and accept incoming as well
|
|
as outgoing connections based on their originating ip address. The
|
|
default filter will allow connections to any ip address. To build a
|
|
set of rules for which addresses are accepted and not, see <a class="reference external" href="reference-Filter.html#ip_filter">ip_filter</a>.</p>
|
|
<p>Each time a peer is blocked because of the IP filter, a
|
|
<a class="reference external" href="reference-Alerts.html#peer_blocked_alert">peer_blocked_alert</a> is generated. <tt class="docutils literal">get_ip_filter()</tt> Returns the
|
|
<a class="reference external" href="reference-Filter.html#ip_filter">ip_filter</a> currently in the <a class="reference external" href="reference-Session.html#session">session</a>. See <a class="reference external" href="reference-Filter.html#ip_filter">ip_filter</a>.</p>
|
|
<a name="set_port_filter()"></a></div>
|
|
<div class="section" id="set-port-filter">
|
|
<h2>set_port_filter()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>set_port_filter</strong> (port_filter const& f);
|
|
</pre>
|
|
<p>apply <a class="reference external" href="reference-Filter.html#port_filter">port_filter</a> <tt class="docutils literal">f</tt> to incoming and outgoing peers. a port filter
|
|
will reject making outgoing peer connections to certain remote ports.
|
|
The main intention is to be able to avoid triggering certain
|
|
anti-virus software by connecting to SMTP, FTP ports.</p>
|
|
<a name="id()"></a></div>
|
|
<div class="section" id="id">
|
|
<h2>id()</h2>
|
|
<pre class="literal-block">
|
|
peer_id <strong>id</strong> () const;
|
|
</pre>
|
|
<p>returns the raw peer ID used by libtorrent. When anonymous mode is set
|
|
the peer ID is randomized per peer.</p>
|
|
<a name="set_key()"></a></div>
|
|
<div class="section" id="set-key">
|
|
<h2>set_key()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>set_key</strong> (int key);
|
|
</pre>
|
|
<p>sets the key sent to trackers. If it's not set, it is initialized
|
|
by libtorrent. The key may be used by the tracker to identify the
|
|
peer potentially across you changing your IP.</p>
|
|
<a name="listen_port()"></a>
|
|
<a name="ssl_listen_port()"></a>
|
|
<a name="is_listening()"></a></div>
|
|
<div class="section" id="listen-port-ssl-listen-port-is-listening">
|
|
<h2>listen_port() ssl_listen_port() is_listening()</h2>
|
|
<pre class="literal-block">
|
|
bool <strong>is_listening</strong> () const;
|
|
unsigned short <strong>listen_port</strong> () const;
|
|
unsigned short <strong>ssl_listen_port</strong> () const;
|
|
</pre>
|
|
<p><tt class="docutils literal">is_listening()</tt> will tell you whether or not the <a class="reference external" href="reference-Session.html#session">session</a> has
|
|
successfully opened a listening port. If it hasn't, this function will
|
|
return false, and then you can set a new
|
|
<a class="reference external" href="reference-Settings.html#listen_interfaces">settings_pack::listen_interfaces</a> to try another interface and port to
|
|
bind to.</p>
|
|
<p><tt class="docutils literal">listen_port()</tt> returns the port we ended up listening on. If the
|
|
port specified in <a class="reference external" href="reference-Settings.html#listen_interfaces">settings_pack::listen_interfaces</a> failed, libtorrent
|
|
will try to bind to the next port, and so on. If it fails
|
|
<a class="reference external" href="reference-Settings.html#max_retry_port_bind">settings_pack::max_retry_port_bind</a> times, it will bind to port 0
|
|
(meaning the OS picks the port). The only way to know which port it
|
|
ended up binding to is to ask for it by calling <tt class="docutils literal">listen_port()</tt>.</p>
|
|
<p>If all ports in the specified range fails to be opened for listening,
|
|
libtorrent will try to use port 0 (which tells the operating system to
|
|
pick a port that's free). If that still fails you may see a
|
|
<a class="reference external" href="reference-Alerts.html#listen_failed_alert">listen_failed_alert</a> with port 0 even if you didn't ask to listen on
|
|
it.</p>
|
|
<p>It is possible to prevent libtorrent from binding to port 0 by passing
|
|
in the flag <tt class="docutils literal"><span class="pre">session::no_system_port</span></tt> in the <tt class="docutils literal">flags</tt> argument.</p>
|
|
<p>The interface parameter can also be a hostname that will resolve to
|
|
the device you want to listen on. If you don't specify an interface,
|
|
libtorrent may attempt to listen on multiple interfaces (typically
|
|
0.0.0.0 and ::). This means that if your IPv6 interface doesn't work,
|
|
you may still see a <a class="reference external" href="reference-Alerts.html#listen_failed_alert">listen_failed_alert</a>, even though the IPv4 port
|
|
succeeded.</p>
|
|
<p>The <tt class="docutils literal">flags</tt> parameter can either be 0 or
|
|
<tt class="docutils literal"><span class="pre">session::listen_reuse_address</span></tt>, which will set the reuse address
|
|
socket option on the listen socket(s). By default, the listen socket
|
|
does not use reuse address. If you're running a service that needs to
|
|
run on a specific port no matter if it's in use, set this flag.</p>
|
|
<a name="set_peer_class_filter()"></a></div>
|
|
<div class="section" id="set-peer-class-filter">
|
|
<h2>set_peer_class_filter()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>set_peer_class_filter</strong> (ip_filter const& f);
|
|
</pre>
|
|
<p>Sets the peer class filter for this <a class="reference external" href="reference-Session.html#session">session</a>. All new peer connections
|
|
will take this into account and be added to the peer classes specified
|
|
by this filter, based on the peer's IP address.</p>
|
|
<p>The ip-filter essentially maps an IP -> uint32. Each bit in that 32
|
|
bit integer represents a peer class. The least significant bit
|
|
represents class 0, the next bit class 1 and so on.</p>
|
|
<p>For more info, see <a class="reference external" href="reference-Filter.html#ip_filter">ip_filter</a>.</p>
|
|
<p>For example, to make all peers in the range 200.1.1.0 - 200.1.255.255
|
|
belong to their own peer class, apply the following filter:</p>
|
|
<pre class="literal-block">
|
|
ip_filter f;
|
|
int my_class = ses.create_peer_class("200.1.x.x IP range");
|
|
f.add_rule(address_v4::from_string("200.1.1.0")
|
|
, address_v4::from_string("200.1.255.255")
|
|
, 1 << my_class);
|
|
ses.set_peer_class_filter(f);
|
|
</pre>
|
|
<p>This setting only applies to new connections, it won't affect existing
|
|
peer connections.</p>
|
|
<p>This function is limited to only peer class 0-31, since there are only
|
|
32 bits in the IP range mapping. Only the set bits matter; no peer
|
|
class will be removed from a peer as a result of this call, peer
|
|
classes are only added.</p>
|
|
<p>The <tt class="docutils literal">peer_class</tt> argument cannot be greater than 31. The bitmasks
|
|
representing peer classes in the <tt class="docutils literal">peer_class_filter</tt> are 32 bits.</p>
|
|
<p>For more information, see <a class="reference external" href="manual-ref.html#peer-classes">peer classes</a>.</p>
|
|
<a name="set_peer_class_type_filter()"></a></div>
|
|
<div class="section" id="set-peer-class-type-filter">
|
|
<h2>set_peer_class_type_filter()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>set_peer_class_type_filter</strong> (peer_class_type_filter const& f);
|
|
</pre>
|
|
<p>Sets and gets the <em>peer class type filter</em>. This is controls automatic
|
|
peer class assignments to peers based on what kind of socket it is.</p>
|
|
<p>It does not only support assigning peer classes, it also supports
|
|
removing peer classes based on socket type.</p>
|
|
<p>The order of these rules being applied are:</p>
|
|
<ol class="arabic simple">
|
|
<li>peer-class IP filter</li>
|
|
<li>peer-class type filter, removing classes</li>
|
|
<li>peer-class type filter, adding classes</li>
|
|
</ol>
|
|
<p>For more information, see <a class="reference external" href="manual-ref.html#peer-classes">peer classes</a>.
|
|
TODO: add get_peer_class_type_filter() as well</p>
|
|
<a name="create_peer_class()"></a></div>
|
|
<div class="section" id="create-peer-class">
|
|
<h2>create_peer_class()</h2>
|
|
<pre class="literal-block">
|
|
int <strong>create_peer_class</strong> (char const* name);
|
|
</pre>
|
|
<p>Creates a new peer class (see <a class="reference external" href="manual-ref.html#peer-classes">peer classes</a>) with the given name. The
|
|
returned integer is the new peer class' identifier. Peer classes may
|
|
have the same name, so each invocation of this function creates a new
|
|
class and returns a unique identifier.</p>
|
|
<p>Identifiers are assigned from low numbers to higher. So if you plan on
|
|
using certain peer classes in a call to <a class="reference internal" href="#set-peer-class-filter">set_peer_class_filter()</a>,
|
|
make sure to create those early on, to get low identifiers.</p>
|
|
<p>For more information on peer classes, see <a class="reference external" href="manual-ref.html#peer-classes">peer classes</a>.</p>
|
|
<a name="delete_peer_class()"></a></div>
|
|
<div class="section" id="delete-peer-class">
|
|
<h2>delete_peer_class()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>delete_peer_class</strong> (int cid);
|
|
</pre>
|
|
<p>This call dereferences the reference count of the specified peer
|
|
class. When creating a peer class it's automatically referenced by 1.
|
|
If you want to recycle a peer class, you may call this function. You
|
|
may only call this function <strong>once</strong> per peer class you create.
|
|
Calling it more than once for the same class will lead to memory
|
|
corruption.</p>
|
|
<p>Since peer classes are reference counted, this function will not
|
|
remove the peer class if it's still assigned to torrents or peers. It
|
|
will however remove it once the last peer and torrent drops their
|
|
references to it.</p>
|
|
<p>There is no need to call this function for custom peer classes. All
|
|
peer classes will be properly destructed when the <a class="reference external" href="reference-Session.html#session">session</a> object
|
|
destructs.</p>
|
|
<p>For more information on peer classes, see <a class="reference external" href="manual-ref.html#peer-classes">peer classes</a>.</p>
|
|
<a name="get_peer_class()"></a>
|
|
<a name="set_peer_class()"></a></div>
|
|
<div class="section" id="get-peer-class-set-peer-class">
|
|
<h2>get_peer_class() set_peer_class()</h2>
|
|
<pre class="literal-block">
|
|
peer_class_info <strong>get_peer_class</strong> (int cid);
|
|
void <strong>set_peer_class</strong> (int cid, peer_class_info const& pci);
|
|
</pre>
|
|
<p>These functions queries information from a peer class and updates the
|
|
configuration of a peer class, respectively.</p>
|
|
<p><tt class="docutils literal">cid</tt> must refer to an existing peer class. If it does not, the
|
|
return value of <tt class="docutils literal">get_peer_class()</tt> is undefined.</p>
|
|
<p><tt class="docutils literal">set_peer_class()</tt> sets all the information in the
|
|
<tt class="docutils literal">peer_class_info</tt> object in the specified peer class. There is no
|
|
option to only update a single property.</p>
|
|
<p>A peer or torrent balonging to more than one class, the highest
|
|
priority among any of its classes is the one that is taken into
|
|
account.</p>
|
|
<p>For more information, see <a class="reference external" href="manual-ref.html#peer-classes">peer classes</a>.</p>
|
|
<a name="remove_torrent()"></a></div>
|
|
<div class="section" id="remove-torrent">
|
|
<h2>remove_torrent()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>remove_torrent</strong> (const torrent_handle& h, int options = 0);
|
|
</pre>
|
|
<p><tt class="docutils literal">remove_torrent()</tt> will close all peer connections associated with
|
|
the torrent and tell the tracker that we've stopped participating in
|
|
the swarm. This operation cannot fail. When it completes, you will
|
|
receive a <a class="reference external" href="reference-Alerts.html#torrent_removed_alert">torrent_removed_alert</a>.</p>
|
|
<p>The optional second argument <tt class="docutils literal">options</tt> can be used to delete all the
|
|
files downloaded by this torrent. To do so, pass in the value
|
|
<tt class="docutils literal"><span class="pre">session::delete_files</span></tt>. The removal of the torrent is asyncronous,
|
|
there is no guarantee that adding the same torrent immediately after
|
|
it was removed will not throw a <a class="reference external" href="reference-Error_Codes.html#libtorrent_exception">libtorrent_exception</a> exception. Once
|
|
the torrent is deleted, a <a class="reference external" href="reference-Alerts.html#torrent_deleted_alert">torrent_deleted_alert</a> is posted.</p>
|
|
<a name="get_settings()"></a>
|
|
<a name="apply_settings()"></a></div>
|
|
<div class="section" id="get-settings-apply-settings">
|
|
<h2>get_settings() apply_settings()</h2>
|
|
<pre class="literal-block">
|
|
aux::session_settings <strong>get_settings</strong> () const;
|
|
void <strong>apply_settings</strong> (settings_pack const& s);
|
|
</pre>
|
|
<p>Applies the settings specified by the <a class="reference external" href="reference-Settings.html#settings_pack">settings_pack</a> <tt class="docutils literal">s</tt>. This is an
|
|
asynchronous operation that will return immediately and actually apply
|
|
the settings to the main thread of libtorrent some time later.</p>
|
|
<a name="pop_alert()"></a>
|
|
<a name="pop_alerts()"></a>
|
|
<a name="wait_for_alert()"></a></div>
|
|
<div class="section" id="pop-alert-pop-alerts-wait-for-alert">
|
|
<h2>pop_alert() pop_alerts() wait_for_alert()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>pop_alerts</strong> (std::deque<alert*>* alerts);
|
|
std::auto_ptr<alert> <strong>pop_alert</strong> ();
|
|
alert const* <strong>wait_for_alert</strong> (time_duration max_wait);
|
|
</pre>
|
|
<p><tt class="docutils literal">pop_alert()</tt> is used to ask the <a class="reference external" href="reference-Session.html#session">session</a> if any errors or events has
|
|
occurred. With <a class="reference external" href="reference-Settings.html#alert_mask">settings_pack::alert_mask</a> you can filter which alerts
|
|
to receive through <tt class="docutils literal">pop_alert()</tt>. For information about the <a class="reference external" href="reference-Alerts.html#alert">alert</a>
|
|
categories, see <a class="reference external" href="manual-ref.html#alerts">alerts</a>.</p>
|
|
<p><tt class="docutils literal">pop_alerts()</tt> pops all pending alerts in a single call. In high
|
|
performance environments with a very high <a class="reference external" href="reference-Alerts.html#alert">alert</a> churn rate, this can
|
|
save significant amount of time compared to popping alerts one at a
|
|
time. Each call requires one round-trip to the network thread. If
|
|
alerts are produced in a higher rate than they can be popped (when
|
|
popped one at a time) it's easy to get stuck in an infinite loop,
|
|
trying to drain the <a class="reference external" href="reference-Alerts.html#alert">alert</a> queue. Popping the entire queue at once
|
|
avoids this problem.</p>
|
|
<p>However, the <tt class="docutils literal">pop_alerts</tt> function comes with significantly more
|
|
responsibility. You pass in an <em>empty</em> <tt class="docutils literal"><span class="pre">std::dequeue<alert*></span></tt> to it.
|
|
If it's not empty, all elements in it will be deleted and then
|
|
cleared. All currently pending alerts are returned by being swapped
|
|
into the passed in container. The responsibility of deleting the
|
|
alerts is transferred to the caller. This means you need to call
|
|
delete for each item in the returned dequeue. It's probably a good
|
|
idea to delete the alerts as you handle them, to save one extra pass
|
|
over the dequeue.</p>
|
|
<p>Alternatively, you can pass in the same container the next time you
|
|
call <tt class="docutils literal">pop_alerts</tt>.</p>
|
|
<p><tt class="docutils literal">wait_for_alert</tt> blocks until an <a class="reference external" href="reference-Alerts.html#alert">alert</a> is available, or for no more
|
|
than <tt class="docutils literal">max_wait</tt> time. If <tt class="docutils literal">wait_for_alert</tt> returns because of the
|
|
time-out, and no alerts are available, it returns 0. If at least one
|
|
<a class="reference external" href="reference-Alerts.html#alert">alert</a> was generated, a pointer to that <a class="reference external" href="reference-Alerts.html#alert">alert</a> is returned. The <a class="reference external" href="reference-Alerts.html#alert">alert</a> is
|
|
not popped, any subsequent calls to <tt class="docutils literal">wait_for_alert</tt> will return the
|
|
same pointer until the <a class="reference external" href="reference-Alerts.html#alert">alert</a> is popped by calling <tt class="docutils literal">pop_alert</tt>. This
|
|
is useful for leaving any <a class="reference external" href="reference-Alerts.html#alert">alert</a> dispatching mechanism independent of
|
|
this blocking call, the dispatcher can be called and it can pop the
|
|
<a class="reference external" href="reference-Alerts.html#alert">alert</a> independently.</p>
|
|
<div class="note">
|
|
<p class="first admonition-title">Note</p>
|
|
<p class="last">Although these functions are all thread-safe, popping alerts from
|
|
multiple separate threads may introduce race conditions in that
|
|
the thread issuing an asynchronous operation may not be the one
|
|
receiving the alert with the result.</p>
|
|
</div>
|
|
<p>In the python binding, <tt class="docutils literal">wait_for_alert</tt> takes the number of
|
|
milliseconds to wait as an integer.</p>
|
|
<p>To control the max number of alerts that's queued by the <a class="reference external" href="reference-Session.html#session">session</a>, see
|
|
<tt class="docutils literal"><span class="pre">session_settings::alert_queue_size</span></tt>.</p>
|
|
<p><a class="reference external" href="reference-Alerts.html#save_resume_data_alert">save_resume_data_alert</a> and <a class="reference external" href="reference-Alerts.html#save_resume_data_failed_alert">save_resume_data_failed_alert</a> are always
|
|
posted, regardelss of the <a class="reference external" href="reference-Alerts.html#alert">alert</a> mask.</p>
|
|
<a name="set_alert_dispatch()"></a></div>
|
|
<div class="section" id="set-alert-dispatch">
|
|
<h2>set_alert_dispatch()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>set_alert_dispatch</strong> (boost::function<void(std::auto_ptr<alert>)> const& fun);
|
|
</pre>
|
|
<p>This sets a function to be called (from within libtorrent's netowrk
|
|
thread) every time an <a class="reference external" href="reference-Alerts.html#alert">alert</a> is posted. Since the function (<tt class="docutils literal">fun</tt>) is
|
|
run in libtorrent's internal thread, it may not call any of
|
|
libtorrent's external API functions. Doing so results in a dead lock.</p>
|
|
<p>The main intention with this function is to support integration with
|
|
platform-dependent message queues or signalling systems. For instance,
|
|
on windows, one could post a message to an HNWD or on linux, write to
|
|
a pipe or an eventfd.</p>
|
|
<a name="add_port_mapping()"></a>
|
|
<a name="delete_port_mapping()"></a></div>
|
|
<div class="section" id="add-port-mapping-delete-port-mapping">
|
|
<h2>add_port_mapping() delete_port_mapping()</h2>
|
|
<pre class="literal-block">
|
|
void <strong>delete_port_mapping</strong> (int handle);
|
|
int <strong>add_port_mapping</strong> (protocol_type t, int external_port, int local_port);
|
|
</pre>
|
|
<p>add_port_mapping adds a port forwarding on UPnP and/or NAT-PMP,
|
|
whichever is enabled. The return value is a handle referring to the
|
|
port mapping that was just created. Pass it to <a class="reference external" href="reference-Session.html#delete_port_mapping()">delete_port_mapping()</a>
|
|
to remove it.</p>
|
|
<a name="save_state_flags_t"></a></div>
|
|
<div class="section" id="enum-save-state-flags-t">
|
|
<h2>enum save_state_flags_t</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<table border="1" class="docutils">
|
|
<colgroup>
|
|
<col width="26%" />
|
|
<col width="7%" />
|
|
<col width="67%" />
|
|
</colgroup>
|
|
<thead valign="bottom">
|
|
<tr><th class="head">name</th>
|
|
<th class="head">value</th>
|
|
<th class="head">description</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody valign="top">
|
|
<tr><td>save_settings</td>
|
|
<td>1</td>
|
|
<td>saves settings (i.e. the session_settings)</td>
|
|
</tr>
|
|
<tr><td>save_dht_settings</td>
|
|
<td>2</td>
|
|
<td>saves <a class="reference external" href="reference-Settings.html#dht_settings">dht_settings</a></td>
|
|
</tr>
|
|
<tr><td>save_dht_state</td>
|
|
<td>4</td>
|
|
<td>saves dht state such as nodes and node-id, possibly accelerating
|
|
joining the DHT if provided at next <a class="reference external" href="reference-Session.html#session">session</a> startup.</td>
|
|
</tr>
|
|
<tr><td>save_encryption_settings</td>
|
|
<td>32</td>
|
|
<td>save pe_settings</td>
|
|
</tr>
|
|
<tr><td>save_feeds</td>
|
|
<td>128</td>
|
|
<td>saves RSS feeds</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<a name="options_t"></a></div>
|
|
<div class="section" id="enum-options-t">
|
|
<h2>enum options_t</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<table border="1" class="docutils">
|
|
<colgroup>
|
|
<col width="19%" />
|
|
<col width="9%" />
|
|
<col width="72%" />
|
|
</colgroup>
|
|
<thead valign="bottom">
|
|
<tr><th class="head">name</th>
|
|
<th class="head">value</th>
|
|
<th class="head">description</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody valign="top">
|
|
<tr><td>delete_files</td>
|
|
<td>1</td>
|
|
<td>delete the files belonging to the torrent from disk.</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<a name="session_flags_t"></a></div>
|
|
<div class="section" id="enum-session-flags-t">
|
|
<h2>enum session_flags_t</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<table border="1" class="docutils">
|
|
<colgroup>
|
|
<col width="25%" />
|
|
<col width="7%" />
|
|
<col width="68%" />
|
|
</colgroup>
|
|
<thead valign="bottom">
|
|
<tr><th class="head">name</th>
|
|
<th class="head">value</th>
|
|
<th class="head">description</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody valign="top">
|
|
<tr><td>add_default_plugins</td>
|
|
<td>1</td>
|
|
<td>this will add common extensions like ut_pex, ut_metadata, lt_tex
|
|
smart_ban and possibly others.</td>
|
|
</tr>
|
|
<tr><td>start_default_features</td>
|
|
<td>2</td>
|
|
<td>this will start features like DHT, local service discovery, UPnP
|
|
and NAT-PMP.</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<a name="protocol_type"></a></div>
|
|
<div class="section" id="enum-protocol-type">
|
|
<h2>enum protocol_type</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<table border="1" class="docutils">
|
|
<colgroup>
|
|
<col width="23%" />
|
|
<col width="27%" />
|
|
<col width="50%" />
|
|
</colgroup>
|
|
<thead valign="bottom">
|
|
<tr><th class="head">name</th>
|
|
<th class="head">value</th>
|
|
<th class="head">description</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody valign="top">
|
|
<tr><td>udp</td>
|
|
<td>1</td>
|
|
<td> </td>
|
|
</tr>
|
|
<tr><td>tcp</td>
|
|
<td>2</td>
|
|
<td> </td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
<a name="find_metric_idx()"></a></div>
|
|
<div class="section" id="find-metric-idx">
|
|
<h2>find_metric_idx()</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<pre class="literal-block">
|
|
int <strong>find_metric_idx</strong> (char const* name);
|
|
</pre>
|
|
<p>given a name of a metric, this function returns the counter index of it,
|
|
or -1 if it could not be found. The counter index is the index into the
|
|
values array returned by <a class="reference external" href="reference-Alerts.html#session_stats_alert">session_stats_alert</a>.</p>
|
|
<a name="session_stats_metrics()"></a></div>
|
|
<div class="section" id="session-stats-metrics">
|
|
<h2>session_stats_metrics()</h2>
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
<pre class="literal-block">
|
|
std::vector<stats_metric> <strong>session_stats_metrics</strong> ();
|
|
</pre>
|
|
<p>This free function returns the list of available metrics exposed by
|
|
libtorrent's statistics API. Each metric has a name and a <em>value index</em>.
|
|
The value index is the index into the array in <a class="reference external" href="reference-Alerts.html#session_stats_alert">session_stats_alert</a> where
|
|
this metric's value can be found when the <a class="reference external" href="reference-Session.html#session">session</a> stats is sampled (by
|
|
calling <a class="reference external" href="reference-Session.html#post_session_stats()">post_session_stats()</a>).</p>
|
|
</div>
|
|
</div>
|
|
|
|
</div>
|
|
</div>
|
|
<div id="gradient"></div>
|
|
<div id="footer">
|
|
<table>
|
|
<tr>
|
|
<td><a href="index.html">home</a></td>
|
|
<td><a href="http://blog.libtorrent.org">blog</a></td>
|
|
<td><a href="utp.html">uTP</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="https://sourceforge.net/projects/libtorrent/files/libtorrent/">download</a></td>
|
|
<td><a href="reference.html">documentation</a></td>
|
|
<td><a href="dht_store.html">DHT put extension</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="https://sourceforge.net/projects/libtorrent/files/py-libtorrent/">python bindings</a></td>
|
|
<td><a href="features.html">features</a></td>
|
|
<td><a href="dht_sec.html">DHT security extension</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="http://dir.gmane.org/gmane.network.bit-torrent.libtorrent">mailing list archive</a></td>
|
|
<td><a href="contributing.html">contributing</a></td>
|
|
<td><a href="streaming.html">streaming</a></td>
|
|
</tr>
|
|
<tr>
|
|
<td><a href="http://code.google.com/p/libtorrent/issues/entry">report a bug</a></td>
|
|
<td><a href="building.html">building</a></td>
|
|
<td><a href="bittorrent.pdf">bittorrent slides</a></td>
|
|
</tr>
|
|
</table>
|
|
</div>
|
|
<div id="filler"></div></div>
|
|
|
|
</div>
|
|
</body>
|
|
</html>
|