/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 */

/* Caveat emptor: this file deviates from the libuv convention of returning

 * negated errno codes. Most uv_fs_*() functions map directly to the system

 * call of the same name. For more complex wrappers, it's easier to just

 * return -1 with errno set. The dispatcher in uv__fs_work() takes care of

 * getting the errno to the right place (req->result or as the return value.)

 */

#include "uv.h"

#include "internal.h"

#include <errno.h>

#include <dlfcn.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <limits.h> /* PATH_MAX */

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <sys/uio.h>

#include <pthread.h>

#include <unistd.h>

#include <fcntl.h>

#include <poll.h>

#if defined(__DragonFly__)        ||                                      \

    defined(__FreeBSD__)          ||                                      \

    defined(__FreeBSD_kernel__)   ||                                      \

    defined(__OpenBSD__)          ||                                      \

    defined(__NetBSD__)

# define HAVE_PREADV 1

#else

# define HAVE_PREADV 0

#endif

#if defined(__linux__) || defined(__sun)

# include <sys/sendfile.h>

#endif

#if defined(__APPLE__)

# include <sys/sysctl.h>

#elif defined(__linux__) && !defined(FICLONE)

# include <sys/ioctl.h>

# define FICLONE _IOW(0x94, 9, int)

#endif

#if defined(_AIX) && !defined(_AIX71)

# include <utime.h>

#endif

#if defined(__APPLE__)            ||                                      \

    defined(__DragonFly__)        ||                                      \

    defined(__FreeBSD__)          ||                                      \

    defined(__FreeBSD_kernel__)   ||                                      \

    defined(__OpenBSD__)          ||                                      \

    defined(__NetBSD__)

# include <sys/param.h>

# include <sys/mount.h>

#elif defined(__sun) || defined(__MVS__) || defined(__NetBSD__) || defined(__HAIKU__)

# include <sys/statvfs.h>

#else

# include <sys/statfs.h>

#endif

#if defined(_AIX) && _XOPEN_SOURCE <= 600

extern char *mkdtemp(char *template); /* See issue #740 on AIX < 7 */

#endif

#define INIT(subtype)                                                         \

  do {                                                                        \

    if (req == NULL)                                                          \

      return UV_EINVAL;                                                       \

    UV_REQ_INIT(req, UV_FS);                                                  \

    req->fs_type = UV_FS_ ## subtype;                                         \

    req->result = 0;                                                          \

    req->ptr = NULL;                                                          \

    req->loop = loop;                                                         \

    req->path = NULL;                                                         \

    req->new_path = NULL;                                                     \

    req->bufs = NULL;                                                         \

    req->cb = cb;                                                             \

  }                                                                           \

  while (0)

#define PATH                                                                  \

  do {                                                                        \

    assert(path != NULL);                                                     \

    if (cb == NULL) {                                                         \

      req->path = path;                                                       \

    } else {                                                                  \

      req->path = uv__strdup(path);                                           \

      if (req->path == NULL)                                                  \

        return UV_ENOMEM;                                                     \

    }                                                                         \

  }                                                                           \

  while (0)

#define PATH2                                                                 \

  do {                                                                        \

    if (cb == NULL) {                                                         \

      req->path = path;                                                       \

      req->new_path = new_path;                                               \

    } else {                                                                  \

      size_t path_len;                                                        \

      size_t new_path_len;                                                    \

      path_len = strlen(path) + 1;                                            \

      new_path_len = strlen(new_path) + 1;                                    \

      req->path = uv__malloc(path_len + new_path_len);                        \

      if (req->path == NULL)                                                  \

        return UV_ENOMEM;                                                     \

      req->new_path = req->path + path_len;                                   \

      memcpy((void*) req->path, path, path_len);                              \

      memcpy((void*) req->new_path, new_path, new_path_len);                  \

    }                                                                         \

  }                                                                           \

  while (0)

