From 2072cfed8dfc76ca12567f5735c7a9323ac76e66 Mon Sep 17 00:00:00 2001 From: wangyu- Date: Wed, 29 Aug 2018 01:19:15 -0500 Subject: [PATCH] reduce diff with non-mp version --- common.h | 1 + network.cpp | 1434 +++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 1108 insertions(+), 327 deletions(-) diff --git a/common.h b/common.h index 70a02fc..f6e8fe9 100644 --- a/common.h +++ b/common.h @@ -408,6 +408,7 @@ int set_buf_size(int fd,int socket_buf_size); void myexit(int a); unsigned short csum(const unsigned short *ptr,int nbytes); +unsigned short csum_with_header(char* header,int hlen,const unsigned short *ptr,int nbytes); int numbers_to_char(my_id_t id1,my_id_t id2,my_id_t id3,char * &data,int &len); int char_to_numbers(const char * data,int len,my_id_t &id1,my_id_t &id2,my_id_t &id3); diff --git a/network.cpp b/network.cpp index 3564df4..01854a0 100644 --- a/network.cpp +++ b/network.cpp @@ -23,7 +23,7 @@ int disable_bpf_filter=0; //for test only,most time no need to disable this u32_t bind_address_uint32=0; -//int lower_level=0; +int lower_level=0; int lower_level_manual=0; int ifindex=-1; char if_name[100]=""; @@ -44,6 +44,15 @@ char g_packet_buf[buf_len]; //looks dirty but works well int g_packet_buf_len=-1; int g_packet_buf_cnt=0; +/* +union +{ + sockaddr_ll ll; + sockaddr_in ipv4; + sockaddr_in6 ipv6; +}g_sockaddr; +socklen_t g_sockaddr_len = -1;*/ + #ifndef NO_LIBNET libnet_t *libnet_handle; libnet_ptag_t g_ptag=0; @@ -78,7 +87,8 @@ struct bpf_program g_filter; int use_tcp_dummy_socket=0; -/* + +#if 0 struct sock_filter code_tcp_old[] = { { 0x28, 0, 0, 0x0000000c },//0 { 0x15, 0, 10, 0x00000800 },//1 @@ -107,8 +117,44 @@ struct sock_filter code_tcp[] = { { 0x6, 0, 0, 0x0000ffff },//9 { 0x6, 0, 0, 0x00000000 },//10 }; +/* +{ 0x28, 0, 0, 0x0000000c }, +{ 0x15, 0, 8, 0x00000800 }, +{ 0x30, 0, 0, 0x00000017 }, +{ 0x15, 0, 6, 0x00000006 }, +{ 0x28, 0, 0, 0x00000014 }, +{ 0x45, 4, 0, 0x00001fff }, +{ 0xb1, 0, 0, 0x0000000e }, +{ 0x48, 0, 0, 0x00000010 }, +{ 0x15, 0, 1, 0x0000fffe }, +{ 0x6, 0, 0, 0x0000ffff }, +{ 0x6, 0, 0, 0x00000000 }, +*/ + int code_tcp_port_index=6; +//tcpdump -i ens33 ip6 and tcp and dst port 65534 -dd +struct sock_filter code_tcp6[] = { +//{ 0x28, 0, 0, 0x0000000c },//0 +//{ 0x15, 0, 5, 0x000086dd },//1 +{ 0x30, 0, 0, 0x00000006 },//2 +{ 0x15, 0, 3, 0x00000006 },//3 +{ 0x28, 0, 0, 0x0000002a },//4 +{ 0x15, 0, 1, 0x0000fffe },//5 +{ 0x6, 0, 0, 0x00040000 },//6 +{ 0x6, 0, 0, 0x00000000 },//7 +};//note: this filter doesnt support extension headers +/* + { 0x30, 0, 0, 0x00000014 },//2 +{ 0x15, 0, 3, 0x00000006 },//3 +{ 0x28, 0, 0, 0x00000038 },//4 +{ 0x15, 0, 1, 0x0000fffe },//5 +{ 0x6, 0, 0, 0x00040000 },//6 +{ 0x6, 0, 0, 0x00000000 },//7 +*/ + +int code_tcp6_port_index=3; + struct sock_filter code_udp[] = { //{ 0x5, 0, 0, 0x00000001 }, //{ 0x5, 0, 0, 0x00000000 }, @@ -123,6 +169,20 @@ struct sock_filter code_udp[] = { { 0x6, 0, 0, 0x00000000 }, }; int code_udp_port_index=6; + +struct sock_filter code_udp6[] = { +// { 0x28, 0, 0, 0x0000000c }, +// { 0x15, 0, 5, 0x000086dd }, + { 0x30, 0, 0, 0x00000006 }, + { 0x15, 0, 3, 0x00000011 }, + { 0x28, 0, 0, 0x0000002a }, + { 0x15, 0, 1, 0x0000fffe }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + +}; +int code_udp6_port_index=3; + struct sock_filter code_icmp[] = { //{ 0x5, 0, 0, 0x00000001 }, //{ 0x5, 0, 0, 0x00000000 }, @@ -130,8 +190,20 @@ struct sock_filter code_icmp[] = { { 0x15, 0, 1, 0x00000001 }, { 0x6, 0, 0, 0x0000ffff }, { 0x6, 0, 0, 0x00000000 }, -};*/ +}; +struct sock_filter code_icmp6[] = { +// { 0x28, 0, 0, 0x0000000c }, +// { 0x15, 0, 6, 0x000086dd }, + { 0x30, 0, 0, 0x00000006 }, + { 0x15, 3, 0, 0x0000003a }, + { 0x15, 0, 3, 0x0000002c }, + { 0x30, 0, 0, 0x00000028 }, + { 0x15, 0, 1, 0x0000003a }, + { 0x6, 0, 0, 0x00040000 }, + { 0x6, 0, 0, 0x00000000 }, + +}; /* tcpdump -i eth1 ip and icmp -d @@ -180,6 +252,7 @@ tcpdump -i eth1 ip and icmp -dd (010) ret #0 */ +#endif packet_info_t::packet_info_t() { @@ -204,7 +277,15 @@ packet_info_t::packet_info_t() } else if (raw_mode == mode_icmp) { - protocol = IPPROTO_ICMP; + if(raw_ip_version==AF_INET) + { + protocol = IPPROTO_ICMP; + } + else + { + assert(raw_ip_version==AF_INET6); + protocol = IPPROTO_ICMPV6; + } my_icmp_seq=0; } @@ -289,6 +370,133 @@ void *pcap_recv_thread_entry(void *none) extern void async_cb(struct ev_loop *loop, struct ev_async *watcher, int revents); +#if 0 +int init_raw_socket() +{ + assert(raw_ip_version==AF_INET||raw_ip_version==AF_INET6); + + g_ip_id_counter=get_true_random_number()%65535; + if(lower_level==0) + { + raw_send_fd = socket(raw_ip_version , SOCK_RAW , IPPROTO_RAW);// IPPROTO_TCP?? + + if(raw_send_fd == -1) { + mylog(log_fatal,"Failed to create raw_send_fd\n"); + //perror("Failed to create raw_send_fd"); + myexit(1); + } + + /*ETH_P_IP + int one = 1; + const int *val = &one; + if (setsockopt (raw_send_fd, IPPROTO_IP, IP_HDRINCL, val, sizeof (one)) < 0) { + mylog(log_fatal,"Error setting IP_HDRINCL %d\n",errno); + //perror("Error setting IP_HDRINCL"); + myexit(2); + }*/ + + + } + else + { + raw_send_fd = socket(PF_PACKET , SOCK_DGRAM , htons(ETH_P_IP));// todo how to create a recv only raw socket? + + if(raw_send_fd == -1) { + mylog(log_fatal,"Failed to create raw_send_fd\n"); + //perror("Failed to create raw_send_fd"); + myexit(1); + } + //init_ifindex(if_name); + + } + + int opt = 0; + assert(setsockopt(raw_send_fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt))==0);// raw_send_fd is for send only, set its recv buffer to zero + + if(force_socket_buf) + { + if(setsockopt(raw_send_fd, SOL_SOCKET, SO_SNDBUFFORCE, &socket_buf_size, sizeof(socket_buf_size))<0) + { + mylog(log_fatal,"SO_SNDBUFFORCE fail socket_buf_size=%d errno=%s\n",socket_buf_size,strerror(errno)); + myexit(1); + } + } + else + { + if(setsockopt(raw_send_fd, SOL_SOCKET, SO_SNDBUF, &socket_buf_size, sizeof(socket_buf_size))<0) + { + mylog(log_fatal,"SO_SNDBUF fail socket_buf_size=%d errno=%s\n",socket_buf_size,strerror(errno)); + myexit(1); + } + } + + + + //raw_fd = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)); + + if(raw_ip_version==AF_INET) + raw_recv_fd= socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP)); + else + raw_recv_fd= socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IPV6)); + //ETH_P_IP doesnt read outgoing packets + // https://stackoverflow.com/questions/20264895/eth-p-ip-is-not-working-as-expected-i-can-only-receive-incoming-packets + // to capture both incoming and outgoing packets use ETH_P_ALL + + if(raw_recv_fd == -1) { + mylog(log_fatal,"Failed to create raw_recv_fd\n"); + //perror(""); + myexit(1); + } + if(strlen(dev)!=0) + { + struct sockaddr_ll bind_address; + memset(&bind_address, 0, sizeof(bind_address)); + + int index=-1; + assert(init_ifindex(dev,raw_recv_fd,index)==0); + + bind_address.sll_family = AF_PACKET; + if(raw_ip_version==AF_INET) + bind_address.sll_protocol = htons(ETH_P_IP); + else + bind_address.sll_protocol = htons(ETH_P_IPV6); + bind_address.sll_ifindex = index; + + if(bind(raw_recv_fd, (struct sockaddr *)&bind_address, sizeof(bind_address))==-1) + { + mylog(log_fatal,"bind to dev [%s] failed\n",dev); + myexit(1); + } + } + + if(force_socket_buf) + { + if(setsockopt(raw_recv_fd, SOL_SOCKET, SO_RCVBUFFORCE, &socket_buf_size, sizeof(socket_buf_size))<0) + { + mylog(log_fatal,"SO_RCVBUFFORCE fail socket_buf_size=%d errno=%s\n",socket_buf_size,strerror(errno)); + myexit(1); + } + } + else + { + if(setsockopt(raw_recv_fd, SOL_SOCKET, SO_RCVBUF, &socket_buf_size, sizeof(socket_buf_size))<0) + { + mylog(log_fatal,"SO_RCVBUF fail socket_buf_size=%d errno=%s\n",socket_buf_size,strerror(errno)); + myexit(1); + } + } + + //IP_HDRINCL to tell the kernel that headers are included in the packet + + + + setnonblocking(raw_send_fd); //not really necessary + setnonblocking(raw_recv_fd); + + return 0; +} +#endif + int init_raw_socket() { @@ -474,6 +682,77 @@ int init_raw_socket() return 0; } +/* +void init_filter(int port) +{ + sock_fprog bpf; + assert(raw_ip_version==AF_INET||raw_ip_version==AF_INET6); + if(raw_mode==mode_faketcp||raw_mode==mode_udp) + { + filter_port=port; + } + if(disable_bpf_filter) return; + //if(raw_mode==mode_icmp) return ; + //code_tcp[8].k=code_tcp[10].k=port; + if(raw_mode==mode_faketcp) + { + if(raw_ip_version==AF_INET) + { + bpf.len = sizeof(code_tcp)/sizeof(code_tcp[0]); + code_tcp[code_tcp_port_index].k=port; + bpf.filter = code_tcp; + }else + { + bpf.len = sizeof(code_tcp6)/sizeof(code_tcp6[0]); + code_tcp6[code_tcp6_port_index].k=port; + bpf.filter = code_tcp6; + } + } + else if(raw_mode==mode_udp) + { + if(raw_ip_version==AF_INET) + { + bpf.len = sizeof(code_udp)/sizeof(code_udp[0]); + code_udp[code_udp_port_index].k=port; + bpf.filter = code_udp; + }else + { + bpf.len = sizeof(code_udp6)/sizeof(code_udp6[0]); + code_udp6[code_udp6_port_index].k=port; + bpf.filter = code_udp6; + } + } + else if(raw_mode==mode_icmp) + { + if(raw_ip_version==AF_INET) + { + bpf.len = sizeof(code_icmp)/sizeof(code_icmp[0]); + bpf.filter = code_icmp; + }else + { + bpf.len = sizeof(code_icmp6)/sizeof(code_icmp6[0]); + bpf.filter = code_icmp6; + } + } + + int dummy; + + int ret=setsockopt(raw_recv_fd, SOL_SOCKET, SO_DETACH_FILTER, &dummy, sizeof(dummy)); //in case i forgot to remove + if (ret != 0) + { + mylog(log_debug,"error remove fiter\n"); + //perror("filter"); + //exit(-1); + } + ret = setsockopt(raw_recv_fd, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf)); + if (ret != 0) + { + mylog(log_fatal,"error set fiter\n"); + //perror("filter"); + myexit(-1); + } +} + */ void init_filter(int port) { /* @@ -577,7 +856,7 @@ void remove_filter() */ } -int init_ifindex(const char * if_name,int &index) +int init_ifindex(const char * if_name,int fd,int &index) { /* struct ifreq ifr; @@ -589,7 +868,7 @@ int init_ifindex(const char * if_name,int &index) mylog(log_fatal,"interface name is too long\n"); myexit(-1); } - if (ioctl(raw_send_fd,SIOCGIFINDEX,&ifr)==-1) { + if (ioctl(fd,SIOCGIFINDEX,&ifr)==-1) { mylog(log_fatal,"SIOCGIFINDEX fail ,%s\n",strerror(errno)); myexit(-1); @@ -616,6 +895,7 @@ bool interface_has_arp(const char * interface) { return !(ifr.ifr_flags & IFF_NOARP); } #endif +/* struct route_info_t { string if_name; @@ -660,7 +940,7 @@ vector find_route_entry(const vector &route_info_vec,u32_t ip } } return res; -} +}*/ /* int find_direct_dest(const vector &route_info_vec,u32_t ip,u32_t &dest_ip,string &if_name) { @@ -692,7 +972,7 @@ int find_direct_dest(const vector &route_info_vec,u32_t ip,u32_t & } mylog(log_error,"dead loop in find_direct_dest\n"); return -1; -}*/ +} struct arp_info_t { u32_t ip; @@ -732,7 +1012,8 @@ int find_arp(const vector &arp_info_vec,u32_t ip,string if_name,stri } hw=arp_info_vec[pos].hw; return 0; -} +}*/ + /* int find_lower_level_info(u32_t ip,u32_t &dest_ip,string &if_name,string &hw) { @@ -823,133 +1104,45 @@ int find_lower_level_info(u32_t ip,u32_t &dest_ip,string &if_name,string &hw) dest_ip=ntohl(dest_ip); return 0; }*/ - -int send_raw_ip(raw_info_t &raw_info,const char * payload,int payloadlen) +#if 0 +int send_raw_packet(raw_info_t &raw_info,const char * packet,int len) { const packet_info_t &send_info=raw_info.send_info; const packet_info_t &recv_info=raw_info.recv_info; - char send_raw_ip_buf0[buf_len+pcap_link_header_len]; - char * send_raw_ip_buf=send_raw_ip_buf0+pcap_link_header_len; - if(raw_info.disabled) - { - mylog(log_debug,"[%s,%d]connection disabled, no packet will be sent\n",my_ntoa(recv_info.src_ip),recv_info.src_port); - assert(max_rst_allowed>=0); - return 0; - } - - struct my_iphdr *iph = (struct my_iphdr *) send_raw_ip_buf; - memset(iph,0,sizeof(my_iphdr)); - - iph->ihl = sizeof(my_iphdr)/4; //we dont use ip options,so the length is just sizeof(iphdr) - iph->version = 4; - iph->tos = 0; - - /* if(lower_level) - { - //iph->id=0; - iph->id = htons (g_ip_id_counter++); //Id of this packet - } - else*/ - iph->id = htons (g_ip_id_counter); //Id of this packet - g_ip_id_counter++; - //iph->id = 0; //Id of this packet ,kernel will auto fill this if id is zero ,or really?????// todo //seems like there is a problem - - iph->frag_off = htons(0x4000); //DF set,others are zero - // iph->frag_off = htons(0x0000); //DF set,others are zero - iph->ttl = (unsigned char)ttl_value; - iph->protocol = send_info.protocol; - iph->check = 0; //Set to 0 before calculating checksum - iph->saddr = send_info.src_ip; //Spoof the source ip address - iph->daddr = send_info.dst_ip; - - uint16_t ip_tot_len=sizeof (struct my_iphdr)+payloadlen; - /* if(lower_level)iph->tot_len = htons(ip_tot_len); //this is not necessary ,kernel will always auto fill this //http://man7.org/linux/man-pages/man7/raw.7.html - else*/ - iph->tot_len = 0; - - memcpy(send_raw_ip_buf+sizeof(my_iphdr) , payload, payloadlen); - - /*if(lower_level) iph->check = - csum ((unsigned short *) send_raw_ip_buf, iph->ihl*4); //this is not necessary ,kernel will always auto fill this - else - iph->check=0; - */ - - - if(! send_with_pcap) - { -#ifndef NO_LIBNET - - g_ptag=libnet_build_ipv4(ip_tot_len, iph->tos, ntohs(iph->id), ntohs(iph->frag_off), - iph->ttl , iph->protocol , iph->check , iph->saddr, iph->daddr, - (const unsigned char *)payload, payloadlen, libnet_handle, g_ptag); - - assert(g_ptag!=-1 &&g_ptag!=0); - - int ret; - ret= libnet_write(libnet_handle); - - assert(ret!=-1); - - - /* - iph->tot_len=htons(ip_tot_len); - iph->check =csum ((unsigned short *) send_raw_ip_buf, iph->ihl*4); - libnet_write_raw_ipv4(libnet_handle,(const unsigned char *)send_raw_ip_buf,ip_tot_len); //this api is marked as internal, so avoid using it. - */ -#endif - } - else - { - iph->tot_len=htons(ip_tot_len); - iph->check =csum ((unsigned short *) send_raw_ip_buf, iph->ihl*4); - - - assert(pcap_header_captured==1); - assert(pcap_link_header_len!=-1); - memcpy(send_raw_ip_buf0,pcap_header_buf,pcap_link_header_len); - int ret=pcap_sendpacket(pcap_handle,(const unsigned char *)send_raw_ip_buf0,ip_tot_len+pcap_link_header_len); - - if(ret!=0) - { - mylog(log_fatal,"pcap_sendpcaket failed with vaule %d,%s\n",ret,pcap_geterr(pcap_handle)); - myexit(-1); - } - /* - unsigned char *p=(unsigned char *)send_raw_ip_buf0; - for(int i=0;i",int(p[i])); - printf("\n"); - assert(pcap_sendpacket(pcap_handle,(const unsigned char *)pcap_header_buf,cap_len)==0); - p=(unsigned char *)pcap_header_buf; - for(int i=0;i",int(p[i])); - printf("\n"); - - printf("pcap send!\n");*/ - } - - - - - /* + int ret; if(lower_level==0) { - struct sockaddr_in sin={0}; - sin.sin_family = AF_INET; - //sin.sin_port = htons(info.dst_port); //dont need this - sin.sin_addr.s_addr = send_info.dst_ip; - ret = sendto(raw_send_fd, send_raw_ip_buf, ip_tot_len , 0, (struct sockaddr *) &sin, sizeof (sin)); + if(raw_ip_version==AF_INET) + { + struct sockaddr_in sin={0}; + sin.sin_family = raw_ip_version; + //sin.sin_port = htons(info.dst_port); //dont need this + sin.sin_addr.s_addr = send_info.new_dst_ip.v4; + ret = sendto(raw_send_fd, packet, len , 0, (struct sockaddr *) &sin, sizeof (sin)); + } + else if(raw_ip_version==AF_INET6) + { + struct sockaddr_in6 sin={0}; + sin.sin6_family = raw_ip_version; + //sin.sin_port = htons(info.dst_port); //dont need this + sin.sin6_addr = send_info.new_dst_ip.v6; + ret = sendto(raw_send_fd, packet, len , 0, (struct sockaddr *) &sin, sizeof (sin)); + }else + { + assert(0==1); + } } else { + assert(0==1); + /* struct sockaddr_ll addr={0}; //={0} not necessary memcpy(&addr,&send_info.addr_ll,sizeof(addr)); - ret = sendto(raw_send_fd, send_raw_ip_buf, ip_tot_len , 0, (struct sockaddr *) &addr, sizeof (addr)); + ret = sendto(raw_send_fd, packet, len , 0, (struct sockaddr *) &addr, sizeof (addr));*/ } if(ret==-1) { @@ -961,156 +1154,345 @@ int send_raw_ip(raw_info_t &raw_info,const char * payload,int payloadlen) else { //mylog(log_info,"sendto succ\n"); - }*/ - return 0; -} -int peek_raw(packet_info_t &peek_info) -{ static char peek_raw_buf[buf_len]; - char *ip_begin=peek_raw_buf+link_level_header_len; - struct sockaddr saddr={0}; - socklen_t saddr_size=sizeof(saddr); - int recv_len = recvfrom(raw_recv_fd, peek_raw_buf,max_data_len, MSG_PEEK ,&saddr , &saddr_size);//change max_data_len to something smaller,we only need header here - my_iphdr * iph = (struct my_iphdr *) (ip_begin); - //mylog(log_info,"recv_len %d\n",recv_len); - if(recv_lensaddr; - unsigned short iphdrlen =iph->ihl*4; - char *payload=ip_begin+iphdrlen; - - //mylog(log_info,"protocol %d\n",iph->protocol); - switch(raw_mode) - { - case mode_faketcp: - { - if(iph->protocol!=IPPROTO_TCP) - { - mylog(log_trace,"failed here"); - return -1; - } - struct my_tcphdr *tcph=(my_tcphdr *)payload; - if(recv_lensource); - peek_info.syn=tcph->syn; - break; - } - case mode_udp: - { - if(iph->protocol!=IPPROTO_UDP) return -1; - struct my_udphdr *udph=(my_udphdr *)payload; - if(recv_lensource); - break; - } - case mode_icmp: - { - if(iph->protocol!=IPPROTO_ICMP) return -1; - struct icmphdr *icmph=(icmphdr *)payload; - if(recv_lenid); - break; - } - default:return -1; } return 0; } -int recv_raw_ip(raw_info_t &raw_info,char * &payload,int &payloadlen) +#endif +int send_raw_packet(raw_info_t &raw_info,const char * packet,int len) { const packet_info_t &send_info=raw_info.send_info; - packet_info_t &recv_info=raw_info.recv_info; + const packet_info_t &recv_info=raw_info.recv_info; - //static char recv_raw_ip_buf[buf_len]; + if(! send_with_pcap) + { +#ifndef NO_LIBNET - my_iphdr * iph; - /*struct sockaddr_ll saddr={0}; - socklen_t saddr_size = sizeof(saddr);*/ - int flag=0; + //g_ptag=libnet_build_ipv4(ip_tot_len, iph->tos, ntohs(iph->id), ntohs(iph->frag_off), + // iph->ttl , iph->protocol , iph->check , iph->saddr, iph->daddr, + // (const unsigned char *)payload, payloadlen, libnet_handle, g_ptag); - //int recv_len = recvfrom(raw_recv_fd, recv_raw_ip_buf, max_data_len+1, flag ,(sockaddr*)&saddr , &saddr_size); + //assert(g_ptag!=-1 &&g_ptag!=0); - assert(g_packet_buf_cnt==1); - g_packet_buf_cnt--; + //int ret; + //ret= libnet_write(libnet_handle); - int recv_len=g_packet_buf_len; - char *recv_raw_ip_buf=g_packet_buf; + //assert(ret!=-1); - if(recv_len==max_data_len+1) + + //iph->tot_len=htons(ip_tot_len); + //iph->check =csum ((unsigned short *) send_raw_ip_buf, iph->ihl*4); + if(raw_ip_version==AF_INET) + { + libnet_write_raw_ipv4(libnet_handle,(const unsigned char *)packet,len); //todo, this api is marked as internal, maybe we should avoid using it. + } + else + { + assert(raw_ip_version==AF_INET6); + libnet_write_raw_ipv6(libnet_handle,(const unsigned char *)packet,len); + } +#endif + } + else + { + char buf[buf_len]; + assert(pcap_header_captured==1); + assert(pcap_link_header_len!=-1); + memcpy(buf,pcap_header_buf,pcap_link_header_len); + memcpy(buf+pcap_link_header_len,packet,len); + int ret=pcap_sendpacket(pcap_handle,(const unsigned char *)buf,len+pcap_link_header_len); + + if(ret!=0) + { + mylog(log_fatal,"pcap_sendpcaket failed with vaule %d,%s\n",ret,pcap_geterr(pcap_handle)); + myexit(-1); + } + /* + unsigned char *p=(unsigned char *)send_raw_ip_buf0; + for(int i=0;i",int(p[i])); + printf("\n"); + assert(pcap_sendpacket(pcap_handle,(const unsigned char *)pcap_header_buf,cap_len)==0); + p=(unsigned char *)pcap_header_buf; + for(int i=0;i",int(p[i])); + printf("\n"); + printf("pcap send!\n");*/ + } + return 0; +} +int send_raw_ip(raw_info_t &raw_info,const char * payload,int payloadlen) +{ + const packet_info_t &send_info=raw_info.send_info; + const packet_info_t &recv_info=raw_info.recv_info; + char send_raw_ip_buf[buf_len]; + + if(raw_info.disabled) + { + mylog(log_debug,"[%s,%d]connection disabled, no packet will be sent\n",recv_info.new_src_ip.get_str1(),recv_info.src_port); + assert(max_rst_allowed>=0); + return 0; + } + + uint16_t ip_tot_len; + if(raw_ip_version==AF_INET) + { + struct my_iphdr *iph = (struct my_iphdr *) send_raw_ip_buf; + memset(iph,0,sizeof(my_iphdr)); + + iph->ihl = sizeof(my_iphdr)/4; //we dont use ip options,so the length is just sizeof(iphdr) + iph->version = 4; + iph->tos = 0; + + if(lower_level) + { + //iph->id=0; + iph->id = htons (g_ip_id_counter++); //Id of this packet + } + else//no need to else? + { + iph->id = htons (g_ip_id_counter++); //Id of this packet + //iph->id = 0; //Id of this packet ,kernel will auto fill this if id is zero ,or really?????// todo //seems like there is a problem + } + + iph->frag_off = htons(0x4000); //DF set,others are zero + // iph->frag_off = htons(0x0000); //DF set,others are zero + iph->ttl = (unsigned char)ttl_value; + iph->protocol = send_info.protocol; + iph->check = 0; //Set to 0 before calculating checksum + iph->saddr = send_info.new_src_ip.v4; //Spoof the source ip address + iph->daddr = send_info.new_dst_ip.v4; + + ip_tot_len=sizeof (struct my_iphdr)+payloadlen; + if(lower_level)iph->tot_len = htons(ip_tot_len); //this is not necessary ,kernel will always auto fill this //http://man7.org/linux/man-pages/man7/raw.7.html + else + iph->tot_len = 0; + + memcpy(send_raw_ip_buf+sizeof(my_iphdr) , payload, payloadlen); + + /* + if(lower_level) iph->check = + csum ((unsigned short *) send_raw_ip_buf, iph->ihl*4); //this is not necessary ,kernel will always auto fill this + else + iph->check=0; + */ + + csum((unsigned short *) send_raw_ip_buf, iph->ihl*4);//always cal checksum for mp version + } + else + { + assert(raw_ip_version==AF_INET6); + + struct my_ip6hdr *ip6h = (struct my_ip6hdr *) send_raw_ip_buf; + memset(ip6h,0,sizeof(my_ip6hdr)); + + ip6h->version=6; + ip6h->payload_len=htons(payloadlen); + ip6h->next_header=send_info.protocol; + ip6h->hop_limit=(unsigned char)ttl_value; + ip6h->src=send_info.new_src_ip.v6; + ip6h->dst=send_info.new_dst_ip.v6; + + ip_tot_len=sizeof (struct my_ip6hdr)+payloadlen; + memcpy(send_raw_ip_buf+sizeof(my_ip6hdr) , payload, payloadlen); + } + + + return send_raw_packet(raw_info,send_raw_ip_buf,ip_tot_len); +} + +int pre_recv_raw_packet() +{ + //not used in mp version,use async cb instead + /* + assert(g_packet_buf_cnt==0); + + + g_sockaddr_len=sizeof(g_sockaddr.ll); + g_packet_buf_len = recvfrom(raw_recv_fd, g_packet_buf, max_data_len+1, 0 ,(sockaddr*)&g_sockaddr , &g_sockaddr_len); + + //assert(g_sockaddr_len==sizeof(g_sockaddr.ll)); //g_sockaddr_len=18, sizeof(g_sockaddr.ll)=20, why its not equal? maybe its bc sll_halen is 6? + + //assert(g_addr_ll_size==sizeof(g_addr_ll)); + + if(g_packet_buf_len==max_data_len+1) { mylog(log_warn,"huge packet, data_len > %d,dropped\n",max_data_len); return -1; } - if(recv_len<0) + if(g_packet_buf_len<0) { - mylog(log_trace,"recv_len %d\n",recv_len); + mylog(log_trace,"recv_len %d\n",g_packet_buf_len); return -1; } - if(recv_lenversion!=4) + { + mylog(log_trace,"expect ipv4 packet, but got something else: %02x\n",iph->version); + return -1; + } + if(raw_packet_len<(int)sizeof(my_iphdr)) + { + mylog(log_trace,"raw_packet_lenversion!=6) + { + mylog(log_trace,"expect ipv6 packet, but got something else: %02x\n",ip6h->version); + return -1; + } + if(raw_packet_len<(int)sizeof(my_ip6hdr)) + { + mylog(log_trace,"raw_packet_lensaddr; - recv_info.dst_ip=iph->daddr; - recv_info.protocol=iph->protocol; - - /* if(lower_level) { - memcpy(&recv_info.addr_ll,&saddr,sizeof(recv_info.addr_ll)); - }*/ + //memcpy(&recv_info.addr_ll,&g_sockaddr.ll,sizeof(recv_info.addr_ll)); + } - if(bind_address_uint32!=0 &&recv_info.dst_ip!=bind_address_uint32) + + unsigned short iphdrlen; + int ip_len; + if(raw_ip_version==AF_INET) { - mylog(log_trace,"bind adress doenst match, dropped\n"); + recv_info.new_src_ip.v4=iph->saddr; + recv_info.new_dst_ip.v4=iph->daddr; + recv_info.protocol=iph->protocol; + iphdrlen =iph->ihl*4; + ip_len=ntohs(iph->tot_len); + } + else + { + //todo flow id + recv_info.new_src_ip.v6=ip6h->src; + recv_info.new_dst_ip.v6=ip6h->dst; + iphdrlen=40; + recv_info.protocol=ip6h->next_header; //todo handle extension headers; + ip_len=ntohs(ip6h->payload_len)+iphdrlen; + } + + if(bind_addr_used && !recv_info.new_dst_ip.equal(bind_addr)) + { + mylog(log_trace,"bind adress doenst match %s %s, dropped\n",recv_info.new_dst_ip.get_str1(), bind_addr.get_str2()); //printf(" bind adress doenst match, dropped\n"); return -1; } + //if (!(iph->ihl > 0 && iph->ihl <=60)) { + // mylog(log_trace,"iph ihl error\n"); + // return -1; + // } - if (!(iph->ihl > 0 && iph->ihl <=60)) { - mylog(log_trace,"iph ihl error\n"); - return -1; - } - int ip_len=ntohs(iph->tot_len); - - if(recv_len-int(link_level_header_len) ihl*4; + if(raw_ip_version==AF_INET) + { + if(raw_info.peek==0)// avoid cal it twice + { + u32_t ip_chk=csum ((unsigned short *) ip_begin, iphdrlen); - u32_t ip_chk=csum ((unsigned short *) ip_begin, iphdrlen); + if(ip_chk!=0) + { + mylog(log_debug,"ip header error %x\n",ip_chk); + return -1; + } + } + } + else + { - if(ip_chk!=0) - { - mylog(log_debug,"ip header error %x\n",ip_chk); - return -1; - } + } payload=ip_begin+iphdrlen; @@ -1125,34 +1507,139 @@ int recv_raw_ip(raw_info_t &raw_info,char * &payload,int &payloadlen) return 0; } +int peek_raw(raw_info_t &raw_info) +{ + //static char peek_raw_buf[buf_len]; + //assert(g_packet_buf_cnt==1); + //g_packet_buf_cnt--; + //char * peek_raw_buf=g_packet_buf; + //int recv_len=g_packet_buf_len; + //char *ip_begin=peek_raw_buf+link_level_header_len; + //struct sockaddr saddr={0}; + //socklen_t saddr_size=sizeof(saddr); + //int recv_len = recvfrom(raw_recv_fd, peek_raw_buf,max_data_len, MSG_PEEK ,&saddr , &saddr_size);//change max_data_len to something smaller,we only need header here + //iphdr * iph = (struct iphdr *) (ip_begin); + //mylog(log_info,"recv_len %d\n",recv_len); + //if(recv_lensaddr; + //unsigned short iphdrlen =iph->ihl*4; + //char *payload=ip_begin+iphdrlen; + + packet_info_t &recv_info=raw_info.recv_info; + + char *payload;int payload_len; + if(recv_raw_ip(raw_info,payload,payload_len)!=0) + return -1; + //mylog(log_info,"protocol %d\n",iph->protocol); + switch(raw_mode) + { + case mode_faketcp: + { + if(recv_info.protocol!=IPPROTO_TCP) + { + mylog(log_trace,"failed here"); + return -1; + } + struct my_tcphdr *tcph=(my_tcphdr *)payload; + if(payload_lensource); + recv_info.syn=tcph->syn; + break; + } + case mode_udp: + { + if(recv_info.protocol!=IPPROTO_UDP) return -1; + struct my_udphdr *udph=(my_udphdr *)payload; + if(payload_lensource); + break; + } + case mode_icmp: + { + if(raw_ip_version==AF_INET) + { + if(recv_info.protocol!=IPPROTO_ICMP) return -1; + }else + { + if(recv_info.protocol!=IPPROTO_ICMPV6) return -1; + } + struct my_icmphdr *icmph=(my_icmphdr *)payload; + if(payload_lenid); + break; + } + default:return -1; + } + return 0; +} int send_raw_icmp(raw_info_t &raw_info, const char * payload, int payloadlen) { const packet_info_t &send_info=raw_info.send_info; const packet_info_t &recv_info=raw_info.recv_info; char send_raw_icmp_buf[buf_len]; - icmphdr *icmph=(struct icmphdr *) (send_raw_icmp_buf); - memset(icmph,0,sizeof(icmphdr)); - if(program_mode==client_mode) + my_icmphdr *icmph=(struct my_icmphdr *) (send_raw_icmp_buf); + memset(icmph,0,sizeof(my_icmphdr)); + if(raw_ip_version==AF_INET) { - icmph->type=8; + if(program_mode==client_mode) + { + icmph->type=8; + } + else + { + icmph->type=0; + } } else { - icmph->type=0; + if(program_mode==client_mode) + { + icmph->type=128; + } + else + { + icmph->type=129; + } } icmph->code=0; icmph->id=htons(send_info.src_port); - icmph->seq=htons(send_info.my_icmp_seq); /////////////modify - memcpy(send_raw_icmp_buf+sizeof(icmphdr),payload,payloadlen); + memcpy(send_raw_icmp_buf+sizeof(my_icmphdr),payload,payloadlen); - icmph->check_sum = csum( (unsigned short*) send_raw_icmp_buf, sizeof(icmphdr)+payloadlen); + if(raw_ip_version==AF_INET) + { + icmph->check_sum = csum( (unsigned short*) send_raw_icmp_buf, sizeof(my_icmphdr)+payloadlen); + } + else + { + pseudo_header6 v6; + struct pseudo_header6 *psh = &v6; - if(send_raw_ip(raw_info,send_raw_icmp_buf,sizeof(icmphdr)+payloadlen)!=0) + psh->src=send_info.new_src_ip.v6; + psh->dst=send_info.new_dst_ip.v6; + psh->next_header=IPPROTO_ICMPV6; + psh->tcp_length=htons(sizeof(my_icmphdr)+payloadlen); + psh->placeholder1 = 0; + psh->placeholder2 = 0; + + icmph->check_sum = csum_with_header((char *)psh,sizeof(pseudo_header6), (unsigned short*) send_raw_icmp_buf, sizeof(my_icmphdr)+payloadlen); + } + if(send_raw_ip(raw_info,send_raw_icmp_buf,sizeof(my_icmphdr)+payloadlen)!=0) { return -1; } @@ -1172,17 +1659,16 @@ int send_raw_udp(raw_info_t &raw_info, const char * payload, int payloadlen) char send_raw_udp_buf[buf_len]; - my_udphdr *udph=(struct my_udphdr *) (send_raw_udp_buf - + sizeof(struct pseudo_header)); + my_udphdr *udph=(struct my_udphdr *) (send_raw_udp_buf); memset(udph,0,sizeof(my_udphdr)); - struct pseudo_header *psh = (struct pseudo_header *) (send_raw_udp_buf); udph->source = htons(send_info.src_port); udph->dest = htons(send_info.dst_port); int udp_tot_len=payloadlen+sizeof(my_udphdr); + if(udp_tot_len>65535) { mylog(log_debug,"invalid len\n"); @@ -1191,19 +1677,43 @@ int send_raw_udp(raw_info_t &raw_info, const char * payload, int payloadlen) mylog(log_trace,"udp_len:%d %d\n",udp_tot_len,udph->len); udph->len=htons(uint16_t(udp_tot_len)); - memcpy(send_raw_udp_buf+sizeof(struct pseudo_header)+sizeof(my_udphdr),payload,payloadlen); + memcpy(send_raw_udp_buf+sizeof(my_udphdr),payload,payloadlen); - psh->source_address = send_info.src_ip; - psh->dest_address = send_info.dst_ip; - psh->placeholder = 0; - psh->protocol = IPPROTO_UDP; - psh->tcp_length = htons(uint16_t(udp_tot_len)); - int csum_size = sizeof(struct pseudo_header) +udp_tot_len ; - udph->check = csum( (unsigned short*) send_raw_udp_buf, csum_size); - if(send_raw_ip(raw_info,send_raw_udp_buf+ sizeof(struct pseudo_header),udp_tot_len)!=0) + if(raw_ip_version==AF_INET) + { + pseudo_header v4; + struct pseudo_header *psh = &v4; + + psh->source_address = send_info.new_src_ip.v4; + psh->dest_address = send_info.new_dst_ip.v4; + psh->placeholder = 0; + psh->protocol = IPPROTO_UDP; + psh->tcp_length = htons(udp_tot_len); + + udph->check = csum_with_header((char *)psh,sizeof(pseudo_header), (unsigned short*) send_raw_udp_buf, udp_tot_len); + } + else + { + pseudo_header6 v6; + struct pseudo_header6 *psh = &v6; + + psh->src=send_info.new_src_ip.v6; + psh->dst=send_info.new_dst_ip.v6; + psh->next_header=IPPROTO_UDP; + psh->tcp_length=htons(udp_tot_len); + + psh->placeholder1 = 0; + psh->placeholder2 = 0; + + + udph->check = csum_with_header((char *)psh,sizeof(pseudo_header6), (unsigned short*) send_raw_udp_buf, udp_tot_len); + } + + + if(send_raw_ip(raw_info,send_raw_udp_buf,udp_tot_len)!=0) { return -1; } @@ -1221,14 +1731,10 @@ int send_raw_tcp(raw_info_t &raw_info,const char * payload, int payloadlen) { char send_raw_tcp_buf[buf_len]; //char *send_raw_tcp_buf=send_raw_tcp_buf0; - struct my_tcphdr *tcph = (struct my_tcphdr *) (send_raw_tcp_buf - + sizeof(struct pseudo_header)); - + struct my_tcphdr *tcph = (struct my_tcphdr *) (send_raw_tcp_buf); memset(tcph,0,sizeof(my_tcphdr)); - struct pseudo_header *psh = (struct pseudo_header *) (send_raw_tcp_buf); - //TCP Header tcph->source = htons(send_info.src_port); tcph->dest = htons(send_info.dst_port); @@ -1244,7 +1750,7 @@ int send_raw_tcp(raw_info_t &raw_info,const char * payload, int payloadlen) { if (tcph->syn == 1) { tcph->doff = 10; //tcp header size - int i = sizeof(pseudo_header)+sizeof(my_tcphdr); + int i = sizeof(my_tcphdr); send_raw_tcp_buf[i++] = 0x02; //mss send_raw_tcp_buf[i++] = 0x04; send_raw_tcp_buf[i++] = 0x05; @@ -1280,7 +1786,7 @@ int send_raw_tcp(raw_info_t &raw_info,const char * payload, int payloadlen) { send_raw_tcp_buf[i++] = wscale; } else { tcph->doff = 8; - int i = sizeof(pseudo_header)+sizeof(my_tcphdr); + int i = sizeof(my_tcphdr); send_raw_tcp_buf[i++] = 0x01; send_raw_tcp_buf[i++] = 0x01; @@ -1306,28 +1812,46 @@ int send_raw_tcp(raw_info_t &raw_info,const char * payload, int payloadlen) { tcph->urg = 0; //tcph->window = htons((uint16_t)(1024)); - tcph->window = htons((uint16_t) (receive_window_lower_bound + get_true_random_number() % receive_window_random_range)); + tcph->window = htons((uint16_t) (receive_window_lower_bound + random() % receive_window_random_range)); tcph->check = 0; //leave checksum 0 now, filled later by pseudo header tcph->urg_ptr = 0; - char *tcp_data = send_raw_tcp_buf+sizeof(struct pseudo_header) + tcph->doff * 4; + char *tcp_data = send_raw_tcp_buf+ + tcph->doff * 4; memcpy(tcp_data, payload, payloadlen); - - psh->source_address = send_info.src_ip; - psh->dest_address = send_info.dst_ip; - psh->placeholder = 0; - psh->protocol = IPPROTO_TCP; - psh->tcp_length = htons(tcph->doff * 4 + payloadlen); - - int csum_size = sizeof(struct pseudo_header) + tcph->doff*4 + payloadlen; - - tcph->check = csum( (unsigned short*) send_raw_tcp_buf, csum_size); - int tcp_totlen=tcph->doff*4 + payloadlen; - if(send_raw_ip(raw_info,send_raw_tcp_buf+ sizeof(struct pseudo_header),tcp_totlen)!=0) + if(raw_ip_version==AF_INET) + { + pseudo_header v4; + struct pseudo_header *psh = &v4; + + psh->source_address = send_info.new_src_ip.v4; + psh->dest_address = send_info.new_dst_ip.v4; + psh->placeholder = 0; + psh->protocol = IPPROTO_TCP; + psh->tcp_length = htons(tcp_totlen); + + tcph->check = csum_with_header((char *)psh,sizeof(pseudo_header), (unsigned short*) send_raw_tcp_buf, tcp_totlen); + } + else + { + pseudo_header6 v6; + struct pseudo_header6 *psh = &v6; + + psh->src=send_info.new_src_ip.v6; + psh->dst=send_info.new_dst_ip.v6; + psh->next_header=IPPROTO_TCP; + psh->tcp_length=htons(tcp_totlen); + psh->placeholder1 = 0; + psh->placeholder2 = 0; + + tcph->check = csum_with_header((char *)psh,sizeof(pseudo_header6), (unsigned short*) send_raw_tcp_buf, tcp_totlen); + } + + + if(send_raw_ip(raw_info,send_raw_tcp_buf,tcp_totlen)!=0) { return -1; } @@ -1520,14 +2044,25 @@ int recv_raw_icmp(raw_info_t &raw_info, char *&payload, int &payloadlen) mylog(log_debug,"recv_raw_ip error\n"); return -1; } - if(recv_info.protocol!=IPPROTO_ICMP) + if(raw_ip_version==AF_INET) { - //printf("not udp protocol\n"); - return -1; + if(recv_info.protocol!=IPPROTO_ICMP) + { + //printf("not udp protocol\n"); + return -1; + } + } + else + { + if(recv_info.protocol!=IPPROTO_ICMPV6) + { + //printf("not udp protocol\n"); + return -1; + } } - icmphdr *icmph=(struct icmphdr *) (ip_payload); + my_icmphdr *icmph=(struct my_icmphdr *) (ip_payload); if(ntohs(icmph->id)!=send_info.src_port) { @@ -1538,23 +2073,50 @@ int recv_raw_icmp(raw_info_t &raw_info, char *&payload, int &payloadlen) recv_info.src_port=recv_info.dst_port=ntohs(icmph->id); recv_info.my_icmp_seq=ntohs(icmph->seq); - - if(program_mode==client_mode) - { - if(icmph->type!=0) - return -1; - } - else - { - if(icmph->type!=8) - return -1; - - } - if(icmph->code!=0) return -1; - unsigned short check = csum( (unsigned short*) ip_payload, ip_payloadlen); + unsigned short check ; + if(raw_ip_version==AF_INET) + { + if(program_mode==client_mode) + { + if(icmph->type!=0) + return -1; + } + else + { + if(icmph->type!=8) + return -1; + } + check= csum( (unsigned short*) ip_payload, ip_payloadlen); + } + else + { + if(program_mode==client_mode) + { + if(icmph->type!=129) + return -1; + } + else + { + if(icmph->type!=128) + return -1; + } + + pseudo_header6 tmp_header; + struct pseudo_header6 *psh=&tmp_header ; + + psh->src = recv_info.new_src_ip.v6; + psh->dst = recv_info.new_dst_ip.v6; + psh->placeholder1 = 0; + psh->placeholder2 = 0; + psh->next_header = IPPROTO_ICMPV6; + psh->tcp_length = htons(ip_payloadlen); + + check = csum_with_header((char *)psh,sizeof(pseudo_header6), (unsigned short*) ip_payload, ip_payloadlen); + } + if(check!=0) { @@ -1569,8 +2131,8 @@ int recv_raw_icmp(raw_info_t &raw_info, char *&payload, int &payloadlen) //mylog(log_info,"send_info.seq=%d\n",send_info.seq); }*/ - payload=ip_payload+sizeof(icmphdr); - payloadlen=ip_payloadlen-sizeof(icmphdr); + payload=ip_payload+sizeof(my_icmphdr); + payloadlen=ip_payloadlen-sizeof(my_icmphdr); mylog(log_trace,"get a packet len=%d\n",payloadlen); return 0; @@ -1580,7 +2142,7 @@ int recv_raw_udp(raw_info_t &raw_info, char *&payload, int &payloadlen) { const packet_info_t &send_info=raw_info.send_info; packet_info_t &recv_info=raw_info.recv_info; - static char recv_raw_udp_buf[buf_len]; + //static char recv_raw_udp_buf[buf_len]; char * ip_payload; int ip_payloadlen; @@ -1610,23 +2172,56 @@ int recv_raw_udp(raw_info_t &raw_info, char *&payload, int &payloadlen) if(udph->dest!=ntohs(uint16_t(filter_port))) { - mylog(log_debug,"dropped packet for other ports\n"); //printf("%x %x",tcph->dest,); return -1; } - memcpy(recv_raw_udp_buf+ sizeof(struct pseudo_header) , ip_payload , ip_payloadlen); + //memcpy(recv_raw_udp_buf+ sizeof(struct pseudo_header) , ip_payload , ip_payloadlen); - struct pseudo_header *psh=(pseudo_header *)recv_raw_udp_buf ; + /* + pseudo_header tmp_header={0}; + struct pseudo_header *psh=&tmp_header ; - psh->source_address = recv_info.src_ip; - psh->dest_address = recv_info.dst_ip; + psh->source_address = recv_info.new_src_ip.v4; + psh->dest_address = recv_info.new_dst_ip.v4; psh->placeholder = 0; psh->protocol = IPPROTO_UDP; psh->tcp_length = htons(ip_payloadlen); - int csum_len=sizeof(struct pseudo_header)+ip_payloadlen; - uint16_t udp_chk = csum( (unsigned short*) recv_raw_udp_buf, csum_len); + int csum_len=ip_payloadlen; + uint16_t udp_chk = csum_with_header((char *)psh,sizeof(pseudo_header), (unsigned short*) ip_payload, csum_len); + */ + uint16_t udp_chk; + int csum_len=ip_payloadlen; + if(raw_ip_version==AF_INET) + { + pseudo_header tmp_header; + struct pseudo_header *psh=&tmp_header ; + + psh->source_address = recv_info.new_src_ip.v4; + psh->dest_address = recv_info.new_dst_ip.v4; + psh->placeholder = 0; + psh->protocol = IPPROTO_UDP; + psh->tcp_length = htons(ip_payloadlen); + + udp_chk = csum_with_header((char *)psh,sizeof(pseudo_header), (unsigned short*) ip_payload, csum_len); + } + else + { + assert(raw_ip_version==AF_INET6); + + pseudo_header6 tmp_header; + struct pseudo_header6 *psh=&tmp_header ; + + psh->src = recv_info.new_src_ip.v6; + psh->dst = recv_info.new_dst_ip.v6; + psh->placeholder1 = 0; + psh->placeholder2 = 0; + psh->next_header = IPPROTO_UDP; + psh->tcp_length = htons(ip_payloadlen); + + udp_chk = csum_with_header((char *)psh,sizeof(pseudo_header6), (unsigned short*) ip_payload, csum_len); + } if(udp_chk!=0) { @@ -1636,7 +2231,7 @@ int recv_raw_udp(raw_info_t &raw_info, char *&payload, int &payloadlen) } - char *udp_begin=recv_raw_udp_buf+sizeof(struct pseudo_header); + char *udp_begin=ip_payload; recv_info.src_port=ntohs(udph->source); recv_info.dst_port=ntohs(udph->dest); @@ -1647,13 +2242,82 @@ int recv_raw_udp(raw_info_t &raw_info, char *&payload, int &payloadlen) return 0; } +int parse_tcp_option(char * option_begin,char * option_end,packet_info_t &recv_info) +{ + recv_info.has_ts=0; + recv_info.ts=0; + char *ptr=option_begin; + //char *option_end=tcp_begin+tcp_hdr_len; + while(ptr=option_end) + { + mylog(log_trace,"invaild option ptr+1==option_end,for ts\n"); + return -1; + } + if(*(ptr+1)!=10) + { + mylog(log_trace,"invaild ts len\n"); + return -1; + } + if(ptr+10>option_end) + { + mylog(log_trace,"ptr+10>option_end for ts\n"); + return -1; + } + + recv_info.has_ts=1; + + recv_info.ts= read_u32(ptr+2); + recv_info.ts_ack=read_u32(ptr+6); + + //printf("<%d %d>!\n",recv_info.ts,recv_info.ts_ack); + + //return 0;//we currently only parse ts, so just return after its found + ptr+=8; + } + else + { + if(ptr+1>=option_end) + { + mylog(log_trace,"invaild option ptr+1==option_end\n"); + return -1; + } + else + { + int len=(unsigned char)*(ptr+1); + if(len<=1) + { + mylog(log_trace,"invaild option len %d\n",len); + return -1; + } + //omit check + ptr+=len; + } + } + //printf("!"); + } + //printf("\n"); + + return 0; +} int recv_raw_tcp(raw_info_t &raw_info,char * &payload,int &payloadlen) { const packet_info_t &send_info=raw_info.send_info; packet_info_t &recv_info=raw_info.recv_info; - static char recv_raw_tcp_buf[buf_len]; + //static char recv_raw_tcp_buf[buf_len]; char * ip_payload; int ip_payloadlen; @@ -1681,26 +2345,55 @@ int recv_raw_tcp(raw_info_t &raw_info,char * &payload,int &payloadlen) return 0; } + if (tcphdrlen >ip_payloadlen) { + mylog(log_debug,"error,tcphdrlen >ip_payloadlen\n"); + return 0; + } + if(tcph->dest!=ntohs(uint16_t(filter_port))) { - mylog(log_debug,"dropped packet for other ports\n"); //printf("%x %x",tcph->dest,); return -1; } - memcpy(recv_raw_tcp_buf+ sizeof(struct pseudo_header) , ip_payload , ip_payloadlen); + // memcpy(recv_raw_tcp_buf+ sizeof(struct pseudo_header) , ip_payload , ip_payloadlen); + uint16_t tcp_chk; + int csum_len=ip_payloadlen; + if(raw_ip_version==AF_INET) + { + pseudo_header tmp_header; + struct pseudo_header *psh=&tmp_header ; - struct pseudo_header *psh=(pseudo_header *)recv_raw_tcp_buf ; + psh->source_address = recv_info.new_src_ip.v4; + psh->dest_address = recv_info.new_dst_ip.v4; + psh->placeholder = 0; + psh->protocol = IPPROTO_TCP; + psh->tcp_length = htons(ip_payloadlen); - psh->source_address = recv_info.src_ip; - psh->dest_address = recv_info.dst_ip; - psh->placeholder = 0; - psh->protocol = IPPROTO_TCP; - psh->tcp_length = htons(ip_payloadlen); + tcp_chk = csum_with_header((char *)psh,sizeof(pseudo_header), (unsigned short*) ip_payload, csum_len); + } + else + { + assert(raw_ip_version==AF_INET6); - int csum_len=sizeof(struct pseudo_header)+ip_payloadlen; - uint16_t tcp_chk = csum( (unsigned short*) recv_raw_tcp_buf, csum_len); + pseudo_header6 tmp_header; + struct pseudo_header6 *psh=&tmp_header ; + + psh->src = recv_info.new_src_ip.v6; + psh->dst = recv_info.new_dst_ip.v6; + psh->placeholder1 = 0; + psh->placeholder2 = 0; + psh->next_header = IPPROTO_TCP; + psh->tcp_length = htons(ip_payloadlen); + + tcp_chk = csum_with_header((char *)psh,sizeof(pseudo_header6), (unsigned short*) ip_payload, csum_len); + } + /*for(int i=0;i",int(ip_payload[i])); + } + printf("\n");*/ if(tcp_chk!=0) { @@ -1710,10 +2403,13 @@ int recv_raw_tcp(raw_info_t &raw_info,char * &payload,int &payloadlen) } - char *tcp_begin=recv_raw_tcp_buf+sizeof(struct pseudo_header); //ip packet's data part + char *tcp_begin=ip_payload; //ip packet's data part - char *tcp_option=recv_raw_tcp_buf+sizeof(struct pseudo_header)+sizeof(my_tcphdr); + char *tcp_option=ip_payload+sizeof(my_tcphdr); + char *option_end=ip_payload+tcphdrlen; + /* + //old ts parse code recv_info.has_ts=0; recv_info.ts=0; if(tcph->doff==10) @@ -1758,7 +2454,9 @@ int recv_raw_tcp(raw_info_t &raw_info,char * &payload,int &payloadlen) { //mylog(log_info,"tcph->doff= %u\n",tcph->doff); } - + printf("<%d %d>\n",recv_info.ts,recv_info.ts_ack); + */ + parse_tcp_option(tcp_option,option_end,recv_info); recv_info.ack=tcph->ack; recv_info.syn=tcph->syn; @@ -1791,29 +2489,29 @@ int recv_raw_tcp(raw_info_t &raw_info,char * &payload,int &payloadlen) { if(raw_info.rst_received < max_rst_to_show) { - mylog(log_warn,"[%s,%d]rst==1,cnt=%d\n",my_ntoa(recv_info.src_ip),recv_info.src_port,(int)raw_info.rst_received); + mylog(log_warn,"[%s,%d]rst==1,cnt=%d\n",recv_info.new_src_ip.get_str1(),recv_info.src_port,(int)raw_info.rst_received); } else if(raw_info.rst_received == max_rst_to_show) { - mylog(log_warn,"[%s,%d]rst==1,cnt=%d >=max_rst_to_show, this log will be muted for current connection\n",my_ntoa(recv_info.src_ip),recv_info.src_port,(int)raw_info.rst_received); + mylog(log_warn,"[%s,%d]rst==1,cnt=%d >=max_rst_to_show, this log will be muted for current connection\n",recv_info.new_src_ip.get_str1(),recv_info.src_port,(int)raw_info.rst_received); } else { - mylog(log_debug,"[%s,%d]rst==1,cnt=%d\n",my_ntoa(recv_info.src_ip),recv_info.src_port,(int)raw_info.rst_received); + mylog(log_debug,"[%s,%d]rst==1,cnt=%d\n",recv_info.new_src_ip.get_str1(),recv_info.src_port,(int)raw_info.rst_received); } } else if(max_rst_to_show==0) { - mylog(log_debug,"[%s,%d]rst==1,cnt=%d\n",my_ntoa(recv_info.src_ip),recv_info.src_port,(int)raw_info.rst_received); + mylog(log_debug,"[%s,%d]rst==1,cnt=%d\n",recv_info.new_src_ip.get_str1(),recv_info.src_port,(int)raw_info.rst_received); } else { - mylog(log_warn,"[%s,%d]rst==1,cnt=%d\n",my_ntoa(recv_info.src_ip),recv_info.src_port,(int)raw_info.rst_received); + mylog(log_warn,"[%s,%d]rst==1,cnt=%d\n",recv_info.new_src_ip.get_str1(),recv_info.src_port,(int)raw_info.rst_received); } if(max_rst_allowed>=0 && raw_info.rst_received==max_rst_allowed+1 ) { - mylog(log_warn,"[%s,%d]connection disabled because of rst_received=%d > max_rst_allow=%d\n",my_ntoa(recv_info.src_ip),recv_info.src_port,(int)raw_info.rst_received,(int)max_rst_allowed ); + mylog(log_warn,"[%s,%d]connection disabled because of rst_received=%d > max_rst_allow=%d\n",recv_info.new_src_ip.get_str1(),recv_info.src_port,(int)raw_info.rst_received,(int)max_rst_allowed ); raw_info.disabled=1; } } @@ -2008,7 +2706,7 @@ int send_raw0(raw_info_t &raw_info,const char * payload,int payloadlen) packet_info_t &send_info=raw_info.send_info; packet_info_t &recv_info=raw_info.recv_info; - mylog(log_trace,"send_raw : from %x %d to %x %d\n",send_info.src_ip,send_info.src_port,send_info.dst_ip,send_info.dst_port); + mylog(log_trace,"send_raw : from %s %d to %s %d\n",send_info.new_src_ip.get_str1(),send_info.src_port,send_info.new_dst_ip.get_str2(),send_info.dst_port); switch(raw_mode) { case mode_faketcp:return send_raw_tcp(raw_info,payload,payloadlen); @@ -2049,7 +2747,7 @@ int after_send_raw0(raw_info_t &raw_info) send_info.seq += raw_info.send_info.data_len; //////////////////modify } else if (seq_mode == 2) { - if (get_true_random_number() % 5 == 3) + if (random() % 5 == 3) send_info.seq += raw_info.send_info.data_len; //////////////////modify } else if(seq_mode==3||seq_mode==4) @@ -2156,6 +2854,7 @@ int recv_raw(raw_info_t &raw_info,char *& payload,int & payloadlen) } }*/ + int get_src_adress(u32_t &ip,u32_t remote_ip_uint32,int remote_port) //a trick to get src adress for a dest adress,so that we can use the src address in raw socket as source ip { struct sockaddr_in remote_addr_in={0}; @@ -2180,29 +2879,49 @@ int get_src_adress(u32_t &ip,u32_t remote_ip_uint32,int remote_port) //a trick if(ret!=0) { mylog(log_warn,"udp fd connect fail\n"); - sock_close(new_udp_fd); + close(new_udp_fd); return -1; } struct sockaddr_in my_addr={0}; socklen_t len=sizeof(my_addr); - if(getsockname(new_udp_fd, (struct sockaddr *) &my_addr, &len)!=0) return -1; + if(getsockname(new_udp_fd, (struct sockaddr *) &my_addr, &len)!=0){close(new_udp_fd); return -1;} ip=my_addr.sin_addr.s_addr; - sock_close(new_udp_fd); + close(new_udp_fd); return 0; } +int get_src_adress2(address_t &output_addr,address_t remote_addr) +{ + int new_udp_fd=remote_addr.new_connected_udp_fd(); + if(new_udp_fd<0) + { + mylog(log_warn,"create udp_fd error\n"); + return -1; + } + + socklen_t len=sizeof(output_addr.inner); + + if(getsockname(new_udp_fd, (struct sockaddr *) &output_addr.inner, &len)!=0) {close(new_udp_fd); return -1;} + + assert(output_addr.get_type()==remote_addr.get_type()); + + close(new_udp_fd); + + return 0; +} + int try_to_list_and_bind(int &fd,u32_t local_ip_uint32,int port) //try to bind to a port,may fail. { int old_bind_fd=fd; if(raw_mode==mode_faketcp) { - fd=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); + fd=socket(AF_INET,SOCK_STREAM,0); } else if(raw_mode==mode_udp||raw_mode==mode_icmp) { @@ -2210,7 +2929,7 @@ int try_to_list_and_bind(int &fd,u32_t local_ip_uint32,int port) //try to bind } if(old_bind_fd!=-1) { - sock_close(old_bind_fd); + close(old_bind_fd); } struct sockaddr_in temp_bind_addr={0}; @@ -2220,13 +2939,14 @@ int try_to_list_and_bind(int &fd,u32_t local_ip_uint32,int port) //try to bind temp_bind_addr.sin_port = htons(port); temp_bind_addr.sin_addr.s_addr = local_ip_uint32; - if (::bind(fd, (struct sockaddr*)&temp_bind_addr, sizeof(temp_bind_addr)) !=0) + if (bind(fd, (struct sockaddr*)&temp_bind_addr, sizeof(temp_bind_addr)) !=0) { mylog(log_debug,"bind fail\n"); return -1; } - if(raw_mode==mode_faketcp &&!use_tcp_dummy_socket) + if(raw_mode==mode_faketcp) { + if (listen(fd, SOMAXCONN) != 0) { mylog(log_warn,"listen fail\n"); return -1; @@ -2234,6 +2954,49 @@ int try_to_list_and_bind(int &fd,u32_t local_ip_uint32,int port) //try to bind } return 0; } +int try_to_list_and_bind2(int &fd,address_t address) //try to bind to a port,may fail. +{ + if(fd!=-1) + { + close(fd); + } + if(raw_mode==mode_faketcp) + { + fd=socket(address.get_type(),SOCK_STREAM,0); + } + else if(raw_mode==mode_udp||raw_mode==mode_icmp) + { + fd=socket(address.get_type(),SOCK_DGRAM,0); + } + + if(fd==-1) + { + mylog(log_debug,"create fd fail\n"); + return -1; + } + /*struct sockaddr_in temp_bind_addr={0}; + //bzero(&temp_bind_addr, sizeof(temp_bind_addr)); + + temp_bind_addr.sin_family = AF_INET; + temp_bind_addr.sin_port = htons(port); + temp_bind_addr.sin_addr.s_addr = local_ip_uint32;*/ + + if (bind(fd, (struct sockaddr*)&address.inner, address.get_len()) !=0) + { + mylog(log_debug,"bind fail\n"); + return -1; + } + if(raw_mode==mode_faketcp) + { + + if (listen(fd, SOMAXCONN) != 0) { + mylog(log_warn,"listen fail\n"); + return -1; + } + } + return 0; +} + int client_bind_to_a_new_port(int &fd,u32_t local_ip_uint32)//find a free port and bind to it. { int raw_send_port=10000+get_true_random_number()%(65535-10000); @@ -2248,3 +3011,20 @@ int client_bind_to_a_new_port(int &fd,u32_t local_ip_uint32)//find a free port a myexit(-1); return -1;////for compiler check } + +int client_bind_to_a_new_port2(int &fd,const address_t& address)//find a free port and bind to it. +{ + address_t tmp=address; + int raw_send_port=10000+get_true_random_number()%(65535-10000); + for(int i=0;i<1000;i++)//try 1000 times at max,this should be enough + { + tmp.set_port(raw_send_port); + if (try_to_list_and_bind2(fd,address)==0) + { + return raw_send_port; + } + } + mylog(log_fatal,"bind port fail\n"); + myexit(-1); + return -1;////for compiler check +}