/*      $NetBSD: puffs_portal.c,v 1.11 2023/04/04 20:39:36 rillig Exp $ */

/*
 * Copyright (c) 2007  Antti Kantee.  All Rights Reserved.
 * Development was supported by the Finnish Cultural Foundation.
 *
 * 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>
#ifndef lint
__RCSID("$NetBSD: puffs_portal.c,v 1.11 2023/04/04 20:39:36 rillig Exp $");
#endif /* !lint */

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <mntopts.h>
#include <paths.h>
#include <poll.h>
#include <puffs.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <util.h>

#include "portald.h"

struct portal_node {
        char *path;
        int fd;
};

__dead static void usage(void);

PUFFSOP_PROTOS(portal)

#define PORTAL_ROOT NULL
#define METADATASIZE (sizeof(int) + sizeof(size_t))

qelem q;
int readcfg, sigchild;
const char *cfg;

static void
usage(void)
{

        errx(1, "usage: %s [-o options] /path/portal.conf mount_point",
            getprogname());
}

static void
sighup(int sig)
{

        readcfg = 1;
}

static void
sigcry(int sig)
{

        sigchild = 1;
}

static void
portal_loopfn(struct puffs_usermount *pu)
{

        if (readcfg)
                conf_read(&q, cfg);
        readcfg = 0;

        if (sigchild) {
                sigchild = 0;
                while (waitpid(-1, NULL, WNOHANG) != -1)
                        continue;
        }
}

#define PUFBUF_FD       1
#define PUFBUF_DATA     2

#define CMSIZE (sizeof(struct cmsghdr) + sizeof(int))

/* receive file descriptor produced by our child process */
static int
readfd(struct puffs_framebuf *pufbuf, int fd, int *done)
{
        struct cmsghdr *cmp;
        struct msghdr msg;
        struct iovec iov;
        ssize_t n;
        int error, rv;

        rv = 0;
        cmp = emalloc(CMSG_SPACE(sizeof(int)));

        iov.iov_base = &error;
        iov.iov_len = sizeof(int);
        msg.msg_iov = &iov;
        msg.msg_iovlen = 1;
        msg.msg_name = NULL;
        msg.msg_namelen = 0;
        msg.msg_control = cmp;
        msg.msg_controllen = CMSG_SPACE(sizeof(int));

        n = recvmsg(fd, &msg, 0);
        if (n == -1) {
                rv = errno;
                goto out;
        }
        if (n == 0) {
                rv = ECONNRESET;
                goto out;
        }

        /* the data for the server */
        puffs_framebuf_putdata_atoff(pufbuf, 0, &error, sizeof(int));
        if (error) {
                rv = error;
                goto out;
        }
        puffs_framebuf_putdata_atoff(pufbuf, sizeof(int),
            CMSG_DATA(cmp), sizeof(int));
        *done = 1;

 out:
        free(cmp);
        return rv;
}

/*
 * receive data from provider
 *
 * XXX: should read directly into the buffer and adjust offsets
 * instead of doing memcpy
 */
static int
readdata(struct puffs_framebuf *pufbuf, int fd, int *done)
{
        char buf[1024];
        size_t max;
        ssize_t n;
        size_t moved;

        /* don't override metadata */
        if (puffs_framebuf_telloff(pufbuf) == 0)
                puffs_framebuf_seekset(pufbuf, METADATASIZE);
        puffs_framebuf_getdata_atoff(pufbuf, sizeof(int), &max, sizeof(size_t));
        moved = puffs_framebuf_tellsize(pufbuf) - METADATASIZE;
        assert(max >= moved);
        max -= moved;

        do {
                n = read(fd, buf, MIN(sizeof(buf), max));
                if (n == 0) {
                        /*
                         * Deal with EOF here by closing the file descriptor
                         * and thus causing an error on subsequent accesses.
                         * This is the last kevent notification we are going
                         * to be getting for regular files.
                         */
                        close(fd);
                        if (moved)
                                break;
                        else
                                return -1; /* caught by read */
                }
                if (n < 0) {
                        if (moved)
                                return 0;

                        if (errno != EAGAIN)
                                return errno;
                        else
                                return 0;
                }

                puffs_framebuf_putdata(pufbuf, buf, n);
                moved += n;
                max -= n;
        } while (max > 0);

        *done = 1;

        return 0;
}

