bittorrent 学习(二) LOG日志和peer管理连接

代码中的log.h log.c比较简单

void logcmd() 记录命令 int logfile();运行日志的记录

int init_logfile() 开启log文件

源码比较清晰也很简单。可以直接看代码

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

peer代码中我们先来看看结构体

 typedef struct _Request_piece {

     int     index;                // 请求的piece的索引     也是bitmap中的index？？

     int     begin;                // 请求的piece的偏移

     int     length;               // 请求的长度,一般为16KB

     struct _Request_piece *next;

 } Request_piece;

 typedef struct  _Peer {

     int            socket;                // 通过该socket与peer进行通信

     char           ip[];                // peer的ip地址

     unsigned short port;                  // peer的端口号

     char           id[];                // peer的id

     int            state;                 // 当前所处的状态

     int            am_choking;            // 是否将peer阻塞

     int            am_interested;         // 是否对peer感兴趣

     int            peer_choking;          // 是否被peer阻塞

     int            peer_interested;       // 是否被peer感兴趣

     Bitmap         bitmap;                // 存放peer的位图

     char           *in_buff;              // 存放从peer处获取的消息

     int            buff_len;              // 缓存区in_buff的长度

     char           *out_msg;              // 存放将发送给peer的消息

     int            msg_len;               // 缓冲区out_msg的长度

     char           *out_msg_copy;         // out_msg的副本,发送时使用该缓冲区

     int            msg_copy_len;          // 缓冲区out_msg_copy的长度

     int            msg_copy_index;        // 下一次要发送的数据的偏移量

     Request_piece  *Request_piece_head;   // 向peer请求数据的队列

     Request_piece  *Requested_piece_head; // 被peer请求数据的队列

     unsigned int   down_total;            // 从该peer下载的数据的总和

     unsigned int   up_total;              // 向该peer上传的数据的总和

     time_t         start_timestamp;       // 最近一次接收到peer消息的时间

     time_t         recet_timestamp;       // 最近一次发送消息给peer的时间

     time_t         last_down_timestamp;   // 最近下载数据的开始时间

     time_t         last_up_timestamp;     // 最近上传数据的开始时间

     long long      down_count;            // 本计时周期从peer下载的数据的字节数

     long long      up_count;              // 本计时周期向peer上传的数据的字节数

     float          down_rate;             // 本计时周期从peer处下载数据的速度

     float          up_rate;               // 本计时周期向peer处上传数据的速度

     struct _Peer   *next;                 // 指向下一个Peer结构体

 } Peer;

注释标注的很清晰。注意一点的是Peer和 Request_piece都是链表形式

Peer结构体体中 int state; // 当前所处的状态

状态定义为以下几种

#define INITIAL -1 // 表明处于初始化状态
#define HALFSHAKED 0 // 表明处于半握手状态
#define HANDSHAKED 1 // 表明处于全握手状态
#define SENDBITFIELD 2 // 表明处于已发送位图状态
#define RECVBITFIELD 3 // 表明处于已接收位图状态
#define DATA 4 // 表明处于与peer交换数据的状态
#define CLOSING 5 // 表明处于即将与peer断开的状态

但是状态的切换是不在Peer.c这个代码中，真正的代码切换是在流程处理中，后面其他代码会慢慢讲到

先来看看Peer的初始化

 int  initialize_peer(Peer *peer)

 {

     if(peer == NULL)   return -;

     peer->socket = -;

     memset(peer->ip,,);

     peer->port = ;

     memset(peer->id,,);

     peer->state = INITIAL;

     peer->in_buff      = NULL;

     peer->out_msg      = NULL;

     peer->out_msg_copy = NULL;

     peer->in_buff = (char *)malloc(MSG_SIZE);

     if(peer->in_buff == NULL)  goto OUT;

     memset(peer->in_buff,,MSG_SIZE);

     peer->buff_len = ;

     peer->out_msg = (char *)malloc(MSG_SIZE);

     if(peer->out_msg == NULL)  goto OUT;

     memset(peer->out_msg,,MSG_SIZE);

     peer->msg_len  = ;

     peer->out_msg_copy = (char *)malloc(MSG_SIZE);

     if(peer->out_msg_copy == NULL)  goto OUT;

     memset(peer->out_msg_copy,,MSG_SIZE);

     peer->msg_copy_len   = ;

     peer->msg_copy_index = ;

     peer->am_choking      = ;

     peer->am_interested   = ;

     peer->peer_choking    = ;

     peer->peer_interested = ;

     peer->bitmap.bitfield        = NULL;

     peer->bitmap.bitfield_length = ;

     peer->bitmap.valid_length    = ;

     peer->Request_piece_head     = NULL;

     peer->Requested_piece_head   = NULL;

     peer->down_total = ;

     peer->up_total   = ;

     peer->start_timestamp     = ;

     peer->recet_timestamp     = ;

     peer->last_down_timestamp = ;

     peer->last_up_timestamp   = ;

     peer->down_count          = ;

     peer->up_count            = ;

     peer->down_rate           = 0.0;

     peer->up_rate             = 0.0;

     peer->next = (Peer *);

     return ;

 OUT:

     if(peer->in_buff != NULL)      free(peer->in_buff);

     if(peer->out_msg != NULL)      free(peer->out_msg);

     if(peer->out_msg_copy != NULL) free(peer->out_msg_copy);

     return -;

 }

