Python边学边用BT客户端实现之（一）BitTorrent文件解析

BitTorrent文件解析：

BitTorrent文件使用bencode编码，其中包括了4种数据类型：

'd' 开头表示是dict类型，'e'表示结束

'l' （小写字母L）开头表示是list类型，'e'表示结束

'i'开头表示是integer类型，'e'表示结束，可以表示负数

以数字开头表示string类型，数字为string长度，长度与string内容以':'分割

默认所有text类型的属性为utf-8编码，但是大多数BitTorrent包含codepage 和 encoding属性，指定了text的编码格式

"announce" -- tracker服务器的地址，为string
"info" ---文件信息，为dict类型
　　"name" --单文件模式，表示文件名，多文件模式表示根目录名。
　　"length" --单文件模式表示文件长度，多文件模式不存在
　　"piece length" --文件分片大小
　　"pieces" --为一个长string, 没20个字节表示一个分片的SHA1 hash值。按照文件分片的顺序排列。
　　　　　　　　分片是按照所以文件组合在一起进行的，即一个分片可能会跨越多个文件。
　　"files" -- 多文件模式存在，为一个文件列表，每个文件为一个dict类型
　　　　　　"path" -- 文件目录列表，最后一项为文件名
　　　　　　"length" --文件长度

"peace length"  --分片大小

以下为draft bep定义的属性
"code page"
"announce-list" --tracker列表，为二维数组，即将tracker服务器分为多个组
"encoding" -- Text属性的编码类型，string 类型，如 UTF-8
"publisher" -- 发布者
"publisher url" --发布者 URL
"creater" --创建者，如btcomet,btspirit
"creation date" --创建日期，为UTC格式，需要转化为本地时区可读格式
"commnent" --注释
"nodes" -- DHT 节点列表

BitTorrent的标准参见：http://www.bittorrent.org/beps/bep_0003.html

以下是自己写的Python实现，初学Python，代码写起来还都是C/C++风格，慢慢改进吧。

 修改代码，bittorrent文件的解码使用异常处理解决文件格式错误的情况，简化处理过程。

'''
Created on 2012-9-30

@author: ddt
'''
class DataEncodedError(BaseException):
    def __str__(self):
        return 'Data Encoded Error'

class DataTypeError(BaseException):
    def __str__(self):
        return 'Data Type Error'
    
def bdecode(data):
    try:
        leading_chr = data[0]
        #print leading_chr,                 
        if leading_chr.isdigit():
            chunk, length = _read_string(data)
            #print chunk
        elif leading_chr == 'd':
            chunk, length = _read_dict(data)
            #print chunk is None
        elif leading_chr == 'i':
            chunk, length = _read_integer(data)
            #print chunk
        elif leading_chr == 'l':
            chunk, length = _read_list(data)
        else:
            raise DataEncodedError()
        return chunk, length
    except:
        raise DataEncodedError()
    
                           
def _read_dict(data):
    chunk = {} 
    length = 1
    
    while data[length] != 'e':
        key, key_len = bdecode(data[length:])
        length += key_len
        
        value, value_len = bdecode(data[length:])
        length += value_len
        
        chunk[key] = value
        #print key
        
    length += 1
    return chunk, length

def _read_list(data):
    chunk = []
    length = 1
    while data[length] != 'e':
        value, value_len = bdecode(data[length:])
        chunk.append(value)
        length += value_len  
        
    length += 1
    return chunk, length

def _read_string(data):
    comm_index = data.find(':')
    str_len = int(data[:comm_index])
    value = data[comm_index+1:comm_index+1+str_len]
    
    length = comm_index + 1 + str_len
    return ''.join(value), length

def _read_integer(data):

    end_index = data.find('e')
    value = int(data[1:end_index])
    length = end_index + 1
    
    return  value, length

def bencode(data):
    data_type = type(data)
    if data_type == type({}):
        result = _write_dict(data)
    elif data_type == type([]):
        result = _write_list(data)
    elif data_type == type(''):
        result = _write_string(data)
    elif data_type == type(int(0)):
        result = _write_integer(data)
    else:
        raise DataTypeError()
    return result

def _write_dict(data):
    result = 'd'
    for key, value in data.items():
        key_encode = bencode(key)
        value_encode = bencode(value)
        result += key_encode
        result += value_encode

    result += 'e'
    return result

def _write_list(data):
    result = 'l'
    for value in data:
        value_encode = bencode(value)
        result += value_encode
        
    result += 'e'
    return result

def _write_string(data):
    return '%d:%s' %(len(data), data)

def _write_integer(data):
    return 'i%de' %data

    

from datetime import datetime
import bcodec
import hashlib

_READ_MAX_LEN = -1

class BTFormatError(BaseException):
    def __str__(self):
        return 'Torrent File Format Error'

