/*      $NetBSD: refuse.c,v 1.114 2022/01/22 08:09:39 pho Exp $ */

/*
 * Copyright © 2007 Alistair Crooks.  All rights reserved.
 * Copyright © 2007 Antti Kantee.  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.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior written
 *    permission.
 *
 * 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 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>
#if !defined(lint)
__RCSID("$NetBSD: refuse.c,v 1.114 2022/01/22 08:09:39 pho Exp $");
#endif /* !lint */

#include <sys/types.h>

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <fuse_internal.h>
#include <fuse_opt.h>
#include <paths.h>
#include <puffs.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#ifdef MULTITHREADED_REFUSE
#include <pthread.h>
#endif

typedef uint64_t         fuse_ino_t;

struct refuse_config {
        int debug;
        char *fsname;
};

#define REFUSE_OPT(t, p, v) \
        { t, offsetof(struct refuse_config, p), v }

static struct fuse_opt refuse_opts[] = {
        REFUSE_OPT("debug"    , debug , 1),
        REFUSE_OPT("fsname=%s", fsname, 0),
        FUSE_OPT_END
};

struct puffs_fuse_dirh {
        void *dbuf;
        struct dirent *d;

        size_t reslen;
        size_t bufsize;
};

struct refusenode {
        struct fuse_file_info   file_info;
        struct puffs_fuse_dirh  dirh;
        int opencount;
        int flags;
};
#define RN_ROOT         0x01
#define RN_OPEN         0x02    /* XXX: could just use opencount */

static int fuse_setattr(struct fuse *, struct puffs_node *,
                        const char *, const struct vattr *);

static struct puffs_node *
newrn(struct puffs_usermount *pu)
{
        struct puffs_node *pn;
        struct refusenode *rn;

        if ((rn = calloc(1, sizeof(*rn))) == NULL) {
                err(EXIT_FAILURE, "newrn");
        }
        pn = puffs_pn_new(pu, rn);

        return pn;
}

static void
nukern(struct puffs_node *pn)
{
        struct refusenode *rn = pn->pn_data;

        free(rn->dirh.dbuf);
        free(rn);
        puffs_pn_put(pn);
}

/* XXX - not threadsafe */
static ino_t fakeino = 3;

/***************** start of pthread context routines ************************/

/*
 * Notes on fuse_context:
 * we follow fuse's lead and use the pthread specific information to hold
 * a reference to the fuse_context structure for this thread.
 */
#ifdef MULTITHREADED_REFUSE
static pthread_mutex_t          context_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_key_t            context_key;
static unsigned long            context_refc;
#endif

/* return the fuse_context struct related to this thread */
struct fuse_context *
fuse_get_context(void)
{
#ifdef MULTITHREADED_REFUSE
        struct fuse_context     *ctxt;

        if ((ctxt = pthread_getspecific(context_key)) == NULL) {
                if ((ctxt = calloc(1, sizeof(struct fuse_context))) == NULL) {
                        abort();
                }
                pthread_setspecific(context_key, ctxt);
        }
        return ctxt;
#else
        static struct fuse_context      fcon;

        return &fcon;
#endif
}

/* used as a callback function */
#ifdef MULTITHREADED_REFUSE
static void
free_context(void *ctxt)
{   
        free(ctxt);
}
#endif

/*
 * Create the pthread key.  The reason for the complexity is to
 * enable use of multiple fuse instances within a single process.
 */
static int
create_context_key(void)
{   
#ifdef MULTITHREADED_REFUSE
        int rv;

        rv = pthread_mutex_lock(&context_mutex);
        assert(rv == 0);

        if (context_refc == 0) {
                if (pthread_key_create(&context_key, free_context) != 0) {
                        warnx("create_context_key: pthread_key_create failed");
                        pthread_mutex_unlock(&context_mutex);
                        return 0;
                }
        }
        context_refc += 1;
        pthread_mutex_unlock(&context_mutex);
        return 1;
#else
        return 1;
#endif
}

/* struct fuse_context is potentially reused among different
 * invocations of fuse_new() / fuse_destroy() pair. Clear its content
 * on fuse_destroy() so that no dangling pointers remain in the
 * context. */
static void
clear_context(void)
{
        struct fuse_context     *ctx;

        ctx = fuse_get_context();
        memset(ctx, 0, sizeof(*ctx));
}

static void
delete_context_key(void)
{   
#ifdef MULTITHREADED_REFUSE
        pthread_mutex_lock(&context_mutex);
        /* If we are the last fuse instances using the key, delete it */
        if (--context_refc == 0) {
                free(pthread_getspecific(context_key));
                pthread_key_delete(context_key);
        }
        pthread_mutex_unlock(&context_mutex);
#endif
}

