/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) NGINX, Inc.
 */

#include <nxt_main.h>


nxt_int_t
nxt_file_open(nxt_task_t *task, nxt_file_t *file, nxt_uint_t mode,
    nxt_uint_t create, nxt_file_access_t access)
{
#ifdef __CYGWIN__
    mode |= O_BINARY;
#endif

    /* O_NONBLOCK is to prevent blocking on FIFOs, special devices, etc. */
    mode |= (O_NONBLOCK | create);

    file->fd = open((char *) file->name, mode, access);

    file->error = (file->fd == -1) ? nxt_errno : 0;

#if (NXT_DEBUG)
    nxt_thread_time_update(task->thread);
#endif

    nxt_debug(task, "open(\"%FN\", 0x%uXi, 0x%uXi): %FD err:%d",
              file->name, mode, access, file->fd, file->error);

    if (file->fd != -1) {
        return NXT_OK;
    }

    if (file->log_level != 0) {
        nxt_log(task, file->log_level, "open(\"%FN\") failed %E",
                file->name, file->error);
    }

    return NXT_ERROR;
}


#if (NXT_HAVE_OPENAT2)

nxt_int_t
nxt_file_openat2(nxt_task_t *task, nxt_file_t *file, nxt_uint_t mode,
    nxt_uint_t create, nxt_file_access_t access, nxt_fd_t dfd,
    nxt_uint_t resolve)
{
    struct open_how  how;

    nxt_memzero(&how, sizeof(how));

    /* O_NONBLOCK is to prevent blocking on FIFOs, special devices, etc. */
    mode |= (O_NONBLOCK | create);

    how.flags = mode;
    how.mode = access;
    how.resolve = resolve;

    file->fd = syscall(SYS_openat2, dfd, file->name, &how, sizeof(how));

    file->error = (file->fd == -1) ? nxt_errno : 0;

#if (NXT_DEBUG)
    nxt_thread_time_update(task->thread);
#endif

    nxt_debug(task, "openat2(%FD, \"%FN\"): %FD err:%d", dfd, file->name,
              file->fd, file->error);

    if (file->fd != -1) {
        return NXT_OK;
    }

    if (file->log_level != 0) {
        nxt_log(task, file->log_level, "openat2(%FD, \"%FN\") failed %E", dfd,
                file->name, file->error);
    }

    return NXT_ERROR;
}

#endif


void
nxt_file_close(nxt_task_t *task, nxt_file_t *file)
{
    nxt_debug(task, "close(%FD)", file->fd);

    if (close(file->fd) != 0) {
        nxt_alert(task, "close(%FD, \"%FN\") failed %E",
                  file->fd, file->name, nxt_errno);
    }
}


ssize_t
nxt_file_write(nxt_file_t *file, const u_char *buf, size_t size,
    nxt_off_t offset)
{
    ssize_t  n;

    nxt_thread_debug(thr);

    n = pwrite(file->fd, buf, size, offset);

    file->error = (n < 0) ? nxt_errno : 0;

    nxt_thread_time_debug_update(thr);

    nxt_log_debug(thr->log, "pwrite(%FD, %p, %uz, %O): %z",
                  file->fd, buf, size, offset, n);

    if (nxt_fast_path(n >= 0)) {
        return n;
    }

    nxt_thread_log_alert("pwrite(%FD, \"%FN\", %p, %uz, %O) failed %E",
                         file->fd, file->name, buf, size,
                         offset, file->error);

    return NXT_ERROR;
}


ssize_t
nxt_file_read(nxt_file_t *file, u_char *buf, size_t size, nxt_off_t offset)
{
    ssize_t  n;

    nxt_thread_debug(thr);

    n = pread(file->fd, buf, size, offset);

    file->error = (n <= 0) ? nxt_errno : 0;

    nxt_thread_time_debug_update(thr);

    nxt_log_debug(thr->log, "pread(%FD, %p, %uz, %O): %z",
                  file->fd, buf, size, offset, n);

    if (nxt_fast_path(n >= 0)) {
        return n;
    }

    nxt_thread_log_alert("pread(%FD, \"%FN\", %p, %uz, %O) failed %E",
                         file->fd, file->name, buf, size,
                         offset, file->error);

    return NXT_ERROR;
}


