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[16];                // peer的ip地址
    unsigned short port;                  // peer的端口号
    char           id[21];                // 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 -1;

    peer->socket = -1;
    memset(peer->ip,0,16);
    peer->port = 0;
    memset(peer->id,0,21);
    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,0,MSG_SIZE);
    peer->buff_len = 0;

    peer->out_msg = (char *)malloc(MSG_SIZE);
    if(peer->out_msg == NULL)  goto OUT;
    memset(peer->out_msg,0,MSG_SIZE);
    peer->msg_len  = 0;
    
    peer->out_msg_copy = (char *)malloc(MSG_SIZE);
    if(peer->out_msg_copy == NULL)  goto OUT;
    memset(peer->out_msg_copy,0,MSG_SIZE);
    peer->msg_copy_len   = 0;
    peer->msg_copy_index = 0;

    peer->am_choking      = 1;
    peer->am_interested   = 0;
    peer->peer_choking    = 1;
    peer->peer_interested = 0;
    
    peer->bitmap.bitfield        = NULL;
    peer->bitmap.bitfield_length = 0;
    peer->bitmap.valid_length    = 0;
    
    peer->Request_piece_head     = NULL;
    peer->Requested_piece_head   = NULL;
    
    peer->down_total = 0;
    peer->up_total   = 0;
    
    peer->start_timestamp     = 0;
    peer->recet_timestamp     = 0;
    
    peer->last_down_timestamp = 0;
    peer->last_up_timestamp   = 0;
    peer->down_count          = 0;
    peer->up_count            = 0;
    peer->down_rate           = 0.0;
    peer->up_rate             = 0.0;
    
    peer->next = (Peer *)0;
    return 0;

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

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

这里使用了不常见的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
",__FILE__,__LINE__); 
        return NULL;
    }

    // 进行初始化
    ret = initialize_peer(node);
    if(ret < 0) { 
        printf("%s:%d error
",__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 -1;

    while(p != NULL) {
        if( p == peer ) {
            if(p == peer_head)  peer_head = p->next;
            else  q->next = p->next;
            free_peer_node(p);  // 可能存在问题
            return 0;
        } else {
            q = p;
            p = p->next;
        }
    }

    return -1;
}

// 撤消当前请求队列
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 0;
}

// 撤消当前被请求队列
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 0;
}

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 = 0;

    while(p != NULL) {
        printf("peer: %d  down_rate: %.2f 
", index, p->down_rate);

        index++;
        p = p->next;
    }
}

都是常规链表操作

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

参考

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