async def connect(self,
first: bool = None,
uploaded: int = 0,
downloaded: int = 0):
params = {
'info_hash': self.torrent.info_hash,
'peer_id': self.peer_id,
'port': 6889,
'uploaded': uploaded,
'downloaded': downloaded,
'left': self.torrent.total_size - downloaded,
'compact': 1}
if first:
params['event'] = 'started'
url = self.torrent.announce + '?' + urlencode(params)
logging.info('Connecting to tracker at: ' + url)
async with self.http_client.get(url) as response:
if not response.status == 200:
raise ConnectionError('Unable to connect to tracker: status code {}'.format(response.status))
data = await response.read()
print(bencoding.Decoder(data).decode())
self.raise_for_error(data)
return TrackerResponse(bencoding.Decoder(data).decode())
def __parse(self, data):
decoder = bencoding.Decoder()
decoder.setCallback(self.__parseBegin, self.__parseEnd)
decoded = decoder.decode(data)
self.infoHash = utilities.sha1(
data[self.__parseInfoBegin:self.__parseInfoEnd])
return decoded
def __init__(self, filename):
self.filename = filename
self.files = []
with open(self.filename, 'rb') as f:
meta_info = f.read()
self.meta_info = bencoding.Decoder(meta_info).decode()
info = bencoding.Encoder(self.meta_info[b'info']).encode()
self.info_hash = sha1(info).digest()
self._identify_files()
def parse(torrentfile):
parsedata = {}
with open(torrentfile, 'rb') as unparsed:
metaData = bencoding.Decoder(unparsed.read()).decode()
torrentInfo = bencoding.Encoder(metaData[b'info']).encode()
infoHash = sha1(torrentInfo).digest()
parsedata['announce'] = metaData[b'announce']
parsedata['info_hash'] = infoHash
parsedata['left'] = metaData[b'info'][b'length']
return parsedata
def __init__(self, torrent_file):
self.meta_data = tp.parse_torrent_file(torrent_file)
self.files = []
self.base_url = self.meta_data['announce']
self.total_length = self.meta_data['info']['length']
self.output_file = self.meta_data['info']['name']
with open(torrent_file, 'rb') as f:
meta_info = f.read()
self.raw_meta = bencoding.Decoder(meta_info).decode()
info = bencoding.Encoder(self.raw_meta[b'info']).encode()
self.info_hash = sha1(info).digest()
def parse_response(raw_response) -> TrackerResponse:
result = TrackerResponse()
decoded = bencoding.Decoder(raw_response).decode()
peers = decoded[b'peers']
peers = [peers[i:i + 6] for i in range(0, len(peers), 6)]
for p in peers:
decoded_port = struct.unpack(">H", p[4:])[0]
result.peers.append((socket.inet_ntoa(p[:4]), decoded_port))
result.complete = decoded.get(b'complete', 0)
result.incomplete = decoded.get(b'incomplete', 0)
result.interval = decoded.get(b'interval', 0)
return result
def __init__(self, filename):
self.filename = filename
self.files = []
with open(self.filename, 'rb') as f:
meta_info = f.read()
self.meta_info = bencoding.Decoder(meta_info).decode()
info = bencoding.Encoder(self.meta_info[b'info']).encode()
self.info_hash = sha1(info).digest()
self._identify_files()
if self.multi_file:
# TODO Add support for multi-file torrents
raise RuntimeError('Multi-file torrents is not supported!')
self.files.append(
TorrentFile(self.meta_info[b'info'][b'name'].decode('utf-8'),
self.meta_info[b'info'][b'length']))
async def connect(self) -> None:
"""
Connect to tracker and retrieve meta info about the torrent
Raises:
TrackerError: If response from tracker has not successfull status code
"""
request_data = {
"info_hash": self.torrent.info_hash,
"peer_id": self.peer_id,
"port": random.randint(6881, 6889),
"uploaded": 0,
"downloaded": 0,
"left": self.torrent.size,
}
request_url = self.torrent.announce + "?" + urllib.parse.urlencode(
request_data)
response = await self._client.get(request_url, params=request_data)
if response.status_code != 200:
raise TrackerError(status_code=response.status_code)
tracker_response = TrackerResponse(
bencoding.Decoder(response.read()).decode())
self.tracker_info = tracker_response
async def connect(self,
first: bool = None,
uploaded: int = 0,
downloaded: int = 0):
params = {}
params['info_hash'] = self.torrent.info_hash
params['uploaded'] = 0
params['download'] = 0
params['peer_id'] = self.peer_id
params['port'] = 6969
params['left'] = self.torrent.total_size - downloaded
params['compact'] = 1
url = self.torrent.announce + '?' + urlencode(params)
print(params)
if first:
params['event'] = 'started'
async with self.http_client.get(url) as response:
if not response.status == 200:
raise ConnectionError(
f'Unable to connect to tracker: status code {response.status}'
)
data = await response.read()
return TrackerResponse(bencoding.Decoder(data).decode())
'info_hash': torrentMetaData['info_hash'],
'peer_id': peerId,
'port': 6881,
'uploaded': 0,
'downloaded': 0,
'left': torrentMetaData['left'],
'compact': 1,
'event': 'started'
}
# make request to tracker
url = (torrentMetaData['announce']).decode('utf-8') + "?" + urlencode(query)
res = requests.get(url)
# decode the binary data and store the peerlist bytes
data = bencoding.Decoder(res.content).decode()
peerlist = data[b'peers']
# offset = 0
# ip1 = struct.unpack_from("!i", peerlist, offset)[0]
# # firstip = socket.inet_ntoa(struct.pack("!i", ip1))
# # print(firstip)
# ip_list = []
# for offset2 in range(0,12,6):
# unpacked_ip = struct.unpack_from("!i", peerlist, offset2)[0]
# dotted_ip = struct.pack('!i', unpacked_ip)
# ip_list.append(ipaddress.ip_address(dotted_ip))
# for item in ip_list:
# print("from the loop", item)