/* 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.

 */

#include <assert.h>

#include <stdlib.h>

#include <direct.h>

#include <errno.h>

#include <fcntl.h>

#include <io.h>

#include <limits.h>

#include <sys/stat.h>

#include <sys/utime.h>

#include <stdio.h>

#include "uv.h"

#include "internal.h"

#include "req-inl.h"

#include "handle-inl.h"

#include "fs-fd-hash-inl.h"

#define UV_FS_FREE_PATHS         0x0002

#define UV_FS_FREE_PTR           0x0008

#define UV_FS_CLEANEDUP          0x0010

#define INIT(subtype)                                                         \

  do {                                                                        \

    if (req == NULL)                                                          \

      return UV_EINVAL;                                                       \

    uv_fs_req_init(loop, req, subtype, cb);                                   \

  }                                                                           \

  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)

#define SET_REQ_RESULT(req, result_value)                                   \

  do {                                                                      \

    req->result = (result_value);                                           \

    assert(req->result != -1);                                              \

  } while (0)

#define SET_REQ_WIN32_ERROR(req, sys_errno)                                 \

  do {                                                                      \

    req->sys_errno_ = (sys_errno);                                          \

    req->result = uv_translate_sys_error(req->sys_errno_);                  \

  } while (0)

#define SET_REQ_UV_ERROR(req, uv_errno, sys_errno)                          \

  do {                                                                      \

    req->result = (uv_errno);                                               \

    req->sys_errno_ = (sys_errno);                                          \

  } while (0)

#define VERIFY_FD(fd, req)                                                  \

  if (fd == -1) {                                                           \

    req->result = UV_EBADF;                                                 \

    req->sys_errno_ = ERROR_INVALID_HANDLE;                                 \

    return;                                                                 \

  }

#define MILLIONu (1000U * 1000U)

#define BILLIONu (1000U * 1000U * 1000U)

#define FILETIME_TO_UINT(filetime)                                          \

   (*((uint64_t*) &(filetime)) - (uint64_t) 116444736 * BILLIONu)

#define FILETIME_TO_TIME_T(filetime)                                        \

   (FILETIME_TO_UINT(filetime) / (10u * MILLIONu))

#define FILETIME_TO_TIME_NS(filetime, secs)                                 \

   ((FILETIME_TO_UINT(filetime) - (secs * (uint64_t) 10 * MILLIONu)) * 100U)

#define FILETIME_TO_TIMESPEC(ts, filetime)                                  \

   do {                                                                     \

     (ts).tv_sec = (long) FILETIME_TO_TIME_T(filetime);                     \

     (ts).tv_nsec = (long) FILETIME_TO_TIME_NS(filetime, (ts).tv_sec);      \

   } while(0)

#define TIME_T_TO_FILETIME(time, filetime_ptr)                              \

  do {                                                                      \

    uint64_t bigtime = ((uint64_t) ((time) * (uint64_t) 10 * MILLIONu)) +   \

                       (uint64_t) 116444736 * BILLIONu;                     \

    (filetime_ptr)->dwLowDateTime = bigtime & 0xFFFFFFFF;                   \

    (filetime_ptr)->dwHighDateTime = bigtime >> 32;                         \

  } while(0)

#define IS_SLASH(c) ((c) == L'\\' || (c) == L'/')

#define IS_LETTER(c) (((c) >= L'a' && (c) <= L'z') || \

  ((c) >= L'A' && (c) <= L'Z'))

#define MIN(a,b) (((a) < (b)) ? (a) : (b))

const WCHAR JUNCTION_PREFIX[] = L"\\??\\";

const WCHAR JUNCTION_PREFIX_LEN = 4;

const WCHAR LONG_PATH_PREFIX[] = L"\\\\?\\";

const WCHAR LONG_PATH_PREFIX_LEN = 4;

const WCHAR UNC_PATH_PREFIX[] = L"\\\\?\\UNC\\";

const WCHAR UNC_PATH_PREFIX_LEN = 8;

static int uv__file_symlink_usermode_flag = SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;

