BitTorrent协议分析六

最新推荐文章于 2021-04-11 17:13:55 发布
最新推荐文章于 2021-04-11 17:13:55 发布
阅读量651 收藏
点赞数 2
分类专栏： BitTorrent协议

ul int process_handshake_msg(Peer *peer,unsigned char *buff,int len)

功能：处理接收到的一条握手消息。

参数：从peer接收到这条握手消息；buff指向握手消息；len为buff的长度。函数实现的代码如下：

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) {  // 若info_hash不一致则关闭连接

          peer->state = CLOSING;

          // 丢弃发送缓冲区中的数据

          discard_send_buffer(peer);

          clear_btcache_before_peer_close(peer);

          close(peer->socket);

          return -1;

     }

     // 保存该peer的peer_id

     memcpy(peer->id,buff+48,20);

     (peer->id)[20] = '\0';

     // 若当前处于Initial状态，则发送握手消息给peer

     if(peer->state == INITIAL) {

          create_handshake_msg(info_hash,peer_id,peer);

          peer->state = HANDSHAKED;

     }

     // 若握手消息已发送，则状态转换为已握手状态

     if(peer->state == HALFSHAKED)  peer->state = HANDSHAKED;

     // 记录最近收到该peer消息的时间

// 若一定时间内(如两分钟)未收到来自该peer的任何消息，则关闭连接

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int process_keep_alive_msg(Peer *peer,unsigned char *buff,int len)

功能：处理刚刚接收到的来自peer的keepv_alive消息。函数实现的代码如下：

int process_keep_alive_msg(Peer *peer,unsigned char *buff,int len)

{

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

     // 记录最近收到该peer消息的时间

// 若一定时间内(如2min)未收到来自该peer的任何消息，则关闭连接

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int process_choke_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的choke消息。函数实现的代码如下：

int process_choke_msg(Peer *peer,unsigned char *buff,int len)

{

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

// 若原先处于unchoke状态，收到该消息后更新peer中某些变量的值

     if( peer->state!=CLOSING && peer->peer_choking==0 ) {

          peer->peer_choking = 1;

          peer->last_down_timestamp = 0;      // 将最近接收到来自该peer数据的时间清零

          peer->down_count = 0;      // 将最近从该peer处下载的字节数清零

          peer->down_rate = 0;       // 将最近从该peer下载数据的速度清零

     }

    

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int process_unchoke_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到unchoke消息。函数实现的代码如下：

int process_unchoke_msg(Peer *peer,unsigned char *buff,int len)

{

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

     // 若原来处于choke状态且与该peer的连接未被关闭

     if( peer->state!=CLOSING && peer->peer_choking==1 ) {

          peer->peer_choking = 0;

          // 若对该peer感兴趣，则构造request消息请求peer发送数据

          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 \n",peer->ip);

          }

          // 更新一些成员的值

          peer->last_down_timestamp = 0;

          peer->down_count = 0;

          peer->down_rate = 0;

     }

    

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int process_interested_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的interested消息。函数实现的代码如下：

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;

}

ul int process_uninterested_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的uninterested消息。函数实现的代码如下：

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;

}

ul int process_have_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的have消息。函数实现的代码如下：

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;  // 生成一个0～2的随机数

     if( peer->state!=CLOSING && peer->state==DATA ) {

          c[0] = buff[5]; c[1] = buff[6];

          c[2] = buff[7]; c[3] = buff[8];    

          // 更新该peer的位图

          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 {  // 收到3个have则发一个interested消息

               if(rand_num == 0) create_chock_interested_msg(2,peer);

          }

     }

    

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int process_cancel_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的cancel消息。函数实现的代码如下：

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;

}