#if (NXT_HAVE_READAHEAD)

/* FreeBSD 8.0 fcntl(F_READAHEAD, size) enables read ahead up to the size. */

void
nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
{
    int     ret;
    u_char  buf;

    ret = fcntl(file->fd, F_READAHEAD, (int) size);

    nxt_thread_log_debug("fcntl(%FD, F_READAHEAD, %uz): %d",
                         file->fd, size, ret);

    if (nxt_fast_path(ret != -1)) {
        (void) nxt_file_read(file, &buf, 1, offset);
        return;
    }

    nxt_thread_log_alert("fcntl(%FD, \"%FN\", F_READAHEAD, %uz) failed %E",
                         file->fd, file->name, size, nxt_errno);
}

#elif (NXT_HAVE_POSIX_FADVISE)

/*
 * POSIX_FADV_SEQUENTIAL
 *   Linux doubles the default readahead window size of a backing device
 *   which is usually 128K.
 *
 *   FreeBSD does nothing.
 *
 * POSIX_FADV_WILLNEED
 *   Linux preloads synchronously up to 2M of specified file region in
 *   the kernel page cache.  Linux-specific readahead(2) syscall does
 *   the same.  Both operations are blocking despite posix_fadvise(2)
 *   claims the opposite.
 *
 *   FreeBSD does nothing.
 */

void
nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
{
    nxt_err_t  err;

    err = posix_fadvise(file->fd, offset, size, POSIX_FADV_WILLNEED);

    nxt_thread_log_debug("posix_fadvise(%FD, \"%FN\", %O, %uz, %d): %d",
                         file->fd, file->name, offset, size,
                         POSIX_FADV_WILLNEED, err);

    if (nxt_fast_path(err == 0)) {
        return;
    }

    nxt_thread_log_alert("posix_fadvise(%FD, \"%FN\", %O, %uz, %d) failed %E",
                         file->fd, file->name, offset, size,
                         POSIX_FADV_WILLNEED, err);
}

#elif (NXT_HAVE_RDAHEAD)

/* MacOSX fcntl(F_RDAHEAD). */

void
nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
{
    int     ret;
    u_char  buf;

    ret = fcntl(file->fd, F_RDAHEAD, 1);

    nxt_thread_log_debug("fcntl(%FD, F_RDAHEAD, 1): %d", file->fd, ret);

    if (nxt_fast_path(ret != -1)) {
        (void) nxt_file_read(file, &buf, 1, offset);
        return;
    }

    nxt_thread_log_alert("fcntl(%FD, \"%FN\", F_RDAHEAD, 1) failed %E",
                         file->fd, file->name, nxt_errno);
}

#else

void
nxt_file_read_ahead(nxt_file_t *file, nxt_off_t offset, size_t size)
{
    u_char  buf;

    (void) nxt_file_read(file, &buf, 1, offset);
}

#endif


nxt_int_t
nxt_file_info(nxt_file_t *file, nxt_file_info_t *fi)
{
    int  n;

    if (file->fd == NXT_FILE_INVALID) {
        n = stat((char *) file->name, fi);

        file->error = (n != 0) ? nxt_errno : 0;

        nxt_thread_log_debug("stat(\"%FN)\": %d", file->name, n);

        if (n == 0) {
            return NXT_OK;
        }

        if (file->log_level != 0) {
            nxt_thread_log_error(file->log_level, "stat(\"%FN\") failed %E",
                                 file->name, file->error);
        }

        return NXT_ERROR;

    } else {
        n = fstat(file->fd, fi);

        file->error = (n != 0) ? nxt_errno : 0;

        nxt_thread_log_debug("fstat(%FD): %d", file->fd, n);

        if (n == 0) {
            return NXT_OK;
        }

        /* Use NXT_LOG_ALERT because fstat() error on open file is strange. */

        nxt_thread_log_alert("fstat(%FD, \"%FN\") failed %E",
                             file->fd, file->name, file->error);

        return NXT_ERROR;
    }
}


nxt_int_t
nxt_file_delete(nxt_file_name_t *name)
{
    nxt_thread_log_debug("unlink(\"%FN\")", name);

    if (nxt_fast_path(unlink((char *) name) == 0)) {
        return NXT_OK;
    }

    nxt_thread_log_alert("unlink(\"%FN\") failed %E", name, nxt_errno);

    return NXT_ERROR;
}


