/* $OpenBSD: fuse_session.c,v 1.1 2026/01/22 11:53:31 helg Exp $ */
/*
 * Copyright (c) 2025 Helg Bredow <helg@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/uio.h>
#include <errno.h>
#include <err.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "debug.h"
#include "fuse_private.h"

void
fuse_session_destroy(struct fuse_session *se)
{
        if (se->init && se->llops.destroy)
                se->llops.destroy(se->userdata);

        free(se->chan);
        free(se);
}
DEF(fuse_session_destroy);

void
fuse_session_add_chan(struct fuse_session *se, struct fuse_chan *ch)
{
        if (se->chan == NULL && ch->se == NULL) {
                se->chan = ch;
                ch->se = se;
        }
}
DEF(fuse_session_add_chan);

void
fuse_session_remove_chan(struct fuse_chan *ch)
{
        if (ch->se->chan == ch) {
                ch->se->chan = NULL;
                ch->se = NULL;
        }
}
DEF(fuse_session_remove_chan);

void
fuse_session_exit(struct fuse_session *se)
{
        se->exit = 1;
}
DEF(fuse_session_exit);

int
fuse_session_exited(const struct fuse_session *se)
{
        return (se->exit);
}
DEF(fuse_session_exited);

void
fuse_session_reset(struct fuse_session *se)
{
        if (se != NULL)
                se->exit = 0;
}
DEF(fuse_session_reset);

int
fuse_session_loop(struct fuse_session *se)
{
        struct fuse_chan *ch;
        struct fusebuf fbuf;
        char *buf = (char *)&fbuf;
        size_t bufsize;
        int err;

        if (se == NULL)
                return (-1);

        ch = se->chan;
        if (ch == NULL)
                return (-1);

        /* prepare the read and write data buffer */
        fbuf.fb_dat = calloc(1, FUSEBUFMAXSIZE);
        if (fbuf.fb_dat == NULL) {
                DPERROR(__func__);
                return (-1);
        }

        bufsize = sizeof(fbuf.fb_hdr) + sizeof(fbuf.FD) + FUSEBUFMAXSIZE;

        while (!fuse_session_exited(se)) {
                err = fuse_chan_recv(&ch, buf, bufsize);
                if (err == -EINTR || err == -ENODEV) {
                        fuse_session_exit(se);
                        continue;
                } else if (err <= 0) {
                        DPERROR(__func__);
                        break;
                }

                fuse_session_process(se, buf, bufsize, ch);
        }

        free(fbuf.fb_dat);
        fuse_session_reset(se);

        return (err == 0 ? 0 : -1);
}
DEF(fuse_session_loop);

static void
iprocess_init(fuse_req_t req)
{
        struct fuse_session *se = req->se;
        struct fuse_conn_info fci;

        DPRINTF("%-11s", "init");

        if (se->llops.init) {
                memset(&fci, 0, sizeof(fci));
                fci.proto_minor = FUSE_MINOR_VERSION;
                fci.proto_major = FUSE_MAJOR_VERSION;

                se->llops.init(se->userdata, &fci);
        }

        fuse_reply_err(req, 0);

        se->init = 1;
}

static void
iprocess_destroy(fuse_req_t req)
{
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "destroy");

        se->chan->dead = 1;
        fuse_session_exit(se);
        fuse_reply_err(req, 0);
}

static void
iprocess_lookup(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        const char *name = fbuf->fb_dat;

        DPRINTF("%-11s", "lookup");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("name: %s\t", name);

        if (se->llops.lookup)
                se->llops.lookup(req, fbuf->fb_ino, name);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_getattr(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "getattr");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.getattr) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;

                se->llops.getattr(req, fbuf->fb_ino, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_setattr(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;
        struct stat *stbuf = &fbuf->fb_attr;
        struct fb_io *io = fbtod(fbuf, struct fb_io *);

        DPRINTF("%-11s", "setattr");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.setattr) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;

                se->llops.setattr(req, fbuf->fb_ino, stbuf, io->fi_flags, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_opendir(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "opendir");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        memset(&ffi, 0, sizeof(ffi));
        ffi.flags = fbuf->fb_io_flags;

        if (se->llops.opendir)
                se->llops.opendir(req, fbuf->fb_ino, &ffi);
        else
                fuse_reply_open(req, &ffi);
}

static void
iprocess_readdir(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "readdir");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("size: %lu\t", fbuf->fb_io_len);
        DPRINTF("offset: %llu\t", fbuf->fb_io_off);

        if (se->llops.readdir) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;

                se->llops.readdir(req, fbuf->fb_ino, fbuf->fb_io_len,
                    fbuf->fb_io_off, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_releasedir(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "releasedir");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.releasedir) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;
                ffi.flags = fbuf->fb_io_flags;

                se->llops.releasedir(req, fbuf->fb_ino, &ffi);
        } else
                fuse_reply_err(req, 0);
}