/* set the uid and gid of the calling process in the current fuse context */
static void
set_fuse_context_uid_gid(const struct puffs_cred *cred)
{
        struct fuse_context     *fusectx;
        uid_t                    uid;
        gid_t                    gid;

        fusectx = fuse_get_context();
        if (puffs_cred_getuid(cred, &uid) == 0) {
                fusectx->uid = uid;
        }
        if (puffs_cred_getgid(cred, &gid) == 0) {
                fusectx->gid = gid;
        }
}

/* set the pid of the calling process in the current fuse context */
static void
set_fuse_context_pid(struct puffs_usermount *pu)
{
        struct puffs_cc         *pcc = puffs_cc_getcc(pu);
        struct fuse_context     *fusectx;

        fusectx = fuse_get_context();
        puffs_cc_getcaller(pcc, &fusectx->pid, NULL);
}

/***************** end of pthread context routines ************************/

#define DIR_CHUNKSIZE 4096
static int
fill_dirbuf(struct puffs_fuse_dirh *dh, const char *name, ino_t dino,
        uint8_t dtype)
{

        /* initial? */
        if (dh->bufsize == 0) {
                if ((dh->dbuf = calloc(1, DIR_CHUNKSIZE)) == NULL) {
                        abort();
                }
                dh->d = dh->dbuf;
                dh->reslen = dh->bufsize = DIR_CHUNKSIZE;
        }

        if (puffs_nextdent(&dh->d, name, dino, dtype, &dh->reslen)) {
                return 0;
        }

        /* try to increase buffer space */
        dh->dbuf = realloc(dh->dbuf, dh->bufsize + DIR_CHUNKSIZE);
        if (dh->dbuf == NULL) {
                abort();
        }
        dh->d = (void *)((uint8_t *)dh->dbuf + (dh->bufsize - dh->reslen));
        dh->reslen += DIR_CHUNKSIZE;
        dh->bufsize += DIR_CHUNKSIZE;

        return !puffs_nextdent(&dh->d, name, dino, dtype, &dh->reslen);
}

/* ARGSUSED3 */
/* XXX: I have no idea how "off" is supposed to be used */
static int
puffs_fuse_fill_dir(void *buf, const char *name,
        const struct stat *stbuf, off_t off, enum fuse_fill_dir_flags flags)
{
        struct puffs_fuse_dirh *deh = buf;
        ino_t dino;
        uint8_t dtype;

        if (stbuf == NULL) {
                dtype = DT_UNKNOWN;
                dino = fakeino++;
        } else {
                dtype = (uint8_t)puffs_vtype2dt(puffs_mode2vt(stbuf->st_mode));
                dino = stbuf->st_ino;

                /*
                 * Some FUSE file systems like to always use 0 as the
                 * inode number.   Our readdir() doesn't like to show
                 * directory entries with inode number 0 ==> workaround.
                 */
                if (dino == 0) {
                        dino = fakeino++;
                }
        }

        return fill_dirbuf(deh, name, dino, dtype);
}

/* ARGSUSED1 */
static int
fuse_getattr(struct fuse *fuse, struct puffs_node *pn, const char *path,
        struct vattr *va)
{
        struct refusenode       *rn = pn->pn_data;
        struct fuse_file_info   *fi = rn->opencount > 0 ? &rn->file_info : NULL;
        struct stat              st;
        int                     ret;

        /* wrap up return code */
        memset(&st, 0, sizeof(st));
        ret = fuse_fs_getattr_v30(fuse->fs, path, &st, fi);

        if (ret == 0) {
                if (st.st_blksize == 0)
                        st.st_blksize = DEV_BSIZE;
                puffs_stat2vattr(va, &st);
        }

        return -ret;
}

/* utility function to set various elements of the attribute */
static int
fuse_setattr(struct fuse *fuse, struct puffs_node *pn, const char *path,
        const struct vattr *va)
{
        struct refusenode       *rn = pn->pn_data;
        struct fuse_file_info   *fi = rn->opencount > 0 ? &rn->file_info : NULL;
        mode_t                  mode;
        uid_t                   uid;
        gid_t                   gid;
        int                     error, ret;

        error = 0;

        mode = va->va_mode;
        uid = va->va_uid;
        gid = va->va_gid;

        if (mode != (mode_t)PUFFS_VNOVAL) {
                ret = fuse_fs_chmod_v30(fuse->fs, path, mode, fi);
                if (ret)
                        error = ret;
        }
        if (uid != (uid_t)PUFFS_VNOVAL || gid != (gid_t)PUFFS_VNOVAL) {
                ret = fuse_fs_chown_v30(fuse->fs, path, uid, gid, fi);
                if (ret)
                        error = ret;
        }
        if (va->va_atime.tv_sec != (time_t)PUFFS_VNOVAL
                || va->va_mtime.tv_sec != (long)PUFFS_VNOVAL) {

                struct timespec tv[2];

                tv[0].tv_sec    = va->va_atime.tv_sec;
                tv[0].tv_nsec   = va->va_atime.tv_nsec;
                tv[1].tv_sec    = va->va_mtime.tv_sec;
                tv[1].tv_nsec   = va->va_mtime.tv_nsec;

                ret = fuse_fs_utimens_v30(fuse->fs, path, tv, fi);
                if (ret)
                        error = ret;
        }
        if (va->va_size != (u_quad_t)PUFFS_VNOVAL) {
                ret = fuse_fs_truncate_v30(fuse->fs, path, (off_t)va->va_size, fi);
                if (ret)
                        error = ret;
        }
        /* XXX: no reflection with reality */
        puffs_setvattr(&pn->pn_va, va);

        return -error;

}

