#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <net/if.h>
#include <sys/ioctl.h>
#include <linux/if_tun.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>

#define PCKT_LEN 1024
#define BACKLOG 3
#define TUN_ADDR "192.168.2.1"
#define SPOOF_NET "192.168.3.0"
#define SPOOF_PREFIX "192.168.3."

#define COUNT 8

const char* spoof_ip_list[COUNT] = {"192.168.3.1",
         "192.168.3.2",
         "192.168.3.3",
         "192.168.3.4",
         "192.168.3.5",
         "192.168.3.6",
         "192.168.3.7",
         "192.168.3.8"}; 

const uint16_t spoof_mss[COUNT] = {536, 1300, 1440, 1460, 536, 1300, 1440, 1460};

const uint32_t spoof_tsp[COUNT] = {1000, 2000, 3000, 4000, 5000,6000, 7000, 8000};

const uint8_t spoof_wscale[COUNT] = {1, 2, 3, 4, 1, 2, 3, 4};

#define TUN_PORT 50001

struct psdhdr{
 uint32_t saddr;
 uint32_t daddr;
 char zero;
 char protocol;
 uint16_t tcplen;
};

struct mss_opt{
 uint8_t kind; // = 2
 uint8_t length; // = 4
 uint16_t mss;  
}__attribute__((packed));

struct tstamp_opt{
 uint8_t kind; // = 8 
 uint8_t length; // = 10
 uint32_t tsval;  
 uint32_t tsecr;
 uint8_t nop[2];
}__attribute__((packed));

struct wscale_opt{
 uint8_t kind; // = 3 
 uint8_t length; // = 3
 uint8_t scale;  
 uint8_t nop;
}__attribute__((packed));

uint16_t calc_cksm(void *pkt, int len)
{
    uint16_t *buf = (uint16_t*)pkt;
    uint32_t cksm = 0;
    while(len > 1)
    {
        cksm += *buf++;
        cksm = (cksm >> 16) + (cksm & 0xffff);
        len -= 2;
    }
    if(len)
    {
        cksm += *((uint8_t*)buf);
        cksm = (cksm >> 16) + (cksm & 0xffff);
    }
    return (uint16_t)((~cksm) & 0xffff);
} 


unsigned short tcp_checksum (struct iphdr *ip, struct tcphdr* th, char* opt, int optlen)
{
	uint16_t sum = 0;
	char buf[PCKT_LEN];
	int chksumlen = 0;
	struct psdhdr psdhdr;

	memset(buf, 0, PCKT_LEN);

	psdhdr.saddr = ip->saddr;
	psdhdr.daddr = ip->daddr;
	psdhdr.zero = 0;
	psdhdr.protocol = ip->protocol;
	psdhdr.tcplen = htons(sizeof(struct tcphdr) + optlen);

	memcpy(&buf[0], &psdhdr, sizeof(struct psdhdr));

	chksumlen += sizeof(struct psdhdr);

	memcpy(&buf[chksumlen], th, sizeof(struct tcphdr));

	chksumlen += sizeof(struct tcphdr);

	if (optlen > 0)
	{
		memcpy(&buf[chksumlen], opt, optlen);
		chksumlen += optlen;
	}

	sum = calc_cksm(buf, chksumlen);

	return sum; 
}


int tun_create(int flags)
{
    int fd, err;
    struct ifreq ifr;

    if ((fd = open("/dev/net/tun", O_RDWR)) < 0){
        return fd;
    }

    memset(&ifr, 0, sizeof(ifr));
    ifr.ifr_flags = flags;

    if ((err = ioctl(fd, TUNSETIFF, (void*)&ifr)) < 0 )
    {
        close(fd);
        return err;
    }

    if (strcmp(ifr.ifr_name, "tun0")) {
        close(fd);
        return -1;
    }

    return fd;
} 

int tun_setup(char* tundev)
{
    struct ifreq ifr;
    int sockfd;
    int err;
    
    memset(&ifr, 0, sizeof(ifr));
    snprintf(ifr.ifr_name, (sizeof(ifr.ifr_name) - 1), "%s", tundev);
    
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        return err;
    }
        
    if((err = ioctl(sockfd, SIOCGIFFLAGS, (void *)&ifr)) < 0 ) 
    {
        return err;
    }

    ifr.ifr_flags |= IFF_UP;
    if((err = ioctl(sockfd, SIOCSIFFLAGS, (void *)&ifr)) < 0 ) 
    {
        return err;
    }

    close(sockfd);

    return 0;
} 

/* Configure a local IPv4 address and netmask for the device */
int tun_set_address(const char* dev,
                     const char* ip,
                      int prefix_len)
{
    char command[128];

    memset(command, 0, sizeof(command));
    
    sprintf(command, "ip addr add %s/%d dev %s > /dev/null 2>&1", ip, prefix_len, dev);

    int result = system(command);
    
    return result;
} 