static void
iprocess_mkdir(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "mkdir");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("mode: %#6o\t", fbuf->fb_io_mode);
        DPRINTF("name: %s\t", fbuf->fb_dat);

        if (se->llops.mkdir)
                se->llops.mkdir(req, fbuf->fb_ino, fbuf->fb_dat,
                    fbuf->fb_io_mode);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_rmdir(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "rmdir");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("name: %s\t", fbuf->fb_dat);

        if (se->llops.rmdir)
                se->llops.rmdir(req, fbuf->fb_ino, fbuf->fb_dat);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_mknod(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "mknod");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("mode: %#6o\t", fbuf->fb_io_mode);
        DPRINTF("name: %s\t", fbuf->fb_dat);

        if (se->llops.mknod)
                se->llops.mknod(req, fbuf->fb_ino, fbuf->fb_dat,
                    fbuf->fb_io_mode, fbuf->fb_io_rdev);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_open(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "open");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        memset(&ffi, 0, sizeof(ffi));
        ffi.flags = fbuf->fb_io_flags;

        if (se->llops.open)
                se->llops.open(req, fbuf->fb_ino, &ffi);
        else
                fuse_reply_open(req, &ffi);
}

static void
iprocess_read(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "read");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("size: %lu\t", fbuf->fb_io_len);
        DPRINTF("offset: %llu\t", fbuf->fb_io_off);

        if (se->llops.read) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;
                ffi.flags = fbuf->fb_io_flags;

                se->llops.read(req, fbuf->fb_ino, fbuf->fb_io_len,
                    fbuf->fb_io_off, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_write(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "write");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("size: %lu\t", fbuf->fb_io_len);
        DPRINTF("offset: %llu\t", fbuf->fb_io_off);

        if (se->llops.write) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;
                ffi.writepage = fbuf->fb_io_flags & 1; // XXX

                se->llops.write(req, fbuf->fb_ino, fbuf->fb_dat,
                    fbuf->fb_io_len, fbuf->fb_io_off, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_fsync(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "fsync");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.fsync) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;

                /*
                 * fdatasync(2) is just a wrapper around fsync(2) so datasync
                 * is always false.
                 */
                se->llops.fsync(req, fbuf->fb_ino, 0 /* datasync */, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_flush(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "flush");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.flush) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;
                ffi.flush = 1;

                se->llops.flush(req, fbuf->fb_ino, &ffi);
        } else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_release(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        struct fuse_file_info ffi;

        DPRINTF("%-11s", "release");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.release) {
                memset(&ffi, 0, sizeof(ffi));
                ffi.fh = fbuf->fb_io_fd;
                ffi.fh_old = ffi.fh;
                ffi.flags = fbuf->fb_io_flags;

                se->llops.release(req, fbuf->fb_ino, &ffi);
        } else
                fuse_reply_err(req, 0);
}

static void
iprocess_forget(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "forget");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.forget)
                se->llops.forget(req, fbuf->fb_ino, 1 /* TODO */);
        else
                fuse_reply_err(req, 0);
}

