/*

# SPDX-License-Identifier: LGPL-2.1+

# ~~~

#   Description: libpcap tests

#

#   Author: Susant Sahani <susant@redhat.com>

#   Copyright (c) 2018 Red Hat, Inc.

# ~~~

*/

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <netinet/in.h>

#include <setjmp.h>

#include <inttypes.h>

#include <cmocka.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <errno.h>

#include <unistd.h>

#include <libnet.h>

#include <netinet/if_ether.h>

#include <sys/socket.h>

#include <netinet/ip.h>

#include <netinet/in.h>

#include <netinet/tcp.h>

#include <arpa/inet.h>

#include <netinet/if_ether.h>

#include <pcap.h>

#include <pthread.h>

#include <sys/time.h>

#define PCAP_FILE "/var/run/libpcap-test.pcap"

pcap_t *handle;

struct UDP_hdr {

        u_short uh_sport;               /* source port */

        u_short uh_dport;               /* destination port */

        u_short uh_ulen;                /* datagram length */

        u_short uh_sum;                 /* datagram checksum */

};

static void assert_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {

        unsigned int ipl;

        uint32_t src, dst;

        struct ip *ip;

        struct ether_header *eth_header;

        eth_header = (struct ether_header *) packet;

        if (ntohs(eth_header->ether_type) != ETHERTYPE_IP)

                return;

        packet += sizeof(struct ether_header);

        ip = (struct ip *) packet;

        ipl = ip->ip_hl * 4;

        src = inet_addr("192.168.50.6");

        dst = inet_addr("192.168.50.5");

        assert_memory_equal(&dst, &ip->ip_dst, sizeof(uint32_t));

        assert_memory_equal(&src, &ip->ip_src, sizeof(uint32_t));

        if (ip->ip_p == IPPROTO_UDP) {

                struct UDP_hdr *udp;

                packet += ipl;

                udp = (struct UDP_hdr *) packet;

                printf("UDP src_port=%d dst_port=%d\n", ntohs(udp->uh_sport), ntohs(udp->uh_dport));

                assert_int_equal(2425, ntohs(udp->uh_sport));

                assert_int_equal(2426, ntohs(udp->uh_dport));

        } else if (ip->ip_p == IPPROTO_TCP) {

                struct tcphdr *tcp;

                packet += ipl;

                tcp = (struct tcphdr *) packet;

                printf("TCP src_port=%d dst_port=%d\n", ntohs(tcp->th_sport), ntohs(tcp->th_dport));

                assert_int_equal(2425, ntohs(tcp->th_sport));

                assert_int_equal(2426, ntohs(tcp->th_dport));

        }

}

void *capture_packet_live(void *ptr) {

        char dev[] = "veth-test";

        char error_buffer[PCAP_ERRBUF_SIZE];

        struct bpf_program filter;

        bpf_u_int32 subnet_mask, ip;

        int total_packet_count;

        int r;

        r = pcap_lookupnet(dev, &ip, &subnet_mask, error_buffer);

        assert_true(r >=0);

        handle = pcap_open_live(dev, BUFSIZ, 1, 1000, error_buffer);

        assert_non_null(handle);

        r = pcap_compile(handle, &filter, ptr, 0, ip);

        assert_true(r >= 0);

        r = pcap_setfilter(handle, &filter);

        assert_true(r >= 0);

        pcap_loop(handle, total_packet_count, assert_packet, NULL);

        return 0;

}

void terminate_thread(int signum) {

        pcap_breakloop(handle);

        pcap_close(handle);

        handle = NULL;

        pthread_exit(NULL);

}

