bittorrent 学习(三) MSG

msg.c中

int转化 char[4]  char[4]转化int的函数 如下(有多种方案)

int int_to_char(int i, unsigned char c[4])
{
    c[3] = i % 256;
    c[2] = (i - c[3]) / 256 % 256;
    c[1] = (i - c[3] - c[2] * 256) / 256 / 256 % 256;
    c[0] = (i - c[3] - c[2] * 256 - c[1] * 256 * 256) / 256 / 256 / 256 % 256;

    return 0;
}

int IntToChar(int j, unsigned char c[4]) {
    int i = 0;
    for (i = 0; i < 4; i++) {
        c[i] = (j >> (4 - i - 1) * 8) & 0xff;
    }
    return 0;
}

int CharToInt1(unsigned char c[4]) {
    int i = 0;

    unsigned char* p = (unsigned char*)&i;
    for (int j = 3; j > 0 ; j--) {
        memcpy(p, &c[j], sizeof(c[j]));
        p++;
    }
    memcpy(p, &c[0], sizeof(c[0]));

    return i;
}

int CharToInt(unsigned char c[4]) {
    int i = 0;
    for (int j = 0; j < 3; j++) {
        i += c[j];
        i <<= 8;
    }
    i += c[3];

    return i;
}

int char_to_int(unsigned char c[4])
{
    int i;

    i = c[0] * 256 * 256 * 256 + c[1] * 256 * 256 + c[2] * 256 + c[3];

    return i;
}

创建握手信息的函数 create_handshake_msg()

握手消息

客户端与一个peer建立TCP连接后，首先向peer发送握手消息，peer收到握手消息后回应一个握手消息。握手消息是一个长度固定为68字节的消息，格式如下：
<pstrlen><pstr><reserved><info_hash><peer_id>

握手消息参数
参数 含义
pstrlen pstr的长度，固定为19
pstr BitTorrent协议的关键字，即”BitTorrent protocol”
reserved 占8字节，用于扩展BT协议。可忽略
info_hash 与发往Tracker的GET请求中的info_hash为同一个值，固定为20字节
peer_id 与发往Tracker的GET请求中的peer_id为同一个值，固定为20字节

info_hash就是种子文件中 4:info 后的种子信息计算的哈希值

int create_handshake_msg(char *info_hash,char *peer_id,Peer *peer)
{
    int            i;
    unsigned char  keyword[20] = "BitTorrent protocol", c = 0x00;
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    if(len < 68)  return -1;  // 68为握手消息的固定长度

    buffer[0] = 19;
    for(i = 0; i < 19; i++)  buffer[i+1]  = keyword[i];
    for(i = 0; i < 8;  i++)  buffer[i+20] = c;
    for(i = 0; i < 20; i++)  buffer[i+28] = info_hash[i];
    for(i = 0; i < 20; i++)  buffer[i+48] = peer_id[i];

    peer->msg_len += 68;
    return 0;
}

 心跳函数 表明I自己在线 create_chock_interested_msg()

发送4个0

int create_keep_alive_msg(Peer *peer)
{
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    if(len < 4)  return -1;  // 4为keep_alive消息的固定长度

    memset(buffer,0,4);
    peer->msg_len += 4;
    return 0;
}

chock 函数 create_chock_interested_msg() 表明对方由于某种原因阻塞 比如贡献度不够？ 或者是否感兴趣  

结构都是一致的 5字节 第四个为1 第五个表示消息类型(choke、unchoke、interested、uninterested)

int create_chock_interested_msg(int type,Peer *peer)
{
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    // 5为choke、unchoke、interested、uninterested消息的固定长度
    if(len < 5)  return -1;

    memset(buffer,0,5);
    buffer[3] = 1;
    buffer[4] = type;

    peer->msg_len += 5;
    return 0;
}

表示是否拥有该index的piece函数 create_have_msg()

9个字节 最后4个字节是index的int to char 计算的结果。 第4 5个字节填写 5 4 。这个似乎在协议说明里没看到

