bittorrent 学习(一) 种子文件分析与bitmap位图

终于抽出时间来进行 BITTORRENT的学习了

BT想必大家都很熟悉了，是一种文件分发协议。每个下载者在下载的同时也在向其他下载者分享文件。

相对于FTP HTTP协议，BT并不是从某一个或者几个指定的点进行文件下载，而是用户之间进行交互，每个用户既是下载者也是上传者.

BT并不会出现提供下载的服务点出现问题而无法下载的现象。

我尝试从BT文件开始下载的流程来分析下我们需要那些功能。

首先我们从某网站下载BT种子文件，文件很小，记录要下载的实际文件的一些信息。

那么我们就需要从该BT种子文件解析出 文件的数量(比如视频文件和文件字幕等多个文件)，文件名称，文件大小，还有最重要的连接何处网站获取其他用户信息等等等等。

这个就是种子解析模块。

Tracker服务器会记录在下载该文件的ip和端口，我们连接上去就可以从其他用户peer下载文件了，同时Tracker服务器也会记录我们自己的IP和端口，为其他peer分享文件。

这个是连接Tracker模块。

我们与其他peer进行连接，交换文件数据。就是peer交换数据模块。

主体就是这些。那么在实际运行中，会有一些细节需要解决，衍生出次级模块。

比如我们要知道其他peer下载的文件内容进度和提供我们下载文件的内容进度，这就需要bitmap管理模块。

为了防止有的peer之下载不上传，就需要添加一个策略管理，鼓励所有peer踊跃分享文件。

我们不可能每下一点点文件内容就马上写入磁盘，这样效率太低，所以也需要缓冲管理模块。

以及整个流程中消息的流转和管理的，消息管理模块。

结构图如下：

今天看看种子文件解析代码.bt种子文件使用B编码。如图

 了解了字符串 数字 列表和字典后，看看一个实际的BT文件

最开始的就是 d8:announce  41:http://tracker.trackerfix.com:80/announce

13:announce-list

l

　　l

　　41:http://tracker.trackerfix.com:80/announce

　　e

　　l

　　30:udp://9.rarbg.to:2710/announce

　　e

　　。。。。。。。

e

字典有两个 映射  一个key value是 announce  和 http://tracker.trackerfix.com:80/announce

一个key value 是 announce-list 对应一组列表  列表是 http://tracker.trackerfix.com:80/announce   udp://9.rarbg.to:2710/announce 等等

announce-list 中包含了 announce项目下的tracker服务器IP和端口 所以代码中只需要搜索其中一个关键字即可

