/*      $NetBSD: shmif_pcapin.c,v 1.1 2024/09/02 05:14:45 ozaki-r Exp $ */

/*-
 * Copyright (c) 2017-2018 Internet Initiative Japan Inc.
 * Copyright (c) 2010 Antti Kantee.
 * All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <rump/rumpuser_port.h>

#ifndef lint
__RCSID("$NetBSD: shmif_pcapin.c,v 1.1 2024/09/02 05:14:45 ozaki-r Exp $");
#endif /* !lint */

#include <stddef.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/atomic.h>
#include <sys/bswap.h>

#include <assert.h>
#include <err.h>
#include <fcntl.h>
#include <inttypes.h>
#include <pcap.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "shmifvar.h"

__dead static void
usage(void)
{

#ifndef HAVE_GETPROGNAME
#define getprogname() "shmif_pcapin"
#endif

        fprintf(stderr, "usage: %s pcap-file-path bus-path\n", getprogname());
        exit(1);
}

/*
 * The BUFSIZE come from shmif_dumpbus.c because there're not any experiences to
 * make a decision about best size.
 */
#define BUFSIZE 64*1024

/*
 * dowakeup, shmif_lockbus and shmif_unlockbus copy from
 * sys/rump/net/lib/libshimif/if_shmem.c. So if you have to understood locking
 * mechanism, you also see that.
 */
static int
dowakeup(int memfd)
{
        struct iovec iov;
        uint32_t ver = SHMIF_VERSION;

        iov.iov_base = &ver;
        iov.iov_len = sizeof(ver);

        if (lseek(memfd, IFMEM_WAKEUP, SEEK_SET) == IFMEM_WAKEUP)
                return writev(memfd, &iov, 1);
        else
                return -1;
}

/*
 * This locking needs work and will misbehave severely if:
 * 1) the backing memory has to be paged in
 * 2) some lockholder exits while holding the lock
 */
static void
shmif_lockbus(struct shmif_mem *busmem)
{
        int i = 0;

        while (__predict_false(atomic_cas_32(&busmem->shm_lock,
            LOCK_UNLOCKED, LOCK_LOCKED) == LOCK_LOCKED)) {
                if (__predict_false(++i > LOCK_COOLDOWN)) {
                        usleep(1000);
                        i = 0;
                }
                continue;
        }
        membar_enter();
}

static void
shmif_unlockbus(struct shmif_mem *busmem)
{
        unsigned int old __diagused;

        membar_exit();
        old = atomic_swap_32(&busmem->shm_lock, LOCK_UNLOCKED);
        assert(old == LOCK_LOCKED);
}


int
main(int argc, char *argv[])
{
        struct stat sb;
        void *busmem;
        struct shmif_mem *bmem;
        int fd;
        const u_char *pkt;
        char *buf;
        char pcap_errbuf[PCAP_ERRBUF_SIZE];
        pcap_t *pcap;
        struct pcap_pkthdr pcaphdr;

        argc -= optind;
        argv += optind;

        if (argc != 2)
                usage();

        buf = malloc(BUFSIZE);
        if (buf == NULL)
                err(EXIT_FAILURE, "malloc");

        fd = open(argv[1], O_RDWR);
        if (fd == -1)
                err(EXIT_FAILURE, "open bus");

        if (fstat(fd, &sb) == -1)
                err(EXIT_FAILURE, "stat");

        busmem = mmap(NULL, sb.st_size, PROT_WRITE|PROT_READ,
            MAP_FILE|MAP_SHARED, fd, 0);
        if (busmem == MAP_FAILED)
                err(EXIT_FAILURE, "mmap");
        bmem = busmem;

        if (bmem->shm_magic != SHMIF_MAGIC)
                errx(EXIT_FAILURE, "%s not a shmif bus", argv[1]);

        /*
         * if bmem->shm_version is 0, it indicates to not write any packets
         * by anyone.
         */
        if (bmem->shm_version != SHMIF_VERSION && bmem->shm_version != 0)
                errx(EXIT_FAILURE, "bus version %d, program %d",
                    bmem->shm_version, SHMIF_VERSION);

        fprintf(stdout, "bus version %d, lock: %d, generation: %" PRIu64
            ", firstoff: 0x%04x, lastoff: 0x%04x\n", bmem->shm_version,
            bmem->shm_lock, bmem->shm_gen, bmem->shm_first, bmem->shm_last);

        pcap = pcap_open_offline(argv[0], pcap_errbuf);
        if (pcap == NULL)
                err(EXIT_FAILURE, "cannot open pcap file: %s", pcap_errbuf);

        while ((pkt = pcap_next(pcap, &pcaphdr))) {
                struct shmif_pkthdr sp;
                uint32_t dataoff;
                struct timeval tv;
                bool wrap;

                gettimeofday(&tv, NULL);
                sp.sp_len = pcaphdr.len;
                sp.sp_sec = tv.tv_sec;
                sp.sp_usec = tv.tv_usec;
                memcpy(buf, pkt, pcaphdr.len);

                shmif_lockbus(bmem);

                bmem->shm_last = shmif_nextpktoff(bmem, bmem->shm_last);
                wrap = false;

                dataoff = shmif_buswrite(bmem, bmem->shm_last, &sp,
                    sizeof(sp), &wrap);
                dataoff = shmif_buswrite(bmem, dataoff, buf, pcaphdr.len, &wrap);

                if (wrap)
                        bmem->shm_gen++;

                shmif_unlockbus(bmem);
        }

        if (dowakeup(fd) == -1)
                errx(EXIT_FAILURE, "writev for wakeup");

        return 0;
}