static int
fuse_newnode(struct puffs_usermount *pu, const char *path,
        const struct vattr *va, struct fuse_file_info *fi,
        struct puffs_newinfo *pni, struct puffs_node **pn_new)
{
        struct puffs_node       *pn;
        struct refusenode       *rn;
        struct vattr             newva;
        struct fuse             *fuse;

        fuse = puffs_getspecific(pu);

        /* fix up nodes */
        pn = newrn(pu);
        if (pn == NULL) {
                if (va->va_type == VDIR) {
                        fuse_fs_rmdir(fuse->fs, path);
                } else {
                        fuse_fs_unlink(fuse->fs, path);
                }
                return ENOMEM;
        }
        fuse_setattr(fuse, pn, path, va);
        if (fuse_getattr(fuse, pn, path, &newva) == 0)
                puffs_setvattr(&pn->pn_va, &newva);

        rn = pn->pn_data;
        if (fi)
                memcpy(&rn->file_info, fi, sizeof(struct fuse_file_info));

        puffs_newinfo_setcookie(pni, pn);
        if (pn_new)
                *pn_new = pn;

        return 0;
}


/* operation wrappers start here */

/* lookup the path */
/* ARGSUSED1 */
static int
puffs_fuse_node_lookup(struct puffs_usermount *pu, void *opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn)
{
        struct puffs_node       *pn_res;
        struct stat              st;
        struct fuse             *fuse;
        const char              *path = PCNPATH(pcn);
        int                      ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        ret = fuse_fs_getattr_v30(fuse->fs, path, &st, NULL);
        if (ret != 0) {
                return -ret;
        }

        /* XXX: fiXXXme unconst */
        pn_res = puffs_pn_nodewalk(pu, puffs_path_walkcmp,
            __UNCONST(&pcn->pcn_po_full));
        if (pn_res == NULL) {
                pn_res = newrn(pu);
                if (pn_res == NULL)
                        return errno;
                puffs_stat2vattr(&pn_res->pn_va, &st);
        }

        puffs_newinfo_setcookie(pni, pn_res);
        puffs_newinfo_setvtype(pni, pn_res->pn_va.va_type);
        puffs_newinfo_setsize(pni, (voff_t)pn_res->pn_va.va_size);
        puffs_newinfo_setrdev(pni, pn_res->pn_va.va_rdev);

        return 0;
}

/* get attributes for the path name */
/* ARGSUSED3 */
static int
puffs_fuse_node_getattr(struct puffs_usermount *pu, void *opc, struct vattr *va,
        const struct puffs_cred *pcr) 
{
        struct puffs_node       *pn = opc;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn);

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcr);

        return fuse_getattr(fuse, pn, path, va);
}

/* read the contents of the symbolic link */
/* ARGSUSED2 */
static int
puffs_fuse_node_readlink(struct puffs_usermount *pu, void *opc,
        const struct puffs_cred *cred, char *linkname, size_t *linklen)
{
        struct puffs_node       *pn = opc;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn), *p;
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(cred);

        /* wrap up return code */
        ret = fuse_fs_readlink(fuse->fs, path, linkname, *linklen);

        if (ret == 0) {
                p = memchr(linkname, '\0', *linklen);
                if (!p)
                        return EINVAL;

                *linklen = (size_t)(p - linkname);
        }

        return -ret;
}

/* make the special node */
/* ARGSUSED1 */
static int
puffs_fuse_node_mknod(struct puffs_usermount *pu, void *opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn,
        const struct vattr *va)
{
        struct fuse             *fuse;
        mode_t                   mode;
        const char              *path = PCNPATH(pcn);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        /* wrap up return code */
        mode = puffs_addvtype2mode(va->va_mode, va->va_type);
        ret = fuse_fs_mknod(fuse->fs, path, mode, va->va_rdev);

        if (ret == 0) {
                ret = fuse_newnode(pu, path, va, NULL, pni, NULL);
        }

        return -ret;
}

/* make a directory */
/* ARGSUSED1 */
static int
puffs_fuse_node_mkdir(struct puffs_usermount *pu, void *opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn,
        const struct vattr *va)
{
        struct fuse             *fuse;
        mode_t                   mode = va->va_mode;
        const char              *path = PCNPATH(pcn);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        /* wrap up return code */
        ret = fuse_fs_mkdir(fuse->fs, path, mode);

        if (ret == 0) {
                ret = fuse_newnode(pu, path, va, NULL, pni, NULL);
        }

        return -ret;
}

