/*

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

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include <stdio.h>

#include <stdlib.h>

#include <limits.h>

#include <fcntl.h>

#include <dirent.h>

#include <unistd.h>

#include <pwd.h>

#include <grp.h>

#include <errno.h>

#include <dlfcn.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/statvfs.h>

#include <sys/time.h>

#ifdef __solaris__

#include <strings.h>

#endif

#if defined(__linux__) || defined(_AIX)

#include <string.h>

#endif

#ifdef _ALLBSD_SOURCE

#include <string.h>

#define stat64 stat

#define statvfs64 statvfs

#define open64 open

#define fstat64 fstat

#define lstat64 lstat

#define dirent64 dirent

#define readdir64_r readdir_r

#endif

#include "jni.h"

#include "jni_util.h"

#include "jlong.h"

#include "sun_nio_fs_UnixNativeDispatcher.h"

/**

 * Size of password or group entry when not available via sysconf

 */

#define ENT_BUF_SIZE   1024

#define RESTARTABLE(_cmd, _result) do { \

  do { \

    _result = _cmd; \

  } while((_result == -1) && (errno == EINTR)); \

} while(0)

#define RESTARTABLE_RETURN_PTR(_cmd, _result) do { \

  do { \

    _result = _cmd; \

  } while((_result == NULL) && (errno == EINTR)); \

} while(0)

static jfieldID attrs_st_mode;

static jfieldID attrs_st_ino;

static jfieldID attrs_st_dev;

static jfieldID attrs_st_rdev;

static jfieldID attrs_st_nlink;

static jfieldID attrs_st_uid;

static jfieldID attrs_st_gid;

static jfieldID attrs_st_size;

static jfieldID attrs_st_atime_sec;

static jfieldID attrs_st_atime_nsec;

static jfieldID attrs_st_mtime_sec;

static jfieldID attrs_st_mtime_nsec;

static jfieldID attrs_st_ctime_sec;

static jfieldID attrs_st_ctime_nsec;

#ifdef _DARWIN_FEATURE_64_BIT_INODE

static jfieldID attrs_st_birthtime_sec;

#endif

static jfieldID attrs_f_frsize;

static jfieldID attrs_f_blocks;

static jfieldID attrs_f_bfree;

static jfieldID attrs_f_bavail;

static jfieldID entry_name;

static jfieldID entry_dir;

static jfieldID entry_fstype;

static jfieldID entry_options;

static jfieldID entry_dev;

/**

 * System calls that may not be available at run time.

 */

typedef int openat64_func(int, const char *, int, ...);

typedef int fstatat64_func(int, const char *, struct stat64 *, int);

typedef int unlinkat_func(int, const char*, int);

typedef int renameat_func(int, const char*, int, const char*);

typedef int futimesat_func(int, const char *, const struct timeval *);

typedef DIR* fdopendir_func(int);

static openat64_func* my_openat64_func = NULL;

static fstatat64_func* my_fstatat64_func = NULL;

static unlinkat_func* my_unlinkat_func = NULL;

static renameat_func* my_renameat_func = NULL;

static futimesat_func* my_futimesat_func = NULL;

static fdopendir_func* my_fdopendir_func = NULL;

/**

 * fstatat missing from glibc on Linux. Temporary workaround

 * for x86/x64.

 */

#if defined(__linux__) && defined(__i386)

#define FSTATAT64_SYSCALL_AVAILABLE

static int fstatat64_wrapper(int dfd, const char *path,

                             struct stat64 *statbuf, int flag)

{

    #ifndef __NR_fstatat64

    #define __NR_fstatat64  300

    #endif

    return syscall(__NR_fstatat64, dfd, path, statbuf, flag);

}

#endif

#if defined(__linux__) && defined(__x86_64__)

#define FSTATAT64_SYSCALL_AVAILABLE

static int fstatat64_wrapper(int dfd, const char *path,

                             struct stat64 *statbuf, int flag)