static DWORD uv__allocation_granularity;

void uv_fs_init(void) {

  SYSTEM_INFO system_info;

  GetSystemInfo(&system_info);

  uv__allocation_granularity = system_info.dwAllocationGranularity;

  uv__fd_hash_init();

}

INLINE static int fs__capture_path(uv_fs_t* req, const char* path,

    const char* new_path, const int copy_path) {

  char* buf;

  char* pos;

  ssize_t buf_sz = 0, path_len = 0, pathw_len = 0, new_pathw_len = 0;

  /* new_path can only be set if path is also set. */

  assert(new_path == NULL || path != NULL);

  if (path != NULL) {

    pathw_len = MultiByteToWideChar(CP_UTF8,

                                    0,

                                    path,

                                    -1,

                                    NULL,

                                    0);

    if (pathw_len == 0) {

      return GetLastError();

    }

    buf_sz += pathw_len * sizeof(WCHAR);

  }

  if (path != NULL && copy_path) {

    path_len = 1 + strlen(path);

    buf_sz += path_len;

  }

  if (new_path != NULL) {

    new_pathw_len = MultiByteToWideChar(CP_UTF8,

                                        0,

                                        new_path,

                                        -1,

                                        NULL,

                                        0);

    if (new_pathw_len == 0) {

      return GetLastError();

    }

    buf_sz += new_pathw_len * sizeof(WCHAR);

  }

  if (buf_sz == 0) {

    req->file.pathw = NULL;

    req->fs.info.new_pathw = NULL;

    req->path = NULL;

    return 0;

  }

  buf = (char*) uv__malloc(buf_sz);

  if (buf == NULL) {

    return ERROR_OUTOFMEMORY;

  }

  pos = buf;

  if (path != NULL) {

    DWORD r = MultiByteToWideChar(CP_UTF8,

                                  0,

                                  path,

                                  -1,

                                  (WCHAR*) pos,

                                  pathw_len);

    assert(r == (DWORD) pathw_len);

    req->file.pathw = (WCHAR*) pos;

    pos += r * sizeof(WCHAR);

  } else {

    req->file.pathw = NULL;

  }

  if (new_path != NULL) {

    DWORD r = MultiByteToWideChar(CP_UTF8,

                                  0,

                                  new_path,

                                  -1,

                                  (WCHAR*) pos,

                                  new_pathw_len);

    assert(r == (DWORD) new_pathw_len);

    req->fs.info.new_pathw = (WCHAR*) pos;

    pos += r * sizeof(WCHAR);

  } else {

    req->fs.info.new_pathw = NULL;

  }

  req->path = path;

  if (path != NULL && copy_path) {

    memcpy(pos, path, path_len);

    assert(path_len == buf_sz - (pos - buf));

    req->path = pos;

  }

  req->flags |= UV_FS_FREE_PATHS;

  return 0;

}

INLINE static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req,

    uv_fs_type fs_type, const uv_fs_cb cb) {

  uv__once_init();

  UV_REQ_INIT(req, UV_FS);

  req->loop = loop;

  req->flags = 0;

  req->fs_type = fs_type;

  req->sys_errno_ = 0;

  req->result = 0;

  req->ptr = NULL;

  req->path = NULL;

  req->cb = cb;

  memset(&req->fs, 0, sizeof(req->fs));

}

static int fs__wide_to_utf8(WCHAR* w_source_ptr,

                               DWORD w_source_len,

                               char** target_ptr,

                               uint64_t* target_len_ptr) {

  int r;

  int target_len;

  char* target;

  target_len = WideCharToMultiByte(CP_UTF8,

                                   0,

                                   w_source_ptr,

                                   w_source_len,

                                   NULL,

                                   0,

                                   NULL,

                                   NULL);

  if (target_len == 0) {

    return -1;

  }

  if (target_len_ptr != NULL) {

    *target_len_ptr = target_len;

  }

  if (target_ptr == NULL) {

    return 0;

  }

  target = uv__malloc(target_len + 1);

  if (target == NULL) {

    SetLastError(ERROR_OUTOFMEMORY);

    return -1;

  }

  r = WideCharToMultiByte(CP_UTF8,

                          0,

                          w_source_ptr,

                          w_source_len,

                          target,

                          target_len,

                          NULL,

                          NULL);

  assert(r == target_len);

  target[target_len] = '\0';

  *target_ptr = target;

  return 0;

}