/*
 * create a regular file
 *
 * since linux/fuse sports using mknod for creating regular files
 * instead of having a separate call for it in some versions, if
 * we don't have create, just jump to op->mknod.
 */
/*ARGSUSED1*/
static int
puffs_fuse_node_create(struct puffs_usermount *pu, void *opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn,
        const struct vattr *va)
{
        struct fuse             *fuse;
        struct fuse_file_info   fi;
        struct puffs_node       *pn;
        mode_t                  mode = va->va_mode;
        const char              *path = PCNPATH(pcn);
        int                     ret, created;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        memset(&fi, 0, sizeof(fi));
        /* In puffs "create" and "open" are two separate operations
         * with atomicity achieved by locking the parent vnode. In
         * fuse, on the other hand, "create" is actually a
         * create-and-open-atomically and the open flags (O_RDWR,
         * O_APPEND, ...) are passed via fi.flags. So the only way to
         * emulate the fuse semantics is to open the file with dummy
         * flags and then immediately close it.
         *
         * You might think that we could simply use fuse->op.mknod all
         * the time but no, that's not possible because most file
         * systems nowadays expect op.mknod to be called only for
         * non-regular files and many don't even support it. */
        created = 0;
        fi.flags = O_WRONLY | O_CREAT | O_EXCL;
        ret = fuse_fs_create(fuse->fs, path, mode | S_IFREG, &fi);
        if (ret == 0) {
                created = 1;
        }
        else if (ret == -ENOSYS) {
                ret = fuse_fs_mknod(fuse->fs, path, mode | S_IFREG, 0);
        }

        if (ret == 0) {
                ret = fuse_newnode(pu, path, va, &fi, pni, &pn);

                /* sweet..  create also open the file */
                if (created) {
                        struct refusenode *rn = pn->pn_data;
                        /* The return value of op.release is expected to be
                         * discarded. */
                        (void)fuse_fs_release(fuse->fs, path, &rn->file_info);
                }
        }

        return -ret;
}

/* remove the directory entry */
/* ARGSUSED1 */
static int
puffs_fuse_node_remove(struct puffs_usermount *pu, void *opc, void *targ,
        const struct puffs_cn *pcn)
{
        struct puffs_node       *pn_targ = targ;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn_targ);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        /* wrap up return code */
        ret = fuse_fs_unlink(fuse->fs, path);

        return -ret;
}

/* remove the directory */
/* ARGSUSED1 */
static int
puffs_fuse_node_rmdir(struct puffs_usermount *pu, void *opc, void *targ,
        const struct puffs_cn *pcn)
{
        struct puffs_node       *pn_targ = targ;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn_targ);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        /* wrap up return code */
        ret = fuse_fs_rmdir(fuse->fs, path);

        return -ret;
}

/* create a symbolic link */
/* ARGSUSED1 */
static int
puffs_fuse_node_symlink(struct puffs_usermount *pu, void *opc,
        struct puffs_newinfo *pni, const struct puffs_cn *pcn_src,
        const struct vattr *va, const char *link_target)
{
        struct fuse             *fuse;
        const char              *path = PCNPATH(pcn_src);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn_src->pcn_cred);

        /* wrap up return code */
        ret = fuse_fs_symlink(fuse->fs, link_target, path);

        if (ret == 0) {
                ret = fuse_newnode(pu, path, va, NULL, pni, NULL);
        }

        return -ret;
}

/* rename a directory entry */
/* ARGSUSED1 */
static int
puffs_fuse_node_rename(struct puffs_usermount *pu, void *opc, void *src,
        const struct puffs_cn *pcn_src, void *targ_dir, void *targ,
        const struct puffs_cn *pcn_targ)
{
        struct fuse             *fuse;
        const char              *path_src = PCNPATH(pcn_src);
        const char              *path_dest = PCNPATH(pcn_targ);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn_targ->pcn_cred);

        ret = fuse_fs_rename_v30(fuse->fs, path_src, path_dest, 0);

        return -ret;
}

/* create a link in the file system */
/* ARGSUSED1 */
static int
puffs_fuse_node_link(struct puffs_usermount *pu, void *opc, void *targ,
        const struct puffs_cn *pcn)
{
        struct puffs_node       *pn = targ;
        struct fuse             *fuse;
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcn->pcn_cred);

        /* wrap up return code */
        ret = fuse_fs_link(fuse->fs, PNPATH(pn), PCNPATH(pcn));

        return -ret;
}

/*
 * fuse's regular interface provides chmod(), chown(), utimes()
 * and truncate() + some variations, so try to fit the square block
 * in the circle hole and the circle block .... something like that
 */
