/* $OpenBSD: fuse_lowlevel.c,v 1.2 2026/01/29 06:04:27 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 <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

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

enum {
	KEY_HELP,
	KEY_VERSION,
	KEY_DEBUG
};

static const struct fuse_opt fuse_ll_opts[] = {
	FUSE_OPT_KEY("debug",		KEY_DEBUG),
	FUSE_OPT_KEY("-d",		KEY_DEBUG),
	FUSE_OPT_KEY("-h",		KEY_HELP),
	FUSE_OPT_KEY("--help",		KEY_HELP),
	FUSE_OPT_KEY("-V",		KEY_VERSION),
	FUSE_OPT_KEY("--version",	KEY_VERSION),
	FUSE_OPT_KEY("max_read=",	FUSE_OPT_KEY_DISCARD),
	FUSE_OPT_END
};

static void
dump_version(void)
{
	fprintf(stderr, "FUSE library version: %d.%d\n", FUSE_MAJOR_VERSION,
	    FUSE_MINOR_VERSION);
}

static void
dump_help(void)
{
	fprintf(stderr,	"    -o max_write=N         max buffer size for "
	    "write operations\n"
	);
}

static int
ifuse_ll_opt_proc(void *data, const char *arg, int key,
    struct fuse_args *outargs)
{
	switch (key) {
	case KEY_HELP:
		dump_help();
		break;
	case KEY_VERSION:
		dump_version();
		break;
	case KEY_DEBUG:
		ifuse_debug_init();
		return (1);
	default:
		fprintf(stderr, "fuse: unknown option -- %s\n", arg);
	}

	return -1;
}

struct fuse_session *
fuse_lowlevel_new(struct fuse_args *fargs,
    const struct fuse_lowlevel_ops *llops, const size_t llops_len,
    void *userdata)
{
	struct fuse_session *se;

	se = calloc(1, sizeof(*se));
	if (se == NULL)
		return (NULL);

	if (fuse_opt_parse(fargs, NULL, fuse_ll_opts, ifuse_ll_opt_proc) == -1) {
		free(se);
		return (NULL);
	}

	if (llops->create && !llops->mknod)
		DPRINTF("libfuse: WARNING: filesystem supports creating files "
		    "but does not implement mknod. No new files can be "
		    "created.\n");

	/* validate size of ops struct */
	if (sizeof(se->llops) == llops_len)
		memcpy(&se->llops, llops, sizeof(se->llops));
	else {
		free(se);
		return (NULL);
	}

	se->userdata = userdata;

	return (se);
}
DEF(fuse_lowlevel_new);

static int
ifuse_reply(fuse_req_t req, const char *data, const size_t data_size, int err)
{
	struct fusebuf *fbuf;
	struct iovec iov[2];
	size_t fbuf_size;

	/* check for sanity */
	if (data == NULL && data_size > 0) {
		DPRINTF("\nlibfuse: NULL data with size: %zu\n", data_size);
		fuse_reply_err(req, EIO);
		return (-EINVAL);
	}

	fbuf = req->fbuf;
	fbuf_size = sizeof(fbuf->fb_hdr) + sizeof(fbuf->FD);

	fbuf->fb_err = err;
	fbuf->fb_len = data_size;

	iov[0].iov_base = fbuf;
	iov[0].iov_len  = fbuf_size;
	iov[1].iov_base = (void *)data;
	iov[1].iov_len  = data_size;

	DPRINTF("errno: %d", fbuf->fb_err);

	return fuse_chan_send(req->ch, iov, 2);
}

static int
ifuse_reply_ok(fuse_req_t req)
{
	return ifuse_reply(req, NULL, 0, 0);
}

int
fuse_reply_err(fuse_req_t req, int err)
{
	return ifuse_reply(req, NULL, 0, err);
}
DEF(fuse_reply_err);

int
fuse_reply_buf(fuse_req_t req, const char *buf, off_t size)
{
	return ifuse_reply(req, buf, size, 0);
}
DEF(fuse_reply_buf);

int
fuse_reply_readlink(fuse_req_t req, char *path)
{
	return ifuse_reply(req, path, strlen(path), 0);
}
DEF(fuse_reply_readlink);

int
fuse_reply_write(fuse_req_t req, size_t size)
{
	struct fusebuf *fbuf;

	fbuf = req->fbuf;
	fbuf->fb_io_len = size;

	return ifuse_reply_ok(req);
}
DEF(fuse_reply_write);

int
fuse_reply_attr(fuse_req_t req, const struct stat *stbuf, double attr_timeout)
{
	struct fusebuf *fbuf;

	fbuf = req->fbuf;
	fbuf->fb_attr = *stbuf;

	return ifuse_reply_ok(req);
}
DEF(fuse_reply_attr);

int
fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e)
{
	struct fusebuf *fbuf;

	fbuf = req->fbuf;
	fbuf->fb_attr = e->attr;
	fbuf->fb_ino = e->ino;
	DPRINTF("inode: %llu\t", e->ino);

	return ifuse_reply_ok(req);
}
DEF(fuse_reply_entry);

int
fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf)
{
	struct fusebuf *fbuf;

	fbuf = req->fbuf;
	fbuf->fb_stat = *stbuf;

	return ifuse_reply_ok(req);
}
DEF(fuse_reply_statfs);

int
fuse_reply_bmap(fuse_req_t req, uint64_t idx)
{
	DPRINTF("%s: Unsupported", __func__);
	return (-EOPNOTSUPP);
}
DEF(fuse_reply_bmap);

int
fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e,
     const struct fuse_file_info *ffi)
{
	DPRINTF("%s: Unsupported", __func__);
	return (-EOPNOTSUPP);
}
DEF(fuse_reply_create);

int
fuse_reply_open(fuse_req_t req, const struct fuse_file_info *ffi)
{
	struct fusebuf *fbuf;

	fbuf = req->fbuf;
	fbuf->fb_io_fd = ffi->fh;

	return ifuse_reply_ok(req);
}
DEF(fuse_reply_open);

void
fuse_reply_none(fuse_req_t req)
{
	/* no-op */
}
DEF(fuse_reply_none);

#define GENERIC_DIRSIZ(NLEN) \
((sizeof (struct dirent) - (MAXNAMLEN+1)) + ((NLEN+1 + 7) &~ 7))

size_t
fuse_add_direntry(fuse_req_t req, char *buf, const size_t bufsize,
     const char *name, const struct stat *stbuf, off_t off)
{
	struct dirent *dir;
	size_t namelen;
	size_t len;

	if (name == NULL)
		return (0);

	namelen = strnlen(name, MAXNAMLEN);
	len = GENERIC_DIRSIZ(namelen);

	/* NULL buf is used to request size to be calculated */
	if (buf == NULL || stbuf == NULL || req == NULL)
		return (len);

	/* buffer is full */
	if (bufsize < len)
		return (len);

	dir = (struct dirent *)buf;
	dir->d_fileno = stbuf->st_ino;
	dir->d_type = IFTODT(stbuf->st_mode);
	dir->d_reclen = len;
	dir->d_off = off;
	strlcpy(dir->d_name, name, sizeof(dir->d_name));
	dir->d_namlen = strlen(dir->d_name);

	return (len);
}
DEF(fuse_add_direntry);

const struct fuse_ctx *
fuse_req_ctx(fuse_req_t req)
{
	return (&req->ctx);
}
DEF(fuse_req_ctx);

void *
fuse_req_userdata(fuse_req_t req)
{
	return (req->se->userdata);
}
DEF(fuse_req_userdata);