Linux平台下基于BitTorrent应用层协议的下载软件开发--策略管理模块（policy.c）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "parse_metafile.h"
#include "peer.h"
#include "data.h"
#include "message.h"
#include "policy.h"

Unchoke_peers  unchoke_peers; //存放非阻塞peer以及优化非阻塞peer的指针
long long      total_down = 0L, total_up = 0L; //总的上传量以及下载量
float          total_down_rate = 0.0F, total_up_rate = 0.0F;//上传速度以及下载速度
int            total_peers = 0;//已连接的总的peer数

extern int	   end_mode;
extern Bitmap  *bitmap;
extern Peer    *peer_head;
extern int     pieces_length;//每个piece_hash值的长度
extern int     piece_length;//每一个piece的长度

extern Btcache *btcache_head;
extern int     last_piece_index;
extern int     last_piece_count;
extern int     last_slice_len;
extern int     download_piece_num;

// 初始化全局变量unchoke_peers
void init_unchoke_peers()
{
	int i;

	for(i = 0; i < UNCHOKE_COUNT; i++) {
		*(unchoke_peers.unchkpeer + i) = NULL;		
	}

	unchoke_peers.count = 0;
	unchoke_peers.optunchkpeer = NULL;//对非阻塞指针以及优化非阻塞指针全部赋值为空
}

// 判断一个peer是否已经存在于unchoke_peers
int is_in_unchoke_peers(Peer *node)
{
	int i;

	for(i = 0; i < unchoke_peers.count; i++) {
		if( node == (unchoke_peers.unchkpeer)[i] )  return 1;
	}

	return 0;// node为peer指针，所以通过比较可以完全判断
}

// 从unchoke_peers中获取下载速度最慢的peer的索引
int get_last_index(Peer **array,int len)
{
	int i, j = -1;

	if(len <= 0) return j;//这里len为非阻塞peer指针的维度
	else j = 0;

	for(i = 0; i < len; i++)
		if( array[i]->down_rate < array[j]->down_rate )  j = i;

	return j;
}