/* ARGSUSED3 */
static int
puffs_fuse_node_setattr(struct puffs_usermount *pu, void *opc,
        const struct vattr *va, const struct puffs_cred *pcr)
{
        struct puffs_node       *pn = opc;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn);

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcr);

        return fuse_setattr(fuse, pn, path, va);
}

static int
puffs_fuse_node_pathconf(struct puffs_usermount *pu, void *opc,
        int name, __register_t *retval)
{
        /* Returning EINVAL for pathconf(2) means that this filesystem
         * does not support an association of the given name with the
         * file. This is necessary because the default error code
         * returned by the puffs kernel module (ENOTSUPP) is not
         * suitable for an errno from pathconf(2), and "ls -l"
         * complains about it. */
        return EINVAL;
}

/* ARGSUSED2 */
static int
puffs_fuse_node_open(struct puffs_usermount *pu, void *opc, int mode,
        const struct puffs_cred *cred)
{
        struct puffs_node       *pn = opc;
        struct refusenode       *rn = pn->pn_data;
        struct fuse_file_info   *fi = &rn->file_info;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(cred);

        /* if open, don't open again, lest risk nuking file private info */
        if (rn->flags & RN_OPEN) {
                rn->opencount++;
                return 0;
        }

        /* OFLAGS(), need to convert FREAD/FWRITE to O_RD/WR */
        fi->flags = (mode & ~(O_CREAT | O_EXCL | O_TRUNC)) - 1;

        if (pn->pn_va.va_type == VDIR) {
                ret = fuse_fs_opendir(fuse->fs, path, fi);
        } else {
                ret = fuse_fs_open(fuse->fs, path, fi);
        }

        if (ret == 0) {
                rn->flags |= RN_OPEN;
                rn->opencount++;
        }

        return -ret;
}

/* ARGSUSED2 */
static int
puffs_fuse_node_close(struct puffs_usermount *pu, void *opc, int fflag,
        const struct puffs_cred *pcr)
{
        struct puffs_node       *pn = opc;
        struct refusenode       *rn = pn->pn_data;
        struct fuse             *fuse;
        struct fuse_file_info   *fi;
        const char              *path = PNPATH(pn);
        int                     ret;

        fuse = puffs_getspecific(pu);
        fi = &rn->file_info;
        ret = 0;

        set_fuse_context_uid_gid(pcr);

        if (rn->flags & RN_OPEN) {
                if (pn->pn_va.va_type == VDIR) {
                        ret = fuse_fs_releasedir(fuse->fs, path, fi);
                } else {
                        ret = fuse_fs_release(fuse->fs, path, fi);
                }
        }
        rn->flags &= ~RN_OPEN;
        rn->opencount--;

        return ret;
}

/* read some more from the file */
/* ARGSUSED5 */
static int
puffs_fuse_node_read(struct puffs_usermount *pu, void *opc, uint8_t *buf,
        off_t offset, size_t *resid, const struct puffs_cred *pcr,
        int ioflag)
{
        struct puffs_node       *pn = opc;
        struct refusenode       *rn = pn->pn_data;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn);
        size_t                  maxread;
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcr);

        maxread = *resid;
        if (maxread > (size_t)((off_t)pn->pn_va.va_size - offset)) {
                /*LINTED*/
                maxread = (size_t)((off_t)pn->pn_va.va_size - offset);
        }
        if (maxread == 0)
                return 0;

        ret = fuse_fs_read(fuse->fs, path, (char *)buf, maxread, offset,
                           &rn->file_info);

        if (ret > 0) {
                *resid -= (size_t)ret;
                ret = 0;
        }

        return -ret;
}

/* write to the file */
/* ARGSUSED0 */
static int
puffs_fuse_node_write(struct puffs_usermount *pu, void *opc, uint8_t *buf,
        off_t offset, size_t *resid, const struct puffs_cred *pcr,
        int ioflag)
{
        struct puffs_node       *pn = opc;
        struct refusenode       *rn = pn->pn_data;
        struct fuse             *fuse;
        const char              *path = PNPATH(pn);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcr);

        if (ioflag & PUFFS_IO_APPEND)
                offset = (off_t)pn->pn_va.va_size;

        ret = fuse_fs_write(fuse->fs, path, (char *)buf, *resid, offset,
                            &rn->file_info);

        if (ret >= 0) {
                if ((uint64_t)(offset + ret) > pn->pn_va.va_size)
                        pn->pn_va.va_size = (u_quad_t)(offset + ret);
                *resid -= (size_t)ret;
                ret = (*resid == 0) ? 0 : ENOSPC;
        } else {
                ret = -ret;
        }

        return ret;
}