nxt_int_t
nxt_file_set_access(nxt_file_name_t *name, nxt_file_access_t access)
{
    if (nxt_fast_path(chmod((char *) name, access) == 0)) {
        return NXT_OK;
    }

    nxt_thread_log_alert("chmod(\"%FN\") failed %E", name, nxt_errno);

    return NXT_ERROR;
}


nxt_int_t
nxt_file_chown(nxt_file_name_t *name, const char *owner, const char *group)
{
    int    err;
    char   *buf;
    long   bufsize;
    gid_t  gid = ~0;
    uid_t  uid = ~0;

    if (owner == NULL && group == NULL) {
        return NXT_OK;
    }

    if (owner != NULL) {
        struct passwd  pwd, *result;

        bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
        if (bufsize == -1) {
            bufsize = 32768;
        }

        buf = nxt_malloc(bufsize);
        if (buf == NULL) {
            return NXT_ERROR;
        }

        err = getpwnam_r(owner, &pwd, buf, bufsize, &result);
        if (result == NULL) {
            nxt_thread_log_alert("getpwnam_r(\"%s\", ...) failed %E %s",
                                 owner, nxt_errno,
                                 err == 0 ? "(User not found)" : "");
            goto out_err_free;
        }

        uid = pwd.pw_uid;

        nxt_free(buf);
    }

    if (group != NULL) {
        struct group  grp, *result;

        bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
        if (bufsize == -1) {
            bufsize = 32768;
        }

        buf = nxt_malloc(bufsize);
        if (buf == NULL) {
            return NXT_ERROR;
        }

        err = getgrnam_r(group, &grp, buf, bufsize, &result);
        if (result == NULL) {
            nxt_thread_log_alert("getgrnam_r(\"%s\", ...) failed %E %s",
                                 group, nxt_errno,
                                 err == 0 ? "(Group not found)" : "");
            goto out_err_free;
        }

        gid = grp.gr_gid;

        nxt_free(buf);
    }

    if (nxt_fast_path(chown((const char *) name, uid, gid) == 0)) {
        return NXT_OK;
    }

    nxt_thread_log_alert("chown(\"%FN\", %l, %l) failed %E", name,
                         owner != NULL ? (long) uid : -1,
                         group != NULL ? (long) gid : -1, nxt_errno);

    return NXT_ERROR;

out_err_free:
    nxt_free(buf);

    return NXT_ERROR;
}


nxt_int_t
nxt_file_rename(nxt_file_name_t *old_name, nxt_file_name_t *new_name)
{
    int  ret;

    nxt_thread_log_debug("rename(\"%FN\", \"%FN\")", old_name, new_name);

    ret = rename((char *) old_name, (char *) new_name);
    if (nxt_fast_path(ret == 0)) {
        return NXT_OK;
    }

    nxt_thread_log_alert("rename(\"%FN\", \"%FN\") failed %E",
                         old_name, new_name, nxt_errno);

    return NXT_ERROR;
}


/*
 * ioctl(FIONBIO) sets a non-blocking mode using one syscall,
 * thereas fcntl(F_SETFL, O_NONBLOCK) needs to learn the current state
 * using fcntl(F_GETFL).
 *
 * ioctl() and fcntl() are syscalls at least in Linux 2.2, FreeBSD 2.x,
 * and Solaris 7.
 *
 * Linux 2.4 uses BKL for ioctl() and fcntl(F_SETFL).
 * Linux 2.6 does not use BKL.
 */

#if (NXT_HAVE_FIONBIO)

nxt_int_t
nxt_fd_nonblocking(nxt_task_t *task, nxt_fd_t fd)
{
    int  nb;

    nb = 1;

    if (nxt_fast_path(ioctl(fd, FIONBIO, &nb) != -1)) {
        return NXT_OK;
    }

    nxt_alert(task, "ioctl(%d, FIONBIO) failed %E", fd, nxt_errno);

    return NXT_ERROR;

}


nxt_int_t
nxt_fd_blocking(nxt_task_t *task, nxt_fd_t fd)
{
    int  nb;

    nb = 0;

    if (nxt_fast_path(ioctl(fd, FIONBIO, &nb) != -1)) {
        return NXT_OK;
    }

    nxt_alert(task, "ioctl(%d, !FIONBIO) failed %E", fd, nxt_errno);

    return NXT_ERROR;
}