ul int process_bitfield_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的位图消息。函数实现的代码如下：

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;

          if(bitmap->bitfield_length != char_to_int(c)-1) {  // 若收到的一个错误位图

               peer->state = CLOSING;

               // 丢弃发送缓冲区中的数据

               discard_send_buffer(peer);

               clear_btcache_before_peer_close(peer);

               close(peer->socket);

               return -1;

          }

          // 生成该peer的位图

          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);

         

          // 如果原状态为已握手,收到位图后应该向peer发位图

          if(peer->state == HANDSHAKED) {

               create_bitfield_msg(bitmap->bitfield,bitmap->bitfield_length,peer);

               peer->state = DATA;

          }

          // 如果原状态为已发送位图，收到位图后可以进入DATA状态准备交换数据

          if(peer->state == SENDBITFIELD) {

               peer->state = DATA;

          }

          // 根据位图判断peer是否对本客户端感兴趣

          peer->peer_interested = is_interested(bitmap,&(peer->bitmap));

          // 判断对peer是否感兴趣,若是则发送interested消息

          peer->am_interested = is_interested(&(peer->bitmap), bitmap);

          if(peer->am_interested == 1) create_chock_interested_msg(2,peer);

     }

    

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int process_request_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的request消息。函数实现代码如下：

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) {

          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);

         

          // 查看该请求是否已存在,若已存在,则不进行处理

          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 )

               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;

}

ul int process_piece_msg(Peer *peer,unsigned char *buff,int len)

功能：处理收到的piece消息。函数实现代码如下：

int process_piece_msg(Peer *peer,unsigned char *buff,int len)

{

     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;

          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);

          // 判断收到的slice是否是请求过的

          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;}

          // 开始记时，并累计收到数据的字节数

          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);

          // 生成请求数据的消息，要求继续发送数据

          create_req_slice_msg(peer);

     }

    

     peer->start_timestamp = time(NULL);

     return 0;

}

ul int parse_response(Peer *peer)

功能：处理收到的消息（peer的接收缓冲区中可能存放着多条消息）。函数实现代码如下：

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为接收缓冲区

     int            len = peer->buff_len;  // 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);

               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;

          }

          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];

               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消息的长度

          }

          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;

          }

          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;

          }

     } // for语句结束

    

     // 接收缓冲区中的消息处理完毕后,清空接收缓冲区

     peer->buff_len = 0;

     return 0;

}

ul int parse_response_uncomplete_msg(Peer *p,int ok_len)

功能：处理收到的消息。

参数：ok_len为接收缓冲区中完整消息的长度。函数实现代码如下：

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;

}

ul int prepare_send_have_msg()

说明：当下载完一个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;

    

     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;

          }

          p = p->next;

     }

     for(i = 0; i < 64; i++) {

          if(have_piece_index[i] == -1)  break;

          else  have_piece_index[i] = -1;

     }

    

     return 0;

}

ul int create_response_message(Peer *peer)

功能：主动创建发送给peer的消息,而不是等收到某个消息后再创建响应消息。函数实现的代码如下：

int create_response_message(Peer *peer)

{

     if(peer==NULL)  return -1;

     if(peer->state == INITIAL) {  // 处于Intial状态时主动发握手消息

          create_handshake_msg(info_hash,peer_id,peer);

          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;

     }

// 如果条件允许(未将该peer阻塞，且peer发送过请求)，则主动发送piece消息

     if( peer->am_choking==0 && peer->Requested_piece_head!=NULL ) {

          Request_piece *req_p = peer->Requested_piece_head;

          int ret = read_slice_for_send(req_p->index,req_p->begin,req_p->length,peer);

          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;

     if( interval1 > 180 ) {

          peer->state = CLOSING;

          // 丢弃发送缓冲区中的数据

          discard_send_buffer(peer);

          // 将从该peer处下载到的不足一个piece的数据删除

          clear_btcache_before_peer_close(peer);

          close(peer->socket);

     }

     // 如果45秒没有发送和接收到消息,则发送一个keep_alive消息

     long interval2 = now - peer->recet_timestamp;

     if( interval1>45 && interval2>45 && peer->msg_len==0)

          create_keep_alive_msg(peer);

    

     return 0;

}

ul void discard_send_buffer(Peer *peer)

功能：即将与peer断开时,丢弃发送缓冲区中的消息。函数实现的代码如下：

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);

     }

}

