UDPspeeder/misc.cpp

/*
 * misc.cpp
 *
 *  Created on: Oct 26, 2017
 *      Author: root
 */


#include "misc.h"


char fifo_file[1000]="";

int mtu_warn=1350;

int disable_mtu_warn=1;
int disable_fec=0;
int disable_checksum=0;

int debug_force_flush_fec=0;


int jitter_min=0*1000;
int jitter_max=0*1000;

int output_interval_min=0*1000;
int output_interval_max=0*1000;

int fix_latency=0;


address_t local_addr,remote_addr;
address_t *out_addr=0;
char *out_interface=0;
//u32_t local_ip_uint32,remote_ip_uint32=0;
//char local_ip[100], remote_ip[100];
//int local_port = -1, remote_port = -1;

conn_manager_t conn_manager;
delay_manager_t delay_manager;
fd_manager_t fd_manager;

int time_mono_test=0;

int delay_capacity=0;


char sub_net[100]="10.22.22.0";
u32_t sub_net_uint32=0;

char tun_dev[100]="";


int keep_reconnect=0;

int tun_mtu=1500;

int mssfix=default_mtu;

int manual_set_tun=0;
int persist_tun=0;

char rs_par_str[rs_str_len]="20:10";


int from_normal_to_fec(conn_info_t & conn_info,char *data,int len,int & out_n,char **&out_arr,int *&out_len,my_time_t *&out_delay)
{

	static my_time_t out_delay_buf[max_fec_packet_num+100]={0};
	//static int out_len_buf[max_fec_packet_num+100]={0};
	//static int counter=0;
	out_delay=out_delay_buf;
	//out_len=out_len_buf;
	inner_stat_t &inner_stat=conn_info.stat.normal_to_fec;
	if(disable_fec)
	{
		if(data==0)
		{
			out_n=0;
			return 0;
		}
		//assert(data!=0);
		inner_stat.input_packet_num++;
		inner_stat.input_packet_size+=len;
		inner_stat.output_packet_num++;
		inner_stat.output_packet_size+=len;

		out_n=1;
		static char *data_static;
		data_static=data;
		static int len_static;
		len_static=len;
		out_arr=&data_static;
		out_len=&len_static;
		out_delay[0]=0;

	}
	else
	{
		if(data!=0)
		{
			inner_stat.input_packet_num++;
			inner_stat.input_packet_size+=len;
		}
		//counter++;

		conn_info.fec_encode_manager.input(data,len);

		//if(counter%5==0)
			//conn_info.fec_encode_manager.input(0,0);

		//int n;
		//char **s_arr;
		//int s_len;


		conn_info.fec_encode_manager.output(out_n,out_arr,out_len);

		if(out_n>0)
		{
			my_time_t common_latency=0;
			my_time_t first_packet_time=conn_info.fec_encode_manager.get_first_packet_time();

			if(fix_latency==1&&conn_info.fec_encode_manager.get_type()==0)
			{
				my_time_t current_time=get_current_time_us();
				my_time_t tmp;
				assert(first_packet_time!=0);
				//mylog(log_info,"current_time=%llu first_packlet_time=%llu   fec_pending_time=%llu\n",current_time,first_packet_time,(my_time_t)fec_pending_time);
				if((my_time_t)conn_info.fec_encode_manager.get_pending_time() >=(current_time - first_packet_time))
				{
					tmp=(my_time_t)conn_info.fec_encode_manager.get_pending_time()-(current_time - first_packet_time);
					//mylog(log_info,"tmp=%llu\n",tmp);
				}
				else
				{
					tmp=0;
					//mylog(log_info,"0\n");
				}
				common_latency+=tmp;
			}

			common_latency+=random_between(jitter_min,jitter_max);

			out_delay_buf[0]=common_latency;

			for(int i=1;i<out_n;i++)
			{
				out_delay_buf[i]=out_delay_buf[i-1]+ (my_time_t)( random_between(output_interval_min,output_interval_max)/(out_n-1)  );
			}
		}


		if(out_n>0)
		{
			log_bare(log_trace,"seq= %u ",read_u32(out_arr[0]));
		}
		for(int i=0;i<out_n;i++)
		{
			inner_stat.output_packet_num++;
			inner_stat.output_packet_size+=out_len[i];

			log_bare(log_trace,"%d ",out_len[i]);

		}

		log_bare(log_trace,"\n");

	}

	mylog(log_trace,"from_normal_to_fec input_len=%d,output_n=%d\n",len,out_n);


	//for(int i=0;i<n;i++)
	//{
		//delay_send(0,dest,s_arr[i],s_len);
	//}
	//delay_send(0,dest,data,len);
	//delay_send(1000*1000,dest,data,len);
	return 0;
}
int from_fec_to_normal(conn_info_t & conn_info,char *data,int len,int & out_n,char **&out_arr,int *&out_len,my_time_t *&out_delay)
{
	static my_time_t out_delay_buf[max_blob_packet_num+100]={0};
	out_delay=out_delay_buf;
	inner_stat_t &inner_stat=conn_info.stat.fec_to_normal;
	if(disable_fec)
	{
		assert(data!=0);
		inner_stat.input_packet_num++;
		inner_stat.input_packet_size+=len;
		inner_stat.output_packet_num++;
		inner_stat.output_packet_size+=len;

		if(data==0)
		{
			out_n=0;
			return 0;
		}
		out_n=1;
		static char *data_static;
		data_static=data;
		static int len_static;
		len_static=len;
		out_arr=&data_static;
		out_len=&len_static;
		out_delay[0]=0;
	}
	else
	{

		if(data!=0)
		{
			inner_stat.input_packet_num++;
			inner_stat.input_packet_size+=len;
		}

		conn_info.fec_decode_manager.input(data,len);

		//int n;char ** s_arr;int* len_arr;
		conn_info.fec_decode_manager.output(out_n,out_arr,out_len);
		for(int i=0;i<out_n;i++)
		{
			out_delay_buf[i]=0;

			inner_stat.output_packet_num++;
			inner_stat.output_packet_size+=out_len[i];
		}


	}

	mylog(log_trace,"from_fec_to_normal input_len=%d,output_n=%d,input_seq=%u\n",len,out_n,read_u32(data));


//	printf("<n:%d>",n);
	/*
	for(int i=0;i<n;i++)
	{
		delay_send(0,dest,s_arr[i],len_arr[i]);
		//s_arr[i][len_arr[i]]=0;
		//printf("<%s>\n",s_arr[i]);
	}*/
	//my_send(dest,data,len);
	return 0;
}


