/*      $NetBSD: wg_user.c,v 1.5 2026/07/04 22:22:33 riastradh Exp $    */

/*
 * Copyright (C) Ryota Ozaki <ozaki.ryota@gmail.com>
 * All rights reserved.
 *
 * Based on wg_user.c by Antti Kantee.
 *
 * 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: wg_user.c,v 1.5 2026/07/04 22:22:33 riastradh Exp $");

#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/uio.h>
#include <sys/socket.h>
#include <sys/param.h>

#include <net/if.h>
#include <net/if_tun.h>

#include <netinet/in.h>

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <poll.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <rump/rumpuser_component.h>

#include "wg_user.h"

struct wg_user {
        struct wg_softc *wgu_sc;
        int wgu_devnum;
        char wgu_tun_name[IFNAMSIZ];

        int wgu_fd;
        int wgu_sock4;
        int wgu_sock6;
        int wgu_pipe[2];
        pthread_t wgu_rcvthr;

        int wgu_dying;

        struct {
                union {
                        struct sockaddr sa;
                        struct sockaddr_in sin;
                        struct sockaddr_in6 sin6;
                } addr;
                char payload[9018]; /* jumbo frame max len */
        } wgu_rcvbuf;
};

static int
open_tun(const char *tun_name)
{
        char tun_path[MAXPATHLEN];
        int n, fd, error;

        n = snprintf(tun_path, sizeof(tun_path), "/dev/%s", tun_name);
        if (n == MAXPATHLEN)
                return E2BIG;

        fd = open(tun_path, O_RDWR);
        if (fd == -1) {
                fprintf(stderr, "%s: can't open %s: %s\n",
                    __func__, tun_name, strerror(errno));
        }

        int i = 1;
        error = ioctl(fd, TUNSLMODE, &i);
        if (error == -1) {
                close(fd);
                fd = -1;
        }

        return fd;
}

static void
close_tun(struct wg_user *wgu)
{
        int s;
        struct ifreq ifr = {};

        close(wgu->wgu_fd);

        s = socket(AF_INET, SOCK_DGRAM, 0);
        if (s == -1)
                return; /* XXX */
        strcpy(ifr.ifr_name, wgu->wgu_tun_name);
        (void)ioctl(s, SIOCIFDESTROY, &ifr);
        close(s);
}

