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)