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

#define UV_FS_FREE_PATHS 0x0002

#define UV_FS_FREE_PTR 0x0008

#define UV_FS_CLEANEDUP 0x0010

#define QUEUE_FS_TP_JOB(loop, req) \

do { \

uv__req_register(loop, req); \

uv__work_submit((loop), &(req)->work_req, uv__fs_work, uv__fs_done); \

} while (0)

#define SET_REQ_RESULT(req, result_value) \

do { \

req->result = (result_value); \

if (req->result == -1) { \

req->sys_errno_ = _doserrno; \

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

} \

} 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 FILETIME_TO_UINT(filetime) \

(*((uint64_t*) &(filetime)) - 116444736000000000ULL)

#define FILETIME_TO_TIME_T(filetime) \

(FILETIME_TO_UINT(filetime) / 10000000ULL)

#define FILETIME_TO_TIME_NS(filetime, secs) \

((FILETIME_TO_UINT(filetime) - (secs * 10000000ULL)) * 100)

#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 = ((int64_t) (time) * 10000000LL) + \

116444736000000000ULL; \

(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'))

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

const WCHAR JUNCTION_PREFIX_LEN = 4;

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

const WCHAR LONG_PATH_PREFIX_LEN = 4;

void uv_fs_init() {

_fmode = _O_BINARY;

}

INLINE static int fs__capture_path(uv_loop_t* loop, 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, 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;

}

if (!copy_path) {

req->path = path;

} else if (path) {

memcpy(pos, path, path_len);

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

req->path = pos;

} else {

req->path = NULL;

}

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_req_init(loop, (uv_req_t*) req);

req->type = UV_FS;

req->loop = loop;

req->flags = 0;

req->fs_type = fs_type;

req->result = 0;

req->ptr = NULL;

req->path = NULL;

req->cb = cb;

}

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;

char* target;

int target_len;

DWORD bytes;

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 {

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

SetLastError(ERROR_SYMLINK_NOT_SUPPORTED);

return -1;

}

/* If needed, compute the length of the target. */

if (target_ptr != NULL || target_len_ptr != NULL) {

/* Compute the length of the target. */

target_len = WideCharToMultiByte(CP_UTF8,

0,

w_target,

w_target_len,

NULL,

0,

NULL,

NULL);

if (target_len == 0) {

return -1;

}

}

/* If requested, allocate memory and convert to UTF8. */

if (target_ptr != NULL) {

int r;

target = (char*) uv__malloc(target_len + 1);

if (target == NULL) {

SetLastError(ERROR_OUTOFMEMORY);

return -1;

}

r = WideCharToMultiByte(CP_UTF8,

0,

w_target,

w_target_len,

target,

target_len,

NULL,

NULL);

assert(r == target_len);

target[target_len] = '\0';

*target_ptr = target;

}

if (target_len_ptr != NULL) {

*target_len_ptr = target_len;

}

return 0;

}

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;

/* 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 & (_O_RDONLY | _O_WRONLY | _O_RDWR)) {

case _O_RDONLY:

access = FILE_GENERIC_READ;

attributes |= FILE_FLAG_BACKUP_SEMANTICS;

break;

case _O_WRONLY:

access = FILE_GENERIC_WRITE;

break;

case _O_RDWR:

access = FILE_GENERIC_READ | FILE_GENERIC_WRITE;

break;

default:

goto einval;

}

if (flags & _O_APPEND) {

access &= ~FILE_WRITE_DATA;

access |= FILE_APPEND_DATA;

attributes &= ~FILE_FLAG_BACKUP_SEMANTICS;

}

/*

* 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 #1449.

*/

share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;

switch (flags & (_O_CREAT | _O_EXCL | _O_TRUNC)) {

case 0:

case _O_EXCL:

disposition = OPEN_EXISTING;

break;

case _O_CREAT:

disposition = OPEN_ALWAYS;

break;

case _O_CREAT | _O_EXCL:

case _O_CREAT | _O_TRUNC | _O_EXCL:

disposition = CREATE_NEW;

break;

case _O_TRUNC:

case _O_TRUNC | _O_EXCL:

disposition = TRUNCATE_EXISTING;

break;

case _O_CREAT | _O_TRUNC:

disposition = CREATE_ALWAYS;

break;

default:

goto einval;

}

attributes |= FILE_ATTRIBUTE_NORMAL;