#else /* !(NXT_HAVE_FIONBIO) */

nxt_int_t
nxt_fd_nonblocking(nxt_task_t *task, nxt_fd_t fd)
{
    int  flags;

    flags = fcntl(fd, F_GETFL);

    if (nxt_slow_path(flags == -1)) {
        nxt_alert(task, "fcntl(%d, F_GETFL) failed %E", fd, nxt_errno);
        return NXT_ERROR;
    }

    flags |= O_NONBLOCK;

    if (nxt_slow_path(fcntl(fd, F_SETFL, flags) == -1)) {
        nxt_alert(task, "fcntl(%d, F_SETFL, O_NONBLOCK) failed %E",
                  fd, nxt_errno);
        return NXT_ERROR;
    }

    return NXT_OK;
}


nxt_int_t
nxt_fd_blocking(nxt_task_t *task, nxt_fd_t fd)
{
    int  flags;

    flags = fcntl(fd, F_GETFL);

    if (nxt_slow_path(flags == -1)) {
        nxt_alert(task, "fcntl(%d, F_GETFL) failed %E", fd, nxt_errno);
        return NXT_ERROR;
    }

    flags &= O_NONBLOCK;

    if (nxt_slow_path(fcntl(fd, F_SETFL, flags) == -1)) {
        nxt_alert(task, "fcntl(%d, F_SETFL, !O_NONBLOCK) failed %E",
                  fd, nxt_errno);
        return NXT_ERROR;
    }

    return NXT_OK;
}

#endif /* NXT_HAVE_FIONBIO */


ssize_t
nxt_fd_write(nxt_fd_t fd, u_char *buf, size_t size)
{
    ssize_t    n;
    nxt_err_t  err;

    n = write(fd, buf, size);

    err = (n == -1) ? nxt_errno : 0;

    nxt_thread_log_debug("write(%FD, %p, %uz): %z", fd, buf, size, n);

    if (nxt_slow_path(n <= 0)) {
        nxt_thread_log_alert("write(%FD) failed %E", fd, err);
    }

    return n;
}


ssize_t
nxt_fd_read(nxt_fd_t fd, u_char *buf, size_t size)
{
    ssize_t    n;
    nxt_err_t  err;

    n = read(fd, buf, size);

    err = (n == -1) ? nxt_errno : 0;

    nxt_thread_log_debug("read(%FD, %p, %uz): %z", fd, buf, size, n);

    if (nxt_slow_path(n <= 0)) {

        if (err == NXT_EAGAIN) {
            return 0;
        }

        nxt_thread_log_alert("read(%FD) failed %E", fd, err);
    }

    return n;
}


void
nxt_fd_close(nxt_fd_t fd)
{
    nxt_thread_log_debug("close(%FD)", fd);

    if (nxt_slow_path(close(fd) != 0)) {
        nxt_thread_log_alert("close(%FD) failed %E", fd, nxt_errno);
    }
}


FILE *
nxt_file_fopen(nxt_task_t *task, const char *pathname, const char *mode)
{
    int   err;
    FILE  *fp;

#if (NXT_DEBUG)
    nxt_thread_time_update(task->thread);
#endif

    fp = fopen(pathname, mode);
    err = (fp == NULL) ? nxt_errno : 0;

    nxt_debug(task, "fopen(\"%s\", \"%s\"): fp:%p err:%d", pathname, mode, fp,
              err);

    if (nxt_fast_path(fp != NULL)) {
        return fp;
    }

    nxt_alert(task, "fopen(\"%s\") failed %E", pathname, err);

    return NULL;
}


void
nxt_file_fclose(nxt_task_t *task, FILE *fp)
{
    nxt_debug(task, "fclose(%p)", fp);

    if (nxt_slow_path(fclose(fp) == -1)) {
        nxt_alert(task, "fclose() failed %E", nxt_errno);
    }
}


/*
 * nxt_file_redirect() redirects the file to the fd descriptor.
 * Then the fd descriptor is closed.
 */