static int
portal_frame_rf(struct puffs_usermount *pu, struct puffs_framebuf *pufbuf,
        int fd, int *done)
{
        int type;

        if (puffs_framebuf_getdata_atoff(pufbuf, 0, &type, sizeof(int)) == -1)
                return EINVAL;

        if (type == PUFBUF_FD)
                return readfd(pufbuf, fd, done);
        else if (type == PUFBUF_DATA)
                return readdata(pufbuf, fd, done);
        else
                abort();
}

static int
portal_frame_wf(struct puffs_usermount *pu, struct puffs_framebuf *pufbuf,
        int fd, int *done)
{
        void *win;
        size_t pbsize, pboff, winlen;
        ssize_t n;
        int error;

        pboff = puffs_framebuf_telloff(pufbuf);
        pbsize = puffs_framebuf_tellsize(pufbuf);
        error = 0;

        do {
                assert(pbsize > pboff);
                winlen = pbsize - pboff;
                if (puffs_framebuf_getwindow(pufbuf, pboff, &win, &winlen)==-1)
                        return errno;
                n = write(fd, win, winlen);
                if (n == 0) {
                        if (pboff != 0)
                                break;
                        else
                                return -1; /* caught by node_write */
                }
                if (n < 0) {
                        if (pboff != 0)
                                break;

                        if (errno != EAGAIN)
                                return errno;
                        return 0;
                }

                pboff += n;
                puffs_framebuf_seekset(pufbuf, pboff);
        } while (pboff != pbsize);

        *done = 1;
        puffs_framebuf_putdata_atoff(pufbuf, 0, &pboff, sizeof(size_t));
        return error;
}

/* transfer file descriptor to master file server */
static int
sendfd(int s, int fd, int error)
{
        struct cmsghdr *cmp;
        struct msghdr msg;
        struct iovec iov;
        ssize_t n;
        int rv;

        rv = 0;
        cmp = emalloc(CMSG_LEN(sizeof(int)));

        iov.iov_base = &error;
        iov.iov_len = sizeof(int);

        msg.msg_iov = &iov;
        msg.msg_iovlen = 1;
        msg.msg_name = NULL;
        msg.msg_namelen = 0;
        if (error == 0) {
                cmp->cmsg_level = SOL_SOCKET;
                cmp->cmsg_type = SCM_RIGHTS;
                cmp->cmsg_len = CMSG_LEN(sizeof(int));

                msg.msg_control = cmp;
                msg.msg_controllen = CMSG_LEN(sizeof(int));
                *(int *)CMSG_DATA(cmp) = fd;
        } else {
                msg.msg_control = NULL;
                msg.msg_controllen = 0;
        }

        n = sendmsg(s, &msg, 0);
        if (n == -1)
                rv = errno;
        else if (n < (ssize_t)sizeof(int))
                rv = EPROTO;

        free(cmp);
        return rv;
}

/*
 * Produce I/O file descriptor by forking (like original portald).
 * 
 * child: run provider and transfer produced fd to parent
 * parent: yield until child produces fd.  receive it and store it.
 */
static int
provide(struct puffs_usermount *pu, struct portal_node *portn,
        struct portal_cred *portc, char **v)
{
        struct puffs_cc *pcc = puffs_cc_getcc(pu);
        struct puffs_framebuf *pufbuf;
        int s[2];
        int fd, error;
        int data;

        pufbuf = puffs_framebuf_make();
        if (pufbuf == NULL)
                return ENOMEM;

