Added dht_get_peers and dht_announce at session level.

Refactored dht_put_item to dht_put_immutable_item in session_impl since the get operations are not overloaded (consistency).
Added allow_threading_guard to add_dht_node python binding.
Making dht_put_item in session returns a zeroed hash if TORRENT_DISABLE_DHT (avoid unnecessary calculation and it's more consistent).
Added missing DHT operations to the python binding.
Added missing allow_threading_guard to add_dht_node in the python binding.
This commit is contained in:
Alden Torres 2015-07-06 13:14:28 -04:00
parent 42638c3540
commit a856ae6e9b
5 changed files with 1915 additions and 15 deletions

View File

@ -55,6 +55,7 @@ namespace
#ifndef TORRENT_DISABLE_DHT
void add_dht_node(lt::session& s, tuple n)
{
allow_threading_guard guard;
std::string ip = extract<std::string>(n[0]);
int port = extract<int>(n[1]);
s.add_dht_node(std::make_pair(ip, port));
@ -65,7 +66,34 @@ namespace
allow_threading_guard guard;
return s.add_dht_router(std::make_pair(router_, port_));
}
#endif
void dht_get_immutable_item(lt::session& s, sha1_hash const& target)
{
allow_threading_guard guard;
s.dht_get_item(target);
}
void dht_get_mutable_item(lt::session& s, boost::array<char, 32> key, std::string salt)
{
allow_threading_guard guard;
s.dht_get_item(key, salt);
}
sha1_hash dht_put_immutable_item(lt::session& s, entry data)
{
allow_threading_guard guard;
return s.dht_put_item(data);
}
void dht_put_mutable_item(lt::session& s
, boost::array<char, 32> key
, boost::function<void(entry&, boost::array<char,64>&, boost::uint64_t&, std::string const&)> cb
, std::string salt)
{
allow_threading_guard guard;
s.dht_put_item(key, cb, salt);
}
#endif // TORRENT_DISABLE_DHT
void add_extension(lt::session& s, object const& e)
{
@ -659,7 +687,7 @@ void bind_session()
.def("is_listening", allow_threads(&lt::session::is_listening))
.def("listen_port", allow_threads(&lt::session::listen_port))
#ifndef TORRENT_DISABLE_DHT
.def("add_dht_node", add_dht_node)
.def("add_dht_node", &add_dht_node)
.def(
"add_dht_router", &add_dht_router
, (arg("router"), "port")
@ -667,7 +695,13 @@ void bind_session()
.def("is_dht_running", allow_threads(&lt::session::is_dht_running))
.def("set_dht_settings", allow_threads(&lt::session::set_dht_settings))
.def("get_dht_settings", allow_threads(&lt::session::get_dht_settings))
#endif
.def("dht_get_immutable_item", &dht_get_immutable_item)
.def("dht_get_mutable_item", &dht_get_mutable_item)
.def("dht_put_immutable_item", &dht_put_immutable_item)
.def("dht_put_mutable_item", &dht_put_mutable_item)
.def("dht_get_peers", allow_threads(&lt::session::dht_get_peers))
.def("dht_announce", allow_threads(&lt::session::dht_announce))
#endif // TORRENT_DISABLE_DHT
.def("add_torrent", &add_torrent)
.def("async_add_torrent", &async_add_torrent)
#ifndef BOOST_NO_EXCEPTIONS

View File

@ -307,7 +307,7 @@ namespace libtorrent
void dht_get_mutable_item(boost::array<char, 32> key
, std::string salt = std::string());
void dht_put_item(entry data, sha1_hash target);
void dht_put_immutable_item(entry data, sha1_hash target);
void dht_put_mutable_item(boost::array<char, 32> key
, boost::function<void(entry&, boost::array<char,64>&

File diff suppressed because it is too large Load Diff

View File

@ -58,7 +58,6 @@ POSSIBILITY OF SUCH DAMAGE.
#include "libtorrent/hasher.hpp"
#include "libtorrent/entry.hpp"
#include "libtorrent/session.hpp"
#include "libtorrent/session_handle.hpp"
#include "libtorrent/fingerprint.hpp"
#include "libtorrent/entry.hpp"
#include "libtorrent/alert_types.hpp"
@ -339,6 +338,42 @@ namespace libtorrent
#define TORRENT_ASYNC_CALL(x) \
m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl.get()))
#define TORRENT_ASYNC_CALL1(x, a1) \
m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl.get(), a1))
#define TORRENT_ASYNC_CALL2(x, a1, a2) \
m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl.get(), a1, a2))
#define TORRENT_ASYNC_CALL3(x, a1, a2, a3) \
m_impl->get_io_service().dispatch(boost::bind(&session_impl:: x, m_impl.get(), a1, a2, a3))
#define TORRENT_SYNC_CALL(x) \
aux::sync_call(*m_impl, boost::function<void(void)>(boost::bind(&session_impl:: x, m_impl.get())))
#define TORRENT_SYNC_CALL1(x, a1) \
aux::sync_call(*m_impl, boost::function<void(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1)))
#define TORRENT_SYNC_CALL2(x, a1, a2) \
aux::sync_call(*m_impl, boost::function<void(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1, a2)))
#define TORRENT_SYNC_CALL3(x, a1, a2, a3) \
aux::sync_call(*m_impl, boost::function<void(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1, a2, a3)))
#define TORRENT_SYNC_CALL4(x, a1, a2, a3, a4) \
aux::sync_call(*m_impl, boost::function<void(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1, a2, a3, a4)))
#define TORRENT_SYNC_CALL_RET(type, x) \
aux::sync_call_ret<type>(*m_impl, boost::function<type(void)>(boost::bind(&session_impl:: x, m_impl.get())))
#define TORRENT_SYNC_CALL_RET1(type, x, a1) \
aux::sync_call_ret<type>(*m_impl, boost::function<type(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1)))
#define TORRENT_SYNC_CALL_RET2(type, x, a1, a2) \
aux::sync_call_ret<type>(*m_impl, boost::function<type(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1, a2)))
#define TORRENT_SYNC_CALL_RET3(type, x, a1, a2, a3) \
aux::sync_call_ret<type>(*m_impl, boost::function<type(void)>(boost::bind(&session_impl:: x, m_impl.get(), a1, a2, a3)))
#ifndef TORRENT_CFG
#error TORRENT_CFG is not defined!
#endif
@ -373,7 +408,6 @@ namespace libtorrent
}
m_impl = boost::make_shared<session_impl>(boost::ref(*ios));
*static_cast<session_handle*>(this) = session_handle(m_impl.get());
#ifndef TORRENT_DISABLE_EXTENSIONS
if (flags & add_default_plugins)
@ -405,6 +439,864 @@ namespace libtorrent
m_thread->join();
}
void session::save_state(entry& e, boost::uint32_t flags) const
{
TORRENT_SYNC_CALL2(save_state, &e, flags);
}
void session::load_state(bdecode_node const& e)
{
// this needs to be synchronized since the lifespan
// of e is tied to the caller
TORRENT_SYNC_CALL1(load_state, &e);
}
#ifndef TORRENT_NO_DEPRECATE
feed_handle session::add_feed(feed_settings const& feed)
{
// if you have auto-download enabled, you must specify a download directory!
TORRENT_ASSERT_PRECOND(!feed.auto_download || !feed.add_args.save_path.empty());
return TORRENT_SYNC_CALL_RET1(feed_handle, add_feed, feed);
}
void session::remove_feed(feed_handle h)
{
TORRENT_ASYNC_CALL1(remove_feed, h);
}
void session::get_feeds(std::vector<feed_handle>& f) const
{
f.clear();
TORRENT_SYNC_CALL1(get_feeds, &f);
}
#endif
void session::set_load_function(user_load_function_t fun)
{
TORRENT_ASYNC_CALL1(set_load_function, fun);
}
void session::add_extension(boost::function<boost::shared_ptr<torrent_plugin>(torrent*, void*)> ext)
{
#ifndef TORRENT_DISABLE_EXTENSIONS
TORRENT_ASYNC_CALL1(add_extension, ext);
#endif
}
void session::add_extension(boost::shared_ptr<plugin> ext)
{
#ifndef TORRENT_DISABLE_EXTENSIONS
TORRENT_ASYNC_CALL1(add_ses_extension, ext);
#endif
}
#ifndef TORRENT_NO_DEPRECATE
void session::load_asnum_db(char const*) {}
void session::load_country_db(char const*) {}
int session::as_for_ip(address const&)
{ return 0; }
#if TORRENT_USE_WSTRING
void session::load_asnum_db(wchar_t const*) {}
void session::load_country_db(wchar_t const*) {}
#endif // TORRENT_USE_WSTRING
void session::load_state(entry const& ses_state)
{
if (ses_state.type() == entry::undefined_t) return;
std::vector<char> buf;
bencode(std::back_inserter(buf), ses_state);
bdecode_node e;
error_code ec;
#if defined TORRENT_DEBUG || TORRENT_RELEASE_ASSERTS || !defined BOOST_NO_EXCEPTIONS
int ret =
#endif
bdecode(&buf[0], &buf[0] + buf.size(), e, ec);
TORRENT_ASSERT(ret == 0);
#ifndef BOOST_NO_EXCEPTIONS
if (ret != 0) throw libtorrent_exception(ec);
#endif
TORRENT_SYNC_CALL1(load_state, &e);
}
void session::load_state(lazy_entry const& ses_state)
{
if (ses_state.type() == lazy_entry::none_t) return;
std::pair<char const*, int> buf = ses_state.data_section();
bdecode_node e;
error_code ec;
#if defined TORRENT_DEBUG || TORRENT_RELEASE_ASSERTS || !defined BOOST_NO_EXCEPTIONS
int ret =
#endif
bdecode(buf.first, buf.first + buf.second, e, ec);
TORRENT_ASSERT(ret == 0);
#ifndef BOOST_NO_EXCEPTIONS
if (ret != 0) throw libtorrent_exception(ec);
#endif
TORRENT_SYNC_CALL1(load_state, &e);
}
entry session::state() const
{
entry ret;
TORRENT_SYNC_CALL2(save_state, &ret, 0xffffffff);
return ret;
}
#endif // TORRENT_NO_DEPRECATE
void session::set_ip_filter(ip_filter const& f)
{
boost::shared_ptr<ip_filter> copy = boost::make_shared<ip_filter>(f);
TORRENT_ASYNC_CALL1(set_ip_filter, copy);
}
ip_filter session::get_ip_filter() const
{
return TORRENT_SYNC_CALL_RET(ip_filter, get_ip_filter);
}
void session::set_port_filter(port_filter const& f)
{
TORRENT_ASYNC_CALL1(set_port_filter, f);
}
#ifndef TORRENT_NO_DEPRECATE
void session::set_peer_id(peer_id const& id)
{
settings_pack p;
p.set_str(settings_pack::peer_fingerprint, id.to_string());
apply_settings(p);
}
#endif
peer_id session::id() const
{
return TORRENT_SYNC_CALL_RET(peer_id, get_peer_id);
}
io_service& session::get_io_service()
{
return m_impl->get_io_service();
}
void session::set_key(int key)
{
TORRENT_ASYNC_CALL1(set_key, key);
}
void session::get_torrent_status(std::vector<torrent_status>* ret
, boost::function<bool(torrent_status const&)> const& pred
, boost::uint32_t flags) const
{
TORRENT_SYNC_CALL3(get_torrent_status, ret, boost::ref(pred), flags);
}
void session::refresh_torrent_status(std::vector<torrent_status>* ret
, boost::uint32_t flags) const
{
TORRENT_SYNC_CALL2(refresh_torrent_status, ret, flags);
}
void session::post_torrent_updates(boost::uint32_t flags)
{
TORRENT_ASYNC_CALL1(post_torrent_updates, flags);
}
void session::post_session_stats()
{
TORRENT_ASYNC_CALL(post_session_stats);
}
void session::post_dht_stats()
{
TORRENT_ASYNC_CALL(post_dht_stats);
}
std::vector<torrent_handle> session::get_torrents() const
{
return TORRENT_SYNC_CALL_RET(std::vector<torrent_handle>, get_torrents);
}
torrent_handle session::find_torrent(sha1_hash const& info_hash) const
{
return TORRENT_SYNC_CALL_RET1(torrent_handle, find_torrent_handle, info_hash);
}
#ifndef BOOST_NO_EXCEPTIONS
torrent_handle session::add_torrent(add_torrent_params const& params)
{
error_code ec;
torrent_handle r = TORRENT_SYNC_CALL_RET2(torrent_handle, add_torrent, params, boost::ref(ec));
if (ec) throw libtorrent_exception(ec);
return r;
}
#endif
torrent_handle session::add_torrent(add_torrent_params const& params, error_code& ec)
{
ec.clear();
return TORRENT_SYNC_CALL_RET2(torrent_handle, add_torrent, params, boost::ref(ec));
}
void session::async_add_torrent(add_torrent_params const& params)
{
add_torrent_params* p = new add_torrent_params(params);
#ifndef TORRENT_NO_DEPRECATE
if (params.tracker_url)
{
p->trackers.push_back(params.tracker_url);
p->tracker_url = NULL;
}
#endif
TORRENT_ASYNC_CALL1(async_add_torrent, p);
}
#ifndef BOOST_NO_EXCEPTIONS
#ifndef TORRENT_NO_DEPRECATE
// if the torrent already exists, this will throw duplicate_torrent
torrent_handle session::add_torrent(
torrent_info const& ti
, std::string const& save_path
, entry const& resume_data
, storage_mode_t storage_mode
, bool paused
, storage_constructor_type sc)
{
boost::shared_ptr<torrent_info> tip(boost::make_shared<torrent_info>(ti));
add_torrent_params p(sc);
p.ti = tip;
p.save_path = save_path;
if (resume_data.type() != entry::undefined_t)
{
bencode(std::back_inserter(p.resume_data), resume_data);
}
p.storage_mode = storage_mode;
p.paused = paused;
return add_torrent(p);
}
torrent_handle session::add_torrent(
char const* tracker_url
, sha1_hash const& info_hash
, char const* name
, std::string const& save_path
, entry const& resume_data
, storage_mode_t storage_mode
, bool paused
, storage_constructor_type sc
, void* userdata)
{
add_torrent_params p(sc);
p.tracker_url = tracker_url;
p.info_hash = info_hash;
p.save_path = save_path;
p.storage_mode = storage_mode;
p.paused = paused;
p.userdata = userdata;
p.name = name;
if (resume_data.type() != entry::undefined_t)
{
bencode(std::back_inserter(p.resume_data), resume_data);
}
return add_torrent(p);
}
#endif // TORRENT_NO_DEPRECATE
#endif // BOOST_NO_EXCEPTIONS
void session::remove_torrent(const torrent_handle& h, int options)
{
if (!h.is_valid())
#ifdef BOOST_NO_EXCEPTIONS
return;
#else
throw_invalid_handle();
#endif
TORRENT_ASYNC_CALL2(remove_torrent, h, options);
}
#ifndef TORRENT_NO_DEPRECATE
void session::listen_on(
std::pair<int, int> const& port_range
, error_code& ec
, const char* net_interface, int flags)
{
settings_pack p;
std::string interfaces_str;
if (net_interface == NULL || strlen(net_interface) == 0)
net_interface = "0.0.0.0";
interfaces_str = print_endpoint(tcp::endpoint(address::from_string(net_interface, ec), port_range.first));
if (ec) return;
p.set_str(settings_pack::listen_interfaces, interfaces_str);
p.set_int(settings_pack::max_retry_port_bind, port_range.second - port_range.first);
p.set_bool(settings_pack::listen_system_port_fallback, (flags & session::listen_no_system_port) == 0);
apply_settings(p);
}
void session::use_interfaces(char const* interfaces)
{
settings_pack pack;
pack.set_str(settings_pack::outgoing_interfaces, interfaces);
apply_settings(pack);
}
#endif
unsigned short session::listen_port() const
{
return TORRENT_SYNC_CALL_RET(unsigned short, listen_port);
}
unsigned short session::ssl_listen_port() const
{
return TORRENT_SYNC_CALL_RET(unsigned short, ssl_listen_port);
}
void session::pause()
{
TORRENT_ASYNC_CALL(pause);
}
void session::resume()
{
TORRENT_ASYNC_CALL(resume);
}
bool session::is_paused() const
{
return TORRENT_SYNC_CALL_RET(bool, is_paused);
}
#ifndef TORRENT_NO_DEPRECATE
session_status session::status() const
{
return TORRENT_SYNC_CALL_RET(session_status, status);
}
void session::get_cache_info(sha1_hash const& ih
, std::vector<cached_piece_info>& ret) const
{
cache_status st;
get_cache_info(&st, find_torrent(ih));
ret.swap(st.pieces);
}
cache_status session::get_cache_status() const
{
cache_status st;
get_cache_info(&st);
return st;
}
#endif
void session::get_cache_info(cache_status* ret
, torrent_handle h, int flags) const
{
piece_manager* st = 0;
boost::shared_ptr<torrent> t = h.m_torrent.lock();
if (t)
{
if (t->has_storage())
st = &t->storage();
else
flags = session::disk_cache_no_pieces;
}
m_impl->disk_thread().get_cache_info(ret, flags & session::disk_cache_no_pieces, st);
}
#ifndef TORRENT_NO_DEPRECATE
void session::start_dht()
{
settings_pack p;
p.set_bool(settings_pack::enable_dht, true);
apply_settings(p);
}
void session::stop_dht()
{
settings_pack p;
p.set_bool(settings_pack::enable_dht, false);
apply_settings(p);
}
#endif
void session::set_dht_settings(dht_settings const& settings)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL1(set_dht_settings, settings);
#endif
}
dht_settings session::get_dht_settings() const
{
#ifndef TORRENT_DISABLE_DHT
return TORRENT_SYNC_CALL_RET(dht_settings, get_dht_settings);
#else
return dht_settings();
#endif
}
#ifndef TORRENT_NO_DEPRECATE
void session::start_dht(entry const& startup_state)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL1(start_dht, startup_state);
#endif
}
entry session::dht_state() const
{
#ifndef TORRENT_DISABLE_DHT
return TORRENT_SYNC_CALL_RET(entry, dht_state);
#else
return entry();
#endif
}
#endif // TORRENT_NO_DEPRECATE
void session::add_dht_node(std::pair<std::string, int> const& node)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL1(add_dht_node_name, node);
#endif
}
void session::add_dht_router(std::pair<std::string, int> const& node)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL1(add_dht_router, node);
#endif
}
bool session::is_dht_running() const
{
#ifndef TORRENT_DISABLE_DHT
return TORRENT_SYNC_CALL_RET(bool, is_dht_running);
#else
return false;
#endif
}
void session::dht_get_item(sha1_hash const& target)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL1(dht_get_immutable_item, target);
#endif
}
void session::dht_get_item(boost::array<char, 32> key
, std::string salt)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL2(dht_get_mutable_item, key, salt);
#endif
}
sha1_hash session::dht_put_item(entry data)
{
#ifndef TORRENT_DISABLE_DHT
std::vector<char> buf;
bencode(std::back_inserter(buf), data);
sha1_hash ret = hasher(&buf[0], buf.size()).final();
TORRENT_ASYNC_CALL2(dht_put_immutable_item, data, ret);
return ret;
#else
return sha1_hash();
#endif
}
void session::dht_put_item(boost::array<char, 32> key
, boost::function<void(entry&, boost::array<char,64>&
, boost::uint64_t&, std::string const&)> cb
, std::string salt)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL3(dht_put_mutable_item, key, cb, salt);
#endif
}
void session::dht_get_peers(sha1_hash const& info_hash)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL1(dht_get_peers, info_hash);
#endif
}
void session::dht_announce(sha1_hash const& info_hash, int port, int flags)
{
#ifndef TORRENT_DISABLE_DHT
TORRENT_ASYNC_CALL3(dht_announce, info_hash, port, flags);
#endif
}
#ifndef TORRENT_NO_DEPRECATE
void session::set_pe_settings(pe_settings const& r)
{
settings_pack pack;
pack.set_bool(settings_pack::prefer_rc4, r.prefer_rc4);
pack.set_int(settings_pack::out_enc_policy, r.out_enc_policy);
pack.set_int(settings_pack::in_enc_policy, r.in_enc_policy);
pack.set_int(settings_pack::allowed_enc_level, r.allowed_enc_level);
apply_settings(pack);
}
pe_settings session::get_pe_settings() const
{
settings_pack sett = get_settings();
pe_settings r;
r.prefer_rc4 = sett.get_bool(settings_pack::prefer_rc4);
r.out_enc_policy = sett.get_int(settings_pack::out_enc_policy);
r.in_enc_policy = sett.get_int(settings_pack::in_enc_policy);
r.allowed_enc_level = sett.get_int(settings_pack::allowed_enc_level);
return r;
}
#endif // TORRENT_NO_DEPRECATE
void session::set_peer_class_filter(ip_filter const& f)
{
TORRENT_ASYNC_CALL1(set_peer_class_filter, f);
}
void session::set_peer_class_type_filter(peer_class_type_filter const& f)
{
TORRENT_ASYNC_CALL1(set_peer_class_type_filter, f);
}
int session::create_peer_class(char const* name)
{
return TORRENT_SYNC_CALL_RET1(int, create_peer_class, name);
}
void session::delete_peer_class(int cid)
{
TORRENT_ASYNC_CALL1(delete_peer_class, cid);
}
peer_class_info session::get_peer_class(int cid)
{
return TORRENT_SYNC_CALL_RET1(peer_class_info, get_peer_class, cid);
}
void session::set_peer_class(int cid, peer_class_info const& pci)
{
TORRENT_ASYNC_CALL2(set_peer_class, cid, pci);
}
bool session::is_listening() const
{
return TORRENT_SYNC_CALL_RET(bool, is_listening);
}
#ifndef TORRENT_NO_DEPRECATE
void session::set_settings(session_settings const& s)
{
TORRENT_ASYNC_CALL1(set_settings, s);
}
session_settings session::settings() const
{
return TORRENT_SYNC_CALL_RET(session_settings, deprecated_settings);
}
#endif
void session::apply_settings(settings_pack const& s)
{
boost::shared_ptr<settings_pack> copy = boost::make_shared<settings_pack>(s);
TORRENT_ASYNC_CALL1(apply_settings_pack, copy);
}
settings_pack session::get_settings() const
{
return TORRENT_SYNC_CALL_RET(settings_pack, get_settings);
}
#ifndef TORRENT_NO_DEPRECATE
void session::set_proxy(proxy_settings const& s)
{
settings_pack pack;
pack.set_str(settings_pack::proxy_hostname, s.hostname);
pack.set_str(settings_pack::proxy_username, s.username);
pack.set_str(settings_pack::proxy_password, s.password);
pack.set_int(settings_pack::proxy_type, s.type);
pack.set_int(settings_pack::proxy_port, s.port);
pack.set_bool(settings_pack::proxy_hostnames,s.proxy_hostnames);
pack.set_bool(settings_pack::proxy_peer_connections, s.proxy_peer_connections);
apply_settings(pack);
}
proxy_settings session::proxy() const
{
settings_pack sett = get_settings();
return proxy_settings(sett);
}
void session::set_peer_proxy(proxy_settings const& s)
{
set_proxy(s);
}
void session::set_web_seed_proxy(proxy_settings const& s)
{
set_proxy(s);
}
void session::set_tracker_proxy(proxy_settings const& s)
{
set_proxy(s);
}
proxy_settings session::peer_proxy() const
{
return proxy();
}
proxy_settings session::web_seed_proxy() const
{
return proxy();
}
proxy_settings session::tracker_proxy() const
{
return proxy();
}
void session::set_dht_proxy(proxy_settings const& s)
{
set_proxy(s);
}
proxy_settings session::dht_proxy() const
{
return proxy();
}
void session::set_i2p_proxy(proxy_settings const& s)
{
settings_pack pack;
pack.set_str(settings_pack::i2p_hostname, s.hostname);
pack.set_int(settings_pack::i2p_port, s.port);
apply_settings(pack);
}
proxy_settings session::i2p_proxy() const
{
proxy_settings ret;
settings_pack sett = get_settings();
ret.hostname = sett.get_str(settings_pack::i2p_hostname);
ret.port = sett.get_int(settings_pack::i2p_port);
return ret;
}
void session::set_max_half_open_connections(int) {}
int session::max_half_open_connections() const { return 8; }
int session::max_uploads() const
{
return TORRENT_SYNC_CALL_RET(int, max_uploads);
}
void session::set_max_uploads(int limit)
{
TORRENT_ASYNC_CALL1(set_max_uploads, limit);
}
int session::max_connections() const
{
return TORRENT_SYNC_CALL_RET(int, max_connections);
}
void session::set_max_connections(int limit)
{
TORRENT_ASYNC_CALL1(set_max_connections, limit);
}
int session::local_upload_rate_limit() const
{
return TORRENT_SYNC_CALL_RET(int, local_upload_rate_limit);
}
int session::local_download_rate_limit() const
{
return TORRENT_SYNC_CALL_RET(int, local_download_rate_limit);
}
int session::upload_rate_limit() const
{
return TORRENT_SYNC_CALL_RET(int, upload_rate_limit);
}
int session::download_rate_limit() const
{
return TORRENT_SYNC_CALL_RET(int, download_rate_limit);
}
void session::set_local_upload_rate_limit(int bytes_per_second)
{
TORRENT_ASYNC_CALL1(set_local_upload_rate_limit, bytes_per_second);
}
void session::set_local_download_rate_limit(int bytes_per_second)
{
TORRENT_ASYNC_CALL1(set_local_download_rate_limit, bytes_per_second);
}
void session::set_upload_rate_limit(int bytes_per_second)
{
TORRENT_ASYNC_CALL1(set_upload_rate_limit, bytes_per_second);
}
void session::set_download_rate_limit(int bytes_per_second)
{
TORRENT_ASYNC_CALL1(set_download_rate_limit, bytes_per_second);
}
int session::num_uploads() const
{
return TORRENT_SYNC_CALL_RET(int, num_uploads);
}
int session::num_connections() const
{
return TORRENT_SYNC_CALL_RET(int, num_connections);
}
void session::set_alert_dispatch(boost::function<void(std::auto_ptr<alert>)> const& fun)
{
m_impl->alerts().set_dispatch_function(fun);
}
#endif // TORRENT_NO_DEPRECATE
alert* session::wait_for_alert(time_duration max_wait)
{
return m_impl->wait_for_alert(max_wait);
}
// the alerts are const, they may not be deleted by the client
void session::pop_alerts(std::vector<alert*>* alerts)
{
m_impl->pop_alerts(alerts);
}
void session::set_alert_notify(boost::function<void()> const& fun)
{
m_impl->alerts().set_notify_function(fun);
}
#ifndef TORRENT_NO_DEPRECATE
void session::pop_alerts(std::deque<alert*>* alerts)
{
m_impl->pop_alerts(alerts);
}
std::auto_ptr<alert> session::pop_alert()
{
alert const* a = m_impl->pop_alert();
if (a == NULL) return std::auto_ptr<alert>();
return a->clone();
}
void session::set_alert_mask(boost::uint32_t m)
{
settings_pack p;
p.set_int(settings_pack::alert_mask, m);
apply_settings(p);
}
boost::uint32_t session::get_alert_mask() const
{
return get_settings().get_int(settings_pack::alert_mask);
}
size_t session::set_alert_queue_size_limit(size_t queue_size_limit_)
{
return TORRENT_SYNC_CALL_RET1(size_t, set_alert_queue_size_limit, queue_size_limit_);
}
void session::set_severity_level(alert::severity_t s)
{
int m = 0;
switch (s)
{
case alert::debug: m = alert::all_categories; break;
case alert::info: m = alert::all_categories & ~(alert::debug_notification
| alert::progress_notification | alert::dht_notification); break;
case alert::warning: m = alert::all_categories & ~(alert::debug_notification
| alert::status_notification | alert::progress_notification
| alert::dht_notification); break;
case alert::critical: m = alert::error_notification | alert::storage_notification; break;
case alert::fatal: m = alert::error_notification; break;
default: break;
}
settings_pack p;
p.set_int(settings_pack::alert_mask, m);
apply_settings(p);
}
void session::start_lsd()
{
settings_pack p;
p.set_bool(settings_pack::enable_lsd, true);
apply_settings(p);
}
void session::start_natpmp()
{
settings_pack p;
p.set_bool(settings_pack::enable_natpmp, true);
apply_settings(p);
}
void session::start_upnp()
{
settings_pack p;
p.set_bool(settings_pack::enable_upnp, true);
apply_settings(p);
}
void session::stop_lsd()
{
settings_pack p;
p.set_bool(settings_pack::enable_lsd, false);
apply_settings(p);
}
void session::stop_natpmp()
{
settings_pack p;
p.set_bool(settings_pack::enable_natpmp, false);
apply_settings(p);
}
void session::stop_upnp()
{
settings_pack p;
p.set_bool(settings_pack::enable_upnp, false);
apply_settings(p);
}
#endif // TORRENT_NO_DEPRECATED
int session::add_port_mapping(protocol_type t, int external_port, int local_port)
{
return TORRENT_SYNC_CALL_RET3(int, add_port_mapping, int(t), external_port, local_port);
}
void session::delete_port_mapping(int handle)
{
TORRENT_ASYNC_CALL1(delete_port_mapping, handle);
}
#ifndef TORRENT_NO_DEPRECATE
session_settings::session_settings(std::string const& user_agent_)
{

View File

@ -5496,7 +5496,7 @@ retry:
namespace {
void on_dht_put(alert_manager& alerts, sha1_hash target)
void on_dht_put_immutable_item(alert_manager& alerts, sha1_hash target)
{
if (alerts.should_post<dht_put_alert>())
alerts.emplace_alert<dht_put_alert>(target);
@ -5526,10 +5526,10 @@ retry:
} // anonymous namespace
void session_impl::dht_put_item(entry data, sha1_hash target)
void session_impl::dht_put_immutable_item(entry data, sha1_hash target)
{
if (!m_dht) return;
m_dht->put_item(data, boost::bind(&on_dht_put, boost::ref(m_alerts)
m_dht->put_item(data, boost::bind(&on_dht_put_immutable_item, boost::ref(m_alerts)
, target));
}