nxt_int_t
nxt_file_redirect(nxt_file_t *file, nxt_fd_t fd)
{
    nxt_thread_log_debug("dup2(%FD, %FD, \"%FN\")", fd, file->fd, file->name);

    if (dup2(fd, file->fd) == -1) {
        nxt_thread_log_alert("dup2(%FD, %FD, \"%FN\") failed %E",
                             fd, file->fd, file->name, nxt_errno);
        return NXT_ERROR;
    }

    if (close(fd) != 0) {
        nxt_thread_log_alert("close(%FD, \"%FN\") failed %E",
                             fd, file->name, nxt_errno);
        return NXT_ERROR;
    }

    return NXT_OK;
}


/* nxt_file_stdout() redirects the stdout descriptor to the file. */

nxt_int_t
nxt_file_stdout(nxt_file_t *file)
{
    nxt_thread_log_debug("dup2(%FD, %FD, \"%FN\")",
                         file->fd, STDOUT_FILENO, file->name);

    if (dup2(file->fd, STDOUT_FILENO) != -1) {
        return NXT_OK;
    }

    nxt_thread_log_alert("dup2(%FD, %FD, \"%FN\") failed %E",
                         file->fd, STDOUT_FILENO, file->name, nxt_errno);

    return NXT_ERROR;
}


/* nxt_file_stderr() redirects the stderr descriptor to the file. */

nxt_int_t
nxt_file_stderr(nxt_file_t *file)
{
    nxt_thread_log_debug("dup2(%FD, %FD, \"%FN\")",
                         file->fd, STDERR_FILENO, file->name);

    if (dup2(file->fd, STDERR_FILENO) != -1) {
        return NXT_OK;
    }

    nxt_thread_log_alert("dup2(%FD, %FD, \"%FN\") failed %E",
                         file->fd, STDERR_FILENO, file->name, nxt_errno);

    return NXT_ERROR;
}


nxt_int_t
nxt_stderr_start(void)
{
    int  flags, fd;

    flags = fcntl(nxt_stderr, F_GETFL);

    if (flags != -1) {
        /*
         * If the stderr output of a multithreaded application is
         * redirected to a file:
         *    Linux, Solaris and MacOSX do not write atomically to the output;
         *    MacOSX besides adds zeroes to the output.
         * O_APPEND fixes this.
         */
        (void) fcntl(nxt_stderr, F_SETFL, flags | O_APPEND);

    } else {
        /*
         * The stderr descriptor is closed before application start.
         * Reserve the stderr descriptor for future use.  Errors are
         * ignored because anyway they could be written nowhere.
         */
        fd = open("/dev/null", O_WRONLY | O_APPEND);

        if (fd != -1) {
            (void) dup2(fd, nxt_stderr);

            if (fd != nxt_stderr) {
                (void) close(fd);
            }
        }
    }

    return flags;
}


nxt_int_t
nxt_pipe_create(nxt_task_t *task, nxt_fd_t *pp, nxt_bool_t nbread,
    nxt_bool_t nbwrite)
{
    if (pipe(pp) != 0) {
        nxt_alert(task, "pipe() failed %E", nxt_errno);

        return NXT_ERROR;
    }

    nxt_debug(task, "pipe(): %FD:%FD", pp[0], pp[1]);

    if (nbread) {
        if (nxt_fd_nonblocking(task, pp[0]) != NXT_OK) {
            return NXT_ERROR;
        }
    }

    if (nbwrite) {
        if (nxt_fd_nonblocking(task, pp[1]) != NXT_OK) {
            return NXT_ERROR;
        }
    }

    return NXT_OK;
}


void
nxt_pipe_close(nxt_task_t *task, nxt_fd_t *pp)
{
    nxt_debug(task, "pipe close(%FD:%FD)", pp[0], pp[1]);

    if (close(pp[0]) != 0) {
        nxt_alert(task, "pipe close(%FD) failed %E", pp[0], nxt_errno);
    }

    if (close(pp[1]) != 0) {
        nxt_alert(task, "pipe close(%FD) failed %E", pp[1], nxt_errno);
    }
}


size_t
nxt_dir_current(char *buf, size_t len)
{
    if (nxt_fast_path(getcwd(buf, len) != NULL)) {
        return nxt_strlen(buf);
    }

    nxt_thread_log_alert("getcwd(%uz) failed %E", len, nxt_errno);

    return 0;
}