{

    #ifndef __NR_newfstatat

    #define __NR_newfstatat  262

    #endif

    return syscall(__NR_newfstatat, dfd, path, statbuf, flag);

}

#endif

/**

 * Call this to throw an internal UnixException when a system/library

 * call fails

 */

static void throwUnixException(JNIEnv* env, int errnum) {

    jobject x = JNU_NewObjectByName(env, "sun/nio/fs/UnixException",

        "(I)V", errnum);

    if (x != NULL) {

        (*env)->Throw(env, x);

    }

}

/**

 * Initialization

 */

JNIEXPORT jint JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_init(JNIEnv* env, jclass this)

{

    jint capabilities = 0;

    jclass clazz;

    clazz = (*env)->FindClass(env, "sun/nio/fs/UnixFileAttributes");

    CHECK_NULL_RETURN(clazz, 0);

    attrs_st_mode = (*env)->GetFieldID(env, clazz, "st_mode", "I");

    CHECK_NULL_RETURN(attrs_st_mode, 0);

    attrs_st_ino = (*env)->GetFieldID(env, clazz, "st_ino", "J");

    CHECK_NULL_RETURN(attrs_st_ino, 0);

    attrs_st_dev = (*env)->GetFieldID(env, clazz, "st_dev", "J");

    CHECK_NULL_RETURN(attrs_st_dev, 0);

    attrs_st_rdev = (*env)->GetFieldID(env, clazz, "st_rdev", "J");

    CHECK_NULL_RETURN(attrs_st_rdev, 0);

    attrs_st_nlink = (*env)->GetFieldID(env, clazz, "st_nlink", "I");

    CHECK_NULL_RETURN(attrs_st_nlink, 0);

    attrs_st_uid = (*env)->GetFieldID(env, clazz, "st_uid", "I");

    CHECK_NULL_RETURN(attrs_st_uid, 0);

    attrs_st_gid = (*env)->GetFieldID(env, clazz, "st_gid", "I");

    CHECK_NULL_RETURN(attrs_st_gid, 0);

    attrs_st_size = (*env)->GetFieldID(env, clazz, "st_size", "J");

    CHECK_NULL_RETURN(attrs_st_size, 0);

    attrs_st_atime_sec = (*env)->GetFieldID(env, clazz, "st_atime_sec", "J");

    CHECK_NULL_RETURN(attrs_st_atime_sec, 0);

    attrs_st_atime_nsec = (*env)->GetFieldID(env, clazz, "st_atime_nsec", "J");

    CHECK_NULL_RETURN(attrs_st_atime_nsec, 0);

    attrs_st_mtime_sec = (*env)->GetFieldID(env, clazz, "st_mtime_sec", "J");

    CHECK_NULL_RETURN(attrs_st_mtime_sec, 0);

    attrs_st_mtime_nsec = (*env)->GetFieldID(env, clazz, "st_mtime_nsec", "J");

    CHECK_NULL_RETURN(attrs_st_mtime_nsec, 0);

    attrs_st_ctime_sec = (*env)->GetFieldID(env, clazz, "st_ctime_sec", "J");

    CHECK_NULL_RETURN(attrs_st_ctime_sec, 0);

    attrs_st_ctime_nsec = (*env)->GetFieldID(env, clazz, "st_ctime_nsec", "J");

    CHECK_NULL_RETURN(attrs_st_ctime_nsec, 0);

#ifdef _DARWIN_FEATURE_64_BIT_INODE

    attrs_st_birthtime_sec = (*env)->GetFieldID(env, clazz, "st_birthtime_sec", "J");

    CHECK_NULL_RETURN(attrs_st_birthtime_sec, 0);

#endif

    clazz = (*env)->FindClass(env, "sun/nio/fs/UnixFileStoreAttributes");

    CHECK_NULL_RETURN(clazz, 0);

    attrs_f_frsize = (*env)->GetFieldID(env, clazz, "f_frsize", "J");

    CHECK_NULL_RETURN(attrs_f_frsize, 0);

    attrs_f_blocks = (*env)->GetFieldID(env, clazz, "f_blocks", "J");

    CHECK_NULL_RETURN(attrs_f_blocks, 0);

    attrs_f_bfree = (*env)->GetFieldID(env, clazz, "f_bfree", "J");

    CHECK_NULL_RETURN(attrs_f_bfree, 0);

    attrs_f_bavail = (*env)->GetFieldID(env, clazz, "f_bavail", "J");

    CHECK_NULL_RETURN(attrs_f_bavail, 0);

    clazz = (*env)->FindClass(env, "sun/nio/fs/UnixMountEntry");

    CHECK_NULL_RETURN(clazz, 0);

    entry_name = (*env)->GetFieldID(env, clazz, "name", "[B");

    CHECK_NULL_RETURN(entry_name, 0);

    entry_dir = (*env)->GetFieldID(env, clazz, "dir", "[B");

    CHECK_NULL_RETURN(entry_dir, 0);

    entry_fstype = (*env)->GetFieldID(env, clazz, "fstype", "[B");

    CHECK_NULL_RETURN(entry_fstype, 0);

    entry_options = (*env)->GetFieldID(env, clazz, "opts", "[B");

    CHECK_NULL_RETURN(entry_options, 0);

    entry_dev = (*env)->GetFieldID(env, clazz, "dev", "J");

    CHECK_NULL_RETURN(entry_dev, 0);

    /* system calls that might not be available at run time */

#if (defined(__solaris__) && defined(_LP64)) || defined(_ALLBSD_SOURCE)

    /* Solaris 64-bit does not have openat64/fstatat64 */

    my_openat64_func = (openat64_func*)dlsym(RTLD_DEFAULT, "openat");

    my_fstatat64_func = (fstatat64_func*)dlsym(RTLD_DEFAULT, "fstatat");

#else

    my_openat64_func = (openat64_func*) dlsym(RTLD_DEFAULT, "openat64");

    my_fstatat64_func = (fstatat64_func*) dlsym(RTLD_DEFAULT, "fstatat64");

#endif

    my_unlinkat_func = (unlinkat_func*) dlsym(RTLD_DEFAULT, "unlinkat");

    my_renameat_func = (renameat_func*) dlsym(RTLD_DEFAULT, "renameat");

    my_futimesat_func = (futimesat_func*) dlsym(RTLD_DEFAULT, "futimesat");

    my_fdopendir_func = (fdopendir_func*) dlsym(RTLD_DEFAULT, "fdopendir");

#if defined(FSTATAT64_SYSCALL_AVAILABLE)

    /* fstatat64 missing from glibc */

    if (my_fstatat64_func == NULL)

        my_fstatat64_func = (fstatat64_func*)&fstatat64_wrapper;

#endif

    /* supports futimes or futimesat */

#ifdef _ALLBSD_SOURCE

    capabilities |= sun_nio_fs_UnixNativeDispatcher_SUPPORTS_FUTIMES;

#else

    if (my_futimesat_func != NULL)

        capabilities |= sun_nio_fs_UnixNativeDispatcher_SUPPORTS_FUTIMES;

#endif

    /* supports openat, etc. */

    if (my_openat64_func != NULL &&  my_fstatat64_func != NULL &&

        my_unlinkat_func != NULL && my_renameat_func != NULL &&

        my_futimesat_func != NULL && my_fdopendir_func != NULL)

    {

        capabilities |= sun_nio_fs_UnixNativeDispatcher_SUPPORTS_OPENAT;

    }

    /* supports file birthtime */

#ifdef _DARWIN_FEATURE_64_BIT_INODE

    capabilities |= sun_nio_fs_UnixNativeDispatcher_SUPPORTS_BIRTHTIME;

#endif

    return capabilities;

}

