/*
 * NPF nbuf interface tests.
 *
 * Public Domain.
 */

#ifdef _KERNEL
#include <sys/types.h>
#include <sys/kmem.h>
#endif

#include "npf_impl.h"
#include "npf_test.h"

#define MBUF_CHAIN_LEN          128

CTASSERT((MBUF_CHAIN_LEN % sizeof(uint32_t)) == 0);

static void
mbuf_consistency_check(nbuf_t *nbuf)
{
        struct mbuf *m = nbuf_head_mbuf(nbuf);

        while (m) {
                assert(m->m_type != MT_FREE);
                m = m->m_next;
        }
}

static char *
parse_nbuf_chain(struct mbuf *m)
{
        ifnet_t *dummy_ifp = npf_test_addif(IFNAME_TEST, false, false);
        char *s = kmem_zalloc(MBUF_CHAIN_LEN + 1, KM_SLEEP);
        nbuf_t nbuf;
        void *nptr;
        int n;

        nbuf_init(npf_getkernctx(), &nbuf, m, dummy_ifp);

        nptr = nbuf_advance(&nbuf, (random() % 16) + 1, (random() % 16) + 1);
        mbuf_consistency_check(&nbuf);
        assert(nptr != NULL);
        nbuf_reset(&nbuf);

        for (n = 0; ; ) {
                char d[4 + 1];

                nptr = nbuf_ensure_contig(&nbuf, sizeof(uint32_t));
                if (nptr == NULL) {
                        break;
                }
                mbuf_consistency_check(&nbuf);
                memcpy(&d, nptr, sizeof(uint32_t));

                d[sizeof(d) - 1] = '\0';
                strcat(s, d);

                if (n + sizeof(uint32_t) == MBUF_CHAIN_LEN) {
                        assert(nbuf_advance(&nbuf, sizeof(uint32_t) - 1, 0));
                        assert(!nbuf_advance(&nbuf, 1, 0));
                        break;
                }
                if (!nbuf_advance(&nbuf, sizeof(uint32_t), 0)) {
                        break;
                }
                n += sizeof(uint32_t);
        }
        mbuf_consistency_check(&nbuf);
        m_freem(nbuf_head_mbuf(&nbuf));
        return s;
}

static char *
mbuf_getstring(struct mbuf *m)
{
        char *s = kmem_zalloc(MBUF_CHAIN_LEN + 1, KM_SLEEP);
        unsigned tlen = 0;

        while (m) {
                int len = m->m_len;
                char *d = m->m_data;
                while (len--) {
                        s[tlen++] = *d++;
                }
                m = m->m_next;
        }
        return s;
}

static struct mbuf *
mbuf_alloc_with_off(size_t off, int len)
{
        struct mbuf *m;

        KASSERT(off + len < MLEN);
        m = m_get(M_WAITOK, MT_DATA);
        m->m_data = (char *)m->m_data + off;
        m->m_len = len;
        return m;
}

/*
 * Create an mbuf chain, each of 1 byte size.
 */
static struct mbuf *
mbuf_bytesize(size_t clen)
{
        struct mbuf *m0 = NULL, *m = NULL;
        unsigned i, n;

        /* Chain of clen (e.g. 128) mbufs, each storing 1 byte of data. */
        for (i = 0, n = 0; i < clen; i++) {
                /* Range of offset: 0 .. 15. */
                m0 = mbuf_alloc_with_off(n & 0xf, 1);

                /* Fill data with letters from 'a' to 'z'. */
                memset(m0->m_data, 'a' + n, 1);
                n = ('a' + n) < 'z' ? n + 1 : 0;

                /* Next mbuf.. */
                m0->m_next = m;
                m = m0;
        }

        m0 = m_gethdr(M_WAITOK, MT_HEADER);
        m0->m_pkthdr.len = clen;
        m0->m_len = 0;
        m0->m_next = m;
        return m0;
}

/*
 * Generate random number of mbufs, with random offsets and lengths.
 */
static struct mbuf *
mbuf_random_len(size_t chain_len)
{
        struct mbuf *m0 = NULL, *m = NULL;
        unsigned tlen = 0, n = 0;

        while (tlen < chain_len) {
                unsigned off, len;
                char *d;

                /* Random offset and length range: 1 .. 16. */
                off = (random() % 16) + 1;
                len = (random() % 16) + 1;

                /* Do not exceed 128 bytes of total length. */
                if (tlen + len > chain_len) {
                        len = chain_len - tlen;
                }
                tlen += len;

                /* Consistently fill data with letters from 'a' to 'z'. */
                m0 = mbuf_alloc_with_off(off, len);
                d = m0->m_data;
                while (len--) {
                        *d++ = ('a' + n);
                        n = ('a' + n) < 'z' ? n + 1 : 0;
                }

                /* Next mbuf.. */
                m0->m_next = m;
                m = m0;
        }
        KASSERT(tlen == chain_len);

        m0 = m_gethdr(M_WAITOK, MT_HEADER);
        m0->m_pkthdr.len = tlen;
        m0->m_next = m;
        m0->m_len = 0;
        return m0;
}

static bool
validate_mbuf_data(char *bufa, char *bufb)
{
        bool ok = strcmp(bufa, bufb) == 0;

        if (!ok) {
                printf("Buffer A: %s\nBuffer B: %s\n", bufa, bufb);
        }
        kmem_free(bufa, MBUF_CHAIN_LEN + 1);
        kmem_free(bufb, MBUF_CHAIN_LEN + 1);
        return ok;
}

bool
npf_nbuf_test(bool verbose)
{
        struct mbuf *m;
        char *bufa, *bufb;
        unsigned n = 10000;
        bool ok;

        while (n--) {
                m = mbuf_random_len(MBUF_CHAIN_LEN);
                bufa = mbuf_getstring(m);
                bufb = parse_nbuf_chain(m);
                ok = validate_mbuf_data(bufa, bufb);
                CHECK_TRUE(ok);
        }

        m = mbuf_bytesize(MBUF_CHAIN_LEN);
        bufa = mbuf_getstring(m);
        bufb = parse_nbuf_chain(m);
        ok = validate_mbuf_data(bufa, bufb);
        CHECK_TRUE(ok);

        (void)verbose;
        return true;
}