/*-
 * Copyright (c) 2019 Tomohiro Kusumi <tkusumi@netbsd.org>
 * Copyright (c) 2019 The DragonFly Project
 * 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 AND CONTRIBUTORS ``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 "fuse.h"

void
fuse_hexdump(const char *p, size_t len)
{
	int i;

	if (!fuse_debug)
		return;

	for (i = 0; i < (int)len; i++) {
		kprintf("%02X ", p[i] & 0xff);
		if ((i + 1) % 32 == 0)
			kprintf("\n");
	}
	kprintf("\n");
}

void
fuse_fill_in_header(struct fuse_in_header *ihd,
    uint32_t len, uint32_t opcode, uint64_t unique, uint64_t nodeid,
    uint32_t uid, uint32_t gid, uint32_t pid)
{
	ihd->len = len;
	ihd->opcode = opcode;
	ihd->unique = unique;
	ihd->nodeid = nodeid;
	ihd->uid = uid;
	ihd->gid = gid;
	ihd->pid = pid;
}

int
fuse_forget_node(struct fuse_mount *fmp, uint64_t ino, uint64_t nlookup,
    struct ucred *cred)
{
	struct fuse_ipc *fip;
	struct fuse_forget_in *ffi;
	int error;

	KKASSERT(nlookup > 0);

	fip = fuse_ipc_get(fmp, sizeof(*ffi));
	ffi = fuse_ipc_fill(fip, FUSE_FORGET, ino, cred);
	ffi->nlookup = nlookup;

	error = fuse_ipc_tx_noreply(fip);
	if (error)
		return error;
	fuse_ipc_put(fip);

	return 0;
}

/*
 * Ignore FUSE_COMPAT_XXX which seem to exist for backward compatibility
 * for ancient versions of FUSE protocol.
 */
int
fuse_audit_length(struct fuse_in_header *ihd, struct fuse_out_header *ohd)
{
	size_t len = ohd->len - sizeof(struct fuse_out_header);
	bool res;

	switch (ihd->opcode) {
	case FUSE_LOOKUP:
		res = (len == sizeof(struct fuse_entry_out));
		break;
	case FUSE_FORGET:
		res = true;
		break;
	case FUSE_GETATTR:
		res = (len == sizeof(struct fuse_attr_out));
		break;
	case FUSE_SETATTR:
		res = (len == sizeof(struct fuse_attr_out));
		break;
	case FUSE_READLINK:
		res = (len <= PAGE_SIZE);
		break;
	case FUSE_SYMLINK:
		res = (len == sizeof(struct fuse_entry_out));
		break;
	case FUSE_MKNOD:
		res = (len == sizeof(struct fuse_entry_out));
		break;
	case FUSE_MKDIR:
		res = (len == sizeof(struct fuse_entry_out));
		break;
	case FUSE_UNLINK:
		res = (len == 0);
		break;
	case FUSE_RMDIR:
		res = (len == 0);
		break;
	case FUSE_RENAME:
		res = (len == 0);
		break;
	case FUSE_LINK:
		res = (len == sizeof(struct fuse_entry_out));
		break;
	case FUSE_OPEN:
		res = (len == sizeof(struct fuse_open_out));
		break;
	case FUSE_READ:
		res = (len <= ((struct fuse_read_in*)(ihd + 1))->size);
		break;
	case FUSE_WRITE:
		res = (len == sizeof(struct fuse_write_out));
		break;
	case FUSE_STATFS:
		res = (len == sizeof(struct fuse_statfs_out));
		break;
	case FUSE_RELEASE:
		res = (len == 0);
		break;
	case FUSE_FSYNC:
		res = (len == 0);
		break;
	case FUSE_SETXATTR:
		res = (len == 0);
		break;
	case FUSE_GETXATTR:
		res = true;
		break;
	case FUSE_LISTXATTR:
		res = true;
		break;
	case FUSE_REMOVEXATTR:
		res = (len == 0);
		break;
	case FUSE_FLUSH:
		res = (len == 0);
		break;
	case FUSE_INIT:
		res = (len == sizeof(struct fuse_init_out));
		break;
	case FUSE_OPENDIR:
		res = (len == sizeof(struct fuse_open_out));
		break;
	case FUSE_READDIR:
		res = (len <= ((struct fuse_read_in*)(ihd + 1))->size);
		break;
	case FUSE_RELEASEDIR:
		res = (len == 0);
		break;
	case FUSE_FSYNCDIR:
		res = (len == 0);
		break;
	case FUSE_GETLK:
		res = false;
		break;
	case FUSE_SETLK:
		res = false;
		break;
	case FUSE_SETLKW:
		res = false;
		break;
	case FUSE_ACCESS:
		res = (len == 0);
		break;
	case FUSE_CREATE:
		res = (len == sizeof(struct fuse_entry_out) +
		    sizeof(struct fuse_open_out));
		break;
	case FUSE_INTERRUPT:
		res = false;
		break;
	case FUSE_BMAP:
		res = false;
		break;
	case FUSE_DESTROY:
		res = (len == 0);
		break;
	case FUSE_IOCTL:
		res = false;
		break;
	case FUSE_POLL:
		res = false;
		break;
	case FUSE_NOTIFY_REPLY:
		res = false;
		break;
	case FUSE_BATCH_FORGET:
		res = false;
		break;
	case FUSE_FALLOCATE:
		res = false;
		break;
	case FUSE_READDIRPLUS:
		res = false;
		break;
	case FUSE_RENAME2:
		res = false;
		break;
	case FUSE_LSEEK:
		res = false;
		break;
	case FUSE_COPY_FILE_RANGE:
		res = false;
		break;
	default:
		fuse_panic("Invalid opcode %d", ihd->opcode);
		break;
	}

	if (!res)
		return -1;
	return 0;
}