int read_announce_list()
{
    Announce_list  *node = NULL;
    Announce_list  *p    = NULL;
    int            len   = 0;
    long           i;

    if( find_keyword("13:announce-list",&i) == 0 ) {
        if( find_keyword("8:announce",&i) == 1 ) {
            i = i + strlen("8:announce");
            while( isdigit(metafile_content[i]) ) {
                len = len * 10 + (metafile_content[i] - '0');
                i++;
            }
            i++;  // 跳过 ':'

            node = (Announce_list *)malloc(sizeof(Announce_list));
            strncpy(node->announce,&metafile_content[i],len);
            node->announce[len] = '';
            node->next = NULL;
            announce_list_head = node;
        }
    } 
    else {  // 如果有13:announce-list关键词就不用处理8:announce关键词
        i = i + strlen("13:announce-list");
        i++;         // skip 'l'
        while(metafile_content[i] != 'e') {
            i++;     // skip 'l'
            while( isdigit(metafile_content[i]) ) {
                len = len * 10 + (metafile_content[i] - '0');
                i++;
            }
            if( metafile_content[i] == ':' )  i++;
            else  return -1;

            // 只处理以http开头的tracker地址,不处理以udp开头的地址
            if( memcmp(&metafile_content[i],"http",4) == 0 ) {
                node = (Announce_list *)malloc(sizeof(Announce_list));
                strncpy(node->announce,&metafile_content[i],len);
                node->announce[len] = '';
                node->next = NULL;

                if(announce_list_head == NULL)
                    announce_list_head = node;
                else {
                    p = announce_list_head;
                    while( p->next != NULL) p = p->next; // 使p指向最后个结点
                    p->next = node; // node成为tracker列表的最后一个结点
                }
            }

            i = i + len;
            len = 0;
            i++;    // skip 'e'
            if(i >= filesize)  return -1;
        }    
    }

#ifdef DEBUG
    p = announce_list_head;
    while(p != NULL) {
        printf("%s
",p->announce);
        p = p->next;
    }
#endif    
    
    return 0;
}

piece length 表示每个piece的长度 一般是128K

int get_piece_length()
{
    long i;

    if( find_keyword("12:piece length",&i) == 1 ) {
        i = i + strlen("12:piece length");  // skip "12:piece length"
        i++;  // skip 'i'
        while(metafile_content[i] != 'e') {
            piece_length = piece_length * 10 + (metafile_content[i] - '0');
            i++;
        }
    } else {
        return -1;
    }

#ifdef DEBUG
    printf("piece length:%d
",piece_length);
#endif

    return 0;
}

 分析文件最常用的就是寻找关键字 代码采用比较简单的方法，逐个字节比较关键字

int find_keyword(char *keyword,long *position)
{
    long i;

    *position = -1;
    if(keyword == NULL)  return 0;

    for(i = 0; i < filesize-strlen(keyword); i++) {
        if( memcmp(&metafile_content[i], keyword, strlen(keyword)) == 0 ) {
            *position = i;
            return 1;
        }
    }
    
    return 0;
}

get_info_hash() 计算的是piece的哈希值

首先在文件中找到"4:info"关键字,找到其后的info信息 进行哈希计算.遇到需要‘e’字母对应的开头(比如字典开头‘d’，列表开头'l',数字开头'i'),计数加1.遇到‘e’，计数减1。 

计数到零，则说明找到"4:info"的完整信息，可以开始进行哈希计算。

这个要比网络上一些 查找 "4:info" 到 "5:nodes"之间字符串要可靠得多  有些种子文件是没有"5:nodes"

int get_info_hash()
{
    int   push_pop = 0;
    long  i, begin, end;

    if(metafile_content == NULL)  return -1;

    if( find_keyword("4:info",&i) == 1 ) {
        begin = i+6;  // begin是关键字"4:info"对应值的起始下标
    } else {
        return -1;
    }

    i = i + 6;        // skip "4:info"
    for(; i < filesize; )
        if(metafile_content[i] == 'd') { 
            push_pop++;
            i++;
        } else if(metafile_content[i] == 'l') {
            push_pop++;
            i++;
        } else if(metafile_content[i] == 'i') {
            i++;  // skip i
            if(i == filesize)  return -1;
            while(metafile_content[i] != 'e') {
                if((i+1) == filesize)  return -1;
                else i++;
            }
            i++;  // skip e
        } else if((metafile_content[i] >= '0') && (metafile_content[i] <= '9')) {
            int number = 0;
            while((metafile_content[i] >= '0') && (metafile_content[i] <= '9')) {
                number = number * 10 + metafile_content[i] - '0';
                i++;
            }
            i++;  // skip :
            i = i + number;
        } else if(metafile_content[i] == 'e') {
            push_pop--;
            if(push_pop == 0) { end = i; break; }
            else  i++; 
        } else {
            return -1;
        }
    if(i == filesize)  return -1;

    SHA1_CTX context;
    SHA1Init(&context);
    SHA1Update(&context, &metafile_content[begin], end-begin+1);
    SHA1Final(info_hash, &context);

#ifdef DEBUG
    printf("info_hash:");
    for(i = 0; i < 20; i++)  
        printf("%.2x ",info_hash[i]);
    printf("
");
#endif

    return 0;
}

我们需要为自己生成一个用于辨识的peerid,调用get_peer_id()

int get_peer_id()
{
    // 设置产生随机数的种子
    srand(time(NULL));
    // 生成随机数,并把其中12位赋给peer_id,peer_id前8位固定为-TT1000-
    sprintf(peer_id,"-TT1000-%12d",rand());

#ifdef DEBUG
    int i;
    printf("peer_id:");
    for(i = 0; i < 20; i++)  printf("%c",peer_id[i]);
    printf("
");
#endif

    return 0;
}

代码中使用了堆内存，在退出或者不使用的时候需要回收。调用 release_memory_in_parse_metafile()

void release_memory_in_parse_metafile()
{
    Announce_list *p;
    Files         *q;
    
    if(metafile_content != NULL)  free(metafile_content);
    if(file_name != NULL)         free(file_name);
    if(pieces != NULL)            free(pieces);
    
    while(announce_list_head != NULL) {
        p = announce_list_head;
        announce_list_head = announce_list_head->next;
        free(p);
    }

    while(files_head != NULL) {
        q = files_head;
        files_head = files_head->next;
        free(q);
    }
}

//=====================================================================================================

下面看下bitmap 位图

位图相当于一个文件的缩略图，一个字节有8位，如果每位的01代表一个文件的10k的空间是否下载成功，那么我们使用一个字节就可以表示80K文件的下载进度。

而实际上在bttorrent中，每位使用01表示一个piece的下载成功与否，若一个piece是256k，那么一个字节8位就可以表示 256*8=2048k=2M文件的下载进度。

Bitmap结构如下

typedef struct _Bitmap {
　　unsigned char *bitfield; // 保存位图
　　int bitfield_length; // 位图所占的总字节数
　　int valid_length; // 位图有效的总位数,每一位代表一个piece
} Bitmap;

创建bitmap函数流程如下

首先分配Bitmap的内存,然后根据piece长度决定bitmap记录的长度。

valid_length是有效长度，就是能表示的真实文件的长度。 一个位图表示piece长度的1/20

bitfield_length就是位图占用的长度。 一个位图表示piece长度的1/20再除以8 ，就是字节长度

然后根据bitfield_length分配内存。这里需要注意的是，文件长度未必就是完全可以整除的长度，那么bitfield_length就在添加一个字节，用于指示文件整除后不足以显示的余额

// 如果存在一个位图文件,则读位图文件并把获取的内容保存到bitmap
// 如此一来,就可以实现断点续传,即上次下载的内容不至于丢失
int create_bitfield()
{
    bitmap = (Bitmap *)malloc(sizeof(Bitmap));
    if(bitmap == NULL) { 
        printf("allocate memory for bitmap fiailed
"); 
        return -1;
    }

    // pieces_length除以20即为总的piece数
    bitmap->valid_length = pieces_length / 20;
    bitmap->bitfield_length = pieces_length / 20 / 8;
    if( (pieces_length/20) % 8 != 0 )  bitmap->bitfield_length++;

    bitmap->bitfield = (unsigned char *)malloc(bitmap->bitfield_length);
    if(bitmap->bitfield == NULL)  { 
        printf("allocate memory for bitmap->bitfield fiailed
"); 
        if(bitmap != NULL)  free(bitmap);
        return -1;
    }

    char bitmapfile[64];
    sprintf(bitmapfile,"%dbitmap",pieces_length);
    
    int  i;
    FILE *fp = fopen(bitmapfile,"rb");
    if(fp == NULL) {  // 若打开文件失败,说明开始的是一个全新的下载
        memset(bitmap->bitfield, 0, bitmap->bitfield_length);
    } else {
        fseek(fp,0,SEEK_SET);
        for(i = 0; i < bitmap->bitfield_length; i++)
            (bitmap->bitfield)[i] = fgetc(fp);
        fclose(fp); 
        // 给download_piece_num赋新的初值
        download_piece_num = get_download_piece_num();
    }
    
    return 0;
}

 根据索引获取bitmap的标识值 

因为是每1位代表一个pieces的下载与否

索引输入的索引值index是位的个数 

index / 8 = i  i就代表查询或者设置的那位在 第i个byte中。

但是byte有8位，具体是要查询或者设置哪一位呢？ index%8=j  j就是我们要查询设置的位

示意图 index从1开始

int get_bit_value(Bitmap *bitmap,int index)  
{
    int           ret;
    int           byte_index;
    unsigned char byte_value;
    unsigned char inner_byte_index;

    if(index >= bitmap->valid_length)  return -1;

    byte_index = index / 8;
    byte_value = bitmap->bitfield[byte_index];
    inner_byte_index = index % 8;

    byte_value = byte_value >> (7 - inner_byte_index);
    if(byte_value % 2 == 0) ret = 0;
    else                    ret = 1;

    return ret;
}

int set_bit_value(Bitmap *bitmap,int index,unsigned char v)
{
    int           byte_index;
    unsigned char inner_byte_index;

    if(index >= bitmap->valid_length)  return -1;
    if((v != 0) && (v != 1))   return -1;

    byte_index = index / 8;
    inner_byte_index = index % 8;

    v = v << (7 - inner_byte_index);
    bitmap->bitfield[byte_index] = bitmap->bitfield[byte_index] | v;

    return 0;
}

 

int all_zero(Bitmap *bitmap)
int all_set(Bitmap *bitmap) 将bitmap记录全部置0和置1

int all_zero(Bitmap *bitmap)
{
    if(bitmap->bitfield == NULL)  return -1;
    memset(bitmap->bitfield,0,bitmap->bitfield_length);
    return 0;
}
 
int all_set(Bitmap *bitmap)
{
    if(bitmap->bitfield == NULL)  return -1;
    memset(bitmap->bitfield,0xff,bitmap->bitfield_length);
    return 0;    
}

is_interested(Bitmap *dst,Bitmap *src) 比较两个bitmap

如果src的bitmap中有1位为0(即没有这个piece)

而dst的bitmap中这1位为1(即有这个piece) 则说明 src对dst感兴趣 interest

int is_interested(Bitmap *dst,Bitmap *src)
{
    unsigned char const_char[8] = { 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
    unsigned char c1, c2;
    int           i, j;
    
    if( dst==NULL || src==NULL )  return -1;
    if( dst->bitfield==NULL || src->bitfield==NULL )  return -1;
    if( dst->bitfield_length!=src->bitfield_length ||
        dst->valid_length!=src->valid_length )
        return -1;
    
    for(i = 0; i < dst->bitfield_length-1; i++) {
        for(j = 0; j < 8; j++) {
            c1 = (dst->bitfield)[i] & const_char[j];
            c2 = (src->bitfield)[i] & const_char[j];
            if(c1>0 && c2==0) return 1;
        }
    }
    
    j  = dst->valid_length % 8;
    c1 = dst->bitfield[dst->bitfield_length-1];
    c2 = src->bitfield[src->bitfield_length-1];
    for(i = 0; i < j; i++) {
        if( (c1&const_char[i])>0 && (c2&const_char[i])==0 )
            return 1;
    }
    
    return 0;
}

get_download_piece_num() 获取位图中为1的位数 也就是下载了多少pieces

直接和 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01 相与

这种做法是遍历一次查询多少个1 要快很多

int get_download_piece_num()
{
    unsigned char const_char[8] = { 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};
    int           i, j;
    
    if(bitmap==NULL || bitmap->bitfield==NULL)  return 0;
    
    download_piece_num =0;

    for(i = 0; i < bitmap->bitfield_length-1; i++) {
        for(j = 0; j < 8; j++) {
            if( ((bitmap->bitfield)[i] & const_char[j]) != 0) 
                download_piece_num++;
        }
    }

    unsigned char c = (bitmap->bitfield)[i]; // c存放位图最后一个字节
    j = bitmap->valid_length % 8;            // j是位图最后一个字节的有效位数
    for(i = 0; i < j; i++) {
        if( (c & const_char[i]) !=0 ) download_piece_num++;
    }
        
    return download_piece_num;
}

 把代码改写成了cpp

附上

#pragma once
#include "pre.h"
#include <string>
#include <vector>

NAMESPACE(DEF)
NAMESPACE(BTPARSE)
class ParseBT {
public:
    ParseBT() {
        metaFileSize = 0;
        piece_length = -1;
        pieces_length = 0;
        multi_file = false;
        buf_ptr = std::shared_ptr<char>(new char[DEF_BUF_SIZE], std::default_delete<char[]>());
    }
    ~ParseBT() {}
    bool ReadMetaFile(std::string name);
    bool ReadAnnounceList();
    bool FindKeyWord(const std::string& key,int& pos);
    bool IsMultiFiles();
    bool GetPieceLength();
    bool GetPieces();
    bool GetFileName();
    bool GetFilesLengthPath();
    bool GetFileLength();
    bool GetInfoHash();
    bool GetPerID();
private:
    long metaFileSize;
    bool multi_file;
    int piece_length;
    int pieces_length;
    ParseBT(const ParseBT&) = delete;
    ParseBT& operator=(const ParseBT&) = delete;
    enum {
        DEF_BUF_SIZE = 1024 * 100
    };

    unsigned char infoHash[20];
    unsigned char peerID[20];
    std::vector < std::pair<std::string, size_t> > fileInfos;

    std::shared_ptr<char> buf_ptr;
    std::shared_ptr<char> pieces_ptr;
    std::vector<std::string> announce_list;
};











ENDNAMESPACE(BTPARSE)
ENDNAMESPACE(DEF)

#include <iostream>

#include <time.h>
extern "C" {
#include "sha1.h"
}
#include "ParseBT.h"


NAMESPACE(DEF)
NAMESPACE(BTPARSE)
struct Fclose
{
    void operator()(FILE* fp)
    {
        fclose(fp);
        fp = NULL;
    }
};

bool ParseBT::ReadMetaFile(std::string name) {
    bool b = false;
    if (name.empty())
        return b;

    std::unique_ptr<FILE, Fclose> fp(fopen(name.c_str(), "rb"));
    if (fp == nullptr) {
        std::cerr << __FUNCTION__ << "error!" << std::endl;
        return b;
    }

    // 获取种子文件的长度
    fseek(fp.get(), 0, SEEK_END);
    metaFileSize = ftell(fp.get());
    if (metaFileSize == -1) {
        printf("%s:%d fseek failed
", __FILE__, __LINE__);
        return b;
    }
    if (DEF_BUF_SIZE < metaFileSize) {
        std::shared_ptr<char> p = std::shared_ptr<char>(new char[metaFileSize], std::default_delete<char[]>());
        buf_ptr.swap( p );
    }

    fseek(fp.get(), 0, SEEK_SET);
    int readbyte = fread(buf_ptr.get(),1, metaFileSize,fp.get());
    if (readbyte != metaFileSize) {
        std::cerr << __FUNCTION__ << ". fread() error!" << std::endl;
        return b;
    }

    b = true;
    return b;
}

bool ParseBT::GetInfoHash() {
    bool b = false;
    int i = 0;
    int begin = 0; int push_pop = 0; int end = 0;

    if (buf_ptr == NULL)  return b;

    if (FindKeyWord("4:info", i) == true) {
        begin = i + 6;  // begin是关键字"4:info"对应值的起始下标
    }
    else {
        return -b;
    }

    i = i + 6;        // skip "4:info"

    for (; i < metaFileSize; )
        if (buf_ptr.get()[i] == 'd') {
            push_pop++;
            i++;
        }
        else if (buf_ptr.get()[i] == 'l') {
            push_pop++;
            i++;
        }
        else if (buf_ptr.get()[i] == 'i') {
            i++;  // skip i
            if (i == metaFileSize)  return -1;
            while (buf_ptr.get()[i] != 'e') {
                if ((i + 1) == metaFileSize)  return -1;
                else i++;
            }
            i++;  // skip e
        }
        else if ((buf_ptr.get()[i] >= '0') && (buf_ptr.get()[i] <= '9')) {
            int number = 0;
            while ((buf_ptr.get()[i] >= '0') && (buf_ptr.get()[i] <= '9')) {
                number = number * 10 + buf_ptr.get()[i] - '0';
                i++;
            }
            i++;  // skip :
            i = i + number;
        }
        else if (buf_ptr.get()[i] == 'e') {
            push_pop--;
            if (push_pop == 0) { end = i; break; }
            else  i++;
        }
        else {
            return -1;
        }
    if (i == metaFileSize)  return b;

    SHA1Context context;
    SHA1Reset(&context);
    unsigned char* p = (unsigned char*)buf_ptr.get();
    SHA1Input(&context, &(p[begin]), end - begin + 1);
    SHA1Result(&context, infoHash);

    printf("begin = %d ,end = %d 
", begin, end);

#if 1
    printf("info_hash:");
    for (i = 0; i < 20; i++)
        printf("%.2x ", infoHash[i]);
    printf("
");
#endif

    b = true;
    return b;
}


bool ParseBT::GetFileName() {
    bool b = false;
    int  i;
    int   count = 0;

    if (FindKeyWord("4:name", i) == true) {
        i = i + 6;  // skip "4:name"
        while ((buf_ptr.get())[i] != ':') {
            count = count * 10 + ((buf_ptr.get())[i] - '0');
            i++;
        }
        i++;        // skip ':' 
        std::string file_name(&(buf_ptr.get())[i], &(buf_ptr.get())[i]+count);
        //std::string s = "反贪风暴3.L.Storm.2018.1080p.WEB-DL.X264.AAC-国粤中字-RARBT";
    }
    else {
        return b;
    }

#if 1
    // 由于可能含有中文字符,因此可能打印出乱码
    // printf("file_name:%s
",file_name);
#endif

    return b;
}

bool ParseBT::FindKeyWord(const std::string& key, int& pos) {
    bool b = false;
    pos = 0;
    if (key.empty())  return b;

    for (int i = 0; i < metaFileSize - key.size(); i++) {
        if (memcmp(&(buf_ptr.get())[i], key.c_str(),key.size()) == 0) {
            pos = i; b = true;
            return b;
        }
    }

    return b;
}

bool ParseBT::ReadAnnounceList() {
    bool b = false;
    int i = -1;
    int len = 0;
    if (FindKeyWord("13:announce-list", i) == false) {
        if (FindKeyWord("8:announce", i) == true) {
            i = i + strlen("8:announce");
            while (isdigit((buf_ptr.get())[i])) {
                len = len * 10 + ((buf_ptr.get())[i] - '0');
                i++;
            }
            i++;  // 跳过 ':'

            std::string s ( &(buf_ptr.get())[i] , &(buf_ptr.get())[i]+len);
            announce_list.push_back(s);
            b = true;
        }
    }
    else {
        //如果有13:announce-list关键词就不用处理8:announce关键词
        i = i + strlen("13:announce-list");
        i++;         // skip 'l'
        while ((buf_ptr.get())[i] != 'e') {
            i++;     // skip 'l'
            while (isdigit((buf_ptr.get())[i])) {
                len = len * 10 + ((buf_ptr.get())[i] - '0');
                i++;
            }
            if ((buf_ptr.get())[i] == ':')  i++;
            else  return b;

            // 只处理以http开头的tracker地址,不处理以udp开头的地址
            if (memcmp(&(buf_ptr.get())[i], "http", 4) == 0) {

                std::string s(&(buf_ptr.get())[i], &(buf_ptr.get())[i] + len);
                announce_list.push_back(s);
            }

            i = i + len;
            len = 0;
            i++;    // skip 'e'
            if (i >= metaFileSize)  return b;

        }
    }
#if 0
    std::cout << "announce_list size =  " << announce_list.size() << std::endl;
    for (auto& e : announce_list) {
        std::cout << e << std::endl;
    }
    std::cout << std::endl;
#endif
    b = true;
    return b;
}

bool ParseBT::IsMultiFiles() {
    bool b = false;
    int i;

    if (FindKeyWord("5:files", i) == true) {
        multi_file = true;
        b = true;
    }

#if 1
    printf("is_multi_files:%d
",multi_file);
#endif

    b = true;
    return b;
}

bool  ParseBT::GetPieceLength() {
    int length = 0;
    int i = 0;
    if (FindKeyWord("12:piece length", i) == true) {
        i = i + strlen("12:piece length");  // skip "12:piece length"
        i++;  // skip 'i'
        while ((buf_ptr.get())[i] != 'e') {
            length = length * 10 + ((buf_ptr.get())[i] - '0');
            i++;
        }
    }
    else {
        return false;
    }

    piece_length = length;

#if 1
    printf("piece length:%d
", piece_length);
#endif

    return true;
}

bool ParseBT::GetPieces() {
    bool b = false;
    int i = 0;

    if (FindKeyWord("6:pieces", i) == true) {
        i = i + 8;     // skip "6:pieces"
        while ((buf_ptr.get())[i] != ':') {
            pieces_length = pieces_length * 10 + ((buf_ptr.get())[i] - '0');
            i++;
        }
        i++;           // skip ':'

        pieces_ptr = std::shared_ptr<char>(new char[pieces_length + 1], std::default_delete<char[]>());
    
        memcpy(pieces_ptr.get(), &(buf_ptr.get())[i], pieces_length);
        (pieces_ptr.get())[pieces_length] = '';
    }
    else {
        return b;
    }

#if 1
    printf("get_pieces ok
");
#endif

    b = true;
    return b;
}


bool ParseBT::GetFileLength() {
    bool b = false;
    int i = 0;
    size_t file_length = 0;
    if (IsMultiFiles() == true) {
        if (fileInfos.empty())
            GetFilesLengthPath();
        for (auto& e : fileInfos) {
            file_length += e.second;
        }
    }
    else {
        if (FindKeyWord("6:length", i) == true) {
            i = i + 8;
            i++;
            while (buf_ptr.get()[i] != 'e') {
                file_length = file_length * 10 + (buf_ptr.get()[i]  -'0');
                i++;
            }
        }
    }

#if 1
    printf("file_length:%lld
", file_length);
#endif

    b = true;

    return b;
}


bool ParseBT::GetFilesLengthPath() {
    bool b = false;
    if (IsMultiFiles() != true) {
        return b;
    }

    std::string name;
    size_t length = 0;
    int i = 0;
    int count = 0;
    for ( i = 0; i < metaFileSize - 8; i++) {
        if (memcmp(&(buf_ptr.get())[i], "6:length", 8) == 0) {
            i = i + 8;
            i++;
            
            while ((buf_ptr.get())[i] != 'e') {
                length = length*10 + ((buf_ptr.get())[i] - '0');
                i++;
            }
        }

        if (memcmp(&(buf_ptr.get())[i], "4:path", 6) == 0) {
            i = i + 6;
            i++;
            count = 0;
            while (buf_ptr.get()[i] != ':') {
                count = count * 10 + (buf_ptr.get()[i] - '0');
                i++;
            }
            i++;
            name = std::string(&(buf_ptr.get())[i], &(buf_ptr.get())[i] + count);
            //std::cout << name << std::endl;

            if (!name.empty() && length != 0) {
                std::pair<std::string, size_t> pa{ name,length };
                fileInfos.push_back(pa);
                name.clear();
                length = 0;
            }
        }
    }

    b = true;
    return b;
}

bool ParseBT::GetPerID() {
    bool b = false;
    srand(time(NULL));
       sprintf((char*)peerID, "TT1000-%12d", rand());

#if 1
    int i;
    printf("peer_id:");
    for (i = 0; i < 20; i++)  printf("%c", peerID[i]);
    printf("
");
#endif

    b = true;
    return b;
}




ENDNAMESPACE(BTPARSE)
ENDNAMESPACE(DEF)

// MyParseBTFile.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//


#include <iostream>
#include "ParseBT.h"

using namespace DEF::BTPARSE;

int main()
{
    for (int i = 0; i < 100000; i++) {
        ParseBT pbt;
        if (false == pbt.ReadMetaFile("1.torrent"))
            return 1;
        int pos = -1;
        pbt.FindKeyWord("info", pos);
        pbt.ReadAnnounceList();
        pbt.IsMultiFiles();
        pbt.GetPieceLength();
        pbt.GetPieces();
        pbt.GetFileName();
        pbt.GetFilesLengthPath();
        pbt.GetFileLength();
        pbt.GetInfoHash();
        pbt.GetPerID();
    }
    

}

参考

《linux c编程实战》第十三章节btcorrent  及代码