INLINE static int fs__readlink_handle(HANDLE handle, char** target_ptr,

    uint64_t* target_len_ptr) {

  char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];

  REPARSE_DATA_BUFFER* reparse_data = (REPARSE_DATA_BUFFER*) buffer;

  WCHAR* w_target;

  DWORD w_target_len;

  DWORD bytes;

  size_t i;

  size_t len;

  if (!DeviceIoControl(handle,

                       FSCTL_GET_REPARSE_POINT,

                       NULL,

                       0,

                       buffer,

                       sizeof buffer,

                       &bytes,

                       NULL)) {

    return -1;

  }

  if (reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK) {

    /* Real symlink */

    w_target = reparse_data->SymbolicLinkReparseBuffer.PathBuffer +

        (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset /

        sizeof(WCHAR));

    w_target_len =

        reparse_data->SymbolicLinkReparseBuffer.SubstituteNameLength /

        sizeof(WCHAR);

    /* Real symlinks can contain pretty much everything, but the only thing we

     * really care about is undoing the implicit conversion to an NT namespaced

     * path that CreateSymbolicLink will perform on absolute paths. If the path

     * is win32-namespaced then the user must have explicitly made it so, and

     * we better just return the unmodified reparse data. */

    if (w_target_len >= 4 &&

        w_target[0] == L'\\' &&

        w_target[1] == L'?' &&

        w_target[2] == L'?' &&

        w_target[3] == L'\\') {

      /* Starts with \??\ */

      if (w_target_len >= 6 &&

          ((w_target[4] >= L'A' && w_target[4] <= L'Z') ||

           (w_target[4] >= L'a' && w_target[4] <= L'z')) &&

          w_target[5] == L':' &&

          (w_target_len == 6 || w_target[6] == L'\\')) {

        /* \??\<drive>:\ */

        w_target += 4;

        w_target_len -= 4;

      } else if (w_target_len >= 8 &&

                 (w_target[4] == L'U' || w_target[4] == L'u') &&

                 (w_target[5] == L'N' || w_target[5] == L'n') &&

                 (w_target[6] == L'C' || w_target[6] == L'c') &&

                 w_target[7] == L'\\') {

        /* \??\UNC\<server>\<share>\ - make sure the final path looks like

         * \\<server>\<share>\ */

        w_target += 6;

        w_target[0] = L'\\';

        w_target_len -= 6;

      }

    }

  } else if (reparse_data->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) {

    /* Junction. */

    w_target = reparse_data->MountPointReparseBuffer.PathBuffer +

        (reparse_data->MountPointReparseBuffer.SubstituteNameOffset /

        sizeof(WCHAR));

    w_target_len = reparse_data->MountPointReparseBuffer.SubstituteNameLength /

        sizeof(WCHAR);

    /* Only treat junctions that look like \??\<drive>:\ as symlink. Junctions

     * can also be used as mount points, like \??\Volume{<guid>}, but that's

     * confusing for programs since they wouldn't be able to actually

     * understand such a path when returned by uv_readlink(). UNC paths are

     * never valid for junctions so we don't care about them. */

    if (!(w_target_len >= 6 &&

          w_target[0] == L'\\' &&

          w_target[1] == L'?' &&

          w_target[2] == L'?' &&

          w_target[3] == L'\\' &&

          ((w_target[4] >= L'A' && w_target[4] <= L'Z') ||

           (w_target[4] >= L'a' && w_target[4] <= L'z')) &&

          w_target[5] == L':' &&

          (w_target_len == 6 || w_target[6] == L'\\'))) {

      SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

      return -1;

    }

    /* Remove leading \??\ */

    w_target += 4;

    w_target_len -= 4;

  } else if (reparse_data->ReparseTag == IO_REPARSE_TAG_APPEXECLINK) {

    /* String #3 in the list has the target filename. */

    if (reparse_data->AppExecLinkReparseBuffer.StringCount < 3) {

      SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

      return -1;

    }

    w_target = reparse_data->AppExecLinkReparseBuffer.StringList;

    /* The StringList buffer contains a list of strings separated by "\0",   */

    /* with "\0\0" terminating the list. Move to the 3rd string in the list: */

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

      len = wcslen(w_target);

      if (len == 0) {

        SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

        return -1;

      }

      w_target += len + 1;

    }

    w_target_len = wcslen(w_target);

    if (w_target_len == 0) {

      SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

      return -1;

    }

    /* Make sure it is an absolute path. */

    if (!(w_target_len >= 3 &&

         ((w_target[0] >= L'a' && w_target[0] <= L'z') ||

          (w_target[0] >= L'A' && w_target[0] <= L'Z')) &&

         w_target[1] == L':' &&

         w_target[2] == L'\\')) {

      SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

      return -1;

    }

  } else {

    /* Reparse tag does not indicate a symlink. */

    SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

    return -1;

  }

  return fs__wide_to_utf8(w_target, w_target_len, target_ptr, target_len_ptr);

}