static void *
wg_user_rcvthread(void *aaargh)
{
        struct wg_user *wgu = aaargh;
        struct pollfd pfd[4];
        ssize_t nn = 0;
        int prv;

        rumpuser_component_kthread();

        pfd[0].fd = wgu->wgu_fd;
        pfd[0].events = POLLIN;
        pfd[1].fd = wgu->wgu_pipe[0];
        pfd[1].events = POLLIN;
        pfd[2].fd = wgu->wgu_sock4;
        pfd[2].events = POLLIN;
        pfd[3].fd = wgu->wgu_sock6;
        pfd[3].events = POLLIN;

        while (!wgu->wgu_dying) {
                prv = poll(pfd, 4, -1);
                if (prv == 0)
                        continue;
                if (prv == -1) {
                        /* XXX */
                        fprintf(stderr, "%s: poll error: %d\n",
                            wgu->wgu_tun_name, errno);
                        sleep(1);
                        continue;
                }

                /* rumpuser_wg_destroy notified us it's time */
                if (pfd[1].revents & POLLIN)
                        continue;

                /* Receive user packets from tun */
                if (pfd[0].revents & POLLIN) {
                        const struct sockaddr *dst;
                        const void *pkt;
                        size_t pktlen;

                        nn = read(wgu->wgu_fd, &wgu->wgu_rcvbuf,
                            sizeof(wgu->wgu_rcvbuf));
                        if (nn == -1 && errno == EAGAIN)
                                continue;

                        if (nn < 1) {
                                /* XXX */
                                fprintf(stderr, "%s: receive failed\n",
                                    wgu->wgu_tun_name);
                                sleep(1);
                                continue;
                        }

                        dst = &wgu->wgu_rcvbuf.addr.sa;
                        pkt = (const char *)dst + dst->sa_len;
                        pktlen = (size_t)nn - dst->sa_len;

                        rumpuser_component_schedule(NULL);
                        rumpkern_wg_recv_user(wgu->wgu_sc, dst, pkt, pktlen);
                        rumpuser_component_unschedule();
                }

                /* Receive wg UDP/IPv4 packets from a peer */
                if (pfd[2].revents & POLLIN) {
                        struct sockaddr *src = &wgu->wgu_rcvbuf.addr.sa;
                        socklen_t len = sizeof(wgu->wgu_rcvbuf.addr.sin);
                        const void *pkt;
                        size_t pktlen;

                        nn = recvfrom(wgu->wgu_sock4, wgu->wgu_rcvbuf.payload,
                            sizeof(wgu->wgu_rcvbuf.payload), 0, src, &len);
                        if (nn == -1)
                                continue;
                        if (len != sizeof(wgu->wgu_rcvbuf.addr.sin))
                                continue;
                        pkt = wgu->wgu_rcvbuf.payload;
                        pktlen = (size_t)nn;

                        rumpuser_component_schedule(NULL);
                        rumpkern_wg_recv_peer(wgu->wgu_sc, src, pkt, pktlen);
                        rumpuser_component_unschedule();
                }

                /* Receive wg UDP/IPv6 packets from a peer */
                if (pfd[3].revents & POLLIN) {
                        struct sockaddr *src = &wgu->wgu_rcvbuf.addr.sa;
                        socklen_t len = sizeof(wgu->wgu_rcvbuf.addr.sin6);
                        const void *pkt;
                        size_t pktlen;

                        nn = recvfrom(wgu->wgu_sock6, wgu->wgu_rcvbuf.payload,
                            sizeof(wgu->wgu_rcvbuf.payload), 0, src, &len);
                        if (nn == -1)
                                continue;
                        if (len != sizeof(wgu->wgu_rcvbuf.addr.sin6))
                                continue;
                        pkt = wgu->wgu_rcvbuf.payload;
                        pktlen = (size_t)nn;

                        rumpuser_component_schedule(NULL);
                        rumpkern_wg_recv_peer(wgu->wgu_sc, src, pkt, pktlen);
                        rumpuser_component_unschedule();
                }
        }

        assert(wgu->wgu_dying);

        rumpuser_component_kthread_release();
        return NULL;
}

int
rumpuser_wg_create(const char *tun_name, struct wg_softc *wg,
    struct wg_user **wgup)
{
        struct wg_user *wgu = NULL;
        void *cookie;
        int rv;

        cookie = rumpuser_component_unschedule();

        wgu = malloc(sizeof(*wgu));
        if (wgu == NULL) {
                rv = errno;
                goto oerr1;
        }

        if (strlcpy(wgu->wgu_tun_name, tun_name, sizeof(wgu->wgu_tun_name))
            >= sizeof(wgu->wgu_tun_name)) {
                rv = EINVAL;
                goto oerr2;
        }
        wgu->wgu_sc = wg;

        wgu->wgu_fd = open_tun(tun_name);
        if (wgu->wgu_fd == -1) {
                rv = errno;
                goto oerr2;
        }

        if (pipe(wgu->wgu_pipe) == -1) {
                rv = errno;
                goto oerr3;
        }

        wgu->wgu_sock4 = socket(AF_INET, SOCK_DGRAM, 0);
        wgu->wgu_sock6 = socket(AF_INET6, SOCK_DGRAM, 0);
        if (wgu->wgu_sock4 == -1 || wgu->wgu_sock6 == -1) {
                rv = errno;
                goto oerr4;
        }

        rv = pthread_create(&wgu->wgu_rcvthr, NULL, wg_user_rcvthread, wgu);
        if (rv != 0)
                goto oerr5;

        rumpuser_component_schedule(cookie);
        *wgup = wgu;
        return 0;

 oerr5:
        if (wgu->wgu_sock4 != -1)
                close(wgu->wgu_sock4);
        if (wgu->wgu_sock6 != -1)
                close(wgu->wgu_sock6);
 oerr4:
        close(wgu->wgu_pipe[0]);
        close(wgu->wgu_pipe[1]);
 oerr3:
        close_tun(wgu);
 oerr2:
        free(wgu);
 oerr1:
        rumpuser_component_schedule(cookie);
        return rumpuser_component_errtrans(rv);
}

/*
 * Send decrypted packets to users via a tun.
 */
