def __init__(self, config, Output):
try:
self.config = config
self.Output = Output
self.torrent_dir = config["torrent_dir"]
self.torrent_cache = {}
self.file_cache = {}
self.blocked_files = {}
self.scan_period = config["parse_dir_interval"]
self.stats_period = config["display_interval"]
self.torrent_list = []
self.downloads = {}
self.counter = 0
self.doneflag = Event()
self.hashcheck_queue = []
self.hashcheck_current = None
self.rawserver = RawServer(
self.doneflag,
config["timeout_check_interval"],
config["timeout"],
ipv6_enable=config["ipv6_enabled"],
failfunc=self.failed,
errorfunc=self.exchandler,
)
upnp_type = UPnP_test(config["upnp_nat_access"])
while 1:
try:
self.listen_port = self.rawserver.find_and_bind(
config["minport"],
config["maxport"],
config["bind"],
ipv6_socket_style=config["ipv6_binds_v4"],
upnp=upnp_type,
randomizer=config["random_port"],
)
break
except socketerror, e:
if upnp_type and e == UPnP_ERROR:
self.Output.message("WARNING: COULD NOT FORWARD VIA UPnP")
upnp_type = 0
continue
self.failed("Couldn't listen - " + str(e))
return
self.ratelimiter = RateLimiter(self.rawserver.add_task, config["upload_unit_size"])
self.ratelimiter.set_upload_rate(config["max_upload_rate"])
self.handler = MultiHandler(self.rawserver, self.doneflag)
seed(createPeerID())
self.rawserver.add_task(self.scan, 0)
self.rawserver.add_task(self.stats, 0)
self.start()
def __init__(self, config, Output):
try:
self.config = config
self.Output = Output
self.torrent_dir = config['torrent_dir']
self.torrent_cache = {}
self.file_cache = {}
self.blocked_files = {}
self.scan_period = config['parse_dir_interval']
self.stats_period = config['display_interval']
self.torrent_list = []
self.downloads = {}
self.counter = 0
self.doneflag = Event()
self.hashcheck_queue = []
self.hashcheck_current = None
self.rawserver = RawServer(self.doneflag, config['timeout_check_interval'],
config['timeout'], ipv6_enable = config['ipv6_enabled'],
failfunc = self.failed, errorfunc = self.exchandler)
upnp_type = UPnP_test(config['upnp_nat_access'])
while True:
try:
self.listen_port = self.rawserver.find_and_bind(
config['minport'], config['maxport'], config['bind'],
ipv6_socket_style = config['ipv6_binds_v4'],
upnp = upnp_type, randomizer = config['random_port'])
break
except socketerror, e:
if upnp_type and e == UPnP_ERROR:
self.Output.message('WARNING: COULD NOT FORWARD VIA UPnP')
upnp_type = 0
continue
self.failed("Couldn't listen - " + str(e))
return
self.ratelimiter = RateLimiter(self.rawserver.add_task,
config['upload_unit_size'])
self.ratelimiter.set_upload_rate(config['max_upload_rate'])
self.handler = MultiHandler(self.rawserver, self.doneflag, config)
seed(createPeerID())
self.rawserver.add_task(self.scan, 0)
self.rawserver.add_task(self.stats, 0)
self.handler.listen_forever()
self.Output.message('shutting down')
self.hashcheck_queue = []
for hash in self.torrent_list:
self.Output.message('dropped "'+self.torrent_cache[hash]['path']+'"')
self.downloads[hash].shutdown()
self.rawserver.shutdown()
def __init__(self, config, Output):
try:
self.config = config
self.Output = Output
self.torrent_dir = config['torrent_dir']
self.torrent_cache = {}
self.file_cache = {}
self.blocked_files = {}
self.scan_period = config['parse_dir_interval']
self.stats_period = config['display_interval']
self.torrent_list = []
self.downloads = {}
self.counter = 0
self.doneflag = Event()
self.hashcheck_queue = []
self.hashcheck_current = None
self.rawserver = RawServer(self.doneflag, config['timeout_check_interval'],
config['timeout'], ipv6_enable = config['ipv6_enabled'],
failfunc = self.failed, errorfunc = self.exchandler)
upnp_type = UPnP_test(config['upnp_nat_access'])
while True:
try:
self.listen_port = self.rawserver.find_and_bind(
config['minport'], config['maxport'], config['bind'],
ipv6_socket_style = config['ipv6_binds_v4'],
upnp = upnp_type, randomizer = config['random_port'])
break
except socketerror, e:
if upnp_type and e == UPnP_ERROR:
self.Output.message('WARNING: COULD NOT FORWARD VIA UPnP')
upnp_type = 0
continue
self.failed("Couldn't listen - " + str(e))
return
self.ratelimiter = RateLimiter(self.rawserver.add_task,
config['upload_unit_size'])
self.ratelimiter.set_upload_rate(config['max_upload_rate'])
self.handler = MultiHandler(self.rawserver, self.doneflag)
seed(createPeerID())
self.rawserver.add_task(self.scan, 0)
self.rawserver.add_task(self.stats, 0)
self.handler.listen_forever()
self.Output.message('shutting down')
self.hashcheck_queue = []
for hash in self.torrent_list:
self.Output.message('dropped "'+self.torrent_cache[hash]['path']+'"')
self.downloads[hash].shutdown()
self.rawserver.shutdown()
def add(self, hash, data):
c = self.counter
self.counter += 1
x = ''
for i in xrange(3):
x = mapbase64[c & 0x3F]+x
c >>= 6
peer_id = createPeerID(x)
d = SingleDownload(self, hash, data['metainfo'], self.config, peer_id)
self.torrent_list.append(hash)
self.downloads[hash] = d
d.start()
def add(self, hash, data):
c = self.counter
self.counter += 1
x = ''
for i in xrange(3):
x = mapbase64[c & 0x3F]+x
c >>= 6
peer_id = createPeerID(x)
d = SingleDownload(self, hash, data['metainfo'], self.config, peer_id)
self.torrent_list.append(hash)
self.downloads[hash] = d
d.start()
def add(self, item):
hash,data = item.infohash_bin,item.get_meta()
self.torrent_list.append(hash)
self.downloads[hash] = item
c = self.counter
self.counter += 1
x = ''
for i in xrange(3):
x = mapbase64[c & 0x3F]+x
c >>= 6
peer_id = createPeerID(x)
if not self.policy(policy.USE_SINGLE_PORT):
minport = self.policy(policy.MIN_PORT)
maxport = self.policy(policy.MAX_PORT)
maxport = max(minport,maxport)
listen_port = self.rawserver.find_and_bind(
minport, maxport,
self.policy(policy.BIND_IP),
ipv6_socket_style = self.policy(policy.IPV6_BINDS_V4),
upnp = self.upnp,
randomizer = self.policy(policy.RANDOM_PORT))
else:
listen_port = None
config = copy.copy(self.config)
config['saveas'] = item.dest_path
config['spew'] = 1
config['min_peers'] = self.policy(policy.MIN_PEER)
config['max_connections'] = self.policy(policy.MAX_PEER)
config['max_initiate'] = self.policy(policy.MAX_INITIATE)
config['rerequest_interval'] = self.policy(policy.REREQUEST_INTERVAL)
try:
d = SingleDownload(self,item,hash,data,
config,peer_id,listen_port)
item.dow = d
item.listen_port = listen_port
if item.recheck:
d.deleteTorrentData()
item.recheck = 0
d.start()
except Exception,why:
import traceback
traceback.print_exc()
self.remove(item)
self.exchandler(why)
def add(self, hash, data):
#check if we already know about this torrent:
if hash in self.downloads:
#if so, just add the trackers and return:
self.downloads[hash].add_trackers(data['metainfo'])
#and tell the user that that is what happened, so they're not suprised:
GUIController.get().show_msgbox(
"BitBlinder added all new trackers from that .torrent file.",
title="Already Downloading Torrent!")
return None
self.counter += 1
peer_id = createPeerID()
d = Torrent(self, hash, data['metainfo'], self.config, peer_id,
self.dht, self.can_open_more_connections)
self.torrent_list.append(hash)
self.downloads[hash] = d
#added because this normally happens when scanning:
self.torrent_cache[hash] = data
return d
import socket
from traceback import print_exc
from subnetparse import IP_List
from clock import clock
from __init__ import createPeerID
try:
True
except:
True = 1
False = 0
DEBUG = False
EXPIRE_CACHE = 30 # seconds
ID = "BT-"+createPeerID()[-4:]
try:
import pythoncom, win32com.client
_supported = 1
except ImportError:
_supported = 0
class _UPnP1: # derived from Myers Carpenter's code
# seems to use the machine's local UPnP
# system for its operation. Runs fairly fast
def __init__(self):
self.map = None
import time
from traceback import print_exc
from subnetparse import IP_List
from clock import clock
from __init__ import createPeerID
from ACEStream.Core.NATFirewall.upnp import UPnPPlatformIndependent, UPnPError
from ACEStream.Core.NATFirewall.guessip import get_my_wan_ip
try:
True
except:
True = 1
False = 0
DEBUG = False
EXPIRE_CACHE = 30
ID = 'BT-' + createPeerID()[-4:]
try:
import pythoncom, win32com.client
win32_imported = 1
except ImportError:
if DEBUG and sys.platform == 'win32':
print >> sys.stderr, "natpunch: ERROR: pywin32 package not installed, UPnP mode 2 won't work now"
win32_imported = 0
UPnPError = UPnPError
class _UPnP1:
def __init__(self):
self.map = None
self.last_got_map = -100000000000.0
import __init__
import socket
from traceback import print_exc
from NetworkAddress import AddrList
from clock import clock
DEBUG = False
EXPIRE_CACHE = 30 # seconds
ID = "BT-" + __init__.createPeerID()[-4:]
try:
import pythoncom
import win32com.client
_supported = 1
except ImportError:
_supported = 0
class _UPnP1: # derived from Myers Carpenter's code
# seems to use the machine's local UPnP
# system for its operation. Runs fairly fast
def __init__(self):
self.map = None
self.last_got_map = -10e10
def _get_map(self):
if self.last_got_map + EXPIRE_CACHE < clock():
try:
dispatcher = win32com.client.Dispatch("HNetCfg.NATUPnP")
def download(params,
filefunc,
statusfunc,
finfunc,
errorfunc,
doneflag,
cols,
pathFunc=None,
presets={},
exchandler=None,
failed=_failfunc,
paramfunc=None):
try:
config = parse_params(params, presets)
except ValueError as e:
failed(
'error: {}\nrun with no args for parameter explanations'.format(e))
return
if not config:
errorfunc(get_usage())
return
myid = createPeerID()
random.seed(myid)
rawserver = RawServer(doneflag,
config['timeout_check_interval'],
config['timeout'],
ipv6_enable=config['ipv6_enabled'],
failfunc=failed,
errorfunc=exchandler)
upnp_type = UPnP_test(config['upnp_nat_access'])
try:
listen_port = rawserver.find_and_bind(
config['minport'],
config['maxport'],
config['bind'],
ipv6_socket_style=config['ipv6_binds_v4'],
upnp=upnp_type,
randomizer=config['random_port'])
except socket.error as e:
failed("Couldn't listen - " + str(e))
return
response = get_response(config['responsefile'], config['url'], failed)
if not response:
return
infohash = hashlib.sha1(bencode(response['info'])).digest()
d = BT1Download(statusfunc, finfunc, errorfunc, exchandler, doneflag,
config, response, infohash, myid, rawserver, listen_port)
if not d.saveAs(filefunc):
return
if pathFunc:
pathFunc(d.getFilename())
hashcheck = d.initFiles(old_style=True)
if not hashcheck:
return
if not hashcheck():
return
if not d.startEngine():
return
d.startRerequester()
d.autoStats()
statusfunc(activity='connecting to peers')
if paramfunc:
paramfunc({
# change_max_upload_rate(<int KiB/sec>)
'max_upload_rate': d.setUploadRate,
# change_max_uploads(<int max uploads>)
'max_uploads': d.setConns,
'listen_port': listen_port, # int
'peer_id': myid, # string
'info_hash': infohash, # string
# start_connection((<string ip>, <int port>), <peer id>)
'start_connection': d._startConnection,
})
rawserver.listen_forever(d.getPortHandler())
d.shutdown()
def __init__(self, config, Output, isAnonymous):
try:
self.config = config
self.Output = Output
self.torrent_dir = config['torrent_dir']
self.torrent_cache = {}
self.file_cache = {}
self.blocked_files = {}
self.scan_period = config['parse_dir_interval']
self.stats_period = config['display_interval']
self.torrent_list = []
self.downloads = {}
self.counter = 0
self.doneflag = Event()
self.hashcheck_queue = []
self.hashcheck_current = None
self.rawserver = JashRawServer()
upnp_type = UPnP_test(config['upnp_nat_access'])
self.listen_port = None
while True:
try:
self.listen_port = self.rawserver.find_and_bind(
config['minport'],
config['maxport'],
config['bind'],
ipv6_socket_style=config['ipv6_binds_v4'],
upnp=upnp_type,
randomizer=config['random_port'])
break
except socketerror, e:
if upnp_type and e == UPnP_ERROR:
log_msg('WARNING: COULD NOT FORWARD VIA UPnP', 0)
upnp_type = 0
continue
self.failed("Couldn't listen - " + str(e))
return
self.dht = None
if isAnonymous:
self.dht = dht.Proxy.DHTProxy(
BitTorrent.BitTorrentClient.get())
else:
if self.listen_port:
self.dht = dht.Node.LocalDHTNode(self.listen_port,
config['dht_file_name'])
self.ratelimiter = RateLimiter(self.rawserver.add_task,
config['upload_unit_size'])
self.ratelimiter.set_upload_rate(config['max_upload_rate'])
self.handler = MultiHandler(self.rawserver, self.doneflag, config)
seed(createPeerID())
#self.rawserver.add_task(self.scan, 0)
if self.scan_period:
self.scan()
self.scanEvent = Scheduler.schedule_repeat(
self.scan_period, self.scan)
else:
self.scanEvent = None
import time
from traceback import print_exc
from subnetparse import IP_List
from clock import clock
from __init__ import createPeerID
from freestream.Core.NATFirewall.upnp import UPnPPlatformIndependent, UPnPError
from freestream.Core.NATFirewall.guessip import get_my_wan_ip
try:
True
except:
True = 1
False = 0
DEBUG = False
EXPIRE_CACHE = 30
ID = 'BT-' + createPeerID()[-4:]
try:
import pythoncom, win32com.client
win32_imported = 1
except ImportError:
if DEBUG and sys.platform == 'win32':
print >> sys.stderr, "natpunch: ERROR: pywin32 package not installed, UPnP mode 2 won't work now"
win32_imported = 0
UPnPError = UPnPError
class _UPnP1:
def __init__(self):
self.map = None
self.last_got_map = -100000000000.0
# Written by John Hoffman
# derived from NATPortMapping.py by Yejun Yang
# and from example code by Myers Carpenter
# see LICENSE.txt for license information
import socket
from traceback import print_exc
from subnetparse import IP_List
from clock import clock
from __init__ import createPeerID
DEBUG = False
EXPIRE_CACHE = 30 # seconds
ID = "BL-"+createPeerID()[-4:]
try:
import pythoncom, win32com.client
_supported = 1
except ImportError:
_supported = 0
class _UPnP1: # derived from Myers Carpenter's code
# seems to use the machine's local UPnP
# system for its operation. Runs fairly fast
def __init__(self):
self.map = None
self.last_got_map = -10e10
from clock import clock
from __init__ import createPeerID
from Tribler.Core.NATFirewall.upnp import UPnPPlatformIndependent, UPnPError
from Tribler.Core.NATFirewall.guessip import get_my_wan_ip
try:
True
except:
True = 1
False = 0
DEBUG = False
EXPIRE_CACHE = 30 # seconds
ID = "BT-" + createPeerID()[-4:]
try:
import pythoncom, win32com.client
win32_imported = 1
except ImportError:
if DEBUG and (sys.platform == "win32"):
print >>sys.stderr, "natpunch: ERROR: pywin32 package not installed, UPnP mode 2 won't work now"
win32_imported = 0
UPnPError = UPnPError
class _UPnP1: # derived from Myers Carpenter's code
# seems to use the machine's local UPnP
def download(params, filefunc, statusfunc, finfunc, errorfunc, doneflag, cols,
pathFunc=None, presets={}, exchandler=None, failed=_failfunc,
paramfunc=None):
try:
config = parse_params(params, presets)
except ValueError as e:
failed('error: {}\nrun with no args for parameter explanations'.format(
e))
return
if not config:
errorfunc(get_usage())
return
myid = createPeerID()
random.seed(myid)
rawserver = RawServer(doneflag, config['timeout_check_interval'],
config['timeout'],
ipv6_enable=config['ipv6_enabled'],
failfunc=failed, errorfunc=exchandler)
upnp_type = UPnP_test(config['upnp_nat_access'])
try:
listen_port = rawserver.find_and_bind(
config['minport'], config['maxport'], config['bind'],
ipv6_socket_style=config['ipv6_binds_v4'], upnp=upnp_type,
randomizer=config['random_port'])
except socket.error as e:
failed("Couldn't listen - " + str(e))
return
response = get_response(config['responsefile'], config['url'], failed)
if not response:
return
infohash = hashlib.sha1(bencode(response['info'])).digest()
d = BT1Download(statusfunc, finfunc, errorfunc, exchandler, doneflag,
config, response, infohash, myid, rawserver, listen_port)
if not d.saveAs(filefunc):
return
if pathFunc:
pathFunc(d.getFilename())
hashcheck = d.initFiles(old_style=True)
if not hashcheck:
return
if not hashcheck():
return
if not d.startEngine():
return
d.startRerequester()
d.autoStats()
statusfunc(activity='connecting to peers')
if paramfunc:
paramfunc({
# change_max_upload_rate(<int KiB/sec>)
'max_upload_rate': d.setUploadRate,
# change_max_uploads(<int max uploads>)
'max_uploads': d.setConns,
'listen_port': listen_port, # int
'peer_id': myid, # string
'info_hash': infohash, # string
# start_connection((<string ip>, <int port>), <peer id>)
'start_connection': d._startConnection,
})
rawserver.listen_forever(d.getPortHandler())
d.shutdown()
# Written by John Hoffman
# derived from NATPortMapping.py by Yejun Yang
# and from example code by Myers Carpenter
# see LICENSE.txt for license information
import socket
from traceback import print_exc
from subnetparse import IP_List
from clock import clock
from __init__ import createPeerID
DEBUG = False
EXPIRE_CACHE = 30 # seconds
ID = "BL-" + createPeerID()[-4:]
try:
import pythoncom, win32com.client
_supported = 1
except ImportError:
_supported = 0
class _UPnP1: # derived from Myers Carpenter's code
# seems to use the machine's local UPnP
# system for its operation. Runs fairly fast
def __init__(self):
self.map = None
self.last_got_map = -10e10
