c/libuv
1
0
Fork 0
mirror of https://github.com/libuv/libuv synced 2025-03-28 21:13:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge 0e25224e0c0708558be8d40d85170e5054899aa8 into bb706f5fe71827f667f0bce532e95ce0698a498d

Browse Source
This commit is contained in:
Yage Hu 2025-03-24 13:40:57 +01:00 committed by GitHub
commit 7b0eaf0480
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
11 changed files with 1005 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
docs/src/fs.rst
View File

@ -111,7 +111,8 @@ Data types
UV_FS_READDIR,
UV_FS_CLOSEDIR,
UV_FS_MKSTEMP,
UV_FS_LUTIME
UV_FS_LUTIME,
UV_FS_OPENAT
} uv_fs_type;
.. c:type:: uv_statfs_t
@ -237,6 +238,15 @@ API
in binary mode. Because of this the O_BINARY and O_TEXT flags are not
supported.
.. c:function:: int uv_fs_openat(uv_loop_t* loop, uv_fs_t* req, uv_file file, const char* path, int flags, int mode, uv_fs_cb cb)
Equivalent to :man:`openat(2)`.
.. note::
On Windows libuv uses `NtCreateFile` and thus the file is always opened
in binary mode. Because of this the O_BINARY and O_TEXT flags are not
supported.
.. c:function:: int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb)
Equivalent to :man:`preadv(2)`. If the `offset` argument is `-1`, then

10
include/uv.h
View File

