/*      $NetBSD: rump_cygwin_compat.c,v 1.3 2019/01/27 02:08:49 pgoyette Exp $  */

/*
 * Copyright (c) 2013 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.
 *
 * 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>
__KERNEL_RCSID(0, "$NetBSD: rump_cygwin_compat.c,v 1.3 2019/01/27 02:08:49 pgoyette Exp $");

#include <sys/param.h>
#include <sys/dirent.h>
#include <sys/fcntl.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/malloc.h>
#include <sys/namei.h>
#include <sys/stat.h>
#include <sys/syscallargs.h>
#include <sys/vnode.h>
#include <sys/vfs_syscalls.h>

#include <compat/sys/time_types.h>

#include "rump_cygwin_syscallargs.h"

struct cygwin_stat {
        int             st_dev;
        int64_t         st_ino;
        int             st_mode;
        unsigned short  st_nlink;
        int             st_uid;
        int             st_gid;
        int             st_rdev;
        off_t           st_size;

        struct timespec50 st_atim;
        struct timespec50 st_mtim;
        struct timespec50 st_ctim;

        long            st_blksize;
        uint64_t        st_blocks;

        struct timespec50 st_btim;
};

#define PARCOPY(a) ssb->a = sb->a
static void
bsd_to_cygwin_stat(const struct stat *sb, struct cygwin_stat *ssb)
{

        memset(ssb, 0, sizeof(*ssb));
        PARCOPY(st_dev);
        PARCOPY(st_ino);
        PARCOPY(st_mode);
        PARCOPY(st_nlink);
        PARCOPY(st_uid);
        PARCOPY(st_gid);
        PARCOPY(st_rdev);
        PARCOPY(st_size);
        PARCOPY(st_blksize);
        PARCOPY(st_blocks);

        timespec_to_timespec50(&sb->st_atimespec, &ssb->st_atim);
        timespec_to_timespec50(&sb->st_mtimespec, &ssb->st_mtim);
        timespec_to_timespec50(&sb->st_ctimespec, &ssb->st_ctim);
        timespec_to_timespec50(&sb->st_birthtimespec, &ssb->st_btim);
}

int
rump_cygwin_sys_stat(struct lwp *l, const struct rump_cygwin_sys_stat_args *uap,
        register_t *retval)
{
        struct cygwin_stat ssb;
        struct stat sb;
        int error;

        error = do_sys_stat(SCARG(uap, path), FOLLOW, &sb);
        if (error)
                return error;

        bsd_to_cygwin_stat(&sb, &ssb);

        return copyout(&ssb, SCARG(uap, sp), sizeof(ssb));
}

int
rump_cygwin_sys_fstat(struct lwp *l, const struct rump_cygwin_sys_fstat_args *uap,
        register_t *retval)
{
        struct cygwin_stat ssb;
        struct stat sb;
        int error;

        error = do_sys_fstat(SCARG(uap, fd), &sb);
        if (error)
                return error;

        bsd_to_cygwin_stat(&sb, &ssb);

        return copyout(&ssb, SCARG(uap, sp), sizeof(ssb));
}

int
rump_cygwin_sys_lstat(struct lwp *l, const struct rump_cygwin_sys_lstat_args *uap,
        register_t *retval)
{
        struct cygwin_stat ssb;
        struct stat sb;
        int error;

        error = do_sys_stat(SCARG(uap, path), NOFOLLOW, &sb);
        if (error)
                return error;

        bsd_to_cygwin_stat(&sb, &ssb);

        return copyout(&ssb, SCARG(uap, sp), sizeof(ssb));
}

int
rump_cygwin_sys_open(struct lwp *l, const struct rump_cygwin_sys_open_args *uap,
        register_t *retval)
{
        /* {
                syscallarg(const char *) path;
                syscallarg(int) flags;
                syscallarg(int) mode;
        } */
        struct sys_open_args ua;
        int sflags, flags;

        sflags = SCARG(uap, flags);
        flags = sflags & (3 | O_APPEND | O_ASYNC | O_CREAT | O_TRUNC | O_EXCL);
        
        SCARG(&ua, path) = SCARG(uap, path);
        SCARG(&ua, flags) = flags;
        SCARG(&ua, mode) = SCARG(uap, mode);

        return sys_open(l, &ua, retval);
}

#define CYGWIN_NAME_MAX 255
struct cygwin_dirent {
        long            d_version;
        int64_t         d_ino;
        unsigned char   d_type;
        unsigned char   d_unused[3];
        uint32_t        d_internal;
        char            d_name[CYGWIN_NAME_MAX + 1];
} __packed;

#define CYGWIN_NAMEOFF(dp)         offsetof(struct cygwin_dirent,d_name)
#define CYGWIN_RECLEN(dp, namlen)  ((CYGWIN_NAMEOFF(dp) + (namlen) + 1))

int
rump_cygwin_sys_getdents(struct lwp *l,
        const struct rump_cygwin_sys_getdents_args *uap, register_t *retval)
{
        struct file *fp;
        struct dirent *bdp;
        struct cygwin_dirent idb;
        char *buf, *inp, *outp;
        size_t resid, buflen, nbytes;
        size_t reclen, cygwin_reclen;
        int error, done;

        if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
                return (error);

        /*
         * Sneaky, but avoids having "rewind" f_offset due to the
         * conversions not fitting from our intermediate kernel buffer
         * into the user buffer
         */
        nbytes = SCARG(uap, nbytes);
        buflen = min(MAXBSIZE, (nbytes*8)/10);
        buf = kmem_alloc(buflen, KM_SLEEP);

        if ((fp->f_flag & FREAD) == 0) {
                error = EBADF;
                goto out;
        }

        resid = nbytes;
        outp = SCARG(uap, buf);

 again:
        if ((error = vn_readdir(fp, buf, UIO_SYSSPACE, buflen, &done,
            l, NULL, NULL)) != 0)
                goto out;
        if (done == 0)
                goto eof;

        for (inp = buf; done > 0; done -= reclen) {
                bdp = (struct dirent *)inp;
                reclen = bdp->d_reclen;

                /* skip empty entries */
                if (bdp->d_fileno == 0) {
                        inp += reclen;
                        continue;
                }

                cygwin_reclen = CYGWIN_RECLEN(&idb, bdp->d_namlen);
                if (resid < cygwin_reclen) {
                        panic("impossible shortage of resid");
                }

                memset(&idb, 0, sizeof(idb));
                idb.d_ino = bdp->d_fileno;
                idb.d_type = bdp->d_type;
                strlcpy(idb.d_name, bdp->d_name, sizeof(idb.d_name));
                if ((error = copyout(&idb, outp, cygwin_reclen)) != 0)
                        goto out;

                inp += reclen;
                outp += cygwin_reclen;
                resid -= cygwin_reclen;
        }

        /* if we squished out the whole block, try again */
        if (outp == SCARG(uap, buf)) {
                goto again;
        }

 eof:
        *retval = nbytes - resid;
 out:
        kmem_free(buf, buflen);
        fd_putfile(SCARG(uap, fd));

        return (error);
}