// 找出当前下载速度最快的4个peer,将其unchoke  //实现了阻塞算法
int select_unchoke_peer()
{
	Peer*  p;
	Peer*  now_fast[UNCHOKE_COUNT];//现在最快
	Peer*  force_choke[UNCHOKE_COUNT];//强制阻塞
	int    unchoke_socket[UNCHOKE_COUNT], choke_socket[UNCHOKE_COUNT];//阻塞套接字还有非阻塞套接字
	int    i, j, index = 0, len = UNCHOKE_COUNT;

	for(i = 0; i < len; i++) {
		now_fast[i]       = NULL;
		force_choke[i]    = NULL;
		unchoke_socket[i] = -1;
		choke_socket[i]   = -1;//重新赋值
	}

	// 将那些在过去10秒已断开连接而又处于unchoke队列中的peer清除出unchoke队列
	for(i = 0, j = 0; i < unchoke_peers.count; i++) { //unchoke_peers.count记录当前一共有多少个非阻塞的peer,其值并不一定为4
		p = peer_head;
		while(p != NULL) {
			if(p == unchoke_peers.unchkpeer[i])  break;
			p = p->next;
		}
		if(p == NULL)  { unchoke_peers.unchkpeer[i] = NULL; j++; }//如果p等于NULL，说明peer队列中根本就没有非阻塞peer的指针，这说明非阻塞peer指针过时了
	}
	if(j != 0) {//这个时候说明，存在过时的非阻塞peer指针
	        unchoke_peers.count = unchoke_peers.count - j;//跟新当前非阻塞peer的数目
		for(i = 0, j = 0; i < len; i++) {
			if(unchoke_peers.unchkpeer[i] != NULL) {
			        force_choke[j] = unchoke_peers.unchkpeer[i];//将非阻塞的peer指针放入到另一数组中
				j++;
			}
		}
		for(i = 0; i < len; i++) {
		  unchoke_peers.unchkpeer[i] = force_choke[i];//这样的目的就是使得非阻塞的peer指针在内存中保持连续性，以便后面的处理
		  force_choke[i] = NULL;//并且将强制阻塞数组清空
		}
	}

	// 将那些在过去10秒上传速度超过20KB/S而下载速度过小的peer强行阻塞
	// 注意：up_rate和down_rate的单位是B/S而不是KB/S
	for(i = 0, j = -1; i < unchoke_peers.count; i++) {
		if( (unchoke_peers.unchkpeer)[i]->up_rate > 50*1024 &&
			(unchoke_peers.unchkpeer)[i]->down_rate < 0.1*1024 ) {
			j++;
			force_choke[j] = unchoke_peers.unchkpeer[i];
		}
	}

	// 从当前所有Peer中选出下载速度最快的四个peer
	p = peer_head;
	while(p != NULL) {
	          if(p->state==DATA && is_interested(bitmap,&(p->bitmap)) && is_seed(p)!=1) {//要进行下一步，则p需要满足三种状态
			// p不应该在force_choke数组中
			for(i = 0; i < len; i++) {
			  if(p == force_choke[i]) break;//如果peer本身就在强制阻塞数组中，就直接跳过
			}
			if(i == len) {
			        if( index < UNCHOKE_COUNT ) {//指明非阻塞peer的数目，在这里UNCHOKE_COUNT的值为4
					now_fast[index] = p; 
					index++; 
				} else {
				        j = get_last_index(now_fast,UNCHOKE_COUNT);//如果说index的值超过或等于4，说明需要判断是否将那一个peer置换出去
					if(p->down_rate >= now_fast[j]->down_rate) now_fast[j] = p;//上面的函数就是选择下载速度最小的那个
				}
			}
		}
		  p = p->next;//不满足上述的三种状态的时候就应该判断下一个peer是否满足
	}

	// 假设now_fast中所有的peer都是要unchoke的
	for(i = 0; i < index; i++) {
		Peer*  q = now_fast[i];
		unchoke_socket[i] = q->socket;//通过socket与peer通信，这里是给非阻塞套接字赋值
	}

	// 假设unchoke_peers.unchkpeer中所有peer都是choke的
	for(i = 0; i < unchoke_peers.count; i++) {
		Peer*  q = (unchoke_peers.unchkpeer)[i];
		choke_socket[i] = q->socket;//这里是给阻塞套接字赋值
	}

	// 如果now_fast某个元素已经存在于unchoke_peers.unchkpeer
	// 则没有必要进行choke或unckoke
	for(i = 0; i < index; i++) {
		if( is_in_unchoke_peers(now_fast[i]) == 1) {
			for(j = 0; j < len; j++) {
			  Peer*  q = now_fast[i];//最快的peer是4个，所以index为4，其实这几个数组的大小完全相同，都等于UNCHOKE_COUNT
				if(q->socket == unchoke_socket[i])  unchoke_socket[i] = -1;
				if(q->socket == choke_socket[i])    choke_socket[i]   = -1;
			}
		}
	}

	// 更新当前unchoke的peer，也就是重新选择unchoke peer
	for(i = 0; i < index; i++) {
	  (unchoke_peers.unchkpeer)[i] = now_fast[i];//将下载最快的4个peer放入到非阻塞peer数组中
	}
	unchoke_peers.count = index;

	// 状态变化后,要对peer的状态值重新赋值,并且创建choke、unchoke消息
	p = peer_head;
	while(p != NULL) {
		for(i = 0; i < len; i++) {
		        if(unchoke_socket[i]==p->socket && unchoke_socket[i]!=-1) {//如果某一个套接字为非阻塞套接子，并且其值不为-1
			  p->am_choking = 0;//解除自我阻塞
				create_chock_interested_msg(1,p);//创建unchoke消息
			}
			if(choke_socket[i]==p->socket && choke_socket[i]!=-1) { //这个地方好像写错了
			  p->am_choking = 1;//自我阻塞
				cancel_requested_list(p);
				create_chock_interested_msg(0,p);//创建chock消息
			}
		}
		p = p->next;
	}

	//for(i = 0; i < unchoke_peers.count; i++)
	//	printf("unchoke peer:%s \n",(unchoke_peers.unchkpeer)[i]->ip);

	return 0;
}