#define POST                                                                  \

  do {                                                                        \

    if (cb != NULL) {                                                         \

      uv__req_register(loop, req);                                            \

      uv__work_submit(loop,                                                   \

                      &req->work_req,                                         \

                      UV__WORK_FAST_IO,                                       \

                      uv__fs_work,                                            \

                      uv__fs_done);                                           \

      return 0;                                                               \

    }                                                                         \

    else {                                                                    \

      uv__fs_work(&req->work_req);                                            \

      return req->result;                                                     \

    }                                                                         \

  }                                                                           \

  while (0)

static int uv__fs_close(int fd) {

  int rc;

  rc = uv__close_nocancel(fd);

  if (rc == -1)

    if (errno == EINTR || errno == EINPROGRESS)

      rc = 0;  /* The close is in progress, not an error. */

  return rc;

}

static ssize_t uv__fs_fsync(uv_fs_t* req) {

#if defined(__APPLE__)

  /* Apple's fdatasync and fsync explicitly do NOT flush the drive write cache

   * to the drive platters. This is in contrast to Linux's fdatasync and fsync

   * which do, according to recent man pages. F_FULLFSYNC is Apple's equivalent

   * for flushing buffered data to permanent storage. If F_FULLFSYNC is not

   * supported by the file system we fall back to F_BARRIERFSYNC or fsync().

   * This is the same approach taken by sqlite, except sqlite does not issue

   * an F_BARRIERFSYNC call.

   */

  int r;

  r = fcntl(req->file, F_FULLFSYNC);

  if (r != 0)

    r = fcntl(req->file, 85 /* F_BARRIERFSYNC */);  /* fsync + barrier */

  if (r != 0)

    r = fsync(req->file);

  return r;

#else

  return fsync(req->file);

#endif

}

static ssize_t uv__fs_fdatasync(uv_fs_t* req) {

#if defined(__linux__) || defined(__sun) || defined(__NetBSD__)

  return fdatasync(req->file);

#elif defined(__APPLE__)

  /* See the comment in uv__fs_fsync. */

  return uv__fs_fsync(req);

#else

  return fsync(req->file);

#endif

}

UV_UNUSED(static struct timespec uv__fs_to_timespec(double time)) {

  struct timespec ts;

  ts.tv_sec  = time;

  ts.tv_nsec = (uint64_t)(time * 1000000) % 1000000 * 1000;

  return ts;

}

UV_UNUSED(static struct timeval uv__fs_to_timeval(double time)) {

  struct timeval tv;

  tv.tv_sec  = time;

  tv.tv_usec = (uint64_t)(time * 1000000) % 1000000;

  return tv;

}

static ssize_t uv__fs_futime(uv_fs_t* req) {

#if defined(__linux__)                                                        \

    || defined(_AIX71)                                                        \

    || defined(__HAIKU__)

  /* utimesat() has nanosecond resolution but we stick to microseconds

   * for the sake of consistency with other platforms.

   */

  struct timespec ts[2];

  ts[0] = uv__fs_to_timespec(req->atime);

  ts[1] = uv__fs_to_timespec(req->mtime);

#if defined(__ANDROID_API__) && __ANDROID_API__ < 21

  return utimensat(req->file, NULL, ts, 0);

#else

  return futimens(req->file, ts);

#endif

#elif defined(__APPLE__)                                                      \

    || defined(__DragonFly__)                                                 \

    || defined(__FreeBSD__)                                                   \

    || defined(__FreeBSD_kernel__)                                            \

    || defined(__NetBSD__)                                                    \

    || defined(__OpenBSD__)                                                   \

    || defined(__sun)

  struct timeval tv[2];

  tv[0] = uv__fs_to_timeval(req->atime);

  tv[1] = uv__fs_to_timeval(req->mtime);

# if defined(__sun)

  return futimesat(req->file, NULL, tv);

# else

  return futimes(req->file, tv);

# endif

#elif defined(__MVS__)

  attrib_t atr;

  memset(&atr, 0, sizeof(atr));

  atr.att_mtimechg = 1;

  atr.att_atimechg = 1;

  atr.att_mtime = req->mtime;

  atr.att_atime = req->atime;

  return __fchattr(req->file, &atr, sizeof(atr));

#else

  errno = ENOSYS;

  return -1;

#endif

}