static void
iprocess_symlink(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        const char *target;
        const char *name;
        int len;

        name = fbuf->fb_dat;
        len = strnlen(name, fbuf->fb_len);
        target = &fbuf->fb_dat[len + 1];

        DPRINTF("%-11s", "symlink");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("name: %s\t", name);
        DPRINTF("target: %s\t", target);

        if (se->llops.symlink)
                se->llops.symlink(req, target, fbuf->fb_ino, name);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_readlink(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "readlink");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.readlink)
                se->llops.readlink(req, fbuf->fb_ino);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_link(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        const char *name = fbuf->fb_dat;

        DPRINTF("%-11s", "link");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("inode: %llu\t", fbuf->fb_io_ino);
        DPRINTF("name: %s\t", name);

        if (se->llops.link)
                se->llops.link(req, fbuf->fb_io_ino, fbuf->fb_ino, name);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_unlink(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "unlink");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("name: %s\t", fbuf->fb_dat);

        if (se->llops.unlink)
                se->llops.unlink(req, fbuf->fb_ino, fbuf->fb_dat);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_rename(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;
        const char *target;
        const char *name;
        int len;

        name = fbuf->fb_dat;
        len = strnlen(name, fbuf->fb_len);
        target = &fbuf->fb_dat[len + 1];

        DPRINTF("%-11s", "rename");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);
        DPRINTF("name: %s\t", name);
        DPRINTF("inode: %llu\t", fbuf->fb_io_ino);
        DPRINTF("target: %s\t", target);

        if (se->llops.rename)
                se->llops.rename(req, fbuf->fb_ino, name, fbuf->fb_io_ino,
                    target);
        else
                fuse_reply_err(req, ENOSYS);
}

static void
iprocess_statfs(fuse_req_t req)
{
        struct fusebuf *fbuf = req->fbuf;
        struct fuse_session *se = req->se;

        DPRINTF("%-11s", "statfs");
        DPRINTF("inode: %llu\t", fbuf->fb_ino);

        if (se->llops.statfs)
                se->llops.statfs(req, fbuf->fb_ino);
        else
                fuse_reply_err(req, ENOSYS);
}

void
fuse_session_process(struct fuse_session *se, const char *buf, size_t len,
    struct fuse_chan *ch)
{
        struct fusebuf *fbuf;
        struct fuse_req req;

        fbuf = (struct fusebuf *)buf;
        req.fbuf = fbuf;
        req.se = se;
        req.ch = (ch == NULL) ? se->chan : ch;
        req.ctx.uid = fbuf->fb_uid;
        req.ctx.gid = fbuf->fb_gid;
        req.ctx.pid = fbuf->fb_tid;
        req.ctx.umask = fbuf->fb_umask;

        /* need to at least have the header for the next check */
        if (len < sizeof(fbuf->fb_hdr))
                return;

        if (len < sizeof(fbuf->fb_hdr) + sizeof(fbuf->FD) + fbuf->fb_len)
                return;

        switch (fbuf->fb_type) {
        case FBT_INIT:
                iprocess_init(&req);
                break;
        case FBT_DESTROY:
                iprocess_destroy(&req);
                break;
        case FBT_LOOKUP:
                iprocess_lookup(&req);
                break;
        case FBT_GETATTR:
                iprocess_getattr(&req);
                break;
        case FBT_SETATTR:
                iprocess_setattr(&req);
                break;
        case FBT_OPENDIR:
                iprocess_opendir(&req);
                break;
        case FBT_READDIR:
                iprocess_readdir(&req);
                break;
        case FBT_RELEASEDIR:
                iprocess_releasedir(&req);
                break;
        case FBT_MKDIR:
                iprocess_mkdir(&req);
                break;
        case FBT_RMDIR:
                iprocess_rmdir(&req);
                break;
        case FBT_MKNOD:
                iprocess_mknod(&req);
                break;
        case FBT_OPEN:
                iprocess_open(&req);
                break;
        case FBT_READ:
                iprocess_read(&req);
                break;
        case FBT_WRITE:
                iprocess_write(&req);
                break;
        case FBT_FSYNC:
                iprocess_fsync(&req);
                break;
        case FBT_FLUSH:
                iprocess_flush(&req);
                break;
        case FBT_RELEASE:
                iprocess_release(&req);
                break;
        case FBT_RECLAIM:
                iprocess_forget(&req);
                break;
        case FBT_SYMLINK:
                iprocess_symlink(&req);
                break;
        case FBT_READLINK:
                iprocess_readlink(&req);
                break;
        case FBT_LINK:
                iprocess_link(&req);
                break;
        case FBT_UNLINK:
                iprocess_unlink(&req);
                break;
        case FBT_RENAME:
                iprocess_rename(&req);
                break;
        case FBT_STATFS:
                iprocess_statfs(&req);
                break;
        default:
                DPRINTF("Opcode: %i not supported\t", fbuf->fb_type);
                fuse_reply_err(&req, ENOSYS);
        }
        DPRINTF("\n");
}
DEF(fuse_session_process);