void
rumpuser_wg_send_user(struct wg_user *wgu, const struct sockaddr *dst,
    const void *pkt, size_t pktlen)
{
        void *cookie = rumpuser_component_unschedule();
        struct iovec iov[2];
        int iovlen;
        ssize_t idontcare __attribute__((__unused__));

        memset(iov, 0, sizeof(iov));
        iov[0].iov_base = __UNCONST(dst);
        iov[0].iov_len = dst->sa_len;
        iov[1].iov_base = __UNCONST(pkt);
        iov[1].iov_len = pktlen;
        iovlen = 2;

        /*
         * no need to check for return value; packets may be dropped
         *
         * ... sorry, I spoke too soon.  We need to check it because
         * apparently gcc reinvented const poisoning and it's very
         * hard to say "thanks, I know I'm not using the result,
         * but please STFU and let's get on with something useful".
         * So let's trick gcc into letting us share the compiler
         * experience.
         */
        idontcare = writev(wgu->wgu_fd, iov, iovlen);

        rumpuser_component_schedule(cookie);
}

/*
 * Send wg messages to a peer.
 */
int
rumpuser_wg_send_peer(struct wg_user *wgu, const struct sockaddr *dst,
    const void *pkt, size_t pktlen)
{
        void *cookie = rumpuser_component_unschedule();
        int s, error = 0;
        ssize_t sent;

        switch (dst->sa_family) {
        case AF_INET:
                s = wgu->wgu_sock4;
                break;
        case AF_INET6:
                s = wgu->wgu_sock6;
                break;
        default:
                error = EAFNOSUPPORT;
                goto out;
        }

        sent = sendto(s, pkt, pktlen, 0, dst, dst->sa_len);
        if (sent == -1)
                error = errno;
        else if ((size_t)sent != pktlen)
                error = EIO;

out:    rumpuser_component_schedule(cookie);

        return error;
}

int
rumpuser_wg_ioctl(struct wg_user *wgu, u_long cmd, void *data, int af)
{
        void *cookie = rumpuser_component_unschedule();
        int s, error;

        s = socket(af, SOCK_DGRAM, 0);
        if (s == -1)
                return errno;
        error = ioctl(s, cmd, data);
        close(s);

        rumpuser_component_schedule(cookie);

        return error == -1 ? errno : 0;
}

int
rumpuser_wg_sock_bind(struct wg_user *wgu, const uint16_t port)
{
        union {
                struct sockaddr sa;
                struct sockaddr_in sin;
                struct sockaddr_in6 sin6;
        } u;

        memset(&u.sin, 0, sizeof(u.sin));
        u.sin.sin_family = AF_INET;
        u.sin.sin_len = sizeof(u.sin);
        u.sin.sin_addr.s_addr = INADDR_ANY;
        u.sin.sin_port = htons(port);

        if (bind(wgu->wgu_sock4, &u.sa, sizeof(u.sin)) == -1)
                return errno;

        memset(&u.sin6, 0, sizeof(u.sin6));
        u.sin6.sin6_family = AF_INET6;
        u.sin6.sin6_len = sizeof(u.sin6);
        u.sin6.sin6_addr = in6addr_any;
        u.sin6.sin6_port = htons(port);

        if (bind(wgu->wgu_sock6, &u.sa, sizeof(u.sin6)) == -1)
                return errno;

        return 0;
}

void
rumpuser_wg_destroy(struct wg_user *wgu)
{
        void *cookie = rumpuser_component_unschedule();

        wgu->wgu_dying = 1;
        if (write(wgu->wgu_pipe[1],
            &wgu->wgu_dying, sizeof(wgu->wgu_dying)) == -1) {
                /*
                 * this is here mostly to avoid a compiler warning
                 * about ignoring the return value of write()
                 */
                fprintf(stderr, "%s: failed to signal thread\n",
                    wgu->wgu_tun_name);
        }
        pthread_join(wgu->wgu_rcvthr, NULL);
        close_tun(wgu);
        close(wgu->wgu_pipe[0]);
        close(wgu->wgu_pipe[1]);
        free(wgu);

        rumpuser_component_schedule(cookie);
}

char *
rumpuser_wg_get_tunname(struct wg_user *wgu)
{

        return wgu->wgu_tun_name;
}