@ -1429,7 +1429,8 @@ typedef enum {
UV_FS_CLOSEDIR,
UV_FS_STATFS,
UV_FS_MKSTEMP,
UV_FS_LUTIME
UV_FS_LUTIME,
UV_FS_OPENAT
} uv_fs_type;
struct uv_dir_s {
@ -1470,6 +1471,13 @@ UV_EXTERN int uv_fs_open(uv_loop_t* loop,
int flags,
int mode,
uv_fs_cb cb);
UV_EXTERN int uv_fs_openat(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
const char* path,
int flags,
int mode,
uv_fs_cb cb);
UV_EXTERN int uv_fs_read(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,

2
include/uv/win.h
View File

@ -692,7 +692,7 @@ typedef struct {
#define UV_FS_O_EXLOCK 0x10000000 /* EXCLUSIVE SHARING MODE */
#define UV_FS_O_NOATIME 0
#define UV_FS_O_NOCTTY 0
#define UV_FS_O_NOFOLLOW 0
#define UV_FS_O_NOFOLLOW 0x40000000 /* Not mapped but handled as a special case in openat */
#define UV_FS_O_NONBLOCK 0
#define UV_FS_O_SYMLINK 0
#define UV_FS_O_SYNC 0x08000000 /* FILE_FLAG_WRITE_THROUGH */

47
src/unix/fs.c
View File

@ -506,6 +506,34 @@ static ssize_t uv__pwritev(int fd,
return uv__preadv_or_pwritev(fd, bufs, nbufs, off, &cache, /*is_pread*/0);
}
static ssize_t uv__fs_openat(uv_fs_t* req) {
#ifdef O_CLOEXEC
return openat(req->file, 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 = openat(req->file, 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 */
}
static ssize_t uv__fs_read(uv_fs_t* req) {
const struct iovec* bufs;
@ -1714,6 +1742,7 @@ static void uv__fs_work(struct uv__work* w) {
X(MKDTEMP, uv__fs_mkdtemp(req));
X(MKSTEMP, uv__fs_mkstemp(req));
X(OPEN, uv__fs_open(req));
X(OPENAT, uv__fs_openat(req));
X(READ, uv__fs_read(req));
X(SCANDIR, uv__fs_scandir(req));
X(OPENDIR, uv__fs_opendir(req));
@ -2012,6 +2041,24 @@ int uv_fs_open(uv_loop_t* loop,
POST;
}
int uv_fs_openat(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
const char* path,
int flags,
int mode,
uv_fs_cb cb) {
INIT(OPENAT);
PATH;
req->file = file;
req->flags = flags;
req->mode = mode;
if (cb != NULL)
if (uv__iou_fs_openat(loop, req))
return 0;
POST;
}
int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,
uv_file file,

2
src/unix/internal.h
View File

@ -353,6 +353,7 @@ int uv__iou_fs_fsync_or_fdatasync(uv_loop_t* loop,
int uv__iou_fs_link(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_mkdir(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_openat(uv_loop_t* loop, uv_fs_t* req);
int uv__iou_fs_read_or_write(uv_loop_t* loop,
uv_fs_t* req,
int is_read);
@ -370,6 +371,7 @@ int uv__iou_fs_unlink(uv_loop_t* loop, uv_fs_t* req);
#define uv__iou_fs_link(loop, req) 0
#define uv__iou_fs_mkdir(loop, req) 0
#define uv__iou_fs_open(loop, req) 0
#define uv__iou_fs_openat(loop, req) 0
#define uv__iou_fs_read_or_write(loop, req, is_read) 0
#define uv__iou_fs_rename(loop, req) 0
#define uv__iou_fs_statx(loop, req, is_fstat, is_lstat) 0

22
src/unix/linux.c
View File

@ -979,6 +979,28 @@ int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req) {
}
int uv__iou_fs_openat(uv_loop_t* loop, uv_fs_t* req) {
struct uv__io_uring_sqe* sqe;
struct uv__iou* iou;
iou = &uv__get_internal_fields(loop)->iou;
sqe = uv__iou_get_sqe(iou, loop, req);
if (sqe == NULL)
return 0;
sqe->addr = (uintptr_t) req->path;
sqe->fd = req->file;
sqe->len = req->mode;
sqe->opcode = UV__IORING_OP_OPENAT;
sqe->open_flags = req->flags | O_CLOEXEC;
uv__iou_submit(iou);
return 1;
}
int uv__iou_fs_rename(uv_loop_t* loop, uv_fs_t* req) {
struct uv__io_uring_sqe* sqe;
struct uv__iou* iou;

512
src/win/fs.c
View File

@ -35,6 +35,7 @@
/* <winioctl.h> requires <windows.h>, included via "uv.h" above, but needs to
be included before our "winapi.h", included via "internal.h" below. */
#include <winioctl.h>
#include <shlwapi.h>
#include "internal.h"
#include "req-inl.h"
@ -665,6 +666,490 @@ void fs__open(uv_fs_t* req) {
SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
}
struct path {
WCHAR * buf;
// Capacity of the path buffer minus the terminating null in WCHARs.
size_t cap;
// Length of the path string without the terminating null in WCHARs.
size_t len;
};
// Must be freed by `uv__path_free`.
int uv__path_init(struct path * p) {
WCHAR * buf = uv__malloc(sizeof(WCHAR));
if (buf == NULL) return UV_ENOMEM;
p->buf = buf;
p->buf[0] = L'\0';
p->cap = 0;
p->len = 0;
return 0;
}
void uv__path_free(struct path * p) {
uv__free(p->buf);
}
int uv__path_grow_until(struct path * p, size_t cap) {
if (cap <= p->cap) {
return 0;
}
WCHAR * buf = uv__realloc(p->buf, (cap + 1) * sizeof(WCHAR));
if (buf == NULL) return ENOMEM;
p->buf = buf;
p->cap = cap;
return 0;
}
int uv__path_set(struct path * p, WCHAR * source) {
size_t len = wcslen(source);
int err = uv__path_grow_until(p, len);
if (err) return err;
memcpy(p->buf, source, len * sizeof(WCHAR));
p->len = len;
p->buf[p->len] = L'\0';
return 0;
}
int uv__path_push(struct path * p, WCHAR * component) {
size_t len = wcslen(component);
int err = uv__path_grow_until(p, p->len + len + 1);
if (err) return err;
if (p->len > 0 && p->buf[p->len - 1] != L'\\') {
p->buf[p->len] = L'\\';
p->len += 1;
}
memcpy(p->buf + p->len, component, len * sizeof(WCHAR));
p->len += len;
p->buf[p->len] = L'\0';
return 0;
}
int uv__path_pop(struct path * p) {
int i;
if (p->len == 0) return 1;
for (i = p->len - 1; i >= 0; i--) {
if (p->buf[i] == L'\\' || i == 0) {
p->buf[i] = L'\0';
p->len = i;
break;
}
}
return 0;
}
void fs__openat(uv_fs_t* req) {
DWORD access;
DWORD share;
DWORD disposition;
DWORD attributes = 0;
ULONG options = 0;
HANDLE file;
UNICODE_STRING str;
IO_STATUS_BLOCK isb;
OBJECT_ATTRIBUTES obj;
int fd, current_umask, temp_umask = 0;
int flags = req->fs.info.file_flags;
struct uv__fd_info_s fd_info;
WCHAR * path = req->file.pathw;
size_t path_len = wcslen(path);
struct path rebuilt_path;
int i;
// NtCreateFile doesn't recognize forward slashes, only back slashes.
for (i = 0; path[i] != L'\0'; i++)
if (path[i] == L'/')
path[i] = L'\\';
HANDLE root_dir_handle = 0;
HANDLE dir_handle;
BOOL is_absolute = FALSE;
if (
(path_len > 0 && path[0] == L'\\') ||
(path_len > 2 && path[1] == L':' && path[2] == L'\\')
) is_absolute = TRUE;
if (!is_absolute) {
dir_handle = (HANDLE) _get_osfhandle(req->fs.info.fd_out);
if (dir_handle == INVALID_HANDLE_VALUE) {
SET_REQ_WIN32_ERROR(req, (DWORD) UV_EBADF);
return;
}
root_dir_handle = dir_handle;
}
uv__path_init(&rebuilt_path);
WCHAR * next_token = NULL;
WCHAR * token = wcstok_s(path, L"\\", &next_token);
while (token != NULL) {
if (!wcscmp(L".", token) || wcslen(token) == 0) {
// Do nothing.
} else if (!wcscmp(L"..", token)) {
// If rebuilt_path is empty, set it to the path of the parent direcotry.
if (rebuilt_path.len == 0 && !is_absolute) {
DWORD dir_path_len = GetFinalPathNameByHandleW(dir_handle, NULL, 0, VOLUME_NAME_DOS);
if (dir_path_len == 0) {
SET_REQ_WIN32_ERROR(req, GetLastError());
return;
}
WCHAR * dir_path_buf = uv__malloc((dir_path_len + 1) * sizeof(WCHAR));
if (dir_path_buf == NULL) {
SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
return;
}
if (
GetFinalPathNameByHandleW(
dir_handle,
dir_path_buf,
dir_path_len,
VOLUME_NAME_DOS
) == 0
) {
uv__free(dir_path_buf);
SET_REQ_UV_ERROR(req, UV_EBADF, ERROR_INVALID_HANDLE);
return;
}
// We'll call `NtCreateFile` with an absolute path, set root dir handle
// to the null handle.
root_dir_handle = 0;
// The path we get has a prefix of `\\?\`.
// But we need an NT object directory prefix of `\??\`.
WCHAR * dir_path_without_extended_prefix = dir_path_buf + 4;
uv__path_set(&rebuilt_path, L"\\??");
uv__path_push(&rebuilt_path, dir_path_without_extended_prefix);
uv__free(dir_path_buf);
}
// Then pop the last component.
if (rebuilt_path.len > 0) uv__path_pop(&rebuilt_path);
} else {
uv__path_push(&rebuilt_path, token);
}
token = wcstok_s(NULL, L"\\", &next_token);
}
if (is_absolute) {
// Prepend the path with the NT object directory prefix.
WCHAR * buf = uv__malloc((rebuilt_path.len + 1) * sizeof(WCHAR));
memcpy(buf, rebuilt_path.buf, (rebuilt_path.len + 1) * sizeof(WCHAR));
uv__path_set(&rebuilt_path, L"\\??");
uv__path_push(&rebuilt_path, buf);
uv__free(buf);
}
wprintf(L"%d %s\n", root_dir_handle, rebuilt_path.buf);
/* 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. */
_umask_s(temp_umask, &current_umask);
_umask_s(current_umask, &temp_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 = GENERIC_READ;
break;
case UV_FS_O_WRONLY:
access = GENERIC_WRITE;
break;
case UV_FS_O_RDWR:
access = GENERIC_READ | 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 = FILE_OPEN;
break;
case UV_FS_O_CREAT:
disposition = FILE_OPEN_IF;
break;
case UV_FS_O_CREAT | UV_FS_O_EXCL:
case UV_FS_O_CREAT | UV_FS_O_TRUNC | UV_FS_O_EXCL:
disposition = FILE_CREATE;
break;
case UV_FS_O_TRUNC:
case UV_FS_O_TRUNC | UV_FS_O_EXCL:
disposition = FILE_OVERWRITE;
break;
case UV_FS_O_CREAT | UV_FS_O_TRUNC:
disposition = FILE_SUPERSEDE;
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 ) {
options |= FILE_DELETE_ON_CLOSE;
attributes |= 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:
options |= FILE_SEQUENTIAL_ONLY;
break;
case UV_FS_O_RANDOM:
options |= FILE_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;
}
}
options |= FILE_NO_INTERMEDIATE_BUFFERING;
}
switch (flags & (UV_FS_O_DSYNC | UV_FS_O_SYNC)) {
case 0:
break;
case UV_FS_O_DSYNC:
case UV_FS_O_SYNC:
options |= FILE_WRITE_THROUGH;
break;
default:
goto einval;
}
/* Setting this flag makes it possible to open a directory. */
options |= FILE_OPEN_FOR_BACKUP_INTENT;
pRtlInitUnicodeString(&str, rebuilt_path.buf);
InitializeObjectAttributes(&obj,
&str,
OBJ_CASE_INSENSITIVE,
root_dir_handle,
NULL);
NTSTATUS status = pNtCreateFile(&file,
access,
&obj,
&isb,
0,
attributes,
share,
disposition,
options,
NULL,
0);
uv__path_free(&rebuilt_path);
if (!NT_SUCCESS(status)) {
ULONG error = pRtlNtStatusToDosError(status);
if (((isb.Information & FILE_EXISTS) != 0) && (flags & UV_FS_O_CREAT) &&
!(flags & UV_FS_O_EXCL)) {
/* Special case: when 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, error);
}
return;
}
if (flags & UV_FS_O_NOFOLLOW) {
// Emulate O_NOFOLLOW.
IO_STATUS_BLOCK io_status;
FILE_BASIC_INFORMATION basic_info;
status = pNtQueryInformationFile(file,
&io_status,
&basic_info,
sizeof(basic_info),
FileBasicInformation);
if (!NT_SUCCESS(status)) {
SET_REQ_WIN32_ERROR(req, GetLastError());
return;
}
if (basic_info.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
SET_REQ_WIN32_ERROR(req, (DWORD) UV_ELOOP);
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:
uv__path_free(&rebuilt_path);
SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
}
void fs__close(uv_fs_t* req) {
int fd = req->file.fd;
int result;
@ -2893,12 +3378,11 @@ static void fs__symlink(uv_fs_t* req) {
flags = SYMBOLIC_LINK_FLAG_DIRECTORY | uv__file_symlink_usermode_flag;
else
flags = uv__file_symlink_usermode_flag;
if (CreateSymbolicLinkW(new_pathw, pathw, flags)) {
SET_REQ_RESULT(req, 0);
return;
}
/* Something went wrong. We will test if it is because of user-mode
* symlinks.
*/
@ -3133,6 +3617,7 @@ static void uv__fs_work(struct uv__work* w) {
#define XX(uc, lc) case UV_FS_##uc: fs__##lc(req); break;
switch (req->fs_type) {
XX(OPEN, open)
XX(OPENAT, openat)
XX(CLOSE, close)
XX(READ, read)
XX(WRITE, write)
@ -3238,6 +3723,29 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
}
int uv_fs_openat(uv_loop_t* loop,
uv_fs_t* req,
uv_file handle,
const char* path,
int flags,
int mode,
uv_fs_cb cb) {
int err;
INIT(UV_FS_OPENAT);
err = fs__capture_path(req, path, NULL, cb != NULL);
if (err) {
SET_REQ_WIN32_ERROR(req, err);
return req->result;
}
req->fs.info.fd_out = handle;
req->fs.info.file_flags = flags;
req->fs.info.mode = mode;
POST;
}
int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
INIT(UV_FS_CLOSE);
req->file.fd = fd;

13
src/win/winapi.c
View File

@ -27,7 +27,9 @@
/* Ntdll function pointers */
sRtlGetVersion pRtlGetVersion;
sRtlInitUnicodeString pRtlInitUnicodeString;
sRtlNtStatusToDosError pRtlNtStatusToDosError;
sNtCreateFile pNtCreateFile;
sNtDeviceIoControlFile pNtDeviceIoControlFile;
sNtQueryInformationFile pNtQueryInformationFile;
sNtSetInformationFile pNtSetInformationFile;
@ -70,6 +72,17 @@ void uv__winapi_init(void) {
uv_fatal_error(GetLastError(), "GetProcAddress");
}
pRtlInitUnicodeString =
(sRtlInitUnicodeString) GetProcAddress(ntdll_module, "RtlInitUnicodeString");
if (pRtlInitUnicodeString == NULL) {
uv_fatal_error(GetLastError(), "GetProcAddress");
}
pNtCreateFile = (sNtCreateFile) GetProcAddress(ntdll_module, "NtCreateFile");
if (pNtCreateFile == NULL) {
uv_fatal_error(GetLastError(), "GetProcAddress");
}
pNtDeviceIoControlFile = (sNtDeviceIoControlFile) GetProcAddress(
ntdll_module,
"NtDeviceIoControlFile");

89
src/win/winapi.h
View File

@ -4112,6 +4112,7 @@
#if !defined(__UNICODE_STRING_DEFINED) && defined(__MINGW32__)
#define __UNICODE_STRING_DEFINED
#endif
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
@ -4119,6 +4120,48 @@ typedef struct _UNICODE_STRING {
} UNICODE_STRING, *PUNICODE_STRING;
typedef const UNICODE_STRING *PCUNICODE_STRING;
#ifndef _OBJECT_ATTRIBUTES
typedef struct _OBJECT_ATTRIBUTES {
ULONG Length;
HANDLE RootDirectory;
PUNICODE_STRING ObjectName;
ULONG Attributes;
PVOID SecurityDescriptor;
PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES, * POBJECT_ATTRIBUTES;
#endif
#ifndef FILE_DIRECTORY_FILE
#define FILE_DIRECTORY_FILE 0x00000001
#define FILE_WRITE_THROUGH 0x00000002
#define FILE_SEQUENTIAL_ONLY 0x00000004
#define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
#define FILE_SYNCHRONOUS_IO_ALERT 0x00000010
#define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
#define FILE_NON_DIRECTORY_FILE 0x00000040
#define FILE_CREATE_TREE_CONNECTION 0x00000080
#define FILE_COMPLETE_IF_OPLOCKED 0x00000100
#define FILE_NO_EA_KNOWLEDGE 0x00000200
#define FILE_OPEN_FOR_RECOVERY 0x00000400
#define FILE_RANDOM_ACCESS 0x00000800
#define FILE_DELETE_ON_CLOSE 0x00001000
#define FILE_OPEN_BY_FILE_ID 0x00002000
#define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000
#define FILE_NO_COMPRESSION 0x00008000
#define FILE_RESERVE_OPFILTER 0x00100000
#define FILE_OPEN_REPARSE_POINT 0x00200000
#define FILE_OPEN_NO_RECALL 0x00400000
#define FILE_OPEN_FOR_FREE_SPACE_QUERY 0x00800000
#endif
#ifndef OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE 0x00000040
#endif
#ifndef FILE_EXISTS
#define FILE_EXISTS 0x00000004
#endif
/* from ntifs.h */
#ifndef DEVICE_TYPE
@ -4594,9 +4637,27 @@ typedef VOID (NTAPI *PIO_APC_ROUTINE)
typedef NTSTATUS (NTAPI *sRtlGetVersion)
(PRTL_OSVERSIONINFOW lpVersionInformation);
typedef VOID (NTAPI *sRtlInitUnicodeString)(
PUNICODE_STRING DestinationString,
__drv_aliasesMem PCWSTR SourceString
);
typedef ULONG (NTAPI *sRtlNtStatusToDosError)
(NTSTATUS Status);
typedef NTSTATUS (NTAPI *sNtCreateFile)
(PHANDLE FileHandle,
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes,
PIO_STATUS_BLOCK IoStatusBlock,
PLARGE_INTEGER AllocationSize,
ULONG FileAttributes,
ULONG ShareAccess,
ULONG CreateDisposition,
ULONG CreateOptions,
PVOID EaBuffer,
ULONG EaLength);
typedef NTSTATUS (NTAPI *sNtDeviceIoControlFile)
(HANDLE FileHandle,
HANDLE Event,
@ -4751,6 +4812,7 @@ typedef DWORD (WINAPI *sPowerRegisterSuspendResumeNotification)
HANDLE Recipient,
_PHPOWERNOTIFY RegistrationHandle);
/* from Winuser.h */
typedef VOID (CALLBACK* WINEVENTPROC)
(HWINEVENTHOOK hWinEventHook,
@ -4803,7 +4865,9 @@ typedef BOOL(WINAPI* sGetFileInformationByName)(
/* Ntdll function pointers */
extern sRtlGetVersion pRtlGetVersion;
extern sRtlInitUnicodeString pRtlInitUnicodeString;
extern sRtlNtStatusToDosError pRtlNtStatusToDosError;
extern sNtCreateFile pNtCreateFile;
extern sNtDeviceIoControlFile pNtDeviceIoControlFile;
extern sNtQueryInformationFile pNtQueryInformationFile;
extern sNtSetInformationFile pNtSetInformationFile;
@ -4828,4 +4892,29 @@ typedef int (WINAPI *uv_sGetHostNameW)
int);
extern uv_sGetHostNameW pGetHostNameW;
/* from ntdef.h */
#ifndef InitializeObjectAttributes
#define InitializeObjectAttributes( p, n, a, r, s ) { \
(p)->Length = sizeof( OBJECT_ATTRIBUTES ); \
(p)->RootDirectory = r; \
(p)->Attributes = a; \
(p)->ObjectName = n; \
(p)->SecurityDescriptor = s; \
(p)->SecurityQualityOfService = NULL; \
}
#endif
// NtCreateFile CreateDisposition
#ifndef FILE_SUPERSEDE
#define FILE_SUPERSEDE 0x00000000
#define FILE_OPEN 0x00000001
#define FILE_CREATE 0x00000002
#define FILE_OPEN_IF 0x00000003
#define FILE_OVERWRITE 0x00000004
#define FILE_OVERWRITE_IF 0x00000005
#define FILE_MAXIMUM_DISPOSITION 0x00000005
#endif
#endif /* UV_WIN_WINAPI_H_ */

299
test/test-fs.c
View File

@ -82,6 +82,7 @@ static int dummy_cb_count;
static int close_cb_count;
static int create_cb_count;
static int open_cb_count;
static int openat_cb_count;
static int read_cb_count;
static int write_cb_count;
static int unlink_cb_count;
@ -460,6 +461,15 @@ static void open_cb_simple(uv_fs_t* req) {
}
static void openat_cb_simple(uv_fs_t* req) {
ASSERT_EQ(req->fs_type, UV_FS_OPENAT);
ASSERT_GE(req->result, 0);
ASSERT(req->path);
uv_fs_req_cleanup(req);
openat_cb_count++;
}
static void fsync_cb(uv_fs_t* req) {
int r;
ASSERT_PTR_EQ(req, &fsync_req);
@ -3232,6 +3242,295 @@ TEST_IMPL(fs_scandir_early_exit) {
}
TEST_IMPL(fs_openat) {
int r;
uv_fs_t req;
uv_file fd;
uv_file dir;
uv_file nested_dir;
/* Setup. */
unlink("test/fixtures/test_dir/test_file_not_exist");
unlink("test/fixtures/test_dir/test_file");
unlink("test/fixtures/test_dir/link");
unlink("test/fixtures/test_dir/nested_dir/file");
unlink("test/fixtures/file");
rmdir("test/fixtures/test_dir/nested_dir");
rmdir("test/fixtures/test_dir");
loop = uv_default_loop();
r = uv_fs_mkdir(NULL, &req, "test/fixtures/test_dir", 0755, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
r = uv_fs_mkdir(NULL, &req, "test/fixtures/test_dir/nested_dir", 0755, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
r = uv_fs_open(NULL,
&req,
"test/fixtures/test_dir",
UV_FS_O_RDONLY | UV_FS_O_DIRECTORY,
0,
NULL);
ASSERT_GE(r, 0);
dir = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_open(NULL,
&req,
"test/fixtures/test_dir/nested_dir",
UV_FS_O_RDONLY | UV_FS_O_DIRECTORY,
0,
NULL);
ASSERT_GE(r, 0);
nested_dir = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_open(NULL,
&req,
"test/fixtures/test_dir/test_file",
UV_FS_O_RDWR | UV_FS_O_CREAT,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
r = uv_fs_symlink(NULL, &req, "test_file", "test/fixtures/test_dir/link", 0, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
// Open an existing file
{
r = uv_fs_openat(NULL,
&req,
dir,
"test_file",
UV_FS_O_RDWR,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Open an existing file async
{
r = uv_fs_openat(loop,
&req,
dir,
"test_file",
UV_FS_O_RDWR,
S_IWUSR | S_IRUSR,
openat_cb_simple);
ASSERT_GE(r, 0);
ASSERT_OK(openat_cb_count);
uv_run(loop, UV_RUN_DEFAULT);
ASSERT_EQ(1, openat_cb_count);
uv_fs_req_cleanup(&req);
fd = (uv_file) req.result;
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Open a nested dir
{
r = uv_fs_openat(NULL,
&req,
dir,
"nested_dir",
UV_FS_O_RDONLY | UV_FS_O_DIRECTORY,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Open a file in a nested dir
{
r = uv_fs_openat(NULL,
&req,
dir,
"nested_dir/file",
UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_EXCL,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Open a file in the parent dir
{
r = uv_fs_openat(NULL,
&req,
dir,
"../file",
UV_FS_O_RDWR | UV_FS_O_CREAT,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Resolve multiple dot dots
{
r = uv_fs_openat(NULL,
&req,
dir,
"../test_dir/nested_dir/././../../file",
UV_FS_O_RDWR | UV_FS_O_CREAT,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Create a new file
{
r = uv_fs_openat(NULL,
&req,
dir,
"test_file_not_exist",
UV_FS_O_RDWR | UV_FS_O_CREAT,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Exclusively create an existing file.
{
r = uv_fs_openat(NULL,
&req,
dir,
"test_file",
UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_EXCL,
S_IWUSR | S_IRUSR,
NULL);
ASSERT_EQ(r, UV_EEXIST);
uv_fs_req_cleanup(&req);
}
// Open a file read-only and try to write to it
{
r = uv_fs_openat(NULL,
&req,
dir,
"test_file",
UV_FS_O_RDONLY,
0,
NULL);
ASSERT_GE(r, 0);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
iov = uv_buf_init(test_buf, sizeof(test_buf));
r = uv_fs_write(NULL,
&req,
fd,
&iov,
1,
-1,
NULL);
ASSERT_EQ(r, UV_EBADF);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
// Open a symlink without following
{
r = uv_fs_openat(NULL,
&req,
dir,
"link",
UV_FS_O_RDONLY | UV_FS_O_NOFOLLOW,
0,
NULL);
ASSERT_EQ(r, UV_ELOOP);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
}
{
r = uv_fs_realpath(NULL, &req, "test/fixtures/file", NULL);
ASSERT_OK(r);
size_t len = strlen(req.ptr);
char * abs_path = malloc(len + 1);
memcpy(abs_path, req.ptr, len + 1);
uv_fs_req_cleanup(&req);
r = uv_fs_openat(NULL,
&req,
dir,
abs_path,
UV_FS_O_RDONLY,
0,
NULL);
ASSERT_GE(r, 0);
free(abs_path);
fd = (uv_file) req.result;
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, fd, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
}
r = uv_fs_close(NULL, &req, dir, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
r = uv_fs_close(NULL, &req, nested_dir, NULL);
ASSERT_OK(r);
uv_fs_req_cleanup(&req);
/* Cleanup */
unlink("test/fixtures/test_dir/test_file_not_exist");
unlink("test/fixtures/test_dir/test_file");
unlink("test/fixtures/test_dir/link");
unlink("test/fixtures/test_dir/nested_dir/file");
unlink("test/fixtures/file");
rmdir("test/fixtures/test_dir/nested_dir");
rmdir("test/fixtures/test_dir");
MAKE_VALGRIND_HAPPY(loop);
return 0;
}
TEST_IMPL(fs_open_dir) {
const char* path;
uv_fs_t req;

2
test/test-list.h
View File

@ -425,6 +425,7 @@ TEST_DECLARE (fs_scandir_empty_dir)
TEST_DECLARE (fs_scandir_non_existent_dir)
TEST_DECLARE (fs_scandir_file)
TEST_DECLARE (fs_scandir_early_exit)
TEST_DECLARE (fs_openat)
TEST_DECLARE (fs_open_dir)
TEST_DECLARE (fs_readdir_empty_dir)
TEST_DECLARE (fs_readdir_file)
@ -1146,6 +1147,7 @@ TASK_LIST_START
TEST_ENTRY (fs_scandir_non_existent_dir)
TEST_ENTRY (fs_scandir_file)
TEST_ENTRY (fs_scandir_early_exit)
TEST_ENTRY (fs_openat)
TEST_ENTRY (fs_open_dir)
TEST_ENTRY (fs_readdir_empty_dir)
TEST_ENTRY (fs_readdir_file)