int create_have_msg(int index,Peer *peer)
{
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;
    unsigned char  c[4];

    if(len < 9)  return -1;  // 9为have消息的固定长度
    
    memset(buffer,0,9);    
    buffer[3] = 5;
    buffer[4] = 4;
    
    int_to_char(index,c);
    buffer[5] = c[0];
    buffer[6] = c[1];
    buffer[7] = c[2];
    buffer[8] = c[3];
    
    peer->msg_len += 9;
    return 0;
}

创建位图消息 create_bitfield_msg() 传递本地位图文件消息

长度不定 位图长度+5 前4位是位图长度 int to char 的数组  第五位标记为5  后面是位图

int create_bitfield_msg(char *bitfield,int bitfield_len,Peer *peer)
{
    int            i;
    unsigned char  c[4];
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    if( len < bitfield_len+5 )  {  // bitfield消息的长度为bitfield_len+5
        printf("%s:%d buffer too small
",__FILE__,__LINE__); 
        return -1;
    }

    int_to_char(bitfield_len+1,c);
    for(i = 0; i < 4; i++)  buffer[i] = c[i];
    buffer[4] = 5;
    for(i = 0; i < bitfield_len; i++) buffer[i+5] = bitfield[i];

    peer->msg_len += bitfield_len+5;  
    return 0;
}

请求文件的内容函数 create_request_msg()

前5字节固定 第4 5字节填写13 6.后面每4个字节分别填写 index begin end的int to char。

因为peer之间交换数据时以slice（长度为16KB的块）为单位的，因此request消息中length的值一般为16K。最大不超过128K

int create_request_msg(int index,int begin,int length,Peer *peer)
{
    int            i;
    unsigned char  c[4];
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    if(len < 17)  return -1;  // 17为request消息的固定长度

    memset(buffer,0,17);
    buffer[3] = 13;
    buffer[4] = 6;
    int_to_char(index,c);
    for(i = 0; i < 4; i++)  buffer[i+5]  = c[i];
    int_to_char(begin,c);
    for(i = 0; i < 4; i++)  buffer[i+9]  = c[i];
    int_to_char(length,c);
    for(i = 0; i < 4; i++)  buffer[i+13] = c[i];

    peer->msg_len += 17;
    return 0;
}

 创建piece信息 create_piece_msg()

长度为piece长度加13。

头4个字节是总长度 piece_length+13经过 int to char转化。接下来是一个标记7的字节。然后是index begin两个长度int to char.接下来是传输piece

int create_piece_msg(int index,int begin,char *block,int b_len,Peer *peer)
{
    int            i;
    unsigned char  c[4];
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    if( len < b_len+13 ) {  // piece消息的长度为b_len+13
        printf("IP:%s len:%d
",peer->ip,len);
        printf("%s:%d buffer too small
",__FILE__,__LINE__); 
        return -1;
    }
    
    int_to_char(b_len+9,c);
    for(i = 0; i < 4; i++)      buffer[i]    = c[i];
    buffer[4] = 7;
    int_to_char(index,c);
    for(i = 0; i < 4; i++)      buffer[i+5]  = c[i];
    int_to_char(begin,c);
    for(i = 0; i < 4; i++)      buffer[i+9]  = c[i];
    for(i = 0; i < b_len; i++)  buffer[i+13] = block[i];

    peer->msg_len += b_len+13;  
    return 0;
}

取消信息  用于取消对某个piece的请求 create_cancel_msg()

固定长度17

第4 5个字节 赋值 13 8. 后面12个字节分别是 index begin length的int to char 数组

int create_cancel_msg(int index,int begin,int length,Peer *peer)
{
    int            i;
    unsigned char  c[4];
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;
    
    if(len < 17)  return -1;  // 17为cancel消息的固定长度
    
    memset(buffer,0,17);
    buffer[3] = 13;
    buffer[4] = 8;
    int_to_char(index,c);
    for(i = 0; i < 4; i++)  buffer[i+5]  = c[i];
    int_to_char(begin,c);
    for(i = 0; i < 4; i++)  buffer[i+9]  = c[i];
    int_to_char(length,c);
    for(i = 0; i < 4; i++)  buffer[i+13] = c[i];

    peer->msg_len += 17;    
    return 0;
}

传递端口信息 固定7个字节 第四五字节 为3 9 第六七个字节为端口 int to char的 后两个字节

int create_port_msg(int port,Peer *peer)
{
    unsigned char  c[4];
    unsigned char  *buffer = peer->out_msg + peer->msg_len;
    int            len = MSG_SIZE - peer->msg_len;

    if( len < 7)  return 0;  // 7为port消息的固定长度

    memset(buffer,0,7);
    buffer[3] = 3;
    buffer[4] = 9;
    int_to_char(port,c);
    buffer[5] = c[2];
    buffer[6] = c[3];

    peer->msg_len += 7;
    return 0;
}

print_msg_buffer() 打印buffer内容

// 以十六进制的形式打印消息的内容,用于调试
int print_msg_buffer(unsigned char *buffer, int len)
{
    int i;

    for(i = 0; i < len; i++) {
        printf("%.2x ",buffer[i]);
        if( (i+1) % 16 == 0 )  printf("
");
    }
    printf("
");

    return 0;
}

is_complete_message()检测是否一条完整信息存放在BUF中

首先比对固定头信息的集中类型  比如握手 choke interested have request cancel port  然后检测 bitfield 和piece不定长协议。最后根据头文件信息指定的长度是否吻合判断 是否接收到未知定义还是未结束的消息

int is_complete_message(unsigned char *buff,unsigned int len,int *ok_len)
{
    unsigned int   i;
    char           btkeyword[20];

    unsigned char  keep_alive[4]   = { 0x0, 0x0, 0x0, 0x0 };
    unsigned char  chocke[5]       = { 0x0, 0x0, 0x0, 0x1, 0x0};
    unsigned char  unchocke[5]     = { 0x0, 0x0, 0x0, 0x1, 0x1};
    unsigned char  interested[5]   = { 0x0, 0x0, 0x0, 0x1, 0x2};
    unsigned char  uninterested[5] = { 0x0, 0x0, 0x0, 0x1, 0x3};
    unsigned char  have[5]         = { 0x0, 0x0, 0x0, 0x5, 0x4};
    unsigned char  request[5]      = { 0x0, 0x0, 0x0, 0xd, 0x6};
    unsigned char  cancel[5]       = { 0x0, 0x0, 0x0, 0xd, 0x8};
    unsigned char  port[5]         = { 0x0, 0x0, 0x0, 0x3, 0x9};
    
    if(buff==NULL || len<=0 || ok_len==NULL)  return -1;
    *ok_len = 0;
    
    btkeyword[0] = 19;
    memcpy(&btkeyword[1],"BitTorrent protocol",19);  // BitTorrent协议关键字

    unsigned char  c[4];
    unsigned int   length;
    
    for(i = 0; i < len; ) {
        // 握手、chocke、have等消息的长度是固定的
        if( i+68<=len && memcmp(&buff[i],btkeyword,20)==0 )         i += 68;
        else if( i+4 <=len && memcmp(&buff[i],keep_alive,4)==0 )    i += 4;
        else if( i+5 <=len && memcmp(&buff[i],chocke,5)==0 )        i += 5;
        else if( i+5 <=len && memcmp(&buff[i],unchocke,5)==0 )      i += 5;
        else if( i+5 <=len && memcmp(&buff[i],interested,5)==0 )    i += 5;
        else if( i+5 <=len && memcmp(&buff[i],uninterested,5)==0 )  i += 5;
        else if( i+9 <=len && memcmp(&buff[i],have,5)==0 )          i += 9;
        else if( i+17<=len && memcmp(&buff[i],request,5)==0 )       i += 17;
        else if( i+17<=len && memcmp(&buff[i],cancel,5)==0 )        i += 17;
        else if( i+7 <=len && memcmp(&buff[i],port,5)==0 )          i += 7;
        // bitfield消息的长度是变化的
        else if( i+5 <=len && buff[i+4]==5 )  {
            c[0] = buff[i];   c[1] = buff[i+1];
            c[2] = buff[i+2]; c[3] = buff[i+3];
            length = char_to_int(c);    
            // 消息长度占4字节,消息本身占length个字节
            if( i+4+length <= len )  i += 4+length;
            else { *ok_len = i; return -1; }
        }
        // piece消息的长度也是变化的
        else if( i+5 <=len && buff[i+4]==7 )  {
            c[0] = buff[i];   c[1] = buff[i+1];
            c[2] = buff[i+2]; c[3] = buff[i+3];
            length = char_to_int(c);
            // 消息长度占4字节,消息本身占length个字节
            if( i+4+length <= len )  i += 4+length;
            else { *ok_len = i; return -1; }
        }
        else {
            // 处理未知类型的消息
            if(i+4 <= len) {
                c[0] = buff[i];   c[1] = buff[i+1];
                c[2] = buff[i+2]; c[3] = buff[i+3];
                length = char_to_int(c);
                // 消息长度占4字节,消息本身占length个字节
                if(i+4+length <= len)  { i += 4+length; continue; }
                else { *ok_len = i; return -1; }
            }
            // 如果也不是未知消息类型,则认为目前接收的数据还不是一个完整的消息
            *ok_len = i;
            return -1;
        }
    }
    
    *ok_len = i;
    return 1;
}

 process_handshake_msg()处理握手信息

比对info_hash 判断是否需要处理还是丢弃  然后从initial进入到 handshaked状态

int process_handshake_msg(Peer *peer,unsigned char *buff,int len)
{
    if(peer==NULL || buff==NULL)  return -1;

    if(memcmp(info_hash,buff+28,20) != 0) { 
        peer->state = CLOSING;
        // 丢弃发送缓冲区中的数据
        discard_send_buffer(peer);
        clear_btcache_before_peer_close(peer);
        close(peer->socket);
        return -1;
    }
    
    memcpy(peer->id,buff+48,20);
    (peer->id)[20] = '';
    
    if(peer->state == INITIAL) {
        peer->state = HANDSHAKED;
        create_handshake_msg(info_hash,peer_id,peer);
    }
    if(peer->state == HALFSHAKED)  peer->state = HANDSHAKED;

    peer->start_timestamp = time(NULL);
    return 0;
}

 process_keep_alive_msg() 心跳处理 更新下peer的时间 不做其他处理

int process_keep_alive_msg(Peer *peer,unsigned char *buff,int len)
{
    if(peer==NULL || buff==NULL)  return -1;

    peer->start_timestamp = time(NULL);
    return 0;
}

process_choke_msg处理函数 如果peer未关闭且处于未堵塞状态 更改为堵塞  时间重新计数

int process_choke_msg(Peer *peer,unsigned char *buff,int len)
{
    if(peer==NULL || buff==NULL)  return -1;

    if( peer->state!=CLOSING && peer->peer_choking==0 ) {
        peer->peer_choking = 1;
        peer->last_down_timestamp = 0;
        peer->down_count          = 0;
        peer->down_rate           = 0;
    }

    peer->start_timestamp = time(NULL);
    return 0;
}

process_unchoke_msg 解开堵塞状态 创建interested的pieces

int process_unchoke_msg(Peer *peer,unsigned char *buff,int len)
{
    if(peer==NULL || buff==NULL)  return -1;

    if( peer->state!=CLOSING && peer->peer_choking==1 ) {
        peer->peer_choking = 0;
        if(peer->am_interested == 1)  create_req_slice_msg(peer);
        else {
            peer->am_interested = is_interested(&(peer->bitmap), bitmap);
            if(peer->am_interested == 1) create_req_slice_msg(peer);
            else printf("Received unchoke but Not interested to IP:%s 
",peer->ip);
        }

        peer->last_down_timestamp = 0;
        peer->down_count          = 0;
        peer->down_rate           = 0;
    }

    peer->start_timestamp = time(NULL);
    return 0;
}

process_interested_msg更新时间  根据位图更新感兴趣的状态 

int process_interested_msg(Peer *peer,unsigned char *buff,int len)
{
    if(peer==NULL || buff==NULL)  return -1;

    if( peer->state!=CLOSING && peer->state==DATA ) {
        peer->peer_interested = is_interested(bitmap, &(peer->bitmap));
        if(peer->peer_interested == 0)  return -1;
        if(peer->am_choking == 0) create_chock_interested_msg(1,peer);
    }

    peer->start_timestamp = time(NULL);
    return 0;
}

process_uninterested_msg 更新时间 从要求名单中删除peer相关的数据

int process_uninterested_msg(Peer *peer,unsigned char *buff,int len)
{
    if(peer==NULL || buff==NULL)  return -1;

    if( peer->state!=CLOSING && peer->state==DATA ) {
        peer->peer_interested = 0;
        cancel_requested_list(peer);
    }

    peer->start_timestamp = time(NULL);
    return 0;
}

process_have_msg 收到其他peer的have信息 更新该peermap 再次检测是否感兴趣。 无兴趣的点 也有1/3的概率进行回复

int process_have_msg(Peer *peer,unsigned char *buff,int len)
{
    int           rand_num;
    unsigned char c[4];

    if(peer==NULL || buff==NULL)  return -1;

    srand(time(NULL));
    rand_num = rand() % 3;

    if( peer->state!=CLOSING && peer->state==DATA ) {
        c[0] = buff[5]; c[1] = buff[6];
        c[2] = buff[7]; c[3] = buff[8];        
        if(peer->bitmap.bitfield != NULL)
            set_bit_value(&(peer->bitmap),char_to_int(c),1);

        if(peer->am_interested == 0) {
            peer->am_interested = is_interested(&(peer->bitmap), bitmap);
            // 由原来的对peer不感兴趣变为感兴趣时,发interested消息
            if(peer->am_interested == 1) create_chock_interested_msg(2,peer);    
        } else {  // 收到三个have则发一个interested消息
            if(rand_num == 0) create_chock_interested_msg(2,peer);
        }
    }

    peer->start_timestamp = time(NULL);
    return 0;
}

process_cancel_msg 放弃请求的处理

遍历记录链表 删除

int process_cancel_msg(Peer *peer,unsigned char *buff,int len)
{
    unsigned char c[4];
    int           index, begin, length;

    if(peer==NULL || buff==NULL)  return -1;
    
    c[0] = buff[5];  c[1] = buff[6];
    c[2] = buff[7];  c[3] = buff[8];
    index = char_to_int(c);
    c[0] = buff[9];  c[1] = buff[10];
    c[2] = buff[11]; c[3] = buff[12];
    begin = char_to_int(c);
    c[0] = buff[13]; c[1] = buff[14];
    c[2] = buff[15]; c[3] = buff[16];
    length = char_to_int(c);
    
    Request_piece *p, *q;
    p = q = peer->Requested_piece_head;
    while(p != NULL) { 
        if( p->index==index && p->begin==begin && p->length==length ) {
            if(p == peer->Requested_piece_head) 
                peer->Requested_piece_head = p->next;
            else
                q->next = p->next;
            free(p);
            break;
        }
        q = p;
        p = p->next;
    }    

    peer->start_timestamp = time(NULL);
    return 0;
}

后面的函数 基本都是函数名自解释 看看代码即可

参考

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

http://www.cnblogs.com/UnGeek/p/6052776.html

https://blog.csdn.net/str999_cn/article/details/78880189