int delay_send(my_time_t delay,const dest_t &dest,char *data,int len)
{
	//int rand=random()%100;
	//mylog(log_info,"rand = %d\n",rand);

	if (dest.cook&&random_drop != 0) {
		if (get_fake_random_number() % 10000 < (u32_t) random_drop) {
			return 0;
		}
	}
	return delay_manager.add(delay,dest,data,len);;
}

int print_parameter()
{
	mylog(log_info,"jitter_min=%d jitter_max=%d output_interval_min=%d output_interval_max=%d fec_timeout=%d fec_mtu=%d fec_queue_len=%d fec_mode=%d\n",
			jitter_min/1000,jitter_max/1000,output_interval_min/1000,output_interval_max/1000,g_fec_par.timeout/1000,g_fec_par.mtu,g_fec_par.queue_len,g_fec_par.mode);
	mylog(log_info,"fec_str=%s\n",rs_par_str);
	mylog(log_info,"fec_inner_parameter=%s\n",g_fec_par.rs_to_str());
	return 0;
}
int handle_command(char *s)
{
	int len=strlen(s);
	while(len>=1&&s[len-1]=='\n')
		s[len-1]=0;
	mylog(log_info,"got data from fifo,len=%d,s=[%s]\n",len,s);
	int a=-1,b=-1;
	if(strncmp(s,"fec",strlen("fec"))==0)
	{
		mylog(log_info,"got command [fec]\n");
		char tmp_str[max_fec_packet_num*10+100];
		fec_parameter_t tmp_par;
		sscanf(s,"fec %s",tmp_str);
		/*
		if(a<1||b<0||a+b>254)
		{
			mylog(log_warn,"invaild value\n");
			return -1;
		}*/
		int ret=tmp_par.rs_from_str(tmp_str);
		if(ret!=0)
		{
			mylog(log_warn,"failed to parse [%s]\n",tmp_str);
			return -1;
		}
		int version=g_fec_par.version;
		g_fec_par.clone(tmp_par);
		g_fec_par.version=version;
		g_fec_par.version++;
		strcpy(rs_par_str,tmp_str);
		//g_fec_data_num=a;
		//g_fec_redundant_num=b;
	}
	else if(strncmp(s,"mtu",strlen("mtu"))==0)
	{
		mylog(log_info,"got command [mtu]\n");
		sscanf(s,"mtu %d",&a);
		if(a<100||a>2000)
		{
			mylog(log_warn,"invaild value\n");
			return -1;
		}
		g_fec_par.mtu=a;
	}
	else if(strncmp(s,"queue-len",strlen("queue-len"))==0)
	{
		mylog(log_info,"got command [queue-len]\n");
		sscanf(s,"queue-len %d",&a);
		if(a<1||a>10000)
		{
			mylog(log_warn,"invaild value\n");
			return -1;
		}
		g_fec_par.queue_len=a;
	}
	else if(strncmp(s,"mode",strlen("mode"))==0)
	{
		mylog(log_info,"got command [mode]\n");
		sscanf(s,"mode %d",&a);
		if(a!=0&&a!=1)
		{
			mylog(log_warn,"invaild value\n");
			return -1;
		}
		if(g_fec_par.mode!=a)
		{
			g_fec_par.mode=a;

			assert(g_fec_par.rs_from_str(rs_par_str)==0); //re parse rs_par_str,not necessary at the moment, for futher use
			g_fec_par.version++;
		}
	}
	else if(strncmp(s,"timeout",strlen("timeout"))==0)
	{
		mylog(log_info,"got command [timeout]\n");
		sscanf(s,"timeout %d",&a);
		if(a<0||a>1000)
		{
			mylog(log_warn,"invaild value\n");
			return -1;
		}
		g_fec_par.timeout=a*1000;
	}
	else
	{
		mylog(log_info,"unknown command\n");
	}
	print_parameter();

	return 0;
}