void fs__open(uv_fs_t* req) {

  DWORD access;

  DWORD share;

  DWORD disposition;

  DWORD attributes = 0;

  HANDLE file;

  int fd, current_umask;

  int flags = req->fs.info.file_flags;

  struct uv__fd_info_s fd_info;

  /* Adjust flags to be compatible with the memory file mapping. Save the

   * original flags to emulate the correct behavior. */

  if (flags & UV_FS_O_FILEMAP) {

    fd_info.flags = flags;

    fd_info.current_pos.QuadPart = 0;

    if ((flags & (UV_FS_O_RDONLY | UV_FS_O_WRONLY | UV_FS_O_RDWR)) ==

        UV_FS_O_WRONLY) {

      /* CreateFileMapping always needs read access */

      flags = (flags & ~UV_FS_O_WRONLY) | UV_FS_O_RDWR;

    }

    if (flags & UV_FS_O_APPEND) {

      /* Clear the append flag and ensure RDRW mode */

      flags &= ~UV_FS_O_APPEND;

      flags &= ~(UV_FS_O_RDONLY | UV_FS_O_WRONLY | UV_FS_O_RDWR);

      flags |= UV_FS_O_RDWR;

    }

  }

  /* Obtain the active umask. umask() never fails and returns the previous

   * umask. */

  current_umask = umask(0);

  umask(current_umask);

  /* convert flags and mode to CreateFile parameters */

  switch (flags & (UV_FS_O_RDONLY | UV_FS_O_WRONLY | UV_FS_O_RDWR)) {

  case UV_FS_O_RDONLY:

    access = FILE_GENERIC_READ;

    break;

  case UV_FS_O_WRONLY:

    access = FILE_GENERIC_WRITE;

    break;

  case UV_FS_O_RDWR:

    access = FILE_GENERIC_READ | FILE_GENERIC_WRITE;

    break;

  default:

    goto einval;

  }

  if (flags & UV_FS_O_APPEND) {

    access &= ~FILE_WRITE_DATA;

    access |= FILE_APPEND_DATA;

  }

  /*

   * Here is where we deviate significantly from what CRT's _open()

   * does. We indiscriminately use all the sharing modes, to match

   * UNIX semantics. In particular, this ensures that the file can

   * be deleted even whilst it's open, fixing issue

   * https://github.com/nodejs/node-v0.x-archive/issues/1449.

   * We still support exclusive sharing mode, since it is necessary

   * for opening raw block devices, otherwise Windows will prevent

   * any attempt to write past the master boot record.

   */

  if (flags & UV_FS_O_EXLOCK) {

    share = 0;

  } else {

    share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;

  }

  switch (flags & (UV_FS_O_CREAT | UV_FS_O_EXCL | UV_FS_O_TRUNC)) {

  case 0:

  case UV_FS_O_EXCL:

    disposition = OPEN_EXISTING;

    break;

  case UV_FS_O_CREAT:

    disposition = OPEN_ALWAYS;

    break;

  case UV_FS_O_CREAT | UV_FS_O_EXCL:

  case UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL:

    disposition = CREATE_NEW;

    break;

  case UV_FS_O_TRUNC:

  case UV_FS_O_TRUNC | UV_FS_O_EXCL:

    disposition = TRUNCATE_EXISTING;

    break;

  case UV_FS_O_CREAT | UV_FS_O_TRUNC:

    disposition = CREATE_ALWAYS;

    break;

  default:

    goto einval;

  }

  attributes |= FILE_ATTRIBUTE_NORMAL;

  if (flags & UV_FS_O_CREAT) {

    if (!((req->fs.info.mode & ~current_umask) & _S_IWRITE)) {

      attributes |= FILE_ATTRIBUTE_READONLY;

    }

  }

  if (flags & UV_FS_O_TEMPORARY ) {

    attributes |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;

    access |= DELETE;

  }

  if (flags & UV_FS_O_SHORT_LIVED) {

    attributes |= FILE_ATTRIBUTE_TEMPORARY;

  }

  switch (flags & (UV_FS_O_SEQUENTIAL | UV_FS_O_RANDOM)) {

  case 0:

    break;

  case UV_FS_O_SEQUENTIAL:

    attributes |= FILE_FLAG_SEQUENTIAL_SCAN;

    break;

  case UV_FS_O_RANDOM:

    attributes |= FILE_FLAG_RANDOM_ACCESS;

    break;

  default:

    goto einval;

  }

  if (flags & UV_FS_O_DIRECT) {

    /*

     * FILE_APPEND_DATA and FILE_FLAG_NO_BUFFERING are mutually exclusive.

     * Windows returns 87, ERROR_INVALID_PARAMETER if these are combined.

     *

     * FILE_APPEND_DATA is included in FILE_GENERIC_WRITE:

     *

     * FILE_GENERIC_WRITE = STANDARD_RIGHTS_WRITE |

     *                      FILE_WRITE_DATA |

     *                      FILE_WRITE_ATTRIBUTES |

     *                      FILE_WRITE_EA |

     *                      FILE_APPEND_DATA |

     *                      SYNCHRONIZE

     *

     * Note: Appends are also permitted by FILE_WRITE_DATA.

     *

     * In order for direct writes and direct appends to succeed, we therefore

     * exclude FILE_APPEND_DATA if FILE_WRITE_DATA is specified, and otherwise

     * fail if the user's sole permission is a direct append, since this

     * particular combination is invalid.

     */

    if (access & FILE_APPEND_DATA) {

      if (access & FILE_WRITE_DATA) {

        access &= ~FILE_APPEND_DATA;

      } else {

        goto einval;

      }

    }

    attributes |= FILE_FLAG_NO_BUFFERING;

  }

  switch (flags & (UV_FS_O_DSYNC | UV_FS_O_SYNC)) {

  case 0:

    break;

  case UV_FS_O_DSYNC:

  case UV_FS_O_SYNC:

    attributes |= FILE_FLAG_WRITE_THROUGH;

    break;

  default:

    goto einval;

  }

  /* Setting this flag makes it possible to open a directory. */

  attributes |= FILE_FLAG_BACKUP_SEMANTICS;

  file = CreateFileW(req->file.pathw,

                     access,

                     share,

                     NULL,

                     disposition,

                     attributes,

                     NULL);

  if (file == INVALID_HANDLE_VALUE) {

    DWORD error = GetLastError();

    if (error == ERROR_FILE_EXISTS && (flags & UV_FS_O_CREAT) &&

        !(flags & UV_FS_O_EXCL)) {

      /* Special case: when ERROR_FILE_EXISTS happens and UV_FS_O_CREAT was

       * specified, it means the path referred to a directory. */

      SET_REQ_UV_ERROR(req, UV_EISDIR, error);

    } else {

      SET_REQ_WIN32_ERROR(req, GetLastError());

    }

    return;

  }

  fd = _open_osfhandle((intptr_t) file, flags);

  if (fd < 0) {

    /* The only known failure mode for _open_osfhandle() is EMFILE, in which

     * case GetLastError() will return zero. However we'll try to handle other

     * errors as well, should they ever occur.

     */

    if (errno == EMFILE)

      SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES);

    else if (GetLastError() != ERROR_SUCCESS)

      SET_REQ_WIN32_ERROR(req, GetLastError());

    else

      SET_REQ_WIN32_ERROR(req, (DWORD) UV_UNKNOWN);

    CloseHandle(file);

    return;

  }

  if (flags & UV_FS_O_FILEMAP) {

    FILE_STANDARD_INFO file_info;

    if (!GetFileInformationByHandleEx(file,

                                      FileStandardInfo,

                                      &file_info,

                                      sizeof file_info)) {

      SET_REQ_WIN32_ERROR(req, GetLastError());

      CloseHandle(file);

      return;

    }

    fd_info.is_directory = file_info.Directory;

    if (fd_info.is_directory) {

      fd_info.size.QuadPart = 0;

      fd_info.mapping = INVALID_HANDLE_VALUE;

    } else {

      if (!GetFileSizeEx(file, &fd_info.size)) {

        SET_REQ_WIN32_ERROR(req, GetLastError());

        CloseHandle(file);

        return;

      }

      if (fd_info.size.QuadPart == 0) {

        fd_info.mapping = INVALID_HANDLE_VALUE;

      } else {

        DWORD flProtect = (fd_info.flags & (UV_FS_O_RDONLY | UV_FS_O_WRONLY |

          UV_FS_O_RDWR)) == UV_FS_O_RDONLY ? PAGE_READONLY : PAGE_READWRITE;

        fd_info.mapping = CreateFileMapping(file,

                                            NULL,

                                            flProtect,

                                            fd_info.size.HighPart,

                                            fd_info.size.LowPart,

                                            NULL);

        if (fd_info.mapping == NULL) {

          SET_REQ_WIN32_ERROR(req, GetLastError());

          CloseHandle(file);

          return;

        }

      }

    }

    uv__fd_hash_add(fd, &fd_info);

  }

  SET_REQ_RESULT(req, fd);

  return;

 einval:

  SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);

}