        data = PUFBUF_FD;
        if (puffs_framebuf_putdata(pufbuf, &data, sizeof(int)) == -1)
                goto bad;

        if (socketpair(AF_LOCAL, SOCK_STREAM, 0, s) == -1)
                goto bad;

        switch (fork()) {
        case -1:
                close(s[0]); close(s[1]);
                goto bad;
        case 0:
                close(s[0]);
                error = activate_argv(portc, portn->path, v, &fd);
                sendfd(s[1], fd, error);
                exit(0);
        default:
                close(s[1]);
                puffs_framev_addfd(pu, s[0], PUFFS_FBIO_READ);
                puffs_framev_enqueue_directreceive(pcc, s[0], pufbuf, 0);
                puffs_framev_removefd(pu, s[0], 0);
                close(s[0]);

                if (puffs_framebuf_tellsize(pufbuf) < sizeof(int)) {
                        errno = EIO;
                        goto bad;
                }
                puffs_framebuf_getdata_atoff(pufbuf, 0, &error, sizeof(int));
                if (error) {
                        errno = error;
                        goto bad;
                }

                if (puffs_framebuf_tellsize(pufbuf) != 2*sizeof(int)) {
                        errno = EIO;
                        goto bad;
                }

                puffs_framebuf_getdata_atoff(pufbuf, sizeof(int),
                    &fd, sizeof(int));
                puffs_framebuf_destroy(pufbuf);

                data = 1;
                if (ioctl(fd, FIONBIO, &data) == -1)
                        return errno;

                if (puffs_framev_addfd(pu, fd, PUFFS_FBIO_WRITE) == -1)
                        return errno;

                portn->fd = fd;
                return 0;
        }

 bad:
        puffs_framebuf_destroy(pufbuf);
        return errno;
}

int
main(int argc, char *argv[])
{
        struct puffs_usermount *pu;
        struct puffs_ops *pops;
        mntoptparse_t mp;
        int pflags, mntflags;
        int detach;
        int ch;

        setprogname(argv[0]);

        mntflags = pflags = 0;
        detach = 1;
        while ((ch = getopt(argc, argv, "o:s")) != -1) {
                switch (ch) {
                case 'o':
                        mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
                        if (mp == NULL)
                                err(1, "getmntopts");
                        freemntopts(mp);
                        break;
                case 's': /* stay on top */
                        detach = 0;
                        break;
                default:
                        usage();
                        /*NOTREACHED*/
                }
        }
        pflags |= PUFFS_KFLAG_NOCACHE | PUFFS_KFLAG_LOOKUP_FULLPNBUF;
        if (pflags & PUFFS_FLAG_OPDUMP)
                detach = 0;
        argc -= optind;
        argv += optind;

        if (argc != 2)
                usage();

        PUFFSOP_INIT(pops);

        PUFFSOP_SETFSNOP(pops, unmount);
        PUFFSOP_SETFSNOP(pops, sync);
        PUFFSOP_SETFSNOP(pops, statvfs);

        PUFFSOP_SET(pops, portal, node, lookup);
        PUFFSOP_SET(pops, portal, node, getattr);
        PUFFSOP_SET(pops, portal, node, setattr);
        PUFFSOP_SET(pops, portal, node, open);
        PUFFSOP_SET(pops, portal, node, read);
        PUFFSOP_SET(pops, portal, node, write);
        PUFFSOP_SET(pops, portal, node, seek);
        PUFFSOP_SET(pops, portal, node, poll);
        PUFFSOP_SET(pops, portal, node, inactive);
        PUFFSOP_SET(pops, portal, node, reclaim);

        pu = puffs_init(pops, _PATH_PUFFS, "portal", NULL, pflags);
        if (pu == NULL)
                err(1, "init");

        if (signal(SIGHUP, sighup) == SIG_ERR)
                warn("cannot set sighup handler");
        if (signal(SIGCHLD, sigcry) == SIG_ERR)
                err(1, "cannot set sigchild handler");
        if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
                err(1, "cannot ignore sigpipe");

        readcfg = 0;
        cfg = argv[0];
        if (*cfg != '/')
                errx(1, "need absolute path for config");
        q.q_forw = q.q_back = &q;
        if (conf_read(&q, cfg) == -1)
                err(1, "cannot read cfg \"%s\"", cfg);

        puffs_ml_setloopfn(pu, portal_loopfn);
        puffs_framev_init(pu, portal_frame_rf, portal_frame_wf, NULL,NULL,NULL);

        if (detach)
                if (puffs_daemon(pu, 1, 1) == -1)
                        err(1, "puffs_daemon");

        if (puffs_mount(pu,  argv[1], mntflags, PORTAL_ROOT) == -1)
                err(1, "mount");
        if (puffs_mainloop(pu) == -1)
                err(1, "mainloop");

        return 0;
}

