diff --git a/connection.cpp b/connection.cpp index 454344a..d225036 100644 --- a/connection.cpp +++ b/connection.cpp @@ -9,13 +9,14 @@ #include "encrypt.h" #include "fd_manager.h" - int disable_anti_replay=0;//if anti_replay windows is diabled -const int disable_conv_clear=0;//a udp connection in the multiplexer is called conversation in this program,conv for short. + const int disable_conn_clear=0;//a raw connection is called conn. +conn_manager_t conn_manager; + anti_replay_seq_t anti_replay_t::get_new_seq_for_send() { return anti_replay_seq++; @@ -73,154 +74,6 @@ const int disable_conn_clear=0;//a raw connection is called conn. } -void server_clear_function(u64_t u64); - -conv_manager_t::conv_manager_t() - { - clear_it=conv_last_active_time.begin(); - long long last_clear_time=0; - //clear_function=0; - } -conv_manager_t::~conv_manager_t() - { - clear(); - } - int conv_manager_t::get_size() - { - return conv_to_u64.size(); - } - void conv_manager_t::reserve() - { - u64_to_conv.reserve(10007); - conv_to_u64.reserve(10007); - conv_last_active_time.reserve(10007); - } - void conv_manager_t::clear() - { - if(disable_conv_clear) return ; - - if(program_mode==server_mode) - { - for(it=conv_to_u64.begin();it!=conv_to_u64.end();it++) - { - //int fd=int((it->second<<32u)>>32u); - server_clear_function( it->second); - } - } - u64_to_conv.clear(); - conv_to_u64.clear(); - conv_last_active_time.clear(); - - clear_it=conv_last_active_time.begin(); - - } - u32_t conv_manager_t::get_new_conv() - { - u32_t conv=get_true_random_number_nz(); - while(conv_to_u64.find(conv)!=conv_to_u64.end()) - { - conv=get_true_random_number_nz(); - } - return conv; - } - int conv_manager_t::is_conv_used(u32_t conv) - { - return conv_to_u64.find(conv)!=conv_to_u64.end(); - } - int conv_manager_t::is_u64_used(u64_t u64) - { - return u64_to_conv.find(u64)!=u64_to_conv.end(); - } - u32_t conv_manager_t::find_conv_by_u64(u64_t u64) - { - return u64_to_conv[u64]; - } - u64_t conv_manager_t::find_u64_by_conv(u32_t conv) - { - return conv_to_u64[conv]; - } - int conv_manager_t::update_active_time(u32_t conv) - { - return conv_last_active_time[conv]=get_current_time(); - } - int conv_manager_t::insert_conv(u32_t conv,u64_t u64) - { - u64_to_conv[u64]=conv; - conv_to_u64[conv]=u64; - conv_last_active_time[conv]=get_current_time(); - return 0; - } - int conv_manager_t::erase_conv(u32_t conv) - { - if(disable_conv_clear) return 0; - u64_t u64=conv_to_u64[conv]; - if(program_mode==server_mode) - { - server_clear_function(u64); - } - conv_to_u64.erase(conv); - u64_to_conv.erase(u64); - conv_last_active_time.erase(conv); - return 0; - } - int conv_manager_t::clear_inactive(char * ip_port) - { - if(get_current_time()-last_clear_time>conv_clear_interval) - { - last_clear_time=get_current_time(); - return clear_inactive0(ip_port); - } - return 0; - } - int conv_manager_t::clear_inactive0(char * ip_port) - { - if(disable_conv_clear) return 0; - - - //map::iterator it; - int cnt=0; - it=clear_it; - int size=conv_last_active_time.size(); - int num_to_clean=size/conv_clear_ratio+conv_clear_min; //clear 1/10 each time,to avoid latency glitch - - num_to_clean=min(num_to_clean,size); - - u64_t current_time=get_current_time(); - for(;;) - { - if(cnt>=num_to_clean) break; - if(conv_last_active_time.begin()==conv_last_active_time.end()) break; - - if(it==conv_last_active_time.end()) - { - it=conv_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 conv= old_it->first; - erase_conv(old_it->first); - if(ip_port==0) - { - mylog(log_info,"conv %x cleared\n",conv); - } - else - { - mylog(log_info,"[%s]conv %x cleared\n",ip_port,conv); - } - } - else - { - it++; - } - cnt++; - } - clear_it=it; - return 0; - } void conn_info_t::recover(const conn_info_t &conn_info) @@ -266,18 +119,24 @@ conv_manager_t::~conv_manager_t() } void conn_info_t::prepare() { + assert(blob==0); blob=new blob_t; - - } - conn_info_t::conn_info_t(const conn_info_t&b) - { - //mylog(log_error,"called!!!!!!!!!!!!!\n"); - *this=b; - if(blob!=0) + if(program_mode==server_mode) { - blob=new blob_t(*b.blob); + blob->conv_manager.s.additional_clear_function=server_clear_function; + } + else + { + assert(program_mode==client_mode); } } + + conn_info_t::conn_info_t(const conn_info_t&b) + { + assert(0==1); + //mylog(log_error,"called!!!!!!!!!!!!!\n"); + } + conn_info_t& conn_info_t::operator=(const conn_info_t& b) { mylog(log_fatal,"not allowed\n"); @@ -310,6 +169,181 @@ conv_manager_t::~conv_manager_t() } + conn_manager_t::conn_manager_t() + { + ready_num=0; + mp.reserve(10007); + //clear_it=mp.begin(); + // timer_fd_mp.reserve(10007); + const_id_mp.reserve(10007); + // udp_fd_mp.reserve(100007); + last_clear_time=0; + //current_ready_ip=0; + // current_ready_port=0; + } + int conn_manager_t::exist(address_t addr) + { + //u64_t u64=0; + //u64=ip; + //u64<<=32u; + //u64|=port; + if(mp.find(addr)!=mp.end()) + { + return 1; + } + return 0; + } + /* + int insert(uint32_t ip,uint16_t port) + { + uint64_t u64=0; + u64=ip; + u64<<=32u; + u64|=port; + mp[u64]; + return 0; + }*/ + conn_info_t *& conn_manager_t::find_insert_p(address_t addr) //be aware,the adress may change after rehash + { + // u64_t u64=0; + //u64=ip; + //u64<<=32u; + //u64|=port; + unordered_map::iterator it=mp.find(addr); + if(it==mp.end()) + { + mp[addr]=new conn_info_t; + //lru.new_key(addr); + } + else + { + //lru.update(addr); + } + return mp[addr]; + } + conn_info_t & conn_manager_t::find_insert(address_t addr) //be aware,the adress may change after rehash + { + //u64_t u64=0; + //u64=ip; + //u64<<=32u; + //u64|=port; + unordered_map::iterator it=mp.find(addr); + if(it==mp.end()) + { + mp[addr]=new conn_info_t; + //lru.new_key(addr); + } + else + { + //lru.update(addr); + } + return *mp[addr]; + } + int conn_manager_t::erase(unordered_map::iterator erase_it) + { + if(erase_it->second->state.server_current_state==server_ready) + { + ready_num--; + assert(i32_t(ready_num)!=-1); + assert(erase_it->second!=0); + + assert(erase_it->second->timer_fd64 !=0); + + assert(fd_manager.exist(erase_it->second->timer_fd64)); + + assert(erase_it->second->oppsite_const_id!=0); + assert(const_id_mp.find(erase_it->second->oppsite_const_id)!=const_id_mp.end()); + + + //assert(timer_fd_mp.find(erase_it->second->timer_fd)!=timer_fd_mp.end()); + + const_id_mp.erase(erase_it->second->oppsite_const_id); + + fd_manager.fd64_close(erase_it->second->timer_fd64); + + erase_it->second->timer_fd64=0; + //timer_fd_mp.erase(erase_it->second->timer_fd); + //close(erase_it->second->timer_fd);// close will auto delte it from epoll + delete(erase_it->second); + mp.erase(erase_it->first); + } + else + { + assert(erase_it->second->blob==0); + assert(erase_it->second->timer_fd64 ==0); + + + assert(erase_it->second->oppsite_const_id==0); + delete(erase_it->second); + mp.erase(erase_it->first); + } + return 0; + } +int conn_manager_t::clear_inactive() +{ + if(get_current_time()-last_clear_time>conn_clear_interval) + { + last_clear_time=get_current_time(); + return clear_inactive0(); + } + return 0; +} +int conn_manager_t::clear_inactive0() +{ + unordered_map::iterator it; + unordered_map::iterator old_it; + + if(disable_conn_clear) return 0; + + //map::iterator it; + int cnt=0; + it=clear_it; + int size=mp.size(); + int num_to_clean=size/conn_clear_ratio+conn_clear_min; //clear 1/10 each time,to avoid latency glitch + + mylog(log_trace,"mp.size() %d\n", size); + + num_to_clean=min(num_to_clean,(int)mp.size()); + u64_t current_time=get_current_time(); + + for(;;) + { + if(cnt>=num_to_clean) break; + if(mp.begin()==mp.end()) break; + + if(it==mp.end()) + { + it=mp.begin(); + } + + if(it->second->state.server_current_state==server_ready &¤t_time - it->second->last_hb_recv_time <=server_conn_timeout) + { + it++; + } + else if(it->second->state.server_current_state!=server_ready&& current_time - it->second->last_state_time <=server_handshake_timeout ) + { + it++; + } + else if(it->second->blob!=0&&it->second->blob->conv_manager.s.get_size() >0) + { + assert(it->second->state.server_current_state==server_ready); + it++; + } + else + { + mylog(log_info,"[%s:%d]inactive conn cleared \n",it->second->raw_info.recv_info.new_src_ip.get_str1(),it->second->raw_info.recv_info.src_port); + old_it=it; + it++; + erase(old_it); + } + cnt++; + } + clear_it=it; + + return 0; +} + + int send_bare(raw_info_t &raw_info,const char* data,int len)//send function with encryption but no anti replay,this is used when client and server verifys each other //you have to design the protocol carefully, so that you wont be affect by relay attack diff --git a/connection.h b/connection.h index ea0d295..ed15208 100644 --- a/connection.h +++ b/connection.h @@ -16,7 +16,7 @@ extern int disable_anti_replay; #include "network.h" #include "misc.h" -//const int disable_conv_clear=0;//a udp connection in the multiplexer is called conversation in this program,conv for short. +const int disable_conv_clear=0;//a udp connection in the multiplexer is called conversation in this program,conv for short. struct anti_replay_t //its for anti replay attack,similar to openvpn/ipsec 's anti replay window @@ -35,23 +35,170 @@ void server_clear_function(u64_t u64); #include +template struct conv_manager_t // manage the udp connections { //typedef hash_map map; - unordered_map u64_to_conv; //conv and u64 are both supposed to be uniq - unordered_map conv_to_u64; + unordered_map data_to_conv; //conv and u64 are both supposed to be uniq + unordered_map conv_to_data; - unordered_map conv_last_active_time; + lru_collector_t lru; + //unordered_map conv_last_active_time; - unordered_map::iterator clear_it; + //unordered_map::iterator clear_it; - unordered_map::iterator it; - unordered_map::iterator old_it; - - //void (*clear_function)(uint64_t u64) ; + void (*additional_clear_function)(T data) =0; long long last_clear_time; + conv_manager_t() + { + //clear_it=conv_last_active_time.begin(); + long long last_clear_time=0; + additional_clear_function=0; + } + ~conv_manager_t() + { + clear(); + } + int get_size() + { + return conv_to_data.size(); + } + void reserve() + { + data_to_conv.reserve(10007); + conv_to_data.reserve(10007); + //conv_last_active_time.reserve(10007); + + lru.mp.reserve(10007); + } + void clear() + { + if(disable_conv_clear) return ; + + if(additional_clear_function!=0) + { + for(auto it=conv_to_data.begin();it!=conv_to_data.end();it++) + { + //int fd=int((it->second<<32u)>>32u); + additional_clear_function( it->second); + } + } + data_to_conv.clear(); + conv_to_data.clear(); + + lru.clear(); + //conv_last_active_time.clear(); + + //clear_it=conv_last_active_time.begin(); + + } + u32_t get_new_conv() + { + u32_t conv=get_true_random_number_nz(); + while(conv_to_data.find(conv)!=conv_to_data.end()) + { + conv=get_true_random_number_nz(); + } + return conv; + } + int is_conv_used(u32_t conv) + { + return conv_to_data.find(conv)!=conv_to_data.end(); + } + int is_data_used(T data) + { + return data_to_conv.find(data)!=data_to_conv.end(); + } + u32_t find_conv_by_data(T data) + { + return data_to_conv[data]; + } + T find_data_by_conv(u32_t conv) + { + return conv_to_data[conv]; + } + int update_active_time(u32_t conv) + { + //return conv_last_active_time[conv]=get_current_time(); + lru.update(conv); + return 0; + } + int insert_conv(u32_t conv,T data) + { + data_to_conv[data]=conv; + conv_to_data[conv]=data; + //conv_last_active_time[conv]=get_current_time(); + lru.new_key(conv); + return 0; + } + int erase_conv(u32_t conv) + { + if(disable_conv_clear) return 0; + T data=conv_to_data[conv]; + if(additional_clear_function!=0) + { + additional_clear_function(data); + } + conv_to_data.erase(conv); + data_to_conv.erase(data); + //conv_last_active_time.erase(conv); + lru.erase(conv); + return 0; + } + int clear_inactive(char * info=0) + { + if(get_current_time()-last_clear_time>conv_clear_interval) + { + last_clear_time=get_current_time(); + return clear_inactive0(info); + } + return 0; + } + int clear_inactive0(char * info) + { + if(disable_conv_clear) return 0; + + + unordered_map::iterator it; + unordered_map::iterator old_it; + + //map::iterator it; + int cnt=0; + //it=clear_it; + int size=lru.size(); + int num_to_clean=size/conv_clear_ratio+conv_clear_min; //clear 1/10 each time,to avoid latency glitch + + num_to_clean=min(num_to_clean,size); + + my_time_t current_time=get_current_time(); + for(;;) + { + if(cnt>=num_to_clean) break; + if(lru.empty()) break; + + u32_t conv; + my_time_t ts=lru.peek_back(conv); + + if(current_time- ts < conv_timeout) break; + + erase_conv(conv); + if(info==0) + { + mylog(log_info,"conv %x cleared\n",conv); + } + else + { + mylog(log_info,"[%s]conv %x cleared\n",info,conv); + } + cnt++; + } + return 0; + } + + + /* conv_manager_t(); ~conv_manager_t(); int get_size(); @@ -59,20 +206,50 @@ struct conv_manager_t // manage the udp connections void clear(); u32_t get_new_conv(); int is_conv_used(u32_t conv); - int is_u64_used(u64_t u64); - u32_t find_conv_by_u64(u64_t u64); - u64_t find_u64_by_conv(u32_t conv); + int is_u64_used(T u64); + u32_t find_conv_by_u64(T u64); + T find_u64_by_conv(u32_t conv); int update_active_time(u32_t conv); - int insert_conv(u32_t conv,u64_t u64); + int insert_conv(u32_t conv,T u64); int erase_conv(u32_t conv); int clear_inactive(char * ip_port=0); - int clear_inactive0(char * ip_port); + int clear_inactive0(char * ip_port);*/ };//g_conv_manager; -struct blob_t //used in conn_info_t. conv_manager_t and anti_replay_t are costly data structures ,we dont allocate them until its necessary +struct blob_t:not_copy_able_t //used in conn_info_t. { - conv_manager_t conv_manager; - anti_replay_t anti_replay; + union tmp_union_t//conv_manager_t is here to avoid copying when a connection is recovered + { + conv_manager_t c; + conv_manager_t s; + //avoid templates here and there, avoid pointer and type cast + tmp_union_t() + { + if(program_mode==client_mode) + { + new( &c ) conv_manager_t(); + } + else + { + assert(program_mode==server_mode); + new( &s ) conv_manager_t(); + } + } + ~tmp_union_t() + { + if(program_mode==client_mode) + { + c.~conv_manager_t(); + } + else + { + assert(program_mode==server_mode); + s.~conv_manager_t(); + } + } + }conv_manager; + + anti_replay_t anti_replay;//anti_replay_t is here bc its huge,its allocation is delayed. }; struct conn_info_t //stores info for a raw connection.for client ,there is only one connection,for server there can be thousand of connection since server can //handle multiple clients @@ -90,6 +267,7 @@ struct conn_info_t //stores info for a raw connection.for client ,there is o fd64_t timer_fd64; + fd64_t udp_fd64; my_id_t oppsite_const_id; @@ -104,7 +282,6 @@ struct conn_info_t //stores info for a raw connection.for client ,there is o /* const uint32_t &ip=raw_info.recv_info.src_ip; const uint16_t &port=raw_info.recv_info.src_port; - */ void recover(const conn_info_t &conn_info); void re_init(); @@ -125,14 +302,16 @@ struct conn_manager_t //manager for connections. for client,we dont need conn_m unordered_map const_id_mp; - unordered_map mp; //put it at end so that it de-consturcts first + unordered_map mp; //put it at end so that it de-consturcts first - unordered_map::iterator clear_it; + //lru_collector_t lru; + + unordered_map::iterator clear_it; long long last_clear_time; conn_manager_t(); - int exist(u32_t ip,uint16_t port); + int exist(address_t addr); /* int insert(uint32_t ip,uint16_t port) { @@ -143,10 +322,10 @@ struct conn_manager_t //manager for connections. for client,we dont need conn_m mp[u64]; return 0; }*/ - conn_info_t *& find_insert_p(u32_t ip,uint16_t port); //be aware,the adress may change after rehash - conn_info_t & find_insert(u32_t ip,uint16_t port) ; //be aware,the adress may change after rehash + conn_info_t *& find_insert_p(address_t addr); //be aware,the adress may change after rehash //not true? + conn_info_t & find_insert(address_t addr) ; //be aware,the adress may change after rehash - int erase(unordered_map::iterator erase_it); + int erase(unordered_map::iterator erase_it); int clear_inactive(); int clear_inactive0(); diff --git a/main.cpp b/main.cpp index c5df706..1991b6b 100755 --- a/main.cpp +++ b/main.cpp @@ -29,7 +29,7 @@ int client_on_timer(conn_info_t &conn_info) //for client. called when a timer is packet_info_t &send_info=conn_info.raw_info.send_info; packet_info_t &recv_info=conn_info.raw_info.recv_info; raw_info_t &raw_info=conn_info.raw_info; - conn_info.blob->conv_manager.clear_inactive(); + conn_info.blob->conv_manager.c.clear_inactive(); mylog(log_trace,"timer!\n"); mylog(log_trace,"roller my %d,oppsite %d,%lld\n",int(conn_info.my_roller),int(conn_info.oppsite_roller),conn_info.last_oppsite_roller_time); @@ -541,34 +541,34 @@ int client_on_raw_recv(conn_info_t &conn_info) //called when raw fd received a p memcpy(&tmp_conv_id,&data[0],sizeof(tmp_conv_id)); tmp_conv_id=ntohl(tmp_conv_id); - if(!conn_info.blob->conv_manager.is_conv_used(tmp_conv_id)) + if(!conn_info.blob->conv_manager.c.is_conv_used(tmp_conv_id)) { mylog(log_info,"unknow conv %d,ignore\n",tmp_conv_id); return 0; } - conn_info.blob->conv_manager.update_active_time(tmp_conv_id); + conn_info.blob->conv_manager.c.update_active_time(tmp_conv_id); - u64_t u64=conn_info.blob->conv_manager.find_u64_by_conv(tmp_conv_id); + //u64_t u64=conn_info.blob->conv_manager.c.find_dat_by_conv(tmp_conv_id); + address_t addr=conn_info.blob->conv_manager.c.find_data_by_conv(tmp_conv_id); + + //sockaddr_in tmp_sockaddr={0}; + + //tmp_sockaddr.sin_family = AF_INET; + //tmp_sockaddr.sin_addr.s_addr=(u64>>32u); + + //tmp_sockaddr.sin_port= htons(uint16_t((u64<<32u)>>32u)); - sockaddr_in tmp_sockaddr={0}; - - tmp_sockaddr.sin_family = AF_INET; - tmp_sockaddr.sin_addr.s_addr=(u64>>32u); - - tmp_sockaddr.sin_port= htons(uint16_t((u64<<32u)>>32u)); - - - int ret=sendto(udp_fd,data+sizeof(u32_t),data_len -(sizeof(u32_t)),0,(struct sockaddr *)&tmp_sockaddr,sizeof(tmp_sockaddr)); + int ret=sendto(udp_fd,data+sizeof(u32_t),data_len -(sizeof(u32_t)),0,(struct sockaddr *)&addr.inner,addr.get_len()); if(ret<0) { mylog(log_warn,"sento returned %d\n",ret); } - 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); + //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); } else { @@ -593,13 +593,14 @@ void udp_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) conn_info_t & conn_info= *((conn_info_t*)watcher->data);; int recv_len; - struct sockaddr_in udp_new_addr_in={0}; - socklen_t udp_new_addr_len = sizeof(sockaddr_in); - if ((recv_len = recvfrom(udp_fd, buf, max_data_len+1, 0, + address_t addr; + + address_t::storage_t udp_new_addr_in={0}; + socklen_t udp_new_addr_len = sizeof(address_t::storage_t); + if ((recv_len = recvfrom(udp_fd, buf, max_data_len, 0, (struct sockaddr *) &udp_new_addr_in, &udp_new_addr_len)) == -1) { - mylog(log_debug,"recv_from error,this shouldnt happen at client,but lets try to continue\n"); - return ; - //myexit(1); + mylog(log_debug,"recv_from error,this shouldnt happen,err=%s,but we can try to continue\n",get_sock_error()); + return; }; if(recv_len==max_data_len+1) @@ -612,29 +613,32 @@ void udp_accept_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) { 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 ",recv_len,mtu_warn); } - mylog(log_trace,"Received packet from %s:%d,len: %d\n", inet_ntoa(udp_new_addr_in.sin_addr), - ntohs(udp_new_addr_in.sin_port),recv_len); + //mylog(log_trace,"Received packet from %s:%d,len: %d\n", inet_ntoa(udp_new_addr_in.sin_addr), + //ntohs(udp_new_addr_in.sin_port),recv_len); - u64_t u64=((u64_t(udp_new_addr_in.sin_addr.s_addr))<<32u)+ntohs(udp_new_addr_in.sin_port); + addr.from_sockaddr((struct sockaddr *) &udp_new_addr_in,udp_new_addr_len); + + //u64_t u64=((u64_t(udp_new_addr_in.sin_addr.s_addr))<<32u)+ntohs(udp_new_addr_in.sin_port); u32_t conv; - if(!conn_info.blob->conv_manager.is_u64_used(u64)) + if(!conn_info.blob->conv_manager.c.is_data_used(addr)) { - if(conn_info.blob->conv_manager.get_size() >=max_conv_num) + if(conn_info.blob->conv_manager.c.get_size() >=max_conv_num) { mylog(log_warn,"ignored new udp connect bc max_conv_num exceed\n"); return; } - conv=conn_info.blob->conv_manager.get_new_conv(); - conn_info.blob->conv_manager.insert_conv(conv,u64); - mylog(log_info,"new packet from %s:%d,conv_id=%x\n",inet_ntoa(udp_new_addr_in.sin_addr),ntohs(udp_new_addr_in.sin_port),conv); + conv=conn_info.blob->conv_manager.c.get_new_conv(); + conn_info.blob->conv_manager.c.insert_conv(conv,addr); + //mylog(log_info,"new packet from %s:%d,conv_id=%x\n",inet_ntoa(udp_new_addr_in.sin_addr),ntohs(udp_new_addr_in.sin_port),conv); + mylog(log_info,"new packet from %s,conv_id=%x\n",addr.get_str(),conv); } else { - conv=conn_info.blob->conv_manager.find_conv_by_u64(u64); + conv=conn_info.blob->conv_manager.c.find_conv_by_data(addr); } - conn_info.blob->conv_manager.update_active_time(conv); + conn_info.blob->conv_manager.c.update_active_time(conv); if(conn_info.state.client_current_state==client_ready) { @@ -970,14 +974,6 @@ int client_event_loop() if(fifo_file[0]!=0) { fifo_fd=create_fifo(fifo_file); - //ev.events = EPOLLIN; - //ev.data.u64 = fifo_fd; - - //ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, fifo_fd, &ev); - //if (ret!= 0) { - // mylog(log_fatal,"add fifo_fd to epoll error %s\n",strerror(errno)); - // myexit(-1); - //} ev_io_init(&fifo_watcher, fifo_cb, fifo_fd, EV_READ); ev_io_start(loop, &fifo_watcher); @@ -986,49 +982,6 @@ int client_event_loop() } ev_run(loop, 0); - /* - while(1)//////////////////////// - { - if(about_to_exit) myexit(0); - epoll_trigger_counter++; - int nfds = epoll_wait(epollfd, events, max_events, 180 * 1000); - if (nfds < 0) { //allow zero - if(errno==EINTR ) - { - mylog(log_info,"epoll interrupted by signal,continue\n"); - } - else - { - mylog(log_fatal,"epoll_wait return %d,%s\n", nfds,strerror(errno)); - myexit(-1); - } - } - int idx; - for (idx = 0; idx < nfds; ++idx) { - if (events[idx].data.u64 == (u64_t)raw_recv_fd) - { - iphdr *iph;tcphdr *tcph; - - } - else if(events[idx].data.u64 ==(u64_t)timer_fd) - { - - } - else if (events[idx].data.u64 == (u64_t)fifo_fd) - { - } - else if (events[idx].data.u64 == (u64_t)udp_fd) - { - - } - else - { - mylog(log_fatal,"unknown fd,this should never happen\n"); - myexit(-1); - } - } - }*/ - return 0; } diff --git a/misc.cpp b/misc.cpp index 1237c11..22510e8 100644 --- a/misc.cpp +++ b/misc.cpp @@ -401,6 +401,13 @@ void process_arg(int argc, char *argv[]) //process all options switch (opt) { case 'l': no_l = 0; + local_addr.from_str(optarg); + if(local_addr.get_port()==22) + { + mylog(log_fatal,"port 22 not allowed\n"); + myexit(-1); + } + /* if (strchr(optarg, ':') != 0) { sscanf(optarg, "%[^:]:%d", local_ip, &local_port); if(local_port==22) @@ -411,11 +418,17 @@ void process_arg(int argc, char *argv[]) //process all options } else { mylog(log_fatal,"invalid parameter for -l ,%s,should be ip:port\n",optarg); myexit(-1); - - } + }*/ break; case 'r': no_r = 0; + remote_addr.from_str(optarg); + if(remote_addr.get_port()==22) + { + mylog(log_fatal,"port 22 not allowed\n"); + myexit(-1); + } + /* if (strchr(optarg, ':') != 0) { sscanf(optarg, "%[^:]:%d", remote_address, &remote_port); if(remote_port==22) @@ -426,7 +439,7 @@ void process_arg(int argc, char *argv[]) //process all options } else { mylog(log_fatal,"invalid parameter for -r ,%s,should be ip:port\n",optarg); myexit(-1); - } + }*/ break; case 's': if(program_mode==0) diff --git a/network.h b/network.h index ab091df..651f871 100644 --- a/network.h +++ b/network.h @@ -218,6 +218,9 @@ struct packet_info_t //todo change this to union u32_t src_ip; u32_t dst_ip; + my_ip_t new_src_ip; + my_ip_t new_dst_ip; + uint16_t src_port; uint16_t dst_port;