const char*
fuse_get_ops(int op)
{
	switch (op) {
	case FUSE_LOOKUP:
		return "FUSE_LOOKUP";
	case FUSE_FORGET:
		return "FUSE_FORGET";
	case FUSE_GETATTR:
		return "FUSE_GETATTR";
	case FUSE_SETATTR:
		return "FUSE_SETATTR";
	case FUSE_READLINK:
		return "FUSE_READLINK";
	case FUSE_SYMLINK:
		return "FUSE_SYMLINK";
	case FUSE_MKNOD:
		return "FUSE_MKNOD";
	case FUSE_MKDIR:
		return "FUSE_MKDIR";
	case FUSE_UNLINK:
		return "FUSE_UNLINK";
	case FUSE_RMDIR:
		return "FUSE_RMDIR";
	case FUSE_RENAME:
		return "FUSE_RENAME";
	case FUSE_LINK:
		return "FUSE_LINK";
	case FUSE_OPEN:
		return "FUSE_OPEN";
	case FUSE_READ:
		return "FUSE_READ";
	case FUSE_WRITE:
		return "FUSE_WRITE";
	case FUSE_STATFS:
		return "FUSE_STATFS";
	case FUSE_RELEASE:
		return "FUSE_RELEASE";
	case FUSE_FSYNC:
		return "FUSE_FSYNC";
	case FUSE_SETXATTR:
		return "FUSE_SETXATTR";
	case FUSE_GETXATTR:
		return "FUSE_GETXATTR";
	case FUSE_LISTXATTR:
		return "FUSE_LISTXATTR";
	case FUSE_REMOVEXATTR:
		return "FUSE_REMOVEXATTR";
	case FUSE_FLUSH:
		return "FUSE_FLUSH";
	case FUSE_INIT:
		return "FUSE_INIT";
	case FUSE_OPENDIR:
		return "FUSE_OPENDIR";
	case FUSE_READDIR:
		return "FUSE_READDIR";
	case FUSE_RELEASEDIR:
		return "FUSE_RELEASEDIR";
	case FUSE_FSYNCDIR:
		return "FUSE_FSYNCDIR";
	case FUSE_GETLK:
		return "FUSE_GETLK";
	case FUSE_SETLK:
		return "FUSE_SETLK";
	case FUSE_SETLKW:
		return "FUSE_SETLKW";
	case FUSE_ACCESS:
		return "FUSE_ACCESS";
	case FUSE_CREATE:
		return "FUSE_CREATE";
	case FUSE_INTERRUPT:
		return "FUSE_INTERRUPT";
	case FUSE_BMAP:
		return "FUSE_BMAP";
	case FUSE_DESTROY:
		return "FUSE_DESTROY";
	case FUSE_IOCTL:
		return "FUSE_IOCTL";
	case FUSE_POLL:
		return "FUSE_POLL";
	case FUSE_NOTIFY_REPLY:
		return "FUSE_NOTIFY_REPLY";
	case FUSE_BATCH_FORGET:
		return "FUSE_BATCH_FORGET";
	case FUSE_FALLOCATE:
		return "FUSE_FALLOCATE";
	case FUSE_READDIRPLUS:
		return "FUSE_READDIRPLUS";
	case FUSE_RENAME2:
		return "FUSE_RENAME2";
	case FUSE_LSEEK:
		return "FUSE_LSEEK";
	case FUSE_COPY_FILE_RANGE:
		return "FUSE_COPY_FILE_RANGE";
	default:
		fuse_panic("Invalid opcode %d", op);
		break;
	}

	return NULL;
}