/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
/*        All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

#include <sys/param.h>
#include <sys/isa_defs.h>
#include <sys/types.h>
#include <sys/inttypes.h>
#include <sys/sysmacros.h>
#include <sys/cred.h>
#include <sys/dirent.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/vnode.h>
#include <sys/file.h>
#include <sys/mode.h>
#include <sys/uio.h>
#include <sys/filio.h>
#include <sys/debug.h>
#include <sys/kmem.h>
#include <sys/cmn_err.h>

#if defined(_SYSCALL32_IMPL) || defined(_ILP32)

/*
 * Get directory entries in a file system-independent format.
 *
 * The 32-bit version of this function now allocates a buffer to grab the
 * directory entries in dirent64 formats from VOP_READDIR routines.
 * The dirent64 structures are converted to dirent32 structures and
 * copied to the user space.
 *
 * Both 32-bit and 64-bit versions of libc use getdents64() and therefore
 * we don't expect any major performance impact due to the extra kmem_alloc's
 * and copying done in this routine.
 */

/*
 * Native 32-bit system call for non-large-file applications.
 */
int
getdents32(int fd, void *buf, size_t count)
{
        vnode_t *vp;
        file_t *fp;
        struct uio auio;
        struct iovec aiov;
        register int error;
        int sink;
        char *newbuf;
        char *obuf;
        int bufsize;
        int osize, nsize;
        struct dirent64 *dp;
        struct dirent32 *op;

        if (count < sizeof (struct dirent32))
                return (set_errno(EINVAL));

        if ((fp = getf(fd)) == NULL)
                return (set_errno(EBADF));
        vp = fp->f_vnode;
        if (vp->v_type != VDIR) {
                releasef(fd);
                return (set_errno(ENOTDIR));
        }
        if (!(fp->f_flag & FREAD)) {
                releasef(fd);
                return (set_errno(EBADF));
        }

        /*
         * Don't let the user overcommit kernel resources.
         */
        if (count > MAXGETDENTS_SIZE)
                count = MAXGETDENTS_SIZE;

        bufsize = count;
        newbuf = kmem_alloc(bufsize, KM_SLEEP);
        obuf = kmem_alloc(bufsize, KM_SLEEP);

        aiov.iov_base = newbuf;
        aiov.iov_len = count;
        auio.uio_iov = &aiov;
        auio.uio_iovcnt = 1;
        auio.uio_loffset = fp->f_offset;
        auio.uio_segflg = UIO_SYSSPACE;
        auio.uio_resid = count;
        auio.uio_fmode = 0;
        auio.uio_extflg = UIO_COPY_CACHED;
        (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
        error = VOP_READDIR(vp, &auio, fp->f_cred, &sink, NULL, 0);
        VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
        if (error)
                goto out;
        count = count - auio.uio_resid;
        fp->f_offset = auio.uio_loffset;

        dp = (struct dirent64 *)newbuf;
        op = (struct dirent32 *)obuf;
        osize = 0;
        nsize = 0;

        while (nsize < count) {
                uint32_t reclen, namlen;

                /*
                 * This check ensures that the 64 bit d_ino and d_off
                 * fields will fit into their 32 bit equivalents.
                 *
                 * Although d_off is a signed value, the check is done
                 * against the full 32 bits because certain file systems,
                 * NFS for one, allow directory cookies to use the full
                 * 32 bits.  We use uint64_t because there is no exact
                 * unsigned analog to the off64_t type of dp->d_off.
                 */
                if (dp->d_ino > (ino64_t)UINT32_MAX ||
                    dp->d_off > (uint64_t)UINT32_MAX) {
                        error = EOVERFLOW;
                        goto out;
                }
                op->d_ino = (ino32_t)dp->d_ino;
                op->d_off = (off32_t)dp->d_off;
                namlen = strlen(dp->d_name);
                reclen = DIRENT32_RECLEN(namlen);
                op->d_reclen = (uint16_t)reclen;

                /* use strncpy(9f) to zero out uninitialized bytes */

                (void) strncpy(op->d_name, dp->d_name,
                    DIRENT32_NAMELEN(reclen));
                nsize += (uint_t)dp->d_reclen;
                osize += (uint_t)op->d_reclen;
                dp = (struct dirent64 *)((char *)dp + (uint_t)dp->d_reclen);
                op = (struct dirent32 *)((char *)op + (uint_t)op->d_reclen);
        }

        ASSERT(osize <= count);
        ASSERT((char *)op <= (char *)obuf + bufsize);
        ASSERT((char *)dp <= (char *)newbuf + bufsize);

        if ((error = copyout(obuf, buf, osize)) < 0)
                error = EFAULT;
out:
        kmem_free(newbuf, bufsize);
        kmem_free(obuf, bufsize);

        if (error) {
                releasef(fd);
                return (set_errno(error));
        }

        releasef(fd);
        return (osize);
}

#endif  /* _SYSCALL32 || _ILP32 */

int
getdents64(int fd, void *buf, size_t count)
{
        vnode_t *vp;
        file_t *fp;
        struct uio auio;
        struct iovec aiov;
        register int error;
        int sink;

        if (count < sizeof (struct dirent64))
                return (set_errno(EINVAL));

        /*
         * Don't let the user overcommit kernel resources.
         */
        if (count > MAXGETDENTS_SIZE)
                count = MAXGETDENTS_SIZE;

        if ((fp = getf(fd)) == NULL)
                return (set_errno(EBADF));
        vp = fp->f_vnode;
        if (vp->v_type != VDIR) {
                releasef(fd);
                return (set_errno(ENOTDIR));
        }
        if (!(fp->f_flag & FREAD)) {
                releasef(fd);
                return (set_errno(EBADF));
        }
        aiov.iov_base = buf;
        aiov.iov_len = count;
        auio.uio_iov = &aiov;
        auio.uio_iovcnt = 1;
        auio.uio_loffset = fp->f_offset;
        auio.uio_segflg = UIO_USERSPACE;
        auio.uio_resid = count;
        auio.uio_fmode = 0;
        auio.uio_extflg = UIO_COPY_CACHED;
        (void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
        error = VOP_READDIR(vp, &auio, fp->f_cred, &sink, NULL, 0);
        VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
        if (error) {
                releasef(fd);
                return (set_errno(error));
        }
        count = count - auio.uio_resid;
        fp->f_offset = auio.uio_loffset;
        releasef(fd);
        return (count);
}