def announce(self, force=False):
if time.time() < self.last_announce+60 and not force: return # No reannouncing within 60 secs
self.last_announce = time.time()
errors = []
address_hash = hashlib.sha1(self.address).hexdigest()
my_peer_id = sys.modules["main"].file_server.peer_id
# Later, if we have peer exchange
"""if sys.modules["main"].file_server.port_opened:
fileserver_port = config.fileserver_port
else: # Port not opened, report port 0
fileserver_port = 0"""
fileserver_port = config.fileserver_port
s = time.time()
announced = 0
for protocol, ip, port in SiteManager.TRACKERS:
if protocol == "udp": # Udp tracker
if config.disable_udp: continue # No udp supported
tracker = UdpTrackerClient(ip, port)
tracker.peer_port = fileserver_port
try:
tracker.connect()
tracker.poll_once()
tracker.announce(info_hash=address_hash, num_want=50)
back = tracker.poll_once()
peers = back["response"]["peers"]
except Exception, err:
errors.append("%s://%s:%s" % (protocol, ip, port))
continue
else: # Http tracker
params = {
'info_hash': binascii.a2b_hex(address_hash),
'peer_id': my_peer_id, 'port': fileserver_port,
'uploaded': 0, 'downloaded': 0, 'left': 0, 'compact': 1, 'numwant': 30,
'event': 'started'
}
try:
url = "http://"+ip+"?"+urllib.urlencode(params)
# Load url
opener = urllib2.build_opener()
response = opener.open(url, timeout=10).read()
# Decode peers
peer_data = bencode.decode(response)["peers"]
peer_count = len(peer_data) / 6
peers = []
for peer_offset in xrange(peer_count):
off = 6 * peer_offset
peer = peer_data[off:off + 6]
addr, port = struct.unpack('!LH', peer)
peers.append({"addr": socket.inet_ntoa(struct.pack('!L', addr)), "port": port})
except Exception, err:
self.log.debug("Http tracker %s error: %s" % (url, err))
errors.append("%s://%s" % (protocol, ip))
continue
def announceTrackerHttp(self, tracker_address, mode="start", num_want=10):
tracker_ip, tracker_port = tracker_address.rsplit(":", 1)
if helper.getIpType(tracker_ip) in self.getOpenedServiceTypes():
port = self.fileserver_port
else:
port = 1
params = {
'info_hash': hashlib.sha1(self.site.address).digest(),
'peer_id': self.peer_id,
'port': port,
'uploaded': 0,
'downloaded': 0,
'left': 431102370,
'compact': 1,
'numwant': num_want,
'event': 'started'
}
url = "http://" + tracker_address + "?" + urllib.urlencode(params)
s = time.time()
response = None
# Load url
if config.tor == "always" or config.trackers_proxy != "disable":
timeout = 60
else:
timeout = 30
with gevent.Timeout(timeout, False): # Make sure of timeout
req = self.httpRequest(url)
response = req.read()
req.fp._sock.recv = None # Hacky avoidance of memory leak for older python versions
req.close()
req = None
if not response:
raise AnnounceError("No response after %.0fs" % (time.time() - s))
# Decode peers
try:
peer_data = bencode.decode(response)["peers"]
response = None
peer_count = len(peer_data) / 6
peers = []
for peer_offset in xrange(peer_count):
off = 6 * peer_offset
peer = peer_data[off:off + 6]
addr, port = struct.unpack('!LH', peer)
peers.append({
"addr": socket.inet_ntoa(struct.pack('!L', addr)),
"port": port
})
except Exception as err:
raise AnnounceError("Invalid response: %r (%s)" % (response, err))
return peers
def announce(self, force=False):
if time.time() < self.last_announce+60 and not force: return # No reannouncing within 60 secs
self.last_announce = time.time()
errors = []
address_hash = hashlib.sha1(self.address).hexdigest()
my_peer_id = sys.modules["main"].file_server.peer_id
if sys.modules["main"].file_server.port_opened:
fileserver_port = config.fileserver_port
else: # Port not opened, report port 0
fileserver_port = 0
s = time.time()
announced = 0
for protocol, ip, port in SiteManager.TRACKERS:
if protocol == "udp": # Udp tracker
if config.disable_udp: continue # No udp supported
tracker = UdpTrackerClient(ip, port)
tracker.peer_port = fileserver_port
try:
tracker.connect()
tracker.poll_once()
tracker.announce(info_hash=address_hash, num_want=50)
back = tracker.poll_once()
peers = back["response"]["peers"]
except Exception, err:
errors.append("%s://%s:%s" % (protocol, ip, port))
continue
else: # Http tracker
params = {
'info_hash': binascii.a2b_hex(address_hash),
'peer_id': my_peer_id, 'port': fileserver_port,
'uploaded': 0, 'downloaded': 0, 'left': 0, 'compact': 1, 'numwant': 30,
'event': 'started'
}
try:
url = "http://"+ip+"?"+urllib.urlencode(params)
# Load url
opener = urllib2.build_opener()
response = opener.open(url, timeout=10).read()
# Decode peers
peer_data = bencode.decode(response)["peers"]
peer_count = len(peer_data) / 6
peers = []
for peer_offset in xrange(peer_count):
off = 6 * peer_offset
peer = peer_data[off:off + 6]
addr, port = struct.unpack('!LH', peer)
peers.append({"addr": socket.inet_ntoa(struct.pack('!L', addr)), "port": port})
except Exception, err:
self.log.debug("Http tracker %s error: %s" % (url, err))
errors.append("%s://%s" % (protocol, ip))
continue
def get_hash(url, mode='torrent'):
if url.startswith('magnet'):
return url.split('&')[0].split(':')[-1]
else:
try:
torrent = Url.open(url, stream=True).content
metadata = bencode.decode(torrent)
hashcontents = bencode.encode(metadata['info'])
return hashlib.sha1(hashcontents).hexdigest()
except Exception as e: #noqa
return None
def CalcTorrentHash(torrent):
if torrent and torrent.startswith('magnet'):
hashid = re.findall('urn:btih:([\w]{32,40})', torrent)[0]
if len(hashid) == 32:
hashid = b16encode(b32decode(hashid)).lower()
else:
# noinspection PyTypeChecker
info = dict(
decode(torrent))["info"] # python3 decode returns OrderedDict
hashid = sha1(encode(info)).hexdigest()
logger.debug('Torrent Hash: ' + hashid)
return hashid
def CalcTorrentHash(torrent):
# torrent could be a unicode magnet link or a bytes object torrent file contents
if makeUnicode(torrent[:6]) == 'magnet':
# torrent = makeUnicode(torrent)
hashid = re.findall('urn:btih:([\w]{32,40})', torrent)[0]
if len(hashid) == 32:
hashid = b16encode(b32decode(hashid)).lower()
else:
# noinspection PyTypeChecker
info = dict(decode(torrent))["info"] # python3 decode returns OrderedDict
hashid = sha1(encode(info)).hexdigest()
logger.debug('Torrent Hash: ' + hashid)
return hashid
def CalcTorrentHash(torrent):
# torrent could be a unicode magnet link or a bytes object torrent file contents
if makeUnicode(torrent[:6]) == 'magnet':
# torrent = makeUnicode(torrent)
hashid = re.findall('urn:btih:([\w]{32,40})', torrent)[0]
if len(hashid) == 32:
hashid = b16encode(b32decode(hashid)).lower()
else:
# noinspection PyTypeChecker
info = dict(decode(torrent))["info"] # python3 decode returns OrderedDict
hashid = sha1(encode(info)).hexdigest()
logger.debug('Torrent Hash: ' + hashid)
return hashid
def announceTrackerHttp(self, tracker_address, mode="start", num_want=10):
if "ip4" in self.getOpenedServiceTypes():
port = self.fileserver_port
else:
port = 1
params = {
'info_hash': hashlib.sha1(self.site.address).digest(),
'peer_id': self.peer_id, 'port': port,
'uploaded': 0, 'downloaded': 0, 'left': 431102370, 'compact': 1, 'numwant': num_want,
'event': 'started'
}
url = "http://" + tracker_address + "?" + urllib.urlencode(params)
s = time.time()
response = None
# Load url
if config.tor == "always" or config.trackers_proxy != "disable":
timeout = 60
else:
timeout = 30
with gevent.Timeout(timeout, False): # Make sure of timeout
req = self.httpRequest(url)
response = req.read()
req.fp._sock.recv = None # Hacky avoidance of memory leak for older python versions
req.close()
req = None
if not response:
raise AnnounceError("No response after %.0fs" % (time.time() - s))
# Decode peers
try:
peer_data = bencode.decode(response)["peers"]
response = None
peer_count = len(peer_data) / 6
peers = []
for peer_offset in xrange(peer_count):
off = 6 * peer_offset
peer = peer_data[off:off + 6]
addr, port = struct.unpack('!LH', peer)
peers.append({"addr": socket.inet_ntoa(struct.pack('!L', addr)), "port": port})
except Exception as err:
raise AnnounceError("Invalid response: %r (%s)" % (response, err))
return peers
}
req = None
try:
url = "http://" + address + "?" + urllib.urlencode(params)
# Load url
with gevent.Timeout(10, False): # Make sure of timeout
req = urllib2.urlopen(url, timeout=8)
response = req.read()
req.fp._sock.recv = None # Hacky avoidance of memory leak for older python versions
req.close()
req = None
if not response:
self.log.debug("Http tracker %s response error" % url)
return False
# Decode peers
peer_data = bencode.decode(response)["peers"]
response = None
peer_count = len(peer_data) / 6
peers = []
for peer_offset in xrange(peer_count):
off = 6 * peer_offset
peer = peer_data[off:off + 6]
addr, port = struct.unpack('!LH', peer)
peers.append({"addr": socket.inet_ntoa(struct.pack('!L', addr)), "port": port})
except Exception, err:
self.log.debug("Http tracker %s error: %s" % (url, err))
if req:
req.close()
req = None
return False
req = None
try:
url = "http://" + tracker_address + "?" + urllib.urlencode(
params)
# Load url
with gevent.Timeout(30, False): # Make sure of timeout
req = urllib2.urlopen(url, timeout=25)
response = req.read()
req.fp._sock.recv = None # Hacky avoidance of memory leak for older python versions
req.close()
req = None
if not response:
self.log.debug("Http tracker %s response error" % url)
return False
# Decode peers
peer_data = bencode.decode(response)["peers"]
response = None
peer_count = len(peer_data) / 6
peers = []
for peer_offset in xrange(peer_count):
off = 6 * peer_offset
peer = peer_data[off:off + 6]
addr, port = struct.unpack('!LH', peer)
peers.append({
"addr":
socket.inet_ntoa(struct.pack('!L', addr)),
"port":
port
})
except Exception, err:
self.log.debug("Http tracker %s error: %s" % (url, err))