static ssize_t uv__fs_mkdtemp(uv_fs_t* req) {

  return mkdtemp((char*) req->path) ? 0 : -1;

}

static int (*uv__mkostemp)(char*, int);

static void uv__mkostemp_initonce(void) {

  /* z/os doesn't have RTLD_DEFAULT but that's okay

   * because it doesn't have mkostemp(O_CLOEXEC) either.

   */

#ifdef RTLD_DEFAULT

  uv__mkostemp = (int (*)(char*, int)) dlsym(RTLD_DEFAULT, "mkostemp");

  /* We don't care about errors, but we do want to clean them up.

   * If there has been no error, then dlerror() will just return

   * NULL.

   */

  dlerror();

#endif  /* RTLD_DEFAULT */

}

static int uv__fs_mkstemp(uv_fs_t* req) {

  static uv_once_t once = UV_ONCE_INIT;

  int r;

#ifdef O_CLOEXEC

  static int no_cloexec_support;

#endif

  static const char pattern[] = "XXXXXX";

  static const size_t pattern_size = sizeof(pattern) - 1;

  char* path;

  size_t path_length;

  path = (char*) req->path;

  path_length = strlen(path);

  /* EINVAL can be returned for 2 reasons:

      1. The template's last 6 characters were not XXXXXX

      2. open() didn't support O_CLOEXEC

     We want to avoid going to the fallback path in case

     of 1, so it's manually checked before. */

  if (path_length < pattern_size ||

      strcmp(path + path_length - pattern_size, pattern)) {

    errno = EINVAL;

    return -1;

  }

  uv_once(&once, uv__mkostemp_initonce);

#ifdef O_CLOEXEC

  if (no_cloexec_support == 0 && uv__mkostemp != NULL) {

    r = uv__mkostemp(path, O_CLOEXEC);

    if (r >= 0)

      return r;

    /* If mkostemp() returns EINVAL, it means the kernel doesn't

       support O_CLOEXEC, so we just fallback to mkstemp() below. */

    if (errno != EINVAL)

      return r;

    /* We set the static variable so that next calls don't even

       try to use mkostemp. */

    no_cloexec_support = 1;

  }

#endif  /* O_CLOEXEC */

  if (req->cb != NULL)

    uv_rwlock_rdlock(&req->loop->cloexec_lock);

  r = mkstemp(path);

  /* In case of failure `uv__cloexec` will leave error in `errno`,

   * so it is enough to just set `r` to `-1`.

   */

  if (r >= 0 && uv__cloexec(r, 1) != 0) {

    r = uv__close(r);

    if (r != 0)

      abort();

    r = -1;

  }

  if (req->cb != NULL)

    uv_rwlock_rdunlock(&req->loop->cloexec_lock);

  return r;

}

static ssize_t uv__fs_open(uv_fs_t* req) {

#ifdef O_CLOEXEC

  return open(req->path, req->flags | O_CLOEXEC, req->mode);

#else  /* O_CLOEXEC */

  int r;

  if (req->cb != NULL)

    uv_rwlock_rdlock(&req->loop->cloexec_lock);

  r = open(req->path, req->flags, req->mode);

  /* In case of failure `uv__cloexec` will leave error in `errno`,

   * so it is enough to just set `r` to `-1`.

   */

  if (r >= 0 && uv__cloexec(r, 1) != 0) {

    r = uv__close(r);

    if (r != 0)

      abort();

    r = -1;

  }

  if (req->cb != NULL)

    uv_rwlock_rdunlock(&req->loop->cloexec_lock);

  return r;

#endif  /* O_CLOEXEC */

}

#if !HAVE_PREADV