class TorrentFile(object):
    
    def __init__(self):    
        self.__metainfo = {}
        self.__file_name = ''
        self.__bencode_data = None
    
    def read_file(self, filename):
        
        torrent_file = open(filename, 'rb')
        data = torrent_file.read(_READ_MAX_LEN)
        torrent_file.close()
        
        try:
            metainfo, length = bcodec.bdecode(data)
            self.__file_name = filename
            self.__metainfo = metainfo
            self.__bencode_data = data
        except:
            raise BTFormatError()
        
    def __is_singlefile(self):
        
        return self.__get_meta_info('length') != None
    
    def __decode_text(self, text):
        encoding = 'utf-8'
        resultstr = ''
        if self.get_encoding() != None:
            encoding = self.get_encoding()
        elif self.get_codepage() != None:
            encoding = 'cp' + str(self.get_codepage())
        if text:
            try:
                resultstr = text.decode(encoding=encoding)
            except ValueError:
                return text
        else:
            return None
        return resultstr
    
    def __get_meta_top(self, key):
        if key in self.__metainfo.keys():
            return self.__metainfo[key]
        else:
            return None
    def __get_meta_info(self,key):
        meta_info = self.__get_meta_top('info')
        if meta_info != None and key in meta_info.keys():
                return meta_info[key]
        return None
    
    def get_codepage(self):
        return self.__get_meta_top('codepage')
    def get_encoding(self):
        return self.__get_meta_top('encoding')
    
    def get_announces(self):
        announces = self.__get_meta_top('announce-list')
        if announces != None:
            return announces
        
        announces = [[]]
        ann = self.__get_meta_top('announce')
        if ann:
            announces[0].append(ann)
        return announces
    
    def get_publisher(self):
        return self.__decode_text(self.__get_meta_top('publisher'))
    def get_publisher_url(self):
        return self.__decode_text(self.__get_meta_top('publisher-url'))
    
    def get_creater(self):
        return self.__decode_text(self.__get_meta_top('created by'))
    def get_creation_date(self):
        utc_date = self.__get_meta_top('creation date')
        if utc_date == None:
            return utc_date
        creationdate = datetime.utcfromtimestamp(utc_date)
        return creationdate
    def get_comment(self):
        return self.__get_meta_top('comment')
          
    def get_nodes(self):
        return self.__get_meta_top('nodes')
    
    def get_piece_length(self):
        return self.__get_meta_info('piece length')
    
    def get_piece(self, index):
        pieces = self.__get_meta_info('pieces')
        if pieces == None:
            return None
        
        offset = index*20
        if offset+20 > len(pieces):
            return None
        return pieces[offset:offset+20]
    
    def get_pieces_num(self):
        return len(self.__get_meta_info('pieces'))/20
        
    def get_files(self):
        
        files = []
        name = self.__decode_text(self.__get_meta_info('name'))
        piece_length = self.get_piece_length()
        if name == None:
            return files
        
        if self.__is_singlefile():
            file_name = name
            file_length = self.__get_meta_info('length')
            if not file_length:
                return files
            
            pieces_num = file_length/piece_length
            last_piece_offset =  file_length % piece_length
            if last_piece_offset != 0:
                pieces_num = int(pieces_num) + 1
                last_piece_offset -= 1
            else:
                last_piece_offset = piece_length - 1

            first_piece_offset = 0
            
            files.append({'name':[file_name], 'length':file_length, 'first-piece':(0, first_piece_offset), 'last-piece':(pieces_num-1,last_piece_offset)})
            return files
        
        folder = name
        meta_files = self.__get_meta_info('files')
        if meta_files == None:
            return files
        
        total_length = int(0)
        for one_file in self.__get_meta_info('files'):
            
            file_info = {}
            path_list = []
            path_list.append(folder)
                        
            if 'path' not in one_file.keys():
                break
            for path in one_file['path']:
                path_list.append(self.__decode_text(path))
            file_info['name'] = path_list
            
            if 'length' not in one_file.keys():
                break
            
            file_info['length'] =  one_file['length']
            
            piece_index = total_length / piece_length
            first_piece_offset =  total_length % piece_length
            
            total_length += one_file['length']
            pieces_num = total_length / piece_length - piece_index
            last_piece_offset = total_length % piece_length
            
            if last_piece_offset != 0:
                pieces_num += 1
                last_piece_offset -= 1
            else:
                last_piece_offset = piece_length - 1
            
            file_info['first-piece'] = (piece_index,first_piece_offset)
            file_info['last-piece'] = ((piece_index+pieces_num-1),last_piece_offset)
            files.append(file_info)
        return files
    
    def get_info_hash(self):
        info_index = self.__bencode_data.find('4:info')
        info_data_index = info_index+len('4:info')
        
        info_value, info_data_len = bcodec.bdecode(self.__bencode_data[info_data_index:])
        info_data = self.__bencode_data[info_data_index:info_data_index+info_data_len]
        
        info_hash = hashlib.sha1()
        info_hash.update(info_data)
        return info_hash.digest()

    
if __name__ == '__main__':
    filename = r".\narodo.torrent"

    torrent = TorrentFile()

    print "begin to read file"
    torrent.read_file(filename)

    print "end to read file"

    print "announces: " , torrent.get_announces() 
    print "info_hash: ", list(torrent.get_info_hash())
    print "peace length:", torrent.get_piece_length()
    print "code page:" , torrent.get_codepage()
    print "encoding:" , torrent.get_encoding()
    print "publisher:" ,torrent.get_publisher()
    print "publisher url:", torrent.get_publisher_url()
    print "creater:" , torrent.get_creater()
    print "creation date:", torrent.get_creation_date()
    print "commnent:", torrent.get_comment()
    print "nodes:", torrent.get_nodes()
    torrent.get_files()
    for one_file in torrent.get_files():
        print 'name:', '\\'.join(one_file['name'])
        print 'length:', one_file['length']
        print 'first-piece:', one_file['first-piece']
        print 'last-piece:', one_file['last-piece']