/* ARGSUSED3 */
static int
puffs_fuse_node_readdir(struct puffs_usermount *pu, void *opc,
        struct dirent *dent, off_t *readoff, size_t *reslen,
        const struct puffs_cred *pcr, int *eofflag,
        off_t *cookies, size_t *ncookies)
{
        struct puffs_node       *pn = opc;
        struct refusenode       *rn = pn->pn_data;
        struct puffs_fuse_dirh  *dirh;
        struct fuse             *fuse;
        struct dirent           *fromdent;
        const char              *path = PNPATH(pn);
        int                     ret;

        fuse = puffs_getspecific(pu);

        set_fuse_context_uid_gid(pcr);

        if (pn->pn_va.va_type != VDIR)
                return ENOTDIR;

        dirh = &rn->dirh;

        /*
         * if we are starting from the beginning, slurp entire directory
         * into our buffers
         */
        if (*readoff == 0) {
                /* free old buffers */
                free(dirh->dbuf);
                memset(dirh, 0, sizeof(struct puffs_fuse_dirh));

                ret = fuse_fs_readdir_v30(
                        fuse->fs, path, dirh, puffs_fuse_fill_dir,
                        0, &rn->file_info, (enum fuse_readdir_flags)0);

                if (ret)
                        return -ret;
        }

        /* Both op.readdir and op.getdir read full directory */
        *eofflag = 1;

        /* now, stuff results into the kernel buffers */
        while (*readoff < (off_t)(dirh->bufsize - dirh->reslen)) {
                /*LINTED*/
                fromdent = (struct dirent *)((uint8_t *)dirh->dbuf + *readoff);

                if (*reslen < _DIRENT_SIZE(fromdent))
                        break;

                memcpy(dent, fromdent, _DIRENT_SIZE(fromdent));
                *readoff += (off_t)_DIRENT_SIZE(fromdent);
                *reslen -= _DIRENT_SIZE(fromdent);

                dent = _DIRENT_NEXT(dent);
        }

        return 0;
}

/* ARGSUSED */
static int
puffs_fuse_node_reclaim(struct puffs_usermount *pu, void *opc)
{
        struct puffs_node       *pn = opc;

        nukern(pn);
        return 0;
}

/* ARGSUSED1 */
static int
puffs_fuse_fs_unmount(struct puffs_usermount *pu, int flags)
{
        struct fuse             *fuse;

        fuse = puffs_getspecific(pu);
        fuse_fs_destroy(fuse->fs);
        return 0;
}

/* ARGSUSED0 */
static int
puffs_fuse_fs_sync(struct puffs_usermount *pu, int flags,
            const struct puffs_cred *cr)
{
        set_fuse_context_uid_gid(cr);
        return 0;
}

/* ARGSUSED2 */
static int
puffs_fuse_fs_statvfs(struct puffs_usermount *pu, struct puffs_statvfs *svfsb)
{
        struct fuse             *fuse;
        int                     ret;
        struct statvfs          sb;

        /* fuse_fs_statfs() is special: it returns 0 even if the
         * filesystem doesn't support statfs. So clear the struct
         * before calling it. */
        memset(&sb, 0, sizeof(sb));

        fuse = puffs_getspecific(pu);
        ret = fuse_fs_statfs(fuse->fs, PNPATH(puffs_getroot(pu)), &sb);

        if (ret == 0)
                statvfs_to_puffs_statvfs(&sb, svfsb);

        return -ret;
}

/* End of puffs_fuse operations */

struct fuse *
__fuse_setup(int argc, char* argv[],
             const void* op, int op_version, void* user_data,
             struct fuse_cmdline_opts* opts)
{
        struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
        struct fuse *fuse = NULL;

        /* parse low-level options */
        if (fuse_parse_cmdline_v30(&args, opts) != 0)
                return NULL;

        if (opts->show_version) {
                fuse_lowlevel_version();
                goto free_args;
        }

        if (opts->show_help) {
                switch (opts->show_help) {
                case REFUSE_SHOW_HELP_FULL:
                        if (args.argv[0] != NULL && args.argv[0][0] != '\0') {
                                /* argv[0] being empty means that the application doesn't
                                 * want us to print the usage string.
                                 */
                                printf("Usage: %s [options] mountpoint\n\n", args.argv[0]);
                        }
                        break;
                case REFUSE_SHOW_HELP_NO_HEADER:
                        break;
                }
                fuse_cmdline_help();
                goto free_args;
        }

        if (opts->mountpoint == NULL) {
                fprintf(stderr, "fuse: no mountpoint specified\n");
                goto free_args;
        }

        if (opts->debug) {
                if (fuse_opt_add_arg(&args, "-odebug") != 0)
                        goto free_args;
        }

        fuse = __fuse_new(&args, op, op_version, user_data);
        if (fuse == NULL)
                goto free_args;

        if (fuse_daemonize(opts->foreground) != 0)
                goto destroy;

        if (fuse_mount_v30(fuse, opts->mountpoint) != 0)
                goto destroy;

        if (__fuse_set_signal_handlers(fuse) != 0) {
                warn("%s: Failed to set signal handlers", __func__);
                goto destroy;
        }