JNIEXPORT jbyteArray JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_getcwd(JNIEnv* env, jclass this) {

    jbyteArray result = NULL;

    char buf[PATH_MAX+1];

    /* EINTR not listed as a possible error */

    char* cwd = getcwd(buf, sizeof(buf));

    if (cwd == NULL) {

        throwUnixException(env, errno);

    } else {

        jsize len = (jsize)strlen(buf);

        result = (*env)->NewByteArray(env, len);

        if (result != NULL) {

            (*env)->SetByteArrayRegion(env, result, 0, len, (jbyte*)buf);

        }

    }

    return result;

}

JNIEXPORT jbyteArray

Java_sun_nio_fs_UnixNativeDispatcher_strerror(JNIEnv* env, jclass this, jint error)

{

    char* msg;

    jsize len;

    jbyteArray bytes;

#ifdef _AIX

    /* strerror() is not thread-safe on AIX so we have to use strerror_r() */

    char buffer[256];

    msg = (strerror_r((int)error, buffer, 256) == 0) ? buffer : "Error while calling strerror_r";

#else

    msg = strerror((int)error);

#endif

    len = strlen(msg);

    bytes = (*env)->NewByteArray(env, len);

    if (bytes != NULL) {

        (*env)->SetByteArrayRegion(env, bytes, 0, len, (jbyte*)msg);

    }

    return bytes;

}