static void empty_cb(struct ev_loop *loop, struct ev_timer *watcher, int revents)
{

}
int unit_test()
{

	{
		union test_t
		{
			u64_t u64;
			char arry[8];
		}test111;

		assert((void*)&test111.u64==(void*)&test111.arry[0]);
		//printf("%llx,%llx\n",&ttt.u64,&ttt.arry[0]);

//		printf("%lld\n",get_fake_random_number_64());
//		printf("%lld\n",get_fake_random_number_64());
//		printf("%lld\n",get_fake_random_number_64());

//		printf("%x\n",get_fake_random_number());
//		printf("%x\n",get_fake_random_number());
//		printf("%x\n",get_fake_random_number());

		char buf[10];
		get_fake_random_chars(buf,10);
		for(int i=0;i<10;i++)
			printf("<%d>",(int)buf[i]);
		printf("\n");

		get_fake_random_chars(buf,10);
		for(int i=0;i<10;i++)
			printf("<%d>",(int)buf[i]);
		printf("\n");
	}


	int i,j,k;
	void *code=fec_new(3,6);
	char arr[6][100]=
	{
		"aaa","bbb","ccc"
		,"ddd","eee","fff"
	};
	char *data[6];
	for(i=0;i<6;i++)
	{
		data[i]=arr[i];
	}
	rs_encode2(3,6,data,3);
	//printf("%d %d",(int)(unsigned char)arr[5][0],(int)('a'^'b'^'c'^'d'^'e'));

	for(i=0;i<6;i++)
	{
		printf("<%s>",data[i]);
	}

	data[0]=0;
	//data[1]=0;
	//data[5]=0;

	int ret=rs_decode2(3,6,data,3);
	printf("ret:%d\n",ret);

	for(i=0;i<6;i++)
	{
		printf("<%s>",data[i]);
	}
	fec_free(code);


	char arr2[6][100]=
	{
		"aaa11111","","ccc333333333"
		,"ddd444","eee5555","ff6666"
	};
	blob_encode_t blob_encode;
	for(int i=0;i<6;i++)
		blob_encode.input(arr2[i],strlen(arr2[i]));

	char **output;
	int shard_len;
	blob_encode.output(7,output,shard_len);


	printf("<shard_len:%d>",shard_len);
	blob_decode_t blob_decode;
	for(int i=0;i<7;i++)
	{
		blob_decode.input(output[i],shard_len);
	}

	char **decode_output;
	int * len_arr;
	int num;


	ret=blob_decode.output(num,decode_output,len_arr);

	printf("<num:%d,ret:%d>\n",num,ret);
	for(int i=0;i<num;i++)
	{
		char buf[1000]={0};
		memcpy(buf,decode_output[i],len_arr[i]);
		printf("<%d:%s>",len_arr[i],buf);
	}
	printf("\n");
	static fec_encode_manager_t fec_encode_manager;
	static fec_decode_manager_t fec_decode_manager;

	//dynamic_update_fec=0;

	fec_encode_manager.set_loop_and_cb(ev_default_loop(0),empty_cb);

	{

		string a = "11111";
		string b = "22";
		string c = "33333333";

		fec_encode_manager.input((char *) a.c_str(), a.length());
		fec_encode_manager.input((char *) b.c_str(), b.length());
		fec_encode_manager.input((char *) c.c_str(), c.length());
		fec_encode_manager.input(0, 0);

		int n;
		char **s_arr;
		int *len;


		fec_encode_manager.output(n,s_arr,len);
		printf("<n:%d,len:%d>",n,len[0]);

		for(int i=0;i<n;i++)
		{
			fec_decode_manager.input(s_arr[i],len[i]);
		}

		{
			int n;char ** s_arr;int* len_arr;
			fec_decode_manager.output(n,s_arr,len_arr);
			printf("<n:%d>",n);
			for(int i=0;i<n;i++)
			{
				s_arr[i][len_arr[i]]=0;
				printf("<%s>\n",s_arr[i]);
			}
		}


	}

	{
		string a = "aaaaaaa";
		string b = "bbbbbbbbbbbbb";
		string c = "ccc";


		fec_encode_manager.input((char *) a.c_str(), a.length());
		fec_encode_manager.input((char *) b.c_str(), b.length());
		fec_encode_manager.input((char *) c.c_str(), c.length());
		fec_encode_manager.input(0, 0);

		int n;
		char **s_arr;
		int * len;


		fec_encode_manager.output(n,s_arr,len);
		printf("<n:%d,len:%d>",n,len[0]);

		for(int i=0;i<n;i++)
		{
			if(i==1||i==3||i==5||i==0)
			fec_decode_manager.input(s_arr[i],len[i]);
		}

		{
			int n;char ** s_arr;int* len_arr;
			fec_decode_manager.output(n,s_arr,len_arr);
			printf("<n:%d>",n);
			for(int i=0;i<n;i++)
			{
				s_arr[i][len_arr[i]]=0;
				printf("<%s>\n",s_arr[i]);
			}
		}
	}

	printf("ok here.\n");
	for(int i=0;i<10;i++)
	{
		string a = "aaaaaaaaaaaaaaaaaaaaaaa";
		string b = "bbbbbbbbbbbbb";
		string c = "cccccccccccccccccc";



		printf("======\n");
		int n;
		char **s_arr;
		int * len;
		fec_decode_manager.output(n,s_arr,len);

		//fec_encode_manager.reset_fec_parameter(3,2,g_fec_mtu,g_fec_queue_len,g_fec_timeout,1);

		fec_parameter_t &fec_par=fec_encode_manager.get_fec_par();
		fec_par.mtu=g_fec_par.mtu;
		fec_par.queue_len=g_fec_par.queue_len;
		fec_par.timeout=g_fec_par.timeout;
		fec_par.mode=1;
		fec_par.rs_from_str((char *)"3:2");

		fec_encode_manager.input((char *) a.c_str(), a.length());
		fec_encode_manager.output(n,s_arr,len);

		printf("n=<%d>\n",n);
		assert(n==1);

		fec_decode_manager.input(s_arr[0],len[0]);

		fec_decode_manager.output(n,s_arr,len);
		assert(n==1);
		printf("%s\n",s_arr[0]);

		fec_encode_manager.input((char *) b.c_str(), b.length());
		fec_encode_manager.output(n,s_arr,len);
		assert(n==1);
		//fec_decode_manager.input(s_arr[0],len[0]);


		fec_encode_manager.input((char *) c.c_str(), c.length());
		fec_encode_manager.output(n,s_arr,len);

		assert(n==3);

		fec_decode_manager.input(s_arr[0],len[0]);
		//printf("n=%d\n",n);


		{
			int n;
			char **s_arr;
			int * len;
			fec_decode_manager.output(n,s_arr,len);
			assert(n==1);
			printf("%s\n",s_arr[0]);
		}

		fec_decode_manager.input(s_arr[1],len[1]);

		{
			int n;
			char **s_arr;
			int * len;
			fec_decode_manager.output(n,s_arr,len);
			assert(n==1);
			printf("n=%d\n",n);
			s_arr[0][len[0]]=0;
			printf("%s\n",s_arr[0]);
		}

	}

	myexit(0);
	return 0;
}


