/*
 * Copyright 2005-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2012, John Scipione, jscipione@gmail.com.
 * Distributed under the terms of the MIT License.
 */

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>


// Private helper functions
static int get_path(int fd, const char* path, char fullPath[]);
static int eaccess(const char* path, int accessMode);


static int
get_path(int fd, const char* path, char fullPath[])
{
        struct stat dirst;
        if (fstat(fd, &dirst) < 0) {
                // failed to grab stat information, fstat() sets errno
                return -1;
        }

        if (!S_ISDIR(dirst.st_mode)) {
                // fd does not point to a directory
                errno = ENOTDIR;
                return -1;
        }

        if (fcntl(fd, F_GETPATH, fullPath) < 0) {
                // failed to get the path of fd, fcntl() sets errno
                return -1;
        }

        if (strlcat(fullPath, "/", MAXPATHLEN) > MAXPATHLEN
                || strlcat(fullPath, path, MAXPATHLEN) > MAXPATHLEN) {
                // full path is too long
                errno = ENAMETOOLONG;
                return -1;
        }

        return 0;
}


static int
eaccess(const char* path, int accessMode)
{
        uid_t uid = geteuid();
        int fileMode = 0;

        struct stat st;
        if (stat(path, &st) < 0) {
                // failed to get stat information on path, stat() sets errno
                return -1;
        }

        if (uid == 0) {
                // user is root
                // root has always read/write permission, but at least one of the
                // X bits must be set for execute permission
                fileMode = R_OK | W_OK;
                if ((st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) != 0)
                        fileMode |= X_OK;
        } else if (st.st_uid == uid) {
                // user is node owner
                if ((st.st_mode & S_IRUSR) != 0)
                        fileMode |= R_OK;
                if ((st.st_mode & S_IWUSR) != 0)
                        fileMode |= W_OK;
                if ((st.st_mode & S_IXUSR) != 0)
                        fileMode |= X_OK;
        } else if (st.st_gid == getegid()) {
                // user is in owning group
                if ((st.st_mode & S_IRGRP) != 0)
                        fileMode |= R_OK;
                if ((st.st_mode & S_IWGRP) != 0)
                        fileMode |= W_OK;
                if ((st.st_mode & S_IXGRP) != 0)
                        fileMode |= X_OK;
        } else {
                // user is one of the others
                if ((st.st_mode & S_IROTH) != 0)
                        fileMode |= R_OK;
                if ((st.st_mode & S_IWOTH) != 0)
                        fileMode |= W_OK;
                if ((st.st_mode & S_IXOTH) != 0)
                        fileMode |= X_OK;
        }

        if ((accessMode & ~fileMode) != 0) {
                errno = EACCES;
                return -1;
        }

        return 0;
}


int
faccessat(int fd, const char* path, int accessMode, int flag)
{
        if (flag != AT_EACCESS && flag != 0) {
                // invalid flag
                errno = EINVAL;
                return -1;
        }

        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call access() ignoring fd
                return (flag & AT_EACCESS) != 0 ? eaccess(path, accessMode)
                        : access(path, accessMode);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return (flag & AT_EACCESS) != 0 ? eaccess(fullPath, accessMode)
                : access(fullPath, accessMode);
}


int
fchmodat(int fd, const char* path, mode_t mode, int flag)
{
        if ((flag & AT_SYMLINK_NOFOLLOW) == 0 && flag != 0) {
                // invalid flag
                errno = EINVAL;
                return -1;
        }

        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call chmod() ignoring fd
                if ((flag & AT_SYMLINK_NOFOLLOW) != 0) {
                        // fake lchmod() with open() and fchmod()
                        int symlinkfd = open(path, O_RDONLY | O_SYMLINK);
                        int status = fchmod(symlinkfd, mode);
                        close(symlinkfd);
                        return status;
                } else
                        return chmod(path, mode);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        int status;
        if ((flag & AT_SYMLINK_NOFOLLOW) != 0) {
                // fake lchmod() with open() and fchmod()
                int fullfd = open(fullPath, O_RDONLY | O_SYMLINK);
                status = fchmod(fullfd, mode);
                close(fullfd);
        } else
                status = chmod(fullPath, mode);

        return status;
}


int
fchownat(int fd, const char* path, uid_t owner, gid_t group, int flag)
{
        if (flag != AT_SYMLINK_NOFOLLOW && flag != 0) {
                // invalid flag
                errno = EINVAL;
                return -1;
        }

        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call chown() ignoring fd
                return (flag & AT_SYMLINK_NOFOLLOW) != 0 ? lchown(path, owner, group)
                        : chown(path, owner, group);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return (flag & AT_SYMLINK_NOFOLLOW) != 0 ? lchown(fullPath, owner, group)
                : chown(fullPath, owner, group);
}


DIR*
fdopendir(int fd)
{
        struct stat st;
        if (fstat(fd, &st)) {
                // failed to get the stat info for fd, fstat() sets errno
                return NULL;
        }

        if (!S_ISDIR(st.st_mode)) {
                errno = ENOTDIR;
                return NULL;
        }

        char path[MAXPATHLEN];
        if (fcntl(fd, F_GETPATH, path) < 0) {
                // failed to get the path of fd, fcntl() sets errno
                return NULL;
        }

        DIR* dir = opendir(path);
        if (dir != NULL)
                close(fd);

        return dir;
}