int tun_set_route()
{
    char command[128];

    memset(command, 0, sizeof(command));

    sprintf(command,
           "ip route add %s/24 via %s > /dev/null 2>&1", // ip -4 route add 
            SPOOF_NET, TUN_ADDR);

    int result = system(command);
    
    return result;
} 

void* server_thread(void* args)
{
	int listenfd;
	struct sockaddr_in servaddr;

	listenfd = socket(PF_INET, SOCK_STREAM, 0);

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = inet_addr(TUN_ADDR);
	servaddr.sin_port = htons(TUN_PORT);

	bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

	listen(listenfd, BACKLOG);
	while(1)
	{
		sleep(1);
	}

 	return NULL;
}

int server_setup()
{
	pthread_t thread;
	if (pthread_create(&thread, NULL, server_thread, NULL) != 0) {
		perror("pthread error");
		return -1;
	}	
}


void syn_send(int tun_fd, int i)
{
	char buffer[PCKT_LEN];
	struct iphdr *ip = (struct iphdr *) buffer;
	struct tcphdr *tcp = (struct tcphdr *)(buffer + sizeof(struct iphdr));
	uint16_t tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
	uint16_t opt_len = 0;
	char* opt = (char*)(buffer + tot_len); // TCP option 
	memset(buffer, 0, PCKT_LEN);    

	if (spoof_mss[i] != 0)
	{
		struct mss_opt mss_opt;

		memset(&mss_opt, 1, sizeof(mss_opt));

		mss_opt.kind = 2;
		mss_opt.length = 4;
		mss_opt.mss = htons(spoof_mss[i]);

		memcpy(&opt[opt_len], &mss_opt, sizeof(mss_opt));  

		// if we have mss option
		tot_len += sizeof(mss_opt);
		opt_len += sizeof(mss_opt);
	}

	if (spoof_tsp[i] != 0)
	{
		struct tstamp_opt ts_opt;

		memset(&ts_opt, 1, sizeof(ts_opt));

		ts_opt.kind = 8;
		ts_opt.length = 10;
		ts_opt.tsval = htonl(spoof_tsp[i]);
		ts_opt.tsecr = 0;

		memcpy(&opt[opt_len], &ts_opt, sizeof(ts_opt));
		tot_len += sizeof(ts_opt);
		opt_len += sizeof(ts_opt);
	}

	if (spoof_wscale[i] != 0)
	{
		struct wscale_opt wscale_opt;

		memset(&wscale_opt, 1, sizeof(wscale_opt));

		wscale_opt.kind = 3;
		wscale_opt.length = 3;
		wscale_opt.scale = spoof_wscale[i];
		
		memcpy(&opt[opt_len], &wscale_opt, sizeof(wscale_opt));
		tot_len += sizeof(wscale_opt);
		opt_len += sizeof(wscale_opt);
	}

	ip->ihl = 5;
	ip->version = 4;
	ip->tos = 16;
	ip->tot_len = htons(tot_len);
	ip->id = htons(60000 + i);
	ip->frag_off = 0;
	ip->ttl = 64;
	ip->protocol = 6; // TCP 
	ip->saddr = inet_addr(spoof_ip_list[i]);
	ip->daddr = inet_addr(TUN_ADDR);
	ip->check = calc_cksm((unsigned short *)buffer,sizeof(struct iphdr));

	tcp->th_sport = htons(60000 + i);
	tcp->th_dport = htons(TUN_PORT);
	tcp->th_seq = htonl(1);
	tcp->th_ack = 0;
	tcp->th_off = (sizeof(struct tcphdr) + opt_len + sizeof(uint32_t) - 1) / sizeof(uint32_t);
	tcp->th_flags = TH_SYN;
	tcp->th_win = htons(4096);
	tcp->th_urp = 0;
	tcp->th_sum = 0;
	tcp->th_sum = tcp_checksum(ip, tcp, opt, opt_len);  

	if(write(tun_fd, buffer, tot_len) < 0)
	{
		perror("write() error");
		exit(-1);
	}
	else
	{
		printf("send packet %d\n", i);
	}

	return;
}

int main(int argc, char *argv[])
{
    int tun_fd, err;

    
    struct sockaddr_in sin, din;
    int one = 1;
    const int *val = &one;

    
    tun_fd = tun_create(IFF_TUN | IFF_NO_PI);
    if (tun_fd < 0)
    {
        perror("tun_create");
        return 0;
    }
    
    if (tun_setup("tun0") < 0)
    {
        perror("tun_setup");
        return 0;
    } 
    
    if (tun_setup("tun0") < 0)
    {
        perror("tun_setup");
        return 0;
    }

    if (tun_set_address("tun0", TUN_ADDR, 24) < 0)
    {
        perror("set address");
        return 0;
    }

    if (tun_set_route() < 0)
    {
        perror("set address");
        return 0;
    }

 	server_setup();

    sleep(5);

	for(int i = 0; i < COUNT; i++)
    {
        syn_send(tun_fd, i);
		
        usleep(10000);
    }

 	sleep(5);
	
    close(tun_fd);

    return 0; 
}