// 假设要下载的文件共有100个piece
// 以下函数的功能是将0到99这100个数的顺序以随机的方式打乱
// 从而得到一个随机的数组,该数组以随机的方式存储0～99,供片断选择算法使用

int *rand_num = NULL;//也是定义的全局变量
int get_rand_numbers(int length)
{
	int i, index, piece_count, *temp_num;
	
	if(length == 0)  return -1;
	piece_count = length;//说明有多少个piece
	
	rand_num = (int *)malloc(piece_count * sizeof(int));
	if(rand_num == NULL)    return -1;
	
	temp_num = (int *)malloc(piece_count * sizeof(int));//用于临时存放
	if(temp_num == NULL)    return -1;
	for(i = 0; i < piece_count; i++)  temp_num[i] = i;
	
	srand(time(NULL));//随机函数发生器的初始化函数，如果种子相同，那么后面rand（）的值也是相同的
	for(i = 0; i < piece_count; i++) {
	  index = (int)( (float)(piece_count-i) * rand() / (RAND_MAX+1.0) );//index的值不同，这样就做到了打乱了赋值
	  rand_num[i] = temp_num[index];          //RAND_MAX在哪里定义的？
        temp_num[index] = temp_num[piece_count-1-i];
    }
	
	if(temp_num != NULL)  free(temp_num);
	return 0;
}

// 从peer队列中选择一个优化非阻塞peer
int select_optunchoke_peer()
{
	int   count = 0, index, i = 0, j, ret;
	Peer  *p = peer_head; 

	// 获取peer队列中peer的总数
	while(p != NULL) {
		count++;
		p =  p->next;
	}

	// 如果peer总数太少(小于等于4),则没有必要选择优化非阻塞peer
	if(count <= UNCHOKE_COUNT)  return 0;

	ret = get_rand_numbers(count);
	if(ret < 0) {
		printf("%s:%d get rand numbers error\n",__FILE__,__LINE__);
		return -1;
	}
	while(i < count) {
		// 随机选择一个数,该数在0～count-1之间
	        index = rand_num[i];//在之前就有定义，get_rand_numbers函数之前

		p = peer_head;
		j = 0;
		while(j < index && p != NULL) {
			p = p->next;
			j++;
		}//找到对应的peer
                

                /*如果该peer要想成为优化非阻塞peer，则必须满足5个条件：
                  1、首先他不是当前4个非阻塞peer中的一个
                  2、p不是种子
                  3、p的状态处于数据交换状态
                  4、p并不是当前的优化非阻塞peer，从上面可以看出，优化非阻塞peer都是随机选择的
                  5、这个peer含有客户端没有的piece*/

		if( is_in_unchoke_peers(p) != 1 && is_seed(p) != 1 && p->state == DATA &&
		    p != unchoke_peers.optunchkpeer && is_interested(bitmap,&(p->bitmap)) ) {
		
		        if( (unchoke_peers.optunchkpeer) != NULL ) {//说明之前存在优化非阻塞peer，这次不过是另外选择一个罢了
				Peer  *temp = peer_head;
				while( temp != NULL ) {
					if(temp == unchoke_peers.optunchkpeer) break;
					temp = temp->next;//在peer队列中找到当前的优化非阻塞peer
				}
				if(temp != NULL) {
				  (unchoke_peers.optunchkpeer)->am_choking = 1;//找到后将其阻塞，并同时发送阻塞消息
					create_chock_interested_msg(0,unchoke_peers.optunchkpeer);
				}
			}

			p->am_choking = 0;//找到优化的非阻塞peer，并解除阻塞
			create_chock_interested_msg(1,p);//发布非阻塞消息
			unchoke_peers.optunchkpeer = p;//更新优化非阻塞peer
			//printf("*** optunchoke:%s ***\n",p->ip);
			break;
		}

		i++;
	}

	if(rand_num != NULL) { free(rand_num); rand_num = NULL; }//这个时候释放rand_num内存
	return 0;
}

