#include <stdio.h>#include <string.h>#include <malloc.h>#include <unistd.h>#include <stdlib.h>#include <time.h>#include <string.h>#include <sys/socket.h>#include "parse_metafile.h"#include "bitfield.h"#include "peer.h"#include "data.h"#include "policy.h"#include "message.h"#define HANDSHAKE -2#define KEEP_ALIVE -1#define CHOKE 0#define UNCHOKE 1#define INTERESTED 2#define UNINTERESTED 3#define HAVE 4#define BITFIELD 5#define REQUEST 6#define PIECE 7#define CANCEL 8#define PORT 9#define KEEP_ALIVE_TIME 45extern Bitmap *bitmap;extern char info_hash[20];extern char peer_id[20];extern int have_piece_index[64];extern Peer *peer_head;int int_to_char(int i, unsigned char c[4])//我们认为一个整形i如果转换为字符的话，其最低位应该放在c[0],但是从现在的角度看，放在c[3],所以说采用的是大端顺序{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 char_to_int(unsigned char c[4]){int i;i = c[0]*256*256*256 + c[1]*256*256 + c[2]*256 + c[3];//c[0]放的是最高位return i;}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; //创建握手信号，并将其放入out_msg缓冲区中，但是在此之前，缓冲区中可能已经存有数据，这样只有放在其后。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];//为种子文件的关键字info所对应的hash值，其算法描述在hash.c中for(i = 0; i < 20; i++) buffer[i+48] = peer_id[i];peer->msg_len += 68;return 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;}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; //type取不同的四个值，便对应上面所述的四种消息，这里的数据存储的格式为大端顺序peer->msg_len += 5;return 0;}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;}int create_bitfield_msg(char *bitfield,int bitfield_len,Peer *peer)//即使这样，我们可以看出，bitfield的消息长度是不固定的，前四个字节表示长度{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+5printf("%s:%d buffer too small\n",__FILE__,__LINE__); return -1;}int_to_char(bitfield_len+1,c);//将长度之和转换为前四个字节的前缀for(i = 0; i < 4; i++) buffer[i] = c[i];//前四个字节为前缀，指明了id以及负载的长度之和。buffer[4] = 5; //这里解释了为何为bitfield+5for(i = 0; i < bitfield_len; i++) buffer[i+5] = bitfield[i];peer->msg_len += bitfield_len+5; return 0;}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);//固定长度为17字节，但是去除前缀的4个字节，所以id以及负载的长度之和为13个字节。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;}int create_piece_msg(int index,int begin,char *block,int b_len,Peer *peer)//block为消息的内容，b_len为消息的长度。在缓冲区传值的过程中，分别传node->buff,node->length{int i;unsigned char c[4];unsigned char *buffer = peer->out_msg + peer->msg_len;int len = MSG_SIZE - peer->msg_len;//用来查看peer是否有足够的空间来存储一个piece消息if( len < b_len+13 ) { // piece消息的长度为b_len+13printf("IP:%s len:%d\n",peer->ip,len);printf("%s:%d buffer too small\n",__FILE__,__LINE__); return -1;}int_to_char(b_len+9,c); //这里的是block的长度+id+index+begin，后面三个的值为9for(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;}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;//这就是cancel消息的消息结构，前四个字节为前缀，在这里设为13.后面的8为idbuffer[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;}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);//port占有两个字节c[2]为高位buffer[5] = c[2];buffer[6] = c[3];peer->msg_len += 7;return 0;}// 以十六进制的形式打印消息的内容,用于调试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("\n"); //buffer此时放置有各种各样的消息，各种消息存放在一起，要如何区分呢?}printf("\n");return 0;}// 判断缓冲区中是否存放了一条完整的消息int is_complete_message(unsigned char *buff,unsigned int len,int *ok_len){unsigned int i;char btkeyword[20]; //位图消息以及piece消息的长度是不顾定的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; ) { //这个函数用于比较各种各样的消息类型，i的值也随着发生变化// 握手、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;//这个函数的另一个目的就是移动i，来做终极判断// 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; //这样也就算出了i需要移动的位数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; }}//此处for循环结束*ok_len = i;//用于返回完整消息的长度，当然这个消息的长度可能是包含了多条消息，return 1; // 可以用返回值来判断是否为完整的消息呢？现在的理解是当i==len时，则为完整的消息，返回为1.}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本身的info与buff中的info不同的时候的情况peer->state = CLOSING;// 丢弃发送缓冲区中的数据discard_send_buffer(peer);clear_btcache_before_peer_close(peer);close(peer->socket);return -1;}memcpy(peer->id,buff+48,20);//两者info相同的时候，将握手消息的peer_id进行拷贝(peer->id)[20] = '\0';if(peer->state == INITIAL) {//根据peer的不同的状态，来采取不同的操作，如果为初始状态，发送消息之后，则变为握手状态。peer->state = HANDSHAKED;create_handshake_msg(info_hash,peer_id,peer);//创建消息，并将消息放入out_msg所代表的缓存中 } if(peer->state == HALFSHAKED) peer->state = HANDSHAKED;//如果本身就是半握手状态，则将状态直接变为peer的状态变为握手状态peer->start_timestamp = time(NULL);return 0;}int process_keep_alive_msg(Peer *peer,unsigned char *buff,int len) //其实这里的len便是消息的长度{if(peer==NULL || buff==NULL) return -1;peer->start_timestamp = time(NULL); //为了得到当前的日历时间return 0;}/*函数原型: time_t time(time_t *timer) 函数功能: 得到机器的日历时间或者设置日历时间 函数返回: 机器日历时间 参数说明: timer=NULL时得到机器日历时间，timer=时间数值时，用于设置日历时间，time_t是一个long类型 */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->peer_choking = 1; //这里并没有用到buff的内容，只是调用这个函数的时候将peer的相关参数进行设置。peer->last_down_timestamp = 0;peer->down_count = 0;peer->down_rate = 0;}peer->start_timestamp = time(NULL);//得到当前的日历时间return 0;}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 ) {//在处理unchoke消息的时候，如果peer的状态为closed，并且peer_choking阻塞，才进行处理peer->peer_choking = 0;if(peer->am_interested == 1) create_req_slice_msg(peer);//构造request消息，请求peer发送数据！！！ // 构造数据请求,为了提高效率一次请求5个slice //int create_req_slice_msg(Peer *node); 这个函数定义于policy（策略）部分，创建请求slice消息else { peer->am_interested = is_interested(&(peer->bitmap), bitmap);//这个函数定义与bitfield位图模块if(peer->am_interested == 1) create_req_slice_msg(peer);else printf("Received unchoke but Not interested to IP:%s \n",peer->ip);}peer->last_down_timestamp = 0;peer->down_count = 0;peer->down_rate = 0;}peer->start_timestamp = time(NULL);//得到当前日历时间return 0;}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状态，为DATA状态 peer->peer_interested = is_interested(bitmap, &(peer->bitmap));//说的是别人对我感兴趣，也就是将peer_interested置1if(peer->peer_interested == 0) return -1; if(peer->am_choking == 0) create_chock_interested_msg(1,peer);//此时如果本身并没有阻塞，那么创建消息进行发送，这个函数也没有遇到过，之前}peer->start_timestamp = time(NULL);return 0;}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;}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];//因为这是处理have消息，所以这四个值代表的是piece的indexif(peer->bitmap.bitfield != NULL) set_bit_value(&(peer->bitmap),char_to_int(c),1);//这个时候对下标所代表的piece进行重新设值if(peer->am_interested == 0) { peer->am_interested = is_interested(&(peer->bitmap), bitmap);//这里的bitmap为在bitfield中定义的变量// 由原来的对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;}int process_cancel_msg(Peer *peer,unsigned char *buff,int len)//取消对某个slice的数据请求{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); //cancel的信号格式，分别是下标，偏移，长度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;//为结构体，在message.h中定义，为下标，起始或者偏移，长度p = q = peer->Requested_piece_head;//这里是被请求的队列，如果是request_piece_head为向peer请求的队列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;elseq->next = p->next;free(p);break;}q = p;p = p->next;//只要有一个条件不满足，则将p向后移动。}peer->start_timestamp = time(NULL);return 0;}int process_bitfield_msg(Peer *peer,unsigned char *buff,int len){unsigned char c[4];if(peer==NULL || buff==NULL) return -1;if(peer->state==HANDSHAKED || peer->state==SENDBITFIELD) {c[0] = buff[0]; c[1] = buff[1];c[2] = buff[2]; c[3] = buff[3];if( peer->bitmap.bitfield != NULL ) {//若原先收到一个位图消息，则清空原来的位图free(peer->bitmap.bitfield);peer->bitmap.bitfield = NULL;}peer->bitmap.valid_length = bitmap->valid_length;//一个为peer的位图的有效长度，另一个bitmap则为bitfield中定义的全局变量if(bitmap->bitfield_length != char_to_int(c)-1) {//这里减一，是因为其长度值包含了一个字节的id信息peer->state = CLOSING;// 丢弃发送缓冲区中的数据discard_send_buffer(peer);//如果收到一个错误的位图，则做相应的处理工作clear_btcache_before_peer_close(peer);close(peer->socket);return -1;}peer->bitmap.bitfield_length = char_to_int(c) - 1;peer->bitmap.bitfield = (unsigned char *)malloc(peer->bitmap.bitfield_length);memcpy(peer->bitmap.bitfield,&buff[5],peer->bitmap.bitfield_length);//将buffer中的位图信息拷贝到peer的位图当中// 如果原状态为已握手,收到位图后应该向peer发位图if(peer->state == HANDSHAKED) {create_bitfield_msg(bitmap->bitfield,bitmap->bitfield_length,peer);peer->state = DATA;}// 如果原状态为已发送位图，收到位图后可以准备交换数据if(peer->state == SENDBITFIELD) {peer->state = DATA;}// 判断peer是否对我们感兴趣peer->peer_interested = is_interested(bitmap,&(peer->bitmap));//这里的bitmap代表我们，说的是我们是否对peer的bitmap感兴趣// 判断对peer是否感兴趣,若是则发送interested消息peer->am_interested = is_interested(&(peer->bitmap), bitmap);//说的是peer是否对我们的bitmap感兴趣。if(peer->am_interested == 1) create_chock_interested_msg(2,peer);//如果对我们的bitmap感兴趣，则发送感兴趣的消息}peer->start_timestamp = time(NULL);//记录最近的日历时间return 0;}int process_request_msg(Peer *peer,unsigned char *buff,int len){unsigned char c[4];int index, begin, length;Request_piece *request_piece, *p;if(peer==NULL || buff==NULL) return -1;if(peer->am_choking==0 && peer->peer_interested==1) {//这些都是对peer来说的，am_choking表明客户端可以从中下载数据，并且客户端对其感兴趣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);// 错误的slice请求if( begin%(16*1024) != 0 ) {//因为每个slice的大小为16k，所以说begin的值一定为16k的倍数return 0;}// 查看该请求是否已存在,若已存在,则不进行处理p = peer->Requested_piece_head;while(p != NULL) {if(p->index==index && p->begin==begin && p->length==length) {break;}p = p->next;}if(p != NULL) return 0;// 将请求加入到请求队列中request_piece = (Request_piece *)malloc(sizeof(Request_piece));if(request_piece == NULL) { printf("%s:%d error",__FILE__,__LINE__); //对于分配的内存一定要判断是否分配成功return 0; }request_piece->index = index;request_piece->begin = begin;request_piece->length = length;request_piece->next = NULL;if( peer->Requested_piece_head == NULL ) //将生成的Request_piece*指针，加入到链表当中。peer->Requested_piece_head = request_piece;else {p = peer->Requested_piece_head;while(p->next != NULL) p = p->next;p->next = request_piece;}//printf("*** add a request FROM IP:%s index:%-6d begin:%-6x ***\n",// peer->ip,index,begin);}peer->start_timestamp = time(NULL);return 0;}int process_piece_msg(Peer *peer,unsigned char *buff,int len)//如果客户端收到peer的Request消息，并且没有将该peer阻塞，则将其请求的数据通过piece消息发送过去{unsigned char c[4];int index, begin, length;Request_piece *p;if(peer==NULL || buff==NULL) return -1;if(peer->peer_choking==0) {c[0] = buff[0]; c[1] = buff[1];c[2] = buff[2]; c[3] = buff[3];length = char_to_int(c) - 9; //求出请求的block的长度，一般情况下，为16kc[0] = buff[5]; c[1] = buff[6];c[2] = buff[7]; c[3] = buff[8];index = char_to_int(c);//确定出为某个piecec[0] = buff[9]; c[1] = buff[10];c[2] = buff[11]; c[3] = buff[12];begin = char_to_int(c);//确定其偏移量p = peer->Request_piece_head;while(p != NULL) {if(p->index==index && p->begin==begin && p->length==length)break;p = p->next;}if(p == NULL) {printf("did not found matched request\n"); return -1;}//根据收到的Request消息，来发送piece消息，如果请求队列中根本就没有 //则没有办法处理if(peer->last_down_timestamp == 0) peer->last_down_timestamp = time(NULL);//最近一次下载的时间peer->down_count += length;peer->down_total += length;write_slice_to_btcache(index,begin,length,buff+13,length,peer);//这些process函数，全部为收到某个消息的反映，发送消息便是将消息写入缓存区create_req_slice_msg(peer);}peer->start_timestamp = time(NULL);return 0;}int parse_response(Peer *peer)//消息解析协议，对收到的消息进行确认和处理{unsigned char btkeyword[20];unsigned char keep_alive[4] = { 0x0, 0x0, 0x0, 0x0 };int index;unsigned char *buff = peer->in_buff;//in_buff存放的都是从peer处获得的消息int len = peer->buff_len;if(buff==NULL || peer==NULL) return -1;btkeyword[0] = 19;memcpy(&btkeyword[1],"BitTorrent protocol",19); // BitTorrent协议关键字// 分别处理12种消息for(index = 0; index < len; ) { if( (len-index >= 68) && (memcmp(&buff[index],btkeyword,20) == 0) ) {//用于判断多种消息类型，以便处理process_handshake_msg(peer,buff+index,68);index += 68;} else if( (len-index >= 4) && (memcmp(&buff[index],keep_alive,4) == 0)){ process_keep_alive_msg(peer,buff+index,4); //判断是否为保活消息index += 4; }else if( (len-index >= 5) && (buff[index+4] == CHOKE) ) { process_choke_msg(peer,buff+index,5); //判断是否为阻塞消息index += 5;}else if( (len-index >= 5) && (buff[index+4] == UNCHOKE) ) { process_unchoke_msg(peer,buff+index,5); //判断是否为接触阻塞消息index += 5;}else if( (len-index >= 5) && (buff[index+4] == INTERESTED) ) { process_interested_msg(peer,buff+index,5);//判断是否为感兴趣消息index += 5;}else if( (len-index >= 5) && (buff[index+4] == UNINTERESTED) ) { process_uninterested_msg(peer,buff+index,5);//判断是否为不感兴趣消息index += 5;}else if( (len-index >= 9) && (buff[index+4] == HAVE) ) { process_have_msg(peer,buff+index,9); //判断是否为have消息index += 9;}else if( (len-index >= 5) && (buff[index+4] == BITFIELD) ) { process_bitfield_msg(peer,buff+index,peer->bitmap.bitfield_length+5);//判断是否为位图消息 index += peer->bitmap.bitfield_length + 5;//这里之所以不用采用piece消息的处理方式，则bitmap的长度可以从bitfield_length获得}else if( (len-index >= 17) && (buff[index+4] == REQUEST) ) { process_request_msg(peer,buff+index,17); //判断是否为请求消息index += 17;}else if( (len-index >= 13) && (buff[index+4] == PIECE) ) { unsigned char c[4]; //判断是否为piece消息int length;c[0] = buff[index]; c[1] = buff[index+1];c[2] = buff[index+2]; c[3] = buff[index+3];length = char_to_int(c) - 9;process_piece_msg(peer,buff+index,length+13);index += length + 13; // length+13为piece消息的长度，这也全部算在buff的缓冲区内}else if( (len-index >= 17) && (buff[index+4] == CANCEL) ) {process_cancel_msg(peer,buff+index,17);index += 17;}else if( (len-index >= 7) && (buff[index+4] == PORT) ) { index += 7; //处理的是PORT消息}else {// 如果是未知的消息类型,则跳过不予处理unsigned char c[4];int length;if(index+4 <= len) {c[0] = buff[index]; c[1] = buff[index+1];c[2] = buff[index+2]; c[3] = buff[index+3];length = char_to_int(c);if(index+4+length <= len) { index += 4+length; continue; }//未知消息类型}// 如果是一条错误的消息,清空接收缓冲区，如果连未知的类型都算不上，那么就是一条错误的消息peer->buff_len = 0;return -1;}} // end for// 接收缓冲区中的消息处理完毕后,清空接收缓冲区peer->buff_len = 0;return 0;}int parse_response_uncomplete_msg(Peer *p,int ok_len){char *tmp_buff;int tmp_buff_len;// 分配存储空间,并保存接收缓冲区中不完整的消息tmp_buff_len = p->buff_len - ok_len;if(tmp_buff_len <= 0) return -1;tmp_buff = (char *)malloc(tmp_buff_len);if(tmp_buff == NULL) { printf("%s:%d error\n",__FILE__,__LINE__);//还是用来检查内存是否分配成功。return -1;}memcpy(tmp_buff,p->in_buff+ok_len,tmp_buff_len);// 处理接收缓冲区中前面完整的消息p->buff_len = ok_len;parse_response(p); //这个时候已经将完整的消息处理完毕了// 将不完整的消息拷贝到接收缓冲区的开始处memcpy(p->in_buff,tmp_buff,tmp_buff_len);p->buff_len = tmp_buff_len;if(tmp_buff != NULL) free(tmp_buff);return 0;}// 当下载完一个piece时,应该向所有的peer发送have消息int prepare_send_have_msg(){Peer *p = peer_head;int i;if(peer_head == NULL) return -1;if(have_piece_index[0] == -1) return -1;//关于have_piece_index的数组，之前没有遇到过，并且这里为何要去64呢？！while(p != NULL) {for(i = 0; i < 64; i++) {if(have_piece_index[i] != -1) {create_have_msg(have_piece_index[i],p);}else {break;}}//for循环结束p = p->next;}//while循环结束for(i = 0; i < 64; i++) { if(have_piece_index[i] == -1) {//将have_piece_index的元素全部置为-1break;}else {have_piece_index[i] = -1;}}return 0;}// 主动创建发送给peer的消息,而不是等收到某个消息再作出响应int create_response_message(Peer *peer){if(peer==NULL) return -1;if(peer->state == INITIAL) { create_handshake_msg(info_hash,peer_id,peer);//如果peer处于INITAL状态则发送握手消息peer->state = HALFSHAKED;return 0;}if(peer->state == HANDSHAKED) {if(bitmap == NULL) return -1;create_bitfield_msg(bitmap->bitfield,bitmap->bitfield_length,peer);peer->state = SENDBITFIELD; //如果处于握手状态，则发送位图消息return 0;}// 发送piece消息,即发送下载文件的内容if( peer->am_choking==0 && peer->Requested_piece_head!=NULL ) { Request_piece *req_p = peer->Requested_piece_head; //如果被请求的队列不为空，也就是有peer想从这里下载数据 /*如果请求队列中的数据，在btcache中找不到，那么就从硬盘上下载，如果在最开始的时候的bitfield都没有，说明根本没有这个数据*/int ret = read_slice_for_send(req_p->index,req_p->begin,req_p->length,peer);//在data.c文件中，但是肯定是将请求的数据以piece消息发送出去if(ret < 0 ) { printf("read_slice_for_send ERROR\n");}else {if(peer->last_up_timestamp == 0) peer->last_up_timestamp = time(NULL);peer->up_count += req_p->length;peer->up_total += req_p->length;peer->Requested_piece_head = req_p->next;//printf("********* sending a slice TO:%s index:%-5d begin:%-5x *********\n",//peer->ip,req_p->index,req_p->begin);free(req_p);return 0;}}// 如果3分钟没有收到任何消息关闭连接time_t now = time(NULL); // 获取当前时间long interval1 = now - peer->start_timestamp; //为最近一次接受到peer消息的时间，如果很长的时间没有收到peer的任何消息，那么认为链接中断if( interval1 > 180 ) {peer->state = CLOSING;discard_send_buffer(peer); // 丢弃发送缓冲区中的数据clear_btcache_before_peer_close(peer);close(peer->socket);}// 如果45秒没有发送和接收消息,则发送一个keep_alive消息long interval2 = now - peer->recet_timestamp; //最近一次给peer发送消息的时间。if( interval1>45 && interval2>45 && peer->msg_len==0)create_keep_alive_msg(peer);return 0;}void discard_send_buffer(Peer *peer)//从字面意思理解为将发送缓存丢弃{struct linger lin;int lin_len;lin.l_onoff = 1;lin.l_linger = 0;lin_len = sizeof(lin);if(peer->socket > 0) {setsockopt(peer->socket,SOL_SOCKET,SO_LINGER,(char *)&lin,lin_len);}}