        goto done;

destroy:
        fuse_destroy_v30(fuse);
        fuse = NULL;
free_args:
        free(opts->mountpoint);
done:
        fuse_opt_free_args(&args);
        return fuse;
}

void
__fuse_teardown(struct fuse* fuse)
{
        if (__fuse_remove_signal_handlers(fuse) != 0)
                warn("%s: Failed to restore signal handlers", __func__);

        fuse_unmount_v30(fuse);
}

/* ARGSUSED3 */
int
__fuse_main(int argc, char **argv, const void *op,
        int op_version, void *user_data)
{
        struct fuse_cmdline_opts opts;
        struct fuse *fuse;
        int rv;

        fuse = __fuse_setup(argc, argv, op, op_version, user_data, &opts);
        if (fuse == NULL)
                return -1;

        rv = fuse_loop(fuse);

        __fuse_teardown(fuse);

        free(opts.mountpoint);
        return rv;
}

int __fuse_mount(struct fuse *fuse, const char *mountpoint)
{
        struct puffs_pathobj    *po_root;
        struct puffs_node       *pn_root;
        struct refusenode       *rn_root;
        struct puffs_statvfs     svfsb;

        pn_root = newrn(fuse->pu);
        puffs_setroot(fuse->pu, pn_root);
        rn_root = pn_root->pn_data;
        rn_root->flags |= RN_ROOT;

        po_root = puffs_getrootpathobj(fuse->pu);
        if ((po_root->po_path = strdup("/")) == NULL)
                err(1, "fuse_mount");
        po_root->po_len = 1;
        puffs_path_buildhash(fuse->pu, po_root);

        /* sane defaults */
        puffs_vattr_null(&pn_root->pn_va);
        pn_root->pn_va.va_type = VDIR;
        pn_root->pn_va.va_mode = 0755;
        /* It might be tempting to call op.getattr("/") here to
         * populate pn_root->pa_va, but that would mean invoking an
         * operation callback without initializing the filesystem. We
         * cannot call op.init() either, because that is supposed to
         * be called right before entering the main loop. */

        puffs_set_prepost(fuse->pu, set_fuse_context_pid, NULL);

        puffs_zerostatvfs(&svfsb);
        if (puffs_mount(fuse->pu, mountpoint, MNT_NODEV | MNT_NOSUID, pn_root) == -1) {
                err(EXIT_FAILURE, "puffs_mount: directory \"%s\"", mountpoint);
        }

        return 0;
}

int fuse_daemonize(int foreground)
{
        /* There is an impedance mismatch here: FUSE wants to
         * daemonize the process without any contexts but puffs wants
         * one. */
        struct fuse *fuse = fuse_get_context()->fuse;

        if (!fuse)
                /* FUSE would probably allow this, but we cannot. */
                errx(EXIT_FAILURE,
                     "%s: librefuse doesn't allow calling"
                     " this function before fuse_new().", __func__);

        if (!foreground)
                return puffs_daemon(fuse->pu, 0, 0);

        return 0;
}

struct fuse *
__fuse_new(struct fuse_args *args, const void *op, int op_version, void* user_data)
{
        struct refuse_config    config;
        struct puffs_usermount  *pu;
        struct fuse_context     *fusectx;
        struct puffs_ops        *pops;
        struct fuse             *fuse;
        uint32_t                puffs_flags;

        /* parse refuse options */
        memset(&config, 0, sizeof(config));
        if (fuse_opt_parse(args, &config, refuse_opts, NULL) == -1)
                return NULL;

        if ((fuse = calloc(1, sizeof(*fuse))) == NULL) {
                err(EXIT_FAILURE, "fuse_new");
        }

        /* grab the pthread context key */
        if (!create_context_key()) {
                free(config.fsname);
                free(fuse);
                return NULL;
        }

        /* Create the base filesystem layer. */
        fuse->fs = __fuse_fs_new(op, op_version, user_data);

        fusectx = fuse_get_context();
        fusectx->fuse = fuse;
        fusectx->uid = 0;
        fusectx->gid = 0;
        fusectx->pid = 0;
        fusectx->private_data = user_data;

        /* initialise the puffs operations structure */
        PUFFSOP_INIT(pops);

        PUFFSOP_SET(pops, puffs_fuse, fs, sync);
        PUFFSOP_SET(pops, puffs_fuse, fs, statvfs);
        PUFFSOP_SET(pops, puffs_fuse, fs, unmount);

        /*
         * XXX: all of these don't possibly need to be
         * unconditionally set
         */
        PUFFSOP_SET(pops, puffs_fuse, node, lookup);
        PUFFSOP_SET(pops, puffs_fuse, node, getattr);
        PUFFSOP_SET(pops, puffs_fuse, node, setattr);
        PUFFSOP_SET(pops, puffs_fuse, node, pathconf);
        PUFFSOP_SET(pops, puffs_fuse, node, readdir);
        PUFFSOP_SET(pops, puffs_fuse, node, readlink);
        PUFFSOP_SET(pops, puffs_fuse, node, mknod);
        PUFFSOP_SET(pops, puffs_fuse, node, create);
        PUFFSOP_SET(pops, puffs_fuse, node, remove);
        PUFFSOP_SET(pops, puffs_fuse, node, mkdir);
        PUFFSOP_SET(pops, puffs_fuse, node, rmdir);
        PUFFSOP_SET(pops, puffs_fuse, node, symlink);
        PUFFSOP_SET(pops, puffs_fuse, node, rename);
        PUFFSOP_SET(pops, puffs_fuse, node, link);
        PUFFSOP_SET(pops, puffs_fuse, node, open);
        PUFFSOP_SET(pops, puffs_fuse, node, close);
        PUFFSOP_SET(pops, puffs_fuse, node, read);
        PUFFSOP_SET(pops, puffs_fuse, node, write);
        PUFFSOP_SET(pops, puffs_fuse, node, reclaim);

        puffs_flags = PUFFS_FLAG_BUILDPATH
                | PUFFS_FLAG_HASHPATH
                | PUFFS_KFLAG_NOCACHE;
        if (config.debug)
                puffs_flags |= PUFFS_FLAG_OPDUMP;

        pu = puffs_init(pops, _PATH_PUFFS, config.fsname, fuse, puffs_flags);
        if (pu == NULL) {
                err(EXIT_FAILURE, "puffs_init");
        }
        fuse->pu = pu;

        free(config.fsname);
        return fuse;
}