if (flags & _O_CREAT) {

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

attributes |= FILE_ATTRIBUTE_READONLY;

}

}

if (flags & _O_TEMPORARY ) {

attributes |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;

access |= DELETE;

}

if (flags & _O_SHORT_LIVED) {

attributes |= FILE_ATTRIBUTE_TEMPORARY;

}

switch (flags & (_O_SEQUENTIAL | _O_RANDOM)) {

case 0:

break;

case _O_SEQUENTIAL:

attributes |= FILE_FLAG_SEQUENTIAL_SCAN;

break;

case _O_RANDOM:

attributes |= FILE_FLAG_RANDOM_ACCESS;

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 & _O_CREAT) &&

!(flags & _O_EXCL)) {

/* Special case: when ERROR_FILE_EXISTS happens and 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, UV_UNKNOWN);

CloseHandle(file);

return;

}

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;

VERIFY_FD(fd, req);

result = _close(fd);

SET_REQ_RESULT(req, result);

}

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;

VERIFY_FD(fd, req);

handle = uv__get_osfhandle(fd);

if (handle == INVALID_HANDLE_VALUE) {

SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);

return;

}

if (offset != -1) {

memset(&overlapped, 0, sizeof overlapped);

overlapped_ptr = &overlapped;

} else {

overlapped_ptr = NULL;

}

index = 0;

bytes = 0;

do {

DWORD incremental_bytes;

if (offset != -1) {

offset_.QuadPart = offset + bytes;

overlapped.Offset = offset_.LowPart;

overlapped.OffsetHigh = offset_.HighPart;

}

result = ReadFile(handle,

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

req->fs.info.bufs[index].len,

&incremental_bytes,

overlapped_ptr);

bytes += incremental_bytes;

++index;

} while (result && index < req->fs.info.nbufs);

if (result || bytes > 0) {

SET_REQ_RESULT(req, bytes);

} else {

error = GetLastError();

if (error == ERROR_HANDLE_EOF) {

SET_REQ_RESULT(req, bytes);

} else {

SET_REQ_WIN32_ERROR(req, error);

}

}

}

void fs__write(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;

int result;

unsigned int index;

VERIFY_FD(fd, req);

handle = uv__get_osfhandle(fd);

if (handle == INVALID_HANDLE_VALUE) {

SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);

return;

}

if (offset != -1) {

memset(&overlapped, 0, sizeof overlapped);

overlapped_ptr = &overlapped;

} else {

overlapped_ptr = NULL;

}

index = 0;

bytes = 0;

do {

DWORD incremental_bytes;

if (offset != -1) {

offset_.QuadPart = offset + bytes;

overlapped.Offset = offset_.LowPart;

overlapped.OffsetHigh = offset_.HighPart;

}

result = WriteFile(handle,

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

req->fs.info.bufs[index].len,

&incremental_bytes,

overlapped_ptr);

bytes += incremental_bytes;

++index;

} while (result && index < req->fs.info.nbufs);

if (result || bytes > 0) {

SET_REQ_RESULT(req, bytes);

} else {

SET_REQ_WIN32_ERROR(req, GetLastError());

}

}

void fs__rmdir(uv_fs_t* req) {

int result = _wrmdir(req->file.pathw);

SET_REQ_RESULT(req, result);

}

void fs__unlink(uv_fs_t* req) {

const WCHAR* pathw = req->file.pathw;

HANDLE handle;

BY_HANDLE_FILE_INFORMATION info;

FILE_DISPOSITION_INFORMATION disposition;

IO_STATUS_BLOCK iosb;

NTSTATUS status;

handle = CreateFileW(pathw,

FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | DELETE,

FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,

NULL,

OPEN_EXISTING,

FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,

NULL);

if (handle == INVALID_HANDLE_VALUE) {

SET_REQ_WIN32_ERROR(req, GetLastError());

return;

}

if (!GetFileInformationByHandle(handle, &info)) {

SET_REQ_WIN32_ERROR(req, GetLastError());

CloseHandle(handle);

return;

}

if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {

/* Do not allow deletion of directories, unless it is a symlink. When */

/* the path refers to a non-symlink directory, report EPERM as mandated */

/* by POSIX.1. */

/* Check if it is a reparse point. If it's not, it's a normal directory. */

if (!(info.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {

SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);

CloseHandle(handle);

return;

}

/* Read the reparse point and check if it is a valid symlink. */

/* If not, don't unlink. */

if (fs__readlink_handle(handle, NULL, NULL) < 0) {

DWORD error = GetLastError();

if (error == ERROR_SYMLINK_NOT_SUPPORTED)

error = ERROR_ACCESS_DENIED;

SET_REQ_WIN32_ERROR(req, error);

CloseHandle(handle);

return;

}

}

if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {

/* Remove read-only attribute */

FILE_BASIC_INFORMATION basic = { 0 };

basic.FileAttributes = info.dwFileAttributes & ~(FILE_ATTRIBUTE_READONLY);

status = pNtSetInformationFile(handle,

&iosb,

&basic,

sizeof basic,

FileBasicInformation);

if (!NT_SUCCESS(status)) {

SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));

CloseHandle(handle);

return;

}

}