void fs__close(uv_fs_t* req) {

  int fd = req->file.fd;

  int result;

  struct uv__fd_info_s fd_info;

  VERIFY_FD(fd, req);

  if (uv__fd_hash_remove(fd, &fd_info)) {

    if (fd_info.mapping != INVALID_HANDLE_VALUE) {

      CloseHandle(fd_info.mapping);

    }

  }

  if (fd > 2)

    result = _close(fd);

  else

    result = 0;

  /* _close doesn't set _doserrno on failure, but it does always set errno

   * to EBADF on failure.

   */

  if (result == -1) {

    assert(errno == EBADF);

    SET_REQ_UV_ERROR(req, UV_EBADF, ERROR_INVALID_HANDLE);

  } else {

    SET_REQ_RESULT(req, 0);

  }

}

LONG fs__filemap_ex_filter(LONG excode, PEXCEPTION_POINTERS pep,

                           int* perror) {

  if (excode != (LONG)EXCEPTION_IN_PAGE_ERROR) {

    return EXCEPTION_CONTINUE_SEARCH;

  }

  assert(perror != NULL);

  if (pep != NULL && pep->ExceptionRecord != NULL &&

      pep->ExceptionRecord->NumberParameters >= 3) {

    NTSTATUS status = (NTSTATUS)pep->ExceptionRecord->ExceptionInformation[3];

    *perror = pRtlNtStatusToDosError(status);

    if (*perror != ERROR_SUCCESS) {

      return EXCEPTION_EXECUTE_HANDLER;

    }

  }

  *perror = UV_UNKNOWN;

  return EXCEPTION_EXECUTE_HANDLER;

}

