2013-12-21 10:54:17 +01:00
|
|
|
<?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" />
|
2014-04-06 21:11:24 +02:00
|
|
|
<meta name="generator" content="Docutils 0.11: http://docutils.sourceforge.net/" />
|
2013-12-21 10:54:17 +01:00
|
|
|
<title>Settings</title>
|
|
|
|
|
<meta name="author" content="Arvid Norberg, arvid@rasterbar.com" />
|
|
|
|
|
<link rel="stylesheet" type="text/css" href="../../css/base.css" />
|
|
|
|
|
<link rel="stylesheet" type="text/css" href="../../css/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="settings">
|
|
|
|
|
<div id="container">
|
|
|
|
|
<div id="headerNav">
|
|
|
|
|
<ul>
|
|
|
|
|
<li class="first"><a href="/">Home</a></li>
|
|
|
|
|
<li><a href="../../products.html">Products</a></li>
|
|
|
|
|
<li><a href="../../contact.html">Contact</a></li>
|
|
|
|
|
</ul>
|
|
|
|
|
</div>
|
|
|
|
|
<div id="header">
|
|
|
|
|
<div id="orange"></div>
|
|
|
|
|
<div id="logo"></div>
|
|
|
|
|
</div>
|
|
|
|
|
<div id="main">
|
|
|
|
|
<h1 class="title">Settings</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@rasterbar.com">arvid@rasterbar.com</a></td></tr>
|
|
|
|
|
<tr><th class="docinfo-name">Version:</th>
|
|
|
|
|
<td>1.0.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">
|
2014-02-03 03:41:24 +01:00
|
|
|
<li><a class="reference internal" href="#proxy-settings" id="id37">proxy_settings</a></li>
|
|
|
|
|
<li><a class="reference internal" href="#session-settings" id="id38">session_settings</a></li>
|
|
|
|
|
<li><a class="reference internal" href="#dht-settings" id="id39">dht_settings</a></li>
|
|
|
|
|
<li><a class="reference internal" href="#pe-settings" id="id40">pe_settings</a></li>
|
2013-12-21 10:54:17 +01:00
|
|
|
</ul>
|
|
|
|
|
</div>
|
|
|
|
|
<a name="proxy_settings"></a><div class="section" id="proxy-settings">
|
|
|
|
|
<h1>proxy_settings</h1>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<p>The <tt class="docutils literal">proxy_settings</tt> structs contains the information needed to
|
|
|
|
|
direct certain traffic to a proxy.</p>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
struct proxy_settings
|
|
|
|
|
{
|
|
|
|
|
<strong>proxy_settings</strong> ();
|
|
|
|
|
|
|
|
|
|
std::string hostname;
|
|
|
|
|
std::string username;
|
|
|
|
|
std::string password;
|
|
|
|
|
boost::uint8_t type;
|
|
|
|
|
boost::uint16_t port;
|
|
|
|
|
bool proxy_hostnames;
|
|
|
|
|
bool proxy_peer_connections;
|
|
|
|
|
};
|
|
|
|
|
</pre>
|
2014-02-02 10:33:19 +01:00
|
|
|
<a name="proxy_settings()"></a><div class="section" id="id2">
|
|
|
|
|
<h2>proxy_settings()</h2>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
<strong>proxy_settings</strong> ();
|
|
|
|
|
</pre>
|
|
|
|
|
<p>defaults constructs proxy settings, initializing it to the default
|
|
|
|
|
settings.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<a name="hostname"></a><dl class="docutils">
|
|
|
|
|
<dt>hostname</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the name or IP of the proxy server. <tt class="docutils literal">port</tt> is the port number the
|
|
|
|
|
proxy listens to. If required, <tt class="docutils literal">username</tt> and <tt class="docutils literal">password</tt> can be
|
|
|
|
|
set to authenticate with the proxy.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
2014-02-02 10:33:19 +01:00
|
|
|
<a name="username"></a>
|
|
|
|
|
<a name="password"></a><dl class="docutils">
|
|
|
|
|
<dt>username password</dt>
|
|
|
|
|
<dd>when using a proy type that requires authentication, the username
|
|
|
|
|
and password fields must be set to the credentials for the proxy.</dd>
|
|
|
|
|
</dl>
|
2013-12-21 10:54:17 +01:00
|
|
|
<a name="type"></a><dl class="docutils">
|
|
|
|
|
<dt>type</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>tells libtorrent what kind of proxy server it is. See proxy_type
|
2013-12-21 10:54:17 +01:00
|
|
|
enum for options</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="port"></a><dl class="docutils">
|
|
|
|
|
<dt>port</dt>
|
|
|
|
|
<dd>the port the proxy server is running on</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="proxy_hostnames"></a><dl class="docutils">
|
|
|
|
|
<dt>proxy_hostnames</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to true. It means that hostnames should be attempted to be
|
|
|
|
|
resolved through the proxy instead of using the local DNS service.
|
|
|
|
|
This is only supported by SOCKS5 and HTTP.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="proxy_peer_connections"></a><dl class="docutils">
|
|
|
|
|
<dt>proxy_peer_connections</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines whether or not to excempt peer and web seed connections
|
|
|
|
|
from using the proxy. This defaults to true, i.e. peer connections are
|
|
|
|
|
proxied by default.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="session_settings"></a></div>
|
|
|
|
|
</div>
|
|
|
|
|
<div class="section" id="session-settings">
|
|
|
|
|
<h1>session_settings</h1>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<p>This holds most of the session-wide settings in libtorrent. Pass this
|
|
|
|
|
to <a class="reference external" href="reference-Session.html#set_settings()">session::set_settings()</a> to change the settings, initialize it from
|
|
|
|
|
session::get_settings() to get the current settings.</p>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
struct session_settings
|
|
|
|
|
{
|
|
|
|
|
<strong>session_settings</strong> (std::string const& user_agent = "libtorrent/"
|
|
|
|
|
LIBTORRENT_VERSION);
|
|
|
|
|
<strong>~session_settings</strong> ();
|
|
|
|
|
|
|
|
|
|
enum io_buffer_mode_t
|
|
|
|
|
{
|
|
|
|
|
enable_os_cache,
|
|
|
|
|
disable_os_cache_for_aligned_files,
|
|
|
|
|
disable_os_cache,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum disk_cache_algo_t
|
|
|
|
|
{
|
|
|
|
|
lru,
|
|
|
|
|
largest_contiguous,
|
|
|
|
|
avoid_readback,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum bandwidth_mixed_algo_t
|
|
|
|
|
{
|
|
|
|
|
prefer_tcp,
|
|
|
|
|
peer_proportional,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int version;
|
|
|
|
|
std::string user_agent;
|
|
|
|
|
int tracker_completion_timeout;
|
|
|
|
|
int tracker_receive_timeout;
|
|
|
|
|
int stop_tracker_timeout;
|
|
|
|
|
int tracker_maximum_response_length;
|
|
|
|
|
int piece_timeout;
|
|
|
|
|
int request_timeout;
|
|
|
|
|
int request_queue_time;
|
|
|
|
|
int max_allowed_in_request_queue;
|
|
|
|
|
int max_out_request_queue;
|
|
|
|
|
int whole_pieces_threshold;
|
|
|
|
|
int peer_timeout;
|
|
|
|
|
int urlseed_timeout;
|
|
|
|
|
int urlseed_pipeline_size;
|
|
|
|
|
int urlseed_wait_retry;
|
|
|
|
|
int file_pool_size;
|
|
|
|
|
bool allow_multiple_connections_per_ip;
|
|
|
|
|
int max_failcount;
|
|
|
|
|
int min_reconnect_time;
|
|
|
|
|
int peer_connect_timeout;
|
|
|
|
|
bool ignore_limits_on_local_network;
|
|
|
|
|
int connection_speed;
|
|
|
|
|
bool send_redundant_have;
|
|
|
|
|
bool lazy_bitfields;
|
|
|
|
|
int inactivity_timeout;
|
|
|
|
|
int unchoke_interval;
|
|
|
|
|
int optimistic_unchoke_interval;
|
|
|
|
|
std::string announce_ip;
|
|
|
|
|
int num_want;
|
|
|
|
|
int initial_picker_threshold;
|
|
|
|
|
int allowed_fast_set_size;
|
2014-02-03 03:41:24 +01:00
|
|
|
suggest_read_cache = 1 };
|
2013-12-21 10:54:17 +01:00
|
|
|
int suggest_mode;
|
|
|
|
|
int max_queued_disk_bytes;
|
|
|
|
|
int max_queued_disk_bytes_low_watermark;
|
|
|
|
|
int handshake_timeout;
|
|
|
|
|
bool use_dht_as_fallback;
|
|
|
|
|
bool free_torrent_hashes;
|
|
|
|
|
bool upnp_ignore_nonrouters;
|
|
|
|
|
int send_buffer_low_watermark;
|
|
|
|
|
int send_buffer_watermark;
|
|
|
|
|
int send_buffer_watermark_factor;
|
2014-02-03 03:41:24 +01:00
|
|
|
bittyrant_choker };
|
2013-12-21 10:54:17 +01:00
|
|
|
int choking_algorithm;
|
2014-02-03 03:41:24 +01:00
|
|
|
anti_leech };
|
2013-12-21 10:54:17 +01:00
|
|
|
int seed_choking_algorithm;
|
|
|
|
|
bool use_parole_mode;
|
|
|
|
|
int cache_size;
|
|
|
|
|
int cache_buffer_chunk_size;
|
|
|
|
|
int cache_expiry;
|
|
|
|
|
bool use_read_cache;
|
|
|
|
|
bool explicit_read_cache;
|
|
|
|
|
int explicit_cache_interval;
|
|
|
|
|
int disk_io_write_mode;
|
|
|
|
|
int disk_io_read_mode;
|
|
|
|
|
bool coalesce_reads;
|
|
|
|
|
bool coalesce_writes;
|
|
|
|
|
std::pair<int, int> outgoing_ports;
|
|
|
|
|
char peer_tos;
|
|
|
|
|
int active_downloads;
|
|
|
|
|
int active_seeds;
|
|
|
|
|
int active_dht_limit;
|
|
|
|
|
int active_tracker_limit;
|
|
|
|
|
int active_lsd_limit;
|
|
|
|
|
int active_limit;
|
|
|
|
|
bool auto_manage_prefer_seeds;
|
|
|
|
|
bool dont_count_slow_torrents;
|
|
|
|
|
int auto_manage_interval;
|
|
|
|
|
float share_ratio_limit;
|
|
|
|
|
float seed_time_ratio_limit;
|
|
|
|
|
int seed_time_limit;
|
|
|
|
|
int peer_turnover_interval;
|
|
|
|
|
float peer_turnover;
|
|
|
|
|
float peer_turnover_cutoff;
|
|
|
|
|
bool close_redundant_connections;
|
|
|
|
|
int auto_scrape_interval;
|
|
|
|
|
int auto_scrape_min_interval;
|
|
|
|
|
int max_peerlist_size;
|
|
|
|
|
int max_paused_peerlist_size;
|
|
|
|
|
int min_announce_interval;
|
|
|
|
|
bool prioritize_partial_pieces;
|
|
|
|
|
int auto_manage_startup;
|
|
|
|
|
bool rate_limit_ip_overhead;
|
|
|
|
|
bool announce_to_all_trackers;
|
|
|
|
|
bool announce_to_all_tiers;
|
|
|
|
|
bool prefer_udp_trackers;
|
|
|
|
|
bool strict_super_seeding;
|
|
|
|
|
int seeding_piece_quota;
|
|
|
|
|
int max_sparse_regions;
|
|
|
|
|
bool lock_disk_cache;
|
|
|
|
|
int max_rejects;
|
|
|
|
|
int recv_socket_buffer_size;
|
|
|
|
|
int send_socket_buffer_size;
|
|
|
|
|
bool optimize_hashing_for_speed;
|
|
|
|
|
int file_checks_delay_per_block;
|
|
|
|
|
disk_cache_algo_t disk_cache_algorithm;
|
|
|
|
|
int read_cache_line_size;
|
|
|
|
|
int write_cache_line_size;
|
|
|
|
|
int optimistic_disk_retry;
|
|
|
|
|
bool disable_hash_checks;
|
|
|
|
|
bool allow_reordered_disk_operations;
|
|
|
|
|
bool allow_i2p_mixed;
|
|
|
|
|
int max_suggest_pieces;
|
|
|
|
|
bool drop_skipped_requests;
|
|
|
|
|
bool low_prio_disk;
|
|
|
|
|
int local_service_announce_interval;
|
|
|
|
|
int dht_announce_interval;
|
|
|
|
|
int udp_tracker_token_expiry;
|
|
|
|
|
bool volatile_read_cache;
|
|
|
|
|
bool guided_read_cache;
|
|
|
|
|
int default_cache_min_age;
|
|
|
|
|
int num_optimistic_unchoke_slots;
|
|
|
|
|
bool no_atime_storage;
|
|
|
|
|
int default_est_reciprocation_rate;
|
|
|
|
|
int increase_est_reciprocation_rate;
|
|
|
|
|
int decrease_est_reciprocation_rate;
|
|
|
|
|
bool incoming_starts_queued_torrents;
|
|
|
|
|
bool report_true_downloaded;
|
|
|
|
|
bool strict_end_game_mode;
|
|
|
|
|
bool broadcast_lsd;
|
|
|
|
|
bool enable_outgoing_utp;
|
|
|
|
|
bool enable_incoming_utp;
|
|
|
|
|
bool enable_outgoing_tcp;
|
|
|
|
|
bool enable_incoming_tcp;
|
|
|
|
|
int max_pex_peers;
|
|
|
|
|
bool ignore_resume_timestamps;
|
|
|
|
|
bool no_recheck_incomplete_resume;
|
|
|
|
|
bool anonymous_mode;
|
|
|
|
|
bool force_proxy;
|
|
|
|
|
int tick_interval;
|
|
|
|
|
bool report_web_seed_downloads;
|
|
|
|
|
int share_mode_target;
|
|
|
|
|
int upload_rate_limit;
|
|
|
|
|
int download_rate_limit;
|
|
|
|
|
int local_upload_rate_limit;
|
|
|
|
|
int local_download_rate_limit;
|
|
|
|
|
int dht_upload_rate_limit;
|
|
|
|
|
int unchoke_slots_limit;
|
|
|
|
|
int half_open_limit;
|
|
|
|
|
int connections_limit;
|
|
|
|
|
int connections_slack;
|
|
|
|
|
int utp_target_delay;
|
|
|
|
|
int utp_gain_factor;
|
|
|
|
|
int utp_min_timeout;
|
|
|
|
|
int utp_syn_resends;
|
|
|
|
|
int utp_fin_resends;
|
|
|
|
|
int utp_num_resends;
|
|
|
|
|
int utp_connect_timeout;
|
|
|
|
|
bool utp_dynamic_sock_buf;
|
|
|
|
|
int utp_loss_multiplier;
|
|
|
|
|
int mixed_mode_algorithm;
|
|
|
|
|
bool rate_limit_utp;
|
|
|
|
|
int listen_queue_size;
|
|
|
|
|
bool announce_double_nat;
|
|
|
|
|
int torrent_connect_boost;
|
|
|
|
|
bool seeding_outgoing_connections;
|
|
|
|
|
bool no_connect_privileged_ports;
|
|
|
|
|
int alert_queue_size;
|
|
|
|
|
int max_metadata_size;
|
|
|
|
|
bool smooth_connects;
|
|
|
|
|
bool always_send_user_agent;
|
|
|
|
|
bool apply_ip_filter_to_trackers;
|
|
|
|
|
int read_job_every;
|
|
|
|
|
bool use_disk_read_ahead;
|
|
|
|
|
bool lock_files;
|
|
|
|
|
int ssl_listen;
|
|
|
|
|
int tracker_backoff;
|
|
|
|
|
bool ban_web_seeds;
|
|
|
|
|
int max_http_recv_buffer_size;
|
|
|
|
|
bool support_share_mode;
|
|
|
|
|
bool support_merkle_torrents;
|
|
|
|
|
bool report_redundant_bytes;
|
|
|
|
|
std::string handshake_client_version;
|
|
|
|
|
bool use_disk_cache_pool;
|
|
|
|
|
};
|
|
|
|
|
</pre>
|
2014-02-02 10:33:19 +01:00
|
|
|
<a name="~session_settings()"></a>
|
|
|
|
|
<a name="session_settings()"></a><div class="section" id="session-settings-session-settings">
|
|
|
|
|
<h2>~session_settings() session_settings()</h2>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
<strong>session_settings</strong> (std::string const& user_agent = "libtorrent/"
|
|
|
|
|
LIBTORRENT_VERSION);
|
|
|
|
|
<strong>~session_settings</strong> ();
|
|
|
|
|
</pre>
|
|
|
|
|
<p>initializes the <a class="reference external" href="reference-Settings.html#session_settings">session_settings</a> to the default settings.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<a name="io_buffer_mode_t"></a></div>
|
|
|
|
|
<div class="section" id="enum-io-buffer-mode-t">
|
|
|
|
|
<h2>enum io_buffer_mode_t</h2>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<table border="1" class="docutils">
|
|
|
|
|
<colgroup>
|
2014-02-03 03:41:24 +01:00
|
|
|
<col width="32%" />
|
|
|
|
|
<col width="6%" />
|
|
|
|
|
<col width="61%" />
|
2013-12-21 10:54:17 +01:00
|
|
|
</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>enable_os_cache</td>
|
|
|
|
|
<td>0</td>
|
2014-02-03 03:41:24 +01:00
|
|
|
<td>This is the default and files are opened normally, with the OS
|
|
|
|
|
caching reads and writes.</td>
|
2013-12-21 10:54:17 +01:00
|
|
|
</tr>
|
|
|
|
|
<tr><td>disable_os_cache_for_aligned_files</td>
|
|
|
|
|
<td>1</td>
|
2014-02-03 03:41:24 +01:00
|
|
|
<td>This will open files in unbuffered mode for files where every read
|
|
|
|
|
and write would be sector aligned. Using aligned disk offsets is a
|
|
|
|
|
requirement on some operating systems.</td>
|
2013-12-21 10:54:17 +01:00
|
|
|
</tr>
|
|
|
|
|
<tr><td>disable_os_cache</td>
|
|
|
|
|
<td>2</td>
|
2014-02-03 03:41:24 +01:00
|
|
|
<td>This opens all files in unbuffered mode (if allowed by the
|
|
|
|
|
operating system). Linux and Windows, for instance, require disk
|
|
|
|
|
offsets to be sector aligned, and in those cases, this option is
|
|
|
|
|
the same as <tt class="docutils literal">disable_os_caches_for_aligned_files</tt>.</td>
|
2013-12-21 10:54:17 +01:00
|
|
|
</tr>
|
|
|
|
|
</tbody>
|
|
|
|
|
</table>
|
|
|
|
|
<a name="disk_cache_algo_t"></a></div>
|
|
|
|
|
<div class="section" id="enum-disk-cache-algo-t">
|
|
|
|
|
<h2>enum disk_cache_algo_t</h2>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<table border="1" class="docutils">
|
|
|
|
|
<colgroup>
|
2014-02-03 03:41:24 +01:00
|
|
|
<col width="21%" />
|
2013-12-21 10:54:17 +01:00
|
|
|
<col width="7%" />
|
2014-02-03 03:41:24 +01:00
|
|
|
<col width="72%" />
|
2013-12-21 10:54:17 +01:00
|
|
|
</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>lru</td>
|
|
|
|
|
<td>0</td>
|
2014-02-03 03:41:24 +01:00
|
|
|
<td>This flushes the entire piece, in the write cache, that was least
|
|
|
|
|
recently written to.</td>
|
2013-12-21 10:54:17 +01:00
|
|
|
</tr>
|
|
|
|
|
<tr><td>largest_contiguous</td>
|
|
|
|
|
<td>1</td>
|
2014-02-03 03:41:24 +01:00
|
|
|
<td>will flush the largest sequences of contiguous blocks from the
|
|
|
|
|
write cache, regarless of the piece's last use time.</td>
|
2013-12-21 10:54:17 +01:00
|
|
|
</tr>
|
|
|
|
|
<tr><td>avoid_readback</td>
|
|
|
|
|
<td>2</td>
|
2014-02-03 03:41:24 +01:00
|
|
|
<td>will prioritize flushing blocks that will avoid having to read them
|
|
|
|
|
back in to verify the hash of the piece once it's done. This is
|
|
|
|
|
especially useful for high throughput setups, where reading from
|
|
|
|
|
the disk is especially expensive.</td>
|
2013-12-21 10:54:17 +01:00
|
|
|
</tr>
|
|
|
|
|
</tbody>
|
|
|
|
|
</table>
|
|
|
|
|
<a name="bandwidth_mixed_algo_t"></a></div>
|
|
|
|
|
<div class="section" id="enum-bandwidth-mixed-algo-t">
|
|
|
|
|
<h2>enum bandwidth_mixed_algo_t</h2>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<table border="1" class="docutils">
|
|
|
|
|
<colgroup>
|
|
|
|
|
<col width="22%" />
|
|
|
|
|
<col width="8%" />
|
|
|
|
|
<col width="70%" />
|
|
|
|
|
</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>prefer_tcp</td>
|
|
|
|
|
<td>0</td>
|
|
|
|
|
<td>disables the mixed mode bandwidth balancing</td>
|
|
|
|
|
</tr>
|
|
|
|
|
<tr><td>peer_proportional</td>
|
|
|
|
|
<td>1</td>
|
|
|
|
|
<td>does not throttle uTP, throttles TCP to the same proportion
|
|
|
|
|
of throughput as there are TCP connections</td>
|
|
|
|
|
</tr>
|
|
|
|
|
</tbody>
|
|
|
|
|
</table>
|
|
|
|
|
<a name="version"></a><dl class="docutils">
|
|
|
|
|
<dt>version</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>automatically set to the libtorrent version you're using in order to
|
|
|
|
|
be forward binary compatible. This field should not be changed.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="user_agent"></a><dl class="docutils">
|
|
|
|
|
<dt>user_agent</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the client identification to the tracker. The recommended format of
|
|
|
|
|
this string is: "ClientName/ClientVersion
|
|
|
|
|
libtorrent/libtorrentVersion". This name will not only be used when
|
|
|
|
|
making HTTP requests, but also when sending extended headers to peers
|
|
|
|
|
that support that extension.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="tracker_completion_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>tracker_completion_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds the tracker connection will wait from when it
|
|
|
|
|
sent the request until it considers the tracker to have timed-out.
|
|
|
|
|
Default value is 60 seconds.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="tracker_receive_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>tracker_receive_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds to wait to receive any data from the tracker. If
|
|
|
|
|
no data is received for this number of seconds, the tracker will be
|
|
|
|
|
considered as having timed out. If a tracker is down, this is the kind
|
|
|
|
|
of timeout that will occur. The default value is 20 seconds.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="stop_tracker_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>stop_tracker_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">the time to wait when sending a stopped message before considering a
|
|
|
|
|
tracker to have timed out. this is usually shorter, to make the client
|
|
|
|
|
quit faster</p>
|
|
|
|
|
<p class="last">This is given in seconds. Default is 10 seconds.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="tracker_maximum_response_length"></a><dl class="docutils">
|
|
|
|
|
<dt>tracker_maximum_response_length</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the maximum number of bytes in a tracker response. If a response size
|
|
|
|
|
passes this number it will be rejected and the connection will be
|
|
|
|
|
closed. On gzipped responses this size is measured on the uncompressed
|
|
|
|
|
data. So, if you get 20 bytes of gzip response that'll expand to 2
|
|
|
|
|
megs, it will be interrupted before the entire response has been
|
2013-12-21 10:54:17 +01:00
|
|
|
uncompressed (given your limit is lower than 2 megs). Default limit is
|
|
|
|
|
1 megabyte.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="piece_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>piece_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls the number of seconds from a request is sent until it times
|
|
|
|
|
out if no piece response is returned.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="request_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>request_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds one block (16kB) is expected to be received
|
|
|
|
|
within. If it's not, the block is requested from a different peer</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="request_queue_time"></a><dl class="docutils">
|
|
|
|
|
<dt>request_queue_time</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the length of the request queue given in the number of seconds it
|
|
|
|
|
should take for the other end to send all the pieces. i.e. the actual
|
|
|
|
|
number of requests depends on the download rate and this number.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_allowed_in_request_queue"></a><dl class="docutils">
|
|
|
|
|
<dt>max_allowed_in_request_queue</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of outstanding block requests a peer is allowed to queue up
|
|
|
|
|
in the client. If a peer sends more requests than this (before the
|
|
|
|
|
first one has been sent) the last request will be dropped. the higher
|
|
|
|
|
this is, the faster upload speeds the client can get to a single peer.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_out_request_queue"></a><dl class="docutils">
|
|
|
|
|
<dt>max_out_request_queue</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the maximum number of outstanding requests to send to a peer. This
|
|
|
|
|
limit takes precedence over request_queue_time. i.e. no matter the
|
|
|
|
|
download speed, the number of outstanding requests will never exceed
|
|
|
|
|
this limit.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="whole_pieces_threshold"></a><dl class="docutils">
|
|
|
|
|
<dt>whole_pieces_threshold</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if a whole piece can be downloaded in this number of seconds, or less,
|
|
|
|
|
the peer_connection will prefer to request whole pieces at a time from
|
|
|
|
|
this peer. The benefit of this is to better utilize disk caches by
|
|
|
|
|
doing localized accesses and also to make it easier to identify bad
|
|
|
|
|
peers if a piece fails the hash check.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="peer_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>peer_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds to wait for any activity on the peer wire before
|
|
|
|
|
closing the connectiong due to time out. This defaults to 120 seconds,
|
|
|
|
|
since that's what's specified in the protocol specification. After
|
|
|
|
|
half the time out, a keep alive message is sent.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="urlseed_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>urlseed_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>same as peer_timeout, but only applies to url-seeds. this is usually
|
|
|
|
|
set lower, because web servers are expected to be more reliable. This
|
|
|
|
|
value defaults to 20 seconds.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="urlseed_pipeline_size"></a><dl class="docutils">
|
|
|
|
|
<dt>urlseed_pipeline_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls the pipelining with the web server. When using persistent
|
|
|
|
|
connections to HTTP 1.1 servers, the client is allowed to send more
|
|
|
|
|
requests before the first response is received. This number controls
|
|
|
|
|
the number of outstanding requests to use with url-seeds. Default is
|
|
|
|
|
5.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="urlseed_wait_retry"></a><dl class="docutils">
|
|
|
|
|
<dt>urlseed_wait_retry</dt>
|
|
|
|
|
<dd>time to wait until a new retry takes place</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="file_pool_size"></a><dl class="docutils">
|
|
|
|
|
<dt>file_pool_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>sets the upper limit on the total number of files this <a class="reference external" href="reference-Session.html#session">session</a> will
|
|
|
|
|
keep open. The reason why files are left open at all is that some anti
|
|
|
|
|
virus software hooks on every file close, and scans the file for
|
|
|
|
|
viruses. deferring the closing of the files will be the difference
|
|
|
|
|
between a usable system and a completely hogged down system. Most
|
|
|
|
|
operating systems also has a limit on the total number of file
|
|
|
|
|
descriptors a process may have open. It is usually a good idea to find
|
|
|
|
|
this limit and set the number of connections and the number of files
|
2013-12-21 10:54:17 +01:00
|
|
|
limits so their sum is slightly below it.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="allow_multiple_connections_per_ip"></a><dl class="docutils">
|
|
|
|
|
<dt>allow_multiple_connections_per_ip</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines if connections from the same IP address as existing
|
|
|
|
|
connections should be rejected or not. Multiple connections from the
|
|
|
|
|
same IP address is not allowed by default, to prevent abusive behavior
|
|
|
|
|
by peers. It may be useful to allow such connections in cases where
|
|
|
|
|
simulations are run on the same machie, and all peers in a swarm has
|
|
|
|
|
the same IP address.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_failcount"></a><dl class="docutils">
|
|
|
|
|
<dt>max_failcount</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the maximum times we try to connect to a peer before stop connecting
|
|
|
|
|
again. If a peer succeeds, its failcounter is reset. If a peer is
|
|
|
|
|
retrieved from a peer source (other than DHT) the failcount is
|
2013-12-21 10:54:17 +01:00
|
|
|
decremented by one, allowing another try.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="min_reconnect_time"></a><dl class="docutils">
|
|
|
|
|
<dt>min_reconnect_time</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds to wait to reconnect to a peer. this time is
|
|
|
|
|
multiplied with the failcount.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="peer_connect_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>peer_connect_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds to wait after a connection attempt is initiated
|
|
|
|
|
to a peer until it is considered as having timed out. The default is
|
|
|
|
|
10 seconds. This setting is especially important in case the number of
|
|
|
|
|
half-open connections are limited, since stale half-open connection
|
|
|
|
|
may delay the connection of other peers considerably.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="ignore_limits_on_local_network"></a><dl class="docutils">
|
|
|
|
|
<dt>ignore_limits_on_local_network</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if set to true, upload, download and unchoke limits are ignored for
|
|
|
|
|
peers on the local network.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="connection_speed"></a><dl class="docutils">
|
|
|
|
|
<dt>connection_speed</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of connection attempts that are made per second. If a
|
|
|
|
|
number < 0 is specified, it will default to 200 connections per
|
|
|
|
|
second. If 0 is specified, it means don't make outgoing connections at
|
|
|
|
|
all.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="send_redundant_have"></a><dl class="docutils">
|
|
|
|
|
<dt>send_redundant_have</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if this is set to true, have messages will be sent to peers that
|
|
|
|
|
already have the piece. This is typically not necessary, but it might
|
|
|
|
|
be necessary for collecting statistics in some cases. Default is
|
|
|
|
|
false.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="lazy_bitfields"></a><dl class="docutils">
|
|
|
|
|
<dt>lazy_bitfields</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>prevents outgoing bitfields from being full. If the client is seed, a
|
|
|
|
|
few bits will be set to 0, and later filled in with have-messages.
|
|
|
|
|
This is an old attempt to prevent certain ISPs from stopping people
|
|
|
|
|
from seeding.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="inactivity_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>inactivity_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if a peer is uninteresting and uninterested for longer than this
|
|
|
|
|
number of seconds, it will be disconnected. default is 10 minutes</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="unchoke_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>unchoke_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds between chokes/unchokes. On this interval, peers
|
|
|
|
|
are re-evaluated for being choked/unchoked. This is defined as 30
|
|
|
|
|
seconds in the protocol, and it should be significantly longer than
|
|
|
|
|
what it takes for TCP to ramp up to it's max rate.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="optimistic_unchoke_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>optimistic_unchoke_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds between each <em>optimistic</em> unchoke. On this
|
|
|
|
|
timer, the currently optimistically unchoked peer will change.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="announce_ip"></a><dl class="docutils">
|
|
|
|
|
<dt>announce_ip</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the ip address passed along to trackers as the <tt class="docutils literal">&ip=</tt> parameter. If
|
|
|
|
|
left as the default (an empty string), that parameter is omitted. Most
|
|
|
|
|
trackers ignore this argument. This is here for completeness for
|
|
|
|
|
edge-cases where it may be useful.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="num_want"></a><dl class="docutils">
|
|
|
|
|
<dt>num_want</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of peers we want from each tracker request. It defines what
|
|
|
|
|
is sent as the <tt class="docutils literal">&num_want=</tt> parameter to the tracker. Stopped
|
|
|
|
|
messages always send num_want=0. This setting control what to say in
|
|
|
|
|
the case where we actually want peers.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="initial_picker_threshold"></a><dl class="docutils">
|
|
|
|
|
<dt>initial_picker_threshold</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies the number of pieces we need before we switch to rarest
|
|
|
|
|
first picking. This defaults to 4, which means the 4 first pieces in
|
|
|
|
|
any torrent are picked at random, the following pieces are picked in
|
|
|
|
|
rarest first order.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="allowed_fast_set_size"></a><dl class="docutils">
|
|
|
|
|
<dt>allowed_fast_set_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of allowed pieces to send to choked peers that supports the
|
|
|
|
|
fast extensions</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="}"></a><dl class="docutils">
|
|
|
|
|
<dt>}</dt>
|
|
|
|
|
<dd>send out suggest messages for the most recent pieces that are in
|
|
|
|
|
the read cache.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="suggest_mode"></a><dl class="docutils">
|
|
|
|
|
<dt>suggest_mode</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">this determines which pieces will be suggested to peers suggest read
|
|
|
|
|
cache will make libtorrent suggest pieces that are fresh in the disk
|
|
|
|
|
read cache, to potentially lower disk access and increase the cache
|
|
|
|
|
hit ratio</p>
|
|
|
|
|
<p class="last">for options, see suggest_mode_t.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_queued_disk_bytes"></a><dl class="docutils">
|
|
|
|
|
<dt>max_queued_disk_bytes</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">the maximum number of bytes a connection may have pending in the disk
|
|
|
|
|
write queue before its download rate is being throttled. This prevents
|
|
|
|
|
fast downloads to slow medias to allocate more memory indefinitely.
|
|
|
|
|
This should be set to at least 16 kB to not completely disrupt normal
|
|
|
|
|
downloads. If it's set to 0, you will be starving the disk thread and
|
|
|
|
|
nothing will be written to disk. this is a per <a class="reference external" href="reference-Session.html#session">session</a> setting.</p>
|
|
|
|
|
<p class="last">When this limit is reached, the peer connections will stop reading
|
|
|
|
|
data from their sockets, until the disk thread catches up. Setting
|
|
|
|
|
this too low will severly limit your download rate.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_queued_disk_bytes_low_watermark"></a><dl class="docutils">
|
|
|
|
|
<dt>max_queued_disk_bytes_low_watermark</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>this is the low watermark for the disk buffer queue. whenever the
|
|
|
|
|
number of queued bytes exceed the max_queued_disk_bytes, libtorrent
|
|
|
|
|
will wait for it to drop below this value before issuing more reads
|
|
|
|
|
from the sockets. If set to 0, the low watermark will be half of the
|
|
|
|
|
max queued disk bytes</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="handshake_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>handshake_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds to wait for a handshake response from a peer. If
|
|
|
|
|
no response is received within this time, the peer is disconnected.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="use_dht_as_fallback"></a><dl class="docutils">
|
|
|
|
|
<dt>use_dht_as_fallback</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines how the DHT is used. If this is true, the DHT will only be
|
|
|
|
|
used for torrents where all trackers in its tracker list has failed.
|
|
|
|
|
Either by an explicit error message or a time out. This is false by
|
|
|
|
|
default, which means the DHT is used by default regardless of if the
|
|
|
|
|
trackers fail or not.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="free_torrent_hashes"></a><dl class="docutils">
|
|
|
|
|
<dt>free_torrent_hashes</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines whether or not the torrent's piece hashes are kept in
|
|
|
|
|
memory after the torrent becomes a seed or not. If it is set to
|
2013-12-21 10:54:17 +01:00
|
|
|
<tt class="docutils literal">true</tt> the hashes are freed once the torrent is a seed (they're not
|
2014-02-03 03:41:24 +01:00
|
|
|
needed anymore since the torrent won't download anything more). If
|
|
|
|
|
it's set to false they are not freed. If they are freed, the
|
|
|
|
|
<a class="reference external" href="reference-Core.html#torrent_info">torrent_info</a> returned by get_torrent_info() will return an object that
|
|
|
|
|
may be incomplete, that cannot be passed back to <a class="reference external" href="reference-Session.html#async_add_torrent()">async_add_torrent()</a>
|
|
|
|
|
and <a class="reference external" href="reference-Session.html#add_torrent()">add_torrent()</a> for instance.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="upnp_ignore_nonrouters"></a><dl class="docutils">
|
|
|
|
|
<dt>upnp_ignore_nonrouters</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>indicates whether or not the UPnP implementation should ignore any
|
|
|
|
|
broadcast response from a device whose address is not the configured
|
|
|
|
|
router for this machine. i.e. it's a way to not talk to other people's
|
|
|
|
|
routers by mistake.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="send_buffer_low_watermark"></a><dl class="docutils">
|
|
|
|
|
<dt>send_buffer_low_watermark</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>This is the minimum send buffer target size (send buffer includes
|
|
|
|
|
bytes pending being read from disk). For good and snappy seeding
|
|
|
|
|
performance, set this fairly high, to at least fit a few blocks. This
|
|
|
|
|
is essentially the initial window size which will determine how fast
|
|
|
|
|
we can ramp up the send rate</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="send_buffer_watermark"></a><dl class="docutils">
|
|
|
|
|
<dt>send_buffer_watermark</dt>
|
|
|
|
|
<dd><p class="first">the upper limit of the send buffer low-watermark.</p>
|
2014-02-03 03:41:24 +01:00
|
|
|
<p class="last">if the send buffer has fewer bytes than this, 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. The actual watermark may be lower
|
|
|
|
|
than this in case the upload rate is low, this is the upper limit.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="send_buffer_watermark_factor"></a><dl class="docutils">
|
|
|
|
|
<dt>send_buffer_watermark_factor</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">the current upload rate to a peer is multiplied by this factor to get
|
|
|
|
|
the send buffer watermark. The factor is specified as a percentage.
|
|
|
|
|
i.e. 50 indicates a factor of 0.5.</p>
|
|
|
|
|
<p>This product is clamped to the send_buffer_watermark setting to not
|
|
|
|
|
exceed the max. For high speed upload, this should be set to a greater
|
|
|
|
|
value than 100. The default is 50.</p>
|
|
|
|
|
<p class="last">For high capacity connections, setting this higher can improve upload
|
|
|
|
|
performance and disk throughput. Setting it too high may waste RAM and
|
|
|
|
|
create a bias towards read jobs over write jobs.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
2014-02-03 03:41:24 +01:00
|
|
|
<a name="}"></a><dl class="docutils">
|
|
|
|
|
<dt>}</dt>
|
|
|
|
|
<dd>opens up unchoke slots based on the upload rate achieved to peers.
|
|
|
|
|
The more slots that are opened, the marginal upload rate required
|
|
|
|
|
to open up another slot increases.
|
|
|
|
|
attempts to optimize download rate by finding the reciprocation
|
|
|
|
|
rate of each peer individually and prefers peers that gives the
|
|
|
|
|
highest <em>return on investment</em>. It still allocates all upload
|
|
|
|
|
capacity, but shuffles it around to the best peers first. For this
|
|
|
|
|
choker to be efficient, you need to set a global upload rate limit
|
|
|
|
|
<a class="reference external" href="reference-Settings.html#upload_rate_limit">session_settings::upload_rate_limit</a>. For more information about
|
|
|
|
|
this choker, see the <a class="reference external" href="http://bittyrant.cs.washington.edu/#papers">paper</a>.</dd>
|
|
|
|
|
</dl>
|
2013-12-21 10:54:17 +01:00
|
|
|
<a name="choking_algorithm"></a><dl class="docutils">
|
|
|
|
|
<dt>choking_algorithm</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies which algorithm to use to determine which peers to unchoke.
|
|
|
|
|
This setting replaces the deprecated settings <tt class="docutils literal">auto_upload_slots</tt>
|
|
|
|
|
and <tt class="docutils literal">auto_upload_slots_rate_based</tt>. For options, see
|
|
|
|
|
choking_algorithm_t.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="}"></a><dl class="docutils">
|
|
|
|
|
<dt>}</dt>
|
|
|
|
|
<dd>prioritizes peers who have just started or are just about to finish
|
|
|
|
|
the download. The intention is to force peers in the middle of the
|
|
|
|
|
download to trade with each other.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="seed_choking_algorithm"></a><dl class="docutils">
|
|
|
|
|
<dt>seed_choking_algorithm</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls the seeding unchoke behavior. For options, see
|
|
|
|
|
seed_choking_algorithm_t.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="use_parole_mode"></a><dl class="docutils">
|
|
|
|
|
<dt>use_parole_mode</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies if parole mode should be used. Parole mode means that peers
|
|
|
|
|
that participate in pieces that fail the hash check are put in a mode
|
|
|
|
|
where they are only allowed to download whole pieces. If the whole
|
|
|
|
|
piece a peer in parole mode fails the hash check, it is banned. If a
|
|
|
|
|
peer participates in a piece that passes the hash check, it is taken
|
|
|
|
|
out of parole mode.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="cache_size"></a><dl class="docutils">
|
|
|
|
|
<dt>cache_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">the disk write and read cache. It is specified in units of 16 KiB
|
|
|
|
|
blocks. Buffers that are part of a peer's send or receive buffer also
|
|
|
|
|
count against this limit. Send and receive buffers will never be
|
|
|
|
|
denied to be allocated, but they will cause the actual cached blocks
|
|
|
|
|
to be flushed or evicted. If this is set to -1, the cache size is
|
|
|
|
|
automatically set to the amount of 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).</p>
|
|
|
|
|
<p class="last">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 be
|
|
|
|
|
specified in <tt class="docutils literal">cache_buffer_chunk_size</tt>. This defaults to 16 blocks.
|
|
|
|
|
Lower numbers saves memory at the expense of more heap allocations. It
|
|
|
|
|
must be at least 1.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="cache_buffer_chunk_size"></a><dl class="docutils">
|
|
|
|
|
<dt>cache_buffer_chunk_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>this is the number of disk buffer blocks (16 kiB) that should be
|
|
|
|
|
allocated at a time. It must be at least 1. Lower number saves memory
|
|
|
|
|
at the expense of more heap allocations</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="cache_expiry"></a><dl class="docutils">
|
|
|
|
|
<dt>cache_expiry</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds a write cache <a class="reference external" href="reference-Bencoding.html#entry">entry</a> sits idle in the cache
|
|
|
|
|
before it's forcefully flushed to disk.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="use_read_cache"></a><dl class="docutils">
|
|
|
|
|
<dt>use_read_cache</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>when set to true (default), the disk cache is also used to cache
|
|
|
|
|
pieces read from disk. Blocks for writing pieces takes presedence.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="explicit_read_cache"></a><dl class="docutils">
|
|
|
|
|
<dt>explicit_read_cache</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to 0. If set to something greater than 0, the disk read cache
|
|
|
|
|
will not be evicted by cache misses and will explicitly be controlled
|
|
|
|
|
based on the rarity of pieces. Rare pieces are more likely to be
|
|
|
|
|
cached. This would typically be used together with <tt class="docutils literal">suggest_mode</tt>
|
|
|
|
|
set to <tt class="docutils literal">suggest_read_cache</tt>. The value is the number of pieces to
|
|
|
|
|
keep in the read cache. If the actual read cache can't fit as many, it
|
|
|
|
|
will essentially be clamped.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="explicit_cache_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>explicit_cache_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds in between each refresh of a part of the
|
|
|
|
|
explicit read cache. Torrents take turns in refreshing and this is the
|
|
|
|
|
time in between each torrent refresh. Refreshing a torrent's explicit
|
|
|
|
|
read cache means scanning all pieces and picking a random set of the
|
|
|
|
|
rarest ones. There is an affinity to pick pieces that are already in
|
|
|
|
|
the cache, so that subsequent refreshes only swaps in pieces that are
|
|
|
|
|
rarer than whatever is in the cache at the time.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="disk_io_write_mode"></a>
|
|
|
|
|
<a name="disk_io_read_mode"></a><dl class="docutils">
|
|
|
|
|
<dt>disk_io_write_mode disk_io_read_mode</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">determines how files are opened when they're in read only mode versus
|
|
|
|
|
read and write mode. For options, see <a class="reference external" href="reference-Settings.html#io_buffer_mode_t">io_buffer_mode_t</a>.</p>
|
|
|
|
|
<p class="last">One reason to disable caching is that it may help the operating system
|
|
|
|
|
from growing its file cache indefinitely. Since some OSes only allow
|
|
|
|
|
aligned files to be opened in unbuffered mode, It is recommended to
|
|
|
|
|
make the largest file in a torrent the first file (with offset 0) or
|
|
|
|
|
use pad files to align all files to piece boundries.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
2014-02-03 03:41:24 +01:00
|
|
|
<a name="coalesce_reads"></a>
|
|
|
|
|
<a name="coalesce_writes"></a><dl class="docutils">
|
|
|
|
|
<dt>coalesce_reads coalesce_writes</dt>
|
|
|
|
|
<dd>when set to true, instead of issuing multiple adjacent reads or writes
|
|
|
|
|
to the disk, allocate a larger buffer, copy all writes into it and
|
|
|
|
|
issue a single write. For reads, read into a larger buffer and copy
|
|
|
|
|
the buffer into the smaller individual read buffers afterwards. This
|
|
|
|
|
may save system calls, but will cost in additional memory allocation
|
|
|
|
|
and copying.</dd>
|
|
|
|
|
</dl>
|
2013-12-21 10:54:17 +01:00
|
|
|
<a name="outgoing_ports"></a><dl class="docutils">
|
|
|
|
|
<dt>outgoing_ports</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">if set to something other than (0, 0) is a range of ports used to bind
|
|
|
|
|
outgoing sockets to. This may be useful for users whose router allows
|
|
|
|
|
them to assign QoS classes to traffic based on its local port. 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 port is in
|
|
|
|
|
<tt class="docutils literal">TIME_WAIT</tt> state.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<div class="warning last">
|
|
|
|
|
<p class="first admonition-title">Warning</p>
|
|
|
|
|
<p class="last">setting outgoing ports will limit the ability to keep multiple
|
|
|
|
|
connections to the same client, even for different torrents. It is not
|
|
|
|
|
recommended to change this setting. Its main purpose is to use as an
|
2014-02-03 03:41:24 +01:00
|
|
|
escape hatch for cheap routers with QoS capability but can only
|
|
|
|
|
classify flows based on port numbers.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</div>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="peer_tos"></a><dl class="docutils">
|
|
|
|
|
<dt>peer_tos</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines the TOS byte set in the IP header of every packet sent to
|
|
|
|
|
peers (including web seeds). The default value for this is <tt class="docutils literal">0x0</tt> (no
|
|
|
|
|
marking). One potentially useful TOS mark is <tt class="docutils literal">0x20</tt>, this represents
|
2013-12-21 10:54:17 +01:00
|
|
|
the <em>QBone scavenger service</em>. For more details, see <a class="reference external" href="http://qbone.internet2.edu/qbss/">QBSS</a>.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="active_downloads"></a>
|
|
|
|
|
<a name="active_seeds"></a>
|
|
|
|
|
<a name="active_dht_limit"></a>
|
|
|
|
|
<a name="active_tracker_limit"></a>
|
|
|
|
|
<a name="active_lsd_limit"></a>
|
|
|
|
|
<a name="active_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>active_downloads active_seeds active_dht_limit active_tracker_limit active_lsd_limit active_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">for auto managed torrents, these are the limits they are subject to.
|
|
|
|
|
If there are too many torrents some of the auto managed ones will be
|
|
|
|
|
paused until some slots free up.</p>
|
|
|
|
|
<p><tt class="docutils literal">active_dht_limit</tt> and <tt class="docutils literal">active_tracker_limit</tt> limits the number of
|
|
|
|
|
torrents that will be active on the DHT and their tracker. If the
|
|
|
|
|
active limit is set higher than these numbers, some torrents will be
|
|
|
|
|
"active" in the sense that they will accept incoming connections, but
|
|
|
|
|
not announce on the DHT or their trackers.</p>
|
|
|
|
|
<p><tt class="docutils literal">active_lsd_limit</tt> is the max number of torrents to announce to the
|
|
|
|
|
local network over the local service discovery protocol. By default
|
|
|
|
|
this is 80, which is no more than one announce every 5 seconds
|
|
|
|
|
(assuming the default announce interval of 5 minutes).</p>
|
|
|
|
|
<p><tt class="docutils literal">active_limit</tt> is a hard limit on the number of active torrents.
|
|
|
|
|
This applies even to slow torrents.</p>
|
|
|
|
|
<p>You can have more torrents <em>active</em>, even though they are not
|
|
|
|
|
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 accepted,
|
|
|
|
|
unless the torrent is paused, which means it won't accept any
|
|
|
|
|
connections.</p>
|
|
|
|
|
<p><tt class="docutils literal">active_downloads</tt> and <tt class="docutils literal">active_seeds</tt> controls how many active
|
|
|
|
|
seeding and downloading torrents the queuing mechanism allows. The
|
|
|
|
|
target number of active torrents is <tt class="docutils literal">min(active_downloads +
|
|
|
|
|
active_seeds, active_limit)</tt>. <tt class="docutils literal">active_downloads</tt> and
|
|
|
|
|
<tt class="docutils literal">active_seeds</tt> are upper limits on the number of downloading
|
|
|
|
|
torrents and seeding torrents respectively. Setting the value to -1
|
|
|
|
|
means unlimited.</p>
|
|
|
|
|
<p class="last">For example if there are 10 seeding torrents and 10 downloading
|
|
|
|
|
torrents, and <tt class="docutils literal">active_downloads</tt> is 4 and <tt class="docutils literal">active_seeds</tt> is 4,
|
|
|
|
|
there will be 4 seeds active and 4 downloading torrents. If the
|
|
|
|
|
settings are <tt class="docutils literal">active_downloads</tt> = 2 and <tt class="docutils literal">active_seeds</tt> = 4, then
|
|
|
|
|
there will be 2 downloading torrents and 4 seeding torrents active.
|
|
|
|
|
Torrents that are not auto managed are also counted against these
|
|
|
|
|
limits. If there are non-auto managed torrents that use up all the
|
|
|
|
|
slots, no auto managed torrent will be activated.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="auto_manage_prefer_seeds"></a><dl class="docutils">
|
|
|
|
|
<dt>auto_manage_prefer_seeds</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>prefer seeding torrents when determining which torrents to give active
|
|
|
|
|
slots to, the default is false which gives preference to downloading
|
|
|
|
|
torrents</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="dont_count_slow_torrents"></a><dl class="docutils">
|
|
|
|
|
<dt>dont_count_slow_torrents</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if true, torrents without any payload transfers are not subject to the
|
|
|
|
|
<tt class="docutils literal">active_seeds</tt> and <tt class="docutils literal">active_downloads</tt> limits. This is intended to
|
|
|
|
|
make it more likely to utilize all available bandwidth, and avoid
|
|
|
|
|
having torrents that don't transfer anything block the active slots.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="auto_manage_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>auto_manage_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds in between recalculating which torrents to
|
|
|
|
|
activate and which ones to queue</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="share_ratio_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>share_ratio_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">when a seeding torrent reaches either the share ratio (bytes up /
|
|
|
|
|
bytes down) or the seed time ratio (seconds as seed / seconds as
|
|
|
|
|
downloader) or the seed time limit (seconds as seed) it is considered
|
|
|
|
|
done, and it will leave room for other torrents the default value for
|
|
|
|
|
share ratio is 2 the default seed time ratio is 7, because that's a
|
|
|
|
|
common asymmetry ratio on connections</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<div class="note last">
|
|
|
|
|
<p class="first admonition-title">Note</p>
|
2014-02-03 03:41:24 +01:00
|
|
|
<p class="last">This is an out-dated option that doesn't make much sense. It will be
|
|
|
|
|
removed in future versions of libtorrent</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</div>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="seed_time_ratio_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>seed_time_ratio_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the seeding time / downloading time ratio limit for considering a
|
|
|
|
|
seeding torrent to have met the seed limit criteria. See <a class="reference external" href="manual-ref.html#queuing">queuing</a>.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="seed_time_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>seed_time_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the limit on the time a torrent has been an active seed (specified in
|
|
|
|
|
seconds) before it is considered having met the seed limit criteria.
|
2013-12-21 10:54:17 +01:00
|
|
|
See <a class="reference external" href="manual-ref.html#queuing">queuing</a>.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="peer_turnover_interval"></a>
|
|
|
|
|
<a name="peer_turnover"></a>
|
|
|
|
|
<a name="peer_turnover_cutoff"></a><dl class="docutils">
|
|
|
|
|
<dt>peer_turnover_interval peer_turnover peer_turnover_cutoff</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">controls a feature where libtorrent periodically can disconnect the
|
|
|
|
|
least useful peers in the hope of connecting to better ones.
|
|
|
|
|
<tt class="docutils literal">peer_turnover_interval</tt> controls the interval of this optimistic
|
|
|
|
|
disconnect. It defaults to every 5 minutes, and is specified in
|
|
|
|
|
seconds.</p>
|
|
|
|
|
<p><tt class="docutils literal">peer_turnover</tt> Is the fraction of the peers that are disconnected.
|
|
|
|
|
This is a float where 1.f represents all peers an 0 represents no
|
|
|
|
|
peers. It defaults to 4% (i.e. 0.04f)</p>
|
|
|
|
|
<p class="last"><tt class="docutils literal">peer_turnover_cutoff</tt> is the cut off trigger for optimistic
|
|
|
|
|
unchokes. If a torrent has more than this fraction of its connection
|
|
|
|
|
limit, the optimistic unchoke is triggered. This defaults to 90% (i.e.
|
|
|
|
|
0.9f).</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="close_redundant_connections"></a><dl class="docutils">
|
|
|
|
|
<dt>close_redundant_connections</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies whether libtorrent should close connections where both ends
|
|
|
|
|
have no utility in keeping the connection open. For instance if both
|
|
|
|
|
ends have completed their downloads, there's no point in keeping it
|
|
|
|
|
open. This defaults to <tt class="docutils literal">true</tt>.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="auto_scrape_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>auto_scrape_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds between scrapes of queued torrents (auto managed
|
|
|
|
|
and paused torrents). Auto managed torrents that are paused, are
|
|
|
|
|
scraped regularly in order to keep track of their downloader/seed
|
|
|
|
|
ratio. This ratio is used to determine which torrents to seed and
|
|
|
|
|
which to pause.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="auto_scrape_min_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>auto_scrape_min_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the minimum number of seconds between any automatic scrape (regardless
|
|
|
|
|
of torrent). In case there are a large number of paused auto managed
|
|
|
|
|
torrents, this puts a limit on how often a scrape request is sent.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_peerlist_size"></a><dl class="docutils">
|
|
|
|
|
<dt>max_peerlist_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the maximum number of peers in the list of known peers. These peers
|
|
|
|
|
are not necessarily connected, so this number should be much greater
|
|
|
|
|
than the maximum number of connected peers. Peers are evicted from the
|
|
|
|
|
cache when the list grows passed 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 limit on how many peers we'll keep in the
|
|
|
|
|
peer list.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_paused_peerlist_size"></a><dl class="docutils">
|
|
|
|
|
<dt>max_paused_peerlist_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the max peer list size used for torrents that are paused. This default
|
|
|
|
|
to the same as <tt class="docutils literal">max_peerlist_size</tt>, but can be used to save memory
|
|
|
|
|
for paused torrents, since it's not as important for them to keep a
|
|
|
|
|
large peer list.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="min_announce_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>min_announce_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the minimum allowed announce interval for a tracker. This is specified
|
|
|
|
|
in seconds, defaults to 5 minutes and is used as a sanity check on
|
|
|
|
|
what is returned from a tracker. It mitigates hammering misconfigured
|
|
|
|
|
trackers.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="prioritize_partial_pieces"></a><dl class="docutils">
|
|
|
|
|
<dt>prioritize_partial_pieces</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>If true, partial pieces are picked before pieces that are more rare.
|
|
|
|
|
If false, rare pieces are always prioritized, unless the number of
|
|
|
|
|
partial pieces is growing out of proportion.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="auto_manage_startup"></a><dl class="docutils">
|
|
|
|
|
<dt>auto_manage_startup</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of seconds a torrent is considered active after it was
|
|
|
|
|
started, regardless of upload and download speed. This is so that
|
|
|
|
|
newly started torrents are not considered inactive until they have a
|
|
|
|
|
fair chance to start downloading.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="rate_limit_ip_overhead"></a><dl class="docutils">
|
|
|
|
|
<dt>rate_limit_ip_overhead</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if set to true, the estimated TCP/IP overhead is drained from the rate
|
|
|
|
|
limiters, to avoid exceeding the limits with the total traffic</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="announce_to_all_trackers"></a><dl class="docutils">
|
|
|
|
|
<dt>announce_to_all_trackers</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls how multi tracker torrents are treated. If this is set to
|
|
|
|
|
true, all trackers in the same tier are announced to in parallel. If
|
|
|
|
|
all trackers in tier 0 fails, all trackers in tier 1 are announced as
|
|
|
|
|
well. If it's set to false, the behavior is as defined by the multi
|
|
|
|
|
tracker specification. It defaults to false, which is the same
|
|
|
|
|
behavior previous versions of libtorrent has had as well.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="announce_to_all_tiers"></a><dl class="docutils">
|
|
|
|
|
<dt>announce_to_all_tiers</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls how multi tracker torrents 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 default in order to comply with the
|
|
|
|
|
multi-tracker specification.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="prefer_udp_trackers"></a><dl class="docutils">
|
|
|
|
|
<dt>prefer_udp_trackers</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>true by default. It means that trackers may be rearranged in a way
|
|
|
|
|
that udp trackers are always tried before http trackers for the same
|
|
|
|
|
hostname. Setting this to fails means that the trackers' tier is
|
|
|
|
|
respected and there's no preference of one protocol over another.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="strict_super_seeding"></a><dl class="docutils">
|
|
|
|
|
<dt>strict_super_seeding</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>when this is set to true, a piece has to have been forwarded to a
|
|
|
|
|
third peer before another one is handed out. This is the traditional
|
|
|
|
|
definition of super seeding.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="seeding_piece_quota"></a><dl class="docutils">
|
|
|
|
|
<dt>seeding_piece_quota</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of pieces to send to a peer, when seeding, before rotating
|
|
|
|
|
in another peer to the unchoke set. It defaults to 3 pieces, which
|
|
|
|
|
means that when seeding, any peer we've sent more than this number of
|
|
|
|
|
pieces to will be unchoked in favour of a choked peer.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_sparse_regions"></a><dl class="docutils">
|
|
|
|
|
<dt>max_sparse_regions</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>is a limit of the number of <em>sparse regions</em> in a torrent. A sparse
|
|
|
|
|
region is defined as a hole of pieces we have not yet downloaded, in
|
|
|
|
|
between pieces that have been downloaded. This is used as a hack for
|
|
|
|
|
windows vista which has a bug where you cannot write files with more
|
|
|
|
|
than a certain number of sparse regions. This limit is not hard, it
|
|
|
|
|
will be exceeded. Once it's exceeded, pieces that will maintain or
|
|
|
|
|
decrease the number of sparse regions are prioritized. To disable this
|
|
|
|
|
functionality, set this to 0. It defaults to 0 on all platforms except
|
|
|
|
|
windows.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="lock_disk_cache"></a><dl class="docutils">
|
|
|
|
|
<dt>lock_disk_cache</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if lock disk cache is set to true the disk cache that's in use, will
|
|
|
|
|
be locked in physical memory, preventing it from being swapped out.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_rejects"></a><dl class="docutils">
|
|
|
|
|
<dt>max_rejects</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of piece requests we will reject in a row while a peer is
|
|
|
|
|
choked before the peer is considered abusive and is disconnected.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="recv_socket_buffer_size"></a>
|
|
|
|
|
<a name="send_socket_buffer_size"></a><dl class="docutils">
|
|
|
|
|
<dt>recv_socket_buffer_size send_socket_buffer_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies the buffer sizes set on peer sockets. 0 (which is the
|
|
|
|
|
default) means the OS default (i.e. don't change the buffer sizes).
|
|
|
|
|
The socket buffer sizes are changed using setsockopt() with
|
|
|
|
|
SOL_SOCKET/SO_RCVBUF and SO_SNDBUFFER.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="optimize_hashing_for_speed"></a><dl class="docutils">
|
|
|
|
|
<dt>optimize_hashing_for_speed</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>chooses between two ways of reading back piece data from disk when its
|
|
|
|
|
complete and needs to be verified against the piece hash. This happens
|
|
|
|
|
if some blocks were flushed to the disk out of order. Everything that
|
|
|
|
|
is flushed in order is hashed as it goes along. Optimizing for speed
|
|
|
|
|
will allocate space to fit all the the remaingin, unhashed, part of
|
|
|
|
|
the piece, reads the data into it in a single call and hashes it. This
|
|
|
|
|
is the default. If <tt class="docutils literal">optimizing_hashing_for_speed</tt> is false, a single
|
|
|
|
|
block will be allocated (16 kB), and the unhashed parts of the piece
|
|
|
|
|
are read, one at a time, and hashed in this single block. This is
|
|
|
|
|
appropriate on systems that are memory constrained.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="file_checks_delay_per_block"></a><dl class="docutils">
|
|
|
|
|
<dt>file_checks_delay_per_block</dt>
|
|
|
|
|
<dd>the number of milliseconds to sleep
|
|
|
|
|
in between disk read operations when checking torrents. This defaults
|
|
|
|
|
to 0, but can be set to higher numbers to slow down the rate at which
|
|
|
|
|
data is read from the disk while checking. This may be useful for
|
|
|
|
|
background tasks that doesn't matter if they take a bit longer, as long
|
|
|
|
|
as they leave disk I/O time for other processes.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="disk_cache_algorithm"></a><dl class="docutils">
|
|
|
|
|
<dt>disk_cache_algorithm</dt>
|
2014-04-06 21:11:24 +02:00
|
|
|
<dd>tells the disk I/O thread which cache flush algorithm to use.
|
|
|
|
|
This is specified by the <a class="reference external" href="reference-Settings.html#disk_cache_algo_t">disk_cache_algo_t</a> enum.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="read_cache_line_size"></a><dl class="docutils">
|
|
|
|
|
<dt>read_cache_line_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">the number of blocks to read into the read cache when a read cache
|
|
|
|
|
miss occurs. Setting this to 0 is essentially the same thing as
|
|
|
|
|
disabling read cache. The number of blocks read into the read cache is
|
|
|
|
|
always capped by the piece boundry.</p>
|
|
|
|
|
<p class="last">When a piece in the write cache has <tt class="docutils literal">write_cache_line_size</tt>
|
|
|
|
|
contiguous blocks in it, they will be flushed. Setting this to 1
|
|
|
|
|
effectively disables the write cache.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="write_cache_line_size"></a><dl class="docutils">
|
|
|
|
|
<dt>write_cache_line_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>whenever a contiguous range of this many blocks is found in the write
|
|
|
|
|
cache, it is flushed immediately</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="optimistic_disk_retry"></a><dl class="docutils">
|
|
|
|
|
<dt>optimistic_disk_retry</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">the number of seconds from a disk 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.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<p>libtorrent will only do this automatically for auto managed torrents.</p>
|
|
|
|
|
<p class="last">You can explicitly take a torrent out of upload only mode using
|
|
|
|
|
set_upload_mode().</p>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="disable_hash_checks"></a><dl class="docutils">
|
|
|
|
|
<dt>disable_hash_checks</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls if downloaded pieces are verified against the piece hashes in
|
|
|
|
|
the torrent file or not. The default is false, i.e. to verify all
|
|
|
|
|
downloaded data. It may be useful to turn this off for performance
|
|
|
|
|
profiling and simulation scenarios. Do not disable the hash check for
|
|
|
|
|
regular bittorrent clients.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="allow_reordered_disk_operations"></a><dl class="docutils">
|
|
|
|
|
<dt>allow_reordered_disk_operations</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if this is true, disk read operations may be re-ordered based on their
|
|
|
|
|
physical disk read offset. This greatly improves throughput when
|
|
|
|
|
uploading to many peers. This assumes a traditional hard drive with a
|
|
|
|
|
read head and spinning platters. If your storage medium is a solid
|
|
|
|
|
state drive, this optimization doesn't give you an benefits</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="allow_i2p_mixed"></a><dl class="docutils">
|
|
|
|
|
<dt>allow_i2p_mixed</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if this is true, i2p torrents are allowed to also get peers from other
|
|
|
|
|
sources than the tracker, and connect to regular IPs, not providing
|
|
|
|
|
any anonymization. This may be useful if the user is not interested in
|
|
|
|
|
the anonymization of i2p, but still wants to be able to connect to i2p
|
|
|
|
|
peers.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_suggest_pieces"></a><dl class="docutils">
|
|
|
|
|
<dt>max_suggest_pieces</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the max number of suggested piece indices received from a peer that's
|
|
|
|
|
remembered. If a peer floods suggest messages, this limit prevents
|
|
|
|
|
libtorrent from using too much RAM. It defaults to 10.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="drop_skipped_requests"></a><dl class="docutils">
|
|
|
|
|
<dt>drop_skipped_requests</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>If set to true (it defaults to false), piece requests that have been
|
|
|
|
|
skipped enough times when piece messages are received, will be
|
|
|
|
|
considered lost. Requests are considered skipped when the returned
|
|
|
|
|
piece messages are re-ordered compared to the order of the requests.
|
|
|
|
|
This was an attempt to get out of dead-locks caused by BitComet peers
|
|
|
|
|
silently ignoring some requests. It may cause problems at high rates,
|
|
|
|
|
and high level of reordering in the uploading peer, that's why it's
|
|
|
|
|
disabled by default.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="low_prio_disk"></a><dl class="docutils">
|
|
|
|
|
<dt>low_prio_disk</dt>
|
|
|
|
|
<dd>determines if the disk I/O should use a normal
|
|
|
|
|
or low priority policy. This defaults to true, which means that
|
|
|
|
|
it's low priority by default. Other processes doing disk I/O will
|
|
|
|
|
normally take priority in this mode. This is meant to improve the
|
|
|
|
|
overall responsiveness of the system while downloading in the
|
|
|
|
|
background. For high-performance server setups, this might not
|
|
|
|
|
be desirable.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="local_service_announce_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>local_service_announce_interval</dt>
|
|
|
|
|
<dd>the time between local
|
|
|
|
|
network announces for a torrent. By default, when local service
|
|
|
|
|
discovery is enabled a torrent announces itself every 5 minutes.
|
|
|
|
|
This interval is specified in seconds.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="dht_announce_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>dht_announce_interval</dt>
|
|
|
|
|
<dd>the number of seconds between announcing
|
|
|
|
|
torrents to the distributed hash table (DHT). This is specified to
|
|
|
|
|
be 15 minutes which is its default.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="udp_tracker_token_expiry"></a><dl class="docutils">
|
|
|
|
|
<dt>udp_tracker_token_expiry</dt>
|
|
|
|
|
<dd>the number of seconds libtorrent
|
|
|
|
|
will keep UDP tracker connection tokens around for. This is specified
|
|
|
|
|
to be 60 seconds, and defaults to that. The higher this value is, the
|
|
|
|
|
fewer packets have to be sent to the UDP tracker. In order for higher
|
|
|
|
|
values to work, the tracker needs to be configured to match the
|
|
|
|
|
expiration time for tokens.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="volatile_read_cache"></a><dl class="docutils">
|
|
|
|
|
<dt>volatile_read_cache</dt>
|
|
|
|
|
<dd>if this is set to true, read cache blocks
|
|
|
|
|
that are hit by peer read requests are removed from the disk cache
|
|
|
|
|
to free up more space. This is useful if you don't expect the disk
|
|
|
|
|
cache to create any cache hits from other peers than the one who
|
|
|
|
|
triggered the cache line to be read into the cache in the first place.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="guided_read_cache"></a><dl class="docutils">
|
|
|
|
|
<dt>guided_read_cache</dt>
|
|
|
|
|
<dd>enables the disk cache to adjust the size
|
|
|
|
|
of a cache line generated by peers to depend on the upload rate
|
|
|
|
|
you are sending to that peer. The intention is to optimize the RAM
|
|
|
|
|
usage of the cache, to read ahead further for peers that you're
|
|
|
|
|
sending faster to.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="default_cache_min_age"></a><dl class="docutils">
|
|
|
|
|
<dt>default_cache_min_age</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the minimum number of seconds any read cache line is kept in the
|
|
|
|
|
cache. This defaults to one second but may be greater if
|
|
|
|
|
<tt class="docutils literal">guided_read_cache</tt> is enabled. Having a lower bound on the time a
|
|
|
|
|
cache line stays in the cache is an attempt to avoid swapping the same
|
|
|
|
|
pieces in and out of the cache in case there is a shortage of spare
|
|
|
|
|
cache space.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="num_optimistic_unchoke_slots"></a><dl class="docutils">
|
|
|
|
|
<dt>num_optimistic_unchoke_slots</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of optimistic unchoke slots to use. It defaults to 0, which
|
|
|
|
|
means automatic. Having a higher number of optimistic unchoke slots
|
|
|
|
|
mean you will find the good peers faster but with the trade-off to use
|
|
|
|
|
up more bandwidth. When this is set to 0, libtorrent opens up 20% of
|
|
|
|
|
your allowed upload slots as optimistic unchoke slots.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="no_atime_storage"></a><dl class="docutils">
|
|
|
|
|
<dt>no_atime_storage</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>this is a linux-only option and passes in the <tt class="docutils literal">O_NOATIME</tt> to
|
|
|
|
|
<tt class="docutils literal">open()</tt> when opening files. This may lead to some disk performance
|
|
|
|
|
improvements.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="default_est_reciprocation_rate"></a><dl class="docutils">
|
|
|
|
|
<dt>default_est_reciprocation_rate</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the assumed reciprocation rate from peers when using the BitTyrant
|
|
|
|
|
choker. This defaults to 14 kiB/s. If set too high, you will
|
|
|
|
|
over-estimate your peers and be more altruistic while finding the true
|
|
|
|
|
reciprocation rate, if it's set too low, you'll be too stingy and
|
|
|
|
|
waste finding the true reciprocation rate.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="increase_est_reciprocation_rate"></a><dl class="docutils">
|
|
|
|
|
<dt>increase_est_reciprocation_rate</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies how many percent the extimated reciprocation rate should be
|
|
|
|
|
increased by each unchoke interval a peer is still choking us back.
|
|
|
|
|
This defaults to 20%. This only applies to the BitTyrant choker.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="decrease_est_reciprocation_rate"></a><dl class="docutils">
|
|
|
|
|
<dt>decrease_est_reciprocation_rate</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies how many percent the estimated reciprocation rate should be
|
|
|
|
|
decreased by each unchoke interval a peer unchokes us. This default to
|
|
|
|
|
3%. This only applies to the BitTyrant choker.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="incoming_starts_queued_torrents"></a><dl class="docutils">
|
|
|
|
|
<dt>incoming_starts_queued_torrents</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to false. If a torrent has been paused by the auto managed
|
|
|
|
|
feature in libtorrent, i.e. the torrent is paused and auto managed,
|
|
|
|
|
this feature affects whether or not it is automatically started on an
|
|
|
|
|
incoming connection. The main reason to queue torrents, is not to make
|
|
|
|
|
them unavailable, but to save on the overhead of announcing to the
|
|
|
|
|
trackers, the DHT and to avoid spreading one's unchoke slots too thin.
|
|
|
|
|
If a peer managed to find us, even though we're no in the torrent
|
|
|
|
|
anymore, this setting can make us start the torrent and serve it.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="report_true_downloaded"></a><dl class="docutils">
|
|
|
|
|
<dt>report_true_downloaded</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>when set to true, the downloaded counter sent to trackers will include
|
|
|
|
|
the actual number of payload bytes donwnloaded including redundant
|
|
|
|
|
bytes. If set to false, it will not include any redundany bytes</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="strict_end_game_mode"></a><dl class="docutils">
|
|
|
|
|
<dt>strict_end_game_mode</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to true, and controls when a block may be requested twice. If
|
|
|
|
|
this is <tt class="docutils literal">true</tt>, a block may only be requested twice when there's ay
|
|
|
|
|
least one request to every piece that's left to download in the
|
|
|
|
|
torrent. This may slow down progress on some pieces sometimes, but it
|
|
|
|
|
may also avoid downloading a lot of redundant bytes. If this is
|
|
|
|
|
<tt class="docutils literal">false</tt>, libtorrent attempts to use each peer connection to its max,
|
|
|
|
|
by always requesting something, even if it means requesting something
|
|
|
|
|
that has been requested from another peer already.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="broadcast_lsd"></a><dl class="docutils">
|
|
|
|
|
<dt>broadcast_lsd</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if set to true, the local peer discovery (or Local Service Discovery)
|
|
|
|
|
will not only use IP multicast, but also broadcast its messages. This
|
|
|
|
|
can be useful when running on networks that don't support multicast.
|
|
|
|
|
Since broadcast messages might be expensive and disruptive on
|
|
|
|
|
networks, only every 8th announce uses broadcast.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="enable_outgoing_utp"></a>
|
|
|
|
|
<a name="enable_incoming_utp"></a>
|
|
|
|
|
<a name="enable_outgoing_tcp"></a>
|
|
|
|
|
<a name="enable_incoming_tcp"></a><dl class="docutils">
|
|
|
|
|
<dt>enable_outgoing_utp enable_incoming_utp enable_outgoing_tcp enable_incoming_tcp</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>these all determines if libtorrent should attempt to make outgoing
|
|
|
|
|
connections of the specific type, or allow incoming connection. By
|
2013-12-21 10:54:17 +01:00
|
|
|
default all of them are enabled.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_pex_peers"></a><dl class="docutils">
|
|
|
|
|
<dt>max_pex_peers</dt>
|
|
|
|
|
<dd>the max number of peers we accept from pex messages from a single peer.
|
|
|
|
|
this limits the number of concurrent peers any of our peers claims to
|
|
|
|
|
be connected to. If they clain to be connected to more than this, we'll
|
|
|
|
|
ignore any peer that exceeds this limit</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="ignore_resume_timestamps"></a><dl class="docutils">
|
|
|
|
|
<dt>ignore_resume_timestamps</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines if the storage, when loading resume data files, should
|
|
|
|
|
verify that the file modification time with the timestamps in the
|
|
|
|
|
resume data. This defaults to false, which means timestamps are taken
|
|
|
|
|
into account, and resume data is less likely to accepted (torrents are
|
|
|
|
|
more likely to be fully checked when loaded). It might be useful to
|
|
|
|
|
set this to true if your network is faster than your disk, and it
|
|
|
|
|
would be faster to redownload potentially missed pieces than to go
|
|
|
|
|
through the whole storage to look for them.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="no_recheck_incomplete_resume"></a><dl class="docutils">
|
|
|
|
|
<dt>no_recheck_incomplete_resume</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines if the storage should check the whole files when resume
|
|
|
|
|
data is incomplete or missing or whether it should simply assume we
|
|
|
|
|
don't have any of the data. By default, this is determined by the
|
|
|
|
|
existance of any of the files. By setting this setting to true, the
|
|
|
|
|
files won't be checked, but will go straight to download mode.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="anonymous_mode"></a><dl class="docutils">
|
|
|
|
|
<dt>anonymous_mode</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">defaults to false. When set to true, the client tries to hide its
|
|
|
|
|
identity to a certain degree. The peer-ID will no longer include the
|
|
|
|
|
client's fingerprint. The user-agent will be reset to an empty string.
|
|
|
|
|
It will also try to not leak other identifying information, such as
|
|
|
|
|
your local listen port, your IP etc.</p>
|
|
|
|
|
<p class="last">If you're using I2P, a VPN or a proxy, it might make sense to enable
|
|
|
|
|
anonymous mode.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="force_proxy"></a><dl class="docutils">
|
|
|
|
|
<dt>force_proxy</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>disables any communication that's not going over a proxy. Enabling
|
|
|
|
|
this requires a proxy to be configured as well, see
|
|
|
|
|
<tt class="docutils literal">set_proxy_settings</tt>. The listen sockets are closed, and incoming
|
|
|
|
|
connections will only be accepted through a SOCKS5 or I2P proxy (if a
|
|
|
|
|
peer proxy is set up and is run on the same machine as the tracker
|
|
|
|
|
proxy). This setting also disabled peer country lookups, since those
|
|
|
|
|
are done via DNS lookups that aren't supported by proxies.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="tick_interval"></a><dl class="docutils">
|
|
|
|
|
<dt>tick_interval</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies the number of milliseconds between internal ticks. This is
|
|
|
|
|
the frequency with which bandwidth quota is distributed to peers. It
|
|
|
|
|
should not be more than one second (i.e. 1000 ms). Setting this to a
|
|
|
|
|
low value (around 100) means higher resolution bandwidth quota
|
|
|
|
|
distribution, setting it to a higher value saves CPU cycles.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="report_web_seed_downloads"></a><dl class="docutils">
|
|
|
|
|
<dt>report_web_seed_downloads</dt>
|
|
|
|
|
<dd>specifies whether downloads from web seeds is reported to the
|
|
|
|
|
tracker or not. Defaults to on</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="share_mode_target"></a><dl class="docutils">
|
|
|
|
|
<dt>share_mode_target</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies the target share ratio for share mode torrents. This
|
|
|
|
|
defaults to 3, meaning we'll try to upload 3 times as much as we
|
|
|
|
|
download. Setting this very high, will make it very conservative and
|
|
|
|
|
you might end up not downloading anything ever (and not affecting your
|
|
|
|
|
share ratio). It does not make any sense to set this any lower than 2.
|
|
|
|
|
For instance, if only 3 peers need to download the rarest piece, it's
|
|
|
|
|
impossible to download a single piece and upload it more than 3 times.
|
|
|
|
|
If the share_mode_target is set to more than 3, nothing is downloaded.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="upload_rate_limit"></a>
|
|
|
|
|
<a name="download_rate_limit"></a>
|
|
|
|
|
<a name="local_upload_rate_limit"></a>
|
|
|
|
|
<a name="local_download_rate_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>upload_rate_limit download_rate_limit local_upload_rate_limit local_download_rate_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">sets the session-global limits of upload and download rate limits, in
|
|
|
|
|
bytes per second. The local rates refer to peers on the local network.
|
|
|
|
|
By default peers on the local network are not rate limited.</p>
|
|
|
|
|
<p>These rate limits are only used for local peers (peers within the same
|
|
|
|
|
subnet as the client itself) and it is only used when
|
|
|
|
|
<tt class="docutils literal"><span class="pre">session_settings::ignore_limits_on_local_network</span></tt> is set to true
|
|
|
|
|
(which it is by default). These rate limits default to unthrottled,
|
|
|
|
|
but can be useful in case you want to treat local peers
|
|
|
|
|
preferentially, but not quite unthrottled.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<p class="last">A value of 0 means unlimited.</p>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="dht_upload_rate_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>dht_upload_rate_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>sets the rate limit on the DHT. This is specified in bytes per second
|
|
|
|
|
and defaults to 4000. For busy boxes with lots of torrents that
|
|
|
|
|
requires more DHT traffic, this should be raised.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="unchoke_slots_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>unchoke_slots_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the max number of unchoked peers in the <a class="reference external" href="reference-Session.html#session">session</a>. The number of unchoke
|
|
|
|
|
slots may be ignored depending on what <tt class="docutils literal">choking_algorithm</tt> is set
|
|
|
|
|
to. A value of -1 means infinite.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="half_open_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>half_open_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>sets the maximum number of half-open connections libtorrent will have
|
|
|
|
|
when connecting to peers. A half-open connection is one where
|
|
|
|
|
connect() has been called, but the connection still hasn't been
|
|
|
|
|
established (nor failed). Windows XP Service Pack 2 sets a default,
|
|
|
|
|
system wide, limit of the number of half-open connections to 10. So,
|
|
|
|
|
this limit can be used to work nicer together with other network
|
|
|
|
|
applications on that system. The default is to have no limit, and
|
|
|
|
|
passing -1 as the limit, means to have no limit. When limiting the
|
|
|
|
|
number of simultaneous connection attempts, peers will be put in a
|
|
|
|
|
queue waiting for their turn to get connected.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="connections_limit"></a><dl class="docutils">
|
|
|
|
|
<dt>connections_limit</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>sets a global limit on the number of connections opened. The number of
|
|
|
|
|
connections is set to a hard minimum of at least two per torrent, so
|
|
|
|
|
if you set a too low connections limit, and open too many torrents,
|
2013-12-21 10:54:17 +01:00
|
|
|
the limit will not be met.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="connections_slack"></a><dl class="docutils">
|
|
|
|
|
<dt>connections_slack</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of extra incoming connections allowed temporarily, in order
|
|
|
|
|
to support replacing peers</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="utp_target_delay"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_target_delay</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the target delay for uTP sockets in milliseconds. A high value will
|
|
|
|
|
make uTP connections more aggressive and cause longer queues in the
|
|
|
|
|
upload bottleneck. It cannot be too low, since the noise in the
|
|
|
|
|
measurements would cause it to send too slow. The default is 50
|
|
|
|
|
milliseconds.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="utp_gain_factor"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_gain_factor</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of bytes the uTP congestion window can increase at the most
|
|
|
|
|
in one RTT. This defaults to 300 bytes. If this is set too high, the
|
|
|
|
|
congestion controller reacts too hard to noise and will not be stable,
|
|
|
|
|
if it's set too low, it will react slow to congestion and not back off
|
|
|
|
|
as fast.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="utp_min_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_min_timeout</dt>
|
|
|
|
|
<dd><p class="first">the shortest allowed uTP socket timeout, specified in milliseconds.
|
2014-02-03 03:41:24 +01:00
|
|
|
This defaults to 500 milliseconds. The timeout depends on the RTT of
|
|
|
|
|
the connection, but is never smaller 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 resent packet is lost as well).</p>
|
|
|
|
|
<p class="last">The shorter the timeout is, the faster the connection will recover
|
|
|
|
|
from this situation, assuming the RTT is low enough.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="utp_syn_resends"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_syn_resends</dt>
|
|
|
|
|
<dd>the number of SYN packets that are sent (and timed out) before
|
|
|
|
|
giving up and closing the socket.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="utp_fin_resends"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_fin_resends</dt>
|
|
|
|
|
<dd>the number of resent packets sent on a closed socket before giving up</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="utp_num_resends"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_num_resends</dt>
|
|
|
|
|
<dd>the number of times a packet is sent (and lossed or timed out)
|
|
|
|
|
before giving up and closing the connection.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="utp_connect_timeout"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_connect_timeout</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of milliseconds of timeout for the initial SYN packet for
|
|
|
|
|
uTP connections. For each timed out packet (in a row), the timeout is
|
|
|
|
|
doubled.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="utp_dynamic_sock_buf"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_dynamic_sock_buf</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls if the uTP socket manager is allowed to increase the socket
|
|
|
|
|
buffer if a network interface with a large MTU is used (such as
|
|
|
|
|
loopback or ethernet jumbo frames). This defaults to true and might
|
|
|
|
|
improve uTP throughput. For RAM constrained systems, disabling this
|
|
|
|
|
typically saves around 30kB in user space and probably around 400kB in
|
|
|
|
|
kernel socket buffers (it adjusts the send and receive buffer size on
|
|
|
|
|
the kernel socket, both for IPv4 and IPv6).</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="utp_loss_multiplier"></a><dl class="docutils">
|
|
|
|
|
<dt>utp_loss_multiplier</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>controls how the congestion window is changed when a packet loss is
|
|
|
|
|
experienced. It's specified as a percentage multiplier for <tt class="docutils literal">cwnd</tt>.
|
|
|
|
|
By default it's set to 50 (i.e. cut in half). Do not change this value
|
|
|
|
|
unless you know what you're doing. Never set it higher than 100.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="mixed_mode_algorithm"></a><dl class="docutils">
|
|
|
|
|
<dt>mixed_mode_algorithm</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">determines how to treat TCP connections when there are uTP
|
|
|
|
|
connections. Since uTP is designed to yield to TCP, there's an
|
|
|
|
|
inherent problem when using swarms that have both TCP and uTP
|
|
|
|
|
connections. If nothing is done, uTP connections would often be
|
|
|
|
|
starved out for bandwidth by the TCP connections. This mode is
|
|
|
|
|
<tt class="docutils literal">prefer_tcp</tt>. The <tt class="docutils literal">peer_proportional</tt> mode simply looks at the
|
|
|
|
|
current throughput and rate limits all TCP connections to their
|
|
|
|
|
proportional share based on how many of the connections are TCP. This
|
|
|
|
|
works best if uTP connections are not rate limited by the global rate
|
|
|
|
|
limiter (which they aren't by default).</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<p class="last">see <a class="reference external" href="reference-Settings.html#bandwidth_mixed_algo_t">bandwidth_mixed_algo_t</a> for options.</p>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="rate_limit_utp"></a><dl class="docutils">
|
|
|
|
|
<dt>rate_limit_utp</dt>
|
|
|
|
|
<dd>determines if uTP connections should be throttled by the global rate
|
|
|
|
|
limiter or not. By default they are.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="listen_queue_size"></a><dl class="docutils">
|
|
|
|
|
<dt>listen_queue_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the value passed in to listen() for the listen socket. It is the
|
|
|
|
|
number of outstanding incoming connections to queue up while we're not
|
|
|
|
|
actively waiting for a connection to be accepted. The default is 5
|
|
|
|
|
which should be sufficient for any normal client. If this is a high
|
|
|
|
|
performance server which expects to receive a lot of connections, or
|
|
|
|
|
used in a simulator or test, it might make sense to raise this number.
|
|
|
|
|
It will not take affect until <a class="reference external" href="reference-Session.html#listen_on()">listen_on()</a> is called again (or for the
|
|
|
|
|
first time).</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="announce_double_nat"></a><dl class="docutils">
|
|
|
|
|
<dt>announce_double_nat</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if true, the <tt class="docutils literal">&ip=</tt> argument in tracker requests (unless otherwise
|
|
|
|
|
specified) will be set to the intermediate IP address, if the user is
|
|
|
|
|
double NATed. If ther user is not double NATed, this option has no
|
|
|
|
|
affect.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="torrent_connect_boost"></a><dl class="docutils">
|
|
|
|
|
<dt>torrent_connect_boost</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the number of peers to try to connect to immediately when the first
|
|
|
|
|
tracker response is received for a torrent. This is a boost to given
|
|
|
|
|
to new torrents to accelerate them starting up. The normal connect
|
|
|
|
|
scheduler is run once every second, this allows peers to be connected
|
|
|
|
|
immediately instead of waiting for the <a class="reference external" href="reference-Session.html#session">session</a> tick to trigger
|
|
|
|
|
connections.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="seeding_outgoing_connections"></a><dl class="docutils">
|
|
|
|
|
<dt>seeding_outgoing_connections</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines if seeding (and finished) torrents should attempt to make
|
|
|
|
|
outgoing connections or not. By default this is true. It may be set to
|
|
|
|
|
false in very specific applications where the cost of making outgoing
|
|
|
|
|
connections is high, and there are no or small benefits of doing so.
|
|
|
|
|
For instance, if no nodes are behind a firewall or a NAT, seeds don't
|
|
|
|
|
need to make outgoing connections.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="no_connect_privileged_ports"></a><dl class="docutils">
|
|
|
|
|
<dt>no_connect_privileged_ports</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if true (which is the default), libtorrent will not connect to any
|
|
|
|
|
peers on priviliged ports (<= 1023). This can mitigate using
|
|
|
|
|
bittorrent swarms for certain DDoS attacks.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="alert_queue_size"></a><dl class="docutils">
|
|
|
|
|
<dt>alert_queue_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the maximum number of alerts queued up internally. If alerts are not
|
|
|
|
|
popped, the queue will eventually fill up to this level. This defaults
|
|
|
|
|
to 1000.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_metadata_size"></a><dl class="docutils">
|
|
|
|
|
<dt>max_metadata_size</dt>
|
|
|
|
|
<dd>the maximum allowed size (in bytes) to be received
|
|
|
|
|
by the metadata extension, i.e. magnet links. It defaults to 1 MiB.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="smooth_connects"></a><dl class="docutils">
|
|
|
|
|
<dt>smooth_connects</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>true by default, which means the number of connection attempts per
|
|
|
|
|
second may be limited to below the <tt class="docutils literal">connection_speed</tt>, in case we're
|
|
|
|
|
close to bump up against the limit of number of connections. The
|
|
|
|
|
intention of this setting is to more evenly distribute our connection
|
|
|
|
|
attempts over time, instead of attempting to connectin in batches, and
|
|
|
|
|
timing them out in batches.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="always_send_user_agent"></a><dl class="docutils">
|
|
|
|
|
<dt>always_send_user_agent</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to false. When set to true, web connections will include a
|
|
|
|
|
user-agent with every request, as opposed to just the first request in
|
|
|
|
|
a connection.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="apply_ip_filter_to_trackers"></a><dl class="docutils">
|
|
|
|
|
<dt>apply_ip_filter_to_trackers</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to true. It determines whether the IP filter applies to
|
|
|
|
|
trackers as well as peers. If this is set to false, trackers are
|
|
|
|
|
exempt from the IP filter (if there is one). If no IP filter is set,
|
|
|
|
|
this setting is irrelevant.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="read_job_every"></a><dl class="docutils">
|
|
|
|
|
<dt>read_job_every</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>used to avoid starvation of read jobs in the disk I/O thread. By
|
|
|
|
|
default, read jobs are deferred, sorted by physical disk location and
|
|
|
|
|
serviced once all write jobs have been issued. In scenarios where the
|
|
|
|
|
download rate is enough to saturate the disk, there's a risk the read
|
|
|
|
|
jobs will never be serviced. With this setting, every <em>x</em> write job,
|
|
|
|
|
issued in a row, will instead pick one read job off of the sorted
|
|
|
|
|
queue, where <em>x</em> is <tt class="docutils literal">read_job_every</tt>.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="use_disk_read_ahead"></a><dl class="docutils">
|
|
|
|
|
<dt>use_disk_read_ahead</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>defaults to true and will attempt to optimize disk reads by giving the
|
|
|
|
|
operating system heads up of disk read requests as they are queued in
|
|
|
|
|
the disk job queue. This gives a significant performance boost for
|
|
|
|
|
seeding.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="lock_files"></a><dl class="docutils">
|
|
|
|
|
<dt>lock_files</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>determines whether or not to lock files which libtorrent is
|
|
|
|
|
downloading to or seeding from. This is implemented using
|
|
|
|
|
<tt class="docutils literal">fcntl(F_SETLK)</tt> on unix systems and by not passing in
|
|
|
|
|
<tt class="docutils literal">SHARE_READ</tt> and <tt class="docutils literal">SHARE_WRITE</tt> on windows. This might prevent 3rd
|
|
|
|
|
party processes from corrupting the files under libtorrent's feet.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="ssl_listen"></a><dl class="docutils">
|
|
|
|
|
<dt>ssl_listen</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first">sets the listen port for SSL connections. If this is set to 0, no SSL
|
|
|
|
|
listen port is opened. Otherwise a socket is opened on this port. This
|
|
|
|
|
setting is only taken into account when opening the regular listen
|
|
|
|
|
port, and won't re-open the listen socket simply by changing this
|
|
|
|
|
setting.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<p>if this is 0, outgoing SSL connections are disabled</p>
|
|
|
|
|
<p class="last">It defaults to port 4433.</p>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="tracker_backoff"></a><dl class="docutils">
|
|
|
|
|
<dt>tracker_backoff</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd><p class="first"><tt class="docutils literal">tracker_backoff</tt> determines how aggressively to back off from
|
|
|
|
|
retrying failing trackers. This value determines <em>x</em> in the following
|
|
|
|
|
formula, determining the number of seconds to wait until the next
|
|
|
|
|
retry:</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
<blockquote>
|
|
|
|
|
delay = 5 + 5 * x / 100 * fails^2</blockquote>
|
|
|
|
|
<p>It defaults to 250.</p>
|
2014-02-03 03:41:24 +01:00
|
|
|
<p class="last">This setting may be useful to make libtorrent more or less aggressive
|
|
|
|
|
in hitting trackers.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="ban_web_seeds"></a><dl class="docutils">
|
|
|
|
|
<dt>ban_web_seeds</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>enables banning web seeds. By default, web seeds that send corrupt
|
|
|
|
|
data are banned.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="max_http_recv_buffer_size"></a><dl class="docutils">
|
|
|
|
|
<dt>max_http_recv_buffer_size</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>specifies the max number of bytes to receive into RAM buffers when
|
|
|
|
|
downloading stuff over HTTP. Specifically when specifying a URL to a
|
|
|
|
|
.torrent file when adding a torrent or when announcing to an HTTP
|
2013-12-21 10:54:17 +01:00
|
|
|
tracker. The default is 2 MiB.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="support_share_mode"></a><dl class="docutils">
|
|
|
|
|
<dt>support_share_mode</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>enables or disables the share mode extension. This is enabled by
|
|
|
|
|
default.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="support_merkle_torrents"></a><dl class="docutils">
|
|
|
|
|
<dt>support_merkle_torrents</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>enables or disables the merkle tree torrent support. This is enabled
|
|
|
|
|
by default.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="report_redundant_bytes"></a><dl class="docutils">
|
|
|
|
|
<dt>report_redundant_bytes</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>enables or disables reporting redundant bytes to the tracker. This is
|
|
|
|
|
enabled by default.</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="handshake_client_version"></a><dl class="docutils">
|
|
|
|
|
<dt>handshake_client_version</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>the version string to advertise for this client in the peer protocol
|
|
|
|
|
handshake. If this is empty the user_agent is used</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
|
|
|
|
<a name="use_disk_cache_pool"></a><dl class="docutils">
|
|
|
|
|
<dt>use_disk_cache_pool</dt>
|
2014-02-03 03:41:24 +01:00
|
|
|
<dd>if this is true, the disk cache uses a pool allocator for disk cache
|
|
|
|
|
blocks. Enabling this improves performance of the disk cache with the
|
|
|
|
|
side effect that the disk cache is less likely and slower at returning
|
|
|
|
|
memory to the kernel when cache pressure is low.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="dht_settings"></a></div>
|
|
|
|
|
</div>
|
|
|
|
|
<div class="section" id="dht-settings">
|
|
|
|
|
<h1>dht_settings</h1>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<p>structure used to hold configuration options for the DHT</p>
|
|
|
|
|
<p>The <tt class="docutils literal">dht_settings</tt> struct used to contain a <tt class="docutils literal">service_port</tt> member to
|
|
|
|
|
control which port the DHT would listen on and send messages from. This
|
|
|
|
|
field is deprecated and ignored. libtorrent always tries to open the UDP
|
|
|
|
|
socket on the same port as the TCP socket.</p>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
struct dht_settings
|
|
|
|
|
{
|
|
|
|
|
<strong>dht_settings</strong> ();
|
|
|
|
|
|
|
|
|
|
int max_peers_reply;
|
|
|
|
|
int search_branching;
|
|
|
|
|
int max_fail_count;
|
|
|
|
|
int max_torrents;
|
|
|
|
|
int max_dht_items;
|
|
|
|
|
int max_torrent_search_reply;
|
|
|
|
|
bool restrict_routing_ips;
|
|
|
|
|
bool restrict_search_ips;
|
|
|
|
|
bool extended_routing_table;
|
|
|
|
|
bool aggressive_lookups;
|
|
|
|
|
bool privacy_lookups;
|
|
|
|
|
bool enforce_node_id;
|
|
|
|
|
bool ignore_dark_internet;
|
|
|
|
|
};
|
|
|
|
|
</pre>
|
|
|
|
|
<a name="dht_settings()"></a><div class="section" id="id25">
|
|
|
|
|
<h2>dht_settings()</h2>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
<strong>dht_settings</strong> ();
|
|
|
|
|
</pre>
|
|
|
|
|
<p>initialized <a class="reference external" href="reference-Settings.html#dht_settings">dht_settings</a> to the default values</p>
|
|
|
|
|
<a name="max_peers_reply"></a><dl class="docutils">
|
|
|
|
|
<dt>max_peers_reply</dt>
|
|
|
|
|
<dd>the maximum number of peers to send in a reply to <tt class="docutils literal">get_peers</tt></dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="search_branching"></a><dl class="docutils">
|
|
|
|
|
<dt>search_branching</dt>
|
|
|
|
|
<dd>the number of concurrent search request the node will send when
|
|
|
|
|
announcing and refreshing the routing table. This parameter is called
|
|
|
|
|
alpha in the kademlia paper</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_fail_count"></a><dl class="docutils">
|
|
|
|
|
<dt>max_fail_count</dt>
|
|
|
|
|
<dd>the maximum number of failed tries to contact a node before it is
|
|
|
|
|
removed from the routing table. If there are known working nodes that
|
|
|
|
|
are ready to replace a failing node, it will be replaced immediately,
|
|
|
|
|
this limit is only used to clear out nodes that don't have any node
|
|
|
|
|
that can replace them.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_torrents"></a><dl class="docutils">
|
|
|
|
|
<dt>max_torrents</dt>
|
|
|
|
|
<dd>the total number of torrents to track from the DHT. This is simply an
|
|
|
|
|
upper limit to make sure malicious DHT nodes cannot make us allocate
|
|
|
|
|
an unbounded amount of memory.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_dht_items"></a><dl class="docutils">
|
|
|
|
|
<dt>max_dht_items</dt>
|
|
|
|
|
<dd>max number of items the DHT will store</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="max_torrent_search_reply"></a><dl class="docutils">
|
|
|
|
|
<dt>max_torrent_search_reply</dt>
|
|
|
|
|
<dd>the max number of torrents to return in a torrent search query to the
|
|
|
|
|
DHT</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="restrict_routing_ips"></a><dl class="docutils">
|
|
|
|
|
<dt>restrict_routing_ips</dt>
|
|
|
|
|
<dd><p class="first">determines if the routing table entries should restrict entries to one
|
|
|
|
|
per IP. This defaults to true, which helps mitigate some attacks on
|
|
|
|
|
the DHT. It prevents adding multiple nodes with IPs with a very close
|
|
|
|
|
CIDR distance.</p>
|
|
|
|
|
<p class="last">when set, nodes whose IP address that's in the same /24 (or /64 for
|
|
|
|
|
IPv6) range in the same routing table bucket. This is an attempt to
|
|
|
|
|
mitigate node ID spoofing attacks also restrict any IP to only have a
|
|
|
|
|
single <a class="reference external" href="reference-Bencoding.html#entry">entry</a> in the whole routing table</p>
|
|
|
|
|
</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="restrict_search_ips"></a><dl class="docutils">
|
|
|
|
|
<dt>restrict_search_ips</dt>
|
|
|
|
|
<dd>determines if DHT searches should prevent adding nodes with IPs with
|
|
|
|
|
very close CIDR distance. This also defaults to true and helps
|
|
|
|
|
mitigate certain attacks on the DHT.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="extended_routing_table"></a><dl class="docutils">
|
|
|
|
|
<dt>extended_routing_table</dt>
|
|
|
|
|
<dd>makes the first buckets in the DHT routing table fit 128, 64, 32 and
|
|
|
|
|
16 nodes respectively, as opposed to the standard size of 8. All other
|
|
|
|
|
buckets have size 8 still.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="aggressive_lookups"></a><dl class="docutils">
|
|
|
|
|
<dt>aggressive_lookups</dt>
|
|
|
|
|
<dd>slightly changes the lookup behavior in terms of how many outstanding
|
|
|
|
|
requests we keep. Instead of having branch factor be a hard limit, we
|
|
|
|
|
always keep <em>branch factor</em> outstanding requests to the closest nodes.
|
|
|
|
|
i.e. every time we get results back with closer nodes, we query them
|
|
|
|
|
right away. It lowers the lookup times at the cost of more outstanding
|
|
|
|
|
queries.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="privacy_lookups"></a><dl class="docutils">
|
|
|
|
|
<dt>privacy_lookups</dt>
|
|
|
|
|
<dd>when set, perform lookups in a way that is slightly more expensive,
|
|
|
|
|
but which minimizes the amount of information leaked about you.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="enforce_node_id"></a><dl class="docutils">
|
|
|
|
|
<dt>enforce_node_id</dt>
|
|
|
|
|
<dd>when set, node's whose IDs that are not correctly generated based on
|
|
|
|
|
its external IP are ignored. When a query arrives from such node, an
|
|
|
|
|
error message is returned with a message saying "invalid node ID".</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="ignore_dark_internet"></a><dl class="docutils">
|
|
|
|
|
<dt>ignore_dark_internet</dt>
|
|
|
|
|
<dd>ignore DHT messages from parts of the internet we wouldn't expect to
|
|
|
|
|
see any traffic from</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="pe_settings"></a></div>
|
|
|
|
|
</div>
|
|
|
|
|
<div class="section" id="pe-settings">
|
|
|
|
|
<h1>pe_settings</h1>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<p>The <tt class="docutils literal">pe_settings</tt> structure is used to control the settings related
|
|
|
|
|
to peer protocol encryption.</p>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
struct pe_settings
|
|
|
|
|
{
|
|
|
|
|
<strong>pe_settings</strong> ();
|
|
|
|
|
|
|
|
|
|
enum enc_policy
|
|
|
|
|
{
|
|
|
|
|
forced,
|
|
|
|
|
enabled,
|
|
|
|
|
disabled,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
enum enc_level
|
|
|
|
|
{
|
|
|
|
|
plaintext,
|
|
|
|
|
rc4,
|
|
|
|
|
both,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
boost::uint8_t out_enc_policy;
|
|
|
|
|
boost::uint8_t in_enc_policy;
|
|
|
|
|
boost::uint8_t allowed_enc_level;
|
|
|
|
|
bool prefer_rc4;
|
|
|
|
|
};
|
|
|
|
|
</pre>
|
|
|
|
|
<a name="pe_settings()"></a><div class="section" id="id29">
|
|
|
|
|
<h2>pe_settings()</h2>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
<strong>pe_settings</strong> ();
|
|
|
|
|
</pre>
|
|
|
|
|
<p>initializes the encryption settings with the default vaues</p>
|
|
|
|
|
<a name="enc_policy"></a></div>
|
|
|
|
|
<div class="section" id="enum-enc-policy">
|
|
|
|
|
<h2>enum enc_policy</h2>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<table border="1" class="docutils">
|
|
|
|
|
<colgroup>
|
|
|
|
|
<col width="12%" />
|
|
|
|
|
<col width="8%" />
|
|
|
|
|
<col width="80%" />
|
|
|
|
|
</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>forced</td>
|
|
|
|
|
<td>0</td>
|
|
|
|
|
<td>Only encrypted connections are allowed. Incoming connections that
|
|
|
|
|
are not encrypted are closed and if the encrypted outgoing
|
|
|
|
|
connection fails, a non-encrypted retry will not be made.</td>
|
|
|
|
|
</tr>
|
|
|
|
|
<tr><td>enabled</td>
|
|
|
|
|
<td>1</td>
|
|
|
|
|
<td>encrypted connections are enabled, but non-encrypted connections
|
|
|
|
|
are allowed. An incoming non-encrypted connection will be accepted,
|
|
|
|
|
and if an outgoing encrypted connection fails, a non- encrypted
|
|
|
|
|
connection will be tried.</td>
|
|
|
|
|
</tr>
|
|
|
|
|
<tr><td>disabled</td>
|
|
|
|
|
<td>2</td>
|
|
|
|
|
<td>only non-encrypted connections are allowed.</td>
|
|
|
|
|
</tr>
|
|
|
|
|
</tbody>
|
|
|
|
|
</table>
|
|
|
|
|
<a name="enc_level"></a></div>
|
|
|
|
|
<div class="section" id="enum-enc-level">
|
|
|
|
|
<h2>enum enc_level</h2>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session_settings.hpp">libtorrent/session_settings.hpp</a>"</p>
|
|
|
|
|
<table border="1" class="docutils">
|
|
|
|
|
<colgroup>
|
|
|
|
|
<col width="22%" />
|
|
|
|
|
<col width="14%" />
|
|
|
|
|
<col width="63%" />
|
|
|
|
|
</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>plaintext</td>
|
|
|
|
|
<td>1</td>
|
|
|
|
|
<td>use only plaintext encryption</td>
|
|
|
|
|
</tr>
|
|
|
|
|
<tr><td>rc4</td>
|
|
|
|
|
<td>2</td>
|
|
|
|
|
<td>use only rc4 encryption</td>
|
|
|
|
|
</tr>
|
|
|
|
|
<tr><td>both</td>
|
|
|
|
|
<td>3</td>
|
|
|
|
|
<td>allow both</td>
|
|
|
|
|
</tr>
|
|
|
|
|
</tbody>
|
|
|
|
|
</table>
|
|
|
|
|
<a name="out_enc_policy"></a>
|
|
|
|
|
<a name="in_enc_policy"></a><dl class="docutils">
|
|
|
|
|
<dt>out_enc_policy in_enc_policy</dt>
|
|
|
|
|
<dd>control the settings for incoming
|
|
|
|
|
and outgoing connections respectively.
|
|
|
|
|
see <a class="reference external" href="reference-Settings.html#enc_policy">enc_policy</a> enum for the available options.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="allowed_enc_level"></a><dl class="docutils">
|
|
|
|
|
<dt>allowed_enc_level</dt>
|
|
|
|
|
<dd>determines the encryption level of the
|
|
|
|
|
connections. This setting will adjust which encryption scheme is
|
|
|
|
|
offered to the other peer, as well as which encryption scheme is
|
|
|
|
|
selected by the client. See <a class="reference external" href="reference-Settings.html#enc_level">enc_level</a> enum for options.</dd>
|
|
|
|
|
</dl>
|
|
|
|
|
<a name="prefer_rc4"></a><dl class="docutils">
|
|
|
|
|
<dt>prefer_rc4</dt>
|
|
|
|
|
<dd>if the allowed encryption level is both, setting this to
|
|
|
|
|
true will prefer rc4 if both methods are offered, plaintext
|
|
|
|
|
otherwise</dd>
|
2013-12-21 10:54:17 +01:00
|
|
|
</dl>
|
2014-02-02 05:07:36 +01:00
|
|
|
<a name="min_memory_usage()"></a>
|
|
|
|
|
<a name="high_performance_seed()"></a></div>
|
|
|
|
|
<div class="section" id="min-memory-usage-high-performance-seed">
|
|
|
|
|
<h2>min_memory_usage() high_performance_seed()</h2>
|
|
|
|
|
<p>Declared in "<a class="reference external" href="../include/libtorrent/session.hpp">libtorrent/session.hpp</a>"</p>
|
|
|
|
|
<pre class="literal-block">
|
|
|
|
|
session_settings <strong>min_memory_usage</strong> ();
|
|
|
|
|
session_settings <strong>high_performance_seed</strong> ();
|
|
|
|
|
</pre>
|
2014-02-02 10:33:19 +01:00
|
|
|
<p>The default values of the <a class="reference external" href="reference-Session.html#session">session</a> settings are set for a regular
|
|
|
|
|
bittorrent client running on a desktop system. There are functions that
|
|
|
|
|
can set the <a class="reference external" href="reference-Session.html#session">session</a> settings to pre set settings for other environments.
|
|
|
|
|
These can be used for the basis, and should be tweaked to fit your needs
|
|
|
|
|
better.</p>
|
|
|
|
|
<p><tt class="docutils literal">min_memory_usage</tt> returns settings that will use the minimal amount of
|
|
|
|
|
RAM, at the potential expense of upload and download performance. It
|
|
|
|
|
adjusts the socket buffer sizes, disables the disk cache, lowers the send
|
|
|
|
|
buffer watermarks so that each connection only has at most one block in
|
|
|
|
|
use at any one time. It lowers the outstanding blocks send to the disk
|
|
|
|
|
I/O thread so that connections only have one block waiting to be flushed
|
|
|
|
|
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
|
|
|
|
|
pieces, instead of reading it all into memory before hashing.</p>
|
|
|
|
|
<p>This configuration is inteded to be the starting point for embedded
|
|
|
|
|
devices. It will significantly reduce memory usage.</p>
|
|
|
|
|
<p><tt class="docutils literal">high_performance_seed</tt> returns settings optimized for a seed box,
|
|
|
|
|
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
|
|
|
|
|
upload rates by allowing large send buffers.</p>
|
2013-12-21 10:54:17 +01:00
|
|
|
</div>
|
|
|
|
|
</div>
|
|
|
|
|
</div>
|
|
|
|
|
<div id="footer">
|
|
|
|
|
<span>Copyright © 2005-2013 Rasterbar Software.</span>
|
|
|
|
|
</div>
|
|
|
|
|
</div>
|
|
|
|
|
<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
|
|
|
|
|
</script>
|
|
|
|
|
<script type="text/javascript">
|
|
|
|
|
_uacct = "UA-1599045-1";
|
|
|
|
|
urchinTracker();
|
|
|
|
|
</script>
|
|
|
|
|
</div>
|
|
|
|
|
</body>
|
|
|
|
|
</html>
|
