2007-04-07 05:37:23 +02:00
|
|
|
// Copyright Daniel Wallin, Arvid Norberg 2006. Use, modification and distribution is
|
2007-01-10 17:11:43 +01:00
|
|
|
// subject to the Boost Software License, Version 1.0. (See accompanying
|
|
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
|
2011-11-08 06:53:13 +01:00
|
|
|
#include <list>
|
|
|
|
#include <string>
|
2007-01-10 17:11:43 +01:00
|
|
|
#include <libtorrent/session.hpp>
|
2007-04-07 05:37:23 +02:00
|
|
|
#include <libtorrent/storage.hpp>
|
2014-08-27 09:47:39 +02:00
|
|
|
#include <libtorrent/error_code.hpp>
|
2008-02-17 21:55:03 +01:00
|
|
|
#include <libtorrent/ip_filter.hpp>
|
2009-06-26 01:05:12 +02:00
|
|
|
#include <libtorrent/disk_io_thread.hpp>
|
2014-07-06 21:18:00 +02:00
|
|
|
#include <libtorrent/aux_/session_settings.hpp>
|
2012-09-19 08:13:04 +02:00
|
|
|
#include <libtorrent/extensions.hpp>
|
2015-03-12 06:20:12 +01:00
|
|
|
#include <libtorrent/bdecode.hpp>
|
2013-10-10 07:53:44 +02:00
|
|
|
#include <libtorrent/bencode.hpp>
|
2016-02-16 20:20:04 +01:00
|
|
|
#include <libtorrent/read_resume_data.hpp>
|
2014-03-25 07:23:10 +01:00
|
|
|
#include <libtorrent/aux_/session_impl.hpp> // for settings_map()
|
2015-09-18 06:23:45 +02:00
|
|
|
#include <libtorrent/torrent_info.hpp>
|
2015-11-08 19:08:03 +01:00
|
|
|
#include <libtorrent/kademlia/item.hpp> // for sign_mutable_item
|
2012-10-13 04:08:34 +02:00
|
|
|
|
|
|
|
#include <libtorrent/extensions/lt_trackers.hpp>
|
|
|
|
#include <libtorrent/extensions/metadata_transfer.hpp>
|
|
|
|
#include <libtorrent/extensions/smart_ban.hpp>
|
|
|
|
#include <libtorrent/extensions/ut_metadata.hpp>
|
|
|
|
#include <libtorrent/extensions/ut_pex.hpp>
|
|
|
|
|
2007-01-10 17:11:43 +01:00
|
|
|
#include "gil.hpp"
|
2014-09-13 00:38:07 +02:00
|
|
|
#include "bytes.hpp"
|
2007-01-10 17:11:43 +01:00
|
|
|
|
2015-11-20 05:37:45 +01:00
|
|
|
#include "libtorrent/aux_/disable_warnings_push.hpp"
|
|
|
|
|
2016-04-08 04:45:23 +02:00
|
|
|
#include "boost_python.hpp"
|
2015-09-02 07:30:40 +02:00
|
|
|
|
2015-11-20 05:37:45 +01:00
|
|
|
#include "libtorrent/aux_/disable_warnings_pop.hpp"
|
|
|
|
|
2007-01-10 17:11:43 +01:00
|
|
|
using namespace boost::python;
|
|
|
|
using namespace libtorrent;
|
2014-07-06 21:18:00 +02:00
|
|
|
namespace lt = libtorrent;
|
2007-01-10 17:11:43 +01:00
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
2014-07-06 21:18:00 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
|
|
|
void listen_on(lt::session& s, int min_, int max_, char const* interface, int flags)
|
2009-05-31 22:46:40 +02:00
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
2012-09-11 19:20:31 +02:00
|
|
|
error_code ec;
|
2011-08-14 01:30:11 +02:00
|
|
|
s.listen_on(std::make_pair(min_, max_), ec, interface, flags);
|
2014-08-31 23:17:32 +02:00
|
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
2012-09-11 19:20:31 +02:00
|
|
|
if (ec) throw libtorrent_exception(ec);
|
2014-08-31 23:17:32 +02:00
|
|
|
#endif
|
2009-05-31 22:46:40 +02:00
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
#endif
|
2007-01-10 17:11:43 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
void outgoing_ports(lt::session& s, int _min, int _max)
|
2009-05-31 22:46:40 +02:00
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
2015-06-07 06:23:30 +02:00
|
|
|
settings_pack p;
|
|
|
|
p.set_int(settings_pack::outgoing_port, _min);
|
|
|
|
p.set_int(settings_pack::num_outgoing_ports, _max - _min);
|
2014-07-06 21:18:00 +02:00
|
|
|
s.apply_settings(p);
|
2009-05-31 22:46:40 +02:00
|
|
|
return;
|
|
|
|
}
|
2008-03-10 04:19:57 +01:00
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
2014-07-06 21:18:00 +02:00
|
|
|
void add_dht_node(lt::session& s, tuple n)
|
2013-05-03 10:24:26 +02:00
|
|
|
{
|
|
|
|
std::string ip = extract<std::string>(n[0]);
|
|
|
|
int port = extract<int>(n[1]);
|
2015-07-12 17:05:06 +02:00
|
|
|
allow_threading_guard guard;
|
2013-05-03 10:24:26 +02:00
|
|
|
s.add_dht_node(std::make_pair(ip, port));
|
|
|
|
}
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
void add_dht_router(lt::session& s, std::string router_, int port_)
|
2009-05-31 22:46:40 +02:00
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
return s.add_dht_router(std::make_pair(router_, port_));
|
|
|
|
}
|
2015-07-06 19:14:28 +02:00
|
|
|
|
|
|
|
#endif // TORRENT_DISABLE_DHT
|
2008-02-17 22:12:06 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
void add_extension(lt::session& s, object const& e)
|
2012-10-13 04:08:34 +02:00
|
|
|
{
|
2013-12-21 07:20:16 +01:00
|
|
|
#ifndef TORRENT_DISABLE_EXTENSIONS
|
2012-10-13 04:08:34 +02:00
|
|
|
if (!extract<std::string>(e).check()) return;
|
|
|
|
|
|
|
|
std::string name = extract<std::string>(e);
|
|
|
|
if (name == "ut_metadata")
|
|
|
|
s.add_extension(create_ut_metadata_plugin);
|
|
|
|
else if (name == "ut_pex")
|
|
|
|
s.add_extension(create_ut_pex_plugin);
|
|
|
|
else if (name == "smart_ban")
|
|
|
|
s.add_extension(create_smart_ban_plugin);
|
|
|
|
else if (name == "lt_trackers")
|
|
|
|
s.add_extension(create_lt_trackers_plugin);
|
2014-03-17 04:41:35 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2012-10-13 04:08:34 +02:00
|
|
|
else if (name == "metadata_transfer")
|
|
|
|
s.add_extension(create_metadata_plugin);
|
2014-03-17 04:41:35 +01:00
|
|
|
#endif // TORRENT_NO_DEPRECATE
|
|
|
|
|
2013-12-21 07:20:16 +01:00
|
|
|
#endif // TORRENT_DISABLE_EXTENSIONS
|
2012-10-13 04:08:34 +02:00
|
|
|
}
|
|
|
|
|
2016-01-05 07:32:04 +01:00
|
|
|
void make_settings_pack(lt::settings_pack& p, dict const& sett_dict)
|
2010-12-26 09:03:02 +01:00
|
|
|
{
|
2016-01-11 04:53:54 +01:00
|
|
|
list iterkeys = (list)sett_dict.keys();
|
2016-04-27 18:28:22 +02:00
|
|
|
int const len = boost::python::len(iterkeys);
|
|
|
|
for (int i = 0; i < len; i++)
|
2010-12-26 09:03:02 +01:00
|
|
|
{
|
2016-04-27 18:28:22 +02:00
|
|
|
std::string const key = extract<std::string>(iterkeys[i]);
|
2010-12-26 09:03:02 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
int sett = setting_by_name(key);
|
2016-04-27 18:28:22 +02:00
|
|
|
if (sett < 0) continue;
|
2014-07-06 21:18:00 +02:00
|
|
|
|
|
|
|
TORRENT_TRY
|
2010-12-26 09:03:02 +01:00
|
|
|
{
|
2016-04-27 18:28:22 +02:00
|
|
|
object const value = sett_dict[key];
|
2014-07-06 21:18:00 +02:00
|
|
|
switch (sett & settings_pack::type_mask)
|
|
|
|
{
|
|
|
|
case settings_pack::string_type_base:
|
|
|
|
p.set_str(sett, extract<std::string>(value));
|
|
|
|
break;
|
|
|
|
case settings_pack::int_type_base:
|
|
|
|
p.set_int(sett, extract<int>(value));
|
|
|
|
break;
|
|
|
|
case settings_pack::bool_type_base:
|
|
|
|
p.set_bool(sett, extract<bool>(value));
|
|
|
|
break;
|
|
|
|
}
|
2010-12-26 09:03:02 +01:00
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
TORRENT_CATCH(...) {}
|
2010-12-26 09:03:02 +01:00
|
|
|
}
|
2016-01-05 07:32:04 +01:00
|
|
|
}
|
2010-12-26 09:03:02 +01:00
|
|
|
|
2016-01-05 07:32:04 +01:00
|
|
|
boost::shared_ptr<lt::session> make_session(boost::python::dict sett, int flags)
|
|
|
|
{
|
|
|
|
settings_pack p;
|
|
|
|
make_settings_pack(p, sett);
|
|
|
|
return boost::make_shared<lt::session>(p, flags);
|
|
|
|
}
|
2012-12-14 05:38:44 +01:00
|
|
|
|
2016-04-04 06:52:21 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
|
|
|
void session_set_settings(lt::session& ses, object const& sett)
|
|
|
|
{
|
|
|
|
extract<session_settings> old_settings(sett);
|
|
|
|
if (old_settings.check())
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
ses.set_settings(old_settings);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
settings_pack p;
|
|
|
|
make_settings_pack(p, extract<dict>(sett));
|
|
|
|
allow_threading_guard guard;
|
|
|
|
ses.apply_settings(p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
void session_apply_settings(lt::session& ses, dict const& sett_dict)
|
2016-01-05 07:32:04 +01:00
|
|
|
{
|
|
|
|
settings_pack p;
|
|
|
|
make_settings_pack(p, sett_dict);
|
|
|
|
allow_threading_guard guard;
|
2014-07-06 21:18:00 +02:00
|
|
|
ses.apply_settings(p);
|
2010-12-26 09:03:02 +01:00
|
|
|
}
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
dict session_get_settings(lt::session const& ses)
|
2010-12-26 09:03:02 +01:00
|
|
|
{
|
2015-06-07 06:23:30 +02:00
|
|
|
settings_pack sett;
|
2012-09-11 19:20:31 +02:00
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
2014-07-06 21:18:00 +02:00
|
|
|
sett = ses.get_settings();
|
2012-09-11 19:20:31 +02:00
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
dict ret;
|
|
|
|
for (int i = settings_pack::string_type_base;
|
|
|
|
i < settings_pack::max_string_setting_internal; ++i)
|
2010-12-26 09:03:02 +01:00
|
|
|
{
|
2014-07-06 21:18:00 +02:00
|
|
|
ret[name_for_setting(i)] = sett.get_str(i);
|
2010-12-26 09:03:02 +01:00
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
|
|
|
|
for (int i = settings_pack::int_type_base;
|
|
|
|
i < settings_pack::max_int_setting_internal; ++i)
|
|
|
|
{
|
|
|
|
ret[name_for_setting(i)] = sett.get_int(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = settings_pack::bool_type_base;
|
|
|
|
i < settings_pack::max_bool_setting_internal; ++i)
|
|
|
|
{
|
|
|
|
ret[name_for_setting(i)] = sett.get_bool(i);
|
|
|
|
}
|
|
|
|
return ret;
|
2010-12-26 09:03:02 +01:00
|
|
|
}
|
|
|
|
|
2010-08-22 18:45:12 +02:00
|
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
2008-10-28 03:34:14 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2014-07-06 21:18:00 +02:00
|
|
|
torrent_handle add_torrent_depr(lt::session& s, torrent_info const& ti
|
2009-10-26 02:29:39 +01:00
|
|
|
, std::string const& save, entry const& resume
|
2009-05-31 22:46:40 +02:00
|
|
|
, storage_mode_t storage_mode, bool paused)
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
return s.add_torrent(ti, save, resume, storage_mode, paused, default_storage_constructor);
|
|
|
|
}
|
2010-08-22 18:45:12 +02:00
|
|
|
#endif
|
2008-10-28 03:34:14 +01:00
|
|
|
#endif
|
2011-11-08 06:36:22 +01:00
|
|
|
}
|
2008-10-28 03:34:14 +01:00
|
|
|
|
2013-08-27 18:04:19 +02:00
|
|
|
void dict_to_add_torrent_params(dict params, add_torrent_params& p)
|
2009-05-31 22:46:40 +02:00
|
|
|
{
|
2014-07-06 21:18:00 +02:00
|
|
|
// torrent_info objects are always held by a shared_ptr in the python binding
|
2012-07-03 02:59:33 +02:00
|
|
|
if (params.has_key("ti") && params.get("ti") != boost::python::object())
|
2016-04-04 05:50:06 +02:00
|
|
|
{
|
|
|
|
// make a copy here. We don't want to end up holding a python-owned
|
|
|
|
// object inside libtorrent. If the last reference goes out of scope
|
|
|
|
// on the C++ side, it will end up freeing the python object
|
|
|
|
// without holding the GIL and likely crash.
|
|
|
|
// https://mail.python.org/pipermail/cplusplus-sig/2007-June/012130.html
|
|
|
|
p.ti = boost::make_shared<torrent_info>(
|
|
|
|
extract<torrent_info const&>(params["ti"]));
|
|
|
|
}
|
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
|
|
|
|
if (params.has_key("info_hash"))
|
2014-09-13 00:38:07 +02:00
|
|
|
p.info_hash = sha1_hash(bytes(extract<bytes>(params["info_hash"])).arr);
|
2009-05-31 22:46:40 +02:00
|
|
|
if (params.has_key("name"))
|
2012-10-19 07:18:48 +02:00
|
|
|
p.name = extract<std::string>(params["name"]);
|
2009-10-26 02:29:39 +01:00
|
|
|
p.save_path = extract<std::string>(params["save_path"]);
|
2009-05-31 22:46:40 +02:00
|
|
|
|
2016-02-16 20:20:04 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2009-05-31 22:46:40 +02:00
|
|
|
if (params.has_key("resume_data"))
|
|
|
|
{
|
|
|
|
std::string resume = extract<std::string>(params["resume_data"]);
|
2013-08-27 18:04:19 +02:00
|
|
|
p.resume_data.assign(resume.begin(), resume.end());
|
2009-05-31 22:46:40 +02:00
|
|
|
}
|
2016-02-16 20:20:04 +01:00
|
|
|
#endif
|
2009-05-31 22:46:40 +02:00
|
|
|
if (params.has_key("storage_mode"))
|
|
|
|
p.storage_mode = extract<storage_mode_t>(params["storage_mode"]);
|
2011-11-08 06:36:22 +01:00
|
|
|
|
2012-10-13 18:50:07 +02:00
|
|
|
if (params.has_key("trackers"))
|
2012-03-08 10:54:44 +01:00
|
|
|
{
|
|
|
|
list l = extract<list>(params["trackers"]);
|
|
|
|
int n = boost::python::len(l);
|
|
|
|
for(int i = 0; i < n; i++)
|
|
|
|
p.trackers.push_back(extract<std::string>(l[i]));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (params.has_key("dht_nodes"))
|
|
|
|
{
|
|
|
|
list l = extract<list>(params["dht_nodes"]);
|
|
|
|
int n = boost::python::len(l);
|
|
|
|
for(int i = 0; i < n; i++)
|
|
|
|
p.dht_nodes.push_back(extract<std::pair<std::string, int> >(l[i]));
|
|
|
|
}
|
2011-11-08 06:36:22 +01:00
|
|
|
if (params.has_key("flags"))
|
|
|
|
p.flags = extract<boost::uint64_t>(params["flags"]);
|
2010-12-30 02:47:30 +01:00
|
|
|
if (params.has_key("trackerid"))
|
|
|
|
p.trackerid = extract<std::string>(params["trackerid"]);
|
|
|
|
if (params.has_key("url"))
|
|
|
|
p.url = extract<std::string>(params["url"]);
|
2016-02-20 21:49:49 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2011-11-08 06:36:22 +01:00
|
|
|
if (params.has_key("uuid"))
|
|
|
|
p.uuid = extract<std::string>(params["uuid"]);
|
2016-02-20 21:49:49 +01:00
|
|
|
#endif
|
2013-05-04 05:59:52 +02:00
|
|
|
|
|
|
|
if (params.has_key("file_priorities"))
|
|
|
|
{
|
|
|
|
list l = extract<list>(params["file_priorities"]);
|
|
|
|
int n = boost::python::len(l);
|
|
|
|
for(int i = 0; i < n; i++)
|
2013-08-27 18:04:19 +02:00
|
|
|
p.file_priorities.push_back(extract<boost::uint8_t>(l[i]));
|
|
|
|
p.file_priorities.clear();
|
2013-05-04 05:59:52 +02:00
|
|
|
}
|
2011-01-18 04:41:54 +01:00
|
|
|
}
|
|
|
|
|
2011-11-08 06:36:22 +01:00
|
|
|
namespace
|
|
|
|
{
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
torrent_handle add_torrent(lt::session& s, dict params)
|
2011-01-18 04:41:54 +01:00
|
|
|
{
|
|
|
|
add_torrent_params p;
|
2013-08-27 18:04:19 +02:00
|
|
|
dict_to_add_torrent_params(params, p);
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2011-03-07 09:24:02 +01:00
|
|
|
allow_threading_guard guard;
|
|
|
|
|
2010-08-22 18:45:12 +02:00
|
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
2009-05-31 22:46:40 +02:00
|
|
|
return s.add_torrent(p);
|
2010-08-22 18:45:12 +02:00
|
|
|
#else
|
|
|
|
error_code ec;
|
|
|
|
return s.add_torrent(p, ec);
|
|
|
|
#endif
|
2009-05-31 22:46:40 +02:00
|
|
|
}
|
2008-07-01 18:02:17 +02:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
void async_add_torrent(lt::session& s, dict params)
|
2012-10-19 07:18:48 +02:00
|
|
|
{
|
|
|
|
add_torrent_params p;
|
2013-08-27 18:04:19 +02:00
|
|
|
dict_to_add_torrent_params(params, p);
|
2012-10-19 07:18:48 +02:00
|
|
|
|
|
|
|
allow_threading_guard guard;
|
|
|
|
|
|
|
|
s.async_add_torrent(p);
|
|
|
|
}
|
|
|
|
|
2015-04-03 22:15:48 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2014-07-06 21:18:00 +02:00
|
|
|
void start_natpmp(lt::session& s)
|
2008-05-01 07:37:04 +02:00
|
|
|
{
|
2009-05-31 22:46:40 +02:00
|
|
|
allow_threading_guard guard;
|
|
|
|
s.start_natpmp();
|
2008-05-01 07:37:04 +02:00
|
|
|
}
|
2009-05-31 22:46:40 +02:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
void start_upnp(lt::session& s)
|
2008-05-01 07:37:04 +02:00
|
|
|
{
|
2009-05-31 22:46:40 +02:00
|
|
|
allow_threading_guard guard;
|
|
|
|
s.start_upnp();
|
2008-05-01 07:37:04 +02:00
|
|
|
}
|
2016-03-18 18:43:11 +01:00
|
|
|
#endif // TORRENT_NO_DEPRECATE
|
2008-07-01 18:02:17 +02:00
|
|
|
|
2016-01-05 07:32:04 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2016-01-06 06:17:51 +01:00
|
|
|
boost::shared_ptr<alert>
|
2016-01-05 07:32:04 +01:00
|
|
|
#else
|
|
|
|
alert const*
|
|
|
|
#endif
|
|
|
|
wait_for_alert(lt::session& s, int ms)
|
2009-09-25 16:35:28 +02:00
|
|
|
{
|
2011-01-16 23:26:15 +01:00
|
|
|
allow_threading_guard guard;
|
2016-01-05 07:32:04 +01:00
|
|
|
alert const* a = s.wait_for_alert(milliseconds(ms));
|
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
|
|
|
if (a == NULL) return boost::shared_ptr<alert>();
|
|
|
|
return boost::shared_ptr<alert>(a->clone().release());
|
|
|
|
#else
|
|
|
|
return a;
|
|
|
|
#endif
|
2009-09-25 16:35:28 +02:00
|
|
|
}
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
list get_torrents(lt::session& s)
|
2008-07-01 18:02:17 +02:00
|
|
|
{
|
2009-05-31 22:46:40 +02:00
|
|
|
list ret;
|
2012-09-11 19:20:31 +02:00
|
|
|
std::vector<torrent_handle> torrents;
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
torrents = s.get_torrents();
|
|
|
|
}
|
2009-05-31 22:46:40 +02:00
|
|
|
|
|
|
|
for (std::vector<torrent_handle>::iterator i = torrents.begin(); i != torrents.end(); ++i)
|
|
|
|
{
|
|
|
|
ret.append(*i);
|
|
|
|
}
|
|
|
|
return ret;
|
2008-07-01 18:02:17 +02:00
|
|
|
}
|
2008-10-28 07:29:30 +01:00
|
|
|
|
2016-04-04 05:50:06 +02:00
|
|
|
cache_status get_cache_info1(lt::session& s, torrent_handle h, int flags)
|
|
|
|
{
|
|
|
|
cache_status ret;
|
|
|
|
s.get_cache_info(&ret, h, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
|
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2016-04-04 05:50:06 +02:00
|
|
|
cache_status get_cache_status(lt::session& s)
|
|
|
|
{
|
|
|
|
cache_status ret;
|
|
|
|
s.get_cache_info(&ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
|
2013-05-03 10:24:26 +02:00
|
|
|
dict get_utp_stats(session_status const& st)
|
|
|
|
{
|
|
|
|
dict ret;
|
|
|
|
ret["num_idle"] = st.utp_stats.num_idle;
|
|
|
|
ret["num_syn_sent"] = st.utp_stats.num_syn_sent;
|
|
|
|
ret["num_connected"] = st.utp_stats.num_connected;
|
|
|
|
ret["num_fin_sent"] = st.utp_stats.num_fin_sent;
|
|
|
|
ret["num_close_wait"] = st.utp_stats.num_close_wait;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
list get_cache_info2(lt::session& ses, sha1_hash ih)
|
2013-05-05 20:08:03 +02:00
|
|
|
{
|
2014-07-06 21:18:00 +02:00
|
|
|
std::vector<cached_piece_info> ret;
|
|
|
|
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
ses.get_cache_info(ih, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
list pieces;
|
|
|
|
ptime now = time_now();
|
|
|
|
for (std::vector<cached_piece_info>::iterator i = ret.begin()
|
|
|
|
, end(ret.end()); i != end; ++i)
|
|
|
|
{
|
|
|
|
dict d;
|
|
|
|
d["piece"] = i->piece;
|
|
|
|
d["last_use"] = total_milliseconds(now - i->last_use) / 1000.f;
|
|
|
|
d["next_to_hash"] = i->next_to_hash;
|
|
|
|
d["kind"] = i->kind;
|
|
|
|
pieces.append(d);
|
|
|
|
}
|
|
|
|
return pieces;
|
2013-05-05 20:08:03 +02:00
|
|
|
}
|
|
|
|
|
2014-10-05 21:32:29 +02:00
|
|
|
void load_asnum_db(lt::session& s, std::string file) {}
|
|
|
|
void load_country_db(lt::session& s, std::string file) {}
|
2008-04-20 22:12:33 +02:00
|
|
|
#endif
|
2009-12-05 08:24:22 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
entry save_state(lt::session const& s, boost::uint32_t flags)
|
2009-12-05 08:24:22 +01:00
|
|
|
{
|
2011-03-07 09:24:02 +01:00
|
|
|
allow_threading_guard guard;
|
2009-12-05 08:24:22 +01:00
|
|
|
entry e;
|
2010-03-06 18:50:19 +01:00
|
|
|
s.save_state(e, flags);
|
2009-12-05 08:24:22 +01:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
2015-04-03 22:15:48 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2014-07-06 21:18:00 +02:00
|
|
|
object pop_alert(lt::session& ses)
|
2013-07-17 16:27:02 +02:00
|
|
|
{
|
|
|
|
std::auto_ptr<alert> a;
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
a = ses.pop_alert();
|
|
|
|
}
|
|
|
|
|
|
|
|
return object(boost::shared_ptr<alert>(a.release()));
|
|
|
|
}
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
list pop_alerts(lt::session& ses)
|
2013-01-04 18:52:35 +01:00
|
|
|
{
|
2015-04-03 22:15:48 +02:00
|
|
|
std::vector<alert*> alerts;
|
2013-01-04 18:52:35 +01:00
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
ses.pop_alerts(&alerts);
|
|
|
|
}
|
|
|
|
|
|
|
|
list ret;
|
2015-04-03 22:15:48 +02:00
|
|
|
for (std::vector<alert*>::iterator i = alerts.begin()
|
2013-01-04 18:52:35 +01:00
|
|
|
, end(alerts.end()); i != end; ++i)
|
|
|
|
{
|
2016-01-05 07:32:04 +01:00
|
|
|
ret.append(boost::shared_ptr<alert>((*i)->clone().release()));
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
list pop_alerts(lt::session& ses)
|
|
|
|
{
|
|
|
|
std::vector<alert*> alerts;
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
ses.pop_alerts(&alerts);
|
|
|
|
}
|
|
|
|
|
|
|
|
list ret;
|
|
|
|
for (std::vector<alert*>::iterator i = alerts.begin()
|
|
|
|
, end(alerts.end()); i != end; ++i)
|
|
|
|
{
|
|
|
|
ret.append(boost::python::ptr(*i));
|
2013-01-04 18:52:35 +01:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
2016-01-05 07:32:04 +01:00
|
|
|
#endif
|
2013-01-04 18:52:35 +01:00
|
|
|
|
2016-03-05 21:15:22 +01:00
|
|
|
void load_state(lt::session& ses, entry const& st, boost::uint32_t flags)
|
|
|
|
{
|
|
|
|
allow_threading_guard guard;
|
|
|
|
|
|
|
|
std::vector<char> buf;
|
|
|
|
bencode(std::back_inserter(buf), st);
|
|
|
|
bdecode_node e;
|
|
|
|
error_code ec;
|
|
|
|
bdecode(&buf[0], &buf[0] + buf.size(), e, ec);
|
|
|
|
TORRENT_ASSERT(!ec);
|
|
|
|
ses.load_state(e, flags);
|
|
|
|
}
|
2015-11-08 19:08:03 +01:00
|
|
|
|
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
|
|
|
void dht_get_mutable_item(lt::session& ses, std::string key, std::string salt)
|
|
|
|
{
|
|
|
|
TORRENT_ASSERT(key.size() == 32);
|
2016-05-01 05:10:47 +02:00
|
|
|
std::array<char, 32> public_key;
|
2015-11-08 19:08:03 +01:00
|
|
|
std::copy(key.begin(), key.end(), public_key.begin());
|
|
|
|
ses.dht_get_item(public_key, salt);
|
|
|
|
}
|
|
|
|
|
2016-05-01 05:10:47 +02:00
|
|
|
void put_string(entry& e, std::array<char, 64>& sig, boost::uint64_t& seq,
|
2015-11-08 19:08:03 +01:00
|
|
|
std::string const& salt, std::string public_key, std::string private_key,
|
|
|
|
std::string data)
|
|
|
|
{
|
|
|
|
using libtorrent::dht::sign_mutable_item;
|
|
|
|
|
|
|
|
e = data;
|
|
|
|
std::vector<char> buf;
|
|
|
|
bencode(std::back_inserter(buf), e);
|
|
|
|
++seq;
|
|
|
|
sign_mutable_item(std::pair<char const*, int>(&buf[0], buf.size())
|
|
|
|
, std::pair<char const*, int>(&salt[0], salt.size())
|
|
|
|
, seq, public_key.c_str(), private_key.c_str(), sig.data());
|
|
|
|
}
|
|
|
|
|
|
|
|
void dht_put_mutable_item(lt::session& ses, std::string private_key, std::string public_key,
|
|
|
|
std::string data, std::string salt)
|
|
|
|
{
|
|
|
|
TORRENT_ASSERT(private_key.size() == 64);
|
|
|
|
TORRENT_ASSERT(public_key.size() == 32);
|
2016-05-01 05:10:47 +02:00
|
|
|
std::array<char, 32> key;
|
2015-11-08 19:08:03 +01:00
|
|
|
std::copy(public_key.begin(), public_key.end(), key.begin());
|
|
|
|
ses.dht_put_item(key, boost::bind(&put_string, _1, _2, _3, _4
|
|
|
|
, public_key, private_key, data)
|
|
|
|
, salt);
|
|
|
|
}
|
|
|
|
#endif
|
2016-02-16 20:20:04 +01:00
|
|
|
|
|
|
|
add_torrent_params read_resume_data_wrapper(bytes const& b)
|
|
|
|
{
|
|
|
|
error_code ec;
|
|
|
|
add_torrent_params p = read_resume_data(&b.arr[0], b.arr.size(), ec);
|
|
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
|
|
|
if (ec) throw libtorrent_exception(ec);
|
|
|
|
#endif
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2007-01-10 17:11:43 +01:00
|
|
|
} // namespace unnamed
|
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
|
2007-01-10 17:11:43 +01:00
|
|
|
void bind_session()
|
|
|
|
{
|
2015-07-07 01:20:04 +02:00
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
|
|
|
void (lt::session::*dht_get_immutable_item)(sha1_hash const&) = <::session::dht_get_item;
|
|
|
|
sha1_hash (lt::session::*dht_put_immutable_item)(entry data) = <::session::dht_put_item;
|
|
|
|
#endif // TORRENT_DISABLE_DHT
|
|
|
|
|
2010-03-06 18:50:19 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2014-07-06 21:18:00 +02:00
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
|
|
|
void (lt::session::*start_dht0)() = <::session::start_dht;
|
|
|
|
void (lt::session::*start_dht1)(entry const&) = <::session::start_dht;
|
2010-03-06 18:50:19 +01:00
|
|
|
#endif
|
|
|
|
|
2009-05-14 19:24:17 +02:00
|
|
|
class_<session_status>("session_status")
|
|
|
|
.def_readonly("has_incoming_connections", &session_status::has_incoming_connections)
|
2009-05-31 22:46:40 +02:00
|
|
|
|
2009-05-14 19:24:17 +02:00
|
|
|
.def_readonly("upload_rate", &session_status::upload_rate)
|
|
|
|
.def_readonly("download_rate", &session_status::download_rate)
|
|
|
|
.def_readonly("total_download", &session_status::total_download)
|
|
|
|
.def_readonly("total_upload", &session_status::total_upload)
|
2009-05-31 22:46:40 +02:00
|
|
|
|
|
|
|
.def_readonly("payload_upload_rate", &session_status::payload_upload_rate)
|
|
|
|
.def_readonly("payload_download_rate", &session_status::payload_download_rate)
|
2009-05-14 19:24:17 +02:00
|
|
|
.def_readonly("total_payload_download", &session_status::total_payload_download)
|
|
|
|
.def_readonly("total_payload_upload", &session_status::total_payload_upload)
|
2009-05-31 22:46:40 +02:00
|
|
|
|
|
|
|
.def_readonly("ip_overhead_upload_rate", &session_status::ip_overhead_upload_rate)
|
|
|
|
.def_readonly("ip_overhead_download_rate", &session_status::ip_overhead_download_rate)
|
|
|
|
.def_readonly("total_ip_overhead_download", &session_status::total_ip_overhead_download)
|
|
|
|
.def_readonly("total_ip_overhead_upload", &session_status::total_ip_overhead_upload)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("dht_upload_rate", &session_status::dht_upload_rate)
|
|
|
|
.def_readonly("dht_download_rate", &session_status::dht_download_rate)
|
|
|
|
.def_readonly("total_dht_download", &session_status::total_dht_download)
|
|
|
|
.def_readonly("total_dht_upload", &session_status::total_dht_upload)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("tracker_upload_rate", &session_status::tracker_upload_rate)
|
|
|
|
.def_readonly("tracker_download_rate", &session_status::tracker_download_rate)
|
|
|
|
.def_readonly("total_tracker_download", &session_status::total_tracker_download)
|
|
|
|
.def_readonly("total_tracker_upload", &session_status::total_tracker_upload)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("total_redundant_bytes", &session_status::total_redundant_bytes)
|
|
|
|
.def_readonly("total_failed_bytes", &session_status::total_failed_bytes)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-14 19:24:17 +02:00
|
|
|
.def_readonly("num_peers", &session_status::num_peers)
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("num_unchoked", &session_status::num_unchoked)
|
|
|
|
.def_readonly("allowed_upload_slots", &session_status::allowed_upload_slots)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("up_bandwidth_queue", &session_status::up_bandwidth_queue)
|
|
|
|
.def_readonly("down_bandwidth_queue", &session_status::down_bandwidth_queue)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("up_bandwidth_bytes_queue", &session_status::up_bandwidth_bytes_queue)
|
|
|
|
.def_readonly("down_bandwidth_bytes_queue", &session_status::down_bandwidth_bytes_queue)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("optimistic_unchoke_counter", &session_status::optimistic_unchoke_counter)
|
|
|
|
.def_readonly("unchoke_counter", &session_status::unchoke_counter)
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2007-01-10 17:11:43 +01:00
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
2009-05-14 19:24:17 +02:00
|
|
|
.def_readonly("dht_nodes", &session_status::dht_nodes)
|
2009-11-11 06:28:28 +01:00
|
|
|
.def_readonly("dht_node_cache", &session_status::dht_node_cache)
|
2009-05-14 19:24:17 +02:00
|
|
|
.def_readonly("dht_torrents", &session_status::dht_torrents)
|
2009-05-31 22:46:40 +02:00
|
|
|
.def_readonly("dht_global_nodes", &session_status::dht_global_nodes)
|
|
|
|
.def_readonly("active_requests", &session_status::active_requests)
|
2013-05-03 10:24:26 +02:00
|
|
|
.def_readonly("dht_total_allocations", &session_status::dht_total_allocations)
|
2015-01-18 22:36:24 +01:00
|
|
|
#endif // TORRENT_DISABLE_DHT
|
2013-05-03 10:24:26 +02:00
|
|
|
.add_property("utp_stats", &get_utp_stats)
|
2007-01-10 17:11:43 +01:00
|
|
|
;
|
|
|
|
|
2011-04-28 11:24:42 +02:00
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
2009-05-31 22:46:40 +02:00
|
|
|
class_<dht_lookup>("dht_lookup")
|
|
|
|
.def_readonly("type", &dht_lookup::type)
|
|
|
|
.def_readonly("outstanding_requests", &dht_lookup::outstanding_requests)
|
|
|
|
.def_readonly("timeouts", &dht_lookup::timeouts)
|
|
|
|
.def_readonly("response", &dht_lookup::responses)
|
|
|
|
.def_readonly("branch_factor", &dht_lookup::branch_factor)
|
|
|
|
;
|
2015-01-18 22:36:24 +01:00
|
|
|
#endif // TORRENT_DISABLE_DHT
|
|
|
|
#endif // TORRENT_NO_DEPRECATE
|
2009-06-26 01:05:12 +02:00
|
|
|
|
2016-04-13 02:10:09 +02:00
|
|
|
#define PROP(val) \
|
|
|
|
make_getter(val, return_value_policy<return_by_value>()), \
|
|
|
|
make_setter(val, return_value_policy<return_by_value>())
|
|
|
|
|
2016-04-12 07:33:01 +02:00
|
|
|
class_<add_torrent_params>("add_torrent_params")
|
|
|
|
.def_readwrite("version", &add_torrent_params::version)
|
|
|
|
.def_readwrite("ti", &add_torrent_params::ti)
|
2016-04-13 02:10:09 +02:00
|
|
|
.add_property("trackers", PROP(&add_torrent_params::trackers))
|
|
|
|
.add_property("tracker_tiers", PROP(&add_torrent_params::tracker_tiers))
|
|
|
|
.add_property("dht_nodes", PROP(&add_torrent_params::dht_nodes))
|
2016-04-12 07:33:01 +02:00
|
|
|
.def_readwrite("name", &add_torrent_params::name)
|
|
|
|
.def_readwrite("save_path", &add_torrent_params::save_path)
|
|
|
|
.def_readwrite("storage_mode", &add_torrent_params::storage_mode)
|
2016-04-13 02:10:09 +02:00
|
|
|
// .def_readwrite("storage", &add_torrent_params::storage)
|
|
|
|
.add_property("file_priorities", PROP(&add_torrent_params::file_priorities))
|
2016-04-12 07:33:01 +02:00
|
|
|
.def_readwrite("trackerid", &add_torrent_params::trackerid)
|
|
|
|
.def_readwrite("url", &add_torrent_params::url)
|
|
|
|
.def_readwrite("flags", &add_torrent_params::flags)
|
|
|
|
.def_readwrite("info_hash", &add_torrent_params::info_hash)
|
|
|
|
.def_readwrite("max_uploads", &add_torrent_params::max_uploads)
|
|
|
|
.def_readwrite("max_connections", &add_torrent_params::max_connections)
|
|
|
|
.def_readwrite("upload_limit", &add_torrent_params::upload_limit)
|
|
|
|
.def_readwrite("download_limit", &add_torrent_params::download_limit)
|
|
|
|
.def_readwrite("total_uploaded", &add_torrent_params::total_uploaded)
|
|
|
|
.def_readwrite("total_downloaded", &add_torrent_params::total_downloaded)
|
|
|
|
.def_readwrite("active_time", &add_torrent_params::active_time)
|
|
|
|
.def_readwrite("finished_time", &add_torrent_params::finished_time)
|
|
|
|
.def_readwrite("seeding_time", &add_torrent_params::seeding_time)
|
|
|
|
.def_readwrite("added_time", &add_torrent_params::added_time)
|
|
|
|
.def_readwrite("completed_time", &add_torrent_params::completed_time)
|
|
|
|
.def_readwrite("last_seen_complete", &add_torrent_params::last_seen_complete)
|
|
|
|
.def_readwrite("num_complete", &add_torrent_params::num_complete)
|
|
|
|
.def_readwrite("num_incomplete", &add_torrent_params::num_incomplete)
|
|
|
|
.def_readwrite("num_downloaded", &add_torrent_params::num_downloaded)
|
2016-04-13 02:10:09 +02:00
|
|
|
.add_property("http_seeds", PROP(&add_torrent_params::http_seeds))
|
|
|
|
.add_property("url_seeds", PROP(&add_torrent_params::url_seeds))
|
|
|
|
.add_property("peers", PROP(&add_torrent_params::peers))
|
|
|
|
.add_property("banned_peers", PROP(&add_torrent_params::banned_peers))
|
|
|
|
.add_property("unfinished_pieces", PROP(&add_torrent_params::unfinished_pieces))
|
|
|
|
.add_property("have_pieces", PROP(&add_torrent_params::have_pieces))
|
|
|
|
.add_property("verified_pieces", PROP(&add_torrent_params::verified_pieces))
|
|
|
|
.add_property("piece_priorities", PROP(&add_torrent_params::piece_priorities))
|
|
|
|
.add_property("merkle_tree", PROP(&add_torrent_params::merkle_tree))
|
|
|
|
.add_property("renamed_files", PROP(&add_torrent_params::renamed_files))
|
2016-04-12 07:33:01 +02:00
|
|
|
|
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
|
|
|
.def_readwrite("uuid", &add_torrent_params::uuid)
|
|
|
|
.def_readwrite("resume_data", &add_torrent_params::resume_data)
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
|
|
|
|
|
2007-10-15 07:37:35 +02:00
|
|
|
enum_<storage_mode_t>("storage_mode_t")
|
|
|
|
.value("storage_mode_allocate", storage_mode_allocate)
|
|
|
|
.value("storage_mode_sparse", storage_mode_sparse)
|
|
|
|
;
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
enum_<lt::session::options_t>("options_t")
|
|
|
|
.value("delete_files", lt::session::delete_files)
|
2007-10-15 07:37:35 +02:00
|
|
|
;
|
2008-05-01 07:37:04 +02:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
enum_<lt::session::session_flags_t>("session_flags_t")
|
|
|
|
.value("add_default_plugins", lt::session::add_default_plugins)
|
|
|
|
.value("start_default_features", lt::session::start_default_features)
|
2008-10-01 04:07:55 +02:00
|
|
|
;
|
2008-10-28 07:29:30 +01:00
|
|
|
|
2011-11-08 06:36:22 +01:00
|
|
|
enum_<add_torrent_params::flags_t>("add_torrent_params_flags_t")
|
|
|
|
.value("flag_seed_mode", add_torrent_params::flag_seed_mode)
|
|
|
|
.value("flag_upload_mode", add_torrent_params::flag_upload_mode)
|
|
|
|
.value("flag_share_mode", add_torrent_params::flag_share_mode)
|
|
|
|
.value("flag_apply_ip_filter", add_torrent_params::flag_apply_ip_filter)
|
|
|
|
.value("flag_paused", add_torrent_params::flag_paused)
|
|
|
|
.value("flag_auto_managed", add_torrent_params::flag_auto_managed)
|
|
|
|
.value("flag_duplicate_is_error", add_torrent_params::flag_duplicate_is_error)
|
2012-12-31 04:15:50 +01:00
|
|
|
.value("flag_update_subscribe", add_torrent_params::flag_update_subscribe)
|
2014-06-13 00:39:41 +02:00
|
|
|
.value("flag_super_seeding", add_torrent_params::flag_super_seeding)
|
|
|
|
.value("flag_sequential_download", add_torrent_params::flag_sequential_download)
|
2016-02-16 20:20:04 +01:00
|
|
|
.value("flag_pinned", add_torrent_params::flag_pinned)
|
|
|
|
.value("flag_stop_when_ready", add_torrent_params::flag_stop_when_ready)
|
|
|
|
.value("flag_override_trackers", add_torrent_params::flag_override_trackers)
|
|
|
|
.value("flag_override_web_seeds", add_torrent_params::flag_override_web_seeds)
|
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
|
|
|
.value("flag_override_resume_data", add_torrent_params::flag_override_resume_data)
|
|
|
|
.value("flag_merge_resume_trackers", add_torrent_params::flag_merge_resume_trackers)
|
2014-06-13 00:39:41 +02:00
|
|
|
.value("flag_use_resume_save_path", add_torrent_params::flag_use_resume_save_path)
|
2015-09-29 07:51:01 +02:00
|
|
|
.value("flag_merge_resume_http_seeds", add_torrent_params::flag_merge_resume_http_seeds)
|
2016-02-16 20:20:04 +01:00
|
|
|
#endif
|
2011-11-08 06:36:22 +01:00
|
|
|
;
|
2009-06-26 01:05:12 +02:00
|
|
|
class_<cache_status>("cache_status")
|
2014-10-05 21:32:29 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2009-06-26 01:05:12 +02:00
|
|
|
.def_readonly("blocks_written", &cache_status::blocks_written)
|
|
|
|
.def_readonly("writes", &cache_status::writes)
|
|
|
|
.def_readonly("blocks_read", &cache_status::blocks_read)
|
|
|
|
.def_readonly("blocks_read_hit", &cache_status::blocks_read_hit)
|
|
|
|
.def_readonly("reads", &cache_status::reads)
|
2013-05-05 20:08:03 +02:00
|
|
|
.def_readonly("queued_bytes", &cache_status::queued_bytes)
|
2009-06-26 01:05:12 +02:00
|
|
|
.def_readonly("cache_size", &cache_status::cache_size)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def_readonly("write_cache_size", &cache_status::write_cache_size)
|
2009-06-26 01:05:12 +02:00
|
|
|
.def_readonly("read_cache_size", &cache_status::read_cache_size)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def_readonly("pinned_blocks", &cache_status::pinned_blocks)
|
2009-06-26 01:05:12 +02:00
|
|
|
.def_readonly("total_used_buffers", &cache_status::total_used_buffers)
|
2013-05-05 20:08:03 +02:00
|
|
|
.def_readonly("average_read_time", &cache_status::average_read_time)
|
|
|
|
.def_readonly("average_write_time", &cache_status::average_write_time)
|
|
|
|
.def_readonly("average_hash_time", &cache_status::average_hash_time)
|
|
|
|
.def_readonly("average_job_time", &cache_status::average_job_time)
|
|
|
|
.def_readonly("cumulative_job_time", &cache_status::cumulative_job_time)
|
|
|
|
.def_readonly("cumulative_read_time", &cache_status::cumulative_read_time)
|
|
|
|
.def_readonly("cumulative_write_time", &cache_status::cumulative_write_time)
|
|
|
|
.def_readonly("cumulative_hash_time", &cache_status::cumulative_hash_time)
|
|
|
|
.def_readonly("total_read_back", &cache_status::total_read_back)
|
|
|
|
.def_readonly("read_queue_size", &cache_status::read_queue_size)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def_readonly("blocked_jobs", &cache_status::blocked_jobs)
|
|
|
|
.def_readonly("queued_jobs", &cache_status::queued_jobs)
|
|
|
|
.def_readonly("peak_queued", &cache_status::peak_queued)
|
|
|
|
.def_readonly("pending_jobs", &cache_status::pending_jobs)
|
|
|
|
.def_readonly("num_jobs", &cache_status::num_jobs)
|
|
|
|
.def_readonly("num_read_jobs", &cache_status::num_read_jobs)
|
|
|
|
.def_readonly("num_write_jobs", &cache_status::num_write_jobs)
|
|
|
|
.def_readonly("arc_mru_size", &cache_status::arc_mru_size)
|
|
|
|
.def_readonly("arc_mru_ghost_size", &cache_status::arc_mru_ghost_size)
|
|
|
|
.def_readonly("arc_mfu_size", &cache_status::arc_mfu_size)
|
|
|
|
.def_readonly("arc_mfu_ghost_size", &cache_status::arc_mfu_ghost_size)
|
2015-01-02 12:48:04 +01:00
|
|
|
#endif
|
2009-06-26 01:05:12 +02:00
|
|
|
;
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
class_<lt::session, boost::noncopyable>("session", no_init)
|
2016-01-05 07:32:04 +01:00
|
|
|
.def("__init__", boost::python::make_constructor(&make_session
|
|
|
|
, default_call_policies()
|
|
|
|
, (arg("settings")
|
|
|
|
, arg("flags")=lt::session::start_default_features
|
|
|
|
| lt::session::add_default_plugins))
|
2014-07-06 21:18:00 +02:00
|
|
|
)
|
2015-06-08 23:56:18 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2007-01-10 17:11:43 +01:00
|
|
|
.def(
|
2014-07-06 21:18:00 +02:00
|
|
|
init<fingerprint, int, boost::uint32_t>((
|
2008-10-01 04:07:55 +02:00
|
|
|
arg("fingerprint")=fingerprint("LT",0,1,0,0)
|
2014-07-06 21:18:00 +02:00
|
|
|
, arg("flags")=lt::session::start_default_features | lt::session::add_default_plugins
|
2015-04-04 21:27:40 +02:00
|
|
|
, arg("alert_mask")=int(alert::error_notification)))
|
2007-01-10 17:11:43 +01:00
|
|
|
)
|
2015-06-08 23:56:18 +02:00
|
|
|
#endif
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("post_torrent_updates", allow_threads(<::session::post_torrent_updates))
|
2016-01-12 07:52:10 +01:00
|
|
|
.def("post_session_stats", allow_threads(<::session::post_session_stats))
|
2008-07-30 07:31:22 +02:00
|
|
|
.def("outgoing_ports", &outgoing_ports)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("is_listening", allow_threads(<::session::is_listening))
|
|
|
|
.def("listen_port", allow_threads(<::session::listen_port))
|
2008-03-10 04:19:57 +01:00
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
2015-07-06 19:14:28 +02:00
|
|
|
.def("add_dht_node", &add_dht_node)
|
2008-02-17 22:12:06 +01:00
|
|
|
.def(
|
|
|
|
"add_dht_router", &add_dht_router
|
|
|
|
, (arg("router"), "port")
|
|
|
|
)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("is_dht_running", allow_threads(<::session::is_dht_running))
|
|
|
|
.def("set_dht_settings", allow_threads(<::session::set_dht_settings))
|
2015-05-30 19:41:38 +02:00
|
|
|
.def("get_dht_settings", allow_threads(<::session::get_dht_settings))
|
2015-07-07 01:20:04 +02:00
|
|
|
.def("dht_get_immutable_item", allow_threads(dht_get_immutable_item))
|
2015-11-08 19:08:03 +01:00
|
|
|
.def("dht_get_mutable_item", &dht_get_mutable_item)
|
2015-07-07 01:20:04 +02:00
|
|
|
.def("dht_put_immutable_item", allow_threads(dht_put_immutable_item))
|
2015-11-08 19:08:03 +01:00
|
|
|
.def("dht_put_mutable_item", &dht_put_mutable_item)
|
2015-07-06 19:14:28 +02:00
|
|
|
.def("dht_get_peers", allow_threads(<::session::dht_get_peers))
|
|
|
|
.def("dht_announce", allow_threads(<::session::dht_announce))
|
|
|
|
#endif // TORRENT_DISABLE_DHT
|
2009-05-14 19:24:17 +02:00
|
|
|
.def("add_torrent", &add_torrent)
|
2012-10-19 07:18:48 +02:00
|
|
|
.def("async_add_torrent", &async_add_torrent)
|
2016-04-12 07:33:01 +02:00
|
|
|
.def("async_add_torrent", <::session::async_add_torrent)
|
|
|
|
.def("add_torrent", allow_threads((lt::torrent_handle (session_handle::*)(add_torrent_params const&))<::session::add_torrent))
|
2010-08-22 18:45:12 +02:00
|
|
|
#ifndef BOOST_NO_EXCEPTIONS
|
2008-10-28 03:34:14 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
|
|
|
.def(
|
|
|
|
"add_torrent", &add_torrent_depr
|
2008-10-28 07:29:30 +01:00
|
|
|
, (
|
2009-05-14 19:24:17 +02:00
|
|
|
arg("resume_data") = entry(),
|
2010-03-06 18:50:19 +01:00
|
|
|
arg("storage_mode") = storage_mode_sparse,
|
2008-10-28 07:29:30 +01:00
|
|
|
arg("paused") = false
|
|
|
|
)
|
2008-10-28 03:34:14 +01:00
|
|
|
)
|
2015-01-04 22:31:02 +01:00
|
|
|
#endif // TORRENT_NO_DEPRECATE
|
|
|
|
#endif // BOOST_NO_EXCEPTIONS
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("remove_torrent", allow_threads(<::session::remove_torrent), arg("option") = 0)
|
2011-01-23 19:41:15 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2015-01-04 22:31:02 +01:00
|
|
|
.def("status", allow_threads(<::session::status))
|
2016-04-16 21:43:26 +02:00
|
|
|
.def("settings", <::session::settings)
|
2016-04-04 06:52:21 +02:00
|
|
|
.def("set_settings", &session_set_settings)
|
2010-12-26 09:03:02 +01:00
|
|
|
#endif
|
2016-04-04 06:52:21 +02:00
|
|
|
.def("get_settings", &session_get_settings)
|
|
|
|
.def("apply_settings", &session_apply_settings)
|
2014-10-05 21:32:29 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2008-03-10 04:19:57 +01:00
|
|
|
#ifndef TORRENT_DISABLE_ENCRYPTION
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("set_pe_settings", allow_threads(<::session::set_pe_settings))
|
|
|
|
.def("get_pe_settings", allow_threads(<::session::get_pe_settings))
|
2008-03-10 04:19:57 +01:00
|
|
|
#endif
|
2008-04-05 06:53:22 +02:00
|
|
|
#endif
|
2016-03-05 21:15:22 +01:00
|
|
|
.def("load_state", &load_state, (arg("entry"), arg("flags") = 0xffffffff))
|
2010-03-06 18:50:19 +01:00
|
|
|
.def("save_state", &save_state, (arg("entry"), arg("flags") = 0xffffffff))
|
2013-01-04 18:52:35 +01:00
|
|
|
.def("pop_alerts", &pop_alerts)
|
2016-01-05 07:32:04 +01:00
|
|
|
.def("wait_for_alert", &wait_for_alert
|
|
|
|
#ifdef TORRENT_NO_DEPRECATE
|
|
|
|
, return_internal_reference<>()
|
|
|
|
#endif
|
2016-04-04 06:52:21 +02:00
|
|
|
)
|
2012-09-19 08:13:04 +02:00
|
|
|
.def("add_extension", &add_extension)
|
2012-10-13 04:08:34 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2015-04-03 22:15:48 +02:00
|
|
|
.def("pop_alert", &pop_alert)
|
2013-05-03 10:24:26 +02:00
|
|
|
#if TORRENT_USE_I2P
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("set_i2p_proxy", allow_threads(<::session::set_i2p_proxy))
|
|
|
|
.def("i2p_proxy", allow_threads(<::session::i2p_proxy))
|
2010-09-05 18:49:03 +02:00
|
|
|
#endif
|
2014-10-05 21:32:29 +02:00
|
|
|
#endif
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("set_ip_filter", allow_threads(<::session::set_ip_filter))
|
|
|
|
.def("get_ip_filter", allow_threads(<::session::get_ip_filter))
|
|
|
|
.def("find_torrent", allow_threads(<::session::find_torrent))
|
|
|
|
.def("get_torrents", &get_torrents)
|
|
|
|
.def("pause", allow_threads(<::session::pause))
|
|
|
|
.def("resume", allow_threads(<::session::resume))
|
|
|
|
.def("is_paused", allow_threads(<::session::is_paused))
|
|
|
|
.def("id", allow_threads(<::session::id))
|
|
|
|
.def("get_cache_info", &get_cache_info1, (arg("handle") = torrent_handle(), arg("flags") = 0))
|
2015-09-02 07:30:40 +02:00
|
|
|
.def("add_port_mapping", allow_threads(<::session::add_port_mapping))
|
|
|
|
.def("delete_port_mapping", allow_threads(<::session::delete_port_mapping))
|
2014-10-05 21:32:29 +02:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2014-10-05 21:32:29 +02:00
|
|
|
.def(
|
|
|
|
"listen_on", &listen_on
|
|
|
|
, (arg("min"), "max", arg("interface") = (char const*)0, arg("flags") = 0)
|
|
|
|
)
|
|
|
|
#ifndef TORRENT_DISABLE_DHT
|
|
|
|
.def("start_dht", allow_threads(start_dht0))
|
|
|
|
.def("stop_dht", allow_threads(<::session::stop_dht))
|
|
|
|
.def("start_dht", allow_threads(start_dht1))
|
|
|
|
.def("dht_state", allow_threads(<::session::dht_state))
|
|
|
|
.def("set_dht_proxy", allow_threads(<::session::set_dht_proxy))
|
|
|
|
.def("dht_proxy", allow_threads(<::session::dht_proxy))
|
|
|
|
#endif
|
|
|
|
.def("set_local_download_rate_limit", allow_threads(<::session::set_local_download_rate_limit))
|
|
|
|
.def("local_download_rate_limit", allow_threads(<::session::local_download_rate_limit))
|
|
|
|
.def("set_local_upload_rate_limit", allow_threads(<::session::set_local_upload_rate_limit))
|
|
|
|
.def("local_upload_rate_limit", allow_threads(<::session::local_upload_rate_limit))
|
|
|
|
.def("set_download_rate_limit", allow_threads(<::session::set_download_rate_limit))
|
|
|
|
.def("download_rate_limit", allow_threads(<::session::download_rate_limit))
|
|
|
|
.def("set_upload_rate_limit", allow_threads(<::session::set_upload_rate_limit))
|
|
|
|
.def("upload_rate_limit", allow_threads(<::session::upload_rate_limit))
|
|
|
|
.def("set_max_uploads", allow_threads(<::session::set_max_uploads))
|
|
|
|
.def("set_max_connections", allow_threads(<::session::set_max_connections))
|
|
|
|
.def("max_connections", allow_threads(<::session::max_connections))
|
|
|
|
.def("num_connections", allow_threads(<::session::num_connections))
|
|
|
|
.def("load_asnum_db", &load_asnum_db)
|
|
|
|
.def("load_country_db", &load_country_db)
|
|
|
|
.def("set_max_half_open_connections", allow_threads(<::session::set_max_half_open_connections))
|
|
|
|
.def("set_severity_level", allow_threads(<::session::set_severity_level))
|
|
|
|
.def("set_alert_queue_size_limit", allow_threads(<::session::set_alert_queue_size_limit))
|
|
|
|
.def("set_alert_mask", allow_threads(<::session::set_alert_mask))
|
|
|
|
.def("set_peer_proxy", allow_threads(<::session::set_peer_proxy))
|
|
|
|
.def("set_tracker_proxy", allow_threads(<::session::set_tracker_proxy))
|
|
|
|
.def("set_web_seed_proxy", allow_threads(<::session::set_web_seed_proxy))
|
|
|
|
.def("peer_proxy", allow_threads(<::session::peer_proxy))
|
|
|
|
.def("tracker_proxy", allow_threads(<::session::tracker_proxy))
|
|
|
|
.def("web_seed_proxy", allow_threads(<::session::web_seed_proxy))
|
|
|
|
.def("set_proxy", allow_threads(<::session::set_proxy))
|
|
|
|
.def("proxy", allow_threads(<::session::proxy))
|
2009-05-14 19:24:17 +02:00
|
|
|
.def("start_upnp", &start_upnp)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("stop_upnp", allow_threads(<::session::stop_upnp))
|
|
|
|
.def("start_lsd", allow_threads(<::session::start_lsd))
|
|
|
|
.def("stop_lsd", allow_threads(<::session::stop_lsd))
|
2009-05-14 19:24:17 +02:00
|
|
|
.def("start_natpmp", &start_natpmp)
|
2014-07-06 21:18:00 +02:00
|
|
|
.def("stop_natpmp", allow_threads(<::session::stop_natpmp))
|
|
|
|
.def("get_cache_status", &get_cache_status)
|
|
|
|
.def("get_cache_info", &get_cache_info2)
|
|
|
|
.def("set_peer_id", allow_threads(<::session::set_peer_id))
|
2015-01-02 12:48:04 +01:00
|
|
|
#endif // TORRENT_NO_DEPRECATE
|
2007-01-10 17:11:43 +01:00
|
|
|
;
|
|
|
|
|
2015-09-02 07:30:40 +02:00
|
|
|
enum_<lt::session::protocol_type>("protocol_type")
|
|
|
|
.value("udp", lt::session::udp)
|
|
|
|
.value("tcp", lt::session::tcp)
|
2015-06-17 23:40:38 +02:00
|
|
|
;
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
enum_<lt::session::save_state_flags_t>("save_state_flags_t")
|
|
|
|
.value("save_settings", lt::session::save_settings)
|
|
|
|
.value("save_dht_settings", lt::session::save_dht_settings)
|
|
|
|
.value("save_dht_state", lt::session::save_dht_state)
|
|
|
|
.value("save_encryption_settings", lt::session:: save_encryption_settings)
|
2011-01-23 19:41:15 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2016-03-05 21:15:22 +01:00
|
|
|
.value("save_as_map", lt::session::save_as_map)
|
2014-10-05 21:32:29 +02:00
|
|
|
.value("save_i2p_proxy", lt::session::save_i2p_proxy)
|
|
|
|
.value("save_proxy", lt::session::save_proxy)
|
2014-07-06 21:18:00 +02:00
|
|
|
.value("save_dht_proxy", lt::session::save_dht_proxy)
|
|
|
|
.value("save_peer_proxy", lt::session::save_peer_proxy)
|
|
|
|
.value("save_web_proxy", lt::session::save_web_proxy)
|
|
|
|
.value("save_tracker_proxy", lt::session::save_tracker_proxy)
|
2011-01-23 19:41:15 +01:00
|
|
|
#endif
|
2010-03-06 18:50:19 +01:00
|
|
|
;
|
|
|
|
|
2012-11-23 21:43:42 +01:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2014-07-06 21:18:00 +02:00
|
|
|
enum_<lt::session::listen_on_flags_t>("listen_on_flags_t")
|
|
|
|
.value("listen_reuse_address", lt::session::listen_reuse_address)
|
|
|
|
.value("listen_no_system_port", lt::session::listen_no_system_port)
|
2011-08-14 01:30:11 +02:00
|
|
|
;
|
2015-04-03 22:15:48 +02:00
|
|
|
#endif
|
2011-01-18 04:41:54 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
typedef void (*mem_preset2)(settings_pack& s);
|
|
|
|
typedef void (*perf_preset2)(settings_pack& s);
|
2012-11-03 05:38:45 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
#ifndef TORRENT_NO_DEPRECATE
|
2016-01-06 06:17:51 +01:00
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
typedef session_settings (*mem_preset1)();
|
|
|
|
typedef session_settings (*perf_preset1)();
|
|
|
|
|
|
|
|
def("high_performance_seed", (perf_preset1)high_performance_seed);
|
|
|
|
def("min_memory_usage", (mem_preset1)min_memory_usage);
|
2013-08-27 18:04:19 +02:00
|
|
|
scope().attr("create_metadata_plugin") = "metadata_transfer";
|
2014-07-06 21:18:00 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
def("high_performance_seed", (perf_preset2)high_performance_seed);
|
|
|
|
def("min_memory_usage", (mem_preset2)min_memory_usage);
|
2016-02-16 20:20:04 +01:00
|
|
|
def("read_resume_data", read_resume_data_wrapper);
|
2014-07-06 21:18:00 +02:00
|
|
|
|
2013-08-27 18:04:19 +02:00
|
|
|
scope().attr("create_ut_metadata_plugin") = "ut_metadata";
|
|
|
|
scope().attr("create_ut_pex_plugin") = "ut_pex";
|
|
|
|
scope().attr("create_smart_ban_plugin") = "smart_ban";
|
2007-01-10 17:11:43 +01:00
|
|
|
}
|
2014-07-06 21:18:00 +02:00
|
|
|
|