void fs__read_filemap(uv_fs_t* req, struct uv__fd_info_s* fd_info) {

  int fd = req->file.fd; /* VERIFY_FD done in fs__read */

  int rw_flags = fd_info->flags &

    (UV_FS_O_RDONLY | UV_FS_O_WRONLY | UV_FS_O_RDWR);

  size_t read_size, done_read;

  unsigned int index;

  LARGE_INTEGER pos, end_pos;

  size_t view_offset;

  LARGE_INTEGER view_base;

  void* view;

  if (rw_flags == UV_FS_O_WRONLY) {

    SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);

    return;

  }

  if (fd_info->is_directory) {

    SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION);

    return;

  }

  if (req->fs.info.offset == -1) {

    pos = fd_info->current_pos;

  } else {

    pos.QuadPart = req->fs.info.offset;

  }

  /* Make sure we wont read past EOF. */

  if (pos.QuadPart >= fd_info->size.QuadPart) {

    SET_REQ_RESULT(req, 0);

    return;

  }

  read_size = 0;

  for (index = 0; index < req->fs.info.nbufs; ++index) {

    read_size += req->fs.info.bufs[index].len;

  }

  read_size = (size_t) MIN((LONGLONG) read_size,

                           fd_info->size.QuadPart - pos.QuadPart);

  if (read_size == 0) {

    SET_REQ_RESULT(req, 0);

    return;

  }

  end_pos.QuadPart = pos.QuadPart + read_size;

  view_offset = pos.QuadPart % uv__allocation_granularity;

  view_base.QuadPart = pos.QuadPart - view_offset;

  view = MapViewOfFile(fd_info->mapping,

                       FILE_MAP_READ,

                       view_base.HighPart,

                       view_base.LowPart,

                       view_offset + read_size);

  if (view == NULL) {

    SET_REQ_WIN32_ERROR(req, GetLastError());

    return;

  }

  done_read = 0;

  for (index = 0;

       index < req->fs.info.nbufs && done_read < read_size;

       ++index) {

    size_t this_read_size = MIN(req->fs.info.bufs[index].len,

                                read_size - done_read);

#ifdef _MSC_VER

    int err = 0;

    __try {

#endif

      memcpy(req->fs.info.bufs[index].base,

             (char*)view + view_offset + done_read,

             this_read_size);

#ifdef _MSC_VER

    }

    __except (fs__filemap_ex_filter(GetExceptionCode(),

                                    GetExceptionInformation(), &err)) {

      SET_REQ_WIN32_ERROR(req, err);

      UnmapViewOfFile(view);

      return;

    }

#endif

    done_read += this_read_size;

  }

  assert(done_read == read_size);

  if (!UnmapViewOfFile(view)) {

    SET_REQ_WIN32_ERROR(req, GetLastError());

    return;

  }

  if (req->fs.info.offset == -1) {

    fd_info->current_pos = end_pos;

    uv__fd_hash_add(fd, fd_info);

  }

  SET_REQ_RESULT(req, read_size);

  return;

}

void fs__read(uv_fs_t* req) {

  int fd = req->file.fd;

  int64_t offset = req->fs.info.offset;

  HANDLE handle;

  OVERLAPPED overlapped, *overlapped_ptr;

  LARGE_INTEGER offset_;

  DWORD bytes;

  DWORD error;

  int result;

  unsigned int index;

  LARGE_INTEGER original_position;

  LARGE_INTEGER zero_offset;

  int restore_position;

  struct uv__fd_info_s fd_info;

  VERIFY_FD(fd, req);

  if (uv__fd_hash_get(fd, &fd_info)) {

    fs__read_filemap(req, &fd_info);

    return;

  }

  zero_offset.QuadPart = 0;

  restore_position = 0;

  handle = uv__get_osfhandle(fd);

  if (handle == INVALID_HANDLE_VALUE) {

    SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);

    return;