init

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Yu Wang (wangyucn at gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

main.cpp

@@ -0,0 +1,810 @@
+#include<stdio.h>
+#include<string.h>
+#include<sys/socket.h>
+#include<arpa/inet.h>
+#include<stdlib.h>
+#include<getopt.h>
+#include <unistd.h>
+#include<errno.h>
+
+#include <fcntl.h>
+//#include"aes.h"
+
+#include <sys/epoll.h>
+#include <sys/wait.h>
+
+#include<map>
+#include<string>
+#include<vector>
+using namespace std;
+
+#include <sys/time.h>
+#include <time.h>
+
+#include <sys/timerfd.h>
+
+
+typedef unsigned long long u64_t;   //this works on most platform,avoid using the PRId64
+typedef long long i64_t;
+
+typedef unsigned int u32_t;
+typedef int i32_t;
+
+const u32_t anti_replay_window_size=1000;
+typedef u64_t anti_replay_seq_t;
+int disable_anti_replay=0;
+int dup_num=3;
+int dup_delay=5000;   //1000 = 1ms
+int iv_min=2;
+int iv_max=30;//< 256;
+int random_number_fd=-1;
+
+int remote_fd=-1;
+int local_fd=-1;
+int is_client = 0, is_server = 0;
+
+
+int VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV;
+void setnonblocking(int sock) {
+	int opts;
+	opts = fcntl(sock, F_GETFL);
+
+	if (opts < 0) {
+		perror("fcntl(sock,GETFL)");
+		exit(1);
+	}
+
+	opts = opts | O_NONBLOCK;
+	if (fcntl(sock, F_SETFL, opts) < 0) {
+		perror("fcntl(sock,SETFL,opts)");
+		exit(1);
+	}
+}
+void init_random_number_fd()
+{
+
+	random_number_fd=open("/dev/urandom",O_RDONLY);
+
+	if(random_number_fd==-1)
+	{
+		printf("error open /dev/urandom\n");
+	}
+	setnonblocking(random_number_fd);
+}
+void get_true_random_chars(char * s,int len)
+{
+	int size=read(random_number_fd,s,len);
+	if(size!=len)
+	{
+		printf("get random number failed\n");
+		exit(-1);
+	}
+}
+u32_t get_true_random_number()
+{
+	u32_t ret;
+	int size=read(random_number_fd,&ret,sizeof(ret));
+	if(size!=sizeof(ret))
+	{
+		printf("get random number failed %d\n",size);
+		exit(-1);
+	}
+	return ret;
+}
+u64_t ntoh64(u64_t a)
+{
+	if(__BYTE_ORDER == __LITTLE_ENDIAN)
+	{
+		return __bswap_64( a);
+	}
+	else return a;
+
+}
+u64_t hton64(u64_t a)
+{
+	if(__BYTE_ORDER == __LITTLE_ENDIAN)
+	{
+		return __bswap_64( a);
+	}
+	else return a;
+}
+struct anti_replay_t
+{
+	u64_t max_packet_received;
+	char window[anti_replay_window_size];
+	anti_replay_seq_t anti_replay_seq;
+	anti_replay_seq_t get_new_seq_for_send()
+	{
+		return anti_replay_seq++;
+	}
+	anti_replay_t()
+	{
+		max_packet_received=0;
+		anti_replay_seq=0;//random first seq
+		//memset(window,0,sizeof(window)); //not necessary
+	}
+	void re_init()
+	{
+		max_packet_received=0;
+		//memset(window,0,sizeof(window));
+	}
+
+	int is_vaild(u64_t seq)
+	{
+		if(disable_anti_replay) return 1;
+		//if(disabled) return 0;
+
+		if(seq==max_packet_received) return 0;
+		else if(seq>max_packet_received)
+		{
+			if(seq-max_packet_received>=anti_replay_window_size)
+			{
+				memset(window,0,sizeof(window));
+				window[seq%anti_replay_window_size]=1;
+			}
+			else
+			{
+				for (u64_t i=max_packet_received+1;i<seq;i++)
+					window[i%anti_replay_window_size]=0;
+				window[seq%anti_replay_window_size]=1;
+			}
+			max_packet_received=seq;
+			return 1;
+		}
+		else if(seq<max_packet_received)
+		{
+			if(max_packet_received-seq>=anti_replay_window_size) return 0;
+			else
+			{
+				if (window[seq%anti_replay_window_size]==1) return 0;
+				else
+				{
+					window[seq%anti_replay_window_size]=1;
+					return 1;
+				}
+			}
+		}
+
+
+		return 0; //for complier check
+	}
+}anti_replay;
+
+struct my_time:timespec
+{
+    bool operator <(const my_time& other)const
+     {
+        if(tv_sec<other.tv_sec) return true;
+        else if(tv_sec>other.tv_sec) return false;
+        else return tv_nsec<other.tv_nsec;
+     }
+    bool operator ==(const my_time& other)const
+     {
+        if(tv_sec==other.tv_sec&&tv_nsec==other.tv_nsec) return true;
+        return false;
+     }
+};
+struct delay_data
+{
+	int fd;
+	int times_left;
+	char * data;
+	int len;
+};
+int timer_fd;
+
+multimap<my_time,delay_data> delay_mp;
+
+my_time time_after_delay(my_time time)
+{
+	time.tv_nsec+=dup_delay*1000ll;  //8ms
+	if(time.tv_nsec>=1000*1000*1000ll )
+	{
+		time.tv_nsec-=1000*1000*1000ll;
+		time.tv_sec+=1;
+	}
+	return time;
+}
+int add_to_delay_mp(int fd,int times_left,char * buf,int len)
+{
+	delay_data tmp;
+	tmp.data = buf;
+	tmp.fd = fd;
+	tmp.times_left = times_left;
+	tmp.len = len;
+
+	my_time tmp_time;
+	clock_gettime(CLOCK_MONOTONIC, &tmp_time);
+	tmp_time=time_after_delay(tmp_time);
+	delay_mp.insert(make_pair(tmp_time,tmp));
+	return 0;
+}
+int add_and_new(int fd,int times_left,char * buf,int len)
+{
+	char * str= (char *)malloc(len);
+	memcpy(str,buf,len);
+	add_to_delay_mp(fd,times_left,str,len);
+	return 0;
+}
+
+char local_address[100], remote_address[100];
+int local_port = -1, remote_port = -1;
+//char keya[100], keyb[100];
+//int dup_a = 1, dup_b = 1;
+//char iv[100];
+
+const int buf_len = 20480;
+
+void handler(int num) {
+	int status;
+	int pid;
+	while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
+		if (WIFEXITED(status)) {
+			//printf("The child exit with code %d",WEXITSTATUS(status));
+		}
+	}
+
+}
+void encrypt_0(char * input,int &len,char *key)
+{
+	int i,j;
+	if(key[0]==0) return;
+	for(i=0,j=0;i<len;i++,j++)
+	{
+		if(key[j]==0)j=0;
+		input[i]^=key[j];
+	}
+}
+void decrypt_0(char * input,int &len,char *key)
+{
+
+	int i,j;
+	if(key[0]==0) return;
+	for(i=0,j=0;i<len;i++,j++)
+	{
+		if(key[j]==0)j=0;
+		input[i]^=key[j];
+	}
+}
+int add_seq(char * data,int &data_len )
+{
+	if(data_len<0) return -1;
+	anti_replay_seq_t seq=anti_replay.get_new_seq_for_send();
+	seq=hton64(seq);
+	memcpy(data+data_len,&seq,sizeof(seq));
+	data_len+=sizeof(seq);
+	return 0;
+}
+int remove_seq(char * data,int &data_len)
+{
+	anti_replay_seq_t seq;
+	if(data_len<sizeof(seq)) return -1;
+	data_len-=sizeof(seq);
+	memcpy(&seq,data+data_len,sizeof(seq));
+	seq=ntoh64(seq);
+	if(anti_replay.is_vaild(seq)==0)
+	{
+		//return -1;   //TODO for test
+	}
+	return 0;
+}
+int do_obscure(const char * input, int in_len,char *output,int &out_len)
+{
+	//memcpy(output,input,in_len);
+//	out_len=in_len;
+	//return 0;
+
+	int i, j, k;
+	if (in_len > 65535||in_len<0)
+		return -1;
+	int iv_len=iv_min+rand()%(iv_max-iv_min);
+	get_true_random_chars(output,iv_len);
+	memcpy(output+iv_len,input,in_len);
+
+	output[iv_len+in_len]=(uint8_t)iv_len;
+	for(i=0,j=0;i<in_len;i++,j++)
+	{
+		if(j==iv_len) j=0;
+		output[iv_len+i]^=output[j];
+	}
+	output[iv_len+in_len]^=output[0];
+	out_len=iv_len+in_len+1;
+	return 0;
+}
+int de_obscure(const char * input, int in_len,char *output,int &out_len)
+{
+	//memcpy(output,input,in_len);
+	//out_len=in_len;
+	//return 0;
+
+	int i, j, k;
+	if (in_len > 65535||in_len<0)
+	{
+		printf("error1,%d",in_len);
+		return -1;
+	}
+	int iv_len= int ((uint8_t)(input[in_len-1]^input[0]) );
+	out_len=in_len-1-iv_len;
+	if(out_len<0)
+	{
+		printf("error2,%d %d",in_len,out_len);
+		return -1;
+	}
+	for(i=0,j=0;i<in_len;i++,j++)
+	{
+		if(j==iv_len) j=0;
+		output[i]=input[iv_len+i]^input[j];
+	}
+	return 0;
+}
+void check_delay_map()
+{
+	//printf("<<<begin");
+	if(!delay_mp.empty())
+	{
+		my_time current_time;
+
+		multimap<my_time,delay_data>::iterator it;
+		//printf("<map_size:%d>",delay_mp.size());
+		//lfflush(stdout);
+		while(1)
+		{
+			int ret;
+			it=delay_mp.begin();
+			if(it==delay_mp.end()) break;
+			ret=clock_gettime(CLOCK_MONOTONIC, &current_time);
+			if(ret!=0)
+			{
+				printf("unknown error\n");
+				exit(1);
+			}
+			if(it->first < current_time||it->first ==current_time)
+			{
+				//send packet
+				printf("<%d>",it->second.len);
+				if(  (is_client  &&it->second.fd==remote_fd )   || (is_server  &&it->second.fd==local_fd ) )
+				{
+					char new_data[buf_len];int new_len;
+					do_obscure(it->second.data,it->second.len,new_data,new_len);
+					ret = send(it->second.fd, new_data, new_len, 0);
+				}
+				else
+				{
+					ret = send(it->second.fd, it->second.data, it->second.len, 0);
+				}
+
+				if (ret < 0) {
+					printf("send return %d at @300", ret);
+					exit(1);
+				}
+				if(it->second.times_left>1)
+				{
+					//delay_mp.insert(pair<my_time,delay_data>(current_time));
+					add_to_delay_mp(it->second.fd,it->second.times_left-1,it->second.data,it->second.len);
+				}
+				else
+				{
+					free(it->second.data);
+				}
+				delay_mp.erase(it);
+			}
+			else
+			{
+				break;
+			}
+
+		}
+		if(!delay_mp.empty())
+		{
+			itimerspec its;
+			memset(&its.it_interval,0,sizeof(its.it_interval));
+			its.it_value=delay_mp.begin()->first;
+			timerfd_settime(timer_fd,TFD_TIMER_ABSTIME,&its,0);
+		}
+	}
+	//printf("end");
+}
+int set_buf_size(int fd)
+{
+	int socket_buf_size=1024*1024;
+    if(setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &socket_buf_size, sizeof(socket_buf_size))<0)
+    //if(setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &socket_buf_size, sizeof(socket_buf_size))<0)
+    {
+    	printf("set SO_SNDBUF fail\n");
+    	exit(1);
+    }
+    //if(setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &socket_buf_size, sizeof(socket_buf_size))<0)
+    if(setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &socket_buf_size, sizeof(socket_buf_size))<0)
+    {
+    	printf("set SO_RCVBUF fail\n");
+    	exit(1);
+    }
+	return 0;
+}
+int main(int argc, char *argv[])
+{
+	dup2(1, 2);		//redirect stderr to stdout
+
+
+	init_random_number_fd();
+
+	int i, j, k;
+	int opt;
+	signal(SIGCHLD, handler);
+
+	printf("argc=%d ", argc);
+	for (i = 0; i < argc; i++)
+		printf("%s ", argv[i]);
+	printf("\n");
+	if (argc == 1)
+	{
+		printf(
+				"proc -c/-s -l ip:port -r ip:port  [-n dup_times] [-t dup_delay(1000=1ms)] \n");
+		return -1;
+	}
+	int no_l = 1, no_r = 1;
+	while ((opt = getopt(argc, argv, "l:r:d:t:hcs")) != -1)
+	{
+		//string opt_key;
+		//opt_key+=opt;
+		switch (opt)
+		{
+		case 'd':
+			dup_num=-1;
+			sscanf(optarg,"%d\n",&dup_num);
+			if(dup_num<1 ||dup_num>10)
+			{
+				printf("dup_num must be between 1 and 10\n");
+				exit(-1);
+			}
+			break;
+		case 't':
+			dup_delay=-1;
+			sscanf(optarg,"%d\n",&dup_delay);
+			if(dup_delay<1||dup_delay>1000*1000)
+			{
+				printf("dup_delay must be between 1 and 10\n");
+				exit(-1);
+			}
+			break;
+		case 'c':
+			is_client = 1;
+			break;
+		case 's':
+			is_server = 1;
+			break;
+		case 'l':
+			no_l = 0;
+			if (strchr(optarg, ':') != 0)
+			{
+				sscanf(optarg, "%[^:]:%d", local_address, &local_port);
+			}
+			else
+			{
+				printf(" -r ip:port\n");
+				exit(1);
+				strcpy(local_address, "127.0.0.1");
+				sscanf(optarg, "%d", &local_port);
+			}
+			break;
+		case 'r':
+			no_r = 0;
+			if (strchr(optarg, ':') != 0)
+			{
+				//printf("in :\n");
+				//printf("%s\n",optarg);
+				sscanf(optarg, "%[^:]:%d", remote_address, &remote_port);
+				//printf("%d\n",remote_port);
+			}
+			else
+			{
+				printf(" -r ip:port\n");
+				exit(1);
+				strcpy(remote_address, "127.0.0.1");
+				sscanf(optarg, "%d", &remote_port);
+			}
+			break;
+		case 'h':
+			break;
+		default:
+			printf("ignore unknown <%s>", optopt);
+		}
+	}
+
+	if (no_l)
+		printf("error: -i not found\n");
+	if (no_r)
+		printf("error: -o not found\n");
+	if (no_l || no_r)
+		exit(-1);
+	if (is_client == 0 && is_server == 0)
+	{
+		printf("-s -c hasnt been set\n");
+		exit(-1);
+	}
+	if (is_client == 1 && is_server == 1)
+	{
+		printf("-s -c cant be both set\n");
+		exit(-1);
+	}
+
+	struct sockaddr_in local_me, local_other;
+	int local_listen_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	int yes = 1;
+	setsockopt(local_listen_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
+	set_buf_size(local_listen_fd);
+
+	char data[buf_len];
+	//char *data=data0;
+	socklen_t slen = sizeof(sockaddr_in);
+	memset(&local_me, 0, sizeof(local_me));
+	local_me.sin_family = AF_INET;
+	local_me.sin_port = htons(local_port);
+	local_me.sin_addr.s_addr = inet_addr(local_address);
+	if (bind(local_listen_fd, (struct sockaddr*) &local_me, slen) == -1)
+	{
+		printf("socket bind error");
+		exit(1);
+	}
+	while (1)
+	{
+		int data_len;
+		if ((data_len = recvfrom(local_listen_fd, data, buf_len, 0,
+				(struct sockaddr *) &local_other, &slen)) == -1) //<--first packet from a new ip:port turple
+		{
+			printf("recv_from error");
+			exit(1);
+		}
+
+		printf("received packet from %s:%d\n", inet_ntoa(local_other.sin_addr),
+				ntohs(local_other.sin_port));
+
+		data[data_len] = 0;
+		printf("recv_len: %d\n", data_len);
+		fflush(stdout);
+
+		if (is_server)
+		{
+			char new_data[buf_len];
+			int new_len;
+			if(de_obscure(data,data_len,new_data,new_len)!=0)
+			{
+				printf("remove_padding error!\n");
+				continue;
+			}
+			memcpy(data,new_data,new_len);
+			data_len=new_len;
+			if (remove_seq(data, data_len) != 0)
+			{
+				printf("remove_seq error!\n");
+				continue;
+			}
+
+
+			//data=new_data;
+		}
+
+		local_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+		//local_me.sin_addr.s_addr=inet_addr("127.0.0.1");
+		setsockopt(local_fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
+		if (bind(local_fd, (struct sockaddr*) &local_me, slen) == -1) //偷懒的方法，有潜在问题
+		{
+			printf("socket bind error in chilld");
+			exit(1);
+		}
+		int ret = connect(local_fd, (struct sockaddr *) &local_other, slen); //偷懒的方法，有潜在问题
+		if (fork() == 0)  //子
+		{
+			if (ret != 0)
+			{
+				printf("connect return %d @1\n", ret);
+				exit(1);
+			}
+			close(local_listen_fd);
+
+			struct sockaddr_in remote_me, remote_other;
+			memset(&remote_other, 0, sizeof(remote_other));
+			remote_other.sin_family = AF_INET;
+			//printf("remote_address=%s  remote_port=%d\n",remote_address,remote_port);
+			remote_other.sin_port = htons(remote_port);
+			remote_other.sin_addr.s_addr = inet_addr(remote_address);
+			remote_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+			ret = connect(remote_fd, (struct sockaddr *) &remote_other, slen);
+			if (ret != 0)
+			{
+				printf("connect return %d @2\n", ret);
+				exit(1);
+			}
+			if (is_client)
+			{
+				add_seq(data, data_len);
+				char new_data[buf_len];
+				int new_len;
+
+				do_obscure(data, data_len, new_data, new_len);
+				ret = send(remote_fd, new_data, new_len, 0); //<----send the packet receved by father process  ,only for this packet
+				printf("send return %d\n", ret);
+				if(dup_num > 1)
+				{
+					add_and_new(remote_fd, dup_num - 1, data, data_len);
+				}
+			}
+			else
+			{
+				ret = send(remote_fd, data, data_len, 0);
+				printf("send return %d\n", ret);
+			}
+
+			if (ret < 0)
+				exit(-1);
+
+
+			setnonblocking(remote_fd);
+			set_buf_size(remote_fd);
+
+			setnonblocking(local_fd);
+			set_buf_size(local_fd);
+
+			int epollfd = epoll_create1(0);
+			const int max_events = 4096;
+			struct epoll_event ev, events[max_events];
+			if (epollfd < 0)
+			{
+				printf("epoll return %d\n", epollfd);
+				exit(-1);
+			}
+			ev.events = EPOLLIN;
+			ev.data.fd = local_fd;
+			ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, local_fd, &ev);
+			if (ret < 0)
+			{
+				printf("epoll_ctl return %d\n", ret);
+				exit(-1);
+			}
+			ev.events = EPOLLIN;
+			ev.data.fd = remote_fd;
+			ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, remote_fd, &ev);
+			if (ret < 0)
+			{
+				printf("epoll_ctl return %d\n", ret);
+				exit(-1);
+			}
+
+			if ((timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK)) < 0)
+			{
+				printf("timer_fd create error");
+				exit(1);
+			}
+			ev.events = EPOLLIN;
+			ev.data.fd = timer_fd;
+
+			itimerspec zero_its;
+			memset(&zero_its, 0, sizeof(zero_its));
+
+			timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &zero_its, 0);
+			epoll_ctl(epollfd, EPOLL_CTL_ADD, timer_fd, &ev);
+			if (ret < 0)
+			{
+				printf("epoll_ctl return %d\n", ret);
+				exit(-1);
+			}
+
+			check_delay_map();
+
+			for (;;)
+			{
+				int nfds = epoll_wait(epollfd, events, max_events, 180 * 1000); //3mins
+				if (nfds <= 0)
+				{
+					printf("epoll_wait return %d\n", nfds);
+					exit(-1);
+				}
+				int n;
+				for (n = 0; n < nfds; ++n)
+				{
+					if (events[n].data.fd == local_fd) //data income from local end
+					{
+						data_len = recv(local_fd, data, buf_len, 0);
+						if (data_len < 0)
+						{
+							printf("recv return %d @1", data_len);
+							exit(1);
+						}
+
+						data[data_len] = 0;
+						printf("len %d received from child@1\n", data_len);
+						//printf("%s received from child@1\n",buf);
+
+						//printf("before send %s\n",buf);
+						if(is_client)
+						{
+							add_seq(data,data_len);
+							char new_data[buf_len];
+							int new_len;
+							do_obscure(data, data_len, new_data, new_len);
+							ret = send(remote_fd, new_data, new_len, 0);
+							if(dup_num>1)
+							{
+								add_and_new(remote_fd, dup_num - 1, data, data_len);
+							}
+						}
+						else
+						{
+							char new_data[buf_len];
+							int new_len;
+							if(de_obscure(data,data_len,new_data,new_len)!=0) {printf("error at line %d\n",__LINE__);continue;}
+
+							if(remove_seq(new_data,new_len)!=0) {printf("error at line %d\n",__LINE__);continue;}
+
+							ret = send(remote_fd, new_data, new_len, 0);
+						}
+						if (ret < 0)
+						{
+							printf("send return %d at @1", ret);
+							exit(1);
+						}
+
+
+					}
+					else if (events[n].data.fd == remote_fd)
+					{
+						data_len = recv(remote_fd, data, buf_len, 0);
+						if (data_len < 0)
+						{
+							printf("recv return -1 @2", data_len);
+							exit(1);
+						}
+
+						data[data_len] = 0;
+						printf("len %d received from child@1\n", data_len);
+						//printf("%s received from child@2\n",buf);
+						if(is_client)
+						{
+							char new_data[buf_len];
+							int new_len;
+							if(de_obscure(data,data_len,new_data,new_len)!=0) {printf("error at line %d\n",__LINE__);continue;}
+
+							if(remove_seq(new_data,new_len)!=0) {printf("error at line %d\n",__LINE__);continue;}
+
+
+							ret = send(local_fd, new_data, new_len, 0);
+						}
+						else
+						{
+							add_seq(data,data_len);
+							char new_data[buf_len];
+							int new_len;
+							do_obscure(data, data_len, new_data, new_len);
+							ret = send(local_fd, new_data, new_len, 0);
+							if(dup_num>1)
+							{
+								add_and_new(local_fd, dup_num - 1, data, data_len);
+							}
+						}
+
+						if (ret < 0)
+						{
+							printf("send return %d @2", ret);
+							exit(1);
+						}
+					}
+					else if (events[n].data.fd == timer_fd)
+					{
+						uint64_t value;
+						read(timer_fd, &value, 8);
+						//printf("<timerfd_triggered, %d>",delay_mp.size());
+						//fflush(stdout);
+					}
+				}						//end for n = 0; n < nfds
+				check_delay_map();
+			}
+			exit(0);
+		}
+		else //if(fork()==0)  ... else
+		{ //fork 's father process
+			close(local_fd); //father process only listen to local_listen_fd,so,close this fd
+		}
+	}  //while(1)end
+
+	return 0;
+}

makefile

@@ -0,0 +1,10 @@
+ccarm=mips-openwrt-linux-g++
+all:
+	g++ main.cpp -o dupd -static -lrt
+release:
+	g++ main.cpp -o dupd_amd64 -static -lrt	
+	g++ main.cpp -o dupd_x86 -static -lrt -m32
+	${ccarm} main.cpp -o dupd_ar71xx  -static -lgcc_eh -lrt
+
+#g++ forward.cpp aes.c -o forward -static
+#	${ccarm} forward.cpp aes.c  -o forwardarm   -static -lgcc_eh