int
fuse_loop(struct fuse *fuse)
{
        struct fuse_conn_info conn;
        struct fuse_config cfg;

        /* struct fuse_conn_info is a part of the FUSE API so we must
         * expose it to users, but we currently don't use them at
         * all. The same goes for struct fuse_config. */
        memset(&conn, 0, sizeof(conn));
        memset(&cfg, 0, sizeof(cfg));

        fuse_fs_init_v30(fuse->fs, &conn, &cfg);

        return puffs_mainloop(fuse->pu);
}

int
__fuse_loop_mt(struct fuse *fuse,
               struct fuse_loop_config *config __attribute__((__unused__)))
{
        /* TODO: Implement a proper multi-threaded loop. */
        return fuse_loop(fuse);
}

void
__fuse_destroy(struct fuse *fuse)
{

        /*
         * TODO: needs to assert the fs is quiescent, i.e. no other
         * threads exist
         */

        clear_context();
        delete_context_key();
        /* XXXXXX: missing stuff */
        free(fuse);
}

void
fuse_exit(struct fuse *fuse)
{
        /* XXX: puffs_exit() is WRONG */
        if (fuse->dead == 0)
                puffs_exit(fuse->pu, 1);
        fuse->dead = 1;
}

/*
 * XXX: obviously not the most perfect of functions, but needs some
 * puffs tweaking for a better tomorrow
 */
void
__fuse_unmount(struct fuse *fuse)
{
        /* XXX: puffs_exit() is WRONG */
        if (fuse->dead == 0)
                puffs_exit(fuse->pu, 1);
        fuse->dead = 1;
}

void
fuse_lib_help(struct fuse_args *args __attribute__((__unused__)))
{
        fuse_cmdline_help();
}

int
fuse_interrupted(void)
{
        /* ReFUSE doesn't support request interruption at the
         * moment. */
        return 0;
}

int
fuse_invalidate_path(struct fuse *fuse __attribute__((__unused__)),
                     const char *path __attribute__((__unused__)))
{
    /* ReFUSE doesn't cache anything at the moment. No need to do
     * anything. */
    return -ENOENT;
}

int
fuse_version(void)
{
        return _REFUSE_VERSION_;
}

const char *
fuse_pkgversion(void)
{
        return "ReFUSE " ___STRING(_REFUSE_MAJOR_VERSION_)
                "." ___STRING(_REFUSE_MINOR_VERSION_);
}

int
fuse_getgroups(int size, gid_t list[])
{
        /* XXX: In order to implement this, we need to save a pointer
         * to struct puffs_cred in struct fuse upon entering a puffs
         * callback, and set it back to NULL upon leaving it. Then we
         * can use puffs_cred_getgroups(3) here. */
        return -ENOSYS;
}

int
fuse_start_cleanup_thread(struct fuse *fuse)
{
        /* XXX: ReFUSE doesn't support -oremember at the moment. */
        return 0;
}

void
fuse_stop_cleanup_thread(struct fuse *fuse) {
        /* XXX: ReFUSE doesn't support -oremember at the moment. */
}

int
fuse_clean_cache(struct fuse *fuse) {
        /* XXX: ReFUSE doesn't support -oremember at the moment. */
        return 3600;
}

/* This is a legacy function that has been removed from the FUSE API,
 * but is defined here because it needs to access refuse_opts. */
int
fuse_is_lib_option(const char *opt)
{
        return fuse_opt_match(refuse_opts, opt);
}