From fc5cbc9b0c865ea66ef334325a56be3586211916 Mon Sep 17 00:00:00 2001 From: wangyu- Date: Fri, 15 Sep 2017 04:07:59 -0500 Subject: [PATCH] added classic --- classic.cpp | 1273 +++++++++++++++++++++++++++++++++++++++++++++++++++ classic.h | 18 + main.cpp | 1 + makefile | 4 +- packet.cpp | 2 +- 5 files changed, 1295 insertions(+), 3 deletions(-) create mode 100644 classic.cpp create mode 100644 classic.h diff --git a/classic.cpp b/classic.cpp new file mode 100644 index 0000000..8099186 --- /dev/null +++ b/classic.cpp @@ -0,0 +1,1273 @@ +/* + * classic.cpp + * + * Created on: Sep 15, 2017 + * Author: root + */ + + + +#include "common.h" +#include "log.h" +#include "git_version.h" + +namespace classic +{ + + +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_conv_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 random_between(u32_t a,u32_t b) +{ + if(a>b) + { + mylog(log_fatal,"min >max?? %d %d\n",a ,b); + myexit(1); + } + if(a==b)return a; + else return a+get_true_random_number()%(b+1-a); +} + + +int VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV; + +struct anti_replay_t +{ + u64_t max_packet_received; + + u64_t replay_buffer[anti_replay_buff_size]; + unordered_set st; + u32_t const_id; + u32_t anti_replay_seq; + int index; + anti_replay_seq_t get_new_seq_for_send() + { + anti_replay_seq_t res=const_id; + res<<=32u; + anti_replay_seq++; + res|=anti_replay_seq; + return res; + } + void prepare() + { + anti_replay_seq=get_true_random_number();//random first seq + const_id=get_true_random_number_nz(); + } + anti_replay_t() + { + memset(replay_buffer,0,sizeof(replay_buffer)); + st.rehash(anti_replay_buff_size*10); + max_packet_received=0; + index=0; + } + + int is_vaild(u64_t seq) + { + //if(disable_replay_filter) return 1; + if(seq==0) + { + mylog(log_debug,"seq=0\n"); + return 0; + } + if(st.find(seq)!=st.end() ) + { + mylog(log_trace,"seq %llx exist\n",seq); + return 0; + } + + if(replay_buffer[index]!=0) + { + assert(st.find(replay_buffer[index])!=st.end()); + st.erase(replay_buffer[index]); + } + replay_buffer[index]=seq; + st.insert(seq); + index++; + if(index==int(anti_replay_buff_size)) index=0; + + return 1; //for complier check + } +}anti_replay; +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_conv_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) + { + u64_to_fd[u64]=fd; + fd_to_u64[fd]=u64; + fd_last_active_time[fd]=get_current_time(); + return 0; + } + int erase_fd(u32_t fd) + { + if(disable_conv_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_conv_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; + +typedef u64_t my_time_t; + +struct delay_data +{ + int fd; + int times_left; + char * data; + int len; + u64_t u64; +}; +int delay_timer_fd; + +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); +} + +multimap delay_mp; + +int add_to_delay_mp(int fd,int times_left,u32_t delay,char * buf,int len,u64_t u64) +{ + if(max_pending_packet!=0&&int(delay_mp.size()) >=max_pending_packet) + { + mylog(log_warn,"max pending packet reached,ignored\n"); + return 0; + } + delay_data tmp; + tmp.data = buf; + tmp.fd = fd; + tmp.times_left = times_left; + tmp.len = len; + tmp.u64=u64; + my_time_t tmp_time=get_current_time_us(); + tmp_time+=delay*100; + delay_mp.insert(make_pair(tmp_time,tmp)); + + return 0; +} +int add_and_new(int fd,int times_left,u32_t delay,char * buf,int len,u64_t u64) +{ + if(times_left<=0) return -1; + + char * str= (char *)malloc(len); + memcpy(str,buf,len); + add_to_delay_mp(fd,times_left,delay,str,len,u64); + return 0; +} + +multimap new_delay_mp; + + + +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 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; + + output[iv_len+in_len]^=output[0]; + output[iv_len+in_len]^=key_string[0]; + + for(i=0,j=0,k=1;i 65535||in_len<0) + { + mylog(log_debug,"in_len > 65535||in_len<0 , %d",in_len); + return -1; + } + int iv_len= int ((uint8_t)(input[in_len-1]^input[0]^key_string[0]) ); + out_len=in_len-1-iv_len; + if(out_len<0) + { + mylog(log_debug,"%d %d\n",in_len,out_len); + return -1; + } + for(i=0,j=0,k=1;i::iterator it; + while(1) + { + int ret=0; + it=delay_mp.begin(); + if(it==delay_mp.end()) break; + + current_time=get_current_time_us(); + if(it->first < current_time||it->first ==current_time) + { + if (is_client) { + if (conn_manager.exist_fd(it->second.fd)) { + u64_t u64 = conn_manager.find_u64_by_fd(it->second.fd); + if (u64 != it->second.u64) { + it->second.times_left = 0; //fd has been deleted and recreated + // 偷懒的做法 + } else { + char new_data[buf_len]; + int new_len = 0; + do_obscure(it->second.data, it->second.len, + new_data, new_len); + ret = send_fd(it->second.fd, new_data, new_len, 0); + } + } else { + it->second.times_left = 0; + } + } else { + + if (conn_manager.exist_fd(it->second.fd)) { + u64_t u64 = conn_manager.find_u64_by_fd(it->second.fd); + if (u64 != it->second.u64) { + it->second.times_left = 0;//fd has been deleted and recreated + // 偷懒的做法 + } else { + char new_data[buf_len]; + int new_len = 0; + do_obscure(it->second.data, it->second.len, + new_data, new_len); + sendto_u64(local_listen_fd, new_data, new_len, 0, + u64); + } + } else { + it->second.times_left = 0; + } + } + if (ret < 0) { + mylog(log_debug, "send return %d at @300", ret); + } + + + if(it->second.times_left>1) + { + //delay_mp.insert(pair(current_time)); + add_to_delay_mp(it->second.fd,it->second.times_left-1,random_between(dup_delay_min,dup_delay_max),it->second.data,it->second.len,it->second.u64); + } + 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.tv_sec=delay_mp.begin()->first/1000000llu; + its.it_value.tv_nsec=(delay_mp.begin()->first%1000000llu)*1000llu; + timerfd_settime(delay_timer_fd,TFD_TIMER_ABSTIME,&its,0); + } + } +} +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); + + + + if ((delay_timer_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK)) < 0) + { + mylog(log_fatal,"timer_fd create error"); + myexit(1); + } + ev.events = EPOLLIN; + ev.data.fd = delay_timer_fd; + + itimerspec zero_its; + memset(&zero_its, 0, sizeof(zero_its)); + + timerfd_settime(delay_timer_fd, TFD_TIMER_ABSTIME, &zero_its, 0); + epoll_ctl(epollfd, EPOLL_CTL_ADD, delay_timer_fd, &ev); + if (ret < 0) + { + mylog(log_fatal,"epoll_ctl return %d\n", ret); + myexit(-1); + } + + 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)); + } + add_and_new(new_udp_fd, dup_num - 1,random_between(dup_delay_min,dup_delay_max), data, data_len,u64); + } + else + { + add_and_new(new_udp_fd, dup_num,random_between(jitter_min,jitter_max), data, data_len,u64); + } + packet_send_count++; + } + else + { + char new_data[buf_len]; + int new_len; + + if (de_obscure(data, data_len, new_data, new_len) != 0) { + mylog(log_trace,"de_obscure failed \n"); + continue; + } + //dup_packet_recv_count++; + if (remove_seq(new_data, new_len) != 0) { + mylog(log_trace,"remove_seq failed \n"); + continue; + } + //packet_recv_count++; + ret = send_fd(new_udp_fd, new_data,new_len, 0); + if (ret < 0) { + mylog(log_warn, "send returned %d,%s\n", ret,strerror(errno)); + //perror("what happened????"); + } + } + + + } + else if(events[n].data.fd == clear_timer_fd) + { + clear_triggered=1; + if(report_interval!=0 &&get_current_time()-last_report_time>u64_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 if (events[n].data.fd == delay_timer_fd) + { + uint64_t value; + read(delay_timer_fd, &value, 8); + //printf("",delay_mp.size()); + //fflush(stdout); + } + 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); + add_and_new(udp_fd, dup_num - 1,random_between(dup_delay_min,dup_delay_max), data, data_len,u64); + if (ret < 0) { + mylog(log_warn, "sento returned %d,%s\n", ret,strerror(errno)); + //perror("ret<0"); + } + } + else + { + add_and_new(udp_fd, dup_num,random_between(jitter_min,jitter_max), data, data_len,u64); + } + packet_send_count++; + + + } + + //mylog(log_trace, "%s :%d\n", inet_ntoa(tmp_sockaddr.sin_addr), + // ntohs(tmp_sockaddr.sin_port)); + //mylog(log_trace, "%d byte sent\n", ret); + + } + } + check_delay_map(); + conn_manager.check_clear_list(); + if(clear_triggered) // 删除操作在epoll event的最后进行，防止event cache中的fd失效。 + { + u64_t value; + read(clear_timer_fd, &value, 8); + mylog(log_trace, "timer!\n"); + conn_manager.clear_inactive(); + } + } + myexit(0); + return 0; +} +void print_help() +{ + char git_version_buf[100]={0}; + strncpy(git_version_buf,gitversion,10); + + printf("UDPspeeder\n"); + printf("git version:%s ",git_version_buf); + printf("build date:%s %s\n",__DATE__,__TIME__); + printf("repository: https://github.com/wangyu-/UDPspeeder\n"); + printf("\n"); + printf("usage:\n"); + printf(" run as client : ./this_program -c -l local_listen_ip:local_port -r server_ip:server_port [options]\n"); + printf(" run as server : ./this_program -s -l server_listen_ip:server_port -r remote_ip:remote_port [options]\n"); + printf("\n"); + printf("common option,must be same on both sides:\n"); + printf(" -k,--key 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<1||dup_delay>1000*100) + { + mylog(log_fatal,"dup_delay must be between 1 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<1 ||dup_delay_max<1||dup_delay_min>dup_delay_max) + { + mylog(log_fatal," must satisfy 1<=dmin<=dmax\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(); + anti_replay.prepare(); + + remote_address_uint32=inet_addr(remote_address); + + if(!multi_process_mode) + { + event_loop(); + } + else + { + } + + + return 0; +} +} diff --git a/classic.h b/classic.h new file mode 100644 index 0000000..8459ce4 --- /dev/null +++ b/classic.h @@ -0,0 +1,18 @@ +/* + * classic.h + * + * Created on: Sep 15, 2017 + * Author: root + */ + +#ifndef CLASSIC_H_ +#define CLASSIC_H_ + + +namespace classic +{ +int main(int argc, char *argv[]); +} + + +#endif /* CLASSIC_H_ */ diff --git a/main.cpp b/main.cpp index 9b39265..8e5c319 100644 --- a/main.cpp +++ b/main.cpp @@ -4,6 +4,7 @@ #include "lib/rs.h" #include "packet.h" #include "conn_manager.h" +#include "classic.h" using namespace std; typedef unsigned long long u64_t; //this works on most platform,avoid using the PRId64 diff --git a/makefile b/makefile index 35df01f..845a97b 100755 --- a/makefile +++ b/makefile @@ -8,7 +8,7 @@ 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 lib/fec.c lib/rs.c packet.cpp conn_manager.cpp +SOURCES=main.cpp log.cpp common.cpp lib/fec.c lib/rs.c packet.cpp conn_manager.cpp classic.cpp NAME=speeder TARGETS=amd64 arm mips24kc_be x86 mips24kc_le @@ -59,5 +59,5 @@ clean: rm -f git_version.h git_version: - echo "const char *gitversion = \"$(shell git rev-parse HEAD)\";" > git_version.h + echo "const char * const gitversion = \"$(shell git rev-parse HEAD)\";" > git_version.h diff --git a/packet.cpp b/packet.cpp index 618343c..8765999 100644 --- a/packet.cpp +++ b/packet.cpp @@ -121,7 +121,7 @@ int remove_seq(char * data,int &data_len) seq=ntoh64(seq); if(anti_replay.is_vaild(seq)==0) { - if(disable_replay_filter==1) + if(disable_replay_filter==1) //todo inefficient code,why did i put it here??? return 0; mylog(log_trace,"seq %llx dropped bc of replay-filter\n ",seq); return -1;