/* Try to set the delete flag. */

disposition.DeleteFile = TRUE;

status = pNtSetInformationFile(handle,

&iosb,

&disposition,

sizeof disposition,

FileDispositionInformation);

if (NT_SUCCESS(status)) {

SET_REQ_SUCCESS(req);

} else {

SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));

}

CloseHandle(handle);

}

void fs__mkdir(uv_fs_t* req) {

/* TODO: use req->mode. */

int result = _wmkdir(req->file.pathw);

SET_REQ_RESULT(req, result);

}

/* OpenBSD original: lib/libc/stdio/mktemp.c */

void fs__mkdtemp(uv_fs_t* req) {

static const WCHAR *tempchars =

L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

static const size_t num_chars = 62;

static const size_t num_x = 6;

WCHAR *cp, *ep;

unsigned int tries, i;

size_t len;

HCRYPTPROV h_crypt_prov;

uint64_t v;

BOOL released;

len = wcslen(req->file.pathw);

ep = req->file.pathw + len;

if (len < num_x || wcsncmp(ep - num_x, L"XXXXXX", num_x)) {

SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);

return;

}

if (!CryptAcquireContext(&h_crypt_prov, NULL, NULL, PROV_RSA_FULL,

CRYPT_VERIFYCONTEXT)) {

SET_REQ_WIN32_ERROR(req, GetLastError());

return;

}

tries = TMP_MAX;

do {

if (!CryptGenRandom(h_crypt_prov, sizeof(v), (BYTE*) &v)) {

SET_REQ_WIN32_ERROR(req, GetLastError());

break;

}

cp = ep - num_x;

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

*cp++ = tempchars[v % num_chars];

v /= num_chars;

}

if (_wmkdir(req->file.pathw) == 0) {

len = strlen(req->path);

wcstombs((char*) req->path + len - num_x, ep - num_x, num_x);

SET_REQ_RESULT(req, 0);

break;

} else if (errno != EEXIST) {

SET_REQ_RESULT(req, -1);

break;

}

} while (--tries);

released = CryptReleaseContext(h_crypt_prov, 0);

assert(released);

if (tries == 0) {

SET_REQ_RESULT(req, -1);

}

}