static struct portal_node *
makenode(const char *path)
{
        struct portal_node *portn;

        portn = emalloc(sizeof(struct portal_node));
        portn->path = estrdup(path);
        portn->fd = -1;

        return portn;
}

static void
credtr(struct portal_cred *portc, const struct puffs_cred *puffc, int mode)
{
        memset(portc, 0, sizeof(struct portal_cred));

        portc->pcr_flag = mode;
        puffs_cred_getuid(puffc, &portc->pcr_uid);
        puffs_cred_getgid(puffc, &portc->pcr_gid);
        puffs_cred_getgroups(puffc, portc->pcr_groups,
            (short *)&portc->pcr_ngroups);
}

/*
 * XXX: we could also simply already resolve the name at this stage
 * instead of deferring it to open.  But doing it in open is how the
 * original portald does it, and I don't want to introduce any funny
 * incompatibilities.
 */
int
portal_node_lookup(struct puffs_usermount *pu, puffs_cookie_t opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn)
{
        struct portal_node *portn;

        assert(opc == PORTAL_ROOT);

        if (pcn->pcn_nameiop != NAMEI_LOOKUP
            && pcn->pcn_nameiop != NAMEI_CREATE)
                return EOPNOTSUPP;

        portn = makenode(pcn->pcn_name);
        puffs_newinfo_setcookie(pni, portn);
        puffs_newinfo_setvtype(pni, VREG);

        pcn->pcn_flags &= ~NAMEI_REQUIREDIR;
        pcn->pcn_consume = strlen(pcn->pcn_name) - pcn->pcn_namelen;

        return 0;
}

unsigned int fakeid = 3;

/* XXX: libpuffs'ize */
int
portal_node_getattr(struct puffs_usermount *pu, puffs_cookie_t opc,
        struct vattr *va, const struct puffs_cred *pcr)
{
        struct timeval tv;
        struct timespec ts;
        int res = 0;

