59 deps/uv/src/win/fs.c
View file
@@ -133,7 +133,6 @@ static void uv_fs_req_init_sync(uv_loop_t* loop, uv_fs_t* req,
void fs__open(uv_fs_t* req, const char* path, int flags, int mode) {
DWORD access;
DWORD share;
SECURITY_ATTRIBUTES sa;
DWORD disposition;
DWORD attributes;
HANDLE file;
@@ -168,14 +167,6 @@ void fs__open(uv_fs_t* req, const char* path, int flags, int mode) {
*/
share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;

sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
if (flags & _O_NOINHERIT) {
sa.bInheritHandle = FALSE;
} else {
sa.bInheritHandle = TRUE;
}

switch (flags & (_O_CREAT | _O_EXCL | _O_TRUNC)) {
case 0:
case _O_EXCL:
@@ -233,7 +224,7 @@ void fs__open(uv_fs_t* req, const char* path, int flags, int mode) {
file = CreateFileA(path,
access,
share,
&sa,
NULL,
disposition,
attributes,
NULL);
@@ -407,7 +398,6 @@ void fs__readdir(uv_fs_t* req, const char* path, int flags) {
req->ptr = buf;
req->flags |= UV_FS_FREE_PTR;

done:
SET_REQ_RESULT(req, result);
}

@@ -605,6 +595,8 @@ void fs__readlink(uv_fs_t* req, const char* path) {
DWORD bytes_returned;
REPARSE_DATA_BUFFER* reparse_data;
int utf8size;
wchar_t* substitute_name;
int substitute_name_length;

symlink = CreateFileA(path,
0,
@@ -648,8 +640,17 @@ void fs__readlink(uv_fs_t* req, const char* path) {
goto done;
}

utf8size = uv_utf16_to_utf8(reparse_data->SymbolicLinkReparseBuffer.PathBuffer + (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t)),
reparse_data->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(wchar_t),
substitute_name = reparse_data->SymbolicLinkReparseBuffer.PathBuffer + (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t));
substitute_name_length = reparse_data->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(wchar_t);

/* Strip off the leading \??\ from the substitute name buffer.*/
if (memcmp(substitute_name, L"\\??\\", 8) == 0) {
substitute_name += 4;
substitute_name_length -= 4;
}

utf8size = uv_utf16_to_utf8(substitute_name,
substitute_name_length,
NULL,
0);
if (!utf8size) {
@@ -663,10 +664,8 @@ void fs__readlink(uv_fs_t* req, const char* path) {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
}

req->flags |= UV_FS_FREE_PTR;

utf8size = uv_utf16_to_utf8(reparse_data->SymbolicLinkReparseBuffer.PathBuffer + (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t)),
reparse_data->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(wchar_t),
utf8size = uv_utf16_to_utf8(substitute_name,
substitute_name_length,
req->ptr,
utf8size);
if (!utf8size) {
@@ -675,6 +674,7 @@ void fs__readlink(uv_fs_t* req, const char* path) {
goto done;
}

req->flags |= UV_FS_FREE_PTR;
((char*)req->ptr)[utf8size] = '\0';
result = 0;

@@ -805,6 +805,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_fs_req_init_sync(loop, req, UV_FS_OPEN);
fs__open(req, path, flags, mode);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -820,6 +821,7 @@ int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
uv_fs_req_init_sync(loop, req, UV_FS_CLOSE);
fs__close(req, file);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -836,6 +838,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
uv_fs_req_init_sync(loop, req, UV_FS_READ);
fs__read(req, file, buf, length, offset);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -852,6 +855,7 @@ int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
uv_fs_req_init_sync(loop, req, UV_FS_WRITE);
fs__write(req, file, buf, length, offset);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -867,6 +871,7 @@ int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_req_init_sync(loop, req, UV_FS_UNLINK);
fs__unlink(req, path);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -883,6 +888,7 @@ int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
uv_fs_req_init_sync(loop, req, UV_FS_MKDIR);
fs__mkdir(req, path, mode);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -897,6 +903,7 @@ int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
uv_fs_req_init_sync(loop, req, UV_FS_RMDIR);
fs__rmdir(req, path);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -913,6 +920,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_fs_req_init_sync(loop, req, UV_FS_READDIR);
fs__readdir(req, path, flags);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -930,6 +938,7 @@ int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_req_init_sync(loop, req, UV_FS_LINK);
fs__link(req, path, new_path);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -947,6 +956,7 @@ int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_req_init_sync(loop, req, UV_FS_SYMLINK);
fs__symlink(req, path, new_path, flags);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -962,6 +972,7 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_req_init_sync(loop, req, UV_FS_READLINK);
fs__readlink(req, path);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -978,6 +989,7 @@ int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid,
uv_fs_req_init_sync(loop, req, UV_FS_CHOWN);
fs__nop(req);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -994,6 +1006,7 @@ int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uid,
uv_fs_req_init_sync(loop, req, UV_FS_FCHOWN);
fs__nop(req);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1030,6 +1043,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
free(path2);
}
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1067,6 +1081,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
free(path2);
}
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1082,6 +1097,7 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
uv_fs_req_init_sync(loop, req, UV_FS_FSTAT);
fs__fstat(req, file);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1099,6 +1115,7 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_req_init_sync(loop, req, UV_FS_RENAME);
fs__rename(req, path, new_path);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1114,6 +1131,7 @@ int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
uv_fs_req_init_sync(loop, req, UV_FS_FDATASYNC);
fs__fsync(req, file);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1129,6 +1147,7 @@ int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
uv_fs_req_init_sync(loop, req, UV_FS_FSYNC);
fs__fsync(req, file);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1145,6 +1164,7 @@ int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file,
uv_fs_req_init_sync(loop, req, UV_FS_FTRUNCATE);
fs__ftruncate(req, file, offset);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1161,6 +1181,7 @@ int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd,
uv_fs_req_init_sync(loop, req, UV_FS_SENDFILE);
fs__sendfile(req, out_fd, in_fd, in_offset, length);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1177,6 +1198,7 @@ int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
uv_fs_req_init_sync(loop, req, UV_FS_CHMOD);
fs__chmod(req, path, mode);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1193,6 +1215,7 @@ int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode,
uv_fs_req_init_sync(loop, req, UV_FS_FCHMOD);
fs__fchmod(req, file, mode);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1210,6 +1233,7 @@ int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
uv_fs_req_init_sync(loop, req, UV_FS_UTIME);
fs__utime(req, path, atime, mtime);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
@@ -1228,6 +1252,7 @@ int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime,
uv_fs_req_init_sync(loop, req, UV_FS_FUTIME);
fs__futime(req, file, atime, mtime);
SET_UV_LAST_ERROR_FROM_REQ(req);
return req->result;
}

return 0;
89 deps/uv/test/test-fs.c
View file
@@ -390,7 +390,7 @@ TEST_IMPL(fs_file_noent) {
loop = uv_default_loop();

r = uv_fs_open(loop, &req, "does_not_exist", O_RDONLY, 0, NULL);
ASSERT(r == 0);
ASSERT(r == -1);
ASSERT(req.result == -1);
ASSERT(uv_last_error(loop).code == UV_ENOENT);
uv_fs_req_cleanup(&req);
@@ -541,68 +541,68 @@ TEST_IMPL(fs_file_sync) {

r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);

r = uv_fs_write(loop, &write_req, open_req1.result, test_buf,
sizeof(test_buf), -1, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(write_req.result != -1);
uv_fs_req_cleanup(&write_req);

r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(close_req.result != -1);
uv_fs_req_cleanup(&close_req);

r = uv_fs_open(loop, &open_req1, "test_file", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);

r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(read_req.result != -1);
ASSERT(strcmp(buf, test_buf) == 0);
uv_fs_req_cleanup(&read_req);

r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(ftruncate_req.result != -1);
uv_fs_req_cleanup(&ftruncate_req);

r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(close_req.result != -1);
uv_fs_req_cleanup(&close_req);

r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(rename_req.result != -1);
uv_fs_req_cleanup(&rename_req);

r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);

memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(read_req.result != -1);
ASSERT(strcmp(buf, "test-bu") == 0);
uv_fs_req_cleanup(&read_req);

r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(close_req.result != -1);
uv_fs_req_cleanup(&close_req);

r = uv_fs_unlink(loop, &unlink_req, "test_file2", NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(unlink_req.result != -1);
uv_fs_req_cleanup(&unlink_req);

@@ -633,15 +633,15 @@ TEST_IMPL(fs_async_dir) {
/* Create 2 files synchronously. */
r = uv_fs_open(loop, &open_req1, "test_dir/file1", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
uv_fs_req_cleanup(&close_req);

r = uv_fs_open(loop, &open_req1, "test_dir/file2", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
uv_fs_req_cleanup(&open_req1);
r = uv_fs_close(loop, &close_req, open_req1.result, NULL);
ASSERT(r == 0);
@@ -655,6 +655,7 @@ TEST_IMPL(fs_async_dir) {

/* sync uv_fs_readdir */
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL);
ASSERT(r == 2);
ASSERT(readdir_req.result == 2);
ASSERT(readdir_req.ptr);
ASSERT(memcmp(readdir_req.ptr, "file1\0file2\0", 12) == 0
@@ -708,6 +709,8 @@ TEST_IMPL(fs_async_sendfile) {
int f, r;
struct stat s1, s2;

loop = uv_default_loop();

/* Setup. */
unlink("test_file");
unlink("test_file2");
@@ -728,16 +731,14 @@ TEST_IMPL(fs_async_sendfile) {
ASSERT(r == 0);

/* Test starts here. */
loop = uv_default_loop();

r = uv_fs_open(loop, &open_req1, "test_file", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(open_req1.result != -1);
uv_fs_req_cleanup(&open_req1);

r = uv_fs_open(loop, &open_req2, "test_file2", O_WRONLY | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(open_req2.result != -1);
uv_fs_req_cleanup(&open_req2);

@@ -780,13 +781,13 @@ TEST_IMPL(fs_fstat) {

r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
file = req.result;
uv_fs_req_cleanup(&req);

r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
ASSERT(r == 0);
ASSERT(r == sizeof(test_buf));
ASSERT(req.result == sizeof(test_buf));
uv_fs_req_cleanup(&req);

@@ -834,13 +835,13 @@ TEST_IMPL(fs_chmod) {

r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
file = req.result;
uv_fs_req_cleanup(&req);

r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
ASSERT(r == 0);
ASSERT(r == sizeof(test_buf));
ASSERT(req.result == sizeof(test_buf));
uv_fs_req_cleanup(&req);

@@ -921,7 +922,7 @@ TEST_IMPL(fs_chown) {

r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
file = req.result;
uv_fs_req_cleanup(&req);
@@ -980,13 +981,13 @@ TEST_IMPL(fs_link) {

r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
file = req.result;
uv_fs_req_cleanup(&req);

r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
ASSERT(r == 0);
ASSERT(r == sizeof(test_buf));
ASSERT(req.result == sizeof(test_buf));
uv_fs_req_cleanup(&req);

@@ -999,14 +1000,14 @@ TEST_IMPL(fs_link) {
uv_fs_req_cleanup(&req);

r = uv_fs_open(loop, &req, "test_file_link", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
link = req.result;
uv_fs_req_cleanup(&req);

memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
ASSERT(strcmp(buf, test_buf) == 0);

@@ -1019,14 +1020,14 @@ TEST_IMPL(fs_link) {
ASSERT(link_cb_count == 1);

r = uv_fs_open(loop, &req, "test_file_link2", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
link = req.result;
uv_fs_req_cleanup(&req);

memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
ASSERT(strcmp(buf, test_buf) == 0);

@@ -1064,23 +1065,22 @@ TEST_IMPL(fs_symlink) {

r = uv_fs_open(loop, &req, "test_file", O_RDWR | O_CREAT,
S_IWRITE | S_IREAD, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
file = req.result;
uv_fs_req_cleanup(&req);

r = uv_fs_write(loop, &req, file, test_buf, sizeof(test_buf), -1, NULL);
ASSERT(r == 0);
ASSERT(r == sizeof(test_buf));
ASSERT(req.result == sizeof(test_buf));
uv_fs_req_cleanup(&req);

close(file);

/* sync symlink */
r = uv_fs_symlink(loop, &req, "test_file", "test_file_symlink", 0, NULL);
ASSERT(r == 0);
#ifdef _WIN32
if (req.result == -1) {
if (r == -1) {
if (req.errorno == ENOSYS) {
/*
* Windows doesn't support symlinks on older versions.
@@ -1096,27 +1096,28 @@ TEST_IMPL(fs_symlink) {
}
}
#endif
ASSERT(r == 0);
ASSERT(req.result == 0);
uv_fs_req_cleanup(&req);

r = uv_fs_open(loop, &req, "test_file_symlink", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
link = req.result;
uv_fs_req_cleanup(&req);

memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
ASSERT(strcmp(buf, test_buf) == 0);

close(link);

r = uv_fs_symlink(loop, &req, "test_file_symlink", "test_file_symlink_symlink", 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
r = uv_fs_readlink(loop, &req, "test_file_symlink_symlink", NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(strcmp(req.ptr, "test_file_symlink") == 0);
uv_fs_req_cleanup(&req);

@@ -1127,23 +1128,23 @@ TEST_IMPL(fs_symlink) {
ASSERT(symlink_cb_count == 1);

r = uv_fs_open(loop, &req, "test_file_symlink2", O_RDWR, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
link = req.result;
uv_fs_req_cleanup(&req);

memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &req, link, buf, sizeof(buf), 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
ASSERT(strcmp(buf, test_buf) == 0);

close(link);

r = uv_fs_symlink(loop, &req, "test_file_symlink2", "test_file_symlink2_symlink", 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
r = uv_fs_readlink(loop, &req, "test_file_symlink2_symlink", readlink_cb);
ASSERT(r == 0);
ASSERT(r != -1);
uv_run(loop);
ASSERT(readlink_cb_count == 1);

@@ -1178,7 +1179,7 @@ TEST_IMPL(fs_utime) {

r = uv_fs_utime(loop, &req, path, atime, mtime, NULL);
ASSERT(r == 0);
ASSERT(utime_req.result == 0);
ASSERT(req.result == 0);
uv_fs_req_cleanup(&req);

r = uv_fs_stat(loop, &req, path, NULL);
@@ -1217,7 +1218,7 @@ TEST_IMPL(fs_futime) {
atime = mtime = 400497753; /* 1982-09-10 11:22:33 */

r = uv_fs_open(loop, &req, path, O_RDONLY, 0, NULL);
ASSERT(r == 0);
ASSERT(r != -1);
ASSERT(req.result != -1);
file = req.result; /* FIXME probably not how it's supposed to be used */
uv_fs_req_cleanup(&req);
1 deps/uv/test/test-list.h
View file
@@ -196,7 +196,6 @@ TASK_LIST_START
TEST_ENTRY (fs_utime)
TEST_ENTRY (fs_futime)
TEST_ENTRY (fs_symlink)
TEST_ENTRY (fs_symlink)

TEST_ENTRY (threadpool_queue_work_simple)

16 src/node_file.cc
View file
@@ -287,20 +287,22 @@ Local<Value> FSError(int errorno,
int r = uv_fs_##func(uv_default_loop(), &req_wrap->req_, \
__VA_ARGS__, After); \
assert(r == 0); \
req_wrap->object_->Set(oncomplete_sym, callback); \
req_wrap->object_->Set(oncomplete_sym, callback); \
req_wrap->Dispatched(); \
return scope.Close(req_wrap->object_);

#define SYNC_CALL(func, path, ...) \
fs_req_wrap req_wrap; \
uv_fs_##func(uv_default_loop(), &req_wrap.req, __VA_ARGS__, NULL); \
if (req_wrap.req.result < 0) { \
int result = uv_fs_##func(uv_default_loop(), &req_wrap.req, __VA_ARGS__, NULL); \
if (result < 0) { \
int code = uv_last_error(uv_default_loop()).code; \
return ThrowException(FSError(code, #func, "", path)); \
}

#define SYNC_REQ req_wrap.req

#define SYNC_RESULT result


static Handle<Value> Close(const Arguments& args) {
HandleScope scope;
@@ -672,7 +674,7 @@ static Handle<Value> SendFile(const Arguments& args) {
ASYNC_CALL(sendfile, args[4], out_fd, in_fd, in_offset, length)
} else {
SYNC_CALL(sendfile, 0, out_fd, in_fd, in_offset, length)
return scope.Close(Integer::New(SYNC_REQ.result));
return scope.Close(Integer::New(SYNC_RESULT));
}
}

@@ -728,7 +730,7 @@ static Handle<Value> Open(const Arguments& args) {
ASYNC_CALL(open, args[3], *path, flags, mode)
} else {
SYNC_CALL(open, *path, *path, flags, mode)
int fd = SYNC_REQ.result;
int fd = SYNC_RESULT;
SetCloseOnExec(fd);
return scope.Close(Integer::New(fd));
}
@@ -797,7 +799,7 @@ static Handle<Value> Write(const Arguments& args) {
ASYNC_CALL(write, cb, fd, buf, len, pos)
} else {
SYNC_CALL(write, 0, fd, buf, len, pos)
return scope.Close(Integer::New(SYNC_REQ.result));
return scope.Close(Integer::New(SYNC_RESULT));
}
}

@@ -860,7 +862,7 @@ static Handle<Value> Read(const Arguments& args) {
ASYNC_CALL(read, cb, fd, buf, len, pos);
} else {
SYNC_CALL(read, 0, fd, buf, len, pos)
Local<Integer> bytesRead = Integer::New(SYNC_REQ.result);
Local<Integer> bytesRead = Integer::New(SYNC_RESULT);
return scope.Close(bytesRead);
}
}