From 6af08d3aa90f1d1fe11047af7f6d28f52f7970b8 Mon Sep 17 00:00:00 2001 From: wangyu- Date: Wed, 1 Nov 2017 12:44:16 -0500 Subject: [PATCH] init --- common.cpp | 331 ++++++++++++++++++ common.h | 161 +++++++++ git_version.h | 1 + log.cpp | 63 ++++ log.h | 101 ++++++ main.cpp | 951 ++++++++++++++++++++++++++++++++++++++++++++++++++ makefile | 63 ++++ 7 files changed, 1671 insertions(+) create mode 100644 common.cpp create mode 100644 common.h create mode 100644 git_version.h create mode 100755 log.cpp create mode 100755 log.h create mode 100644 main.cpp create mode 100755 makefile diff --git a/common.cpp b/common.cpp new file mode 100644 index 0000000..5993a38 --- /dev/null +++ b/common.cpp @@ -0,0 +1,331 @@ +/* + * comm.cpp + * + * Created on: Jul 29, 2017 + * Author: wangyu + */ + +#include "common.h" +#include "log.h" + + + +int about_to_exit=0; + +raw_mode_t raw_mode=mode_faketcp; +unordered_map raw_mode_tostring = {{mode_faketcp, "faketcp"}, {mode_udp, "udp"}, {mode_icmp, "icmp"}}; +int socket_buf_size=1024*1024; +static int random_number_fd=-1; +char iptables_rule[200]=""; +program_mode_t program_mode=unset_mode;//0 unset; 1client 2server + +u64_t get_current_time() +{ + timespec tmp_time; + clock_gettime(CLOCK_MONOTONIC, &tmp_time); + return tmp_time.tv_sec*1000+tmp_time.tv_nsec/(1000*1000l); +} + +u64_t get_current_time_us() +{ + timespec tmp_time; + clock_gettime(CLOCK_MONOTONIC, &tmp_time); + return (uint64_t(tmp_time.tv_sec))*1000llu*1000llu+ (uint64_t(tmp_time.tv_nsec))/1000llu; +} + +u64_t pack_u64(u32_t a,u32_t b) +{ + u64_t ret=a; + ret<<=32u; + ret+=b; + return ret; +} +u32_t get_u64_h(u64_t a) +{ + return a>>32u; +} +u32_t get_u64_l(u64_t a) +{ + return (a<<32u)>>32u; +} + +char * my_ntoa(u32_t ip) +{ + in_addr a; + a.s_addr=ip; + return inet_ntoa(a); +} + + +int add_iptables_rule(char * s) +{ + strcpy(iptables_rule,s); + char buf[300]="iptables -I "; + strcat(buf,s); + if(system(buf)==0) + { + mylog(log_warn,"auto added iptables rule by: %s\n",buf); + } + else + { + mylog(log_fatal,"auto added iptables failed by: %s\n",buf); + myexit(-1); + } + return 0; +} + +int clear_iptables_rule() +{ + if(iptables_rule[0]!=0) + { + char buf[300]="iptables -D "; + strcat(buf,iptables_rule); + if(system(buf)==0) + { + mylog(log_warn,"iptables rule cleared by: %s \n",buf); + } + else + { + mylog(log_error,"clear iptables failed by: %s\n",buf); + } + + } + return 0; +} + + +void init_random_number_fd() +{ + + random_number_fd=open("/dev/urandom",O_RDONLY); + + if(random_number_fd==-1) + { + mylog(log_fatal,"error open /dev/urandom\n"); + myexit(-1); + } + setnonblocking(random_number_fd); +} +u64_t get_true_random_number_64() +{ + u64_t ret; + int size=read(random_number_fd,&ret,sizeof(ret)); + if(size!=sizeof(ret)) + { + mylog(log_fatal,"get random number failed %d\n",size); + + myexit(-1); + } + + return ret; +} +u32_t get_true_random_number() +{ + u32_t ret; + int size=read(random_number_fd,&ret,sizeof(ret)); + if(size!=sizeof(ret)) + { + mylog(log_fatal,"get random number failed %d\n",size); + myexit(-1); + } + return ret; +} +u32_t get_true_random_number_nz() //nz for non-zero +{ + u32_t ret=0; + while(ret==0) + { + ret=get_true_random_number(); + } + 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; + +} + +void setnonblocking(int sock) { + int opts; + opts = fcntl(sock, F_GETFL); + + if (opts < 0) { + mylog(log_fatal,"fcntl(sock,GETFL)\n"); + //perror("fcntl(sock,GETFL)"); + myexit(1); + } + opts = opts | O_NONBLOCK; + if (fcntl(sock, F_SETFL, opts) < 0) { + mylog(log_fatal,"fcntl(sock,SETFL,opts)\n"); + //perror("fcntl(sock,SETFL,opts)"); + myexit(1); + } + +} + +/* + Generic checksum calculation function +*/ +unsigned short csum(const unsigned short *ptr,int nbytes) { + register long sum; + unsigned short oddbyte; + register short answer; + + sum=0; + while(nbytes>1) { + sum+=*ptr++; + nbytes-=2; + } + if(nbytes==1) { + oddbyte=0; + *((u_char*)&oddbyte)=*(u_char*)ptr; + sum+=oddbyte; + } + + sum = (sum>>16)+(sum & 0xffff); + sum = sum + (sum>>16); + answer=(short)~sum; + + return(answer); +} +int set_buf_size(int fd,int size) +{ + //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; +} +void myexit(int a) +{ + if(enable_log_color) + printf("%s\n",RESET); + clear_iptables_rule(); + exit(a); +} +void signal_handler(int sig) +{ + about_to_exit=1; + // myexit(0); +} + +int numbers_to_char(id_t id1,id_t id2,id_t id3,char * &data,int &len) +{ + static char buf[buf_len]; + data=buf; + id_t tmp=htonl(id1); + memcpy(buf,&tmp,sizeof(tmp)); + + tmp=htonl(id2); + memcpy(buf+sizeof(tmp),&tmp,sizeof(tmp)); + + tmp=htonl(id3); + memcpy(buf+sizeof(tmp)*2,&tmp,sizeof(tmp)); + + len=sizeof(id_t)*3; + return 0; +} + + +int char_to_numbers(const char * data,int len,id_t &id1,id_t &id2,id_t &id3) +{ + if(len + +#include +#include +#include +#include + +#include +#include +#include +#include +#include //for socket ofcourse +#include +#include //for exit(0); +#include //For errno - the error number +#include //Provides declarations for tcp header +#include +#include //Provides declarations for ip header +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + + +#include +#include +#include +using namespace std; + + +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 int max_data_len=1600; +const int buf_len=max_data_len+200; + +const u32_t conv_clear_interval=200; +const u32_t timer_interval=400; +const int conv_clear_ratio=40; +const int conv_clear_min=5; +const u32_t conv_timeout=20000; +const int max_conv_num=10000; + +/* +const u32_t max_handshake_conn_num=10000; +const u32_t max_ready_conn_num=1000; +//const u32_t anti_replay_window_size=1000; + + +const u32_t client_handshake_timeout=5000; +const u32_t client_retry_interval=1000; + +const u32_t server_handshake_timeout=10000;// this should be much longer than clients. client retry initially ,server retry passtively + +const int conv_clear_ratio=10; //conv grabage collecter check 1/10 of all conv one time +const int conn_clear_ratio=10; +const int conv_clear_min=5; +const int conn_clear_min=1; + + +const u32_t conn_clear_interval=1000; + + +const i32_t max_fail_time=0;//disable + +const u32_t heartbeat_interval=1000; + +const u32_t timer_interval=400;//this should be smaller than heartbeat_interval and retry interval; + +//const uint32_t conv_timeout=120000; //120 second +const u32_t conv_timeout=120000; //for test + +const u32_t client_conn_timeout=10000; +const u32_t client_conn_uplink_timeout=client_conn_timeout+2000; + +//const uint32_t server_conn_timeout=conv_timeout+60000;//this should be 60s+ longer than conv_timeout,so that conv_manager can destruct convs gradually,to avoid latency glicth +const u32_t server_conn_timeout=conv_timeout+60000;//for test +*/ + +extern int about_to_exit; + +enum raw_mode_t{mode_faketcp=0,mode_udp,mode_icmp,mode_end}; +extern raw_mode_t raw_mode; +enum program_mode_t {unset_mode=0,client_mode,server_mode}; +extern program_mode_t program_mode; +extern unordered_map raw_mode_tostring ; +extern int socket_buf_size; + +typedef u32_t id_t; + +typedef u64_t iv_t; + +typedef u64_t padding_t; + +typedef u64_t anti_replay_seq_t; + +u64_t get_current_time(); +u64_t get_current_time_us(); +u64_t pack_u64(u32_t a,u32_t b); + +u32_t get_u64_h(u64_t a); + +u32_t get_u64_l(u64_t a); + +char * my_ntoa(u32_t ip); + +void myexit(int a); +void init_random_number_fd(); +u64_t get_true_random_number_64(); +u32_t get_true_random_number(); +u32_t get_true_random_number_nz(); +u64_t ntoh64(u64_t a); +u64_t hton64(u64_t a); +bool larger_than_u16(uint16_t a,uint16_t b); +bool larger_than_u32(u32_t a,u32_t b); +void setnonblocking(int sock); +int set_buf_size(int fd,int size=socket_buf_size); + +unsigned short csum(const unsigned short *ptr,int nbytes); + +void signal_handler(int sig); +int numbers_to_char(id_t id1,id_t id2,id_t id3,char * &data,int &len); +int char_to_numbers(const char * data,int len,id_t &id1,id_t &id2,id_t &id3); + +void myexit(int a); + +int add_iptables_rule(char *); + +int clear_iptables_rule(); +void get_true_random_chars(char * s,int len); + +#endif /* COMMON_H_ */ diff --git a/git_version.h b/git_version.h new file mode 100644 index 0000000..9671b16 --- /dev/null +++ b/git_version.h @@ -0,0 +1 @@ +const char *gitversion = "7a4e5c2bc85be728b0477363e5c1c6bc2ad2a5a8"; diff --git a/log.cpp b/log.cpp new file mode 100755 index 0000000..543cf3f --- /dev/null +++ b/log.cpp @@ -0,0 +1,63 @@ +#include +#include + +int log_level=log_info; + +int enable_log_position=0; +int enable_log_color=1; + + +void log0(const char * file,const char * function,int line,int level,const char* str, ...) { + + if(level>log_level) return ; + if(level>log_trace||level<0) return ; + + + time_t timer; + char buffer[100]; + struct tm* tm_info; + + time(&timer); + tm_info = localtime(&timer); + + if(enable_log_color) + printf("%s",log_color[level]); + + strftime(buffer, 100, "%Y-%m-%d %H:%M:%S", tm_info); + printf("[%s][%s]",buffer,log_text[level]); + + if(enable_log_position)printf("[%s,func:%s,line:%d]",file,function,line); + + va_list vlist; + va_start(vlist, str); + vfprintf(stdout, str, vlist); + va_end(vlist); + if(enable_log_color) + printf("%s",RESET); + + //printf("\n"); + //if(enable_log_color) + //printf(log_color[level]); + fflush(stdout); + + if(log_level==log_fatal) + { + about_to_exit=1; + } +} + +void log_bare(int level,const char* str, ...) +{ + if(level>log_level) return ; + if(level>log_trace||level<0) return ; + if(enable_log_color) + printf("%s",log_color[level]); + va_list vlist; + va_start(vlist, str); + vfprintf(stdout, str, vlist); + va_end(vlist); + if(enable_log_color) + printf("%s",RESET); + fflush(stdout); + +} diff --git a/log.h b/log.h new file mode 100755 index 0000000..d29788f --- /dev/null +++ b/log.h @@ -0,0 +1,101 @@ + +#ifndef _LOG_MYLOG_H_ +#define _LOG_MYLOG_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +//#include"aes.h" + +#include +#include + +#include +#include +#include + + +#include //for socket ofcourse +#include +#include //for exit(0); +#include //For errno - the error number +#include //Provides declarations for tcp header +#include +#include //Provides declarations for ip header +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +//#include +#include + +#include +#include +#include +#include +#include + +using namespace std; + + +#define RED "\x1B[31m" +#define GRN "\x1B[32m" +#define YEL "\x1B[33m" +#define BLU "\x1B[34m" +#define MAG "\x1B[35m" +#define CYN "\x1B[36m" +#define WHT "\x1B[37m" +#define RESET "\x1B[0m" + + +const int log_never=0; +const int log_fatal=1; +const int log_error=2; +const int log_warn=3; +const int log_info=4; +const int log_debug=5; +const int log_trace=6; +const int log_end=7; + +const char log_text[][20]={"NEVER","FATAL","ERROR","WARN","INFO","DEBUG","TRACE",""}; +const char log_color[][20]={RED,RED,RED,YEL,GRN,MAG,""}; + +extern int log_level; +extern int enable_log_position; +extern int enable_log_color; + + +#ifdef MY_DEBUG +#define mylog(__first_argu__dummy_abcde__,...) printf(__VA_ARGS__) + +#else +#define mylog(...) log0(__FILE__,__FUNCTION__,__LINE__,__VA_ARGS__) +#endif + + +//#define mylog(__first_argu__dummy_abcde__,...) {;} + +void log0(const char * file,const char * function,int line,int level,const char* str, ...); + +void log_bare(int level,const char* str, ...); + + +#endif diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..686bce4 --- /dev/null +++ b/main.cpp @@ -0,0 +1,951 @@ +#include "common.h" +#include "log.h" +#include "git_version.h" + +using namespace std; + +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; + +typedef u64_t anti_replay_seq_t; +int disable_replay_filter=0; +int dup_num=1; +int dup_delay_min=20; //0.1ms +int dup_delay_max=20; +//int dup_first_delay=9000; //0.1ms + +int jitter_min=0; +int jitter_max=0; + +int iv_min=2; +int iv_max=16;//< 256; +int random_number_fd=-1; + +int remote_fd=-1; +int local_fd=-1; +int is_client = 0, is_server = 0; +int local_listen_fd=-1; + +int disable_conn_clear=0; +int mtu_warn=1350; +u32_t remote_address_uint32=0; + +char local_address[100], remote_address[100]; +int local_port = -1, remote_port = -1; +int multi_process_mode=0; +const u32_t anti_replay_buff_size=10000; + +char key_string[1000]= "secret key"; + +int random_drop=0; + +u64_t last_report_time=0; +int report_interval=0; + +u64_t packet_send_count=0; +u64_t dup_packet_send_count=0; +u64_t packet_recv_count=0; +u64_t dup_packet_recv_count=0; +int max_pending_packet=0; + + +int VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV; + + +struct conn_manager_t //TODO change map to unordered map +{ + //typedef hash_map map; + unordered_map u64_to_fd; //conv and u64 are both supposed to be uniq + unordered_map fd_to_u64; + + unordered_map fd_last_active_time; + + unordered_map::iterator clear_it; + + unordered_map::iterator it; + unordered_map::iterator old_it; + + //void (*clear_function)(uint64_t u64) ; + + long long last_clear_time; + list clear_list; + conn_manager_t() + { + clear_it=fd_last_active_time.begin(); + long long last_clear_time=0; + rehash(); + //clear_function=0; + } + ~conn_manager_t() + { + clear(); + } + int get_size() + { + return fd_to_u64.size(); + } + void rehash() + { + u64_to_fd.rehash(10007); + fd_to_u64.rehash(10007); + fd_last_active_time.rehash(10007); + } + void clear() + { + if(disable_conn_clear) return ; + + for(it=fd_to_u64.begin();it!=fd_to_u64.end();it++) + { + //int fd=int((it->second<<32u)>>32u); + close( it->first); + } + u64_to_fd.clear(); + fd_to_u64.clear(); + fd_last_active_time.clear(); + + clear_it=fd_last_active_time.begin(); + + } + int exist_fd(u32_t fd) + { + return fd_to_u64.find(fd)!=fd_to_u64.end(); + } + int exist_u64(u64_t u64) + { + return u64_to_fd.find(u64)!=u64_to_fd.end(); + } + u32_t find_fd_by_u64(u64_t u64) + { + return u64_to_fd[u64]; + } + u64_t find_u64_by_fd(u32_t fd) + { + return fd_to_u64[fd]; + } + int update_active_time(u32_t fd) + { + return fd_last_active_time[fd]=get_current_time(); + } + int insert_fd(u32_t fd,u64_t u64) + { + int before=fd_last_active_time.bucket_count(); + u64_to_fd[u64]=fd; + fd_to_u64[fd]=u64; + fd_last_active_time[fd]=get_current_time(); + int after=fd_last_active_time.bucket_count(); + if(after!=before)//rehash happens! + { + clear_it=fd_last_active_time.begin(); + } + return 0; + } + int erase_fd(u32_t fd) + { + if(disable_conn_clear) return 0; + u64_t u64=fd_to_u64[fd]; + + u32_t ip= (u64 >> 32u); + + int port= uint16_t((u64 << 32u) >> 32u); + + mylog(log_info,"fd %d cleared,assocated adress %s,%d\n",fd,my_ntoa(ip),port); + + close(fd); + + fd_to_u64.erase(fd); + u64_to_fd.erase(u64); + fd_last_active_time.erase(fd); + return 0; + } + void check_clear_list() + { + while(!clear_list.empty()) + { + int fd=*clear_list.begin(); + clear_list.pop_front(); + erase_fd(fd); + } + } + int clear_inactive() + { + if(get_current_time()-last_clear_time>conv_clear_interval) + { + last_clear_time=get_current_time(); + return clear_inactive0(); + } + return 0; + } + int clear_inactive0() + { + if(disable_conn_clear) return 0; + + + //map::iterator it; + int cnt=0; + it=clear_it; + int size=fd_last_active_time.size(); + int num_to_clean=size/conv_clear_ratio+conv_clear_min; //clear 1/10 each time,to avoid latency glitch + + u64_t current_time=get_current_time(); + for(;;) + { + if(cnt>=num_to_clean) break; + if(fd_last_active_time.begin()==fd_last_active_time.end()) break; + + if(it==fd_last_active_time.end()) + { + it=fd_last_active_time.begin(); + } + + if( current_time -it->second >conv_timeout ) + { + //mylog(log_info,"inactive conv %u cleared \n",it->first); + old_it=it; + it++; + u32_t fd= old_it->first; + erase_fd(old_it->first); + + + } + else + { + it++; + } + cnt++; + } + return 0; + } +}conn_manager; + + +int sendto_u64 (int fd,char * buf, int len,int flags, u64_t u64) +{ + + if(is_server) + { + dup_packet_send_count++; + } + if(is_server&&random_drop!=0) + { + if(get_true_random_number()%10000<(u32_t)random_drop) + { + return 0; + } + } + + sockaddr_in tmp_sockaddr; + + memset(&tmp_sockaddr,0,sizeof(tmp_sockaddr)); + tmp_sockaddr.sin_family = AF_INET; + tmp_sockaddr.sin_addr.s_addr = (u64 >> 32u); + + tmp_sockaddr.sin_port = htons(uint16_t((u64 << 32u) >> 32u)); + + return sendto(fd, buf, + len , 0, + (struct sockaddr *) &tmp_sockaddr, + sizeof(tmp_sockaddr)); +} + +int send_fd (int fd,char * buf, int len,int flags) +{ + if(is_client) + { + dup_packet_send_count++; + } + if(is_client&&random_drop!=0) + { + if(get_true_random_number()%10000<(u32_t)random_drop) + { + return 0; + } + } + return send(fd,buf,len,flags); +} + +int create_new_udp(int &new_udp_fd) +{ + struct sockaddr_in remote_addr_in; + + socklen_t slen = sizeof(sockaddr_in); + memset(&remote_addr_in, 0, sizeof(remote_addr_in)); + remote_addr_in.sin_family = AF_INET; + remote_addr_in.sin_port = htons(remote_port); + remote_addr_in.sin_addr.s_addr = remote_address_uint32; + + new_udp_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + if (new_udp_fd < 0) { + mylog(log_warn, "create udp_fd error\n"); + return -1; + } + setnonblocking(new_udp_fd); + set_buf_size(new_udp_fd); + + mylog(log_debug, "created new udp_fd %d\n", new_udp_fd); + int ret = connect(new_udp_fd, (struct sockaddr *) &remote_addr_in, slen); + if (ret != 0) { + mylog(log_warn, "udp fd connect fail %d %s\n",ret,strerror(errno)); + close(new_udp_fd); + return -1; + } + + + return 0; +} +int set_timer(int epollfd,int &timer_fd) +{ + int ret; + epoll_event ev; + + itimerspec its; + memset(&its,0,sizeof(its)); + + if((timer_fd=timerfd_create(CLOCK_MONOTONIC,TFD_NONBLOCK)) < 0) + { + mylog(log_fatal,"timer_fd create error\n"); + myexit(1); + } + its.it_interval.tv_sec=(timer_interval/1000); + its.it_interval.tv_nsec=(timer_interval%1000)*1000ll*1000ll; + its.it_value.tv_nsec=1; //imidiately + timerfd_settime(timer_fd,0,&its,0); + + + ev.events = EPOLLIN; + ev.data.fd = timer_fd; + + ret=epoll_ctl(epollfd, EPOLL_CTL_ADD, timer_fd, &ev); + if (ret < 0) { + mylog(log_fatal,"epoll_ctl return %d\n", ret); + myexit(-1); + } + return 0; +} +int event_loop() +{ + struct sockaddr_in local_me, local_other; + 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,4*1024*1024); + setnonblocking(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) + { + mylog(log_fatal,"socket bind error"); + myexit(1); + } + + int epollfd = epoll_create1(0); + const int max_events = 4096; + struct epoll_event ev, events[max_events]; + if (epollfd < 0) + { + mylog(log_fatal,"epoll created return %d\n", epollfd); + myexit(-1); + } + ev.events = EPOLLIN; + ev.data.fd = local_listen_fd; + int ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, local_listen_fd, &ev); + + if(ret!=0) + { + mylog(log_fatal,"epoll created return %d\n", epollfd); + myexit(-1); + } + int clear_timer_fd=-1; + set_timer(epollfd,clear_timer_fd); + + + + for (;;) + { + int nfds = epoll_wait(epollfd, events, max_events, 180 * 1000); //3mins + if (nfds < 0) + { + mylog(log_fatal,"epoll_wait return %d\n", nfds); + myexit(-1); + } + int n; + int clear_triggered=0; + for (n = 0; n < nfds; ++n) + { + if (events[n].data.fd == local_listen_fd) //data income from local end + { + + char data[buf_len]; + int data_len; + + slen = sizeof(sockaddr_in); + if ((data_len = recvfrom(local_listen_fd, data, max_data_len, 0, + (struct sockaddr *) &local_other, &slen)) == -1) //<--first packet from a new ip:port turple + { + + mylog(log_error,"recv_from error,errno %s,this shouldnt happen,but lets try to pretend it didnt happen",strerror(errno)); + //myexit(1); + continue; + } + mylog(log_trace, "received data from listen fd,%s:%d, len=%d\n", my_ntoa(local_other.sin_addr.s_addr),ntohs(local_other.sin_port),data_len); + if(data_len>mtu_warn) + { + mylog(log_warn,"huge packet,data len=%d (>%d).strongly suggested to set a smaller mtu at upper level,to get rid of this warn\n ",data_len,mtu_warn); + } + data[data_len] = 0; //for easier debug + u64_t u64=pack_u64(local_other.sin_addr.s_addr,ntohs(local_other.sin_port)); + + if(!conn_manager.exist_u64(u64)) + { + + if(int(conn_manager.fd_to_u64.size())>=max_conv_num) + { + mylog(log_info,"new connection from %s:%d ,but ignored,bc of max_conv_num reached\n",my_ntoa(local_other.sin_addr.s_addr),ntohs(local_other.sin_port)); + continue; + } + int new_udp_fd; + if(create_new_udp(new_udp_fd)!=0) + { + mylog(log_info,"new connection from %s:%d ,but create udp fd failed\n",my_ntoa(local_other.sin_addr.s_addr),ntohs(local_other.sin_port)); + continue; + } + struct epoll_event ev; + + mylog(log_trace, "u64: %lld\n", u64); + ev.events = EPOLLIN; + + ev.data.fd = new_udp_fd; + + ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, new_udp_fd, &ev); + if (ret != 0) { + mylog(log_info,"new connection from %s:%d ,but add to epoll failed\n",my_ntoa(local_other.sin_addr.s_addr),ntohs(local_other.sin_port)); + close(new_udp_fd); + continue; + } + mylog(log_info,"new connection from %s:%d ,created new udp fd %d\n",my_ntoa(local_other.sin_addr.s_addr),ntohs(local_other.sin_port),new_udp_fd); + conn_manager.insert_fd(new_udp_fd,u64); + } + int new_udp_fd=conn_manager.find_fd_by_u64(u64); + conn_manager.update_active_time(new_udp_fd); + int ret; + + /* + if(is_client) + { + add_seq(data,data_len); + if(jitter_max==0) + { + char new_data[buf_len]; + int new_len=0; + do_obscure(data, data_len, new_data, new_len); + ret = send_fd(new_udp_fd, new_data,new_len, 0); + if (ret < 0) { + mylog(log_warn, "send returned %d ,errno:%s\n", ret,strerror(errno)); + } + if(dup_delay_max!=0) + { + add_and_new(new_udp_fd, dup_num - 1,random_between(dup_delay_min,dup_delay_max), data, data_len,u64); + } + else + { + for(int i=0;iu64_t(report_interval)*1000) + { + last_report_time=get_current_time(); + if(is_client) + mylog(log_info,"client-->server: %llu,%llu(include dup); server-->client %llu,%lld(include dup)\n",packet_send_count, + dup_packet_send_count,packet_recv_count,dup_packet_recv_count); + else + mylog(log_info,"client-->server: %llu,%llu(include dup); server-->client %llu,%lld(include dup)\n",packet_recv_count,dup_packet_recv_count,packet_send_count, + dup_packet_send_count); + } + } + + else + { + int udp_fd=events[n].data.fd; + if(!conn_manager.exist_fd(udp_fd)) continue; + + char data[buf_len]; + int data_len =recv(udp_fd,data,max_data_len,0); + mylog(log_trace, "received data from udp fd %d, len=%d\n", udp_fd,data_len); + if(data_len<0) + { + if(errno==ECONNREFUSED) + { + //conn_manager.clear_list.push_back(udp_fd); + mylog(log_debug, "recv failed %d ,udp_fd%d,errno:%s\n", data_len,udp_fd,strerror(errno)); + } + + mylog(log_warn, "recv failed %d ,udp_fd%d,errno:%s\n", data_len,udp_fd,strerror(errno)); + continue; + } + if(data_len>mtu_warn) + { + mylog(log_warn,"huge packet,data len=%d (>%d).strongly suggested to set a smaller mtu at upper level,to get rid of this warn\n ",data_len,mtu_warn); + } + + assert(conn_manager.exist_fd(udp_fd)); + + conn_manager.update_active_time(udp_fd); + + u64_t u64=conn_manager.find_u64_by_fd(udp_fd); + + /* + if(is_client) + { + char new_data[buf_len]; + int new_len; + if (de_obscure(data, data_len, new_data, new_len) != 0) { + mylog(log_debug,"data_len=%d \n",data_len); + continue; + } + + //dup_packet_recv_count++; + if (remove_seq(new_data, new_len) != 0) { + mylog(log_debug,"remove_seq error \n"); + continue; + } + //packet_recv_count++; + ret = sendto_u64(local_listen_fd, new_data, + new_len , 0,u64); + if (ret < 0) { + mylog(log_warn, "sento returned %d,%s\n", ret,strerror(errno)); + //perror("ret<0"); + } + } + else + { + add_seq(data,data_len); + + if(jitter_max==0) + { + char new_data[buf_len]; + int new_len=0; + do_obscure(data, data_len, new_data, new_len); + ret = sendto_u64(local_listen_fd, new_data, + new_len , 0,u64); + if(dup_delay_max!=0) + { + add_and_new(udp_fd, dup_num - 1,random_between(dup_delay_min,dup_delay_max), data, data_len,u64); + } + else + { + for(int i=0;i key for simple xor encryption,default:\"secret key\"\n"); + + printf("main options:\n"); + printf(" -d duplicated packet number, -d 0 means no duplicate. default value:0\n"); + printf(" -t duplicated packet delay time, unit: 0.1ms,default value:20(2ms)\n"); + printf(" -j simulated jitter.randomly delay first packet for 0~jitter_value*0.1 ms,to\n"); + printf(" create simulated jitter.default value:0.do not use if you dont\n"); + printf(" know what it means\n"); + printf(" --report turn on udp send/recv report,and set a time interval for reporting,unit:s\n"); + printf("advanced options:\n"); + printf(" -t tmin:tmax simliar to -t above,but delay randomly between tmin and tmax\n"); + printf(" -j jmin:jmax simliar to -j above,but create jitter randomly between jmin and jmax\n"); + printf(" --random-drop simulate packet loss ,unit:0.01%%\n"); + printf(" --disable-filter disable duplicate packet filter.\n"); + printf(" -m max pending packets,to prevent the program from eating up all your memory,\n"); + printf(" default value:0(disabled).\n"); + printf("other options:\n"); + printf(" --log-level 0:never 1:fatal 2:error 3:warn \n"); + printf(" 4:info (default) 5:debug 6:trace\n"); + printf(" --log-position enable file name,function name,line number in log\n"); + printf(" --disable-color disable log color\n"); + printf(" --sock-buf buf size for socket,>=10 and <=10240,unit:kbyte,default:1024\n"); + //printf(" -p use multi-process mode instead of epoll.very costly,only for test,do dont use\n"); + printf(" -h,--help print this help message\n"); + + //printf("common options,these options must be same on both side\n"); +} +void process_arg(int argc, char *argv[]) +{ + 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}, + {"disable-filter", no_argument, 0, 1}, + {"sock-buf", required_argument, 0, 1}, + {"random-drop", required_argument, 0, 1}, + {"report", required_argument, 0, 1}, + {NULL, 0, 0, 0} + }; + int option_index = 0; + if (argc == 1) + { + print_help(); + myexit( -1); + } + for (i = 0; i < argc; i++) + { + if(strcmp(argv[i],"-h")==0||strcmp(argv[i],"--help")==0) + { + print_help(); + myexit(0); + } + } + for (i = 0; i < argc; i++) + { + if(strcmp(argv[i],"--log-level")==0) + { + if(i1000\n"); + myexit(-1); + } + break; + + case 'j': + if (strchr(optarg, ':') == 0) + { + int jitter; + sscanf(optarg,"%d\n",&jitter); + if(jitter<0 ||jitter>1000*100) + { + mylog(log_fatal,"jitter must be between 0 and 100,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); + } + } + break; + case 't': + if (strchr(optarg, ':') == 0) + { + int dup_delay=-1; + sscanf(optarg,"%d\n",&dup_delay); + if(dup_delay<0||dup_delay>1000*100) + { + mylog(log_fatal,"dup_delay must be between 0 and 100,000(10 second)\n"); + myexit(-1); + } + dup_delay_min=dup_delay_max=dup_delay; + } + else + { + sscanf(optarg,"%d:%d\n",&dup_delay_min,&dup_delay_max); + if(dup_delay_min<0 ||dup_delay_max<0||dup_delay_min>dup_delay_max) + { + mylog(log_fatal," must satisfy 0<=tmin<=tmax\n"); + myexit(-1); + } + } + break; + case 'd': + dup_num=-1; + sscanf(optarg,"%d\n",&dup_num); + if(dup_num<0 ||dup_num>5) + { + mylog(log_fatal,"dup_num must be between 0 and 5\n"); + myexit(-1); + } + dup_num+=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 + { + mylog(log_fatal," -r ip:port\n"); + myexit(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 + { + mylog(log_fatal," -r ip:port\n"); + myexit(1); + strcpy(remote_address, "127.0.0.1"); + sscanf(optarg, "%d", &remote_port); + } + 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,"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); + } + } + 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 + { + mylog(log_fatal,"unknown option\n"); + myexit(-1); + } + break; + default: + mylog(log_fatal,"unknown option <%x>", opt); + myexit(-1); + } + } + + if (no_l) + mylog(log_fatal,"error: -i not found\n"); + if (no_r) + mylog(log_fatal,"error: -o not found\n"); + if (no_l || no_r) + 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); + } +} +int main(int argc, char *argv[]) +{ + assert(sizeof(u64_t)==8); + assert(sizeof(i64_t)==8); + assert(sizeof(u32_t)==4); + assert(sizeof(i32_t)==4); + dup2(1, 2); //redirect stderr to stdout + int i, j, k; + process_arg(argc,argv); + init_random_number_fd(); + + remote_address_uint32=inet_addr(remote_address); + + if(!multi_process_mode) + { + event_loop(); + } + else + { + } + + + return 0; +} + diff --git a/makefile b/makefile new file mode 100755 index 0000000..9be23b8 --- /dev/null +++ b/makefile @@ -0,0 +1,63 @@ +cc_cross=/home/wangyu/Desktop/arm-2014.05/bin/arm-none-linux-gnueabi-g++ +cc_local=g++ +#cc_mips34kc=/toolchains/OpenWrt-SDK-ar71xx-for-linux-x86_64-gcc-4.8-linaro_uClibc-0.9.33.2/staging_dir/toolchain-mips_34kc_gcc-4.8-linaro_uClibc-0.9.33.2/bin/mips-openwrt-linux-g++ +cc_mips24kc_be=/toolchains/lede-sdk-17.01.2-ar71xx-generic_gcc-5.4.0_musl-1.1.16.Linux-x86_64/staging_dir/toolchain-mips_24kc_gcc-5.4.0_musl-1.1.16/bin/mips-openwrt-linux-musl-g++ +cc_mips24kc_le=/toolchains/lede-sdk-17.01.2-ramips-mt7621_gcc-5.4.0_musl-1.1.16.Linux-x86_64/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl-1.1.16/bin/mipsel-openwrt-linux-musl-g++ +#cc_arm= /toolchains/gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabi/bin/arm-linux-gnueabi-g++ -march=armv6 -marm +cc_arm= /toolchains/arm-2014.05/bin/arm-none-linux-gnueabi-g++ +#cc_bcm2708=/home/wangyu/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-g++ +FLAGS= -std=c++11 -Wall -Wextra -Wno-unused-variable -Wno-unused-parameter -Wno-missing-field-initializers + +SOURCES=main.cpp log.cpp common.cpp + +NAME=forwarder +TARGETS=amd64 arm mips24kc_be x86 mips24kc_le + +TAR=${NAME}_binaries.tar.gz `echo ${TARGETS}|sed -r 's/([^ ]+)/forwarder_\1/g'` + +all:git_version + rm -f ${NAME} + ${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -ggdb -static -O3 +fast: git_version + rm -f ${NAME} + ${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -ggdb +debug: git_version + rm -f ${NAME} + ${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -Wformat-nonliteral -D MY_DEBUG +debug2: git_version + rm -f ${NAME} + ${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -Wformat-nonliteral -ggdb + +mips24kc_be: git_version + ${cc_mips24kc_be} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -lgcc_eh -static -O3 + +mips24kc_le: git_version + ${cc_mips24kc_le} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -lgcc_eh -static -O3 + +amd64:git_version + ${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O3 +x86:git_version + ${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O3 -m32 +arm:git_version + ${cc_arm} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O3 + +cross:git_version + ${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -O3 + +cross2:git_version + ${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -static -lgcc_eh -O3 + +cross3:git_version + ${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -static -O3 + +release: ${TARGETS} + tar -zcvf ${TAR} + +clean: + rm -f ${TAR} + rm -f forwarder forwarder_cross + rm -f git_version.h + +git_version: + echo "const char *gitversion = \"$(shell git rev-parse HEAD)\";" > git_version.h +