该创建的创建该分配的分配该置零的置零

这里使用了不常见的GOTO。为了保证逻辑清晰，一般是不允许代码里四处GOTO跳转的。

但是GOTO在跳出多重循环和调至结尾释放资源是比较清晰简洁的写法。

GOTO可以避免多处return忘记释放资源，而是跳转到结尾释放资源后return。return值在处理流程中会赋值1或者-1 表示成功与否

这种写法在结构复杂，多出return还有资源要释放时可以尝试使用下.

其他函数比较简单

Peer* add_peer_node(); // 添加一个peer结点插入链表
int del_peer_node(Peer *peer); // 从链表中删除一个peer结点
void free_peer_node(Peer *node); // 释放一个peer的内存

int cancel_request_list(Peer *node); // 撤消当前请求队列
int cancel_requested_list(Peer *node); // 撤消当前被请求队列

void release_memory_in_peer(); // 释放peer.c中的动态分配的内存
void print_peers_data(); // 打印peer链表中某些成员的值,用于调试

 Peer* add_peer_node()

 {

     int  ret;

     Peer *node, *p;

     // 分配内存空间

     node = (Peer *)malloc(sizeof(Peer));

     if(node == NULL)  {

         printf("%s:%d error\n",__FILE__,__LINE__);

         return NULL;

     }

     // 进行初始化

     ret = initialize_peer(node);

     if(ret < ) {

         printf("%s:%d error\n",__FILE__,__LINE__);

         free(node);

         return NULL;

     }

     // 将node加入到peer链表中

     if(peer_head == NULL)  { peer_head = node; }

     else {

         p = peer_head;

         while(p->next != NULL)  p = p->next;

         p->next = node;

     }

     return node;

 }

 int del_peer_node(Peer *peer)

 {

     Peer *p = peer_head, *q;

     if(peer == NULL)  return -;

     while(p != NULL) {

         if( p == peer ) {

             if(p == peer_head)  peer_head = p->next;

             else  q->next = p->next;

             free_peer_node(p);  // 可能存在问题

             return ;

         } else {

             q = p;

             p = p->next;

         }

     }

     return -;

 }

 // 撤消当前请求队列

 int cancel_request_list(Peer *node)

 {

     Request_piece  *p;

     p = node->Request_piece_head;

     while(p != NULL) {

         node->Request_piece_head = node->Request_piece_head->next;

         free(p);

         p = node->Request_piece_head;

     }

     return ;

 }

 // 撤消当前被请求队列

 int cancel_requested_list(Peer *node)

 {

     Request_piece  *p;

     p = node->Requested_piece_head;

     while(p != NULL) {

         node->Requested_piece_head = node->Requested_piece_head->next;

         free(p);

         p = node->Requested_piece_head;

     }

     return ;

 }

 void  free_peer_node(Peer *node)

 {

     if(node == NULL)  return;

     if(node->bitmap.bitfield != NULL) {

         free(node->bitmap.bitfield);

         node->bitmap.bitfield = NULL;

     }

     if(node->in_buff != NULL) {

         free(node->in_buff);

         node->in_buff = NULL;

     }

     if(node->out_msg != NULL) {

         free(node->out_msg);

         node->out_msg = NULL;

     }

     if(node->out_msg_copy != NULL) {

         free(node->out_msg_copy);

         node->out_msg_copy = NULL;

     }

     cancel_request_list(node);

     cancel_requested_list(node);

     // 释放完peer成员的内存后,再释放peer所占的内存

     free(node);

 }

 void  release_memory_in_peer()

 {

     Peer *p;

     if(peer_head == NULL)  return;

     p = peer_head;

     while(p != NULL) {

         peer_head = peer_head->next;

         free_peer_node(p);

         p = peer_head;

     }

 }

 void print_peers_data()

 {

     Peer *p    = peer_head;

     int  index = ;

     while(p != NULL) {

         printf("peer: %d  down_rate: %.2f \n", index, p->down_rate);

         index++;

         p = p->next;

     }

 }

都是常规链表操作

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

参考

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

巴特西

bittorrent 学习(二) LOG日志和peer管理连接

最新文章

热门文章