address_conf.c

支持IPv6的adov路由协议（本人修改后）

#include <sys/time.h>
#include <string.h>
#include "aodv_timeout.h"
#include "timer_queue.h"
#include "address_conf.h"
#include "ipv6_utils.h"
#include "params.h"
#include "address_areq.h"
extern int is_gateway,internet_gw_mode;
int addr_generate_by_linkaddr=0;
char *ip6addr_generate(char *prefix)
{
	struct timeval now;
	u_int32_t randnum;
	//u_int32_t ipaddr=0;
	char *ip6addr_str=NULL,*prefix_addr=NULL,*prefix_addr_len=NULL,ip6_addr[9],ip6_addr_token[2][5],ip6_prefix[IP6ADDR_STR_LEN+3];
	struct in6_addr addr_by_linkaddr;
	int prefix_len,prefix_length;
	//int i=0;
	strcpy(ip6_prefix,prefix);
	//printf("begin to get prefix_addr...\n");
	prefix_addr=strtok(ip6_prefix,"/");
	//printf("begin to get prefix len...\n");
	prefix_addr_len=strtok(NULL,"\0");
	if(!prefix_addr_len){
		fprintf(stderr,"unrecognized prefix length!\n");
		exit(-1);
	}
	prefix_len=atoi(prefix_addr_len);
	if(prefix_len!=64&&prefix_len!=96){
		fprintf(stderr,"don't support prefix length:%d,only support length 64 and 96!\n",prefix_len);
		exit(-1);
	}
	if((ip6addr_str=(char *)malloc(sizeof(char)*(IP6ADDR_STR_LEN+3)))==NULL){
		printf("malloc failed!\n");
		exit(-1);
	}
	if(addr_generate_by_linkaddr){
		if(prefix_len!=64){
			fprintf(stderr,"generate address by link_addr,prefix length %d!=64,exit!\n",prefix_len);
			exit(-1);
		}
		inet_pton(AF_INET6,prefix_addr,&addr_by_linkaddr);
		printf("prefix_addr:%s\n",prefix_addr);
		addr_by_linkaddr.s6_addr32[2]=if_link_addr.s6_addr32[2];
		addr_by_linkaddr.s6_addr32[3]=if_link_addr.s6_addr32[3];
		//memcpy(&addr_by_linkaddr.s6_addr32[2],&if_link_addr.s6_addr32[2],sizeof(u_int32_t));
		//memcpy(&addr_by_linkaddr.s6_addr32[3],&if_link_addr.s6_addr32[4],sizeof(u_int32_t));
		sprintf(ip6addr_str,"%s/%d",ip6_to_str(addr_by_linkaddr),prefix_len);
		printf("manet addr:%s\n",ip6addr_str);
		return ip6addr_str;
	}
	//printf("prefix:%s len:%d\n",prefix_addr,prefix_len);
	memset(prefix_addr_len-2,'\0',sizeof(char));
	prefix_length=prefix_len;
	while(prefix_len<=96){
		gettimeofday(&now,NULL);
		srandom(now.tv_usec);
		randnum=random();
		if(prefix_len==96)
			while(randnum==0) randnum=random();
		sprintf(ip6_addr,"%8x",randnum);
		//printf("ip6_addr:%s\n",ip6_addr);
		sscanf(ip6_addr,"%4s%4s",ip6_addr_token[0],ip6_addr_token[1]);
		ip6_addr_token[0][4]=':';
		if(prefix_len==96)
			sprintf(prefix_addr,"%s:",prefix_addr);
		sprintf(prefix_addr,"%s%s",prefix_addr,ip6_addr_token[0]);
		prefix_len+=32;
	}
	//strcpy(ipaddr_str,ip_to_str(ipaddr));
	sprintf(ip6addr_str,"%s/%d",prefix_addr,prefix_length);
	//printf("new ip6 address:%s\n",ip6addr_str);
	return ip6addr_str;
}
void ip6addr_config_add(char *ip6addr)
{
	char buf[100];
	char *ip6addr_str;
	memset(buf,'\0',sizeof(buf));
	sprintf(buf,"ifconfig %s add %s",myifname,ip6addr);
	//printf("ip6addr:%s\n",ip6addr);
	system(buf);
	if(new_ip6addr_head==NULL){
		if((new_ip6addr_head=(struct ip6_addr *)malloc(sizeof(struct ip6_addr)))==NULL){
			printf("malloc failed!\n");
			exit(1);
		}
		new_ip6addr_tail=new_ip6addr_head;	
	}else{
		if((new_ip6addr_tail->next=(struct ip6_addr *)malloc(sizeof(struct ip6_addr)))==NULL){
			printf("malloc failed!\n");
			exit(1);
		}
		new_ip6addr_tail=new_ip6addr_tail->next;
	}
	strcpy(buf,ip6addr);
	ip6addr_str=strtok(buf,"/");
	inet_pton(AF_INET6,ip6addr_str,&new_ip6addr_tail->ip6_in6addr);
	ip6addr_str=strtok(NULL,"\0");
	new_ip6addr_tail->plen=atoi(ip6addr_str);
	new_ip6addr_tail->next=NULL;
}
void ip6addr_config_remove(struct ip6_addr *ip6addr,struct ip6_addr *ip6addr_list)
{
	char buf[100];
	struct ip6_addr *ip6addr_tmp=NULL,*ip6addr_list_pre=NULL,*ip6addr_list_tmp=NULL;
	if(ip6addr==NULL) return;
	ip6addr_tmp=ip6addr;
	while(ip6addr_tmp){
		memset(buf,'\0',sizeof(buf));
		sprintf(buf,"ifconfig %s del %s/%d",myifname,
			ip6_to_str(ip6addr_tmp->ip6_in6addr),ip6addr_tmp->plen);
		printf("del ip:%s\n",ip6_to_str(ip6addr_tmp->ip6_in6addr));
		system(buf);
		ip6addr_list_tmp=ip6addr_list;
		ip6addr_list_pre=ip6addr_list_tmp;
		//printf("enter while(ip6addr_list_tmp)!\n");
		while(ip6addr_list_tmp){
			if(!memcmp(&(ip6addr_list_tmp->ip6_in6addr),&(ip6addr_tmp->ip6_in6addr),
				sizeof(struct in6_addr))){
				//printf("list hit!\n");
				if(ip6addr_list_tmp==ip6addr_list){
					ip6addr_list=ip6addr_list_tmp->next;
					if(ip6addr_list_tmp==ip6addr_tmp)
						ip6addr_tmp=ip6addr_tmp->next;
				}
				else
					ip6addr_list_pre->next=ip6addr_list_tmp->next;
				printf("free ip:%s\n",ip6_to_str(ip6addr_list_tmp->ip6_in6addr));
				if(ip6addr_list_tmp==new_ip6addr_head)
					new_ip6addr_head=new_ip6addr_head->next;
				if(ip6addr_list_tmp==new_ip6addr_tail){
					if(ip6addr_list_tmp==ip6addr_list_pre)
						new_ip6addr_tail=NULL;
					else
						new_ip6addr_tail=ip6addr_list_pre;
				}
				free(ip6addr_list_tmp);
				break;
			}
			ip6addr_list_pre=ip6addr_list_tmp;
			ip6addr_list_tmp=ip6addr_list_tmp->next;
		}
		if(ip6addr_tmp!=ip6addr_list)
			ip6addr_tmp=ip6addr_tmp->next;
	}
}
void ip6addr_clear()
{
	char buf[100];
	struct if6_info *old_list_tmp;
	struct ip6_addr *tmp;
	for(tmp=new_ip6addr_head;tmp;tmp=tmp->next)
		printf("ip6 addr:%s\n",ip6_to_str(tmp->ip6_in6addr));
	ip6addr_config_remove(new_ip6addr_head,new_ip6addr_head);
	for(old_list_tmp=if_in_use_old;old_list_tmp;old_list_tmp=old_list_tmp->next){
		memset(buf,'\0',sizeof(buf));
		sprintf(buf,"ifconfig %s add %s/%d",myifname,
			ip6_to_str(old_list_tmp->ipv6_addr),old_list_tmp->plen);
		system(buf);
	}
}

