Lines Matching refs:req
35 #include "req-inl.h"
47 if (req == NULL) \
49 uv__fs_req_init(loop, req, subtype, cb); \
56 uv__req_register(loop, req); \
58 &req->work_req, \
64 uv__fs_work(&req->work_req); \
65 return req->result; \
70 #define SET_REQ_RESULT(req, result_value) \
72 req->result = (result_value); \
73 assert(req->result != -1); \
76 #define SET_REQ_WIN32_ERROR(req, sys_errno) \
78 req->sys_errno_ = (sys_errno); \
79 req->result = uv_translate_sys_error(req->sys_errno_); \
82 #define SET_REQ_UV_ERROR(req, uv_errno, sys_errno) \
84 req->result = (uv_errno); \
85 req->sys_errno_ = (sys_errno); \
88 #define VERIFY_FD(fd, req) \
90 req->result = UV_EBADF; \
91 req->sys_errno_ = ERROR_INVALID_HANDLE; \
145 INLINE static int fs__capture_path(uv_fs_t* req, const char* path,
189 req->file.pathw = NULL;
190 req->fs.info.new_pathw = NULL;
191 req->path = NULL;
210 req->file.pathw = (WCHAR*) pos;
213 req->file.pathw = NULL;
224 req->fs.info.new_pathw = (WCHAR*) pos;
227 req->fs.info.new_pathw = NULL;
230 req->path = path;
234 req->path = pos;
237 req->flags |= UV_FS_FREE_PATHS;
244 INLINE static void uv__fs_req_init(uv_loop_t* loop, uv_fs_t* req,
247 UV_REQ_INIT(req, UV_FS);
248 req->loop = loop;
249 req->flags = 0;
250 req->fs_type = fs_type;
251 req->sys_errno_ = 0;
252 req->result = 0;
253 req->ptr = NULL;
254 req->path = NULL;
255 req->cb = cb;
256 memset(&req->fs, 0, sizeof(req->fs));
444 void fs__open(uv_fs_t* req) {
451 int flags = req->fs.info.file_flags;
540 if (!((req->fs.info.mode & ~current_umask) & _S_IWRITE)) {
612 file = CreateFileW(req->file.pathw,
625 SET_REQ_UV_ERROR(req, UV_EISDIR, error);
627 SET_REQ_WIN32_ERROR(req, GetLastError());
639 SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES);
641 SET_REQ_WIN32_ERROR(req, GetLastError());
643 SET_REQ_WIN32_ERROR(req, (DWORD) UV_UNKNOWN);
654 SET_REQ_WIN32_ERROR(req, GetLastError());
665 SET_REQ_WIN32_ERROR(req, GetLastError());
682 SET_REQ_WIN32_ERROR(req, GetLastError());
692 SET_REQ_RESULT(req, fd);
696 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
699 void fs__close(uv_fs_t* req) {
700 int fd = req->file.fd;
704 VERIFY_FD(fd, req);
722 SET_REQ_UV_ERROR(req, UV_EBADF, ERROR_INVALID_HANDLE);
724 SET_REQ_RESULT(req, 0);
749 void fs__read_filemap(uv_fs_t* req, struct uv__fd_info_s* fd_info) {
750 int fd = req->file.fd; /* VERIFY_FD done in fs__read */
761 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FLAGS);
765 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION);
769 if (req->fs.info.offset == -1) {
772 pos.QuadPart = req->fs.info.offset;
777 SET_REQ_RESULT(req, 0);
782 for (index = 0; index < req->fs.info.nbufs; ++index) {
783 read_size += req->fs.info.bufs[index].len;
788 SET_REQ_RESULT(req, 0);
802 SET_REQ_WIN32_ERROR(req, GetLastError());
808 index < req->fs.info.nbufs && done_read < read_size;
810 size_t this_read_size = MIN(req->fs.info.bufs[index].len,
816 memcpy(req->fs.info.bufs[index].base,
823 SET_REQ_WIN32_ERROR(req, err);
833 SET_REQ_WIN32_ERROR(req, GetLastError());
837 if (req->fs.info.offset == -1) {
842 SET_REQ_RESULT(req, read_size);
846 void fs__read(uv_fs_t* req) {
847 int fd = req->file.fd;
848 int64_t offset = req->fs.info.offset;
861 VERIFY_FD(fd, req);
864 fs__read_filemap(req, &fd_info);
873 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
900 req->fs.info.bufs[index].base,
901 req->fs.info.bufs[index].len,
906 } while (result && index < req->fs.info.nbufs);
912 SET_REQ_RESULT(req, bytes);
920 SET_REQ_RESULT(req, bytes);
922 SET_REQ_WIN32_ERROR(req, error);
928 void fs__write_filemap(uv_fs_t* req, HANDLE file,
930 int fd = req->file.fd; /* VERIFY_FD done in fs__write */
943 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FLAGS);
947 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION);
952 for (index = 0; index < req->fs.info.nbufs; ++index) {
953 write_size += req->fs.info.bufs[index].len;
957 SET_REQ_RESULT(req, 0);
963 } else if (req->fs.info.offset == -1) {
966 pos.QuadPart = req->fs.info.offset;
984 SET_REQ_WIN32_ERROR(req, GetLastError());
1005 SET_REQ_WIN32_ERROR(req, GetLastError());
1010 for (index = 0; index < req->fs.info.nbufs; ++index) {
1016 req->fs.info.bufs[index].base,
1017 req->fs.info.bufs[index].len);
1022 SET_REQ_WIN32_ERROR(req, err);
1027 done_write += req->fs.info.bufs[index].len;
1032 SET_REQ_WIN32_ERROR(req, GetLastError());
1037 SET_REQ_WIN32_ERROR(req, GetLastError());
1041 if (req->fs.info.offset == -1) {
1049 SET_REQ_RESULT(req, done_write);
1052 void fs__write(uv_fs_t* req) {
1053 int fd = req->file.fd;
1054 int64_t offset = req->fs.info.offset;
1067 VERIFY_FD(fd, req);
1073 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
1078 fs__write_filemap(req, handle, &fd_info);
1105 req->fs.info.bufs[index].base,
1106 req->fs.info.bufs[index].len,
1111 } while (result && index < req->fs.info.nbufs);
1117 SET_REQ_RESULT(req, bytes);
1125 SET_REQ_WIN32_ERROR(req, error);
1130 void fs__rmdir(uv_fs_t* req) {
1131 int result = _wrmdir(req->file.pathw);
1133 SET_REQ_WIN32_ERROR(req, _doserrno);
1135 SET_REQ_RESULT(req, 0);
1139 void fs__unlink(uv_fs_t* req) {
1140 const WCHAR* pathw = req->file.pathw;
1156 SET_REQ_WIN32_ERROR(req, GetLastError());
1161 SET_REQ_WIN32_ERROR(req, GetLastError());
1173 SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);
1184 SET_REQ_WIN32_ERROR(req, error);
1203 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
1217 SET_REQ_SUCCESS(req);
1219 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
1226 void fs__mkdir(uv_fs_t* req) {
1227 /* TODO: use req->mode. */
1228 if (CreateDirectoryW(req->file.pathw, NULL)) {
1229 SET_REQ_RESULT(req, 0);
1231 SET_REQ_WIN32_ERROR(req, GetLastError());
1232 if (req->sys_errno_ == ERROR_INVALID_NAME ||
1233 req->sys_errno_ == ERROR_DIRECTORY)
1234 req->result = UV_EINVAL;
1238 typedef int (*uv__fs_mktemp_func)(uv_fs_t* req);
1241 void fs__mktemp(uv_fs_t* req, uv__fs_mktemp_func func) {
1252 path = (char*)req->path;
1253 len = wcslen(req->file.pathw);
1254 ep = req->file.pathw + len;
1256 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
1263 SET_REQ_UV_ERROR(req, UV_EIO, ERROR_IO_DEVICE);
1273 if (func(req)) {
1274 if (req->result >= 0) {
1282 SET_REQ_WIN32_ERROR(req, GetLastError());
1289 static int fs__mkdtemp_func(uv_fs_t* req) {
1291 if (CreateDirectoryW(req->file.pathw, NULL)) {
1292 SET_REQ_RESULT(req, 0);
1297 SET_REQ_WIN32_ERROR(req, error);
1305 void fs__mkdtemp(uv_fs_t* req) {
1306 fs__mktemp(req, fs__mkdtemp_func);
1310 static int fs__mkstemp_func(uv_fs_t* req) {
1314 file = CreateFileW(req->file.pathw,
1329 SET_REQ_WIN32_ERROR(req, error);
1343 SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES);
1345 SET_REQ_WIN32_ERROR(req, GetLastError());
1347 SET_REQ_WIN32_ERROR(req, UV_UNKNOWN);
1352 SET_REQ_RESULT(req, fd);
1358 void fs__mkstemp(uv_fs_t* req) {
1359 fs__mktemp(req, fs__mkstemp_func);
1363 void fs__scandir(uv_fs_t* req) {
1392 CreateFileW(req->file.pathw,
1539 req->ptr = dirents;
1541 req->flags |= UV_FS_FREE_PTR;
1543 SET_REQ_RESULT(req, dirents_used);
1546 req->fs.info.nbufs = 0;
1551 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
1555 SET_REQ_WIN32_ERROR(req, GetLastError());
1559 SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
1563 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
1575 void fs__opendir(uv_fs_t* req) {
1582 pathw = req->file.pathw;
1588 SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY);
1594 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
1609 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
1619 SET_REQ_WIN32_ERROR(req, GetLastError());
1624 req->ptr = dir;
1625 SET_REQ_RESULT(req, 0);
1631 req->ptr = NULL;
1634 void fs__readdir(uv_fs_t* req) {
1643 req->flags |= UV_FS_FREE_PTR;
1644 dir = req->ptr;
1687 SET_REQ_RESULT(req, dirent_idx);
1691 SET_REQ_WIN32_ERROR(req, GetLastError());
1698 void fs__closedir(uv_fs_t* req) {
1701 dir = req->ptr;
1703 uv__free(req->ptr);
1704 SET_REQ_RESULT(req, 0);
1895 INLINE static void fs__stat_impl(uv_fs_t* req, int do_lstat) {
1898 error = fs__stat_impl_from_path(req->file.pathw, do_lstat, &req->statbuf);
1904 fs__stat_impl(req, 0);
1907 SET_REQ_WIN32_ERROR(req, error);
1913 req->ptr = &req->statbuf;
1914 SET_REQ_RESULT(req, 0);
1918 static void fs__stat(uv_fs_t* req) {
1919 fs__stat_prepare_path(req->file.pathw);
1920 fs__stat_impl(req, 0);
1924 static void fs__lstat(uv_fs_t* req) {
1925 fs__stat_prepare_path(req->file.pathw);
1926 fs__stat_impl(req, 1);
1930 static void fs__fstat(uv_fs_t* req) {
1931 int fd = req->file.fd;
1934 VERIFY_FD(fd, req);
1939 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
1943 if (fs__stat_handle(handle, &req->statbuf, 0) != 0) {
1944 SET_REQ_WIN32_ERROR(req, GetLastError());
1948 req->ptr = &req->statbuf;
1949 SET_REQ_RESULT(req, 0);
1953 static void fs__rename(uv_fs_t* req) {
1954 if (!MoveFileExW(req->file.pathw, req->fs.info.new_pathw, MOVEFILE_REPLACE_EXISTING)) {
1955 SET_REQ_WIN32_ERROR(req, GetLastError());
1959 SET_REQ_RESULT(req, 0);
1963 INLINE static void fs__sync_impl(uv_fs_t* req) {
1964 int fd = req->file.fd;
1967 VERIFY_FD(fd, req);
1971 SET_REQ_WIN32_ERROR(req, GetLastError());
1973 SET_REQ_RESULT(req, result);
1978 static void fs__fsync(uv_fs_t* req) {
1979 fs__sync_impl(req);
1983 static void fs__fdatasync(uv_fs_t* req) {
1984 fs__sync_impl(req);
1988 static void fs__ftruncate(uv_fs_t* req) {
1989 int fd = req->file.fd;
1996 VERIFY_FD(fd, req);
2002 SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED);
2011 eof_info.EndOfFile.QuadPart = req->fs.info.offset;
2020 SET_REQ_RESULT(req, 0);
2022 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status));
2049 SET_REQ_WIN32_ERROR(req, GetLastError());
2064 static void fs__copyfile(uv_fs_t* req) {
2070 flags = req->fs.info.file_flags;
2073 SET_REQ_UV_ERROR(req, UV_ENOSYS, ERROR_NOT_SUPPORTED);
2079 if (CopyFileW(req->file.pathw, req->fs.info.new_pathw, overwrite) != 0) {
2080 SET_REQ_RESULT(req, 0);
2084 SET_REQ_WIN32_ERROR(req, GetLastError());
2085 if (req->result != UV_EBUSY)
2089 if (fs__stat_impl_from_path(req->file.pathw, 0, &statbuf) != 0 ||
2090 fs__stat_impl_from_path(req->fs.info.new_pathw, 0, &new_statbuf) != 0) {
2096 SET_REQ_RESULT(req, 0);
2101 static void fs__sendfile(uv_fs_t* req) {
2102 int fd_in = req->file.fd, fd_out = req->fs.info.fd_out;
2103 size_t length = req->fs.info.bufsml[0].len;
2104 int64_t offset = req->fs.info.offset;
2144 SET_REQ_RESULT(req, result);
2148 static void fs__access(uv_fs_t* req) {
2149 DWORD attr = GetFileAttributesW(req->file.pathw);
2152 SET_REQ_WIN32_ERROR(req, GetLastError());
2163 if (!(req->fs.info.mode & W_OK) ||
2166 SET_REQ_RESULT(req, 0);
2168 SET_REQ_WIN32_ERROR(req, UV_EPERM);
2174 static void fs__chmod(uv_fs_t* req) {
2175 int result = _wchmod(req->file.pathw, req->fs.info.mode);
2177 SET_REQ_WIN32_ERROR(req, _doserrno);
2179 SET_REQ_RESULT(req, 0);
2183 static void fs__fchmod(uv_fs_t* req) {
2184 int fd = req->file.fd;
2191 VERIFY_FD(fd, req);
2195 SET_REQ_WIN32_ERROR(req, GetLastError());
2206 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2221 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2230 if (req->fs.info.mode & _S_IWRITE) {
2243 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2258 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status));
2263 SET_REQ_SUCCESS(req);
2315 INLINE static void fs__utime_impl(uv_fs_t* req, int do_lutime) {
2318 error = fs__utime_impl_from_path(req->file.pathw,
2319 req->fs.time.atime,
2320 req->fs.time.mtime,
2328 fs__utime_impl(req, 0);
2331 SET_REQ_WIN32_ERROR(req, error);
2337 SET_REQ_RESULT(req, 0);
2340 static void fs__utime(uv_fs_t* req) {
2341 fs__utime_impl(req, /* do_lutime */ 0);
2345 static void fs__futime(uv_fs_t* req) {
2346 int fd = req->file.fd;
2348 VERIFY_FD(fd, req);
2353 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE);
2357 if (fs__utime_handle(handle, req->fs.time.atime, req->fs.time.mtime) != 0) {
2358 SET_REQ_WIN32_ERROR(req, GetLastError());
2362 SET_REQ_RESULT(req, 0);
2365 static void fs__lutime(uv_fs_t* req) {
2366 fs__utime_impl(req, /* do_lutime */ 1);
2370 static void fs__link(uv_fs_t* req) {
2371 DWORD r = CreateHardLinkW(req->fs.info.new_pathw, req->file.pathw, NULL);
2373 SET_REQ_WIN32_ERROR(req, GetLastError());
2375 SET_REQ_RESULT(req, 0);
2379 static void fs__create_junction(uv_fs_t* req, const WCHAR* path,
2404 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_NOT_SUPPORTED);
2497 SET_REQ_WIN32_ERROR(req, GetLastError());
2512 SET_REQ_WIN32_ERROR(req, GetLastError());
2525 SET_REQ_WIN32_ERROR(req, GetLastError());
2533 SET_REQ_RESULT(req, 0);
2549 static void fs__symlink(uv_fs_t* req) {
2555 pathw = req->file.pathw;
2556 new_pathw = req->fs.info.new_pathw;
2558 if (req->fs.info.file_flags & UV_FS_SYMLINK_JUNCTION) {
2559 fs__create_junction(req, pathw, new_pathw);
2563 if (req->fs.info.file_flags & UV_FS_SYMLINK_DIR)
2569 SET_REQ_RESULT(req, 0);
2583 fs__symlink(req);
2585 SET_REQ_WIN32_ERROR(req, err);
2590 static void fs__readlink(uv_fs_t* req) {
2593 handle = CreateFileW(req->file.pathw,
2602 SET_REQ_WIN32_ERROR(req, GetLastError());
2606 if (fs__readlink_handle(handle, (char**) &req->ptr, NULL) != 0) {
2607 SET_REQ_WIN32_ERROR(req, GetLastError());
2612 req->flags |= UV_FS_FREE_PTR;
2613 SET_REQ_RESULT(req, 0);
2667 static void fs__realpath(uv_fs_t* req) {
2670 handle = CreateFileW(req->file.pathw,
2678 SET_REQ_WIN32_ERROR(req, GetLastError());
2682 if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) {
2684 SET_REQ_WIN32_ERROR(req, GetLastError());
2689 req->flags |= UV_FS_FREE_PTR;
2690 SET_REQ_RESULT(req, 0);
2694 static void fs__chown(uv_fs_t* req) {
2695 SET_REQ_RESULT(req, 0);
2699 static void fs__fchown(uv_fs_t* req) {
2700 SET_REQ_RESULT(req, 0);
2704 static void fs__lchown(uv_fs_t* req) {
2705 SET_REQ_RESULT(req, 0);
2709 static void fs__statfs(uv_fs_t* req) {
2717 pathw = req->file.pathw;
2731 is_second = pathw != req->file.pathw;
2736 SET_REQ_WIN32_ERROR(req, err);
2743 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2747 ret = GetFullPathNameW(req->file.pathw,
2753 SET_REQ_WIN32_ERROR(req, err);
2759 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2769 if (pathw != req->file.pathw) {
2775 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2786 req->ptr = stat_fs;
2787 req->flags |= UV_FS_FREE_PTR;
2788 SET_REQ_RESULT(req, 0);
2793 uv_fs_t* req;
2795 req = container_of(w, uv_fs_t, work_req);
2796 assert(req->type == UV_FS);
2798 #define XX(uc, lc) case UV_FS_##uc: fs__##lc(req); break;
2799 switch (req->fs_type) {
2843 uv_fs_t* req;
2845 req = container_of(w, uv_fs_t, work_req);
2846 uv__req_unregister(req->loop, req);
2849 assert(req->result == 0);
2850 SET_REQ_UV_ERROR(req, UV_ECANCELED, 0);
2853 req->cb(req);
2857 void uv_fs_req_cleanup(uv_fs_t* req) {
2858 if (req == NULL)
2861 if (req->flags & UV_FS_CLEANEDUP)
2864 if (req->flags & UV_FS_FREE_PATHS)
2865 uv__free(req->file.pathw);
2867 if (req->flags & UV_FS_FREE_PTR) {
2868 if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL)
2869 uv__fs_scandir_cleanup(req);
2870 else if (req->fs_type == UV_FS_READDIR)
2871 uv__fs_readdir_cleanup(req);
2873 uv__free(req->ptr);
2876 if (req->fs.info.bufs != req->fs.info.bufsml)
2877 uv__free(req->fs.info.bufs);
2879 req->path = NULL;
2880 req->file.pathw = NULL;
2881 req->fs.info.new_pathw = NULL;
2882 req->fs.info.bufs = NULL;
2883 req->ptr = NULL;
2885 req->flags |= UV_FS_CLEANEDUP;
2889 int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
2894 err = fs__capture_path(req, path, NULL, cb != NULL);
2896 SET_REQ_WIN32_ERROR(req, err);
2897 return req->result;
2900 req->fs.info.file_flags = flags;
2901 req->fs.info.mode = mode;
2906 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
2908 req->file.fd = fd;
2914 uv_fs_t* req,
2923 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
2927 req->file.fd = fd;
2929 req->fs.info.nbufs = nbufs;
2930 req->fs.info.bufs = req->fs.info.bufsml;
2931 if (nbufs > ARRAY_SIZE(req->fs.info.bufsml))
2932 req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs));
2934 if (req->fs.info.bufs == NULL) {
2935 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2939 memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs));
2941 req->fs.info.offset = offset;
2947 uv_fs_t* req,
2956 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
2960 req->file.fd = fd;
2962 req->fs.info.nbufs = nbufs;
2963 req->fs.info.bufs = req->fs.info.bufsml;
2964 if (nbufs > ARRAY_SIZE(req->fs.info.bufsml))
2965 req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs));
2967 if (req->fs.info.bufs == NULL) {
2968 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY);
2972 memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs));
2974 req->fs.info.offset = offset;
2979 int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
2984 err = fs__capture_path(req, path, NULL, cb != NULL);
2986 SET_REQ_WIN32_ERROR(req, err);
2987 return req->result;
2994 int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
2999 err = fs__capture_path(req, path, NULL, cb != NULL);
3001 SET_REQ_WIN32_ERROR(req, err);
3002 return req->result;
3005 req->fs.info.mode = mode;
3011 uv_fs_t* req,
3017 err = fs__capture_path(req, tpl, NULL, TRUE);
3019 SET_REQ_WIN32_ERROR(req, err);
3020 return req->result;
3028 uv_fs_t* req,
3034 err = fs__capture_path(req, tpl, NULL, TRUE);
3036 SET_REQ_WIN32_ERROR(req, err);
3037 return req->result;
3044 int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
3048 err = fs__capture_path(req, path, NULL, cb != NULL);
3050 SET_REQ_WIN32_ERROR(req, err);
3051 return req->result;
3058 int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
3063 err = fs__capture_path(req, path, NULL, cb != NULL);
3065 SET_REQ_WIN32_ERROR(req, err);
3066 return req->result;
3069 req->fs.info.file_flags = flags;
3074 uv_fs_t* req,
3080 err = fs__capture_path(req, path, NULL, cb != NULL);
3082 SET_REQ_WIN32_ERROR(req, err);
3083 return req->result;
3089 uv_fs_t* req,
3097 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3101 req->ptr = dir;
3106 uv_fs_t* req,
3111 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3114 req->ptr = dir;
3118 int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
3123 err = fs__capture_path(req, path, new_path, cb != NULL);
3125 SET_REQ_WIN32_ERROR(req, err);
3126 return req->result;
3133 int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
3138 err = fs__capture_path(req, path, new_path, cb != NULL);
3140 SET_REQ_WIN32_ERROR(req, err);
3141 return req->result;
3144 req->fs.info.file_flags = flags;
3149 int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
3154 err = fs__capture_path(req, path, NULL, cb != NULL);
3156 SET_REQ_WIN32_ERROR(req, err);
3157 return req->result;
3164 int uv_fs_realpath(uv_loop_t* loop, uv_fs_t* req, const char* path,
3171 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3175 err = fs__capture_path(req, path, NULL, cb != NULL);
3177 SET_REQ_WIN32_ERROR(req, err);
3178 return req->result;
3185 int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
3190 err = fs__capture_path(req, path, NULL, cb != NULL);
3192 SET_REQ_WIN32_ERROR(req, err);
3193 return req->result;
3200 int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_uid_t uid,
3207 int uv_fs_lchown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid,
3212 err = fs__capture_path(req, path, NULL, cb != NULL);
3214 SET_REQ_WIN32_ERROR(req, err);
3215 return req->result;
3222 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
3226 err = fs__capture_path(req, path, NULL, cb != NULL);
3228 SET_REQ_WIN32_ERROR(req, err);
3229 return req->result;
3236 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
3240 err = fs__capture_path(req, path, NULL, cb != NULL);
3242 SET_REQ_WIN32_ERROR(req, err);
3243 return req->result;
3250 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
3252 req->file.fd = fd;
3257 int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
3262 err = fs__capture_path(req, path, new_path, cb != NULL);
3264 SET_REQ_WIN32_ERROR(req, err);
3265 return req->result;
3272 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
3274 req->file.fd = fd;
3279 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) {
3281 req->file.fd = fd;
3286 int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file fd,
3289 req->file.fd = fd;
3290 req->fs.info.offset = offset;
3296 uv_fs_t* req,
3308 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER);
3312 err = fs__capture_path(req, path, new_path, cb != NULL);
3314 SET_REQ_WIN32_ERROR(req, err);
3315 return req->result;
3318 req->fs.info.file_flags = flags;
3323 int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file fd_out,
3326 req->file.fd = fd_in;
3327 req->fs.info.fd_out = fd_out;
3328 req->fs.info.offset = in_offset;
3329 req->fs.info.bufsml[0].len = length;
3335 uv_fs_t* req,
3342 err = fs__capture_path(req, path, NULL, cb != NULL);
3344 SET_REQ_WIN32_ERROR(req, err);
3345 return req->result;
3348 req->fs.info.mode = flags;
3353 int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
3358 err = fs__capture_path(req, path, NULL, cb != NULL);
3360 SET_REQ_WIN32_ERROR(req, err);
3361 return req->result;
3364 req->fs.info.mode = mode;
3369 int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file fd, int mode,
3372 req->file.fd = fd;
3373 req->fs.info.mode = mode;
3378 int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
3383 err = fs__capture_path(req, path, NULL, cb != NULL);
3385 SET_REQ_WIN32_ERROR(req, err);
3386 return req->result;
3389 req->fs.time.atime = atime;
3390 req->fs.time.mtime = mtime;
3395 int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file fd, double atime,
3398 req->file.fd = fd;
3399 req->fs.time.atime = atime;
3400 req->fs.time.mtime = mtime;
3404 int uv_fs_lutime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
3409 err = fs__capture_path(req, path, NULL, cb != NULL);
3411 SET_REQ_WIN32_ERROR(req, err);
3412 return req->result;
3415 req->fs.time.atime = atime;
3416 req->fs.time.mtime = mtime;
3422 uv_fs_t* req,
3428 err = fs__capture_path(req, path, NULL, cb != NULL);
3430 SET_REQ_WIN32_ERROR(req, err);
3431 return req->result;
3437 int uv_fs_get_system_error(const uv_fs_t* req) {
3438 return req->sys_errno_;