def _connect_via_http(self): """ https://wiki.theory.org/BitTorrentSpecification#Tracker_Request_Parameters make a request to tracker which is an HTTP(S) service that holds information about the torrent and peers. """ params = { 'info_hash': self.torrent.info_hash, 'peer_id': self.torrent.peer_id, 'left': self.torrent.left, 'downloaded': 0, 'uploaded': 0, 'port': 6881, 'compact': 1, 'event': 'started' } url = self.url + '?' + urlencode(params) r = urlopen(url) response = bdecode(r.read()) if 'failure reason' not in response: return self._decode_peers(response['peers']) else: time.sleep(response['interval'])
def make_tracker_request(gto_dict, peer_id, info_hash, key_file, crt_file): # TODO(hammer): support partial downloads left = sum([f.get('length') for f in gto_dict.get('info').get('files')]) key = get_random_string(8) payload = { 'peer_id': peer_id, 'port': 20893, 'uploaded': 0, 'downloaded': 0, 'left': left, 'corrupt': 0, 'redundant': 0, 'compact': 1, 'numwant': 200, 'key': key, 'no_peer_id': 1, 'supportcrypto': 1, 'event': 'started', } url = 'https://dream.annailabs.com:21111/tracker.php/announce' url += '?info_hash=' + urllib.parse.quote(info_hash.digest(), '') + '&' url += urllib.parse.urlencode(payload) r = requests.get(url, verify=False, cert=(crt_file, key_file)) logging.debug('Tracker response content: %s' % r.content) tracker_response = bencode.bdecode(r.content.strip()) return tracker_response
def getMessage22(s, q): try: data, address = s.recvfrom(1024 * 64) msg = bdecode(data) msg_type = msg.get("y", "e") #print(msg_type) #print(msg) if msg_type == "e": pass if (msg_type == "r"): if "nodes" in msg["r"]: nodes = decode_nodes(msg["r"]["nodes"]) #print (address) dealFindNodesBack(nodes, s, q) if (msg_type == "q"): if msg["q"] == "ping": dealPing(msg, s, address, q) elif msg["q"] == "find_node": dealFideNodes(msg, s, address, q) elif msg["q"] == "get_peers": dealGetPeer(msg, s, address, q) elif msg["q"] == "announce_peer": dealAnnouncePeer(msg, s, address, q) else: pass #print(msg) except ConnectionResetError: print("ldldldldlldldlld=======") except: print("error") print(msg)
def verifyFileContent(torrentFile, actualFile): torrent = bdecode(f) plength = torrent['info']['piece length'] thash = torrent['info']['pieces'] flength = torrent['info']['length'] realfile = actualFile realfile.seek(0,2) realfileLength = realfile.tell() realfile.seek(0,0) if flength != realfileLength: print("File sizes do not match! Invalid file!") return False piece = realfile.read(plength) digest = hashlib.sha1(piece).digest() while piece != bytes(): piece = realfile.read(plength) if piece != bytes(): phash = hashlib.sha1(piece).digest() digest = digest + phash if digest == thash: print("file integrity is intact!!") print("MAGENT URI:", genenateMagentURI(torrent)) return True else: print("kid, what are you trying to pull? get that malicious shit outta here") return False
def http_scraper(self, torrent, tracker): params = { 'info_hash': torrent.info_hash, 'peer_id': torrent.peer_id, 'uploaded': 0, 'downloaded': 0, 'left': torrent.total_length, 'event': 'started', 'port': 0, } try: answer_tracker = requests.get(tracker, params=params, timeout=5) if answer_tracker.status_code != 200: print( "Failed tracker '%s', status=%d, body=%s" % (tracker, answer_tracker.status_code, answer_tracker.text)) else: list_peers = bdecode(answer_tracker.content) # t = UdpTrackerAnnounceOutput() # # t.from_bytes(list_peers['peers']) for peer in list_peers['peers']: s = SockAddr(peer['ip'], peer['port']) self.dict_sock_addr[s.__hash__()] = s print("Got %d peers from HTTP tracker" % len(self.dict_sock_addr)) except Exception: logging.exception("HTTP scraping failed")
def getPeersMessage(s, info): while True: try: data, address = s.recvfrom(1024 * 4) msg = bdecode(data) msg_type = msg.get("y", "e") #print(msg_type) #print(msg) if msg_type == "e": pass if (msg_type == "r"): if "token" in msg["r"]: if "nodes" in msg["r"]: nodes = decode_nodes(msg["r"]["nodes"]) sendgetpeers2(info, nodes, s) if "values" in msg["r"]: print(msg) s.close() return except ConnectionResetError: print("ldldldldlldldlld=======") except: print("error") #print(msg) # print (ExceptionType) raise
def parse(self): with open(self.path, 'rb') as f: torrent_file = bdecode(f) urls = [] if 'announce' in torrent_file: urls.append(torrent_file['announce']) if 'announce-list' in torrent_file: for tracker in torrent_file['announce-list']: urls.append(tracker[0]) info = torrent_file['info'] name = info['name'] piece_length = info['piece length'] pieces = info['pieces'] if 'length' in info: length = info['length'] # only exists for single-file torrents file_list = [File(length, [name], 0)] else: files = info['files'] file_list = [] offset = 0 for file in files: file_list.append(File(file['length'], file['path'], offset)) offset += file['length'] target = FileStructure(name, file_list) print("Torrent has %d pieces" % (len(pieces) // 20)) print("Torrent piece length = %d" % int(piece_length)) # print("Torrent has %d bytes" % length) return Torrent(urls, info, piece_length, pieces, target)
def getMessage(s): while True: data,address = s.recvfrom(65536) try: msg=bdecode(data) msg_type = msg.get("y", "e") #print(msg_type) #print(msg) if msg_type == "e": return if(msg_type == "r"): nodes=decode_nodes(msg["r"]["nodes"]) #print (address) dealFindNodesBack(nodes,s) if(msg_type=="q"): if msg["q"]=="ping": dealPing(msg,s,address) if msg["q"]=="find_node": dealFideNodes(msg,s,address) if msg["q"]=="get_peers": dealGetPeer(msg,s,address) if msg["q"]=="announce_peer": dealAnnouncePeer(msg,s,address) except KeyError: print("error") print(msg) continue
def __init__(self, torrent, tracker, dict_sock_addr): # loading the parameters for HTTP scrapper params = { 'info_hash': torrent.info_hash, 'peer_id': torrent.peer_id, 'uploaded': 0, 'downloaded': 0, 'port': 6881, 'left': torrent.total_length, 'event': 'started' } self.dict_sock_addr = dict_sock_addr try: # HTTP : GET requesting the tracker link for the list of peers answer_tracker = requests.get(tracker, params=params, timeout=5) # decoding the response content list_peers = bdecode(answer_tracker.content) # for each peer, create a socket for p in list_peers['peers']: s = socket_address.SockAddr(p['ip'], p['port']) self.dict_sock_addr[s.__hash__()] = s except Exception as e: logging.exception("HTTP scraping failed: %s" % e.__str__())
def load_content(self, path): with open(path, 'rb') as file: contents = bdecode(file) self.torrent_file = contents # getting metainfo of torrent file in separate variables """ Please refer to https://en.wikipedia.org/wiki/Torrent_file#File_structure for understanding the structure of Torrent files containing metainfo """ # creating hash info for handshaking purpose raw_info_hash = bencode(self.torrent_file['info']) self.info_hash = hashlib.sha1(raw_info_hash).digest() self.peer_id = self.generate_peer_id() # creating directory structure and store file info in the dictionary self.announce_list = self.get_trackers() self.init_files() # creating number of pieces self.piece_length = self.torrent_file['info']['piece length'] self.pieces = self.torrent_file['info']['pieces'] self.number_of_pieces = math.ceil(self.total_length / self.piece_length) # checking for the lengths.. if equal to zero, it will show an assertion error assert (self.total_length > 0) assert (len(self.file_names) > 0) # return all the values return self
def getInfoMessage(adrr, infohash): begin = time() the_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) the_socket.connect(adrr) print(type(infohash)) send_handshake(the_socket, infohash) packet = the_socket.recv(4096) print(packet) print(packet[68:]) if (packet == "".encode()): the_socket.close() return ut_metadata = get_ut_metadata(packet) send_ext_handshake(the_socket) if (ut_metadata == -1): packet = the_socket.recv(4096) ut_metadata, metadata_size = get_ut_metadata(packet), get_metadata_size( packet) print(metadata_size) print(ut_metadata, metadata_size) # request each piece of metadata metadata = "".encode() for piece in range(int(math.ceil(metadata_size / (16.0 * 1024)))): #piece是个控制块,根据控制块下载数据 request_metadata(the_socket, ut_metadata, piece) packet = recvall(the_socket, 0.5) #the_socket.recv(1024*17) print(packet.index("ee".encode())) metadata = metadata + packet[packet.index("ee".encode()) + 2:] #print(metadata) result = bdecode(metadata) print(result["name"]) print(time() - begin)
def read_torrent(self, filename): torrent_file = open(filename, 'rb') torrent_data = bcoding.bdecode(torrent_file.read()) if 'announce' not in torrent_data: warnings.warn("No 'announce' URL found in %s; ignoring" % filename) return # Get tracker hostname, see if this torrent should be ignored # tracker_url = urllib.parse.urlparse(torrent_data['announce']) tracker_hostname = tracker_url.hostname # Store tracker even if it's excluded; this list is only used for # 'info' if tracker_hostname not in self.trackers: self.trackers.append(tracker_hostname) if tracker_hostname in self.config.exclude_trackers: if store_ignored: self.excluded_torrent_files.append(filename) self.excluded += 1 torrent_file.close() return type = 'single' if 'files' in torrent_data['info']: type = 'multi' name = torrent_data['info']['name'] name_index = getattr(self, "names_" + type) # Check for duplicates is_duplicate = False if name in name_index: for existing_torrent in name_index[name]: if torrent_info_matches(existing_torrent.file_info, torrent_data['info']): is_duplicate = True self.duplicates += 1 break if is_duplicate: if self.store_ignored: self.duplicate_torrent_files.append(filename) torrent_file.close() return torrent = Torrent(filename, name, type, torrent_data['info']) self.torrents.append(torrent) if name in name_index: name_index[name].append(torrent) else: name_index[name] = [torrent] torrent_file.close()
def make_magnet_from_file(file) : file_torrent=open(file,"rb") metadata = bcoding.bdecode(file_torrent.read()) subj = metadata[b'info'] hashcontents = bcoding.bencode(subj) digest = hashlib.sha1(hashcontents).digest() b32hash = base64.b32encode(digest).decode() return 'magnet:?'+ 'xt=urn:btih:' + b32hash+ '&dn=' + metadata[b'info'][b'name'].decode()+ '&tr=' + metadata[b'announce'].decode()+ '&xl=' + str(metadata[b'info'][b'length']) '''convert torrent into magnet file for further sharing, not currently used, but for possible future development'''
def __init__(self, torrent_file_path): self.peers = [] self.pieces = deque([]) self.peer_id = hashlib.sha1(str(time.time()).encode('utf-8')).digest() self.torrent_dict = bcoding.bdecode(open(torrent_file_path, 'rb').read()) bencode_info = bcoding.bencode(self.torrent_dict['info']) self.infoHash = hashlib.sha1(bencode_info).digest() self.generate_peer_connections() self.generate_pieces_objects() self.num_pieces_so_far = 0
def load_from_path(self, path): with open(path, 'rb') as file: contents = bdecode(file) self.torrent_file = contents self.piece_length = self.torrent_file['info']['piece length'] self.pieces = self.torrent_file['info']['pieces'] self.info_hash = hashlib.sha1(bencode( self.torrent_file['info'])).digest() self.peer_id = self.generate_peer_id() self.announce_list = self.get_trakers() self.init_files() self.number_of_pieces = math.ceil(self.total_length / self.piece_length) return self
def unpack_request(self, req): #i think we might have to change the endianness of the response decoded = bcoding.bdecode(req) # print('%d seeders, %d leechers' % (decoded['complete'], decoded['incomplete'])) peers = [] for i in range(0, len(decoded['peers']), 6): ip_add = str( ipaddress.IPv4Address( int.from_bytes(decoded['peers'][i:i + 4], byteorder='big'))) port = str( int.from_bytes(decoded['peers'][i + 4:i + 6], byteorder='big')) peers.append(':'.join([ip_add, port])) return peers
def _open_file(self, path_to_file): #read torrent file as binary object with open(self.path_to_file, 'rb') as meta_file: self.decoded = bdecode(meta_file.read()) #check to see if it's a multi-file torrent if 'files' in self.decoded['info']: self.multi_file = True ''' This stuff doesn't care whether or not it's a multi-file torrent ''' # extract the creation date self.creation_date = self.decoded['creation date'] # extract the announce url self.announce = urllib.parse.urlparse(self.decoded['announce']) print(self.decoded['announce']) # calculates info hash self.info_hash = hashlib.sha1(bencode(self.decoded['info'])).digest() # extract piece length self.piece_length = self.decoded['info']['piece length'] # extract pieces (in bytes) self.pieces = self.decoded['info']['pieces'] self.num_pieces = len(self.pieces) // 20 # extract name / dictionary as to where to store the files self.name = self.decoded['info']['name'] if not self.multi_file: # extract length self.length = self.decoded['info']['length'] self.last_piece_len = self.length - self.piece_length * ( self.num_pieces - 1) else: self.files = [] self.length = 0 for f in self.decoded['info']['files']: self.length += int(f['length']) self.files.append({ 'length': int(f['length']), 'path': f['path'] }) self.last_piece_len = self.length - self.piece_length * ( self.num_pieces - 1) self.file_info()
def __init__(self, metafile): self.logger = logging.getLogger('main_bt.torrent_wrapper.TorrentWrapper') self.logger.info('creating a TorrentWrapper instance') with open(metafile, 'rb') as f: self.torrent = bdecode(f) self.INFO_HASH = sha1_info(self.torrent) self.TRACKER_URL = self.announce() self.piece_length = self.torrent['info']['piece length'] self.total_bytes = self.total_file_length() self.number_pieces = self._num_pieces() self.last_piece_length = self._length_of_last_piece() self.LAST_PIECE_INDEX = self.number_pieces - 1 self.file_meta = self.file_info() self.file_boundaries_by_byte_indices = self.list_of_file_boundaries()
def getDirectDownload(self): from bcoding import bdecode torrent = self.getTorrent() d = bdecode(torrent) bases = d["direct download"].split("|") # Always make sure the url ends with a slash, so we don't # get a different result depending on whether it does or not for i, base in enumerate(bases): if not base.endswith("/"): bases[i] += "/" # cache the file list torrentFiles = set() for f in d["info"]["files"]: if f["type"] == "alignment": continue torrentFiles.add(TorrentFile(f)) return bases, torrentFiles
def announce(self, downloadedBytes = 0, announceEvent = "started"): print("About to send announce no. <{}>".format(self.announceCount)) self.announceCount += 1 qParams = { "info_hash": self.infoHash, "peer_id": self.local_peer_id, "port": "6882", "uploaded": "0", "downloaded": downloadedBytes, "left": (self.length - downloadedBytes), "compact": "1" } if (self.trackerid != -1): qParams["trackerid"] = self.trackerid if (announceEvent != "None"): qParams["event"] = announceEvent response = bdecode(requests.get(self.announceData, params = qParams).content) # TO-DO # Handle other info received from response if ('tracker id' in response.keys()): self.trackerid = response['tracker id'] if ('interval' in response.keys()): self.announceInterval = response['interval'] if ('min interval' in response.keys()): self.announceInterval = response['min interval'] if ('interval' not in response.keys() and 'min interval' not in response.keys()): self.announceInterval = 300 self.announceInterval = 60 # Instantiate a peer manager for this torrent file if (announceEvent == "started"): # Needs to be created only once self.changeStatus("Creating peer manager for this torrent") self.pManager = pm.peerManager(response['peers'], self) else: #Give new peer list to peerManager self.pManager.updatePeerList(response['peers']) # Lastly start the timer self.announceTimer = time.monotonic()
def scrape_udp(info_hash, announce, peer_id): parsed = urlparse(announce) ip = socket.gethostbyname(parsed.hostname) if ip == '127.0.0.1': return False try: # TODO : Needs verification sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.settimeout(8) conn = (ip, parsed.port) msg, trans_id, action = make_connection_id_request() response = send_msg(conn, sock, msg, trans_id, action, 16) conn_id = response[8:] msg, trans_id, action = make_announce_input(info_hash, conn_id, peer_id) response = send_msg(conn, sock, msg, trans_id, action, 20) payload = bcoding.bdecode(response) return payload['peers'] except TimeoutError: return ''
def http_scraper(self, torrent, tracker): params = { 'info_hash': torrent.info_hash, 'peer_id': torrent.peer_id, 'uploaded': 0, 'downloaded': 0, 'port': 6881, 'left': torrent.total_length, 'event': 'started' } try: answer_tracker = requests.get(tracker, params=params, timeout=5) list_peers = bdecode(answer_tracker.content) for p in list_peers['peers']: s = SockAddr(p['ip'], p['port']) self.dict_sock_addr[s.__hash__()] = s except Exception as e: logging.exception("HTTP scraping failed: %s" % e.__str__())
def open_from_file(self, movie): with open(a1[1], 'r+b') as file2: contents2 = bdecode(file2) self.torrent_file2 = contents2 self.piece_length = self.torrent_file2['info']['piece length'] self.pieces = self.torrent_file2['info']['pieces'] raw_info_hash = bencode(self.torrent_file2['info']) self.info_hash = hashlib.sha1(raw_info_hash).digest() self.peer_id = self.generate_peer_id() self.announce_list = self.get_trakers() self.init_files() self.number_of_pieces = math.ceil(self.total_length / self.piece_length) logging.debug(self.announce_list) logging.debug(self.file_names) assert (self.total_length > 0) assert (len(self.file_names) > 0) return self
def getInfoMessage(adrr, infohash, infohash2, mu): try: begin = time() the_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) the_socket.connect(adrr) #print(type(infohash)) send_handshake(the_socket, infohash) packet = the_socket.recv(4096) #print(packet) if (packet == "".encode()): the_socket.close() return ut_metadata = get_ut_metadata(packet) send_ext_handshake(the_socket) if (ut_metadata == -1): packet = the_socket.recv(4096) ut_metadata, metadata_size = get_ut_metadata( packet), get_metadata_size(packet) #print("ut_metadata,and metadata_size") #print(ut_metadata,metadata_size) request_metadata(the_socket, ut_metadata, 0) packet = recvall(the_socket, "".encode()) #the_socket.recv(1024*17) metadata = packet #print(metadata) result = bdecode(metadata) #if mu.acquire(True): #print("ddddddddddddddddddddddd") f = open('cili5.txt', 'a', encoding='utf-8') print(result["name"]) f.write(infohash2 + " " + result["name"] + "\n") f.close() #mu.release() print(time() - begin) the_socket.close() #raise RuntimeError('testError') except: #raise return
def _send_http_request(self, e, url): payload = self.gen_p(e) try: r = requests.get(url, params=payload, timeout=1) resp = bdecode(bytes(r.text, 'ISO-8859-1')) peers = resp['peers'] peers_dict = {} print("HTTP tracker response received ...") for i in range(0, len(peers)): if not peers[i] in peers_dict.values(): #print(Peer(peers[i])) #sys.exit(1) peers_dict[i] = Peer2(peers[i]) resp['peers'] = peers_dict print("List of %d peers received" % len(resp['peers'])) return resp except (ConnectionResetError, ConnectionError) as e: return False
def scrape_http(announce, info_hash, peer_id, length): params = { 'info_hash': info_hash, 'peer_id': peer_id, 'uploaded': 0, 'downloaded': 0, 'port': 6881, 'left': str(length).encode('utf-8'), 'corrupt': 0, 'event': 'started', } response = requests.get(announce, params=params) if response.status_code > 400: message = ("Failed to connect to torrent_dict.\n" "Status Code: %s \n" "Reason: %s") % (response.status_code, response.reason) raise RuntimeError(message) print(f'Tracker Response : {response}') results = bcoding.bdecode(response.content) return results['peers']
def http_scraper(self, torrent, tracker): params = { 'info_hash': torrent.info_hash, 'peer_id': torrent.peer_id, 'uploaded': 0, 'downloaded': 0, 'left': torrent.total_length, 'event': 'started' } try: answer_tracker = requests.get(tracker, params=params, timeout=5) list_peers = bdecode(answer_tracker.content) t = UdpTrackerAnnounceOutput() t.from_bytes(list_peers['peers']) for ip, port in list_peers['peers']: s = SockAddr(ip, port) self.dict_sock_addr[s.__hash__()] = s except Exception: logging.exception("HTTP scraping failed")
def downloadAgent(self, record): data = record.firstChild.data.strip() self.debug("data=%r" % (data)) component = record.getAttribute("component") if component == "cdn": cdns = data.split("|") print("Available CDNs: %s" % (", ".join(cdns))) return incrementalTorrent, fullTorrent, toBuild, fromBuild, zero = data.split( ";") files = set() for url in (incrementalTorrent, fullTorrent): torrent = urlopen(url) d = bdecode(torrent) directDownload = d["direct download"].decode("utf-8") self.debug("directDownload=%r" % (directDownload)) # As of S2 1.5, directDownload supports mirrors, e.g.: # "http://dist.blizzard.com.edgesuite.net/sc2-pod-retail/NA/22342.direct|http://llnw.blizzard.com/sc2-pod-retail/NA/22342.direct" directDownload = directDownload.split("|")[0] # Always make sure the url ends with a slash, so we don't # get a different result depending on whether it does or not if not directDownload.endswith("/"): directDownload += "/" for f in d["info"]["files"]: if f["type"] == "alignment": continue path = "/".join(f["path"]) files.add(path) self.outputFiles(files, directDownload)
def downloadAgent(self, record): data = record.firstChild.data.strip() self.debug("data=%r" % (data)) component = record.getAttribute("component") if component == "cdn": cdns = data.split("|") print("Available CDNs: %s" % (", ".join(cdns))) return incrementalTorrent, fullTorrent, toBuild, fromBuild, zero = data.split(";") files = set() for url in (incrementalTorrent, fullTorrent): torrent = urlopen(url) d = bdecode(torrent) directDownload = d["direct download"].decode("utf-8") self.debug("directDownload=%r" % (directDownload)) # As of S2 1.5, directDownload supports mirrors, e.g.: # "http://dist.blizzard.com.edgesuite.net/sc2-pod-retail/NA/22342.direct|http://llnw.blizzard.com/sc2-pod-retail/NA/22342.direct" directDownload = directDownload.split("|")[0] # Always make sure the url ends with a slash, so we don't # get a different result depending on whether it does or not if not directDownload.endswith("/"): directDownload += "/" for f in d["info"]["files"]: if f["type"] == "alignment": continue path = "/".join(f["path"]) files.add(path) self.outputFiles(files, directDownload)
def parse_file(self): with open(self.file, 'rb') as file: content = bdecode(file) info = content['info'] files = [] full_size = 0 for file in info['files']: file_info = {'size': file['length'], 'name': file['path'][0]} files.append(file_info) full_size += file['length'] tracker_list = [] for tracker in content['announce-list']: tracker_list.append(tracker[0]) info_hash = hashlib.sha1(bencode(info)).hexdigest() announce_url = content['announce'] data = { 'info_hash': info_hash, 'files': files, 'announce': announce_url, 'full_size': self.make_size(full_size), 'tracker_list': tracker_list } return data
def downloadMfil(self, record): program = self.args.program data = record.firstChild.data.strip() self.debug("data=%r" % (data)) base, thash, mhash, build = data.split(";") self.debug("base=%r" % (base)) build = int(build) baseUrl = self.getBaseUrl(base, program, self.args.preferred_server) self.debug("baseUrl=%r" % (baseUrl)) tfilUrl = baseUrl + "%s-%i-%s.torrent" % (program.lower(), build, thash) if self.args.mfil: mfilUrl = self.args.mfil else: mfilUrl = baseUrl + "%s-%i-%s.mfil" % (program.lower(), build, mhash) self.debug("tfilUrl=%r" % (tfilUrl)) self.debug("mfilUrl=%r" % (mfilUrl)) self.debug("build=%r" % (build)) torrent = self.cache.get(tfilUrl) if torrent: self.debug("cache hit: torrent=%r" % (torrent)) torrent = open(torrent, "rb") else: self.debug("Reading torrent file: %r" % (tfilUrl)) try: torrent = urlopen(tfilUrl) except HTTPError as e: raise ServerError("Could not open %s: %s" % (tfilUrl, e)) path, torrent = self.cache.set(tfilUrl, torrent.read()) self.debug("Cache torrent path=%r" % (path)) self.debug("Parsing torrent...") d = bdecode(torrent) directDownload = d["direct download"] self.debug("directDownload=%r" % (directDownload)) # As of S2 1.5, directDownload supports mirrors, e.g.: # "http://dist.blizzard.com.edgesuite.net/sc2-pod-retail/NA/22342.direct|http://llnw.blizzard.com/sc2-pod-retail/NA/22342.direct" directDownload = directDownload.split("|")[0] # Always make sure the url ends with a slash, so we don't # get a different result depending on whether it does or not if not directDownload.endswith("/"): directDownload += "/" mfil = self.cache.get(mfilUrl) if mfil: self.debug("cache hit: mfil=%r" % (mfil)) else: self.debug("Reading manifest file: %r" % (mfilUrl)) try: mfil = urlopen(mfilUrl).read() except HTTPError as e: raise ServerError("Could not open %s: %s" % (mfilUrl, e)) mfilPath, mfil = self.cache.set(mfilUrl, mfil) self.debug("Cache manifest path=%r" % (mfilPath)) mfil = MFIL(mfil) files = set() for file, fileInfo in mfil["file"].items(): if isinstance(fileInfo["size"], str) and int(fileInfo["size"]) == 0: # Directory continue files.add(file) if True: # add a flag to disable? for f in d["info"]["files"]: if f["type"] == "alignment": continue files.add("/".join(f["path"])) self.outputFiles(files, directDownload, mfil["file"])
if not os.path.exists(basedir + 'by time'): os.makedirs(basedir + 'by time') os.chdir(basedir + 'by time') hashlabel = {} listfiles = [] for root, dirs, files in os.walk(basedir + 'by time', topdown=False): for name in files: os.remove(os.path.join(root, name)) for name in dirs: os.rmdir(os.path.join(root, name)) shottime = "%.20f" % time.time() shutil.copy(resumefile, resumefile + '.' + shottime) resumefile += '.' + shottime print(datetime.now().strftime('%H:%M:%S') + ' Чтение файла bittorrent, составление первичного массива') bitfile = open(resumefile, 'rb') torrent = bdecode(bitfile) for key, value in torrent.items(): if key != '.fileguard' and key != 'rec': path = value.get(u'path') labels = value.get(u'labels') timeadd = value.get(u'added_on') if not labels: value['labels'].append('Empty') for label in labels: if label in hashlabel: hashlabel[label].append([path, timeadd]) else: hashlabel[label] = [[path, timeadd]] del torrent bitfile.close()
def get_gto_dict(content_specifier, auth_token): # TODO(hammer): handle non-URIs payload = {'token': auth_token} r = requests.post(content_specifier, data=payload) gto_dict = bencode.bdecode(r.content) return gto_dict
def read(): r = bcoding.bdecode(sys.stdin.buffer) logging.info("read data: %s", r) return r
def read(pod): """Reads data from pod's stdout.""" return bcoding.bdecode(pod.stdout)
#got list of peers announce_response = decode_udpannounceresponse(response) print( '\nTracker response:\nconnection id:{}\naction:{}\ntransaction id:{}\ninterval:{}\nleechers:{}\nseeders:{}\n' .format(connection_response[2], announce_response[0], announce_response[1], announce_response[2], announce_response[3], announce_response[4])) peers = [] for ip, port in announce_response[5]: peers.append(Peer(ip, port)) print('Found {} peers from {}'.format(len(peers), tracker[0])) return peers, tracker[0] with open(torrent, 'rb') as f: meta_info = bdecode(f) torrent_data = get_torrent_data(meta_info) progress = download_info() #got the chunk dictionary chunks = get_chunks(meta_info, torrent_data['length']) #create our bitfield mybitfield = bitstring.BitArray( math.ceil(torrent_data['length'] / meta_info['info']['piece length'])) #make partitions in chunks(form blocks) partitioned_chunks = make_blocks_in_chunks(chunks)
def read(): return dict(bdecode(sys.stdin.buffer))
def tracker(self): params_dict = self.make_params() r = requests.get(self.url, params=params_dict) self.response = bdecode(r.content) self.peers = self.response['peers']
def try_to_connect_to_tracker(tracker_list, info_hash): parameters = { 'info_hash': info_hash, 'peer_id': PEER_ID, 'port': 6885, 'uploaded': 0, 'downloaded': 0, 'left': 0, 'event': 'started' } #print(parameters) for tracker in tracker_list: if str.startswith(tracker[0], 'http'): try: #print(tracker[0]) print('\nTrying to connect to (HTTP) tracker -> {}'.format( tracker[0])) response = requests.get(tracker[0], parameters, timeout=5) #print(response.content,'\n') except: print('Can\'t connect to {}'.format(tracker[0])) if not response: print('No response') return response = bdecode(response.content) #print(response) peers = [] for peer in response['peers']: peers.append(Peer(peer['ip'], peer['port'], peer['peer id'])) print('Found {} peers from {}'.format(len(peers), tracker[0])) return peers, tracker[0] elif str.startswith(tracker[0], 'udp'): print('\nTrying to connect to (UDP) tracker -> {}'.format( tracker[0])) request = urlparse(tracker[0]) sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.settimeout(4) try: ip, port = socket.gethostbyname(request.hostname), request.port except: continue if ipaddress.ip_address(ip).is_private: continue connection_request = encode_udpconnection() response = send_udp_message((ip, port), sock, connection_request) if not response: print('No response for udp connection request') continue connection_response = decode_udpconnection(response) announce_request = encode_udpannouncerequest( connection_response[2], torrent_data['info_hash'], bytes(PEER_ID, 'utf-8')) response = send_udp_message((ip, port), sock, announce_request) if not response: print('No response for udp announce request') continue #got list of peers announce_response = decode_udpannounceresponse(response) print( '\nTracker response:\nconnection id:{}\naction:{}\ntransaction id:{}\ninterval:{}\nleechers:{}\nseeders:{}\n' .format(connection_response[2], announce_response[0], announce_response[1], announce_response[2], announce_response[3], announce_response[4])) peers = [] for ip, port in announce_response[5]: peers.append(Peer(ip, port)) print('Found {} peers from {}'.format(len(peers), tracker[0])) return peers, tracker[0]
def decodeFile(self): f = open(self.inputURL, "rb") d = bdecode(f.read()) self.url = d['announce'] self.info = d['info'] self.reencoded = bencode(self.info)