From: Ben Noordhuis Date: Fri, 14 Oct 2011 22:42:10 +0000 (+0200) Subject: uv: upgrade to 456f831 X-Git-Tag: v0.5.10~55 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=3108a9ee3831b8b0a40a09314a005ef2430dacbc;p=platform%2Fupstream%2Fnodejs.git uv: upgrade to 456f831 --- diff --git a/deps/uv/config-unix.mk b/deps/uv/config-unix.mk index 7f596fb..53bcbd4 100644 --- a/deps/uv/config-unix.mk +++ b/deps/uv/config-unix.mk @@ -82,6 +82,15 @@ OBJS += src/unix/netbsd.o OBJS += src/unix/kqueue.o endif +ifeq (OpenBSD,$(uname_S)) +EV_CONFIG=config_openbsd.h +EIO_CONFIG=config_openbsd.h +CPPFLAGS += -Isrc/ares/config_openbsd +LINKFLAGS+= +OBJS += src/unix/openbsd.o +OBJS += src/unix/kqueue.o +endif + ifneq (,$(findstring CYGWIN,$(uname_S))) EV_CONFIG=config_cygwin.h EIO_CONFIG=config_cygwin.h diff --git a/deps/uv/include/uv-private/uv-win.h b/deps/uv/include/uv-private/uv-win.h index d3e825a..81693ea 100644 --- a/deps/uv/include/uv-private/uv-win.h +++ b/deps/uv/include/uv-private/uv-win.h @@ -345,6 +345,7 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s); HANDLE close_handle; #define UV_FS_PRIVATE_FIELDS \ + wchar_t* pathw; \ int flags; \ int last_error; \ struct _stati64 stat; \ diff --git a/deps/uv/src/unix/eio/config_openbsd.h b/deps/uv/src/unix/eio/config_openbsd.h new file mode 100644 index 0000000..a73b8a8 --- /dev/null +++ b/deps/uv/src/unix/eio/config_openbsd.h @@ -0,0 +1,137 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the header file. */ +#define HAVE_DLFCN_H 1 + +/* fallocate(2) is available */ +/* #undef HAVE_FALLOCATE */ + +/* fdatasync(2) is available */ +/* #undef HAVE_FDATASYNC */ + +/* futimes(2) is available */ +#define HAVE_FUTIMES 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* posix_fadvise(2) is available */ +/* #undef HAVE_POSIX_FADVISE */ + +/* posix_madvise(2) is available */ +#define HAVE_POSIX_MADVISE 1 + +/* prctl(PR_SET_NAME) is available */ +/* #undef HAVE_PRCTL_SET_NAME */ + +/* pread(2) and pwrite(2) are available */ +#define HAVE_PREADWRITE 1 + +/* readahead(2) is available (linux) */ +/* #undef HAVE_READAHEAD */ + +/* sendfile(2) is available and supported */ +/* #undef HAVE_SENDFILE */ + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* sync_file_range(2) is available */ +/* #undef HAVE_SYNC_FILE_RANGE */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_PRCTL_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* syscall(__NR_syncfs) is available */ +/* #undef HAVE_SYS_SYNCFS */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_SYSCALL_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* utimes(2) is available */ +#define HAVE_UTIMES 1 + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#define LT_OBJDIR ".libs/" + +/* Name of package */ +#define PACKAGE "libeio" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Enable extensions on AIX 3, Interix. */ +#ifndef _ALL_SOURCE +# define _ALL_SOURCE 1 +#endif +/* Enable GNU extensions on systems that have them. */ +#ifndef _GNU_SOURCE +# define _GNU_SOURCE 1 +#endif +/* Enable threading extensions on Solaris. */ +#ifndef _POSIX_PTHREAD_SEMANTICS +# define _POSIX_PTHREAD_SEMANTICS 1 +#endif +/* Enable extensions on HP NonStop. */ +#ifndef _TANDEM_SOURCE +# define _TANDEM_SOURCE 1 +#endif +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# define __EXTENSIONS__ 1 +#endif + + +/* Version number of package */ +#define VERSION "1.0" + +/* Define to 1 if on MINIX. */ +/* #undef _MINIX */ + +/* Define to 2 if the system does not provide POSIX.1 features except with + this defined. */ +/* #undef _POSIX_1_SOURCE */ + +/* Define to 1 if you need to in order for `stat' and other things to work. */ +/* #undef _POSIX_SOURCE */ diff --git a/deps/uv/src/unix/ev/config_openbsd.h b/deps/uv/src/unix/ev/config_openbsd.h new file mode 100644 index 0000000..8bc9b89 --- /dev/null +++ b/deps/uv/src/unix/ev/config_openbsd.h @@ -0,0 +1,126 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if you have the `clock_gettime' function. */ +#define HAVE_CLOCK_GETTIME 1 + +/* "use syscall interface for clock_gettime" */ +/* #undef HAVE_CLOCK_SYSCALL */ + +/* Define to 1 if you have the header file. */ +#define HAVE_DLFCN_H 1 + +/* Define to 1 if you have the `epoll_ctl' function. */ +/* #undef HAVE_EPOLL_CTL */ + +/* Define to 1 if you have the `eventfd' function. */ +/* #undef HAVE_EVENTFD */ + +/* Define to 1 if you have the `inotify_init' function. */ +/* #undef HAVE_INOTIFY_INIT */ + +/* Define to 1 if you have the header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the `kqueue' function. */ +#define HAVE_KQUEUE 1 + +/* Define to 1 if you have the `m' library (-lm). */ +#define HAVE_LIBM 1 + +/* Define to 1 if you have the `rt' library (-lrt). */ +/* #undef HAVE_LIBRT */ + +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the `nanosleep' function. */ +#define HAVE_NANOSLEEP 1 + +/* Define to 1 if you have the `poll' function. */ +#define HAVE_POLL 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_POLL_H 1 + +/* Define to 1 if you have the `port_create' function. */ +/* #undef HAVE_PORT_CREATE */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_PORT_H */ + +/* Define to 1 if you have the `select' function. */ +#define HAVE_SELECT 1 + +/* Define to 1 if you have the `signalfd' function. */ +/* #undef HAVE_SIGNALFD */ + +/* Define to 1 if you have the header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_EPOLL_H */ + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_EVENTFD_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_EVENT_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_INOTIFY_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_SELECT_H 1 + +/* Define to 1 if you have the header file. */ +/* #undef HAVE_SYS_SIGNALFD_H */ + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#define LT_OBJDIR ".libs/" + +/* Name of package */ +#define PACKAGE "libev" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION "4.04" diff --git a/deps/uv/src/unix/openbsd.c b/deps/uv/src/unix/openbsd.c new file mode 100644 index 0000000..98af6d0 --- /dev/null +++ b/deps/uv/src/unix/openbsd.c @@ -0,0 +1,123 @@ +/* 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 +#include +#include +#include +#include + +#include +#include +#include +#include + +#undef NANOSEC +#define NANOSEC 1000000000 + + +uint64_t uv_hrtime(void) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (ts.tv_sec * NANOSEC + ts.tv_nsec); +} + +void uv_loadavg(double avg[3]) { + struct loadavg info; + size_t size = sizeof(info); + int which[] = {CTL_VM, VM_LOADAVG}; + + if (sysctl(which, 2, &info, &size, NULL, 0) < 0) return; + + avg[0] = (double) info.ldavg[0] / info.fscale; + avg[1] = (double) info.ldavg[1] / info.fscale; + avg[2] = (double) info.ldavg[2] / info.fscale; +} + +int uv_exepath(char* buffer, size_t* size) { + int mib[4]; + char **argsbuf = NULL; + char **argsbuf_tmp; + size_t argsbuf_size = 100U; + size_t exepath_size; + pid_t mypid; + int status = -1; + + if (!buffer || !size) { + goto out; + } + mypid = getpid(); + for (;;) { + if ((argsbuf_tmp = realloc(argsbuf, argsbuf_size)) == NULL) { + goto out; + } + argsbuf = argsbuf_tmp; + mib[0] = CTL_KERN; + mib[1] = KERN_PROC_ARGS; + mib[2] = mypid; + mib[3] = KERN_PROC_ARGV; + if (sysctl(mib, 4, argsbuf, &argsbuf_size, NULL, 0) == 0) { + break; + } + if (errno != ENOMEM) { + goto out; + } + argsbuf_size *= 2U; + } + if (argsbuf[0] == NULL) { + goto out; + } + exepath_size = strlen(argsbuf[0]); + if (exepath_size >= *size) { + goto out; + } + memcpy(buffer, argsbuf[0], exepath_size + 1U); + *size = exepath_size; + status = 0; + +out: + free(argsbuf); + + return status; +} + +double uv_get_free_memory(void) { + struct uvmexp info; + size_t size = sizeof(info); + int which[] = {CTL_VM, VM_UVMEXP}; + + if (sysctl(which, 2, &info, &size, NULL, 0) < 0) { + return -1; + } + + return (double) info.free * sysconf(_SC_PAGESIZE); +} + +double uv_get_total_memory(void) { + uint64_t info; + int which[] = {CTL_HW, HW_PHYSMEM64}; + size_t size = sizeof(info); + + if (sysctl(which, 2, &info, &size, NULL, 0) < 0) { + return -1; + } + + return (double) info; +} diff --git a/deps/uv/src/win/fs-event.c b/deps/uv/src/win/fs-event.c index aec7caf..a416df2 100644 --- a/deps/uv/src/win/fs-event.c +++ b/deps/uv/src/win/fs-event.c @@ -326,7 +326,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req, filename, utf8size); if (utf8size) { - filename[utf8size] = L'\0'; + filename[utf8size] = '\0'; } else { free(filename); filename = NULL; diff --git a/deps/uv/src/win/fs.c b/deps/uv/src/win/fs.c index 8a956e2..f6a036a 100644 --- a/deps/uv/src/win/fs.c +++ b/deps/uv/src/win/fs.c @@ -40,6 +40,18 @@ #define UV_FS_CLEANEDUP 0x0010 #define UV_FS_LAST_ERROR_SET 0x0020 + +#define UTF8_TO_UTF16(s, t) \ + size = uv_utf8_to_utf16(s, NULL, 0) * sizeof(wchar_t); \ + t = (wchar_t*)malloc(size); \ + if (!t) { \ + uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); \ + } \ + if (!uv_utf8_to_utf16(s, t, size / sizeof(wchar_t))) { \ + uv__set_sys_error(loop, GetLastError()); \ + return -1; \ + } + #define STRDUP_ARG(req, i) \ req->arg##i = (void*)strdup((const char*)req->arg##i); \ if (!req->arg##i) { \ @@ -47,6 +59,9 @@ } \ req->flags |= UV_FS_FREE_ARG##i; +#define SET_ALLOCED_ARG(req, i) \ + req->flags |= UV_FS_FREE_ARG##i; + #define WRAP_REQ_ARGS1(req, a0) \ req->arg0 = (void*)a0; @@ -110,7 +125,7 @@ void uv_fs_init() { static void uv_fs_req_init_async(uv_loop_t* loop, uv_fs_t* req, - uv_fs_type fs_type, const char* path, uv_fs_cb cb) { + uv_fs_type fs_type, const char* path, const wchar_t* pathw, uv_fs_cb cb) { uv_req_init(loop, (uv_req_t*) req); req->type = UV_FS; req->loop = loop; @@ -120,6 +135,7 @@ static void uv_fs_req_init_async(uv_loop_t* loop, uv_fs_t* req, req->result = 0; req->ptr = NULL; req->path = path ? strdup(path) : NULL; + req->pathw = (wchar_t*)pathw; req->errorno = 0; req->last_error = 0; memset(&req->overlapped, 0, sizeof(req->overlapped)); @@ -136,11 +152,12 @@ static void uv_fs_req_init_sync(uv_loop_t* loop, uv_fs_t* req, req->result = 0; req->ptr = NULL; req->path = NULL; + req->pathw = NULL; req->errorno = 0; } -void fs__open(uv_fs_t* req, const char* path, int flags, int mode) { +void fs__open(uv_fs_t* req, const wchar_t* path, int flags, int mode) { DWORD access; DWORD share; DWORD disposition; @@ -232,11 +249,11 @@ void fs__open(uv_fs_t* req, const char* path, int flags, int mode) { } /* Figure out whether path is a file or a directory. */ - if (GetFileAttributesA(path) & FILE_ATTRIBUTE_DIRECTORY) { + if (GetFileAttributesW(path) & FILE_ATTRIBUTE_DIRECTORY) { attributes |= FILE_FLAG_BACKUP_SEMANTICS; } - file = CreateFileA(path, + file = CreateFileW(path, access, share, NULL, @@ -342,51 +359,55 @@ void fs__write(uv_fs_t* req, uv_file file, void *buf, size_t length, } -void fs__unlink(uv_fs_t* req, const char* path) { - int result = _unlink(path); +void fs__unlink(uv_fs_t* req, const wchar_t* path) { + int result = _wunlink(path); SET_REQ_RESULT(req, result); } -void fs__mkdir(uv_fs_t* req, const char* path, int mode) { - int result = _mkdir(path); +void fs__mkdir(uv_fs_t* req, const wchar_t* path, int mode) { + int result = _wmkdir(path); SET_REQ_RESULT(req, result); } -void fs__rmdir(uv_fs_t* req, const char* path) { - int result = _rmdir(path); +void fs__rmdir(uv_fs_t* req, const wchar_t* path) { + int result = _wrmdir(path); SET_REQ_RESULT(req, result); } -void fs__readdir(uv_fs_t* req, const char* path, int flags) { - int result; - char* buf = NULL, *ptr, *name; +void fs__readdir(uv_fs_t* req, const wchar_t* path, int flags) { + int result, size; + wchar_t* buf = NULL, *ptr, *name; HANDLE dir; - WIN32_FIND_DATAA ent = {0}; - size_t len = strlen(path); + WIN32_FIND_DATAW ent = {0}; + size_t len = wcslen(path); size_t buf_size = 4096; - char* path2; - const char* fmt = !len ? "./*" - : (path[len - 1] == '/' || path[len - 1] == '\\') ? "%s*" - : "%s\\*"; + wchar_t* path2; + const wchar_t* fmt = !len ? L"./*" + : (path[len - 1] == L'/' || path[len - 1] == L'\\') ? L"%s*" + : L"%s\\*"; /* Figure out whether path is a file or a directory. */ - if (!(GetFileAttributesA(path) & FILE_ATTRIBUTE_DIRECTORY)) { + if (!(GetFileAttributesW(path) & FILE_ATTRIBUTE_DIRECTORY)) { req->result = -1; req->errorno = UV_ENOTDIR; req->last_error = ERROR_SUCCESS; return; } - path2 = (char*)malloc(len + 4); + path2 = (wchar_t*)malloc(sizeof(wchar_t) * (len + 4)); if (!path2) { uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); } - sprintf(path2, fmt, path); - dir = FindFirstFileA(path2, &ent); +#ifdef _MSC_VER + swprintf(path2, len + 3, fmt, path); +#else + swprintf(path2, fmt, path); +#endif + dir = FindFirstFileW(path2, &ent); free(path2); if(dir == INVALID_HANDLE_VALUE) { @@ -399,11 +420,11 @@ void fs__readdir(uv_fs_t* req, const char* path, int flags) { do { name = ent.cFileName; - if (name[0] != '.' || (name[1] && (name[1] != '.' || name[2]))) { - len = strlen(name); + if (name[0] != L'.' || (name[1] && (name[1] != L'.' || name[2]))) { + len = wcslen(name); if (!buf) { - buf = (char*)malloc(buf_size); + buf = (wchar_t*)malloc(buf_size); if (!buf) { uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); } @@ -414,7 +435,7 @@ void fs__readdir(uv_fs_t* req, const char* path, int flags) { while ((ptr - buf) + len + 1 > buf_size) { buf_size *= 2; path2 = buf; - buf = (char*)realloc(buf, buf_size); + buf = (wchar_t*)realloc(buf, buf_size); if (!buf) { uv_fatal_error(ERROR_OUTOFMEMORY, "realloc"); } @@ -422,25 +443,51 @@ void fs__readdir(uv_fs_t* req, const char* path, int flags) { ptr = buf + (ptr - path2); } - strcpy(ptr, name); + wcscpy(ptr, name); ptr += len + 1; result++; } - } while(FindNextFileA(dir, &ent)); + } while(FindNextFileW(dir, &ent)); FindClose(dir); - req->ptr = buf; - req->flags |= UV_FS_FREE_PTR; + if (buf) { + /* Convert result to UTF8. */ + size = uv_utf16_to_utf8(buf, buf_size / sizeof(wchar_t), NULL, 0); + if (!size) { + SET_REQ_RESULT_WIN32_ERROR(req, GetLastError()); + return; + } + + req->ptr = (char*)malloc(size + 1); + if (!req->ptr) { + uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); + } + + size = uv_utf16_to_utf8(buf, buf_size / sizeof(wchar_t), (char*)req->ptr, size); + if (!size) { + free(buf); + free(req->ptr); + req->ptr = NULL; + SET_REQ_RESULT_WIN32_ERROR(req, GetLastError()); + return; + } + free(buf); + + ((char*)req->ptr)[size] = '\0'; + req->flags |= UV_FS_FREE_PTR; + } else { + req->ptr = NULL; + } SET_REQ_RESULT(req, result); } -void fs__stat(uv_fs_t* req, const char* path) { +void fs__stat(uv_fs_t* req, const wchar_t* path) { int result; - result = _stati64(path, &req->stat); + result = _wstati64(path, &req->stat); if (result == -1) { req->ptr = NULL; } else { @@ -467,8 +514,8 @@ void fs__fstat(uv_fs_t* req, uv_file file) { } -void fs__rename(uv_fs_t* req, const char* path, const char* new_path) { - int result = rename(path, new_path); +void fs__rename(uv_fs_t* req, const wchar_t* path, const wchar_t* new_path) { + int result = _wrename(path, new_path); SET_REQ_RESULT(req, result); } @@ -537,8 +584,8 @@ void fs__sendfile(uv_fs_t* req, uv_file out_file, uv_file in_file, } -void fs__chmod(uv_fs_t* req, const char* path, int mode) { - int result = _chmod(path, mode); +void fs__chmod(uv_fs_t* req, const wchar_t* path, int mode) { + int result = _wchmod(path, mode); SET_REQ_RESULT(req, result); } @@ -589,10 +636,10 @@ done: } -void fs__utime(uv_fs_t* req, const char* path, double atime, double mtime) { +void fs__utime(uv_fs_t* req, const wchar_t* path, double atime, double mtime) { int result; struct _utimbuf b = {(time_t)atime, (time_t)mtime}; - result = _utime(path, &b); + result = _wutime(path, &b); SET_REQ_RESULT(req, result); } @@ -608,8 +655,8 @@ void fs__futime(uv_fs_t* req, uv_file file, double atime, double mtime) { } -void fs__link(uv_fs_t* req, const char* path, const char* new_path) { - int result = CreateHardLinkA(new_path, path, NULL) ? 0 : -1; +void fs__link(uv_fs_t* req, const wchar_t* path, const wchar_t* new_path) { + int result = CreateHardLinkW(new_path, path, NULL) ? 0 : -1; if (result == -1) { SET_REQ_RESULT_WIN32_ERROR(req, GetLastError()); } else { @@ -618,11 +665,11 @@ void fs__link(uv_fs_t* req, const char* path, const char* new_path) { } -void fs__symlink(uv_fs_t* req, const char* path, const char* new_path, +void fs__symlink(uv_fs_t* req, const wchar_t* path, const wchar_t* new_path, int flags) { int result; - if (pCreateSymbolicLinkA) { - result = pCreateSymbolicLinkA(new_path, + if (pCreateSymbolicLinkW) { + result = pCreateSymbolicLinkW(new_path, path, flags & UV_FS_SYMLINK_DIR ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0) ? 0 : -1; if (result == -1) { @@ -640,7 +687,7 @@ void fs__symlink(uv_fs_t* req, const char* path, const char* new_path, } -void fs__readlink(uv_fs_t* req, const char* path) { +void fs__readlink(uv_fs_t* req, const wchar_t* path) { int result = -1; BOOL rv; HANDLE symlink; @@ -651,7 +698,7 @@ void fs__readlink(uv_fs_t* req, const char* path) { wchar_t* substitute_name; int substitute_name_length; - symlink = CreateFileA(path, + symlink = CreateFileW(path, 0, 0, NULL, @@ -685,7 +732,7 @@ void fs__readlink(uv_fs_t* req, const char* path) { goto done; } - reparse_data = buffer; + reparse_data = (REPARSE_DATA_BUFFER*)buffer; if (reparse_data->ReparseTag != IO_REPARSE_TAG_SYMLINK) { result = -1; /* something is seriously wrong */ @@ -693,8 +740,10 @@ void fs__readlink(uv_fs_t* req, const char* path) { goto done; } - substitute_name = reparse_data->SymbolicLinkReparseBuffer.PathBuffer + (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t)); - substitute_name_length = 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) { @@ -719,7 +768,7 @@ void fs__readlink(uv_fs_t* req, const char* path) { utf8size = uv_utf16_to_utf8(substitute_name, substitute_name_length, - req->ptr, + (char*)req->ptr, utf8size); if (!utf8size) { result = -1; @@ -758,7 +807,7 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) { switch (req->fs_type) { case UV_FS_OPEN: - fs__open(req, req->path, (int)req->arg0, (int)req->arg1); + fs__open(req, req->pathw, (int)req->arg0, (int)req->arg1); break; case UV_FS_CLOSE: fs__close(req, (uv_file)req->arg0); @@ -778,26 +827,26 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) { (off_t) req->arg3); break; case UV_FS_UNLINK: - fs__unlink(req, req->path); + fs__unlink(req, req->pathw); break; case UV_FS_MKDIR: - fs__mkdir(req, req->path, (int)req->arg0); + fs__mkdir(req, req->pathw, (int)req->arg0); break; case UV_FS_RMDIR: - fs__rmdir(req, req->path); + fs__rmdir(req, req->pathw); break; case UV_FS_READDIR: - fs__readdir(req, req->path, (int)req->arg0); + fs__readdir(req, req->pathw, (int)req->arg0); break; case UV_FS_STAT: case UV_FS_LSTAT: - fs__stat(req, req->path); + fs__stat(req, req->pathw); break; case UV_FS_FSTAT: fs__fstat(req, (uv_file)req->arg0); break; case UV_FS_RENAME: - fs__rename(req, req->path, (const char*)req->arg0); + fs__rename(req, req->pathw, (const wchar_t*)req->arg0); break; case UV_FS_FSYNC: case UV_FS_FDATASYNC: @@ -814,25 +863,25 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) { (size_t) req->arg3); break; case UV_FS_CHMOD: - fs__chmod(req, req->path, (int)req->arg0); + fs__chmod(req, req->pathw, (int)req->arg0); break; case UV_FS_FCHMOD: fs__fchmod(req, (uv_file)req->arg0, (int)req->arg1); break; case UV_FS_UTIME: - fs__utime(req, req->path, req->arg4, req->arg5); + fs__utime(req, req->pathw, req->arg4, req->arg5); break; case UV_FS_FUTIME: fs__futime(req, (uv_file)req->arg0, req->arg4, req->arg5); break; case UV_FS_LINK: - fs__link(req, req->path, (const char*)req->arg0); + fs__link(req, req->pathw, (const wchar_t*)req->arg0); break; case UV_FS_SYMLINK: - fs__symlink(req, req->path, (const char*)req->arg0, (int)req->arg1); + fs__symlink(req, req->pathw, (const wchar_t*)req->arg0, (int)req->arg1); break; case UV_FS_READLINK: - fs__readlink(req, req->path); + fs__readlink(req, req->pathw); break; case UV_FS_CHOWN: case UV_FS_FCHOWN: @@ -850,13 +899,20 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) { int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int mode, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_OPEN, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_OPEN, path, pathw, cb); WRAP_REQ_ARGS2(req, flags, mode); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_OPEN); - fs__open(req, path, flags, mode); + fs__open(req, pathw, flags, mode); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -867,7 +923,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_CLOSE, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_CLOSE, NULL, NULL, cb); WRAP_REQ_ARGS1(req, file); QUEUE_FS_TP_JOB(loop, req); } else { @@ -884,7 +940,7 @@ int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, size_t length, off_t offset, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_READ, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_READ, NULL, NULL, cb); WRAP_REQ_ARGS4(req, file, buf, length, offset); QUEUE_FS_TP_JOB(loop, req); } else { @@ -901,7 +957,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, size_t length, off_t offset, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_WRITE, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_WRITE, NULL, NULL, cb); WRAP_REQ_ARGS4(req, file, buf, length, offset); QUEUE_FS_TP_JOB(loop, req); } else { @@ -917,12 +973,19 @@ int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_UNLINK, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_UNLINK, path, pathw, cb); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_UNLINK); - fs__unlink(req, path); + fs__unlink(req, pathw); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -933,13 +996,20 @@ int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_MKDIR, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_MKDIR, path, pathw, cb); WRAP_REQ_ARGS1(req, mode); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_MKDIR); - fs__mkdir(req, path, mode); + fs__mkdir(req, pathw, mode); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -949,12 +1019,19 @@ int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_RMDIR, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_RMDIR, path, pathw, cb); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_RMDIR); - fs__rmdir(req, path); + fs__rmdir(req, pathw); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -965,13 +1042,20 @@ int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_READDIR, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_READDIR, path, pathw, cb); WRAP_REQ_ARGS1(req, flags); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_READDIR); - fs__readdir(req, path, flags); + fs__readdir(req, pathw, flags); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -982,14 +1066,24 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb) { + wchar_t* pathw; + wchar_t* new_pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + UTF8_TO_UTF16(new_path, new_pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_LINK, path, cb); - WRAP_REQ_ARGS1(req, new_path); - STRDUP_ARG(req, 0); + uv_fs_req_init_async(loop, req, UV_FS_LINK, path, pathw, cb); + WRAP_REQ_ARGS1(req, new_pathw); + SET_ALLOCED_ARG(req, 0); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_LINK); - fs__link(req, path, new_path); + fs__link(req, pathw, new_pathw); + free(pathw); + free(new_pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1000,14 +1094,24 @@ int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, int flags, uv_fs_cb cb) { + wchar_t* pathw; + wchar_t* new_pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + UTF8_TO_UTF16(new_path, new_pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_SYMLINK, path, cb); - WRAP_REQ_ARGS2(req, new_path, flags); - STRDUP_ARG(req, 0); + uv_fs_req_init_async(loop, req, UV_FS_SYMLINK, path, pathw, cb); + WRAP_REQ_ARGS2(req, new_pathw, flags); + SET_ALLOCED_ARG(req, 0); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_SYMLINK); - fs__symlink(req, path, new_path, flags); + fs__symlink(req, pathw, new_pathw, flags); + free(pathw); + free(new_pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1018,12 +1122,19 @@ int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_READLINK, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_READLINK, path, pathw, cb); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_READLINK); - fs__readlink(req, path); + fs__readlink(req, pathw); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1034,13 +1145,20 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid, int gid, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_CHOWN, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_CHOWN, path, pathw, cb); WRAP_REQ_ARGS2(req, uid, gid); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_CHOWN); fs__nop(req); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1052,7 +1170,7 @@ int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid, int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uid, int gid, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FCHOWN, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FCHOWN, NULL, NULL, cb); WRAP_REQ_ARGS3(req, file, uid, gid); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1069,6 +1187,8 @@ int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uid, int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { int len = strlen(path); char* path2 = NULL; + wchar_t* pathw; + int size; if (len > 1 && path[len - 2] != ':' && (path[len - 1] == '\\' || path[len - 1] == '/')) { @@ -1081,20 +1201,24 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { } if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_STAT, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_STAT, NULL, NULL, cb); if (path2) { req->path = path2; + UTF8_TO_UTF16(path2, req->pathw); } else { req->path = strdup(path); + UTF8_TO_UTF16(path, req->pathw); } QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_STAT); - fs__stat(req, path2 ? path2 : path); + UTF8_TO_UTF16(path2 ? path2 : path, pathw); + fs__stat(req, pathw); if (path2) { free(path2); } + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1107,6 +1231,8 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { int len = strlen(path); char* path2 = NULL; + wchar_t* pathw; + int size; if (len > 1 && path[len - 2] != ':' && (path[len - 1] == '\\' || path[len - 1] == '/')) { @@ -1119,20 +1245,24 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { } if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_LSTAT, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_LSTAT, NULL, NULL, cb); if (path2) { req->path = path2; + UTF8_TO_UTF16(path2, req->pathw); } else { req->path = strdup(path); + UTF8_TO_UTF16(path, req->pathw); } QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_LSTAT); - fs__stat(req, path2 ? path2 : path); + UTF8_TO_UTF16(path2 ? path2 : path, pathw); + fs__stat(req, pathw); if (path2) { free(path2); } + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1143,7 +1273,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FSTAT, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FSTAT, NULL, NULL, cb); WRAP_REQ_ARGS1(req, file); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1159,14 +1289,24 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* new_path, uv_fs_cb cb) { + wchar_t* pathw; + wchar_t* new_pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + UTF8_TO_UTF16(new_path, new_pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_RENAME, path, cb); - WRAP_REQ_ARGS1(req, new_path); - STRDUP_ARG(req, 0); + uv_fs_req_init_async(loop, req, UV_FS_RENAME, path, pathw, cb); + WRAP_REQ_ARGS1(req, new_pathw); + SET_ALLOCED_ARG(req, 0); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_RENAME); - fs__rename(req, path, new_path); + fs__rename(req, pathw, new_pathw); + free(pathw); + free(new_pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1177,7 +1317,7 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FDATASYNC, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FDATASYNC, NULL, NULL, cb); WRAP_REQ_ARGS1(req, file); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1193,7 +1333,7 @@ int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FSYNC, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FSYNC, NULL, NULL, cb); WRAP_REQ_ARGS1(req, file); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1210,7 +1350,7 @@ int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, off_t offset, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FTRUNCATE, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FTRUNCATE, NULL, NULL, cb); WRAP_REQ_ARGS2(req, file, offset); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1227,7 +1367,7 @@ int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd, uv_file in_fd, off_t in_offset, size_t length, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_SENDFILE, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_SENDFILE, NULL, NULL, cb); WRAP_REQ_ARGS4(req, out_fd, in_fd, in_offset, length); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1243,13 +1383,20 @@ int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd, int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_CHMOD, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_CHMOD, path, pathw, cb); WRAP_REQ_ARGS1(req, mode); QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_CHMOD); - fs__chmod(req, path, mode); + fs__chmod(req, pathw, mode); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1261,7 +1408,7 @@ int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FCHMOD, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FCHMOD, NULL, NULL, cb); WRAP_REQ_ARGS2(req, file, mode); QUEUE_FS_TP_JOB(loop, req); } else { @@ -1277,14 +1424,21 @@ int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode, int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, double mtime, uv_fs_cb cb) { + wchar_t* pathw; + int size; + + /* Convert to UTF16. */ + UTF8_TO_UTF16(path, pathw); + if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_UTIME, path, cb); + uv_fs_req_init_async(loop, req, UV_FS_UTIME, path, pathw, cb); req->arg4 = (ssize_t)atime; req->arg5 = (ssize_t)mtime; QUEUE_FS_TP_JOB(loop, req); } else { uv_fs_req_init_sync(loop, req, UV_FS_UTIME); - fs__utime(req, path, atime, mtime); + fs__utime(req, pathw, atime, mtime); + free(pathw); SET_UV_LAST_ERROR_FROM_REQ(req); return req->result; } @@ -1296,7 +1450,7 @@ int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime, double mtime, uv_fs_cb cb) { if (cb) { - uv_fs_req_init_async(loop, req, UV_FS_FUTIME, NULL, cb); + uv_fs_req_init_async(loop, req, UV_FS_FUTIME, NULL, NULL, cb); WRAP_REQ_ARGS1(req, file); req->arg4 = (ssize_t)atime; req->arg5 = (ssize_t)mtime; @@ -1347,6 +1501,11 @@ void uv_fs_req_cleanup(uv_fs_t* req) { req->path = NULL; } + if (req->pathw) { + free(req->pathw); + req->pathw = NULL; + } + if (req->flags & UV_FS_ASYNC_QUEUED) { uv_unref(loop); } diff --git a/deps/uv/src/win/pipe.c b/deps/uv/src/win/pipe.c index 2b55579..9c90fda 100644 --- a/deps/uv/src/win/pipe.c +++ b/deps/uv/src/win/pipe.c @@ -778,6 +778,8 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req, memset(&req->overlapped, 0, sizeof(req->overlapped)); if (handle->ipc) { + ipc_frame.header.flags = 0; + /* Use the IPC framing protocol. */ if (send_handle) { tcp_send_handle = (uv_tcp_t*)send_handle; @@ -997,6 +999,7 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle, } assert(bytes == sizeof(ipc_frame.header)); + assert(ipc_frame.header.flags <= UV_IPC_UV_STREAM | UV_IPC_RAW_DATA); if (ipc_frame.header.flags & UV_IPC_UV_STREAM) { assert(avail - sizeof(ipc_frame.header) >= diff --git a/deps/uv/src/win/winapi.c b/deps/uv/src/win/winapi.c index 4a58c14..4f8597c 100644 --- a/deps/uv/src/win/winapi.c +++ b/deps/uv/src/win/winapi.c @@ -31,7 +31,7 @@ sNtQueryInformationFile pNtQueryInformationFile; sNtSetInformationFile pNtSetInformationFile; sGetQueuedCompletionStatusEx pGetQueuedCompletionStatusEx; sSetFileCompletionNotificationModes pSetFileCompletionNotificationModes; -sCreateSymbolicLinkA pCreateSymbolicLinkA; +sCreateSymbolicLinkW pCreateSymbolicLinkW; void uv_winapi_init() { @@ -76,6 +76,6 @@ void uv_winapi_init() { pSetFileCompletionNotificationModes = (sSetFileCompletionNotificationModes) GetProcAddress(kernel32_module, "SetFileCompletionNotificationModes"); - pCreateSymbolicLinkA = (sCreateSymbolicLinkA) - GetProcAddress(kernel32_module, "CreateSymbolicLinkA"); + pCreateSymbolicLinkW = (sCreateSymbolicLinkW) + GetProcAddress(kernel32_module, "CreateSymbolicLinkW"); } diff --git a/deps/uv/src/win/winapi.h b/deps/uv/src/win/winapi.h index 760281e..78ffe16 100644 --- a/deps/uv/src/win/winapi.h +++ b/deps/uv/src/win/winapi.h @@ -4317,9 +4317,9 @@ typedef BOOL (WINAPI* sSetFileCompletionNotificationModes) (HANDLE FileHandle, UCHAR Flags); -typedef BOOLEAN (WINAPI* sCreateSymbolicLinkA) - (LPCSTR lpSymlinkFileName, - LPCSTR lpTargetFileName, +typedef BOOLEAN (WINAPI* sCreateSymbolicLinkW) + (LPCWSTR lpSymlinkFileName, + LPCWSTR lpTargetFileName, DWORD dwFlags); @@ -4332,6 +4332,6 @@ extern sNtSetInformationFile pNtSetInformationFile; /* Kernel32 function pointers */ extern sGetQueuedCompletionStatusEx pGetQueuedCompletionStatusEx; extern sSetFileCompletionNotificationModes pSetFileCompletionNotificationModes; -extern sCreateSymbolicLinkA pCreateSymbolicLinkA; +extern sCreateSymbolicLinkW pCreateSymbolicLinkW; #endif /* UV_WIN_WINAPI_H_ */ diff --git a/deps/uv/uv.gyp b/deps/uv/uv.gyp index 900551e..3503f27 100644 --- a/deps/uv/uv.gyp +++ b/deps/uv/uv.gyp @@ -236,6 +236,14 @@ 'EIO_CONFIG_H="config_freebsd.h"', ], }], + [ 'OS=="openbsd"', { + 'include_dirs': [ 'src/ares/config_openbsd' ], + 'sources': [ 'src/unix/openbsd.c' ], + 'defines': [ + 'EV_CONFIG_H="config_openbsd.h"', + 'EIO_CONFIG_H="config_openbsd.h"', + ], + }], [ 'OS=="mac" or OS=="freebsd" or OS=="openbsd" or OS=="netbsd"', { 'sources': [ 'src/unix/kqueue.c' ], }],