void fs__scandir(uv_fs_t* req) {

static const size_t dirents_initial_size = 32;

HANDLE dir_handle = INVALID_HANDLE_VALUE;

uv__dirent_t** dirents = NULL;

size_t dirents_size = 0;

size_t dirents_used = 0;

IO_STATUS_BLOCK iosb;

NTSTATUS status;

/* Buffer to hold directory entries returned by NtQueryDirectoryFile.

* It's important that this buffer can hold at least one entry, regardless

* of the length of the file names present in the enumerated directory.

* A file name is at most 256 WCHARs long.

* According to MSDN, the buffer must be aligned at an 8-byte boundary.

*/

__declspec(align(8)) char buffer[8192];

STATIC_ASSERT(sizeof buffer >=

sizeof(FILE_DIRECTORY_INFORMATION) + 256 * sizeof(WCHAR));

/* Open the directory. */

dir_handle =

CreateFileW(req->file.pathw,

FILE_LIST_DIRECTORY | SYNCHRONIZE,

FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,

NULL,

OPEN_EXISTING,

FILE_FLAG_BACKUP_SEMANTICS,

NULL);

if (dir_handle == INVALID_HANDLE_VALUE)

goto win32_error;

/* Read the first chunk. */

status = pNtQueryDirectoryFile(dir_handle,

NULL,

NULL,

NULL,

&iosb,

&buffer,

sizeof buffer,

FileDirectoryInformation,

FALSE,

NULL,

TRUE);

/* If the handle is not a directory, we'll get STATUS_INVALID_PARAMETER.

* This should be reported back as UV_ENOTDIR.

*/

if (status == STATUS_INVALID_PARAMETER)

goto not_a_directory_error;

while (NT_SUCCESS(status)) {

char* position = buffer;

size_t next_entry_offset = 0;

do {

FILE_DIRECTORY_INFORMATION* info;

uv__dirent_t* dirent;

size_t wchar_len;

size_t utf8_len;

/* Obtain a pointer to the current directory entry. */

position += next_entry_offset;

info = (FILE_DIRECTORY_INFORMATION*) position;

/* Fetch the offset to the next directory entry. */

next_entry_offset = info->NextEntryOffset;

/* Compute the length of the filename in WCHARs. */

wchar_len = info->FileNameLength / sizeof info->FileName[0];

/* Skip over '.' and '..' entries. */

if (wchar_len == 1 && info->FileName[0] == L'.')

continue;

if (wchar_len == 2 && info->FileName[0] == L'.' &&

info->FileName[1] == L'.')

continue;

/* Compute the space required to store the filename as UTF-8. */

utf8_len = WideCharToMultiByte(

CP_UTF8, 0, &info->FileName[0], wchar_len, NULL, 0, NULL, NULL);

if (utf8_len == 0)

goto win32_error;

/* Resize the dirent array if needed. */

if (dirents_used >= dirents_size) {

size_t new_dirents_size =

dirents_size == 0 ? dirents_initial_size : dirents_size << 1;

uv__dirent_t** new_dirents =

uv__realloc(dirents, new_dirents_size * sizeof *dirents);

if (new_dirents == NULL)

goto out_of_memory_error;

dirents_size = new_dirents_size;

dirents = new_dirents;

}

/* Allocate space for the uv dirent structure. The dirent structure

* includes room for the first character of the filename, but `utf8_len`

* doesn't count the NULL terminator at this point.

*/

dirent = uv__malloc(sizeof *dirent + utf8_len);

if (dirent == NULL)

goto out_of_memory_error;

dirents[dirents_used++] = dirent;

/* Convert file name to UTF-8. */

if (WideCharToMultiByte(CP_UTF8,

0,

&info->FileName[0],

wchar_len,

&dirent->d_name[0],

utf8_len,

NULL,

NULL) == 0)

goto win32_error;

/* Add a null terminator to the filename. */

dirent->d_name[utf8_len] = '\0';

/* Fill out the type field. */

if (info->FileAttributes & FILE_ATTRIBUTE_DEVICE)

dirent->d_type = UV__DT_CHAR;

else if (info->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)

dirent->d_type = UV__DT_LINK;

else if (info->FileAttributes & FILE_ATTRIBUTE_DIRECTORY)

dirent->d_type = UV__DT_DIR;

else

dirent->d_type = UV__DT_FILE;

} while (next_entry_offset != 0);

/* Read the next chunk. */

status = pNtQueryDirectoryFile(dir_handle,

NULL,

NULL,

NULL,

&iosb,

&buffer,

sizeof buffer,

FileDirectoryInformation,

FALSE,

NULL,

FALSE);

/* After the first pNtQueryDirectoryFile call, the function may return

* STATUS_SUCCESS even if the buffer was too small to hold at least one

* directory entry.

*/

if (status == STATUS_SUCCESS && iosb.Information == 0)

status = STATUS_BUFFER_OVERFLOW;

}

if (status != STATUS_NO_MORE_FILES)

goto nt_error;

CloseHandle(dir_handle);

/* Store the result in the request object. */

req->ptr = dirents;

if (dirents != NULL)

req->flags |= UV_FS_FREE_PTR;

SET_REQ_RESULT(req, dirents_used);

/* `nbufs` will be used as index by uv_fs_scandir_next. */

req->fs.info.nbufs = 0;

return;

nt_error:

SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));

goto cleanup;

win32_error:

SET_REQ_WIN32_ERROR(req, GetLastError());

goto cleanup;

not_a_directory_error:

SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);

goto cleanup;

out_of_memory_error:

SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);

goto cleanup;

cleanup:

if (dir_handle != INVALID_HANDLE_VALUE)

CloseHandle(dir_handle);

while (dirents_used > 0)