void process_arg(int argc, char *argv[])
{
	int is_client=0,is_server=0;
	int i, j, k;
	int opt;
    static struct option long_options[] =
      {
		{"log-level", required_argument,    0, 1},
		{"log-position", no_argument,    0, 1},
		{"disable-color", no_argument,    0, 1},
		{"enable-color", no_argument,    0, 1},
		{"disable-filter", no_argument,    0, 1},
		{"disable-fec", no_argument,    0, 1},
		{"disable-obscure", no_argument,    0, 1},
		{"disable-xor", no_argument,    0, 1},
		{"disable-checksum", no_argument,    0, 1},
		{"fix-latency", no_argument,    0, 1},
		{"sock-buf", required_argument,    0, 1},
		{"random-drop", required_argument,    0, 1},
		{"report", required_argument,    0, 1},
		{"delay-capacity", required_argument,    0, 1},
		{"mtu", required_argument,    0, 1},
		{"mode", required_argument,   0,1},
		{"timeout", required_argument,   0,1},
		{"decode-buf", required_argument,   0,1},
		{"queue-len", required_argument,   0,'q'},
		{"fec", required_argument,   0,'f'},
		{"jitter", required_argument,   0,'j'},
		{"out-addr", required_argument,   0,1},
		{"out-interface", required_argument,    0, 1},
		{"key", required_argument,   0,'k'},
		{"header-overhead", required_argument,    0, 1},
		//{"debug-fec", no_argument,    0, 1},
		{"debug-fec-enc", no_argument,    0, 1},
		{"debug-fec-dec", no_argument,    0, 1},
		{"fifo", required_argument,    0, 1},
		{"sub-net", required_argument,    0, 1},
		{"tun-dev", required_argument,    0, 1},
		{"tun-mtu", required_argument,    0, 1},
		{"mssfix", required_argument,    0, 1},
		{"keep-reconnect", no_argument,    0, 1},
		{"persist-tun", no_argument,    0, 1},
		{"manual-set-tun", no_argument,    0, 1},
		{"interval", required_argument,   0,'i'},
		{NULL, 0, 0, 0}
      };
    int option_index = 0;
    assert(g_fec_par.rs_from_str(rs_par_str)==0);

	for (i = 0; i < argc; i++)
	{
		if(strcmp(argv[i],"--unit-test")==0)
		{
			unit_test();
			myexit(0);
		}
	}

	for (i = 0; i < argc; i++)
	{
		if(strcmp(argv[i],"--log-level")==0)
		{
			if(i<argc -1)
			{
				sscanf(argv[i+1],"%d",&log_level);
				if(0<=log_level&&log_level<log_end)
				{
				}
				else
				{
					log_bare(log_fatal,"invalid log_level\n");
					myexit(-1);
				}
			}
		}
		if(strcmp(argv[i],"--enable-color")==0)
		{
			enable_log_color=1;
		}
		if(strcmp(argv[i],"--disable-color")==0)
		{
			enable_log_color=0;
		}
	}

    mylog(log_info,"argc=%d ", argc);

	for (i = 0; i < argc; i++) {
		log_bare(log_info, "%s ", argv[i]);
	}
	log_bare(log_info, "\n");


	int no_l = 1, no_r = 1;
	while ((opt = getopt_long(argc, argv, "l:r:hcsk:j:f:p:n:i:q:",long_options,&option_index)) != -1)
	{
		//string opt_key;
		//opt_key+=opt;
		switch (opt)
		{
		case 'k':
			sscanf(optarg,"%s\n",key_string);
			mylog(log_debug,"key=%s\n",key_string);
			if(strlen(key_string)==0)
			{
				mylog(log_fatal,"key len=0??\n");
				myexit(-1);
			}
			break;
		case 'j':
			if (strchr(optarg, ':') == 0)
			{
				int jitter;
				sscanf(optarg,"%d\n",&jitter);
				if(jitter<0 ||jitter>1000*10)
				{
					mylog(log_fatal,"jitter must be between 0 and 10,000(10 second)\n");
					myexit(-1);
				}
				jitter_min=0;
				jitter_max=jitter;


			}
			else
			{
				sscanf(optarg,"%d:%d\n",&jitter_min,&jitter_max);
				if(jitter_min<0 ||jitter_max<0||jitter_min>jitter_max)
				{
					mylog(log_fatal," must satisfy  0<=jmin<=jmax\n");
					myexit(-1);
				}
			}
			jitter_min*=1000;
			jitter_max*=1000;
			break;
		case 'i':
			if (strchr(optarg, ':') == 0)
			{
				int output_interval=-1;
				sscanf(optarg,"%d\n",&output_interval);
				if(output_interval<0||output_interval>1000*10)
				{
					mylog(log_fatal,"output_interval must be between 0 and 10,000(10 second)\n");
					myexit(-1);
				}
				output_interval_min=output_interval_max=output_interval;
			}
			else
			{
				sscanf(optarg,"%d:%d\n",&output_interval_min,&output_interval_max);
				if(output_interval_min<0 ||output_interval_max<0||output_interval_min>output_interval_max)
				{
					mylog(log_fatal," must satisfy  0<=output_interval_min<=output_interval_max\n");
					myexit(-1);
				}
			}
			output_interval_min*=1000;
			output_interval_max*=1000;
			break;
		case 'f':
			if (strchr(optarg, ':') == 0)
			{
				mylog(log_fatal,"invalid format for f");
				myexit(-1);
			}
			else
			{
				strcpy(rs_par_str,optarg);
				//sscanf(optarg,"%d:%d\n",&g_fec_data_num,&g_fec_redundant_num);
				/*
				if(g_fec_data_num<1 ||g_fec_redundant_num<0||g_fec_data_num+g_fec_redundant_num>254)
				{
					mylog(log_fatal,"fec_data_num<1 ||fec_redundant_num<0||fec_data_num+fec_redundant_num>254\n");
					myexit(-1);
				}*/
			}
			break;
		case 'q':
			sscanf(optarg,"%d",&g_fec_par.queue_len);
			if(g_fec_par.queue_len<1||g_fec_par.queue_len>10000)
			{

					mylog(log_fatal,"fec_pending_num should be between 1 and 10000\n");
					myexit(-1);
			}
			break;
		case 'c':
			is_client = 1;
			break;
		case 's':
			is_server = 1;
			break;
		case 'l':
			no_l = 0;
			local_addr.from_str(optarg);
			break;
		case 'r':
			no_r = 0;
			remote_addr.from_str(optarg);
			break;
		case 'h':
			break;
		case 1:
			if(strcmp(long_options[option_index].name,"log-level")==0)
			{
			}
			else if(strcmp(long_options[option_index].name,"disable-filter")==0)
			{
				disable_replay_filter=1;
				//enable_log_color=0;
			}
			else if(strcmp(long_options[option_index].name,"disable-color")==0)
			{
				//enable_log_color=0;
			}
			else if(strcmp(long_options[option_index].name,"enable-color")==0)
			{
				//enable_log_color=0;
			}
			else if(strcmp(long_options[option_index].name,"disable-fec")==0)
			{
				disable_fec=1;
			}
			else if(strcmp(long_options[option_index].name,"disable-obscure")==0)
			{
				mylog(log_info,"obscure disabled\n");
				disable_obscure=1;
			}
			else if(strcmp(long_options[option_index].name,"disable-xor")==0)
			{
				mylog(log_info,"xor disabled\n");
				disable_xor=1;
			}
			else if(strcmp(long_options[option_index].name,"disable-checksum")==0)
			{
				disable_checksum=1;
				mylog(log_warn,"checksum disabled\n");
			}
			else if(strcmp(long_options[option_index].name,"fix-latency")==0)
			{
				mylog(log_info,"fix-latency enabled\n");
				fix_latency=1;
			}

			else if(strcmp(long_options[option_index].name,"log-position")==0)
			{
				enable_log_position=1;
			}
			else if(strcmp(long_options[option_index].name,"random-drop")==0)
			{
				sscanf(optarg,"%d",&random_drop);
				if(random_drop<0||random_drop>10000)
				{
					mylog(log_fatal,"random_drop must be between 0 10000 \n");
					myexit(-1);
				}
				mylog(log_info,"random_drop=%d\n",random_drop);
			}
			else if(strcmp(long_options[option_index].name,"delay-capacity")==0)
			{
				sscanf(optarg,"%d",&delay_capacity);

				if(delay_capacity<0)
				{
					mylog(log_fatal,"delay_capacity must be >=0 \n");
					myexit(-1);
				}
			}
			else if(strcmp(long_options[option_index].name,"report")==0)
			{
				sscanf(optarg,"%d",&report_interval);

				if(report_interval<=0)
				{
					mylog(log_fatal,"report_interval must be >0 \n");
					myexit(-1);
				}
			}
			else if(strcmp(long_options[option_index].name,"sock-buf")==0)
			{
				int tmp=-1;
				sscanf(optarg,"%d",&tmp);
				if(10<=tmp&&tmp<=10*1024)
				{
					socket_buf_size=tmp*1024;
				}
				else
				{
					mylog(log_fatal,"sock-buf value must be between 1 and 10240 (kbyte) \n");
					myexit(-1);
				}
			}
			else if(strcmp(long_options[option_index].name,"decode-buf")==0)
			{
				sscanf(optarg,"%d",&fec_buff_num);
				if(fec_buff_num<300 || fec_buff_num>20000)
				{
					mylog(log_fatal,"decode-buf value must be between 300 and 20000 (kbyte) \n");
					myexit(-1);
				}
				mylog(log_info,"decode-buf=%d\n",fec_buff_num);
			}
			else if(strcmp(long_options[option_index].name,"mode")==0)
			{
				sscanf(optarg,"%d",&g_fec_par.mode);
				if(g_fec_par.mode!=0&&g_fec_par.mode!=1)
				{
					mylog(log_fatal,"mode should be 0 or 1\n");
					myexit(-1);
				}
			}
			else if(strcmp(long_options[option_index].name,"mtu")==0)
			{
				sscanf(optarg,"%d",&g_fec_par.mtu);
				if(g_fec_par.mtu<100||g_fec_par.mtu>2000)
				{
					mylog(log_fatal,"fec_mtu should be between 100 and 2000\n");
					myexit(-1);
				}
			}
			else if(strcmp(long_options[option_index].name,"out-addr")==0)
			{
			    //has_b = true;
			    mylog(log_debug,"out-addr=%s\n",optarg);
			    out_addr=new address_t();
			    out_addr->from_str(optarg);
			}
			else if(strcmp(long_options[option_index].name,"out-interface")==0)
			{
			    out_interface=new char[strlen(optarg)+10];
				sscanf(optarg,"%s\n",out_interface);
				mylog(log_debug,"out-interface=%s\n",out_interface);
				if(strlen(out_interface)==0)
				{
					mylog(log_fatal,"out_interface string len=0??\n");
					myexit(-1);
				}
			}
			else if(strcmp(long_options[option_index].name,"timeout")==0)
			{
				sscanf(optarg,"%d",&g_fec_par.timeout);
				if(g_fec_par.timeout<0||g_fec_par.timeout>1000)
				{

						mylog(log_fatal,"fec_pending_time should be between 0 and 1000(1s)\n");
						myexit(-1);
				}
				g_fec_par.timeout*=1000;
			}
			else if(strcmp(long_options[option_index].name,"debug-fec-enc")==0)
			{
				debug_fec_enc=1;
				mylog(log_info,"debug_fec_enc enabled\n");
			}
			else if(strcmp(long_options[option_index].name,"debug-fec-dec")==0)
			{
				debug_fec_dec=1;
				mylog(log_info,"debug_fec_dec enabled\n");
			}
			else if(strcmp(long_options[option_index].name,"fifo")==0)
			{
				sscanf(optarg,"%s",fifo_file);

				mylog(log_info,"fifo_file =%s \n",fifo_file);
			}
			else if(strcmp(long_options[option_index].name,"keep-reconnect")==0)
			{
				keep_reconnect=1;
				mylog(log_info,"keep_reconnect enabled\n");
			}
			else if(strcmp(long_options[option_index].name,"manual-set-tun")==0)
			{
				manual_set_tun=1;
				mylog(log_info,"manual_set_tun enabled\n");
			}
			else if(strcmp(long_options[option_index].name,"persist-tun")==0)
			{
				persist_tun=1;
				mylog(log_info,"persist_tun enabled\n");
			}
			else if(strcmp(long_options[option_index].name,"sub-net")==0)
			{
				sscanf(optarg,"%s",sub_net);
				mylog(log_info,"sub_net %s\n",sub_net);

			}
			else if(strcmp(long_options[option_index].name,"tun-dev")==0)
			{
				sscanf(optarg,"%s",tun_dev);
				mylog(log_info,"tun_dev=%s\n",tun_dev);

			}
			else if(strcmp(long_options[option_index].name,"tun-mtu")==0)
			{
				sscanf(optarg,"%d",&tun_mtu);
				mylog(log_warn,"changed tun_mtu,tun_mtu=%d\n",tun_mtu);
			}
			else if(strcmp(long_options[option_index].name,"header-overhead")==0)
			{
				sscanf(optarg,"%d",&header_overhead);
				mylog(log_warn,"changed header_overhead,header_overhead=%d\n",header_overhead);
			}
			else if(strcmp(long_options[option_index].name,"mssfix")==0)
			{
				sscanf(optarg,"%d",&mssfix);
				mylog(log_warn,"mssfix=%d\n",mssfix);
			}
			else
			{
				mylog(log_fatal,"unknown option\n");
				myexit(-1);
			}
			break;
		default:
			mylog(log_fatal,"unknown option <%x>", opt);
			myexit(-1);
		}
	}

	if (is_client == 0 && is_server == 0)
	{
		mylog(log_fatal,"-s -c hasnt been set\n");
		myexit(-1);
	}
	if (is_client == 1 && is_server == 1)
	{
		mylog(log_fatal,"-s -c cant be both set\n");
		myexit(-1);
	}
	if(is_client==1)
	{
		program_mode=client_mode;
	}
	else
	{
		program_mode=server_mode;
	}


	if(working_mode==tunnel_mode)
	{
		if (no_l)
			mylog(log_fatal,"error: -l not found\n");
		if (no_r)
			mylog(log_fatal,"error: -r not found\n");
		if (no_l || no_r)
			myexit(-1);
	}
	else if(working_mode==tun_dev_mode)
	{
		if(program_mode==client_mode&&no_r)
		{
			mylog(log_fatal,"error: -r not found\n");
			myexit(-1);
		}
		else if(program_mode==server_mode&&no_l)
		{
			mylog(log_fatal,"error: -l not found\n");
			myexit(-1);
		}
	}

	int ret=g_fec_par.rs_from_str(rs_par_str);
	if(ret!=0)
	{
		mylog(log_fatal,"failed to parse [%s]\n",rs_par_str);
		myexit(-1);
	}

	print_parameter();

}