JNIEXPORT jint

Java_sun_nio_fs_UnixNativeDispatcher_dup(JNIEnv* env, jclass this, jint fd) {

    int res = -1;

    RESTARTABLE(dup((int)fd), res);

    if (res == -1) {

        throwUnixException(env, errno);

    }

    return (jint)res;

}

JNIEXPORT jlong JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_fopen0(JNIEnv* env, jclass this,

    jlong pathAddress, jlong modeAddress)

{

    FILE* fp = NULL;

    const char* path = (const char*)jlong_to_ptr(pathAddress);

    const char* mode = (const char*)jlong_to_ptr(modeAddress);

    do {

        fp = fopen(path, mode);

    } while (fp == NULL && errno == EINTR);

    if (fp == NULL) {

        throwUnixException(env, errno);

    }

    return ptr_to_jlong(fp);

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_fclose(JNIEnv* env, jclass this, jlong stream)

{

    FILE* fp = jlong_to_ptr(stream);

    /* NOTE: fclose() wrapper is only used with read-only streams.

     * If it ever is used with write streams, it might be better to add

     * RESTARTABLE(fflush(fp)) before closing, to make sure the stream

     * is completely written even if fclose() failed.

     */

    if (fclose(fp) == EOF && errno != EINTR) {

        throwUnixException(env, errno);

    }

}

JNIEXPORT jint JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_open0(JNIEnv* env, jclass this,

    jlong pathAddress, jint oflags, jint mode)

{

    jint fd;

    const char* path = (const char*)jlong_to_ptr(pathAddress);

    RESTARTABLE(open64(path, (int)oflags, (mode_t)mode), fd);

    if (fd == -1) {

        throwUnixException(env, errno);

    }

    return fd;

}

JNIEXPORT jint JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_openat0(JNIEnv* env, jclass this, jint dfd,

    jlong pathAddress, jint oflags, jint mode)

{

    jint fd;

    const char* path = (const char*)jlong_to_ptr(pathAddress);

    if (my_openat64_func == NULL) {

        JNU_ThrowInternalError(env, "should not reach here");

        return -1;

    }

    RESTARTABLE((*my_openat64_func)(dfd, path, (int)oflags, (mode_t)mode), fd);

    if (fd == -1) {

        throwUnixException(env, errno);

    }

    return fd;

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_close(JNIEnv* env, jclass this, jint fd) {

    int err;

    /* TDB - need to decide if EIO and other errors should cause exception */

    RESTARTABLE(close((int)fd), err);

}

JNIEXPORT jint JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_read(JNIEnv* env, jclass this, jint fd,

    jlong address, jint nbytes)

{

    ssize_t n;

    void* bufp = jlong_to_ptr(address);

    RESTARTABLE(read((int)fd, bufp, (size_t)nbytes), n);

    if (n == -1) {

        throwUnixException(env, errno);

    }

    return (jint)n;

}

JNIEXPORT jint JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_write(JNIEnv* env, jclass this, jint fd,

    jlong address, jint nbytes)

{

    ssize_t n;

    void* bufp = jlong_to_ptr(address);

    RESTARTABLE(write((int)fd, bufp, (size_t)nbytes), n);

    if (n == -1) {

        throwUnixException(env, errno);

    }

    return (jint)n;

}

/**

 * Copy stat64 members into sun.nio.fs.UnixFileAttributes

 */

static void prepAttributes(JNIEnv* env, struct stat64* buf, jobject attrs) {

    (*env)->SetIntField(env, attrs, attrs_st_mode, (jint)buf->st_mode);

    (*env)->SetLongField(env, attrs, attrs_st_ino, (jlong)buf->st_ino);

    (*env)->SetLongField(env, attrs, attrs_st_dev, (jlong)buf->st_dev);

    (*env)->SetLongField(env, attrs, attrs_st_rdev, (jlong)buf->st_rdev);

    (*env)->SetIntField(env, attrs, attrs_st_nlink, (jint)buf->st_nlink);

    (*env)->SetIntField(env, attrs, attrs_st_uid, (jint)buf->st_uid);

    (*env)->SetIntField(env, attrs, attrs_st_gid, (jint)buf->st_gid);

    (*env)->SetLongField(env, attrs, attrs_st_size, (jlong)buf->st_size);

    (*env)->SetLongField(env, attrs, attrs_st_atime_sec, (jlong)buf->st_atime);

    (*env)->SetLongField(env, attrs, attrs_st_mtime_sec, (jlong)buf->st_mtime);

    (*env)->SetLongField(env, attrs, attrs_st_ctime_sec, (jlong)buf->st_ctime);

#ifdef _DARWIN_FEATURE_64_BIT_INODE

    (*env)->SetLongField(env, attrs, attrs_st_birthtime_sec, (jlong)buf->st_birthtime);

#endif

#if (_POSIX_C_SOURCE >= 200809L) || defined(__solaris__)

    (*env)->SetLongField(env, attrs, attrs_st_atime_nsec, (jlong)buf->st_atim.tv_nsec);

    (*env)->SetLongField(env, attrs, attrs_st_mtime_nsec, (jlong)buf->st_mtim.tv_nsec);

    (*env)->SetLongField(env, attrs, attrs_st_ctime_nsec, (jlong)buf->st_ctim.tv_nsec);

#endif

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_stat0(JNIEnv* env, jclass this,

    jlong pathAddress, jobject attrs)

{

    int err;

    struct stat64 buf;

    const char* path = (const char*)jlong_to_ptr(pathAddress);

    RESTARTABLE(stat64(path, &buf), err);

    if (err == -1) {

        throwUnixException(env, errno);

    } else {

        prepAttributes(env, &buf, attrs);

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_lstat0(JNIEnv* env, jclass this,

    jlong pathAddress, jobject attrs)

{

    int err;

    struct stat64 buf;

    const char* path = (const char*)jlong_to_ptr(pathAddress);

    RESTARTABLE(lstat64(path, &buf), err);

    if (err == -1) {

        throwUnixException(env, errno);

    } else {

        prepAttributes(env, &buf, attrs);

    }

}

JNIEXPORT void JNICALL

Java_sun_nio_fs_UnixNativeDispatcher_fstat(JNIEnv* env, jclass this, jint fd,

    jobject attrs)