int
fstatat(int fd, const char *path, struct stat *st, int flag)
{
        if (flag != AT_SYMLINK_NOFOLLOW && flag != 0) {
                // invalid flag
                errno = EINVAL;
                return -1;
        }

        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call stat() or lstat() ignoring fd
                return (flag & AT_SYMLINK_NOFOLLOW) != 0 ? lstat(path, st)
                        : stat(path, st);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return (flag & AT_SYMLINK_NOFOLLOW) != 0 ? lstat(fullPath, st)
                : stat(fullPath, st);
}


int
mkdirat(int fd, const char *path, mode_t mode)
{
        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call mkdir() ignoring fd
                return mkdir(path, mode);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return mkdir(fullPath, mode);
}


int
mkfifoat(int fd, const char *path, mode_t mode)
{
        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call mkfifo() ignoring fd
                return mkfifo(path, mode);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return mkfifo(fullPath, mode);
}


int
mknodat(int fd, const char *path, mode_t mode, dev_t dev)
{
        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call mknod() ignoring fd
                return mknod(path, mode, dev);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return mknod(fullPath, mode, dev);
}


int
renameat(int oldFD, const char* oldPath, int newFD, const char* newPath)
{
        bool ignoreOldFD = false;
        bool ignoreNewFD = false;

        if (oldFD == AT_FDCWD || (oldPath != NULL && oldPath[0] == '/'))
                ignoreOldFD = true;

        if (newFD == AT_FDCWD || (newPath != NULL && newPath[0] == '/'))
                ignoreNewFD = true;

        if (ignoreOldFD && ignoreNewFD) {
                // call rename() ignoring the fd's
                return rename(oldPath, newPath);
        }

        char oldFullPath[MAXPATHLEN];
        if (!ignoreOldFD) {
                if (oldFD < 0) {
                        // Invalid file descriptor
                        errno = EBADF;
                        return -1;
                }

                if (get_path(oldFD, oldPath, oldFullPath) < 0)
                        return -1;
        }

        char newFullPath[MAXPATHLEN];
        if (!ignoreNewFD) {
                if (newFD < 0) {
                        // Invalid file descriptor
                        errno = EBADF;
                        return -1;
                }

                if (get_path(newFD, newPath, newFullPath) < 0)
                        return -1;
        }

        return rename(ignoreOldFD ? oldPath : oldFullPath,
                ignoreNewFD ? newPath : newFullPath);
}


ssize_t
readlinkat(int fd, const char *path, char *buffer, size_t bufferSize)
{
        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call readlink() ignoring fd
                return readlink(path, buffer, bufferSize);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return readlink(fullPath, buffer, bufferSize);
}


int
symlinkat(const char *oldPath, int fd, const char *newPath)
{
        if (fd == AT_FDCWD || (newPath != NULL && newPath[0] == '/')) {
                // call symlink() ignoring fd
                return symlink(oldPath, newPath);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        // newPath is relative to the fd
        char newFullPath[MAXPATHLEN];
        if (get_path(fd, newPath, newFullPath) < 0)
                return -1;

        return symlink(oldPath, newFullPath);
}


int
unlinkat(int fd, const char *path, int flag)
{
        if (flag != AT_REMOVEDIR && flag != 0) {
                // invalid flag
                errno = EINVAL;
                return -1;
        }

        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call rmdir() or unlink() ignoring fd
                return (flag & AT_REMOVEDIR) != 0 ? rmdir(path) : unlink(path);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return (flag & AT_REMOVEDIR) != 0 ? rmdir(fullPath)
                : unlink(fullPath);
}


int
linkat(int oldFD, const char *oldPath, int newFD, const char *newPath,
           int flag)
{
        if ((flag & AT_SYMLINK_FOLLOW) != 0) {
                // Dereference oldPath
                // CURRENTLY UNSUPPORTED
                errno = ENOTSUP;
                return -1;
        } else if (flag != 0) {
                errno = EINVAL;
                return -1;
        }

        bool ignoreOldFD = false;
        bool ignoreNewFD = false;

        if (oldFD == AT_FDCWD || (oldPath != NULL && oldPath[0] == '/'))
                ignoreOldFD = true;

        if (newFD == AT_FDCWD || (newPath != NULL && newPath[0] == '/'))
                ignoreNewFD = true;

        if (ignoreOldFD && ignoreNewFD) {
                // call link() ignoring the fd's
                return link(oldPath, newPath);
        }

        char oldFullPath[MAXPATHLEN];
        if (!ignoreOldFD) {
                if (oldFD < 0) {
                        // Invalid file descriptor
                        errno = EBADF;
                        return -1;
                }

                if (get_path(oldFD, oldPath, oldFullPath) < 0)
                        return -1;
        }

        char newFullPath[MAXPATHLEN];
        if (!ignoreNewFD) {
                if (newFD < 0) {
                        // Invalid file descriptor
                        errno = EBADF;
                        return -1;
                }

                if (get_path(newFD, newPath, newFullPath) < 0)
                        return -1;
        }

        return link(ignoreOldFD ? oldPath : oldFullPath,
                ignoreNewFD ? newPath : newFullPath);
}


int
futimesat(int fd, const char *path, const struct timeval times[2])
{
        if (fd == AT_FDCWD || (path != NULL && path[0] == '/')) {
                // call utimes() ignoring fd
                return utimes(path, times);
        }

        if (fd < 0) {
                // Invalid file descriptor
                errno = EBADF;
                return -1;
        }

        char fullPath[MAXPATHLEN];
        if (get_path(fd, path, fullPath) < 0)
                return -1;

        return utimes(fullPath, times);
}