static ssize_t uv__fs_preadv(uv_file fd,

                             uv_buf_t* bufs,

                             unsigned int nbufs,

                             off_t off) {

  uv_buf_t* buf;

  uv_buf_t* end;

  ssize_t result;

  ssize_t rc;

  size_t pos;

  assert(nbufs > 0);

  result = 0;

  pos = 0;

  buf = bufs + 0;

  end = bufs + nbufs;

  for (;;) {

    do

      rc = pread(fd, buf->base + pos, buf->len - pos, off + result);

    while (rc == -1 && errno == EINTR);

    if (rc == 0)

      break;

    if (rc == -1 && result == 0)

      return UV__ERR(errno);

    if (rc == -1)

      break;  /* We read some data so return that, ignore the error. */

    pos += rc;

    result += rc;

    if (pos < buf->len)

      continue;

    pos = 0;

    buf += 1;

    if (buf == end)

      break;

  }

  return result;

}

#endif

static ssize_t uv__fs_read(uv_fs_t* req) {

#if defined(__linux__)

  static int no_preadv;

#endif

  unsigned int iovmax;

  ssize_t result;

  iovmax = uv__getiovmax();

  if (req->nbufs > iovmax)

    req->nbufs = iovmax;

  if (req->off < 0) {

    if (req->nbufs == 1)

      result = read(req->file, req->bufs[0].base, req->bufs[0].len);

    else

      result = readv(req->file, (struct iovec*) req->bufs, req->nbufs);

  } else {

    if (req->nbufs == 1) {

      result = pread(req->file, req->bufs[0].base, req->bufs[0].len, req->off);

      goto done;

    }

#if HAVE_PREADV

    result = preadv(req->file, (struct iovec*) req->bufs, req->nbufs, req->off);

#else

# if defined(__linux__)

    if (no_preadv) retry:

# endif

    {

      result = uv__fs_preadv(req->file, req->bufs, req->nbufs, req->off);

    }

# if defined(__linux__)

    else {

      result = uv__preadv(req->file,

                          (struct iovec*)req->bufs,

                          req->nbufs,

                          req->off);

      if (result == -1 && errno == ENOSYS) {

        no_preadv = 1;

        goto retry;

      }

    }

# endif

#endif

  }

done:

  /* Early cleanup of bufs allocation, since we're done with it. */

  if (req->bufs != req->bufsml)

    uv__free(req->bufs);

  req->bufs = NULL;

  req->nbufs = 0;

#ifdef __PASE__

  /* PASE returns EOPNOTSUPP when reading a directory, convert to EISDIR */

  if (result == -1 && errno == EOPNOTSUPP) {

    struct stat buf;

    ssize_t rc;

    rc = fstat(req->file, &buf;;

    if (rc == 0 && S_ISDIR(buf.st_mode)) {

      errno = EISDIR;

    }

  }

#endif

  return result;

}

#if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_8)

#define UV_CONST_DIRENT uv__dirent_t

#else

#define UV_CONST_DIRENT const uv__dirent_t

#endif

static int uv__fs_scandir_filter(UV_CONST_DIRENT* dent) {

  return strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0;

}

static int uv__fs_scandir_sort(UV_CONST_DIRENT** a, UV_CONST_DIRENT** b) {

  return strcmp((*a)->d_name, (*b)->d_name);

}

static ssize_t uv__fs_scandir(uv_fs_t* req) {

  uv__dirent_t** dents;

  int n;

  dents = NULL;

  n = scandir(req->path, &dents, uv__fs_scandir_filter, uv__fs_scandir_sort);

  /* NOTE: We will use nbufs as an index field */

  req->nbufs = 0;

  if (n == 0) {

    /* OS X still needs to deallocate some memory.

     * Memory was allocated using the system allocator, so use free() here.

     */

    free(dents);

    dents = NULL;

  } else if (n == -1) {

    return n;

  }

  req->ptr = dents;

  return n;

}

static int uv__fs_opendir(uv_fs_t* req) {

  uv_dir_t* dir;

  dir = uv__malloc(sizeof(*dir));

  if (dir == NULL)

    goto error;

  dir->dir = opendir(req->path);

  if (dir->dir == NULL)

    goto error;

  req->ptr = dir;

  return 0;

error:

  uv__free(dir);

  req->ptr = NULL;

  return -1;

}

static int uv__fs_readdir(uv_fs_t* req) {

  uv_dir_t* dir;

  uv_dirent_t* dirent;

  struct dirent* res;

  unsigned int dirent_idx;

  unsigned int i;

  dir = req->ptr;

  dirent_idx = 0;

  while (dirent_idx < dir->nentries) {

    /* readdir() returns NULL on end of directory, as well as on error. errno

       is used to differentiate between the two conditions. */

    errno = 0;

    res = readdir(dir->dir);

    if (res == NULL) {

      if (errno != 0)

        goto error;

      break;

    }

    if (strcmp(res->d_name, ".") == 0 || strcmp(res->d_name, "..") == 0)

      continue;

    dirent = &dir->dirents[dirent_idx];

    dirent->name = uv__strdup(res->d_name);

    if (dirent->name == NULL)

      goto error;

    dirent->type = uv__fs_get_dirent_type(res);

    ++dirent_idx;

  }

  return dirent_idx;

error:

  for (i = 0; i < dirent_idx; ++i) {

    uv__free((char*) dir->dirents[i].name);

    dir->dirents[i].name = NULL;

  }

  return -1;

}

static int uv__fs_closedir(uv_fs_t* req) {

  uv_dir_t* dir;

  dir = req->ptr;

  if (dir->dir != NULL) {

    closedir(dir->dir);

    dir->dir = NULL;

  }

  uv__free(req->ptr);

  req->ptr = NULL;

  return 0;

}

static int uv__fs_statfs(uv_fs_t* req) {

  uv_statfs_t* stat_fs;

#if defined(__sun) || defined(__MVS__) || defined(__NetBSD__) || defined(__HAIKU__)

  struct statvfs buf;

  if (0 != statvfs(req->path, &buf))

#else

  struct statfs buf;

  if (0 != statfs(req->path, &buf))

#endif /* defined(__sun) */

    return -1;

  stat_fs = uv__malloc(sizeof(*stat_fs));

  if (stat_fs == NULL) {

    errno = ENOMEM;

    return -1;

  }

#if defined(__sun) || defined(__MVS__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__HAIKU__)

  stat_fs->f_type = 0;  /* f_type is not supported. */

#else

  stat_fs->f_type = buf.f_type;

#endif

  stat_fs->f_bsize = buf.f_bsize;

  stat_fs->f_blocks = buf.f_blocks;

  stat_fs->f_bfree = buf.f_bfree;

  stat_fs->f_bavail = buf.f_bavail;

  stat_fs->f_files = buf.f_files;

  stat_fs->f_ffree = buf.f_ffree;

  req->ptr = stat_fs;

  return 0;

}

static ssize_t uv__fs_pathmax_size(const char* path) {

  ssize_t pathmax;

  pathmax = pathconf(path, _PC_PATH_MAX);

  if (pathmax == -1)

    pathmax = UV__PATH_MAX;

  return pathmax;

}

static ssize_t uv__fs_readlink(uv_fs_t* req) {

  ssize_t maxlen;

  ssize_t len;

  char* buf;

#if defined(_POSIX_PATH_MAX) || defined(PATH_MAX)

  maxlen = uv__fs_pathmax_size(req->path);

#else

  /* We may not have a real PATH_MAX.  Read size of link.  */

  struct stat st;

  int ret;

  ret = lstat(req->path, &st);

  if (ret != 0)

    return -1;

  if (!S_ISLNK(st.st_mode)) {

    errno = EINVAL;

    return -1;

  }

  maxlen = st.st_size;

  /* According to readlink(2) lstat can report st_size == 0

     for some symlinks, such as those in /proc or /sys.  */

  if (maxlen == 0)

    maxlen = uv__fs_pathmax_size(req->path);

#endif

  buf = uv__malloc(maxlen);

  if (buf == NULL) {

    errno = ENOMEM;

    return -1;

  }

#if defined(__MVS__)

  len = os390_readlink(req->path, buf, maxlen);

#else

  len = readlink(req->path, buf, maxlen);

#endif

  if (len == -1) {

    uv__free(buf);

    return -1;

  }

  /* Uncommon case: resize to make room for the trailing nul byte. */

  if (len == maxlen) {

    buf = uv__reallocf(buf, len + 1);

    if (buf == NULL)

      return -1;

  }

  buf[len] = '\0';

  req->ptr = buf;

  return 0;

}

static ssize_t uv__fs_realpath(uv_fs_t* req) {

  char* buf;

#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L

  buf = realpath(req->path, NULL);

  if (buf == NULL)

    return -1;

#else

  ssize_t len;

  len = uv__fs_pathmax_size(req->path);

  buf = uv__malloc(len + 1);

  if (buf == NULL) {

    errno = ENOMEM;

    return -1;

  }

  if (realpath(req->path, buf) == NULL) {

    uv__free(buf);

    return -1;

  }

#endif

  req->ptr = buf;

  return 0;

}

static ssize_t uv__fs_sendfile_emul(uv_fs_t* req) {

  struct pollfd pfd;

  int use_pread;

  off_t offset;

  ssize_t nsent;

  ssize_t nread;

  ssize_t nwritten;

  size_t buflen;

  size_t len;

  ssize_t n;

  int in_fd;

  int out_fd;

  char buf[8192];

  len = req->bufsml[0].len;

  in_fd = req->flags;

  out_fd = req->file;

  offset = req->off;

  use_pread = 1;

  /* Here are the rules regarding errors:

   *

   * 1. Read errors are reported only if nsent==0, otherwise we return nsent.

   *    The user needs to know that some data has already been sent, to stop

   *    them from sending it twice.

   *

   * 2. Write errors are always reported. Write errors are bad because they

   *    mean data loss: we've read data but now we can't write it out.

   *

   * We try to use pread() and fall back to regular read() if the source fd

   * doesn't support positional reads, for example when it's a pipe fd.

   *

   * If we get EAGAIN when writing to the target fd, we poll() on it until

   * it becomes writable again.

   *

   * FIXME: If we get a write error when use_pread==1, it should be safe to

   *        return the number of sent bytes instead of an error because pread()

   *        is, in theory, idempotent. However, special files in /dev or /proc

   *        may support pread() but not necessarily return the same data on

   *        successive reads.

   *

   * FIXME: There is no way now to signal that we managed to send *some* data

   *        before a write error.

   */

  for (nsent = 0; (size_t) nsent < len; ) {

    buflen = len - nsent;

    if (buflen > sizeof(buf))

      buflen = sizeof(buf);

    do

      if (use_pread)

        nread = pread(in_fd, buf, buflen, offset);

      else

        nread = read(in_fd, buf, buflen);

    while (nread == -1 && errno == EINTR);

    if (nread == 0)

      goto out;

    if (nread == -1) {

      if (use_pread && nsent == 0 && (errno == EIO || errno == ESPIPE)) {

        use_pread = 0;

        continue;

      }

      if (nsent == 0)

        nsent = -1;

      goto out;

    }

    for (nwritten = 0; nwritten < nread; ) {

      do

        n = write(out_fd, buf + nwritten, nread - nwritten);

      while (n == -1 && errno == EINTR);

      if (n != -1) {

        nwritten += n;

        continue;

      }

      if (errno != EAGAIN && errno != EWOULDBLOCK) {

        nsent = -1;

        goto out;

      }

      pfd.fd = out_fd;

      pfd.events = POLLOUT;

      pfd.revents = 0;

      do

        n = poll(&pfd, 1, -1);

      while (n == -1 && errno == EINTR);

      if (n == -1 || (pfd.revents & ~POLLOUT) != 0) {

        errno = EIO;

        nsent = -1;

        goto out;

      }

    }

    offset += nread;

    nsent += nread;

  }

out:

  if (nsent != -1)

    req->off = offset;

  return nsent;

}

static ssize_t uv__fs_sendfile(uv_fs_t* req) {

  int in_fd;

  int out_fd;