        puffs_vattr_null(va);
        if (opc == PORTAL_ROOT) {
                va->va_type = VDIR;
                va->va_mode = 0777;
                va->va_nlink = 2;
                va->va_uid = va->va_gid = 0;
#if 0   /* XXX Huh? */
                va->va_fileid = fakeid++;
#else
                va->va_fileid = 2;      /*XXX; ROOTINO*/
#endif
                va->va_size = va->va_bytes = 0;
                va->va_gen = 0;
                va->va_rdev = PUFFS_VNOVAL;
                va->va_blocksize = DEV_BSIZE;

                gettimeofday(&tv, NULL);
                TIMEVAL_TO_TIMESPEC(&tv, &ts);
                va->va_atime = va->va_ctime = va->va_mtime =
                    va->va_birthtime = ts;
        } else {
                /* cheat for now */
                int error;
                int newfd;
                struct stat st;
                struct portal_node *portn = opc;
                struct portal_cred portc;
                char **v = conf_match(&q, portn->path);

                if (v == NULL)
                        return ENOENT;
                if (portn->fd == -1) {
                        credtr(&portc, pcr, 0777);
                        error = provide(pu, portn, &portc, v);
                        if (error)
                                return error;
                        newfd = 1;
                } else
                        newfd = 0;

                if (fstat(portn->fd, &st) == -1)
                        res = errno;
                else {
#if 0
                        va->va_type = S_ISDIR(st.st_mode) ? VDIR : VREG; /* XXX */
#else
                        va->va_type = puffs_mode2vt(st.st_mode);
#endif
                        /* puffs supplies S_IFMT bits later */
                        va->va_mode = (st.st_mode & ~S_IFMT);

                        va->va_nlink = st.st_nlink ? st.st_nlink : 1;
                        va->va_uid = st.st_uid;
                        va->va_gid = st.st_gid;
                        va->va_fileid = st.st_ino ? st.st_ino : fakeid++;
                        va->va_size = va->va_bytes = st.st_size;
                        va->va_gen = 0;
                        va->va_rdev = st.st_rdev;
                        va->va_blocksize = st.st_blksize;
                        va->va_atime = st.st_atim;
                        va->va_ctime = st.st_ctim;
                        va->va_mtime = st.st_mtim;
                        va->va_birthtime = st.st_birthtim;
                }
                if (newfd) {
                        puffs_framev_removefd(pu, portn->fd, 0);
                        close(portn->fd);
                        portn->fd = -1;
                }
        }

        return res;
}

/* for writing, just pretend we care */
int
portal_node_setattr(struct puffs_usermount *pu, puffs_cookie_t opc,
        const struct vattr *va, const struct puffs_cred *pcr)
{

        return 0;
}

int
portal_node_open(struct puffs_usermount *pu, puffs_cookie_t opc, int mode,
        const struct puffs_cred *pcr)
{
        struct portal_node *portn = opc;
        struct portal_cred portc;
        char **v;

        if (opc == PORTAL_ROOT)
                return 0;

        if (mode & O_NONBLOCK)
                return EOPNOTSUPP;

        v = conf_match(&q, portn->path);
        if (v == NULL)
                return ENOENT;

        credtr(&portc, pcr, mode);
        return provide(pu, portn, &portc, v);
}

int
portal_node_read(struct puffs_usermount *pu, puffs_cookie_t opc,
        uint8_t *buf, off_t offset, size_t *resid,
        const struct puffs_cred *pcr, int ioflag)
{
        struct puffs_cc *pcc = puffs_cc_getcc(pu);
        struct portal_node *portn = opc;
        struct puffs_framebuf *pufbuf;
        size_t xfersize, winsize, boff;
        void *win;
        int rv, error;
        int data, dummy;

        assert(opc != PORTAL_ROOT);
        error = 0;

        /* if we can't (re-)enable it, treat it as EOF */
        rv = puffs_framev_enablefd(pu, portn->fd, PUFFS_FBIO_READ);
        if (rv == -1)
                return 0;

        pufbuf = puffs_framebuf_make();
        data = PUFBUF_DATA;
        puffs_framebuf_putdata(pufbuf, &data, sizeof(int));
        puffs_framebuf_putdata(pufbuf, resid, sizeof(size_t));

        /* if we are doing nodelay, do read directly */
        if (ioflag & PUFFS_IO_NDELAY) {
                rv = readdata(pufbuf, portn->fd, &dummy);
                if (rv != 0) {
                        error = rv;
                        goto out;
                }
        } else {
                rv = puffs_framev_enqueue_directreceive(pcc,
                    portn->fd, pufbuf, 0);

                if (rv == -1) {
                        error = errno;
                        goto out;
                }
        }

        xfersize = puffs_framebuf_tellsize(pufbuf) - METADATASIZE;
        if (xfersize == 0) {
                assert(ioflag & PUFFS_IO_NDELAY);
                error = EAGAIN;
                goto out;
        }

        *resid -= xfersize;
        boff = 0;
        while (xfersize > 0) {
                winsize = xfersize;
                rv = puffs_framebuf_getwindow(pufbuf, METADATASIZE,
                    &win, &winsize);
                assert(rv == 0);
                assert(winsize > 0);

                memcpy(buf + boff, win, winsize);
                xfersize -= winsize;
                boff += winsize;
        }

 out:
        puffs_framev_disablefd(pu, portn->fd, PUFFS_FBIO_READ);
        puffs_framebuf_destroy(pufbuf);

        /* a trickery, from readdata() */
        if (error == -1)
                return 0;
        return error;
}