li6322511
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
哈工大计算机网络Week2-网络应用数据交换
gao2628688的博客
09-17 1083
目录 网络应用数据交换 P2P应用：原理与文件分发 纯P2P架构 文件分发：客户机/服务器 vs. P2P CS 为什么是这样的？不应该传送和发出难道是并行的？？？ P2P P2P文件分发典型例子：BitTorrent（bit激流） 思考题 P2P应用：索引技术 P2P: 搜索信息 集中式索引 全分布非结构：洪泛式查询（Query flooding） 如何查询？ 层次式覆盖网络 ...
BitTorrent 原理简介
longjef的博客
05-13 2490
引言 之前我这边在生产环境中使用 Murder 软件的 BT 上传下载的方式来实现大文件的快速分发。 这属于 BT 软件的应用。最近重新看了下 BT 协议的分析与实现，现在重新了解下 BT 协议原理。 BitTorrent 原理简述 与传统客户端/服务器网络通信模式不同，对等方到对等方（P2P）通信模式在近年来越来越流行起来。 在 P2P 模式中，服务和资源分布化，资源不集中存储在某些设备上，而是分散存储在运行 P2P 程序的设备上， 每一个对等方都可以为其他对等方提供服务。 BitTorrent（
BT种子的技术原理是什么？就是.torrent文件该如何理解？
dianliang01的博客
06-12 2万+
看到很多咨询BT种子原理的问题，在这里整理些资料，希望对需要的朋友有帮助。可以分两个层面来分析一下：  1、torrent文件的原理：如果这个问题是指torrent文件本身，那么，当你对一个文件（或者文件夹）制作成.torrent文件，实际上生成的.torrent文件里面主要包括了这些信息：  A）这个文件（文件夹）中数据的SHA1值，比如一个1G的文件，如果按1M每块进行分块，则会被分为了100...
P2P网络与BitTorrent技术简介
跨链技术践行者
04-17 9980
P2P网络 点对点（P2P）计算或网络是分布式应用程序体系结构，用于在对等体之间分割任务或工作负载。 其中互联节点（“对等”）彼此共享资源而不使用集中式管理系统. P2P网络的分散性提高了鲁棒性，因为它消除了基于客户端 - 服务器系统固有的单点故障。[36]作为节点到达和对系统的需求的增加，系统的总容量也增加，发生故障的可能性减小。如果网络上的一个对等设备无法正常工作，则整个网络不会受到影响或...
BitTorrent Tracker 搭建及使用
threeboss的博客
05-10 5586
BitTorrent Tracker 搭建及使用(Linux)安装xbt-Tracker安装相应的库下载源码安装安装MySqlxbt-tracker配置服务启停(Linux)安装BitTorrent客户端Transmissionyum repo下载安装transmission-deamon服务启停Transmission配置制作种子并发布transmission-create制作种子添加种子发布种...
BitTorrent 协议分析与实现
05-07
摘 要:本文具体分析 BitTorrent 协议与 Trackerless DHT 协议,运用 CommView 抓包工具 研究基于 HTTP 的 Tracker 协议,基于 UDP 的 Trackerless 协议,基于 TCP 的 Peer wire 协 议交互的具体内容。使用标准 C 语言...
BT_Test_BT协议分析_
10-02
总结，BitTorrent协议分析涉及理解其核心概念，如info hash、追踪器、对等体网络以及块管理和验证。"BT_Test.py"这样的脚本为我们提供了一个窗口，通过它可以深入了解和操控这个复杂的P2P文件分享系统。
论文研究-一种针对BitTorrent协议中have消息的隐写分析方法.pdf
07-22
BitTorrent协议的巨大流量使其成为一种极佳的隐写载体，基于BitTorrent协议have消息的隐写即在此背景下提出，目前公开文献尚无有效的检测算法。基于此，提出了一种基于多特征分类的检测方法。该方法首先提取正常have...
BitTorrent:C 语言中的 BitTorrent 协议
07-04
BitTorrent 是一种流行的点对点（P2P）文件共享协议，它允许用户高效地分发大型文件，如高清视频、软件更新或大型游戏。在 C 语言中实现 BitTorrent 协议涉及到对协议规范的理解以及对网络编程的扎实基础。下面我们...
对BitTorrent通信协议的分析与检测.doc
09-16
BitTorrent（BT）通信协议是一种对等方到对等方（P2P）技术，它在互联网上广泛用于文件共享，尤其是大文件如电影、软件和音乐的高速下载。与传统的客户机/服务器（C/S）模式不同，P2P模式允许用户之间直接交换数据，...
qbittorren下载某雷无法下载东东的神器（包含最近最全30余个插件）
01-17
Qbittorrent是一个跨Linux, Mac OS X, Windows, OS/2, FreeBSD平台的BT下载软件，，因而其界面和许多功能和Ut很像。相较其它优秀BT客户端比Vuze轻巧，比Deluge美观，比Transmission多很多功能，用过都说好。
BitTorrent 简介
riba2534的博客
04-11 7725
BitTorrent 简介 从 P2P 说起 经常在网上飙车的老司机应该都知道 BT 下载，但是有时候拿到了种子却下载不动，会不会很抓狂，是不是还觉得是自己网不行，那作为一个合格的老司机，我们需要探究一下下载不动的原因是什么，BT的运作方式是怎样的，如果你也有这样的疑惑，那么，系好安全带，我们一起来了解一下什么是 BT。 2001年4月，程序员布莱姆·科恩设计了一种协议，然后在2001年7月2日，他发布了 BitTorrent 客户端的第一个实现。 BT(BitTorrent)是 P2P 的一种实现，P2
BitTorrent协议详解
一叶舟轻
11-16 5905
BitTorrent协议详解 这个翻译版本由孤波独立完成原文见http://bitconjurer.org/BitTorrent/protocol.html作者Bram Cohen孤波享有对该翻译版本解释权修改权非商业引用请注明译者目前处在Beta测试中，很不完善，请不要转贴或引用希望高人提出建议和指出错误错误不断完善尤其请注意后面几段，我都不知道自己翻译的什么我将在尽量3天内发出正式版本。B
BitTorrent协议分析二
li6322511的专栏
01-08 1939
接一 客户端与一个peer建立TCP连接后，首先向peer发送握手消息，peer收到握手消息后回应一个握手消息。 l     握手消息是一个长度固定为68字节的消息。消息的格式如下： 消息格式中一些参数的含义如表13-9所示。 表13-9                                                               握手
bt协议分析
程序狗的成长之路
04-08 7834
BitTorrent协议特征分析 1、概述 BitTorrent（简称BT）是一种文件分发协议，属于P2P协议。它通过URL识别内容并且和网络无缝结合。它在HTTP平台上的优势在于，同时下在一个文件的下载者在下载的同时不断互相上传数据，使文件源可以在很有限的负载增加的情况下支持大量下载者同时下载。 一 BT系统的组成结构   1 普通的Web服务器：   例如Apache
BT原理分析
热门推荐
it_man的专栏
07-13 3万+
BitTorrent协议。BT全名为BitTorrent,是一个p2p软件,你在下载download的同时，也在为其他用户提供上传upload，因为大家是“互相帮助”，所以不会随着用户数的增加而降低下载速度。 下面是一般用ftp，http等分享流程：下面是用BitTorrent分
BitTorrent协议概述
echoaiya的专栏
05-21 1316
本文转自  http://www.doc88.com/p-691270196531.html 1. BT网络架构 BT网络由以下几部分组成：.torrent文件、种子提供站点、目录服务器和内容发布者/下载者。 （1）.torrent文件（又称种子文件）是一个文本文件，包含了tracker信息和文件信息两部分。Tracker信息主要是BT下载中需要用到的tracker服务器的地址和
BitTorrent协议分析四
li6322511的专栏
01-08 696
4.2  位图管理模块的设计和实现 对位图的操作主要在bitfield.h和bitfield.c中，负责创建位图，设置和获取位图某一位的值，保存位图等。 bitfield.h #ifndef BITFIELD_H #define BITFIELD_H   typedef struct _Bitmap {      unsigned char  *bitfi
用C语言开发一个BT下载软件 （四） ------ 代码实现-5-Peer管理模块
str999_cn的专栏
01-04 1189
系统为每一个与之建立TCP连接的Peer构造一个Peer结构体。Peer管理模块负责管理由各个Peer节点构成的Peer链表，主要工作是创建节点，添加节点到Peer链表，从Peer链表中删除节点等。 //peer.h #ifndef PEER_H #define PEER_H #include #include #include "bitfield.h" #define IN
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值