def test_fingerprint(self) -> None:
with self.assertWarns(DeprecationWarning):
fprint = lt.fingerprint("AB", 1, 2, 3, 4)
self.assertEqual(str(fprint), "-AB1234-")
self.assertEqual(fprint.major_version, 1)
self.assertEqual(fprint.minor_version, 2)
self.assertEqual(fprint.revision_version, 3)
self.assertEqual(fprint.tag_version, 4)
# short names behave differently
with self.assertWarns(DeprecationWarning):
fprint = lt.fingerprint("A", 1, 2, 3, 4)
self.assertEqual(str(fprint), "-A\x001234-")
def get_torrent_info_magnet(v1, v3, u):
global handle, ses, info, cnt, cnt_limit, file_name, ui
ui = u
#print(v1,'------------hello----------info---')
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB', 3, 3, 5, 0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
handle = lt.add_magnet_uri(ses, v1, {'save_path': v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i + 1
print('finding metadata')
if i > 300:
print('No Metadata Available')
break
info = handle.get_torrent_info()
handle.set_sequential_download(True)
print(handle.trackers())
return handle, ses, info
def __init__(self, start_port=6881, end_port=6891):
"""
Class constructor
:param start_port: int
:param end_port: int
:return:
"""
# torrents_pool is used to map torrent handles to their sha1 info_hashes (string hex digests)
# Item format {info_hashes: torr_handle}
self._torrents_pool = {}
# Worker threads
self._add_torrent_thread = None
# Signal events
self._torrent_added = threading.Event()
# Inter-thread data buffer.
self._last_added_torrent = Buffer()
# Initialize session
self._session = libtorrent.session(
fingerprint=libtorrent.fingerprint('UT', 3, 4, 5, 41865))
self._session.listen_on(start_port, end_port)
# Lower cache size is needed for libtorrent to dump data on disk more often,
# otherwise have_piece may give false positives for pieces
# that are in the memory cache but not saved to disk yet.
self.set_session_settings(
cache_size=256, # 4MB
ignore_limits_on_local_network=True,
user_agent='uTorrent/3.4.5(41865)')
self._session.add_dht_router('router.bittorrent.com', 6881)
self._session.add_dht_router('router.utorrent.com', 6881)
self._session.add_dht_router('router.bitcomet.com', 6881)
self._session.start_dht()
self._session.start_lsd()
self._session.start_upnp()
self._session.start_natpmp()
def __init__(self, start_port=6881, end_port=6891):
"""
Class constructor
:param start_port: int
:param end_port: int
:return:
"""
# torrents_pool is used to map torrent handles to their sha1 info_hashes (string hex digests)
# Item format {info_hashes: torr_handle}
self._torrents_pool = {}
# Worker threads
self._add_torrent_thread = None
# Signal events
self._torrent_added = threading.Event()
# Inter-thread data buffer.
self._last_added_torrent = Buffer()
# Initialize session
self._session = libtorrent.session(fingerprint=libtorrent.fingerprint('UT', 3, 4, 5, 41865))
self._session.listen_on(start_port, end_port)
# Lower cache size is needed for libtorrent to dump data on disk more often,
# otherwise have_piece may give false positives for pieces
# that are in the memory cache but not saved to disk yet.
self.set_session_settings(cache_size=256, # 4MB
ignore_limits_on_local_network=True,
user_agent='uTorrent/3.4.5(41865)')
self._session.add_dht_router('router.bittorrent.com', 6881)
self._session.add_dht_router('router.utorrent.com', 6881)
self._session.add_dht_router('router.bitcomet.com', 6881)
self._session.start_dht()
self._session.start_lsd()
self._session.start_upnp()
self._session.start_natpmp()
def get_torrent_info_magnet(v1, v3, u, p_bar, tmp_dir):
global handle, ses, info, cnt, cnt_limit, file_name, ui, progress, tmp_dir_folder
ui = u
progress = p_bar
tmp_dir_folder = tmp_dir
progress.setValue(0)
progress.show()
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB', 3, 3, 5, 0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
handle = lt.add_magnet_uri(ses, v1, {'save_path': v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i + 1
print('finding metadata {0}'.format(i))
if i > 300:
print('No Metadata Available: {0}s'.format(i))
break
info = handle.get_torrent_info()
handle.set_sequential_download(True)
print(handle.trackers())
return handle, ses, info
def get_torrent_info_magnet(v1,v3,u,p_bar,tmp_dir):
global handle,ses,info,cnt,cnt_limit,file_name,ui,progress,tmp_dir_folder
ui = u
progress = p_bar
tmp_dir_folder = tmp_dir
progress.setValue(0)
progress.show()
#print(v1,'------------hello----------info---')
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB',3,3,5,0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
handle = lt.add_magnet_uri(ses,v1,{'save_path':v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i+1
print('finding metadata')
if i > 300:
print('No Metadata Available')
break
info = handle.get_torrent_info()
handle.set_sequential_download(True)
print(handle.trackers())
return handle,ses,info
def init_libtorrent(self, max_download_speed=0, max_upload_speed=0):
"""Perform the initialization of things that should be initialized once"""
if self.session:
return
settings = libtorrent.session_settings()
settings.user_agent = encode_utf8(
'Torrent Launcher (libtorrent/{})'.format(
decode_utf8(libtorrent.version)))
"""When running on a network where the bandwidth is in such an abundance
that it's virtually infinite, this algorithm is no longer necessary, and
might even be harmful to throughput. It is adviced to experiment with the
session_setting::mixed_mode_algorithm, setting it to session_settings::prefer_tcp.
This setting entirely disables the balancing and unthrottles all connections."""
settings.mixed_mode_algorithm = 0
# Fingerprint = 'LT1080' == LibTorrent 1.0.8.0
fingerprint = libtorrent.fingerprint(
b'LT', *(int(i) for i in libtorrent.version.split('.')))
self.session = libtorrent.session(fingerprint=fingerprint)
self.session.listen_on(
6881, 6891
) # This is just a port suggestion. On failure, the port is automatically selected.
# Prevent conversion to C int error
settings.download_rate_limit = min(max_download_speed, 999999) * 1024
settings.upload_rate_limit = min(max_upload_speed, 999999) * 1024
self.session.set_settings(settings)
def __init__(self, trsession, ignore_singleton=False):
if not ignore_singleton:
if LibtorrentMgr.__single:
raise RuntimeError("LibtorrentMgr is singleton")
LibtorrentMgr.__single = self
self.trsession = trsession
settings = lt.session_settings()
settings.user_agent = 'Tribler/' + version_id
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(int,
version_id.split('-')[0].split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
self.ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
self.ltsession.set_settings(settings)
self.ltsession.set_alert_mask(
lt.alert.category_t.stats_notification
| lt.alert.category_t.error_notification
| lt.alert.category_t.status_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.performance_warning
| lt.alert.category_t.debug_notification)
self.ltsession.listen_on(self.trsession.get_listen_port(),
self.trsession.get_listen_port() + 10)
self.set_upload_rate_limit(-1)
self.set_download_rate_limit(-1)
self.upnp_mapper = self.ltsession.start_upnp()
print >> sys.stderr, "LibtorrentMgr: listening on %d" % self.ltsession.listen_port(
)
# Start DHT
self.dht_ready = False
try:
dht_state = open(
os.path.join(self.trsession.get_state_dir(),
DHTSTATE_FILENAME)).read()
self.ltsession.start_dht(lt.bdecode(dht_state))
except:
print >> sys.stderr, "LibtorrentMgr: could not restore dht state, starting from scratch"
self.ltsession.start_dht(None)
self.ltsession.add_dht_router('router.bittorrent.com', 6881)
self.ltsession.add_dht_router('router.utorrent.com', 6881)
self.ltsession.add_dht_router('router.bitcomet.com', 6881)
self.torlock = NoDispersyRLock()
self.torrents = {}
self.metainfo_requests = {}
self.metainfo_lock = threading.RLock()
self.metainfo_cache = {}
self.trsession.lm.rawserver.add_task(self.process_alerts, 1)
self.trsession.lm.rawserver.add_task(self.reachability_check, 1)
self.trsession.lm.rawserver.add_task(self.monitor_dht, 5)
self.upnp_mappings = {}
def create_session(self, hops=0):
settings = lt.session_settings()
if hops == 0:
settings.user_agent = 'Tribler/' + version_id
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(int, version_id.split('-')[0].split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
enable_utp = self.trsession.get_libtorrent_utp()
settings.enable_outgoing_utp = enable_utp
settings.enable_incoming_utp = enable_utp
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
else:
settings.enable_outgoing_utp = True
settings.enable_incoming_utp = True
settings.enable_outgoing_tcp = False
settings.enable_incoming_tcp = False
settings.anonymous_mode = True
# No PEX for anonymous sessions
ltsession = lt.session(flags=0)
ltsession.add_extension(lt.create_ut_metadata_plugin)
ltsession.add_extension(lt.create_smart_ban_plugin)
ltsession.set_settings(settings)
ltsession.set_alert_mask(lt.alert.category_t.stats_notification |
lt.alert.category_t.error_notification |
lt.alert.category_t.status_notification |
lt.alert.category_t.storage_notification |
lt.alert.category_t.performance_warning |
lt.alert.category_t.tracker_notification)
# Load proxy settings
if hops == 0:
proxy_settings = self.trsession.get_libtorrent_proxy_settings()
else:
proxy_settings = list(self.trsession.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.trsession.get_listen_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port():
self.trsession.set_listen_port_runtime(ltsession.listen_port())
try:
dht_state = open(os.path.join(self.trsession.get_state_dir(), DHTSTATE_FILENAME)).read()
ltsession.start_dht(lt.bdecode(dht_state))
except Exception, exc:
self._logger.info("could not restore dht state, got exception: %r. starting from scratch" % exc)
ltsession.start_dht(None)
def startup(self):
fingerprint = lt.fingerprint("MR", 1, 1, 0, 0)
self.session = lt.session(fingerprint)
self.listen()
self.set_upnp()
self.set_upload_limit()
self.set_download_limit()
self.set_encryption()
self.callback_handle = app.downloader_config_watcher.connect('changed',
self.on_config_changed)
def init(self, config_dir):
self.config = Config('spritzle.conf', config_dir)
version = pkg_resources.require("spritzle")[0].version
version = [int(value.split("-")[0]) for value in version.split(".")]
while len(version) < 4:
version.append(0)
self.session = lt.session(lt.fingerprint("SZ", *version), flags=1)
def __init__(self, trsession, ignore_singleton=False):
if not ignore_singleton:
if LibtorrentMgr.__single:
raise RuntimeError("LibtorrentMgr is singleton")
LibtorrentMgr.__single = self
self.trsession = trsession
settings = lt.session_settings()
settings.user_agent = 'Tribler/' + version_id
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(int, version_id.split('-')[0].split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
self.ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
self.ltsession.set_settings(settings)
self.ltsession.set_alert_mask(lt.alert.category_t.stats_notification |
lt.alert.category_t.error_notification |
lt.alert.category_t.status_notification |
lt.alert.category_t.storage_notification |
lt.alert.category_t.performance_warning |
lt.alert.category_t.debug_notification)
self.ltsession.listen_on(self.trsession.get_listen_port(), self.trsession.get_listen_port() + 10)
self.set_upload_rate_limit(-1)
self.set_download_rate_limit(-1)
self.upnp_mapper = self.ltsession.start_upnp()
print >> sys.stderr, "LibtorrentMgr: listening on %d" % self.ltsession.listen_port()
# Start DHT
self.dht_ready = False
try:
dht_state = open(os.path.join(self.trsession.get_state_dir(), DHTSTATE_FILENAME)).read()
self.ltsession.start_dht(lt.bdecode(dht_state))
except:
print >> sys.stderr, "LibtorrentMgr: could not restore dht state, starting from scratch"
self.ltsession.start_dht(None)
self.ltsession.add_dht_router('router.bittorrent.com', 6881)
self.ltsession.add_dht_router('router.utorrent.com', 6881)
self.ltsession.add_dht_router('router.bitcomet.com', 6881)
self.torlock = NoDispersyRLock()
self.torrents = {}
self.metainfo_requests = {}
self.metainfo_lock = threading.RLock()
self.metainfo_cache = {}
self.trsession.lm.rawserver.add_task(self.process_alerts, 1)
self.trsession.lm.rawserver.add_task(self.reachability_check, 1)
self.trsession.lm.rawserver.add_task(self.monitor_dht, 5)
self.upnp_mappings = {}
def __init__(self, config_file_path):
fingerprint = lt.fingerprint(self.FINGERPRINT_ID, 1, 0, 1, 1)
super().__init__(fingerprint)
self.alive = True
self.config_file_path = config_file_path
self.config = Utility.load_config_file(config_file_path)
self.listen_on(self.config['port_start'], self.config['port_end'])
self.__configure_session(self.config)
# Initialize the data producer
self.data_queue = SafeQueue(self.config['max_torrents'])
self.producer = DataProducer(self, 0.5, 0.1)
self.producer.start()
def _create_session(self, port_min, port_max):
flags = 0
# TODO: Move seedbank version to a version or init file
s = lt.session(lt.fingerprint("TE", 1, 0, 0, 0), flags)
settings = get_server_settings()
s.set_settings(settings)
if self._peer_id:
s.set_peer_id(lt.big_number(self._peer_id))
s.set_alert_mask(ALERT_MASK_DEFAULT)
listen_flags = lt.listen_on_flags_t.listen_reuse_address | lt.listen_on_flags_t.listen_no_system_port
listen_interface = None
s.listen_on(port_min, port_max, listen_interface, listen_flags)
return s
def __init__(self, parent):
self.parent = parent
self.log = logging.getLogger("epour.session")
from Globals import version
ver_ints = []
for s in version.split("."):
ver_ints.append(int(s))
fp = lt.fingerprint("EP", *ver_ints)
self.log.debug("peer-id: {}".format(fp))
lt.session.__init__(
self,
fingerprint = fp,
# flags = \
#lt.session_flags_t.add_default_plugins | \
#lt.session_flags_t.start_default_features
)
self.log.info("Session started")
self.torrents = {}
#sdpipsdtsppe
#theprtertoer
#atrboabaorer
#t|flgtucrtro
#s|oorugkam|r
#||rces|ega||
#||mks||rep||
mask = 0b000001000001
self.set_alert_mask(mask)
conf = self.conf = self.setup_conf()
self.listen_on(
conf.getint("Settings", "listen_low"),
conf.getint("Settings", "listen_high")
)
self.alert_manager = AlertManager(self)
self.alert_manager.callback_add(
"metadata_received_alert", self.metadata_received)
def __init__(self, parent):
self.parent = parent
self.log = logging.getLogger("epour.session")
from Globals import version
ver_ints = []
for s in version.split("."):
ver_ints.append(int(s))
fp = lt.fingerprint("EP", *ver_ints)
self.log.debug("peer-id: {}".format(fp))
lt.session.__init__(
self,
fingerprint=fp,
# flags = \
#lt.session_flags_t.add_default_plugins | \
#lt.session_flags_t.start_default_features
)
self.log.info("Session started")
self.torrents = {}
#sdpipsdtsppe
#theprtertoer
#atrboabaorer
#t|flgtucrtro
#s|oorugkam|r
#||rces|ega||
#||mks||rep||
mask = 0b000001000001
self.set_alert_mask(mask)
conf = self.conf = self.setup_conf()
self.listen_on(conf.getint("Settings", "listen_low"),
conf.getint("Settings", "listen_high"))
self.alert_manager = AlertManager(self)
self.alert_manager.callback_add("metadata_received_alert",
self.metadata_received)
def __init__(self, trsession, utility):
if LibtorrentMgr.__single:
raise RuntimeError, "LibtorrentMgr is singleton"
LibtorrentMgr.__single = self
self.utility = utility
self.trsession = trsession
settings = lt.session_settings()
settings.user_agent = 'Tribler/' + version_id
fingerprint = ['TL'] + map(int, version_id.split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
self.ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
self.ltsession.set_settings(settings)
self.ltsession.set_alert_mask(
lt.alert.category_t.stats_notification
| lt.alert.category_t.error_notification
| lt.alert.category_t.status_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.performance_warning)
self.ltsession.listen_on(self.trsession.get_listen_port(),
self.trsession.get_listen_port() + 10)
self.set_upload_rate_limit(-1)
self.set_download_rate_limit(-1)
self.ltsession.start_upnp()
# Start DHT
try:
dht_state = open(
os.path.join(self.trsession.get_state_dir(),
DHTSTATE_FILENAME)).read()
self.ltsession.start_dht(lt.bdecode(dht_state))
except:
print >> sys.stderr, "LibtorrentMgr: could not restore dht state, starting from scratch"
self.ltsession.start_dht(None)
self.ltsession.add_dht_router('router.bittorrent.com', 6881)
self.ltsession.add_dht_router('router.utorrent.com', 6881)
self.ltsession.add_dht_router('router.bitcomet.com', 6881)
self.torlock = NoDispersyRLock()
self.torrents = {}
self.trsession.lm.rawserver.add_task(self.process_alerts, 1)
self.trsession.lm.rawserver.add_task(self.reachability_check, 1)
def __init__(self, trsession, utility):
if LibtorrentMgr.__single:
raise RuntimeError, "LibtorrentMgr is singleton"
LibtorrentMgr.__single = self
self.utility = utility
self.trsession = trsession
settings = lt.session_settings()
settings.user_agent = 'Tribler/' + version_id
fingerprint = ['TL'] + map(int, version_id.split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
self.ltsession = lt.session(lt.fingerprint(*fingerprint), flags = 1)
self.ltsession.set_settings(settings)
self.ltsession.set_alert_mask(lt.alert.category_t.stats_notification |
lt.alert.category_t.error_notification |
lt.alert.category_t.status_notification |
lt.alert.category_t.storage_notification |
lt.alert.category_t.performance_warning )
self.ltsession.listen_on(self.trsession.get_listen_port(), self.trsession.get_listen_port()+10)
self.set_upload_rate_limit(-1)
self.set_download_rate_limit(-1)
self.ltsession.start_upnp()
# Start DHT
try:
dht_state = open(os.path.join(self.trsession.get_state_dir(), DHTSTATE_FILENAME)).read()
self.ltsession.start_dht(lt.bdecode(dht_state))
except:
print >> sys.stderr, "LibtorrentMgr: could not restore dht state, starting from scratch"
self.ltsession.start_dht(None)
self.ltsession.add_dht_router('router.bittorrent.com', 6881)
self.ltsession.add_dht_router('router.utorrent.com', 6881)
self.ltsession.add_dht_router('router.bitcomet.com', 6881)
self.torlock = NoDispersyRLock()
self.torrents = {}
self.trsession.lm.rawserver.add_task(self.process_alerts, 1)
self.trsession.lm.rawserver.add_task(self.reachability_check, 1)
def test_deprecations(self) -> None:
with self.assertWarns(DeprecationWarning):
lt.fingerprint("AB", 1, 2, 3, 4)
def test_fingerprint_broken(self) -> None:
fprint = lt.fingerprint("AB", 1, 2, 3, 4)
self.assertEqual(fprint.major_version, 1)
self.assertEqual(fprint.minor_version, 2)
self.assertEqual(fprint.revision_version, 3)
self.assertEqual(fprint.tag_version, 4)
def get_torrent_info(v1,
v2,
v3,
session,
u,
p_bar,
tmp_dir,
key=None,
client=None):
global handle, ses, info, cnt, cnt_limit, file_name, ui, torrent_download_path
global progress, total_size_content, tmp_dir_folder, content_length
global media_server_key, client_auth_arr
media_server_key = key
client_auth_arr = client
content_length = 0
ui = u
progress = p_bar
tmp_dir_folder = tmp_dir
progress.setValue(0)
progress.show()
if not session:
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB', 3, 3, 5, 0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
else:
ses = session
#print(ses.get_settings())
if v1.startswith('magnet:'):
handle = lt.add_magnet_uri(ses, v1, {'save_path': v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i + 1
if i > 60:
print('No Metadata Available')
break
info = handle.get_torrent_info()
else:
info = lt.torrent_info(v1)
#print(info)
#sett = ses.get_settings()
#print(sett)
#print(sett['user_agent'], sett['upload_rate_limit'])
handle = ses.add_torrent({'ti': info, 'save_path': v3})
handle.set_sequential_download(True)
print(handle.trackers())
print(ses.get_torrents(), 'torrents_list')
torr_arr = ses.get_torrents()
for i in torr_arr:
print(i.name())
i = 0
fileIndex = int(v2)
file_found = False
for f in info.files():
file_exists = False
new_path = os.path.join(v3, f.path)
new_size = f.size
if os.path.exists(new_path) and os.stat(new_path).st_size == new_size:
file_exists = True
if fileIndex == i:
fileStr = f
handle.file_priority(i, 7)
if file_exists:
file_found = True
else:
if file_exists:
handle.file_priority(i, 1)
else:
handle.file_priority(i, 0)
i = i + 1
print(fileStr.path)
file_name = os.path.join(v3, fileStr.path)
torrent_download_path = v3
file_arr = []
for f in info.files():
file_arr.append(f.path)
i += 1
for i in file_arr:
print(i)
content_length = fileStr.size
print(content_length, 'content-length')
total_size_content = str(int(content_length / (1024 * 1024))) + 'M'
pr = info.map_file(fileIndex, 0, fileStr.size)
print(pr.length, info.piece_length(), info.num_pieces())
n_pieces = pr.length / info.piece_length() + 1
print(n_pieces)
n_pieces = int(n_pieces)
for i in range(info.num_pieces()):
if i in range(pr.piece, pr.piece + n_pieces):
if i in range(pr.piece, pr.piece + 10):
if i == pr.piece:
handle.piece_priority(i, 7)
else:
handle.piece_priority(i, 6)
elif i == pr.piece + n_pieces - 1:
handle.piece_priority(i, 7)
else:
handle.piece_priority(i, 1)
tmp = ''
for i in range(info.num_pieces()):
tmp = tmp + ':' + str(handle.piece_priority(i))
print(tmp)
print('starting', handle.name())
handle.set_sequential_download(True)
cnt = pr.piece
cnt_limit = pr.piece + n_pieces
cnt1 = cnt
print('\n', cnt, cnt_limit, file_name, '---get--torrent--info\n')
if ses.is_paused():
ses.resume()
handle.resume()
return handle, ses, info, cnt, cnt_limit, file_name
# ----------------------------------------------------------------------------
import gtk
import gtk.glade
import gobject
import os
import sys
import time
import shutil
from threading import Thread
try:
import libtorrent as lt
lt.fingerprint("PO", 0, 2, 0, 0)
except:
print ("python-libtorrent needed for this plugin")
raise
from modules import functions
def threaded(f):
def wrapper(*args, **kwargs):
t = Thread(target=f, args=args, kwargs=kwargs)
t.start()
return wrapper
def calculate_discusage(dir):
total_size = 0
def create_session(self, hops=0, store_listen_port=True):
settings = {}
# Due to a bug in Libtorrent 0.16.18, the outgoing_port and num_outgoing_ports value should be set in
# the settings dictionary
settings['outgoing_port'] = 0
settings['num_outgoing_ports'] = 1
# Copy construct so we don't modify the default list
extensions = list(DEFAULT_LT_EXTENSIONS)
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(int, version_id.split('-')[0].split('.')) + [0]
ltsession = lt.session(lt.fingerprint(*fingerprint), flags=0) if hops == 0 else lt.session(flags=0)
if hops == 0:
settings['user_agent'] = 'Tribler/' + version_id
enable_utp = self.tribler_session.config.get_libtorrent_utp()
settings['enable_outgoing_utp'] = enable_utp
settings['enable_incoming_utp'] = enable_utp
if LooseVersion(self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings['prefer_rc4'] = True
settings["listen_interfaces"] = "0.0.0.0:%d" % self.tribler_session.config.get_libtorrent_port()
else:
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
mid = self.tribler_session.trustchain_keypair.key_to_hash()
settings['peer_fingerprint'] = mid
settings['handshake_client_version'] = 'Tribler/' + version_id + '/' + mid.encode('hex')
else:
settings['enable_outgoing_utp'] = True
settings['enable_incoming_utp'] = True
settings['enable_outgoing_tcp'] = False
settings['enable_incoming_tcp'] = False
settings['anonymous_mode'] = True
settings['force_proxy'] = True
if LooseVersion(self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings["listen_interfaces"] = "0.0.0.0:%d" % self.tribler_session.config.get_anon_listen_port()
# No PEX for anonymous sessions
if lt.create_ut_pex_plugin in extensions:
extensions.remove(lt.create_ut_pex_plugin)
ltsession.set_settings(settings)
ltsession.set_alert_mask(self.default_alert_mask)
# Load proxy settings
if hops == 0:
proxy_settings = self.tribler_session.config.get_libtorrent_proxy_settings()
else:
proxy_settings = list(self.tribler_session.config.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
for extension in extensions:
ltsession.add_extension(extension)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.tribler_session.config.get_libtorrent_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port() and store_listen_port:
self.tribler_session.config.set_libtorrent_port_runtime(ltsession.listen_port())
try:
lt_state = lt.bdecode(
open(os.path.join(self.tribler_session.config.get_state_dir(), LTSTATE_FILENAME)).read())
if lt_state is not None:
ltsession.load_state(lt_state)
else:
self._logger.warning("the lt.state appears to be corrupt, writing new data on shutdown")
except Exception, exc:
self._logger.info("could not load libtorrent state, got exception: %r. starting from scratch" % exc)
ltsession.start_dht()
def create_session(self, hops=0):
settings = {}
# Due to a bug in Libtorrent 0.16.18, the outgoing_port and num_outgoing_ports value should be set in
# the settings dictionary
settings['outgoing_port'] = 0
settings['num_outgoing_ports'] = 1
# Copy construct so we don't modify the default list
extensions = list(DEFAULT_LT_EXTENSIONS)
if hops == 0:
settings['user_agent'] = 'Tribler/' + version_id
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(
int,
version_id.split('-')[0].split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
ltsession = lt.session(lt.fingerprint(*fingerprint), flags=0)
enable_utp = self.tribler_session.config.get_libtorrent_utp()
settings['enable_outgoing_utp'] = enable_utp
settings['enable_incoming_utp'] = enable_utp
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
else:
settings['enable_outgoing_utp'] = True
settings['enable_incoming_utp'] = True
settings['enable_outgoing_tcp'] = False
settings['enable_incoming_tcp'] = False
settings['anonymous_mode'] = True
settings['force_proxy'] = True
ltsession = lt.session(flags=0)
# No PEX for anonymous sessions
if lt.create_ut_pex_plugin in extensions:
extensions.remove(lt.create_ut_pex_plugin)
ltsession.set_settings(settings)
ltsession.set_alert_mask(self.default_alert_mask)
# Load proxy settings
if hops == 0:
proxy_settings = self.tribler_session.config.get_libtorrent_proxy_settings(
)
else:
proxy_settings = list(
self.tribler_session.config.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
for extension in extensions:
ltsession.add_extension(extension)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.tribler_session.config.get_libtorrent_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port():
self.tribler_session.config.set_libtorrent_port_runtime(
ltsession.listen_port())
try:
lt_state = lt.bdecode(
open(
os.path.join(
self.tribler_session.config.get_state_dir(),
LTSTATE_FILENAME)).read())
if lt_state is not None:
ltsession.load_state(lt_state)
else:
self._logger.warning(
"the lt.state appears to be corrupt, writing new data on shutdown"
)
except Exception, exc:
self._logger.info(
"could not load libtorrent state, got exception: %r. starting from scratch"
% exc)
ltsession.start_dht()
def get_torrent_info(v1, v2, v3, session, u):
global handle, ses, info, cnt, cnt_limit, file_name, ui, torrent_download_path
ui = u
if not session:
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB', 3, 3, 5, 0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
else:
ses = session
#print(ses.get_settings())
if v1.startswith('magnet:'):
handle = lt.add_magnet_uri(ses, v1, {'save_path': v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i + 1
if i > 60:
print('No Metadata Available')
break
info = handle.get_torrent_info()
else:
info = lt.torrent_info(v1)
#print(info)
#sett = ses.get_settings()
#print(sett)
#print(sett['user_agent'],sett['upload_rate_limit'])
handle = ses.add_torrent({'ti': info, 'save_path': v3})
handle.set_sequential_download(True)
print(handle.trackers())
i = 0
fileIndex = int(v2)
for f in info.files():
if fileIndex == i:
fileStr = f
handle.file_priority(i, 7)
else:
handle.file_priority(i, 0)
i += 1
print(fileStr.path)
file_name = v3 + '/' + fileStr.path
torrent_download_path = v3
file_arr = []
for f in info.files():
file_arr.append(f.path)
i += 1
for i in file_arr:
print(i)
content_length = fileStr.size
print(content_length, 'content-length')
pr = info.map_file(fileIndex, 0, fileStr.size)
print(pr.length, info.piece_length(), info.num_pieces())
n_pieces = pr.length / info.piece_length() + 1
print(n_pieces)
n_pieces = int(n_pieces)
for i in range(info.num_pieces()):
if i in range(pr.piece, pr.piece + n_pieces):
if i == pr.piece:
handle.piece_priority(i, 7)
elif i == pr.piece + 1:
handle.piece_priority(i, 7)
elif i == pr.piece + 2:
handle.piece_priority(i, 1)
elif i == pr.piece + n_pieces - 1:
handle.piece_priority(i, 7)
else:
handle.piece_priority(i, 1)
else:
handle.piece_priority(i, 0)
print('starting', handle.name())
handle.set_sequential_download(True)
cnt = pr.piece
cnt_limit = pr.piece + n_pieces
cnt1 = cnt
print('\n', cnt, cnt_limit, file_name, '---get--torrent--info\n')
if ses.is_paused():
ses.resume()
handle.resume()
return handle, ses, info, cnt, cnt_limit, file_name
def create_session(self, hops=0, store_listen_port=True):
# Due to a bug in Libtorrent 0.16.18, the outgoing_port and num_outgoing_ports value should be set in
# the settings dictionary
settings = {'outgoing_port': 0,
'num_outgoing_ports': 1,
'allow_multiple_connections_per_ip': 0}
# Copy construct so we don't modify the default list
extensions = list(DEFAULT_LT_EXTENSIONS)
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + [int(x) for x in version_id.split('-')[0].split('.')] + [0]
ltsession = lt.session(lt.fingerprint(*fingerprint), flags=0) if hops == 0 else lt.session(flags=0)
if hops == 0:
settings['user_agent'] = 'Tribler/' + version_id
enable_utp = self.tribler_session.config.get_libtorrent_utp()
settings['enable_outgoing_utp'] = enable_utp
settings['enable_incoming_utp'] = enable_utp
if LooseVersion(self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings['prefer_rc4'] = True
settings["listen_interfaces"] = "0.0.0.0:%d" % self.tribler_session.config.get_libtorrent_port()
else:
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
mid = self.tribler_session.trustchain_keypair.key_to_hash()
settings['peer_fingerprint'] = mid
settings['handshake_client_version'] = 'Tribler/' + version_id + '/' + hexlify(mid)
else:
settings['enable_outgoing_utp'] = True
settings['enable_incoming_utp'] = True
settings['enable_outgoing_tcp'] = False
settings['enable_incoming_tcp'] = False
settings['anonymous_mode'] = True
settings['force_proxy'] = True
if LooseVersion(self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings["listen_interfaces"] = "0.0.0.0:%d" % self.tribler_session.config.get_anon_listen_port()
# By default block all IPs except 1.1.1.1 (which is used to ensure libtorrent makes a connection to us)
self.update_ip_filter(ltsession, ['1.1.1.1'])
self.set_session_settings(ltsession, settings)
ltsession.set_alert_mask(self.default_alert_mask)
# Load proxy settings
if hops == 0:
proxy_settings = self.tribler_session.config.get_libtorrent_proxy_settings()
else:
proxy_settings = list(self.tribler_session.config.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
for extension in extensions:
ltsession.add_extension(extension)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.tribler_session.config.get_libtorrent_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port() and store_listen_port:
self.tribler_session.config.set_libtorrent_port_runtime(ltsession.listen_port())
try:
with open(self.tribler_session.config.get_state_dir() / LTSTATE_FILENAME, 'rb') as fp:
lt_state = bdecode_compat(fp.read())
if lt_state is not None:
ltsession.load_state(lt_state)
else:
self._logger.warning("the lt.state appears to be corrupt, writing new data on shutdown")
except Exception as exc:
self._logger.info("could not load libtorrent state, got exception: %r. starting from scratch" % exc)
else:
ltsession.listen_on(self.tribler_session.config.get_anon_listen_port(),
self.tribler_session.config.get_anon_listen_port() + 20)
settings = {'upload_rate_limit': self.tribler_session.config.get_libtorrent_max_upload_rate(),
'download_rate_limit': self.tribler_session.config.get_libtorrent_max_download_rate()}
self.set_session_settings(ltsession, settings)
if self.tribler_session.config.get_libtorrent_dht_enabled():
ltsession.start_dht()
for router in DEFAULT_DHT_ROUTERS:
ltsession.add_dht_router(*router)
ltsession.start_lsd()
self._logger.debug("Started libtorrent session for %d hops on port %d", hops, ltsession.listen_port())
self.lt_session_shutdown_ready[hops] = False
return ltsession
def startSession(self):
logging.info('Starting session...')
self.session = lt.session(lt.fingerprint('LT', lt.version_major, lt.version_minor, 0, 0),
flags=int(lt.session_flags_t.add_default_plugins))
alertMask = (lt.alert.category_t.error_notification |
lt.alert.category_t.storage_notification |
lt.alert.category_t.tracker_notification |
lt.alert.category_t.status_notification)
if self.config.debugAlerts:
alertMask |= lt.alert.category_t.debug_notification
self.session.set_alert_mask(alertMask)
settings = self.session.get_settings()
settings["request_timeout"] = self.config.requestTimeout
settings["peer_connect_timeout"] = self.config.peerConnectTimeout
settings["announce_to_all_trackers"] = True
settings["announce_to_all_tiers"] = True
settings["torrent_connect_boost"] = self.config.torrentConnectBoost
settings["connection_speed"] = self.config.connectionSpeed
settings["min_reconnect_time"] = self.config.minReconnectTime
settings["max_failcount"] = self.config.maxFailCount
settings["recv_socket_buffer_size"] = 1024 * 1024
settings["send_socket_buffer_size"] = 1024 * 1024
settings["rate_limit_ip_overhead"] = True
settings["min_announce_interval"] = 60
settings["tracker_backoff"] = 0
self.session.set_settings(settings)
if self.config.stateFile != '':
logging.info('Loading session state from %s' % (self.config.stateFile,))
try:
with open(self.config.stateFile, 'rb') as f:
bytes__ = f.read()
except IOError as e:
strerror = e.args
logging.error(strerror)
else:
self.session.load_state(lt.bdecode(bytes__))
rand = SystemRandom(time.time())
portLower = self.config.listenPort
if self.config.randomPort:
portLower = rand.randint(0, 16374) + 49151
portUpper = portLower + 10
try:
self.session.listen_on(portLower, portUpper)
except IOError as e:
strerror = e.args
logging.error(strerror)
raise
settings = self.session.get_settings()
if self.config.userAgent != '':
settings['user_agent'] = self.config.userAgent
if self.config.connectionsLimit >= 0:
settings['connections_limit'] = self.config.connectionsLimit
if self.config.maxDownloadRate >= 0:
settings['download_rate_limit'] = self.config.maxDownloadRate * 1024
if self.config.maxUploadRate >= 0:
settings['upload_rate_limit'] = self.config.maxUploadRate * 1024
settings['enable_incoming_tcp'] = self.config.enableTCP
settings['enable_outgoing_tcp'] = self.config.enableTCP
settings['enable_incoming_utp'] = self.config.enableUTP
settings['enable_outgoing_utp'] = self.config.enableUTP
self.session.set_settings(settings)
if self.config.dhtRouters != '':
routers = self.config.dhtRouters.split(',')
for router in routers:
router = router.strip()
if router != '':
hostPort = router.split(':')
host = hostPort[0].strip()
try:
port = len(hostPort) > 1 and int(hostPort[1].strip()) or 6881
except ValueError as e:
strerror = e.args
logging.error(strerror)
raise
self.session.add_dht_router(host, port)
logging.info('Added DHT router: %s:%d' % (host, port))
logging.info('Setting encryption settings')
try:
encryptionSettings = lt.pe_settings()
encryptionSettings.out_enc_policy = lt.enc_policy(self.config.encryption)
encryptionSettings.in_enc_policy = lt.enc_policy(self.config.encryption)
encryptionSettings.allowed_enc_level = lt.enc_level.both
encryptionSettings.prefer_rc4 = True
self.session.set_pe_settings(encryptionSettings)
except Exception as e:
logging.info('Encryption not supported: %s' % (e.args,))
def startSession(self):
logging.info('Starting session...')
self.session = lt.session(
lt.fingerprint('LT', lt.version_major, lt.version_minor, 0, 0),
flags=int(lt.session_flags_t.add_default_plugins))
alertMask = (lt.alert.category_t.error_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.tracker_notification
| lt.alert.category_t.status_notification)
if self.config.debugAlerts:
alertMask |= lt.alert.category_t.debug_notification
self.session.set_alert_mask(alertMask)
settings = self.session.get_settings()
settings["request_timeout"] = self.config.requestTimeout
settings["peer_connect_timeout"] = self.config.peerConnectTimeout
settings["announce_to_all_trackers"] = True
settings["announce_to_all_tiers"] = True
settings["torrent_connect_boost"] = self.config.torrentConnectBoost
settings["connection_speed"] = self.config.connectionSpeed
settings["min_reconnect_time"] = self.config.minReconnectTime
settings["max_failcount"] = self.config.maxFailCount
settings["recv_socket_buffer_size"] = 1024 * 1024
settings["send_socket_buffer_size"] = 1024 * 1024
settings["rate_limit_ip_overhead"] = True
settings["min_announce_interval"] = 60
settings["tracker_backoff"] = 0
self.session.set_settings(settings)
if self.config.stateFile != '':
logging.info('Loading session state from %s' %
(self.config.stateFile, ))
try:
with open(self.config.stateFile, 'rb') as f:
bytes__ = f.read()
except IOError as e:
strerror = e.args
logging.error(strerror)
else:
self.session.load_state(lt.bdecode(bytes__))
rand = SystemRandom(time.time())
portLower = self.config.listenPort
if self.config.randomPort:
portLower = rand.randint(0, 16374) + 49151
portUpper = portLower + 10
try:
self.session.listen_on(portLower, portUpper)
except IOError as e:
strerror = e.args
logging.error(strerror)
raise
settings = self.session.get_settings()
if self.config.userAgent != '':
settings['user_agent'] = self.config.userAgent
if self.config.connectionsLimit >= 0:
settings['connections_limit'] = self.config.connectionsLimit
if self.config.maxDownloadRate >= 0:
settings[
'download_rate_limit'] = self.config.maxDownloadRate * 1024
if self.config.maxUploadRate >= 0:
settings['upload_rate_limit'] = self.config.maxUploadRate * 1024
settings['enable_incoming_tcp'] = self.config.enableTCP
settings['enable_outgoing_tcp'] = self.config.enableTCP
settings['enable_incoming_utp'] = self.config.enableUTP
settings['enable_outgoing_utp'] = self.config.enableUTP
self.session.set_settings(settings)
if self.config.dhtRouters != '':
routers = self.config.dhtRouters.split(',')
for router in routers:
router = router.strip()
if router != '':
hostPort = router.split(':')
host = hostPort[0].strip()
try:
port = len(hostPort) > 1 and int(
hostPort[1].strip()) or 6881
except ValueError as e:
strerror = e.args
logging.error(strerror)
raise
self.session.add_dht_router(host, port)
logging.info('Added DHT router: %s:%d' % (host, port))
logging.info('Setting encryption settings')
try:
encryptionSettings = lt.pe_settings()
encryptionSettings.out_enc_policy = lt.enc_policy(
self.config.encryption)
encryptionSettings.in_enc_policy = lt.enc_policy(
self.config.encryption)
encryptionSettings.allowed_enc_level = lt.enc_level.both
encryptionSettings.prefer_rc4 = True
self.session.set_pe_settings(encryptionSettings)
except Exception as e:
logging.info('Encryption not supported: %s' % (e.args, ))
def get_torrent_info(v1,v2,v3,session,u,p_bar,tmp_dir,key=None,client=None):
global handle,ses,info,cnt,cnt_limit,file_name,ui,torrent_download_path
global progress,total_size_content,tmp_dir_folder,content_length
global media_server_key,client_auth_arr
media_server_key = key
client_auth_arr = client
content_length = 0
ui = u
progress = p_bar
tmp_dir_folder = tmp_dir
progress.setValue(0)
progress.show()
if not session:
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB',3,3,5,0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
else:
ses = session
#print(ses.get_settings())
if v1.startswith('magnet:'):
handle = lt.add_magnet_uri(ses,v1,{'save_path':v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i+1
if i > 60:
print('No Metadata Available')
break
info = handle.get_torrent_info()
else:
info = lt.torrent_info(v1)
#print(info)
#sett = ses.get_settings()
#print(sett)
#print(sett['user_agent'],sett['upload_rate_limit'])
handle = ses.add_torrent({'ti': info, 'save_path': v3})
handle.set_sequential_download(True)
print(handle.trackers())
print(ses.get_torrents(),'torrents_list')
torr_arr = ses.get_torrents()
for i in torr_arr:
print(i.name())
i=0
fileIndex = int(v2)
file_found = False
for f in info.files():
file_exists = False
new_path = os.path.join(v3,f.path)
new_size = f.size
if os.path.exists(new_path) and os.stat(new_path).st_size == new_size:
file_exists = True
if fileIndex == i:
fileStr = f
handle.file_priority(i,7)
if file_exists:
file_found = True
else:
if file_exists:
handle.file_priority(i,1)
else:
handle.file_priority(i,0)
i = i+1
print (fileStr.path)
file_name = os.path.join(v3,fileStr.path)
torrent_download_path = v3
file_arr =[]
for f in info.files():
file_arr.append(f.path)
i += 1
for i in file_arr:
print(i)
content_length = fileStr.size
print(content_length,'content-length')
total_size_content = str(int(content_length/(1024*1024)))+'M'
pr = info.map_file(fileIndex,0,fileStr.size)
print(pr.length,info.piece_length(),info.num_pieces())
n_pieces = pr.length / info.piece_length() + 1
print(n_pieces)
n_pieces = int(n_pieces)
for i in range(info.num_pieces()):
if i in range(pr.piece,pr.piece+n_pieces):
if i in range(pr.piece,pr.piece+10):
if i == pr.piece:
handle.piece_priority(i,7)
else:
handle.piece_priority(i,6)
elif i == pr.piece+n_pieces-1:
handle.piece_priority(i,7)
else:
handle.piece_priority(i,1)
tmp = ''
for i in range(info.num_pieces()):
tmp = tmp+':'+str(handle.piece_priority(i))
print(tmp)
print ('starting', handle.name())
handle.set_sequential_download(True)
cnt = pr.piece
cnt_limit = pr.piece+n_pieces
cnt1 = cnt
print('\n',cnt,cnt_limit,file_name,'---get--torrent--info\n')
if ses.is_paused():
ses.resume()
handle.resume()
return handle,ses,info,cnt,cnt_limit,file_name
def get_torrent_info(v1,v2,v3,session,u):
global handle,ses,info,cnt,cnt_limit,file_name,ui,torrent_download_path
ui = u
if not session:
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB',3,3,5,0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
else:
ses = session
#print(ses.get_settings())
if v1.startswith('magnet:'):
handle = lt.add_magnet_uri(ses,v1,{'save_path':v3})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i+1
if i > 60:
print('No Metadata Available')
break
info = handle.get_torrent_info()
else:
info = lt.torrent_info(v1)
#print(info)
#sett = ses.get_settings()
#print(sett)
#print(sett['user_agent'],sett['upload_rate_limit'])
handle = ses.add_torrent({'ti': info, 'save_path': v3})
handle.set_sequential_download(True)
print(handle.trackers())
i=0
fileIndex = int(v2)
for f in info.files():
if fileIndex == i:
fileStr = f
handle.file_priority(i,7)
else:
handle.file_priority(i,0)
i += 1
print (fileStr.path)
file_name = v3+'/'+fileStr.path
torrent_download_path = v3
file_arr =[]
for f in info.files():
file_arr.append(f.path)
i += 1
for i in file_arr:
print(i)
content_length = fileStr.size
print(content_length,'content-length')
pr = info.map_file(fileIndex,0,fileStr.size)
print(pr.length,info.piece_length(),info.num_pieces())
n_pieces = pr.length / info.piece_length() + 1
print(n_pieces)
n_pieces = int(n_pieces)
for i in range(info.num_pieces()):
if i in range(pr.piece,pr.piece+n_pieces):
if i == pr.piece:
handle.piece_priority(i,7)
elif i == pr.piece+1:
handle.piece_priority(i,7)
elif i == pr.piece+2:
handle.piece_priority(i,1)
elif i == pr.piece+n_pieces-1:
handle.piece_priority(i,7)
else:
handle.piece_priority(i,1)
else:
handle.piece_priority(i,0)
print ('starting', handle.name())
handle.set_sequential_download(True)
cnt = pr.piece
cnt_limit = pr.piece+n_pieces
cnt1 = cnt
print('\n',cnt,cnt_limit,file_name,'---get--torrent--info\n')
if ses.is_paused():
ses.resume()
handle.resume()
return handle,ses,info,cnt,cnt_limit,file_name
def create_session(self, hops=0, store_listen_port=True):
settings = {}
# Due to a bug in Libtorrent 0.16.18, the outgoing_port and num_outgoing_ports value should be set in
# the settings dictionary
settings['outgoing_port'] = 0
settings['num_outgoing_ports'] = 1
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(int,
version_id.split('-')[0].split('.')) + [0]
ltsession = lt.session(lt.fingerprint(
*fingerprint), flags=1) if hops == 0 else lt.session(flags=0)
if hops == 0:
settings['user_agent'] = 'Tribler/' + version_id
enable_utp = self.trsession.get_libtorrent_utp()
settings['enable_outgoing_utp'] = enable_utp
settings['enable_incoming_utp'] = enable_utp
if LooseVersion(
self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings['prefer_rc4'] = True
settings[
"listen_interfaces"] = "0.0.0.0:%d" % self.trsession.get_listen_port(
)
else:
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
else:
settings['enable_outgoing_utp'] = True
settings['enable_incoming_utp'] = True
settings['enable_outgoing_tcp'] = False
settings['enable_incoming_tcp'] = False
settings['anonymous_mode'] = True
settings['force_proxy'] = True
if LooseVersion(
self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings[
"listen_interfaces"] = "0.0.0.0:%d" % self.trsession.get_anon_listen_port(
)
# No PEX for anonymous sessions
ltsession = lt.session(flags=0)
ltsession.add_extension(lt.create_ut_metadata_plugin)
ltsession.add_extension(lt.create_smart_ban_plugin)
ltsession.set_settings(settings)
ltsession.set_alert_mask(lt.alert.category_t.stats_notification
| lt.alert.category_t.error_notification
| lt.alert.category_t.status_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.performance_warning
| lt.alert.category_t.tracker_notification)
# Load proxy settings
if hops == 0:
proxy_settings = self.trsession.get_libtorrent_proxy_settings()
else:
proxy_settings = list(self.trsession.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.trsession.get_listen_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port() and store_listen_port:
self.trsession.set_listen_port_runtime(ltsession.listen_port())
try:
lt_state = lt.bdecode(
open(
os.path.join(self.trsession.get_state_dir(),
LTSTATE_FILENAME)).read())
if lt_state is not None:
ltsession.load_state(lt_state)
else:
self._logger.warning(
"the lt.state appears to be corrupt, writing new data on shutdown"
)
except Exception, exc:
self._logger.info(
"could not load libtorrent state, got exception: %r. starting from scratch"
% exc)
ltsession.start_dht()
def get_torrent_info(torrent_file,
file_index,
file_dest,
session,
u,
p_bar,
tmp_dir,
key=None,
client=None,
torrent_handle=None):
global handle, ses, info, count, count_limit, file_name, ui
global progress, total_size_content, tmp_dir_folder, content_length
global media_server_key, client_auth_arr, torrent_download_path
media_server_key = key
client_auth_arr = client
content_length = 0
ui = u
progress = p_bar
tmp_dir_folder = tmp_dir
progress.setValue(0)
progress.show()
if not session:
sett = lt.session_settings()
sett.user_agent = 'qBittorrent v3.3.5'
sett.always_send_user_agent = True
fingerprint = lt.fingerprint('qB', 3, 3, 5, 0)
ses = lt.session(fingerprint)
ses.listen_on(40000, 50000)
ses.set_settings(sett)
else:
ses = session
if torrent_file.startswith('magnet:'):
handle = lt.add_magnet_uri(ses, torrent_file, {'save_path': file_dest})
i = 0
while (not handle.has_metadata()):
time.sleep(1)
i = i + 1
if i > 60:
print('No Metadata Available')
break
info = handle.get_torrent_info()
elif torrent_handle and torrent_handle.is_valid():
info = lt.torrent_info(torrent_file)
handle = torrent_handle
else:
info = lt.torrent_info(torrent_file)
handle = ses.add_torrent({'ti': info, 'save_path': file_dest})
fileIndex = int(file_index)
for i, f in enumerate(info.files()):
file_exists = False
new_path = os.path.join(file_dest, f.path)
new_size = f.size
if os.path.exists(new_path) and os.stat(new_path).st_size:
file_exists = True
if fileIndex == i:
fileStr = f
handle.file_priority(i, 1)
elif file_exists:
handle.file_priority(i, 1)
else:
handle.file_priority(i, 0)
print(fileStr.path)
file_name = os.path.join(file_dest, fileStr.path)
torrent_download_path = file_dest
content_length = fileStr.size
print(content_length, 'content-length')
total_size_content = str(int(content_length / (1024 * 1024))) + 'M'
pr = info.map_file(fileIndex, 0, fileStr.size)
print(pr.length, info.piece_length(), info.num_pieces())
n_pieces = pr.length / info.piece_length() + 1
print(n_pieces)
n_pieces = int(n_pieces)
count = pr.piece
count_limit = pr.piece + n_pieces - 1
assign_piece_priority(handle, info, count, count_limit)
print('starting', handle.name())
handle.set_sequential_download(True)
if ses.is_paused():
ses.resume()
if handle.status().paused:
handle.resume()
return handle, ses, info, count, count_limit, file_name
def create_session(self, hops=0, store_listen_port=True):
settings = {}
# Due to a bug in Libtorrent 0.16.18, the outgoing_port and num_outgoing_ports value should be set in
# the settings dictionary
settings['outgoing_port'] = 0
settings['num_outgoing_ports'] = 1
settings['allow_multiple_connections_per_ip'] = 0
# Copy construct so we don't modify the default list
extensions = list(DEFAULT_LT_EXTENSIONS)
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + [int(x) for x in version_id.split('-')[0].split('.')] + [0]
ltsession = lt.session(lt.fingerprint(*fingerprint), flags=0) if hops == 0 else lt.session(flags=0)
if hops == 0:
settings['user_agent'] = 'Tribler/' + version_id
enable_utp = self.tribler_session.config.get_libtorrent_utp()
settings['enable_outgoing_utp'] = enable_utp
settings['enable_incoming_utp'] = enable_utp
if LooseVersion(self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings['prefer_rc4'] = True
settings["listen_interfaces"] = "0.0.0.0:%d" % self.tribler_session.config.get_libtorrent_port()
else:
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
mid = self.tribler_session.trustchain_keypair.key_to_hash()
settings['peer_fingerprint'] = mid
settings['handshake_client_version'] = 'Tribler/' + version_id + '/' + str(hexlify(mid))
else:
settings['enable_outgoing_utp'] = True
settings['enable_incoming_utp'] = True
settings['enable_outgoing_tcp'] = False
settings['enable_incoming_tcp'] = False
settings['anonymous_mode'] = True
settings['force_proxy'] = True
if LooseVersion(self.get_libtorrent_version()) >= LooseVersion("1.1.0"):
settings["listen_interfaces"] = "0.0.0.0:%d" % self.tribler_session.config.get_anon_listen_port()
self.set_session_settings(ltsession, settings)
ltsession.set_alert_mask(self.default_alert_mask)
# Load proxy settings
if hops == 0:
proxy_settings = self.tribler_session.config.get_libtorrent_proxy_settings()
else:
proxy_settings = list(self.tribler_session.config.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
for extension in extensions:
ltsession.add_extension(extension)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.tribler_session.config.get_libtorrent_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port() and store_listen_port:
self.tribler_session.config.set_libtorrent_port_runtime(ltsession.listen_port())
try:
lt_state = lt.bdecode(
open(os.path.join(self.tribler_session.config.get_state_dir(), LTSTATE_FILENAME)).read())
if lt_state is not None:
ltsession.load_state(lt_state)
else:
self._logger.warning("the lt.state appears to be corrupt, writing new data on shutdown")
except Exception as exc:
self._logger.info("could not load libtorrent state, got exception: %r. starting from scratch" % exc)
else:
ltsession.listen_on(self.tribler_session.config.get_anon_listen_port(),
self.tribler_session.config.get_anon_listen_port() + 20)
ltsession_settings = ltsession.get_settings()
ltsession_settings['upload_rate_limit'] = self.tribler_session.config.get_libtorrent_max_upload_rate()
ltsession_settings['download_rate_limit'] = self.tribler_session.config.get_libtorrent_max_download_rate()
self.set_session_settings(ltsession, ltsession_settings)
if self.tribler_session.config.get_libtorrent_dht_enabled():
ltsession.start_dht()
for router in DEFAULT_DHT_ROUTERS:
ltsession.add_dht_router(*router)
ltsession.start_lsd()
self._logger.debug("Started libtorrent session for %d hops on port %d", hops, ltsession.listen_port())
self.lt_session_shutdown_ready[hops] = False
return ltsession
def create_session(self, hops=0):
settings = lt.session_settings()
if hops == 0:
settings.user_agent = 'Tribler/' + version_id
# Elric: Strip out the -rcX, -beta, -whatever tail on the version string.
fingerprint = ['TL'] + map(
int,
version_id.split('-')[0].split('.')) + [0]
# Workaround for libtorrent 0.16.3 segfault (see https://code.google.com/p/libtorrent/issues/detail?id=369)
ltsession = lt.session(lt.fingerprint(*fingerprint), flags=1)
enable_utp = self.trsession.get_libtorrent_utp()
settings.enable_outgoing_utp = enable_utp
settings.enable_incoming_utp = enable_utp
pe_settings = lt.pe_settings()
pe_settings.prefer_rc4 = True
ltsession.set_pe_settings(pe_settings)
else:
settings.enable_outgoing_utp = True
settings.enable_incoming_utp = True
settings.enable_outgoing_tcp = False
settings.enable_incoming_tcp = False
settings.anonymous_mode = True
# No PEX for anonymous sessions
ltsession = lt.session(flags=0)
ltsession.add_extension(lt.create_ut_metadata_plugin)
ltsession.add_extension(lt.create_smart_ban_plugin)
ltsession.set_settings(settings)
ltsession.set_alert_mask(lt.alert.category_t.stats_notification
| lt.alert.category_t.error_notification
| lt.alert.category_t.status_notification
| lt.alert.category_t.storage_notification
| lt.alert.category_t.performance_warning
| lt.alert.category_t.tracker_notification)
# Load proxy settings
if hops == 0:
proxy_settings = self.trsession.get_libtorrent_proxy_settings()
else:
proxy_settings = list(self.trsession.get_anon_proxy_settings())
proxy_host, proxy_ports = proxy_settings[1]
proxy_settings[1] = (proxy_host, proxy_ports[hops - 1])
self.set_proxy_settings(ltsession, *proxy_settings)
# Set listen port & start the DHT
if hops == 0:
listen_port = self.trsession.get_listen_port()
ltsession.listen_on(listen_port, listen_port + 10)
if listen_port != ltsession.listen_port():
self.trsession.set_listen_port_runtime(ltsession.listen_port())
try:
dht_state = open(
os.path.join(self.trsession.get_state_dir(),
DHTSTATE_FILENAME)).read()
ltsession.start_dht(lt.bdecode(dht_state))
except Exception, exc:
self._logger.info(
"could not restore dht state, got exception: %r. starting from scratch"
% exc)
ltsession.start_dht(None)
