sad
/
udp2raw
mirror of https://github.com/wangyu-/udp2raw.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
udp2raw/network.cpp

2827 lines
88 KiB
C++
Raw Permalink Blame History

/*
* network.cpp
*
* Created on: Jul 29, 2017
* Author: wangyu
*/
#include "common.h"
#include "network.h"
#include "log.h"
#include "misc.h"
int g_fix_gro = 0;
int raw_recv_fd = -1;
int raw_send_fd = -1;
u32_t link_level_header_len = 0; // set it to 14 if SOCK_RAW is used in socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP));
int use_tcp_dummy_socket = 0;
int seq_mode = 3;
int max_seq_mode = 4;
int random_drop = 0;
int filter_port = -1;
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_manual = 0;
int ifindex = -1;
char if_name[100] = "";
char dev[100] = "";
unsigned short g_ip_id_counter = 0;
#ifdef UDP2RAW_LINUX
unsigned char dest_hw_addr[sizeof(sockaddr_ll::sll_addr)] =
{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0};
#endif
//{0x00,0x23,0x45,0x67,0x89,0xb9};
const u32_t receive_window_lower_bound = 40960;
const u32_t receive_window_random_range = 512;
const unsigned char wscale = 0x05;
char g_packet_buf[huge_buf_len]; // looks dirty but works well
int g_packet_buf_len = -1;
int g_packet_buf_cnt = 0;
#ifdef UDP2RAW_LINUX
union {
sockaddr_ll ll;
sockaddr_in ipv4;
sockaddr_in6 ipv6;
} g_sockaddr;
socklen_t g_sockaddr_len = -1;
#endif
#ifdef UDP2RAW_MP
#ifndef NO_LIBNET
libnet_t *libnet_handle;
libnet_ptag_t g_ptag = 0;
int send_with_pcap = 0;
#else
int send_with_pcap = 1;
#endif
int pcap_header_captured = 0;
int pcap_header_buf[buf_len];
int pcap_captured_full_len = -1;
pcap_t *pcap_handle;
int pcap_link_header_len = -1;
// int pcap_cnt=0;
queue_t my_queue;
pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t pcap_mutex = PTHREAD_MUTEX_INITIALIZER;
int use_pcap_mutex = 1;
ev_async async_watcher;
struct ev_loop *g_default_loop;
pthread_t pcap_recv_thread;
struct bpf_program g_filter;
long long g_filter_compile_cnt = 0;
#endif
#ifdef UDP2RAW_LINUX
struct sock_filter code_tcp_old[] = {
{0x28, 0, 0, 0x0000000c}, // 0
{0x15, 0, 10, 0x00000800}, // 1
{0x30, 0, 0, 0x00000017}, // 2
{0x15, 0, 8, 0x00000006}, // 3
{0x28, 0, 0, 0x00000014}, // 4
{0x45, 6, 0, 0x00001fff}, // 5
{0xb1, 0, 0, 0x0000000e}, // 6
{0x48, 0, 0, 0x0000000e}, // 7
{0x15, 2, 0, 0x0000ef32}, // 8
{0x48, 0, 0, 0x00000010}, // 9
{0x15, 0, 1, 0x0000ef32}, // 10
{0x6, 0, 0, 0x0000ffff}, // 11
{0x6, 0, 0, 0x00000000}, // 12
};
struct sock_filter code_tcp[] = {
//{ 0x5, 0, 0, 0x00000001 },//0 //jump to 2,dirty hack from tcpdump -d's output
//{ 0x5, 0, 0, 0x00000000 },//1
{0x30, 0, 0, 0x00000009}, // 2
{0x15, 0, 6, 0x00000006}, // 3
{0x28, 0, 0, 0x00000006}, // 4
{0x45, 4, 0, 0x00001fff}, // 5
{0xb1, 0, 0, 0x00000000}, // 6
{0x48, 0, 0, 0x00000002}, // 7
{0x15, 0, 1, 0x0000fffe}, // 8 //modify this fffe to the port you listen on
{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 },
{0x30, 0, 0, 0x00000009},
{0x15, 0, 6, 0x00000011},
{0x28, 0, 0, 0x00000006},
{0x45, 4, 0, 0x00001fff},
{0xb1, 0, 0, 0x00000000},
{0x48, 0, 0, 0x00000002},
{0x15, 0, 1, 0x0000fffe}, // modify this fffe to the port you listen on
{0x6, 0, 0, 0x0000ffff},
{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 },
{0x30, 0, 0, 0x00000009},
{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
(000) ldh [12]
(001) jeq #0x800 jt 2 jf 5
(002) ldb [23]
(003) jeq #0x1 jt 4 jf 5
(004) ret #65535
(005) ret #0
tcpdump -i eth1 ip and icmp -dd
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 0, 3, 0x00000800 },
{ 0x30, 0, 0, 0x00000017 },
{ 0x15, 0, 1, 0x00000001 },
{ 0x6, 0, 0, 0x0000ffff },
{ 0x6, 0, 0, 0x00000000 },
*/
/*
tcpdump -i eth1 ip and tcp and dst port 65534 -dd
{ 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 },
(000) ldh [12]
(001) jeq #0x800 jt 2 jf 10
(002) ldb [23]
(003) jeq #0x6 jt 4 jf 10
(004) ldh [20]
(005) jset #0x1fff jt 10 jf 6
(006) ldxb 4*([14]&0xf)
(007) ldh [x + 16]
(008) jeq #0xfffe jt 9 jf 10
(009) ret #65535
(010) ret #0
*/
#endif
packet_info_t::packet_info_t() {
src_port = 0;
dst_port = 0;
if (raw_mode == mode_faketcp) {
protocol = IPPROTO_TCP;
ack_seq = get_true_random_number();
seq = get_true_random_number();
has_ts = 0;
ts_ack = 0;
syn = 0;
ack = 1;
ack_seq_counter = 0;
// mylog(log_info,"<cons ,ts_ack= %u>\n",ts_ack);
} else if (raw_mode == mode_udp) {
protocol = IPPROTO_UDP;
} else if (raw_mode == mode_icmp) {
if (raw_ip_version == AF_INET) {
protocol = IPPROTO_ICMP;
} else {
assert(raw_ip_version == AF_INET6);
protocol = IPPROTO_ICMPV6;
}
my_icmp_seq = 0;
}
}
#ifdef UDP2RAW_MP
void my_packet_handler(
u_char *args,
const struct pcap_pkthdr *packet_header,
const u_char *pkt_data) {
/*printf("<%d %d>\n",(int)packet_header->caplen,(int)packet_header->len );
for(int i=0;i<sizeof(pcap_pkthdr);i++)
{
char *p=(char *) packet_header;
printf("<%x>",int( p[i] ));
}
printf("\n");*/
// mylog(log_debug,"received a packet!\n");
assert(packet_header->caplen <= packet_header->len);
assert(packet_header->caplen <= huge_data_len);
// if(packet_header->caplen > max_data_len) return ;
if (g_fix_gro == 0 && packet_header->caplen < packet_header->len) return;
if ((int)packet_header->caplen < pcap_link_header_len) return;
// mylog(log_debug,"and its vaild!\n");
pthread_mutex_lock(&queue_mutex);
if (!my_queue.full())
my_queue.push_back((char *)pkt_data, (int)(packet_header->caplen));
pthread_mutex_unlock(&queue_mutex);
// pcap_cnt++;
ev_async_send(g_default_loop, &async_watcher);
return;
}
void *pcap_recv_thread_entry(void *none) {
struct pcap_pkthdr *packet_header;
const u_char *pkt_data;
while (1) {
if (use_pcap_mutex) pthread_mutex_lock(&pcap_mutex);
int ret = pcap_loop(pcap_handle, -1, my_packet_handler, NULL); // use -1 instead of 0 as cnt, since 0 is undefined in old versions
if (use_pcap_mutex) pthread_mutex_unlock(&pcap_mutex);
if (ret == -1)
mylog(log_warn, "pcap_loop exited with value %d\n", ret);
else {
mylog(log_debug, "pcap_loop exited with value %d\n", ret);
}
ev_sleep(1.0);
// myexit(-1);
}
/*
while(1)
{
//printf("!!!\n");
pthread_mutex_lock(&pcap_mutex);
int ret=pcap_next_ex(pcap_handle,&packet_header,&pkt_data);
pthread_mutex_unlock(&pcap_mutex);
switch (ret)
{
case 0:
continue;
case 1:
break;
case -1:
mylog(log_fatal,"pcap_next_ex error [%s]\n",pcap_geterr(pcap_handle));
myexit(-1);
break;
case -2:
assert(0==1);//
break;
default:
assert(0==1);//
}
}
myexit(-1);*/
return 0;
}
extern void async_cb(struct ev_loop *loop, struct ev_async *watcher, int revents);
#endif
#ifdef UDP2RAW_LINUX
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
#ifdef UDP2RAW_MP
int init_raw_socket() {
#ifndef NO_LIBNET
char libnet_errbuf[LIBNET_ERRBUF_SIZE];
if (raw_ip_version == AF_INET) {
libnet_handle = libnet_init(LIBNET_RAW4, dev, libnet_errbuf);
} else {
assert(raw_ip_version == AF_INET6);
libnet_handle = libnet_init(LIBNET_RAW6, dev, libnet_errbuf);
}
if (libnet_handle == 0) {
mylog(log_fatal, "libnet_init failed bc of [%s]\n", libnet_errbuf);
myexit(-1);
}
g_ptag = 0;
libnet_clear_packet(libnet_handle);
#endif
char pcap_errbuf[PCAP_ERRBUF_SIZE];
// pcap_handle=pcap_open_live(dev,max_data_len,0,1000,pcap_errbuf);
pcap_handle = pcap_create(dev, pcap_errbuf);
if (pcap_handle == 0) {
mylog(log_fatal, "pcap_create failed bc of [%s]\n", pcap_errbuf);
myexit(-1);
}
assert(pcap_set_snaplen(pcap_handle, huge_data_len) == 0);
assert(pcap_set_promisc(pcap_handle, 0) == 0);
assert(pcap_set_timeout(pcap_handle, 1) == 0);
assert(pcap_set_immediate_mode(pcap_handle, 1) == 0);
int ret = pcap_activate(pcap_handle);
if (ret < 0) {
printf("pcap_activate failed %s\n", pcap_geterr(pcap_handle));
myexit(-1);
}
if (send_with_pcap) {
ret = pcap_setdirection(pcap_handle, PCAP_D_INOUT); // must be used after being actived
if (ret != 0) mylog(log_debug, "pcap_setdirection(pcap_handle,PCAP_D_INOUT) failed with value %d, %s\n", ret, pcap_geterr(pcap_handle));
} else {
ret = pcap_setdirection(pcap_handle, PCAP_D_IN);
if (ret != 0) mylog(log_debug, "pcap_setdirection(pcap_handle,PCAP_D_IN) failed with value %d, %s\n", ret, pcap_geterr(pcap_handle));
}
ret = pcap_datalink(pcap_handle);
if (ret == DLT_EN10MB) {
pcap_link_header_len = 14;
} else if (ret == DLT_NULL) {
pcap_link_header_len = 4;
} else if (ret == DLT_LINUX_SLL) {
pcap_link_header_len = 16;
} else {
mylog(log_fatal, "unknown pcap link type : %d\n", ret);
myexit(-1);
}
char filter_exp[1000];
address_t tmp_addr;
if (get_src_adress2(tmp_addr, remote_addr) != 0) {
mylog(log_error, "get_src_adress() failed, maybe you dont have internet\n");
myexit(-1);
}
string src = tmp_addr.get_ip();
string dst = remote_addr.get_ip();
if (raw_ip_version == AF_INET) {
// sprintf(filter_exp,"ip and src %s and dst %s and (tcp or udp or icmp)",my_ntoa(source_ip_uint32),dst.c_str());
sprintf(filter_exp, "ip and src %s and dst %s and (tcp or udp or icmp)", src.c_str(), dst.c_str());
} else {
assert(raw_ip_version == AF_INET6);
sprintf(filter_exp, "ip6 and src %s and dst %s and (tcp or udp or icmp6)", src.c_str(), dst.c_str());
}
if (pcap_compile(pcap_handle, &g_filter, filter_exp, 0, PCAP_NETMASK_UNKNOWN) == -1) {
printf("Bad filter - %s\n", pcap_geterr(pcap_handle));
myexit(-1);
}
g_filter_compile_cnt++;
if (pcap_setfilter(pcap_handle, &g_filter) == -1) {
printf("Error setting filter - %s\n", pcap_geterr(pcap_handle));
myexit(-1);
}
///////////////////////////////////////////////////////////////new thread created here
if (pthread_create(&pcap_recv_thread, NULL, pcap_recv_thread_entry, 0)) {
mylog(log_fatal, "Error creating thread\n");
myexit(-1);
}
////////////////////////////////////////////////////////////////////////////////
g_ip_id_counter = get_true_random_number() % 65535;
/*
if(lower_level==0)
{
raw_send_fd = socket(AF_INET , SOCK_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);
}
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));
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);
}
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));
raw_recv_fd= socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
if(raw_recv_fd == -1) {
mylog(log_fatal,"Failed to create raw_recv_fd\n");
//perror("");
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
#ifdef UDP2RAW_LINUX
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=0;
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);
}
}
#endif
#ifdef UDP2RAW_MP
void init_filter(int port) {
/*
sock_fprog bpf;*/
if (raw_mode == mode_faketcp || raw_mode == mode_udp) {
filter_port = port;
}
char filter_exp[1000];
if (raw_ip_version == AF_INET) {
if (raw_mode == mode_faketcp) {
sprintf(filter_exp, "ip and tcp and src %s and src port %d and dst port %d", remote_addr.get_ip(), remote_addr.get_port(), port);
} else if (raw_mode == mode_udp) {
sprintf(filter_exp, "ip and udp and src %s and src port %d and dst port %d", remote_addr.get_ip(), remote_addr.get_port(), port);
} else if (raw_mode == mode_icmp) {
sprintf(filter_exp, "ip and icmp and src %s", remote_addr.get_ip());
} else {
mylog(log_fatal, "unknow raw mode\n");
myexit(-1);
}
} else {
assert(raw_ip_version == AF_INET6);
if (raw_mode == mode_faketcp) {
sprintf(filter_exp, "ip6 and tcp and src %s and src port %d and dst port %d", remote_addr.get_ip(), remote_addr.get_port(), port);
} else if (raw_mode == mode_udp) {
sprintf(filter_exp, "ip6 and udp and src %s and src port %d and dst port %d", remote_addr.get_ip(), remote_addr.get_port(), port);
} else if (raw_mode == mode_icmp) {
sprintf(filter_exp, "ip6 and icmp6 and src %s", remote_addr.get_ip());
} else {
mylog(log_fatal, "unknow raw mode\n");
myexit(-1);
}
}
mylog(log_info, "filter expression is [%s]\n", filter_exp);
// pthread_mutex_lock(&pcap_mutex);//not sure if mutex is needed here
long long tmp_cnt = 0;
if (use_pcap_mutex) {
while (pthread_mutex_trylock(&pcap_mutex) != 0) {
tmp_cnt++;
pcap_breakloop(pcap_handle);
if (tmp_cnt == 100) {
mylog(log_warn, "%lld attempts of pcap_breakloop()\n", tmp_cnt);
}
if (tmp_cnt % 1000 == 0) {
mylog(log_warn, "%lld attempts of pcap_breakloop()\n", tmp_cnt);
if (tmp_cnt > 5000) {
mylog(log_fatal, "we might have already run into a deadlock\n");
}
}
ev_sleep(0.001);
}
mylog(log_info, "breakloop() succeed after %lld attempt(s)\n", tmp_cnt);
}
if (1) {
int ret = pcap_setdirection(pcap_handle, PCAP_D_IN);
if (ret != 0) mylog(log_debug, "pcap_setdirection(pcap_handle,PCAP_D_IN) failed with value %d, %s\n", ret, pcap_geterr(pcap_handle));
}
assert(g_filter_compile_cnt != 0);
pcap_freecode(&g_filter);
if (pcap_compile(pcap_handle, &g_filter, filter_exp, 0, PCAP_NETMASK_UNKNOWN) == -1) {
mylog(log_fatal, "Bad filter - %s\n", pcap_geterr(pcap_handle));
myexit(-1);
}
g_filter_compile_cnt++;
if (pcap_setfilter(pcap_handle, &g_filter) == -1) {
mylog(log_fatal, "Error setting filter - %s\n", pcap_geterr(pcap_handle));
myexit(-1);
}
if (use_pcap_mutex) pthread_mutex_unlock(&pcap_mutex);
/*
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)
{
bpf.len = sizeof(code_tcp)/sizeof(code_tcp[0]);
code_tcp[code_tcp_port_index].k=port;
bpf.filter = code_tcp;
}
else if(raw_mode==mode_udp)
{
bpf.len = sizeof(code_udp)/sizeof(code_udp[0]);
code_udp[code_udp_port_index].k=port;
bpf.filter = code_udp;
}
else if(raw_mode==mode_icmp)
{
bpf.len = sizeof(code_icmp)/sizeof(code_icmp[0]);
bpf.filter = code_icmp;
}
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);
}*/
}
#endif
void remove_filter() {
filter_port = 0;
#ifdef UDP2RAW_LINUX
int dummy=0;
int ret = setsockopt(raw_recv_fd, SOL_SOCKET, SO_DETACH_FILTER, &dummy, sizeof(dummy));
if (ret != 0) {
mylog(log_debug, "error remove fiter\n");
// perror("filter");
// exit(-1);
}
#endif
}
int init_ifindex(const char *if_name, int fd, int &index) {
#ifdef UDP2RAW_LINUX
struct ifreq ifr;
size_t if_name_len = strlen(if_name);
if (if_name_len < sizeof(ifr.ifr_name)) {
memcpy(ifr.ifr_name, if_name, if_name_len);
ifr.ifr_name[if_name_len] = 0;
} else {
mylog(log_fatal, "interface name is too long\n");
myexit(-1);
}
if (ioctl(fd, SIOCGIFINDEX, &ifr) == -1) {
mylog(log_fatal, "SIOCGIFINDEX fail ,%s\n", strerror(errno));
myexit(-1);
}
index = ifr.ifr_ifindex;
mylog(log_info, "ifname:%s ifindex:%d\n", if_name, index);
#endif
return 0;
}
#ifdef UDP2RAW_LINUX
bool interface_has_arp(const char *interface) {
struct ifreq ifr;
// int sock = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
int sock = raw_send_fd;
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, interface);
if (ioctl(sock, SIOCGIFFLAGS, &ifr) < 0) {
// perror("SIOCGIFFLAGS");
mylog(log_fatal, "ioctl(sock, SIOCGIFFLAGS, &ifr) failed for interface %s,errno %s\n", interface, strerror(errno));
myexit(-1);
}
// close(sock);
return !(ifr.ifr_flags & IFF_NOARP);
}
struct route_info_t {
string if_name;
u32_t dest;
u32_t mask;
u32_t gw;
u32_t flag;
};
int dest_idx = 1;
int gw_idx = 2;
int if_idx = 0;
int mask_idx = 7;
int flag_idx = 3;
vector<int> find_route_entry(const vector<route_info_t> &route_info_vec, u32_t ip) {
vector<int> res;
for (u32_t i = 0; i <= 32; i++) {
u32_t mask = 0xffffffff;
// mask >>=i;
// if(i==32) mask=0; //why 0xffffffff>>32 equals 0xffffffff??
mask <<= i;
if (i == 32) mask = 0;
log_bare(log_debug, "(mask:%x)", mask);
for (u32_t j = 0; j < route_info_vec.size(); j++) {
const route_info_t &info = route_info_vec[j];
if (info.mask != mask)
continue;
log_bare(log_debug, "<<%d,%d>>", i, j);
if ((info.dest & mask) == (ip & mask)) {
log_bare(log_debug, "found!");
res.push_back(j);
}
}
if (res.size() != 0) {
return res;
}
}
return res;
}
int find_direct_dest(const vector<route_info_t> &route_info_vec, u32_t ip, u32_t &dest_ip, string &if_name) {
vector<int> res;
for (int i = 0; i < 1000; i++) {
res = find_route_entry(route_info_vec, ip);
log_bare(log_debug, "<entry:%u>", (u32_t)res.size());
if (res.size() == 0) {
mylog(log_error, "cant find route entry\n");
return -1;
}
if (res.size() > 1) {
mylog(log_error, "found duplicated entries\n");
return -1;
}
if ((route_info_vec[res[0]].flag & 2) == 0) {
dest_ip = ip;
if_name = route_info_vec[res[0]].if_name;
return 0;
} else {
ip = route_info_vec[res[0]].gw;
}
}
mylog(log_error, "dead loop in find_direct_dest\n");
return -1;
}
struct arp_info_t {
u32_t ip;
string hw;
string if_name;
};
int arp_ip_idx = 0;
int arp_hw_idx = 3;
int arp_if_idx = 5;
int find_arp(const vector<arp_info_t> &arp_info_vec, u32_t ip, string if_name, string &hw) {
int pos = -1;
int count = 0;
for (u32_t i = 0; i < arp_info_vec.size(); i++) {
const arp_info_t &info = arp_info_vec[i];
if (info.if_name != if_name) continue;
if (info.ip == ip) {
count++;
pos = i;
}
}
if (count == 0) {
// mylog(log_warn,"cant find arp entry for %s %s,using 00:00:00:00:00:00\n",my_ntoa(ip),if_name.c_str());
// hw="00:00:00:00:00:00";
mylog(log_error, "cant find arp entry for %s %s\n", my_ntoa(ip), if_name.c_str());
return -1;
}
if (count > 1) {
mylog(log_error, "find multiple arp entry for %s %s\n", my_ntoa(ip), if_name.c_str());
return -1;
}
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) {
ip = htonl(ip);
if (ip == htonl(inet_addr("127.0.0.1"))) {
dest_ip = ntohl(ip);
if_name = "lo";
hw = "00:00:00:00:00:00";
return 0;
}
string route_file;
if (read_file("/proc/net/route", route_file) != 0) return -1;
string arp_file;
if (read_file("/proc/net/arp", arp_file) != 0) return -1;
log_bare(log_debug, "/proc/net/route:<<%s>>\n", route_file.c_str());
log_bare(log_debug, "/proc/net/arp:<<%s>>\n", route_file.c_str());
auto route_vec2 = string_to_vec2(route_file.c_str());
vector<route_info_t> route_info_vec;
for (u32_t i = 1; i < route_vec2.size(); i++) {
log_bare(log_debug, "<size:%u>", (u32_t)route_vec2[i].size());
if (route_vec2[i].size() != 11) {
mylog(log_error, "route coloum %d !=11 \n", int(route_vec2[i].size()));
return -1;
}
route_info_t tmp;
tmp.if_name = route_vec2[i][if_idx];
if (hex_to_u32_with_endian(route_vec2[i][dest_idx], tmp.dest) != 0) return -1;
if (hex_to_u32_with_endian(route_vec2[i][gw_idx], tmp.gw) != 0) return -1;
if (hex_to_u32_with_endian(route_vec2[i][mask_idx], tmp.mask) != 0) return -1;
if (hex_to_u32(route_vec2[i][flag_idx], tmp.flag) != 0) return -1;
route_info_vec.push_back(tmp);
for (u32_t j = 0; j < route_vec2[i].size(); j++) {
log_bare(log_debug, "<%s>", route_vec2[i][j].c_str());
}
log_bare(log_debug, "%s dest:%x mask:%x gw:%x flag:%x", tmp.if_name.c_str(), tmp.dest, tmp.mask, tmp.gw, tmp.flag);
log_bare(log_debug, "\n");
}
if (find_direct_dest(route_info_vec, ip, dest_ip, if_name) != 0) {
mylog(log_error, "find_direct_dest failed for ip %s\n", my_ntoa(ntohl(ip)));
return -1;
}
log_bare(log_debug, "========\n");
auto arp_vec2 = string_to_vec2(arp_file.c_str());
vector<arp_info_t> arp_info_vec;
for (u32_t i = 1; i < arp_vec2.size(); i++) {
log_bare(log_debug, "<<arp_vec2[i].size(): %d>>", (int)arp_vec2[i].size());
for (u32_t j = 0; j < arp_vec2[i].size(); j++) {
log_bare(log_debug, "<%s>", arp_vec2[i][j].c_str());
}
if (arp_vec2[i].size() != 6) {
mylog(log_error, "arp coloum %d !=11 \n", int(arp_vec2[i].size()));
return -1;
}
arp_info_t tmp;
tmp.if_name = arp_vec2[i][arp_if_idx];
tmp.hw = arp_vec2[i][arp_hw_idx];
tmp.ip = htonl(inet_addr(arp_vec2[i][arp_ip_idx].c_str()));
arp_info_vec.push_back(tmp);
log_bare(log_debug, "\n");
}
if (!interface_has_arp(if_name.c_str())) {
mylog(log_info, "%s is a noarp interface,using 00:00:00:00:00:00\n", if_name.c_str());
hw = "00:00:00:00:00:00";
} else if (find_arp(arp_info_vec, dest_ip, if_name, hw) != 0) {
mylog(log_error, "find_arp failed for dest_ip %s ,if_name %s\n", my_ntoa(ntohl(ip)), if_name.c_str());
return -1;
}
// printf("%s\n",hw.c_str());
dest_ip = ntohl(dest_ip);
return 0;
}
#endif
#ifdef UDP2RAW_LINUX
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;
int ret;
if (lower_level == 0) {
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 {
struct sockaddr_ll addr = {0}; //={0} not necessary
memcpy(&addr, &send_info.addr_ll, sizeof(addr));
ret = sendto(raw_send_fd, packet, len, 0, (struct sockaddr *)&addr, sizeof(addr));
}
if (ret == -1) {
mylog(log_trace, "sendto failed\n");
// perror("why?");
return -1;
} else {
// mylog(log_info,"sendto succ\n");
}
return 0;
}
#endif
#ifdef UDP2RAW_MP
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;
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);
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);
// pthread_mutex_lock(&pcap_mutex); looks like this is not necessary, and it harms performance
int ret = pcap_sendpacket(pcap_handle, (const unsigned char *)buf, len + pcap_link_header_len);
if (ret != 0) {
mylog(log_warn, "pcap_sendpcaket failed with vaule %d,%s, data_len=%d\n", ret, pcap_geterr(pcap_handle), len);
// pthread_mutex_unlock(&pcap_mutex);
// myexit(-1);
}
// pthread_mutex_unlock(&pcap_mutex);
/*
unsigned char *p=(unsigned char *)send_raw_ip_buf0;
for(int i=0;i<ip_tot_len+pcap_link_header_len;i++)
printf("<%02x>",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<cap_len;i++)
printf("<%02x>",int(p[i]));
printf("\n");
printf("pcap send!\n");*/
}
return 0;
}
#endif
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;
#ifdef UDP2RAW_LINUX
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;
#endif
#ifdef UDP2RAW_MP
iph->tot_len = htons(ip_tot_len); // always fill for mp version
#endif
memcpy(send_raw_ip_buf + sizeof(my_iphdr), payload, payloadlen);
#ifdef UDP2RAW_LINUX
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;
#endif
#ifdef UDP2RAW_MP
iph->check = csum((unsigned short *)send_raw_ip_buf, iph->ihl * 4); // always cal checksum for mp version
#endif
} 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() {
#ifdef UDP2RAW_LINUX
assert(g_packet_buf_cnt == 0);
g_sockaddr_len = sizeof(g_sockaddr.ll);
g_packet_buf_len = recvfrom(raw_recv_fd, g_packet_buf, huge_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 == huge_data_len + 1) {
if (g_fix_gro == 0) {
mylog(log_warn, "huge packet, data_len %d > %d,dropped\n", g_packet_buf_len, huge_data_len);
return -1;
} else {
mylog(log_debug, "huge packet, data_len %d > %d,not dropped\n", g_packet_buf_len, huge_data_len);
g_packet_buf_len = huge_data_len;
}
}
if (g_packet_buf_len >= max_data_len + 1) {
if (g_fix_gro == 0) {
mylog(log_warn, "huge packet, data_len %d > %d(max_data_len) dropped, maybe you need to turn down mtu at upper level, or you may take a look at --fix-gro\n", g_packet_buf_len,
max_data_len);
return -1;
} else {
mylog(log_debug, "huge packet, data_len %d > %d(max_data_len) not dropped\n", g_packet_buf_len,
max_data_len);
// return -1;
}
}
if (g_packet_buf_len < 0) {
mylog(log_trace, "recv_len %d\n", g_packet_buf_len);
return -1;
}
g_packet_buf_cnt++;
#endif
return 0;
}
int discard_raw_packet() {
assert(g_packet_buf_cnt == 1);
g_packet_buf_cnt--;
return 0;
}
#ifdef UDP2RAW_LINUX
int recv_raw_packet(char *&packet, int &len, int peek) {
assert(g_packet_buf_cnt == 1);
if (!peek)
g_packet_buf_cnt--;
if (g_packet_buf_len < int(link_level_header_len)) {
mylog(log_trace, "packet len %d shorter than link_level_header_len %d\n", g_packet_buf_len, int(link_level_header_len));
return -1;
}
if (link_level_header_len == 14) {
unsigned char a = g_packet_buf[12];
unsigned char b = g_packet_buf[13];
if (!((a == 0x08 && b == 0x00) || (a == 0x86 && b == 0xdd))) {
mylog(log_trace, "not an ipv4 or ipv6 packet!\n");
return -1;
}
}
packet = g_packet_buf + int(link_level_header_len);
len = g_packet_buf_len - int(link_level_header_len);
return 0;
}
#endif
#ifdef UDP2RAW_MP
int recv_raw_packet(char *&packet, int &len, int peek) {
assert(g_packet_buf_cnt == 1);
if (!peek)
g_packet_buf_cnt--;
packet = g_packet_buf;
len = g_packet_buf_len;
return 0;
}
#endif
int recv_raw_ip(raw_info_t &raw_info, char *&payload, int &payloadlen) {
char *raw_packet_buf;
// static char recv_raw_ip_buf[buf_len];
int raw_packet_len;
if (recv_raw_packet(raw_packet_buf, raw_packet_len, raw_info.peek) != 0) return -1;
// const packet_info_t &send_info=raw_info.send_info;
packet_info_t &recv_info = raw_info.recv_info;
my_iphdr *iph;
my_ip6hdr *ip6h;
int flag = 0;
// int recv_len = recvfrom(raw_recv_fd, recv_raw_ip_buf, max_data_len+1, flag ,(sockaddr*)&saddr , &saddr_size);
char *ip_begin = raw_packet_buf; // 14 is eth net header
if (raw_packet_len < 1) {
mylog(log_trace, "raw_packet_len <1, dropped\n");
return -1;
}
iph = (struct my_iphdr *)(ip_begin);
ip6h = (struct my_ip6hdr *)(ip_begin);
if (raw_ip_version == AF_INET) {
if (iph->version != 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_len<sizeof(iphdr)\n");
return -1;
}
} else {
assert(raw_ip_version == AF_INET6);
if (ip6h->version != 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_len<sizeof(ip6_hdr)\n");
return -1;
}
}
#ifdef UDP2RAW_LINUX
if (lower_level) {
memcpy(&recv_info.addr_ll, &g_sockaddr.ll, sizeof(recv_info.addr_ll));
}
#endif
unsigned short iphdrlen;
int ip_len;
if (raw_ip_version == AF_INET) {
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
assert(raw_ip_version == AF_INET6);
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 (raw_packet_len < ip_len) {
mylog(log_debug, "incomplete packet\n");
return -1;
}
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);
if (ip_chk != 0) {
mylog(log_debug, "ip header error %x\n", ip_chk);
return -1;
}
}
} else {
// do nothing
}
payload = ip_begin + iphdrlen;
payloadlen = ip_len - iphdrlen;
if (payloadlen < 0) {
mylog(log_warn, "error payload len\n");
return -1;
}
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_len<int(sizeof(iphdr)))
//{
// mylog(log_trace,"failed here %d %d\n",recv_len,int(sizeof(iphdr)));
// mylog(log_trace,"%s\n ",strerror(errno));
// return -1;
// }
// peek_info.new_src_ip.v4=iph->saddr;
// 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_len < int(sizeof(my_tcphdr))) {
mylog(log_trace, "failed here");
return -1;
}
recv_info.src_port = ntohs(tcph->source);
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_len < int(sizeof(my_udphdr)))
return -1;
recv_info.src_port = ntohs(udph->source);
break;
}
case mode_icmp: {
if (raw_ip_version == AF_INET) {
if (recv_info.protocol != IPPROTO_ICMP) return -1;
} else {
assert(raw_ip_version == AF_INET6);
if (recv_info.protocol != IPPROTO_ICMPV6) return -1;
}
struct my_icmphdr *icmph = (my_icmphdr *)payload;
if (payload_len < int(sizeof(my_udphdr)))
return -1;
recv_info.src_port = ntohs(icmph->id);
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];
my_icmphdr *icmph = (struct my_icmphdr *)(send_raw_icmp_buf);
memset(icmph, 0, sizeof(my_icmphdr));
if (raw_ip_version == AF_INET) {
if (program_mode == client_mode) {
icmph->type = 8;
} else {
icmph->type = 0;
}
} else {
assert(raw_ip_version == AF_INET6);
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(my_icmphdr), payload, payloadlen);
if (raw_ip_version == AF_INET) {
icmph->check_sum = csum((unsigned short *)send_raw_icmp_buf, sizeof(my_icmphdr) + payloadlen);
} else {
assert(raw_ip_version == AF_INET6);
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_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;
}
/*if(program_mode==client_mode)
{
send_info.icmp_seq++;
}*/
return 0;
}
int send_raw_udp(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_udp_buf[buf_len];
my_udphdr *udph = (struct my_udphdr *)(send_raw_udp_buf);
memset(udph, 0, sizeof(my_udphdr));
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");
return -1;
}
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(my_udphdr), payload, payloadlen);
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 {
assert(raw_ip_version == AF_INET6);
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;
}
return 0;
}
int send_raw_tcp(raw_info_t &raw_info, const char *payload, int payloadlen) { // TODO seq increase
const packet_info_t &send_info = raw_info.send_info;
const packet_info_t &recv_info = raw_info.recv_info;
// mylog(log_debug,"syn %d\n",send_info.syn);
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);
memset(tcph, 0, sizeof(my_tcphdr));
// TCP Header
tcph->source = htons(send_info.src_port);
tcph->dest = htons(send_info.dst_port);
tcph->seq = htonl(send_info.seq);
tcph->ack_seq = htonl(send_info.ack_seq);
tcph->fin = 0;
tcph->syn = send_info.syn;
tcph->rst = 0;
tcph->psh = send_info.psh;
tcph->ack = send_info.ack;
if (tcph->syn == 1) {
tcph->doff = 10; // tcp header size
int i = sizeof(my_tcphdr);
send_raw_tcp_buf[i++] = 0x02; // mss
send_raw_tcp_buf[i++] = 0x04;
send_raw_tcp_buf[i++] = 0x05;
send_raw_tcp_buf[i++] = (char)0xb4;
// raw_send_buf[i++]=0x01;
// raw_send_buf[i++]=0x01;
send_raw_tcp_buf[i++] = 0x04; // sack ok
send_raw_tcp_buf[i++] = 0x02; // sack ok
send_raw_tcp_buf[i++] = 0x08; // ts i=6
send_raw_tcp_buf[i++] = 0x0a; // i=7
//*(u32_t*) (&send_raw_tcp_buf[i]) = htonl(
// (u32_t) get_current_time());
u32_t ts = htonl((u32_t)get_current_time());
memcpy(&send_raw_tcp_buf[i], &ts, sizeof(ts));
i += 4;
// mylog(log_info,"[syn]<send_info.ts_ack= %u>\n",send_info.ts_ack);
//*(u32_t*) (&send_raw_tcp_buf[i]) = htonl(send_info.ts_ack);
u32_t ts_ack = htonl(send_info.ts_ack);
memcpy(&send_raw_tcp_buf[i], &ts_ack, sizeof(ts_ack));
i += 4;
send_raw_tcp_buf[i++] = 0x01;
send_raw_tcp_buf[i++] = 0x03;
send_raw_tcp_buf[i++] = 0x03;
send_raw_tcp_buf[i++] = wscale;
} else {
tcph->doff = 8;
int i = sizeof(my_tcphdr);
send_raw_tcp_buf[i++] = 0x01;
send_raw_tcp_buf[i++] = 0x01;
send_raw_tcp_buf[i++] = 0x08; // ts //i=2
send_raw_tcp_buf[i++] = 0x0a; // i=3;
//*(u32_t*) (&send_raw_tcp_buf[i]) = htonl(
// (u32_t) get_current_time());
u32_t ts = htonl((u32_t)get_current_time());
memcpy(&send_raw_tcp_buf[i], &ts, sizeof(ts));
i += 4;
// mylog(log_info,"<send_info.ts_ack= %u>\n",send_info.ts_ack);
//*(u32_t*) (&send_raw_tcp_buf[i]) = htonl(send_info.ts_ack);
u32_t ts_ack = htonl(send_info.ts_ack);
memcpy(&send_raw_tcp_buf[i], &ts_ack, sizeof(ts_ack));
i += 4;
}
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->check = 0; // leave checksum 0 now, filled later by pseudo header
tcph->urg_ptr = 0;
char *tcp_data = send_raw_tcp_buf + +tcph->doff * 4;
memcpy(tcp_data, payload, payloadlen);
int tcp_totlen = tcph->doff * 4 + payloadlen;
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 {
assert(raw_ip_version == AF_INET6);
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;
}
raw_info.send_info.data_len = payloadlen;
return 0;
}
/*
int send_raw_tcp_deprecated(const packet_info_t &info,const char * payload,int payloadlen)
{
static uint16_t ip_id=1;
char raw_send_buf[buf_len];
char raw_send_buf2[buf_len];
//if((prog_mode==client_mode&& payloadlen!=9) ||(prog_mode==server_mode&& payloadlen!=5 ) )
mylog(log_trace,"send raw from to %d %d %d %d\n",info.src_ip,info.src_port,info.dst_ip,info.dst_port);
char *data;
memset(raw_send_buf,0,payloadlen+100);
struct iphdr *iph = (struct iphdr *) raw_send_buf;
//TCP header
struct tcphdr *tcph = (struct tcphdr *) (raw_send_buf + sizeof (struct ip));
struct sockaddr_in sin;
struct pseudo_header psh;
//some address resolution
sin.sin_family = AF_INET;
sin.sin_port = htons(info.dst_port);
sin.sin_addr.s_addr = info.dst_ip;
//Fill in the IP Header
iph->ihl = 5;
iph->version = 4;
iph->tos = 0;
iph->id = htonl (ip_id++); //Id of this packet
iph->frag_off = htons(0x4000); //DF set,others are zero
iph->ttl = (unsigned char)ttl_value;
iph->protocol = IPPROTO_TCP;
iph->check = 0; //Set to 0 before calculating checksum
iph->saddr = info.src_ip; //Spoof the source ip address
iph->daddr = info.dst_ip;
//TCP Header
tcph->source = htons(info.src_port);
tcph->dest = htons(info.dst_port);
tcph->seq =htonl(info.seq);
tcph->ack_seq = htonl(info.ack_seq);
tcph->fin=0;
tcph->syn=info.syn;
tcph->rst=0;
tcph->psh=info.psh;
tcph->ack=info.ack;
if(tcph->syn==1)
{
tcph->doff = 10; //tcp header size
int i=sizeof (struct iphdr)+20;
raw_send_buf[i++]=0x02;//mss
raw_send_buf[i++]=0x04;
raw_send_buf[i++]=0x05;
raw_send_buf[i++]=0xb4;
//raw_send_buf[i++]=0x01;
//raw_send_buf[i++]=0x01;
raw_send_buf[i++]=0x04; //sack ok
raw_send_buf[i++]=0x02; //sack ok
raw_send_buf[i++]=0x08; //i=6;
raw_send_buf[i++]=0x0a;
*(uint32_t*)(& raw_send_buf[i])=htonl((uint32_t)get_current_time());
i+=4;
*(uint32_t*)(& raw_send_buf[i])=htonl(info.ts_ack);
i+=4;
raw_send_buf[i++]=0x01;
raw_send_buf[i++]=0x03;
raw_send_buf[i++]=0x03;
raw_send_buf[i++]=0x05;
}
else
{
tcph->doff=8;
int i=sizeof (struct iphdr)+20;
raw_send_buf[i++]=0x01;
raw_send_buf[i++]=0x01;
raw_send_buf[i++]=0x08; //i=0;
raw_send_buf[i++]=0x0a;
*(uint32_t*)(& raw_send_buf[i])=htonl((uint32_t)get_current_time());
i+=4;
*(uint32_t*)(& raw_send_buf[i])=htonl(info.ts_ack);
i+=4;
}
tcph->urg=0;
//tcph->window = htons((uint16_t)(1024));
tcph->window = htons((uint16_t)(10240+random()%100));
tcph->check = 0; //leave checksum 0 now, filled later by pseudo header
tcph->urg_ptr = 0;
//Data part
data = raw_send_buf + sizeof(struct iphdr) + tcph->doff*4;
iph->tot_len = sizeof (struct iphdr) + tcph->doff*4 + payloadlen;
memcpy(data , payload, payloadlen);
psh.source_address = info.src_ip;
psh.dest_address = sin.sin_addr.s_addr;
psh.placeholder = 0;
psh.protocol = IPPROTO_TCP;
psh.tcp_length = htons(tcph->doff*4 + payloadlen );
int psize = sizeof(struct pseudo_header) + tcph->doff*4 + payloadlen;
memcpy(raw_send_buf2 , (char*) &psh , sizeof (struct pseudo_header));
memcpy(raw_send_buf2 + sizeof(struct pseudo_header) , tcph , tcph->doff*4 + payloadlen);
tcph->check = csum( (unsigned short*) raw_send_buf2, psize);
//Ip checksum
iph->check = csum ((unsigned short *) raw_send_buf, iph->tot_len);
mylog(log_trace,"sent seq ack_seq len<%u %u %d>\n",g_packet_info_send.seq,g_packet_info_send.ack_seq,payloadlen);
int ret = sendto(raw_send_fd, raw_send_buf, iph->tot_len , 0, (struct sockaddr *) &sin, sizeof (sin));
if(g_packet_info_send.syn==0&&g_packet_info_send.ack==1&&payloadlen!=0)
{
if(seq_mode==0)
{
}
else if(seq_mode==1)
{
g_packet_info_send.seq+=payloadlen;
}
else if(seq_mode==2)
{
if(random()% 5==3 )
g_packet_info_send.seq+=payloadlen;
}
}
mylog(log_trace,"<ret:%d>\n",ret);
if(ret<0)
{
mylog(log_fatal,"");
perror("raw send error\n");
//printf("send error\n");
}
return 0;
}
*/
int recv_raw_icmp(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_icmp_buf[buf_len];
char *ip_payload;
int ip_payloadlen;
if (recv_raw_ip(raw_info, ip_payload, ip_payloadlen) != 0) {
mylog(log_debug, "recv_raw_ip error\n");
return -1;
}
mylog(log_trace, "ip_payloadlen=%d\n", ip_payloadlen);
if (raw_ip_version == AF_INET) {
if (recv_info.protocol != IPPROTO_ICMP) {
// printf("not udp protocol\n");
return -1;
}
} else {
assert(raw_ip_version == AF_INET6);
if (recv_info.protocol != IPPROTO_ICMPV6) {
// printf("not udp protocol\n");
return -1;
}
}
if (ip_payloadlen < int(sizeof(my_icmphdr))) {
mylog(log_debug, "too short to hold icmp header\n");
return -1;
}
my_icmphdr *icmph = (struct my_icmphdr *)(ip_payload);
if (ntohs(icmph->id) != send_info.src_port) {
mylog(log_debug, "icmp id mis-match,ignored\n");
return -1;
}
recv_info.src_port = recv_info.dst_port = ntohs(icmph->id);
recv_info.my_icmp_seq = ntohs(icmph->seq);
if (icmph->code != 0)
return -1;
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 {
assert(raw_ip_version == AF_INET6);
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) {
mylog(log_debug, "icmp checksum fail %x\n", check);
return -1;
}
// mylog(log_info,"program_mode=%d\n",program_mode);
/*
if(program_mode==server_mode)
{
send_info.icmp_seq=ntohs(icmph->seq);
//mylog(log_info,"send_info.seq=%d\n",send_info.seq);
}*/
payload = ip_payload + sizeof(my_icmphdr);
payloadlen = ip_payloadlen - sizeof(my_icmphdr);
mylog(log_trace, "get a packet len=%d\n", payloadlen);
return 0;
}
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];
char *ip_payload;
int ip_payloadlen;
if (recv_raw_ip(raw_info, ip_payload, ip_payloadlen) != 0) {
mylog(log_debug, "recv_raw_ip error\n");
return -1;
}
if (recv_info.protocol != IPPROTO_UDP) {
// printf("not udp protocol\n");
return -1;
}
if (ip_payloadlen < int(sizeof(my_udphdr))) {
mylog(log_debug, "too short to hold udpheader\n");
return -1;
}
my_udphdr *udph = (struct my_udphdr *)ip_payload;
if (int(ntohs(udph->len)) != ip_payloadlen) {
mylog(log_debug, "udp length error %d %d \n", ntohs(udph->len), ip_payloadlen);
return -1;
}
if (udph->dest != ntohs(uint16_t(filter_port))) {
// printf("%x %x",tcph->dest,);
return -1;
}
// memcpy(recv_raw_udp_buf+ sizeof(struct pseudo_header) , ip_payload , ip_payloadlen);
/*
pseudo_header tmp_header={0};
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);
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) {
mylog(log_debug, "udp_chk:%x\n", udp_chk);
mylog(log_debug, "udp header error\n");
return -1;
}
char *udp_begin = ip_payload;
recv_info.src_port = ntohs(udph->source);
recv_info.dst_port = ntohs(udph->dest);
payloadlen = ip_payloadlen - sizeof(my_udphdr);
payload = udp_begin + sizeof(my_udphdr);
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) {
if (*ptr == 0) {
return 0;
} else if (*ptr == 1) {
ptr++;
} else if (*ptr == 8) {
if (ptr + 1 >= 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 += 10;
} 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];
char *ip_payload;
int ip_payloadlen;
if (recv_raw_ip(raw_info, ip_payload, ip_payloadlen) != 0) {
mylog(log_debug, "recv_raw_ip error\n");
return -1;
}
if (recv_info.protocol != IPPROTO_TCP) {
// printf("not tcp protocol\n");
return -1;
}
my_tcphdr *tcph = (struct my_tcphdr *)ip_payload;
unsigned short tcphdrlen = tcph->doff * 4;
if (!(tcphdrlen > 0 && tcphdrlen <= 60)) {
mylog(log_debug, "tcph error\n");
return 0;
}
if (tcphdrlen > ip_payloadlen) {
mylog(log_debug, "error,tcphdrlen >ip_payloadlen\n");
return 0;
}
if (tcph->dest != ntohs(uint16_t(filter_port))) {
// printf("%x %x",tcph->dest,);
return -1;
}
// 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;
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);
tcp_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_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<csum_len;i++)
{
printf("<%d>",int(ip_payload[i]));
}
printf("\n");*/
if (tcp_chk != 0) {
mylog(log_debug, "tcp_chk:%x, tcp checksum failed, ignored\n", tcp_chk);
// return -1;
}
char *tcp_begin = ip_payload; // ip packet's data part
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)
{
if(tcp_option[6]==0x08 &&tcp_option[7]==0x0a)
{
recv_info.has_ts=1;
//recv_info.ts=ntohl(*(u32_t*)(&tcp_option[8]));
memcpy(&recv_info.ts,&tcp_option[8],sizeof(recv_info.ts));
recv_info.ts=ntohl(recv_info.ts);
//recv_info.ts_ack=ntohl(*(u32_t*)(&tcp_option[12]));
memcpy(&recv_info.ts_ack,&tcp_option[12],sizeof(recv_info.ts_ack));
recv_info.ts_ack=ntohl(recv_info.ts_ack);
//g_packet_info_send.ts_ack= ntohl(*(uint32_t*)(&tcp_option[8]));
}
else
{
// mylog(log_info,"\n");
}
}
else if(tcph->doff==8)
{
if(tcp_option[2]==0x08 &&tcp_option[3]==0x0a)
{
recv_info.has_ts=1;
//recv_info.ts=ntohl(*(u32_t*)(&tcp_option[4]));
memcpy(&recv_info.ts,&tcp_option[4],sizeof(recv_info.ts));
recv_info.ts=ntohl(recv_info.ts);
//recv_info.ts_ack=ntohl(*(u32_t*)(&tcp_option[8]));
memcpy(&recv_info.ts_ack,&tcp_option[8],sizeof(recv_info.ts_ack));
recv_info.ts_ack=ntohl(recv_info.ts_ack);
//g_packet_info_send.ts_ack= ntohl(*(uint32_t*)(&tcp_option[0]));
}
else
{
//mylog(log_info,"!!!\n");
}
}
else
{
//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;
recv_info.rst = tcph->rst;
recv_info.src_port = ntohs(tcph->source);
recv_info.dst_port = ntohs(tcph->dest);
recv_info.seq = ntohl(tcph->seq);
// recv_info.last_last_ack_seq=recv_info.last_ack_seq;
// recv_info.last_ack_seq=recv_info.ack_seq;
u32_t last_ack_seq = recv_info.ack_seq;
recv_info.ack_seq = ntohl(tcph->ack_seq);
if (recv_info.ack_seq == last_ack_seq) {
recv_info.ack_seq_counter++;
} else {
recv_info.ack_seq_counter = 0;
}
recv_info.psh = tcph->psh;
if (tcph->rst == 1) {
raw_info.rst_received++;
if (max_rst_to_show > 0) {
if (raw_info.rst_received < max_rst_to_show) {
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", 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", 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", 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", 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", recv_info.new_src_ip.get_str1(), recv_info.src_port, (int)raw_info.rst_received, (int)max_rst_allowed);
raw_info.disabled = 1;
}
}
/* if(recv_info.has_ts)
{
send_info.ts_ack=recv_info.ts; //////////////////////////////////////////////modify
}*/
payloadlen = ip_payloadlen - tcphdrlen;
payload = tcp_begin + tcphdrlen;
/*if (recv_info.syn == 0 && recv_info.ack == 1&& payloadlen != 0) //only modify send_info when the packet is not part of handshake
{
send_info.ack_seq=recv_info.seq;
}*/
raw_info.recv_info.data_len = payloadlen;
return 0;
}
/*
int recv_raw_tcp_deprecated(packet_info_t &info,char * &payload,int &payloadlen)
{
static char buf[buf_len];
char raw_recv_buf[buf_len];
char raw_recv_buf2[buf_len];
char raw_recv_buf3[buf_len];
iphdr * iph;
tcphdr * tcph;
int size;
struct sockaddr saddr;
socklen_t saddr_size;
saddr_size = sizeof(saddr);
mylog(log_trace,"raw!\n");
size = recvfrom(raw_recv_fd, buf, max_data_len, 0 ,&saddr , &saddr_size);
if(buf[12]!=8||buf[13]!=0)
{
mylog(log_debug,"not an ipv4 packet!\n");
return -1;
}
char *ip_begin=buf+14;
iph = (struct iphdr *) (ip_begin);
if (!(iph->ihl > 0 && iph->ihl <=60)) {
mylog(log_debug,"iph ihl error");
return -1;
}
if (iph->protocol != IPPROTO_TCP) {
mylog(log_debug,"iph protocal != tcp\n");
return -1;
}
int ip_len=ntohs(iph->tot_len);
unsigned short iphdrlen =iph->ihl*4;
tcph=(struct tcphdr*)(ip_begin+ iphdrlen);
unsigned short tcphdrlen = tcph->doff*4;
if (!(tcph->doff > 0 && tcph->doff <=60)) {
mylog(log_debug,"tcph error");
return 0;
}
if(tcph->dest!=ntohs(uint16_t(filter_port)))
{
//printf("%x %x",tcph->dest,);
return -1;
}
/////ip
uint32_t ip_chk=csum ((unsigned short *) ip_begin, iphdrlen);
int psize = sizeof(struct pseudo_header) + ip_len-iphdrlen;
/////ip end
///tcp
struct pseudo_header psh;
psh.source_address = iph->saddr;
psh.dest_address = iph->daddr;
psh.placeholder = 0;
psh.protocol = IPPROTO_TCP;
psh.tcp_length = htons(ip_len-iphdrlen);
memcpy(raw_recv_buf2 , (char*) &psh , sizeof (struct pseudo_header));
memcpy(raw_recv_buf2 + sizeof(struct pseudo_header) , ip_begin+ iphdrlen , ip_len-iphdrlen);
uint16_t tcp_chk = csum( (unsigned short*) raw_recv_buf2, psize);
if(ip_chk!=0)
{
mylog(log_debug,"ip header error %d\n",ip_chk);
return -1;
}
if(tcp_chk!=0)
{
mylog(log_debug,"tcp_chk:%x\n",tcp_chk);
mylog(log_debug,"tcp header error\n");
return -1;
}
char *tcp_begin=raw_recv_buf2+sizeof(struct pseudo_header); //ip packet's data part
char *tcp_option=raw_recv_buf2+sizeof(struct pseudo_header)+sizeof(tcphdr);
info.has_ts=0;
if(tcph->doff==10)
{
if(tcp_option[6]==0x08 &&tcp_option[7]==0x0a)
{
info.has_ts=1;
info.ts=ntohl(*(uint32_t*)(&tcp_option[8]));
info.ts_ack=ntohl(*(uint32_t*)(&tcp_option[12]));
//g_packet_info_send.ts_ack= ntohl(*(uint32_t*)(&tcp_option[8]));
}
}
else if(tcph->doff==8)
{
if(tcp_option[3]==0x08 &&tcp_option[4]==0x0a)
{
info.has_ts=1;
info.ts=ntohl(*(uint32_t*)(&tcp_option[0]));
info.ts_ack=ntohl(*(uint32_t*)(&tcp_option[4]));
//g_packet_info_send.ts_ack= ntohl(*(uint32_t*)(&tcp_option[0]));
}
}
if(tcph->rst==1)
{
mylog(log_warn,"%%%%%%%%%%rst==1%%%%%%%%%%%%%\n");
}
info.ack=tcph->ack;
info.syn=tcph->syn;
info.rst=tcph->rst;
info.src_port=ntohs(tcph->source);
info.src_ip=iph->saddr;
info.seq=ntohl(tcph->seq);
info.ack_seq=ntohl(tcph->ack_seq);
info.psh=tcph->psh;
if(info.has_ts)
{
g_packet_info_send.ts_ack=info.ts;
}
////tcp end
payloadlen = ip_len-tcphdrlen-iphdrlen;
payload=ip_begin+tcphdrlen+iphdrlen;
if(payloadlen>0&&payload[0]=='h')
{
mylog(log_debug,"recvd <%u %u %d>\n",ntohl(tcph->seq ),ntohl(tcph->ack_seq), payloadlen);
}
if(payloadlen>0&&tcph->syn==0&&tcph->ack==1)
{
//if(seq_increse)
g_packet_info_send.ack_seq=ntohl(tcph->seq)+(uint32_t)payloadlen;
}
//printf("%d\n",ip_len);
mylog(log_trace,"<%u,%u,%u,%u,%d>\n",(unsigned int)iphdrlen,(unsigned int)tcphdrlen,(unsigned int)tcph->syn,(unsigned int)tcph->ack,payloadlen);
return 0;
}*/
int send_raw0(raw_info_t &raw_info, const char *payload, int payloadlen) {
if (random_drop != 0) {
if (get_true_random_number() % 10000 < (u32_t)random_drop) {
return 0;
}
}
packet_info_t &send_info = raw_info.send_info;
packet_info_t &recv_info = raw_info.recv_info;
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);
case mode_udp:
return send_raw_udp(raw_info, payload, payloadlen);
case mode_icmp:
return send_raw_icmp(raw_info, payload, payloadlen);
default:
return -1;
}
}
int recv_raw0(raw_info_t &raw_info, char *&payload, int &payloadlen) {
packet_info_t &send_info = raw_info.send_info;
packet_info_t &recv_info = raw_info.recv_info;
switch (raw_mode) {
case mode_faketcp:
return recv_raw_tcp(raw_info, payload, payloadlen);
case mode_udp:
return recv_raw_udp(raw_info, payload, payloadlen);
case mode_icmp:
return recv_raw_icmp(raw_info, payload, payloadlen);
default:
return -1;
}
}
int after_send_raw0(raw_info_t &raw_info) {
packet_info_t &send_info = raw_info.send_info;
packet_info_t &recv_info = raw_info.recv_info;
if (raw_mode == mode_faketcp) {
if (send_info.syn == 0 && send_info.ack == 1 && raw_info.send_info.data_len != 0) // only modify send_info when the packet is not part of handshake
{
if (seq_mode == 0) {
} else if (seq_mode == 1) {
send_info.seq += raw_info.send_info.data_len; //////////////////modify
} else if (seq_mode == 2) {
if (get_true_random_number() % 5 == 3)
send_info.seq += raw_info.send_info.data_len; //////////////////modify
} else if (seq_mode == 3 || seq_mode == 4) {
send_info.seq += raw_info.send_info.data_len;
u32_t window_size;
if (seq_mode == 3) {
window_size = (u32_t)((u32_t)receive_window_lower_bound << (u32_t)wscale);
} else // seq_mode==4
{
window_size = (u32_t)((u32_t)receive_window_lower_bound);
}
if (larger_than_u32(send_info.seq + max_data_len, recv_info.ack_seq + window_size)) {
send_info.seq = raw_info.recv_info.ack_seq;
}
if (recv_info.ack_seq_counter >= 3) // simulate tcp fast re-transmit
{
recv_info.ack_seq_counter = 0;
send_info.seq = raw_info.recv_info.ack_seq;
}
if (larger_than_u32(raw_info.recv_info.ack_seq, send_info.seq)) // for further use,currently no effect.
{
send_info.seq = raw_info.recv_info.ack_seq;
}
}
}
}
if (raw_mode == mode_icmp) {
if (program_mode == client_mode) {
send_info.my_icmp_seq++;
}
}
return 0;
}
int after_recv_raw0(raw_info_t &raw_info) {
packet_info_t &send_info = raw_info.send_info;
packet_info_t &recv_info = raw_info.recv_info;
if (raw_mode == mode_faketcp) {
if (recv_info.has_ts)
send_info.ts_ack = recv_info.ts;
if (recv_info.syn == 0 && recv_info.ack == 1 && raw_info.recv_info.data_len != 0) // only modify send_info when the packet is not part of handshake
{
if (seq_mode == 0 || seq_mode == 1 || seq_mode == 2) {
if (larger_than_u32(recv_info.seq + raw_info.recv_info.data_len, send_info.ack_seq))
send_info.ack_seq = recv_info.seq + raw_info.recv_info.data_len; // TODO only update if its larger
} else if (seq_mode == 3 || seq_mode == 4) {
if (recv_info.seq == send_info.ack_seq) {
send_info.ack_seq = recv_info.seq + raw_info.recv_info.data_len; // currently we dont remembr tcp segments,this is the simplest way
// TODO implement tcp segment remembering and SACK.
}
}
}
}
if (raw_mode == mode_icmp) {
if (program_mode == server_mode) {
if (larger_than_u16(recv_info.my_icmp_seq, send_info.my_icmp_seq))
send_info.my_icmp_seq = recv_info.my_icmp_seq; // TODO only update if its larger
}
}
return 0;
}
/*
int send_raw(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;
int ret=send_raw0(raw_info,payload,payloadlen);
if(ret<0) return ret;
else
{
after_send_raw0(raw_info);
return ret;
}
}
int recv_raw(raw_info_t &raw_info,char *& payload,int & payloadlen)
{
packet_info_t &send_info=raw_info.send_info;
packet_info_t &recv_info=raw_info.recv_info;
int ret=recv_raw0(raw_info,payload,payloadlen);
if(ret<0) return ret;
else
{
after_recv_raw0(raw_info);
return ret;
}
}*/
/*
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};
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_ip_uint32;
int 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;
}
//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\n");
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){close(new_udp_fd); return -1;}
ip=my_addr.sin_addr.s_addr;
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,0);
}
else if(raw_mode==mode_udp||raw_mode==mode_icmp)
{
fd=socket(AF_INET,SOCK_DGRAM,0);
}
if(old_bind_fd!=-1)
{
close(old_bind_fd);
}
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*)&temp_bind_addr, sizeof(temp_bind_addr)) !=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 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 && !use_tcp_dummy_socket) {
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);
for(int i=0;i<1000;i++)//try 1000 times at max,this should be enough
{
if (try_to_list_and_bind(fd,local_ip_uint32,raw_send_port)==0)
{
return raw_send_port;
}
}
mylog(log_fatal,"bind port fail\n");
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;
for (int i = 0; i < 1000; i++) // try 1000 times at max,this should be enough
{
int raw_send_port = 10000 + get_true_random_number() % (65535 - 10000);
tmp.set_port(raw_send_port);
if (try_to_list_and_bind2(fd, tmp) == 0) {
return raw_send_port;
}
}
mylog(log_fatal, "bind port fail\n");
myexit(-1);
return -1; ////for compiler check
}
Reference in New Issue View Git Blame Copy Permalink