// 计算最近一段时间(如10秒)每个peer的上传下载速度
int compute_rate()
{
	Peer    *p       = peer_head;
	time_t  time_now = time(NULL);//记录当前的日历时间
	long    t        = 0;

	while(p != NULL) {
		if(p->last_down_timestamp == 0) {
			p->down_rate  = 0.0f;
			p->down_count = 0;
		} else {
		        t = time_now - p->last_down_timestamp;//最近一次下载的时间
			if(t == 0)  printf("%s:%d time is 0\n",__FILE__,__LINE__);
			else  p->down_rate = p->down_count / t;//计算下载的速率
			p->down_count          = 0;
			p->last_down_timestamp = 0;
		}

		if(p->last_up_timestamp == 0) {
			p->up_rate  = 0.0f;
			p->up_count = 0;
		} else {
		        t = time_now - p->last_up_timestamp;//计算最近一次上传的时间
			if(t == 0)  printf("%s:%d time is 0\n",__FILE__,__LINE__);
			else  p->up_rate = p->up_count / t;//计算上传的速率
			p->up_count          = 0;
			p->last_up_timestamp = 0;//重新设置
		}

		p = p->next;
	}

	return 0;
}

// 计算总的下载和上传速度
int compute_total_rate()//总的上传和下载速度等于各个peer的和
{
        Peer *p = peer_head;//指向与之通信的peer列表

	total_peers     = 0;
	total_down      = 0;
	total_up        = 0;  
	total_down_rate = 0.0f;
	total_up_rate   = 0.0f;

	while(p != NULL) {
		total_down      += p->down_total;
		total_up        += p->up_total;
		total_down_rate += p->down_rate;
		total_up_rate   += p->up_rate;

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

	return 0;
}

/*何为种子？
  种子就是不缺少任何一个piece,其位图信息必须全部为1*/

int is_seed(Peer *node)
{
	int            i;
	//其实下面的这两条语句，就是为了描述完整位图的信息，因为根据piece的数目很自然的可以构造出完整的位图
	unsigned char  c = (unsigned char)0xFF, last_byte;
	unsigned char  cnst[8] = { 255, 254, 252, 248, 240, 224, 192, 128 };//分别为128，128+64，128+64+32，128+64+32+1……
	
	if(node->bitmap.bitfield == NULL)  return 0;
	
	for(i = 0; i < node->bitmap.bitfield_length-1; i++) {//位图的长度，根据piece的数目肯定可以得到完整位图的信息
	  if( (node->bitmap.bitfield)[i] != c ) return 0;//这样的目的就是为了找到最后一个字节
	}
		
	// 获取位图的最后一个字节
	last_byte = node->bitmap.bitfield[i];
	// 获取最后一个字节的无效位数
	i = 8 * node->bitmap.bitfield_length - node->bitmap.valid_length; //valid_length表示的是piece的数目
	// 判断最后一个是否位种子的最后一个字节
	if(last_byte >= cnst[i]) return 1;
	else return 0;
}

// 生成request请求消息,实现了片断选择算法,17为一个request消息的固定长度，peer* node本身发送请求消息，而不是主机发送，里面牵扯到主机的内容是怎么回事呢？
int create_req_slice_msg(Peer *node)
{
	int index, begin, length = 16*1024;
	int i, count = 0;

	if(node == NULL)  return -1;
	// 如果被peer阻塞或对peer不感兴趣,就没有必要生成request消息
	if(node->peer_choking==1 || node->am_interested==0 )  return -1; //相当于peer向主机请求某一个slice

	// 如果之前向该peer发送过请求,则根据之前的请求构造新请求
	// 遵守一条原则：同一个piece的所有slice应该从同一个peer处下载 //是不是片断选择的策略1？
	Request_piece *p = node->Request_piece_head, *q = NULL;
	if(p != NULL) {
		while(p->next != NULL)  { p = p->next; } // 定位到最后一个结点处，这最后一个节点也是为某一个piece的请求消息

		/*确定last slice的位置，为后面生成slice消息做准备。 一个piece的最后一个slice的起始下标*/
		int last_begin = piece_length - 16*1024;
		// 如果是最后一个piece
		if(p->index == last_piece_index) { //如果说这个piece为最后一个piece，那么其最后一个slice的坐标也会发生变化
			last_begin = (last_piece_count - 1) * 16 * 1024;
		}
		

                /*
                  从下面的函数可以看出，在Request_piece_head所代表的列表中，如果最后一个piece中的slice请求还有未发送，那么就就构建
                  slice请求将最后一个piece中的一个slice发送出去*/
		// 当前piece还有未请求的slice,则构造请求消息
		if(p->begin < last_begin) {
			index = p->index;
			begin = p->begin + 16*1024;
			count = 0; //这句话的意思是，每次调用这个函数也就只能发送一个slice,如果想多次发送，则需要多次调用

			while(begin!=piece_length && count<1) {//这里是请求slice的信息，所以begin的值不能等于piece_length
				// 如果是最后一个piece的最后一个slice
				if(p->index == last_piece_index) {
					if( begin == (last_piece_count - 1) * 16 * 1024 )
					      length = last_slice_len;//如果为最后一个piece的最后一个slice，那么length的长度可能达不到一个slice也就是16k
				}                                     //因为在本函数的开始处，就默认的定义length为16k，所以这种情况是一个特例

				create_request_msg(index,begin,length,node);//创建request消息，注意了这是node创建的消息
				
				q = (Request_piece *)malloc(sizeof(Request_piece));//将当前的请求记录到请求队列
				if(q == NULL) { 
					printf("%s:%d error\n",__FILE__,__LINE__);
					return -1;
				}
				q->index  = index;
				q->begin  = begin;
				q->length = length;
				q->next   = NULL;
				p->next   = q;
				p         = q;

				begin += 16*1024;//用于while循环，但是这句话好像没有任何作用，因为是count控制着循环
				count++;
			}//while循环结束
			
			return 0;  // 构造完毕,就返回
		}//while之前的if语句结束
	}//再之前的if语句结束



	//片断选择策略的2和3
       /*然后去btcache_head中寻找这样的piece:它没有下载完,但它不在任何peer的
	 request消息队列中,应该优先下载这样的piece,出现这样的piece的原因是:
	 从一个peer处下载一个piece,还没下载完,那个peer就将我们choke了或下线了

	 但是测试结果表明, 以这种方式这种方式创建rquest请求执行效率并不高
	 如果直接丢弃未下载完成的piece,则没有必要进行这种生成请求的方式
	 int ret = create_req_slice_msg_from_btcache(node);
	 if(ret == 0) return 0;*/

	// 生成随机数  
	if(get_rand_numbers(pieces_length/20) == -1) { //说明slice请求消息并没有构造完毕
		printf("%s:%d error\n",__FILE__,__LINE__);
		return -1;
	}
	// 随机选择一个piece的下标,该下标所代表的piece应该没有向任何peer请求过
	for(i = 0; i < pieces_length/20; i++) {
		index = rand_num[i];

		// 判断对于以index为下标的piece,peer是否拥有
		if( get_bit_value(&(node->bitmap),index) == 1)  continue;//要想执行下去，那么其值应该为1，也就是拥有,但是如果其拥有了又何必发request请求？我觉得有错误！！
		// 判断对于以index为下标的piece,是否已经下载
		if( get_bit_value(bitmap,index) == 1) continue;//但是主机没有

		// 判断对于以index为下标的piece,是否已经请求过了
		Peer          *peer_ptr = peer_head;
		Request_piece *reqt_ptr;
		int           find = 0;
		while(peer_ptr != NULL) {
		        reqt_ptr = peer_ptr->Request_piece_head;//前面提到过，它不再任何peer的请求队列中
			while(reqt_ptr != NULL) {
				if(reqt_ptr->index == index)  { find = 1; break; }
				reqt_ptr = reqt_ptr->next;
			}
			if(find == 1) break;

			peer_ptr = peer_ptr->next;
		}
		if(find == 1) continue;//说明能够在peer的请求队列中找到这样的piece,这样就不是我们想要下载的piece 

		break; // 程序若执行到此处,说明已经找到一个复合要求的index
	}
	if(i == pieces_length/20) {//这个时候说明没有找到符合条件的index
		if(end_mode == 0)  end_mode = 1;
		for(i = 0; i < pieces_length/20; i++) {
		     if( get_bit_value(bitmap,i) == 0 )  { index = i; break; }//在没有找到理想的index的情况下，查找现在还有那一个piece还没有下载
		}
		
		if(i == pieces_length/20) { //如果是这种情况，说明所有的piece已经下载，没有需要下载的piece,也就没有必要发送slice消息
			printf("Can not find an index to IP:%s\n",node->ip);
			return -1;
		}
	}

	// 构造piece请求消息，走到这一步说明本机中还是有piece没有被下载
	begin = 0;
	count = 0;
	p = node->Request_piece_head;
	if(p != NULL)
		while(p->next != NULL)  p = p->next;
	while(count < 4) {
		// 如果是构造最后一个piece的请求消息
		if(index == last_piece_index) {
			if(count+1 > last_piece_count) 
				break;
			if(begin == (last_piece_count - 1) * 16 * 1024)
				length = last_slice_len;
		}

		create_request_msg(index,begin,length,node); //到最后还是node构造request请求

		q = (Request_piece *)malloc(sizeof(Request_piece));
		if(q == NULL) { printf("%s:%d error\n",__FILE__,__LINE__); return -1; }
		q->index  = index;
		q->begin  = begin;
		q->length = length;
		q->next   = NULL;
		if(node->Request_piece_head == NULL)  { node->Request_piece_head = q; p = q; }
		else  { p->next = q; p = q; }
		//printf("*** create request index:%-6d begin:%-6x to IP:%s ***\n",
		//	index,q->begin,node->ip);
		begin += 16*1024;
		count++;
	}

	if(rand_num != NULL)  { free(rand_num); rand_num = NULL; }
	return 0;
}

// 以下这个函数实际并未调用,若要使用需先在头文件中声明
int create_req_slice_msg_from_btcache(Peer *node)
{
	// 指针b用于遍历btcache缓冲区
	// 指针b_piece_first指向每个piece第一个slice处
	// slice_count指明一个piece含有多少个slice
	// valid_count指明一个piece中已下载的slice数
	Btcache        *b = btcache_head, *b_piece_first;
	Peer           *p;
	Request_piece  *r;
	int            slice_count = piece_length / (16*1024);
	int            count = 0, num, valid_count;
	int            index = -1, length = 16*1024;
	
	while(b != NULL) {
		if(count%slice_count == 0) {
			num           = slice_count;
			b_piece_first = b;
			valid_count   = 0;
			index         = -1;
			
			// 遍历btcache中一个piece的所有slice
			while(num>0 && b!=NULL) {
				if(b->in_use==1 && b->read_write==1 && b->is_writed==0)
					valid_count++;
				if(index==-1 && b->index!=-1) index = b->index;
				num--;
				count++;
				b = b->next;
			}
			
			// 找到一个未下载完piece
			if(valid_count>0 && valid_count<slice_count) {
				// 检查该piece是否存在于某个peer的请求队列中
				p = peer_head;
				while(p != NULL) {
					r = p->Request_piece_head;
					while(r != NULL) {
						if(r->index==index && index!=-1) break;
						r = r->next;
					}
					if(r != NULL) break;
					p = p->next;
				}
				// 如果该piece没有存在于任何peer的请求队列中,那么就找到了需要的piece
				if(p==NULL && get_bit_value(&(node->bitmap),index)==1) {
					int request_count = 5;
					num = 0;
					// 将r定位到peer最后一个请求消息处
					r = node->Request_piece_head;
					if(r != NULL) {
						while(r->next != NULL) r = r->next;
					}
					while(num<slice_count && request_count>0) {
						if(b_piece_first->in_use == 0) {
							create_request_msg(index,num*length,length,node);
							
							Request_piece *q;
							q = (Request_piece *)malloc(sizeof(Request_piece));
							if(q == NULL) { 
								printf("%s:%d error\n",__FILE__,__LINE__);
								return -1;
							}
							q->index  = index;
							q->begin  = num*length;
							q->length = length;
							q->next   = NULL;
							printf("create request from btcache index:%-6d begin:%-6x\n",
								index,q->begin);
							if(r == NULL) {
								node->Request_piece_head = q;
								r = q;
							} else{
								r->next = q;
								r = q;
							}
							request_count--;
						}
						num++;
						b_piece_first = b_piece_first->next;
					}
					return 0;
				}
			}
		}
	}
	
	return -1;
}