void temp_address_config()
{
	char *ip6_addr;
	new_ip6addr_head=new_ip6addr_tail=NULL;
	//printf("calling ip6addr_generate...\n");
	ip6_addr=ip6addr_generate(MANET_INIT_PREFIX);
	//ip6_address=ip6addr_generate(MANET_PREFIX);
	//printf("calling ip6addr_remove...\n");
	ip6addr_config_remove(old_ip6addr_head,old_ip6addr_head);	
	//printf("calling ip6addr_config_add...\n");
	ip6addr_config_add(ip6_addr);
}
void tentative_addrconf_init()
{
	addrconf_begin_timer.handler=addrconf_begin_timeout;
	addrconf_begin_timer.data=NULL;
	timer_add_msec(&addrconf_begin_timer,ADDRESS_CONFIG_BEGIN_TIME);
}
void tentative_addrconf_begin()
{
	addrconf_timer.handler=address_config_timeout;
	addrconf_timer.data=NULL;
	timer_add_msec(&addrconf_timer,ADDRESS_CONFIG_TIME);
	addr_generate_by_linkaddr=1;
	tentative_addr_conf();
}

void tentative_addr_conf()
{
	char *ip6_addr,*ip6_addr_str,*ip6_addr_len;
	int prefix_len;
	struct in6_addr ip6_address;
	struct timeval now;
	u_int32_t randnum;
	ip6_addr=ip6addr_generate(MANET_PREFIX);
	printf("generated ip6 addr:%s\n",ip6_addr);
	addr_generate_by_linkaddr=0;
	ip6_addr_str=strtok(ip6_addr,"/");
	ip6_addr_len=strtok(NULL,"\0");
	prefix_len=atoi(ip6_addr_len);
	printf("ip6 address:%s  prefix len:%d\n",ip6_addr_str,prefix_len);
	inet_pton(AF_INET6,ip6_addr_str, &ip6_address);
	memcpy(&areq_info.request_addr,&ip6_address,sizeof(struct in6_addr));
	areq_info.prefix_len=prefix_len;
	areq_info.retries=AREQ_RETRIES;
	gettimeofday(&now,NULL);
	srandom(now.tv_usec);
	if((randnum=random()-AREQ_RETRIES)<0)
		randnum+=AREQ_RETRIES;
	areq_info.seqno=randnum;
	areq_info.id=random();
	printf("request address:%s\n",ip6_to_str(areq_info.request_addr));
	dup_addr_detect();
}