static void test_udp_packet_ipv4(void **state) {

        char dst[6] = {0xff,0xff,0xff,0xff,0xff,0xff};

        char src[6] = {0x12,0x34,0x56,0x78,0x9a,0xab};

        char err_buf[LIBNET_ERRBUF_SIZE] = {};

        char buf[1024] = {};

        libnet_t* l;

        int r, i;

        uint32_t len;

        pthread_t pcap_thread;

        struct itimerval tval;

        timerclear(& tval.it_interval); /* zero interval means no reset of timer */

        timerclear(& tval.it_value);

        tval.it_value.tv_sec = 10;      /* 10 second timeout */

        (void) signal(SIGALRM, terminate_thread);

        (void) setitimer(ITIMER_REAL, & tval, NULL);

        r = pthread_create(&pcap_thread, NULL, capture_packet_live, "udp port 2425");

        assert_true(r >=0);

        l = libnet_init(LIBNET_LINK_ADV, "veth-peer", err_buf);

        assert_non_null(l);

        len = sprintf(buf, "1:1:1111111111111:32:hello world%d", 1);

        for (i = 0; i < 5; i++) {

                r = libnet_build_udp(2425, 2426, len + 8, 0, buf, len, l, 0);

                assert_true(r >= 0);

                r = libnet_build_ipv4(20 + 8 + len, 0, 0, 0, 128, 17, 0, inet_addr("192.168.50.6"), inet_addr("192.168.50.5"), NULL, 0, l, 0);

                assert_true(r >= 0);

                r = libnet_build_ethernet(dst, src, 0x0800, NULL, 0, l, 0);

                assert_true(r >= 0);

                r = libnet_write(l);

                assert_true(r >= 0);

                sleep(1);

        }

        libnet_destroy(l);

}

static void test_tcp_packet_ipv4(void **state) {

        char dst[6] = {0xff,0xff,0xff,0xff,0xff,0xff};

        char src[6] = {0x12,0x34,0x56,0x78,0x9a,0xab};

        char errbuf[LIBNET_ERRBUF_SIZE];

        uint8_t *payload, payload_s;

        libnet_ptag_t tcp, ip, eth;

        int c, i, j, seqn, ack;

        char buf[1024] = {};

        pthread_t pcap_thread;

        struct itimerval tval;

        uint32_t len;

        libnet_t *l;

        int r;

        timerclear(& tval.it_interval);

        timerclear(& tval.it_value);

        tval.it_value.tv_sec = 10;

        (void) signal(SIGALRM, terminate_thread);

        (void) setitimer(ITIMER_REAL, & tval, NULL);

        r = pthread_create(&pcap_thread, NULL, capture_packet_live, "tcp port 2425");

        assert_true(r >=0);

        payload_s = 10;

        payload = malloc(payload_s*sizeof(uint8_t));

        assert_non_null(payload);

        memset(payload,0,payload_s);

        l = libnet_init(LIBNET_LINK, "veth-peer", errbuf);

        assert_non_null(l);

        tcp = ip = eth = LIBNET_PTAG_INITIALIZER;

        for (i=0; i<5; i++){

                seqn=i * (LIBNET_TCP_H+payload_s + 1);

                r = libnet_build_tcp(2425, 2426, seqn, seqn + LIBNET_TCP_H + payload_s + 1,

                                     TH_SYN, 32767, 0, 10, LIBNET_TCP_H + payload_s,

                                     payload, payload_s, l, tcp);

                assert_true(r >=0);

                r = libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_TCP_H + payload_s,0,242,0,64,IPPROTO_TCP,0,

                                      inet_addr("192.168.50.6"), inet_addr("192.168.50.5"),

                                      NULL,0,l,ip);

                assert_true(r >=0);

                r = libnet_build_ethernet(dst, src, ETHERTYPE_IP, NULL, 0, l, eth);

                assert_true(r >=0);

                r = libnet_write(l);

                assert_true(r >=0);

                sleep(1);

        }

}

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

        const struct CMUnitTest libpcap_tests[] = {

                                                   cmocka_unit_test(test_udp_packet_ipv4),

                                                   cmocka_unit_test(test_tcp_packet_ipv4),

        };

        return cmocka_run_group_tests(libpcap_tests, NULL, NULL);

}