int
portal_node_write(struct puffs_usermount *pu, puffs_cookie_t opc,
        uint8_t *buf, off_t offset, size_t *resid,
        const struct puffs_cred *pcr, int ioflag)
{
        struct puffs_cc *pcc = puffs_cc_getcc(pu);
        struct portal_node *portn = opc;
        struct puffs_framebuf *pufbuf;
        size_t written;
        int error, rv, dummy;

        assert(opc != PORTAL_ROOT);

        pufbuf = puffs_framebuf_make();
        puffs_framebuf_putdata(pufbuf, buf, *resid);

        error = 0;
        if (ioflag & PUFFS_IO_NDELAY) {
                rv = portal_frame_wf(pu, pufbuf, portn->fd, &dummy);
                if (rv) {
                        error = rv;
                        goto out;
                }
        } else  {
                rv = puffs_framev_enqueue_directsend(pcc, portn->fd, pufbuf, 0);
                if (rv == -1) {
                        error = errno;
                        goto out;
                }
        }

        rv = puffs_framebuf_getdata_atoff(pufbuf, 0, &written, sizeof(size_t));
        assert(rv == 0);
        assert(written <= *resid);
        *resid -= written;

 out:
        puffs_framebuf_destroy(pufbuf);
        if (error == -1)
                error = 0;
        return 0;
}

int
portal_node_seek(struct puffs_usermount *pu, puffs_cookie_t opc,
        off_t oldoff, off_t newoff, const struct puffs_cred *pcr)
{
        struct portal_node *portn = opc;

        if (opc == PORTAL_ROOT || portn->fd == -1)
                return EOPNOTSUPP;

        if (lseek(portn->fd, newoff, SEEK_SET) == -1)
                return errno;
        return 0;
}

int
portal_node_poll(struct puffs_usermount *pu, puffs_cookie_t opc, int *events)
{
        struct puffs_cc *pcc = puffs_cc_getcc(pu);
        struct portal_node *portn = opc;
        int what;

        what = 0;
        if (*events & POLLIN)
                what |= PUFFS_FBIO_READ;
        if (*events & POLLOUT)
                what |= PUFFS_FBIO_WRITE;
        if (*events & POLLERR)
                what |= PUFFS_FBIO_ERROR;

        if (puffs_framev_enqueue_waitevent(pcc, portn->fd, &what) == -1) {
                *events = POLLERR;
                return errno;
        }

        *events = 0;
        if (what & PUFFS_FBIO_READ)
                *events |= POLLIN;
        if (what & PUFFS_FBIO_WRITE)
                *events |= POLLOUT;
        if (what & PUFFS_FBIO_ERROR)
                *events |= POLLERR;

        return 0;
}

int
portal_node_inactive(struct puffs_usermount *pu, puffs_cookie_t opc)
{

        if (opc == PORTAL_ROOT)
                return 0;

        puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N1);
        return 0;
}

int
portal_node_reclaim(struct puffs_usermount *pu, puffs_cookie_t opc)
{
        struct portal_node *portn = opc;

        if (portn->fd != -1) {
                puffs_framev_removefd(pu, portn->fd, 0);
                close(portn->fd);
        }
        free(portn->path);
        free(portn);

        return 0;
}