void tentative_address_config()
{
	char ip6_addr[IP6ADDR_STR_LEN+3],buf[100];
	struct if6_info *if_in_use=NULL;
	ip6addr_config_remove(new_ip6addr_head,new_ip6addr_head);
	new_ip6addr_head=NULL;
	printf("areq_info.prefix_len:%d\n",areq_info.prefix_len);
	sprintf(ip6_addr,"%s/%d",ip6_to_str(areq_info.request_addr),areq_info.prefix_len);
	printf("ip6_addr:%s\n",ip6_addr);
	ip6addr_config_add(ip6_addr);
	if_in_use = get_if6_info(myifname);
	if (if_in_use==NULL)
	  {
	    fprintf(stderr, "\nCould not find a %s interface!\n", myifname);
	    fprintf(stderr, "%s might not configure for IPv6.\n\n", myifname);
	    exit(-1);	
	  }
	
	DEV_NR(this_host.nif).ifindex =  if_in_use->if_idx;
	dev_indices[this_host.nif] = if_in_use->if_idx;
	strcpy(DEV_IFINDEX(if_in_use->if_idx).ifname, myifname);
	memcpy(&(DEV_IFINDEX(if_in_use->if_idx).ipaddr), &(if_in_use->ipv6_addr),
	       sizeof(struct in6_addr));
	printf("manet ipv6 address:%s  ",ip6_to_str(if_in_use->ipv6_addr));
	DEV_IFINDEX(if_in_use->if_idx).plen = if_in_use->plen;
	printf("prefix length:%d\n",if_in_use->plen);
	printf("config one tentative address to wireless card.\n");
	/*if(internet_gw_mode){
		memset(buf,'\0',sizeof(buf));
		sprintf(buf,"route -A inet6 add %s/%d gw %s",ip6_to_str(ipv6_dest_default),
			IPV6_DEST_DEFAULT_PLEN,"fec0:0:0:ffff::88");
		printf("buf:%s\n",buf);
		system(buf);
	}
	*/
	if(is_gateway)
		global_address_config(gw_global_prefix);
}
void global_address_config(char *global_prefix)
{
	char *prefix_addr=NULL,*prefix_addr_len=NULL;
	char /*manet_addr[IP6ADDR_STR_LEN+3],*/global_addr[IP6ADDR_STR_LEN+3];
	int prefix_len,len,remain_len,i=0,j=0,bits_num=16,global_addr_bin[128],hex_num=0;
	int global_addrtoken_bin[16],manet_addrtoken_bin[16];
	struct in6_addr global_prefix_addr,manet_tentative_addr,global_in6addr;
	prefix_addr=strtok(global_prefix,"/");
	prefix_addr_len=strtok(NULL,"\0");
	if(prefix_addr_len==NULL)
		prefix_len=64;
	else
		prefix_len=atoi(prefix_addr_len);
	if(prefix_len>64){
		fprintf(stderr,"prefix length %d>64,don't support now!\n",prefix_len);
		exit(-1);
	}
	/*generate global address*/
	inet_pton(AF_INET6,prefix_addr,&global_prefix_addr);
	//memcpy(manet_addr,new_ip6addr_head->ip6_address,sizeof(manet_addr));
	//prefix_addr=strtok(manet_addr,"/");
	//inet_pton(AF_INET6,prefix_addr,&manet_tentative_addr);
	memcpy(&manet_tentative_addr,&(new_ip6addr_head->ip6_in6addr),sizeof(struct in6_addr));
	len=prefix_len;
	printf("global_prefix_addr:%s  manet_tentative_addr:%s\n",ip6_to_str(global_prefix_addr),ip6_to_str(manet_tentative_addr));
	memset(global_addr,'\0',sizeof(global_addr));
	memset(global_addr_bin,0,sizeof(global_addr_bin));
	remain_len=prefix_len%16;
	while(len--){		
		bits_num--;
		if(bits_num==-1){
			bits_num=15;
			i++;
		}
		if((remain_len!=0)&&(len<remain_len)) break;
		global_addr_bin[i*16+((23-bits_num)%16)]=
		((global_prefix_addr.s6_addr16[i])&(1<<bits_num))>0?1:0;
		printf("%d",i*16+((23-bits_num)%16));
	}
	printf("\nlen:%d bits_num:%d i:%d\n",len,bits_num,i);
	if(remain_len!=0){
		for(bits_num=15;bits_num>=0;bits_num--)
			global_addrtoken_bin[(23-bits_num)%16]=
			((global_prefix_addr.s6_addr16[i])&(1<<bits_num))>0?1:0;
		for(j=remain_len;j<16;j++)
			global_addrtoken_bin[j]=0;
		for(bits_num=15;bits_num>=0;bits_num--)
			manet_addrtoken_bin[(23-bits_num)%16]=
			((manet_tentative_addr.s6_addr16[i])&(1<<bits_num))>0?1:0;
		for(j=0;j<remain_len;j++)
			manet_addrtoken_bin[j]=0;
		for(j=0;j<16;j++){
			global_addr_bin[i*16+j]=global_addrtoken_bin[j]||manet_addrtoken_bin[j];
			printf("%d",global_addr_bin[i*16+j]);
		}
		printf("\ng_token:");
		for(j=0;j<16;j++)
			printf("%d",global_addrtoken_bin[j]);
		printf("\nm_token:");
		for(j=0;j<16;j++)
			printf("%d",manet_addrtoken_bin[j]);
		printf("\n");
	}			
	len=128-prefix_len-(16-remain_len)%16;
	printf("bits_num:%d i:%d len:%d\n",bits_num,i,len);
	bits_num--;
	while(len--){
		if(bits_num==-1){
			bits_num=15;
			i++;
		}
		global_addr_bin[i*16+((23-bits_num)%16)]=
		((manet_tentative_addr.s6_addr16[i])&(1<<bits_num))>0?1:0;
		bits_num--;
	}
	j=0;
	for(i=0;i<128;i++){
		switch(j){
			case 0:
				hex_num+=global_addr_bin[i]*8;
				break;
			case 1:
				hex_num+=global_addr_bin[i]*4;
				break;
			case 2:
				hex_num+=global_addr_bin[i]*2;
				break;
			case 3:
				hex_num+=global_addr_bin[i]*1;
				sprintf(global_addr,"%s%x",global_addr,hex_num);
				if((((i+1)%16)==0)&&(i!=127))
					sprintf(global_addr,"%s:",global_addr);
				j=-1;
				hex_num=0;
		}
		j++;
	}
	inet_pton(AF_INET6,global_addr,&global_in6addr);
	if(new_ip6addr_head->next){
		if(memcmp(&(new_ip6addr_head->next->ip6_in6addr),
				&global_in6addr,sizeof(struct in6_addr)))
			ip6addr_config_remove(new_ip6addr_head->next,new_ip6addr_head);	
		else
			return;
	}
	sprintf(global_addr,"%s/%d",global_addr,prefix_len);
	ip6addr_config_add(global_addr);
	printf("config global addr:%s to wireless card.\n",global_addr);
}
int to_my_address(struct in6_addr dest_addr)
{
	struct ip6_addr *curr;
	curr=new_ip6addr_head;
	while(curr){
		if(memcmp(&(curr->ip6_in6addr),&dest_addr,sizeof(struct in6_addr))==0)
			return 1;
		curr=curr->next;
	}
	return 0;
}