luo980/libuv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixes #76. Unify OS error reporting

Browse Source 
As a nice fringe benefit, this also shaves a word
off of a windows TCP handle by replacing "uv_err_t
bind_error" with "int bind_error".
This commit is contained in:
Erick Tryzelaar 2011-09-27 07:44:01 -07:00 committed by Ryan Dahl
parent 1d7e61fafa
commit 23796d208c
35 changed files with 242 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/uv-private/uv-win.h
View File

@ -151,7 +151,7 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
#define UV_TCP_PRIVATE_FIELDS \
SOCKET socket; \
uv_err_t bind_error; \
int bind_error; \
union { \
struct { uv_tcp_server_fields }; \
struct { uv_tcp_connection_fields }; \

2
src/unix/cares.c
View File

@ -147,7 +147,7 @@ int uv_ares_init_options(uv_loop_t* loop, ares_channel *channelptr,
/* only allow single init at a time */
if (loop->channel != NULL) {
uv_err_new_artificial(loop, UV_EALREADY);
uv__set_artificial_error(loop, UV_EALREADY);
return -1;
}

6
src/unix/core.c
View File

@ -563,7 +563,7 @@ int uv_timer_stop(uv_timer_t* timer) {
int uv_timer_again(uv_timer_t* timer) {
if (!ev_is_active(&timer->timer_watcher)) {
uv_err_new(timer->loop, EINVAL);
uv__set_sys_error(timer->loop, EINVAL);
return -1;
}
@ -595,7 +595,7 @@ static int uv_getaddrinfo_done(eio_req* req) {
if (handle->retcode != 0) {
/* TODO how to display gai error strings? */
uv_err_new(handle->loop, handle->retcode);
uv__set_sys_error(handle->loop, handle->retcode);
}
handle->cb(handle, handle->retcode, res);
@ -626,7 +626,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
if (handle == NULL || cb == NULL ||
(hostname == NULL && service == NULL)) {
uv_err_new_artificial(loop, UV_EINVAL);
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}

2
src/unix/cygwin.c
View File

@ -58,7 +58,7 @@ int uv_fs_event_init(uv_loop_t* loop,
uv_fs_event_t* handle,
const char* filename,
uv_fs_event_cb cb) {
uv_err_new(loop, ENOSYS);
uv__set_sys_error(loop, ENOSYS);
return -1;
}

2
src/unix/darwin.c
View File

@ -73,7 +73,7 @@ int uv_fs_event_init(uv_loop_t* loop,
uv_fs_event_t* handle,
const char* filename,
uv_fs_event_cb cb) {
uv_err_new(loop, ENOSYS);
uv__set_sys_error(loop, ENOSYS);
return -1;
}

18
src/unix/error.c
View File

@ -90,21 +90,3 @@ uv_err_code uv_translate_sys_error(int sys_errno) {
assert(0 && "unreachable");
return -1;
}
uv_err_t uv_err_new_artificial(uv_loop_t* loop, int code) {
uv_err_t err;
err.sys_errno_ = 0;
err.code = code;
loop->last_err = err;
return err;
}
uv_err_t uv_err_new(uv_loop_t* loop, int sys_error) {
uv_err_t err;
err.sys_errno_ = sys_error;
err.code = uv_translate_sys_error(sys_error);
loop->last_err = err;
return err;
}

2
src/unix/freebsd.c
View File

@ -72,7 +72,7 @@ int uv_fs_event_init(uv_loop_t* loop,
uv_fs_event_t* handle,
const char* filename,
uv_fs_event_cb cb) {
uv_err_new(loop, ENOSYS);
uv__set_sys_error(loop, ENOSYS);
return -1;
}

42
src/unix/fs.c
View File

@ -46,7 +46,7 @@
/* async */ \
req->eio = eiofunc(args, EIO_PRI_DEFAULT, uv__fs_after, req); \
if (!req->eio) { \
uv_err_new(loop, ENOMEM); \
uv__set_sys_error(loop, ENOMEM); \
return -1; \
} \
uv_ref(loop); \
@ -54,7 +54,7 @@
/* sync */ \
req->result = func(args); \
if (req->result) { \
uv_err_new(loop, errno); \
uv__set_sys_error(loop, errno); \
} \
return req->result; \
} \
@ -192,7 +192,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_ref(loop);
req->eio = eio_open(path, flags, mode, EIO_PRI_DEFAULT, uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -200,7 +200,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
/* sync */
req->result = open(path, flags, mode);
if (req->result < 0) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -224,7 +224,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file fd, void* buf,
uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -235,7 +235,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file fd, void* buf,
pread(fd, buf, length, offset);
if (req->result < 0) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -261,7 +261,7 @@ int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
req->eio = eio_write(file, buf, length, offset, EIO_PRI_DEFAULT,
uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -272,7 +272,7 @@ int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
pwrite(file, buf, length, offset);
if (req->result < 0) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -308,7 +308,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_ref(loop);
req->eio = eio_readdir(path, flags, EIO_PRI_DEFAULT, uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -316,7 +316,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
/* sync */
DIR* dir = opendir(path);
if (!dir) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
req->result = -1;
return -1;
}
@ -345,7 +345,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
r = closedir(dir);
if (r) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
req->result = -1;
return -1;
}
@ -381,7 +381,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
free(pathdup);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -392,7 +392,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
free(pathdup);
if (req->result < 0) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -413,7 +413,7 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
req->eio = eio_fstat(file, EIO_PRI_DEFAULT, uv__fs_after, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -422,7 +422,7 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
req->result = fstat(file, &req->statbuf);
if (req->result < 0) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -520,7 +520,7 @@ int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime,
WRAP_EIO(UV_FS_FUTIME, eio_futime, _futime, ARGS3(file, atime, mtime))
#else
uv_err_new(loop, ENOSYS);
uv__set_sys_error(loop, ENOSYS);
return -1;
#endif
}
@ -550,7 +550,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
free(pathdup);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -561,7 +561,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
free(pathdup);
if (req->result < 0) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -600,7 +600,7 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_ref(loop);
return 0;
} else {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
} else {
@ -616,7 +616,7 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
}
if ((buf = malloc(size + 1)) == NULL) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}
@ -693,7 +693,7 @@ int uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb,
req->eio = eio_custom(uv__work, EIO_PRI_DEFAULT, uv__after_work, req);
if (!req->eio) {
uv_err_new(loop, ENOMEM);
uv__set_sys_error(loop, ENOMEM);
return -1;
}

2
src/unix/internal.h
View File

@ -96,8 +96,6 @@ int uv__socket(int domain, int type, int protocol);
/* error */
uv_err_code uv_translate_sys_error(int sys_errno);
uv_err_t uv_err_new(uv_loop_t* loop, int sys_error);
uv_err_t uv_err_new_artificial(uv_loop_t* loop, int code);
void uv_fatal_error(const int errorno, const char* syscall);
/* stream */

4
src/unix/linux.c
View File

@ -145,7 +145,7 @@ int uv_fs_event_init(uv_loop_t* loop,
* keep creating new inotify fds.
*/
if ((fd = new_inotify_fd()) == -1) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -158,7 +158,7 @@ int uv_fs_event_init(uv_loop_t* loop,
| IN_MOVED_TO;
if (inotify_add_watch(fd, filename, flags) == -1) {
uv_err_new(loop, errno);
uv__set_sys_error(loop, errno);
uv__close(fd);
return -1;
}

2
src/unix/netbsd.c
View File

@ -75,7 +75,7 @@ int uv_fs_event_init(uv_loop_t* loop,
uv_fs_event_t* handle,
const char* filename,
uv_fs_event_cb cb) {
uv_err_new(loop, ENOSYS);
uv__set_sys_error(loop, ENOSYS);
return -1;
}

18
src/unix/pipe.c
View File

@ -53,13 +53,13 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
/* Already bound? */
if (handle->fd >= 0) {
uv_err_new_artificial(handle->loop, UV_EINVAL);
uv__set_artificial_error(handle->loop, UV_EINVAL);
goto out;
}
/* Make a copy of the file name, it outlives this function's scope. */
if ((pipe_fname = strdup(name)) == NULL) {
uv_err_new(handle->loop, ENOMEM);
uv__set_sys_error(handle->loop, ENOMEM);
goto out;
}
@ -67,7 +67,7 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
name = NULL;
if ((sockfd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
goto out;
}
@ -88,7 +88,7 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
|| unlink(pipe_fname) == -1
|| bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr) == -1) {
/* Convert ENOENT to EACCES for compatibility with Windows. */
uv_err_new(handle->loop, (errno == ENOENT) ? EACCES : errno);
uv__set_sys_error(handle->loop, (errno == ENOENT) ? EACCES : errno);
goto out;
}
}
@ -125,13 +125,13 @@ int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
status = -1;
if (handle->fd == -1) {
uv_err_new_artificial(handle->loop, UV_EINVAL);
uv__set_artificial_error(handle->loop, UV_EINVAL);
goto out;
}
assert(handle->fd >= 0);
if ((status = listen(handle->fd, backlog)) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
} else {
handle->connection_cb = cb;
ev_io_init(&handle->read_watcher, uv__pipe_accept, handle->fd, EV_READ);
@ -190,7 +190,7 @@ int uv_pipe_connect(uv_connect_t* req,
status = -1;
if ((sockfd = uv__socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
goto out;
}
@ -207,7 +207,7 @@ int uv_pipe_connect(uv_connect_t* req,
while (r == -1 && errno == EINTR);
if (r == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
uv__close(sockfd);
goto out;
}
@ -257,7 +257,7 @@ void uv__pipe_accept(EV_P_ ev_io* watcher, int revents) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
assert(0 && "EAGAIN on uv__accept(pipefd)");
} else {
uv_err_new(pipe->loop, errno);
uv__set_sys_error(pipe->loop, errno);
}
} else {
pipe->accepted_fd = sockfd;

4
src/unix/process.c
View File

@ -277,7 +277,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
return 0;
error:
uv_err_new(process->loop, errno);
uv__set_sys_error(process->loop, errno);
uv__close(stdin_pipe[0]);
uv__close(stdin_pipe[1]);
uv__close(stdout_pipe[0]);
@ -292,7 +292,7 @@ int uv_process_kill(uv_process_t* process, int signum) {
int r = kill(process->pid, signum);
if (r) {
uv_err_new(process->loop, errno);
uv__set_sys_error(process->loop, errno);
return -1;
} else {
return 0;

38
src/unix/stream.c
View File

@ -87,7 +87,7 @@ int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
yes = 1;
if (stream->type == UV_TCP
&& setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
uv_err_new(stream->loop, errno);
uv__set_sys_error(stream->loop, errno);
return -1;
}
@ -118,7 +118,7 @@ void uv__stream_destroy(uv_stream_t* stream) {
free(req->bufs);
if (req->cb) {
uv_err_new_artificial(req->handle->loop, UV_EINTR);
uv__set_artificial_error(req->handle->loop, UV_EINTR);
req->cb(req, -1);
}
}
@ -129,7 +129,7 @@ void uv__stream_destroy(uv_stream_t* stream) {
req = ngx_queue_data(q, uv_write_t, queue);
if (req->cb) {
uv_err_new_artificial(stream->loop, req->error);
uv__set_artificial_error(stream->loop, req->error);
req->cb(req, req->error ? -1 : 0);
}
}
@ -167,7 +167,7 @@ void uv__server_io(EV_P_ ev_io* watcher, int revents) {
/* TODO special trick. unlock reserved socket, accept, close. */
return;
} else {
uv_err_new(stream->loop, errno);
uv__set_sys_error(stream->loop, errno);
stream->connection_cb((uv_stream_t*)stream, -1);
}
} else {
@ -199,7 +199,7 @@ int uv_accept(uv_stream_t* server, uv_stream_t* client) {
streamClient = (uv_stream_t*)client;
if (streamServer->accepted_fd < 0) {
uv_err_new(server->loop, EAGAIN);
uv__set_sys_error(server->loop, EAGAIN);
goto out;
}
@ -272,12 +272,12 @@ static void uv__drain(uv_stream_t* stream) {
if (shutdown(stream->fd, SHUT_WR)) {
/* Error. Report it. User should call uv_close(). */
uv_err_new(stream->loop, errno);
uv__set_sys_error(stream->loop, errno);
if (req->cb) {
req->cb(req, -1);
}
} else {
uv_err_new(stream->loop, 0);
uv__set_sys_error(stream->loop, 0);
((uv_handle_t*) stream)->flags |= UV_SHUT;
if (req->cb) {
req->cb(req, 0);
@ -428,7 +428,7 @@ static void uv__write_callbacks(uv_stream_t* stream) {
/* NOTE: call callback AFTER freeing the request data. */
if (req->cb) {
uv_err_new_artificial(stream->loop, req->error);
uv__set_artificial_error(stream->loop, req->error);
req->cb(req, req->error ? -1 : 0);
}
@ -472,19 +472,19 @@ static void uv__read(uv_stream_t* stream) {
if (stream->flags & UV_READING) {
ev_io_start(ev, &stream->read_watcher);
}
uv_err_new(stream->loop, EAGAIN);
uv__set_sys_error(stream->loop, EAGAIN);
stream->read_cb(stream, 0, buf);
return;
} else {
/* Error. User should call uv_close(). */
uv_err_new(stream->loop, errno);
uv__set_sys_error(stream->loop, errno);
stream->read_cb(stream, -1, buf);
assert(!ev_is_active(&stream->read_watcher));
return;
}
} else if (nread == 0) {
/* EOF */
uv_err_new_artificial(stream->loop, UV_EOF);
uv__set_artificial_error(stream->loop, UV_EOF);
ev_io_stop(ev, &stream->read_watcher);
stream->read_cb(stream, -1, buf);
return;
@ -505,7 +505,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
stream->flags & UV_SHUT ||
stream->flags & UV_CLOSED ||
stream->flags & UV_CLOSING) {
uv_err_new(stream->loop, EINVAL);
uv__set_sys_error(stream->loop, EINVAL);
return -1;
}
@ -593,7 +593,7 @@ static void uv__stream_connect(uv_stream_t* stream) {
return;
} else {
/* Error */
uv_err_new(stream->loop, error);
uv__set_sys_error(stream->loop, error);
stream->connect_req = NULL;
if (req->cb) {
@ -610,7 +610,7 @@ int uv__connect(uv_connect_t* req, uv_stream_t* stream, struct sockaddr* addr,
if (stream->fd <= 0) {
if ((sockfd = uv__socket(addr->sa_family, SOCK_STREAM, 0)) == -1) {
uv_err_new(stream->loop, errno);
uv__set_sys_error(stream->loop, errno);
return -1;
}
@ -627,12 +627,12 @@ int uv__connect(uv_connect_t* req, uv_stream_t* stream, struct sockaddr* addr,
ngx_queue_init(&req->queue);
if (stream->connect_req) {
uv_err_new(stream->loop, EALREADY);
uv__set_sys_error(stream->loop, EALREADY);
return -1;
}
if (stream->type != UV_TCP) {
uv_err_new(stream->loop, ENOTSOCK);
uv__set_sys_error(stream->loop, ENOTSOCK);
return -1;
}
@ -656,7 +656,7 @@ int uv__connect(uv_connect_t* req, uv_stream_t* stream, struct sockaddr* addr,
break;
default:
uv_err_new(stream->loop, errno);
uv__set_sys_error(stream->loop, errno);
return -1;
}
}
@ -684,7 +684,7 @@ int uv_write(uv_write_t* req, uv_stream_t* stream, uv_buf_t bufs[], int bufcnt,
"uv_write (unix) does not yet support other types of streams");
if (stream->fd < 0) {
uv_err_new(stream->loop, EBADF);
uv__set_sys_error(stream->loop, EBADF);
return -1;
}
@ -742,7 +742,7 @@ int uv_read_start(uv_stream_t* stream, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
stream->type == UV_TTY);
if (stream->flags & UV_CLOSING) {
uv_err_new(stream->loop, EINVAL);
uv__set_sys_error(stream->loop, EINVAL);
return -1;
}

2
src/unix/sunos.c
View File

@ -67,7 +67,7 @@ int uv_fs_event_init(uv_loop_t* loop,
uv_fs_event_t* handle,
const char* filename,
uv_fs_event_cb cb) {
uv_err_new(loop, ENOSYS);
uv__set_sys_error(loop, ENOSYS);
return -1;
}

30
src/unix/tcp.c
View File

@ -45,7 +45,7 @@ static int uv__tcp_bind(uv_tcp_t* tcp,
if (tcp->fd < 0) {
if ((tcp->fd = uv__socket(domain, SOCK_STREAM, 0)) == -1) {
uv_err_new(tcp->loop, errno);
uv__set_sys_error(tcp->loop, errno);
goto out;
}
@ -64,7 +64,7 @@ static int uv__tcp_bind(uv_tcp_t* tcp,
if (errno == EADDRINUSE) {
tcp->delayed_error = errno;
} else {
uv_err_new(tcp->loop, errno);
uv__set_sys_error(tcp->loop, errno);
goto out;
}
}
@ -78,7 +78,7 @@ out:
int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
if (handle->type != UV_TCP || addr.sin_family != AF_INET) {
uv_err_new(handle->loop, EFAULT);
uv__set_sys_error(handle->loop, EFAULT);
return -1;
}
@ -91,7 +91,7 @@ int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
if (handle->type != UV_TCP || addr.sin6_family != AF_INET6) {
uv_err_new(handle->loop, EFAULT);
uv__set_sys_error(handle->loop, EFAULT);
return -1;
}
@ -112,13 +112,13 @@ int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name,
saved_errno = errno;
if (handle->delayed_error) {
uv_err_new(handle->loop, handle->delayed_error);
uv__set_sys_error(handle->loop, handle->delayed_error);
rv = -1;
goto out;
}
if (handle->fd < 0) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
rv = -1;
goto out;
}
@ -127,7 +127,7 @@ int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name,
socklen = (socklen_t)*namelen;
if (getsockname(handle->fd, name, &socklen) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
rv = -1;
} else {
*namelen = (int)socklen;
@ -149,13 +149,13 @@ int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
saved_errno = errno;
if (handle->delayed_error) {
uv_err_new(handle->loop, handle->delayed_error);
uv__set_sys_error(handle->loop, handle->delayed_error);
rv = -1;
goto out;
}
if (handle->fd < 0) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
rv = -1;
goto out;
}
@ -164,7 +164,7 @@ int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
socklen = (socklen_t)*namelen;
if (getpeername(handle->fd, name, &socklen) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
rv = -1;
} else {
*namelen = (int)socklen;
@ -180,13 +180,13 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
int r;
if (tcp->delayed_error) {
uv_err_new(tcp->loop, tcp->delayed_error);
uv__set_sys_error(tcp->loop, tcp->delayed_error);
return -1;
}
if (tcp->fd < 0) {
if ((tcp->fd = uv__socket(AF_INET, SOCK_STREAM, 0)) == -1) {
uv_err_new(tcp->loop, errno);
uv__set_sys_error(tcp->loop, errno);
return -1;
}
@ -201,7 +201,7 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
r = listen(tcp->fd, backlog);
if (r < 0) {
uv_err_new(tcp->loop, errno);
uv__set_sys_error(tcp->loop, errno);
return -1;
}
@ -227,7 +227,7 @@ int uv_tcp_connect(uv_connect_t* req,
status = -1;
if (handle->type != UV_TCP || address.sin_family != AF_INET) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
goto out;
}
@ -254,7 +254,7 @@ int uv_tcp_connect6(uv_connect_t* req,
status = -1;
if (handle->type != UV_TCP || address.sin6_family != AF_INET6) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
goto out;
}

8
src/unix/tty.c
View File

@ -65,7 +65,7 @@ int uv_tty_set_mode(uv_tty_t* tty, int mode) {
return 0;
fatal:
uv_err_new(tty->loop, ENOTTY);
uv__set_sys_error(tty->loop, ENOTTY);
return -1;
}
@ -74,7 +74,7 @@ int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
struct winsize ws;
if (ioctl(tty->fd, TIOCGWINSZ, &ws) < 0) {
uv_err_new(tty->loop, errno);
uv__set_sys_error(tty->loop, errno);
return -1;
}
@ -89,7 +89,7 @@ uv_handle_type uv_guess_handle(uv_file file) {
struct stat s;
if (file < 0) {
uv_err_new(NULL, EINVAL); /* XXX Need loop? */
uv__set_sys_error(NULL, EINVAL); /* XXX Need loop? */
return -1;
}
@ -98,7 +98,7 @@ uv_handle_type uv_guess_handle(uv_file file) {
}
if (fstat(file, &s)) {
uv_err_new(NULL, errno); /* XXX Need loop? */
uv__set_sys_error(NULL, errno); /* XXX Need loop? */
return -1;
}

36
src/unix/udp.c
View File

@ -84,7 +84,7 @@ void uv__udp_destroy(uv_udp_t* handle) {
req = ngx_queue_data(q, uv_udp_send_t, queue);
if (req->send_cb) {
/* FIXME proper error code like UV_EABORTED */
uv_err_new_artificial(handle->loop, UV_EINTR);
uv__set_artificial_error(handle->loop, UV_EINTR);
req->send_cb(req, -1);
}
}
@ -187,7 +187,7 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
req->send_cb(req, 0);
}
else {
uv_err_new(handle->loop, -req->status);
uv__set_sys_error(handle->loop, -req->status);
req->send_cb(req, -1);
}
}
@ -223,11 +223,11 @@ static void uv__udp_recvmsg(uv_udp_t* handle) {
if (nread == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
uv_err_new(handle->loop, EAGAIN);
uv__set_sys_error(handle->loop, EAGAIN);
handle->recv_cb(handle, 0, buf, NULL, 0);
}
else {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
handle->recv_cb(handle, -1, buf, NULL, 0);
}
}
@ -305,24 +305,24 @@ static int uv__udp_bind(uv_udp_t* handle,
/* Check for bad flags. */
if (flags & ~UV_UDP_IPV6ONLY) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
goto out;
}
/* Cannot set IPv6-only mode on non-IPv6 socket. */
if ((flags & UV_UDP_IPV6ONLY) && domain != AF_INET6) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
goto out;
}
/* Check for already active socket. */
if (handle->fd != -1) {
uv_err_new_artificial(handle->loop, UV_EALREADY);
uv__set_artificial_error(handle->loop, UV_EALREADY);
goto out;
}
if ((fd = uv__socket(domain, SOCK_DGRAM, 0)) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
goto out;
}
@ -330,17 +330,17 @@ static int uv__udp_bind(uv_udp_t* handle,
#ifdef IPV6_V6ONLY
yes = 1;
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof yes) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
goto out;
}
#else
uv_err_new((uv_handle_t*)handle, ENOTSUP);
uv__set_sys_error((uv_handle_t*)handle, ENOTSUP);
goto out;
#endif
}
if (bind(fd, addr, len) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
goto out;
}
@ -417,7 +417,7 @@ static int uv__udp_send(uv_udp_send_t* req,
req->bufs = req->bufsml;
}
else if ((req->bufs = malloc(bufcnt * sizeof(bufs[0]))) == NULL) {
uv_err_new(handle->loop, ENOMEM);
uv__set_sys_error(handle->loop, ENOMEM);
return -1;
}
memcpy(req->bufs, bufs, bufcnt * sizeof(bufs[0]));
@ -445,7 +445,7 @@ int uv_udp_init(uv_loop_t* loop, uv_udp_t* handle) {
int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr, unsigned flags) {
if (handle->type != UV_UDP || addr.sin_family != AF_INET) {
uv_err_new(handle->loop, EFAULT);
uv__set_sys_error(handle->loop, EFAULT);
return -1;
}
@ -459,7 +459,7 @@ int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr, unsigned flags) {
int uv_udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, unsigned flags) {
if (handle->type != UV_UDP || addr.sin6_family != AF_INET6) {
uv_err_new(handle->loop, EFAULT);
uv__set_sys_error(handle->loop, EFAULT);
return -1;
}
@ -481,7 +481,7 @@ int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name,
saved_errno = errno;
if (handle->fd < 0) {
uv_err_new(handle->loop, EINVAL);
uv__set_sys_error(handle->loop, EINVAL);
rv = -1;
goto out;
}
@ -490,7 +490,7 @@ int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name,
socklen = (socklen_t)*namelen;
if (getsockname(handle->fd, name, &socklen) == -1) {
uv_err_new(handle->loop, errno);
uv__set_sys_error(handle->loop, errno);
rv = -1;
} else {
*namelen = (int)socklen;
@ -538,12 +538,12 @@ int uv_udp_recv_start(uv_udp_t* handle,
uv_alloc_cb alloc_cb,
uv_udp_recv_cb recv_cb) {
if (alloc_cb == NULL || recv_cb == NULL) {
uv_err_new_artificial(handle->loop, UV_EINVAL);
uv__set_artificial_error(handle->loop, UV_EINVAL);
return -1;
}
if (ev_is_active(&handle->read_watcher)) {
uv_err_new_artificial(handle->loop, UV_EALREADY);
uv__set_artificial_error(handle->loop, UV_EALREADY);
return -1;
}

18
src/uv-common.c
View File

@ -95,6 +95,24 @@ const char* uv_err_name(uv_err_t err) {
}
void uv__set_error(uv_loop_t* loop, uv_err_code code, int sys_error) {
loop->last_err.code = code;
loop->last_err.sys_errno_ = sys_error;
}
void uv__set_sys_error(uv_loop_t* loop, int sys_error) {
loop->last_err.code = uv_translate_sys_error(sys_error);
loop->last_err.sys_errno_ = sys_error;
}
void uv__set_artificial_error(uv_loop_t* loop, uv_err_code code) {
loop->last_err.code = code;
loop->last_err.sys_errno_ = 0;
}
struct sockaddr_in uv_ip4_addr(const char* ip, int port) {
struct sockaddr_in addr;

4
src/uv-common.h
View File

@ -48,5 +48,9 @@ void uv_add_ares_handle(uv_loop_t* loop, uv_ares_task_t* handle);
int uv_ares_handles_empty(uv_loop_t* loop);
uv_err_code uv_translate_sys_error(int sys_errno);
void uv__set_error(uv_loop_t* loop, uv_err_code code, int sys_error);
void uv__set_sys_error(uv_loop_t* loop, int sys_error);
void uv__set_artificial_error(uv_loop_t* loop, uv_err_code code);
#endif /* UV_COMMON_H_ */

12
src/win/error.c
View File

@ -143,15 +143,3 @@ uv_err_t uv_new_sys_error(int sys_errno) {
e.sys_errno_ = sys_errno;
return e;
}
void uv_set_sys_error(uv_loop_t* loop, int sys_errno) {
loop->last_error.code = uv_translate_sys_error(sys_errno);
loop->last_error.sys_errno_ = sys_errno;
}
void uv_set_error(uv_loop_t* loop, uv_err_code code, int sys_errno) {
loop->last_error.code = code;
loop->last_error.sys_errno_ = sys_errno;
}

4
src/win/fs-event.c
View File

@ -144,7 +144,7 @@ int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle,
if (!uv_utf8_to_utf16(filename, filenamew,
name_size / sizeof(wchar_t))) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -252,7 +252,7 @@ error:
handle->buffer = NULL;
}
uv_set_sys_error(loop, last_error);
uv__set_sys_error(loop, last_error);
return -1;
}

4
src/win/fs.c
View File

@ -66,7 +66,7 @@
if (!QueueUserWorkItem(&uv_fs_thread_proc, \
req, \
WT_EXECUTELONGFUNCTION)) { \
uv_set_sys_error((loop), GetLastError()); \
uv__set_sys_error((loop), GetLastError()); \
return -1; \
} \
req->flags |= UV_FS_ASYNC_QUEUED; \
@ -75,7 +75,7 @@
#define SET_UV_LAST_ERROR_FROM_REQ(req) \
if (req->flags & UV_FS_LAST_ERROR_SET) { \
uv_set_sys_error(req->loop, req->last_error); \
uv__set_sys_error(req->loop, req->last_error); \
}
#define SET_REQ_LAST_ERROR(req, error) \

14
src/win/getaddrinfo.c
View File

@ -256,7 +256,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
if (handle == NULL || getaddrinfo_cb == NULL ||
(node == NULL && service == NULL)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
goto error;
}
@ -271,7 +271,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
if (node != NULL) {
nodesize = ALIGNED_SIZE(uv_utf8_to_utf16(node, NULL, 0) * sizeof(wchar_t));
if (nodesize == 0) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
goto error;
}
}
@ -280,7 +280,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
servicesize = ALIGNED_SIZE(uv_utf8_to_utf16(service, NULL, 0) *
sizeof(wchar_t));
if (servicesize == 0) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
goto error;
}
}
@ -291,7 +291,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
/* allocate memory for inputs, and partition it as needed */
alloc_ptr = (char*)malloc(nodesize + servicesize + hintssize);
if (!alloc_ptr) {
uv_set_sys_error(loop, WSAENOBUFS);
uv__set_sys_error(loop, WSAENOBUFS);
goto error;
}
@ -305,7 +305,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
if (uv_utf8_to_utf16(node,
(wchar_t*) alloc_ptr,
nodesize / sizeof(wchar_t)) == 0) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
goto error;
}
alloc_ptr += nodesize;
@ -320,7 +320,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
if (uv_utf8_to_utf16(service,
(wchar_t*) alloc_ptr,
servicesize / sizeof(wchar_t)) == 0) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
goto error;
}
alloc_ptr += servicesize;
@ -352,7 +352,7 @@ int uv_getaddrinfo(uv_loop_t* loop,
if (QueueUserWorkItem(&getaddrinfo_thread_proc,
handle,
WT_EXECUTELONGFUNCTION) == 0) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
goto error;
}

3
src/win/internal.h
View File

@ -275,9 +275,6 @@ extern const uv_err_t uv_ok_;
void uv_fatal_error(const int errorno, const char* syscall);
uv_err_code uv_translate_sys_error(int sys_errno);
uv_err_t uv_new_sys_error(int sys_errno);
void uv_set_sys_error(uv_loop_t* loop, int sys_errno);
void uv_set_error(uv_loop_t* loop, uv_err_code code, int sys_errno);
#define SET_REQ_STATUS(req, status) \
(req)->overlapped.Internal = (ULONG_PTR) (status)

52
src/win/pipe.c
View File

@ -111,7 +111,7 @@ int uv_stdio_pipe_server(uv_loop_t* loop, uv_pipe_t* handle, DWORD access,
errno = GetLastError();
if (errno != ERROR_PIPE_BUSY && errno != ERROR_ACCESS_DENIED) {
uv_set_sys_error(loop, errno);
uv__set_sys_error(loop, errno);
err = -1;
goto done;
}
@ -124,7 +124,7 @@ int uv_stdio_pipe_server(uv_loop_t* loop, uv_pipe_t* handle, DWORD access,
loop->iocp,
(ULONG_PTR)handle,
0) == NULL) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
err = -1;
goto done;
}
@ -209,7 +209,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
/* Failure */
handle->flags &= ~UV_HANDLE_SHUTTING;
if (req->cb) {
uv_set_sys_error(loop, pRtlNtStatusToDosError(nt_status));
uv__set_sys_error(loop, pRtlNtStatusToDosError(nt_status));
req->cb(req, -1);
}
DECREASE_PENDING_REQ_COUNT(handle);
@ -237,7 +237,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
/* Failure. */
handle->flags &= ~UV_HANDLE_SHUTTING;
if (req->cb) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
req->cb(req, -1);
}
DECREASE_PENDING_REQ_COUNT(handle);
@ -274,12 +274,12 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
uv_pipe_accept_t* req;
if (handle->flags & UV_HANDLE_BOUND) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
if (!name) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
@ -300,7 +300,7 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
}
if (!uv_utf8_to_utf16(name, handle->name, nameSize / sizeof(wchar_t))) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -317,17 +317,17 @@ int uv_pipe_bind(uv_pipe_t* handle, const char* name) {
if (handle->accept_reqs[0].pipeHandle == INVALID_HANDLE_VALUE) {
errno = GetLastError();
if (errno == ERROR_ACCESS_DENIED) {
uv_set_error(loop, UV_EADDRINUSE, errno);
uv__set_error(loop, UV_EADDRINUSE, errno);
} else if (errno == ERROR_PATH_NOT_FOUND || errno == ERROR_INVALID_NAME) {
uv_set_error(loop, UV_EACCESS, errno);
uv__set_error(loop, UV_EACCESS, errno);
} else {
uv_set_sys_error(loop, errno);
uv__set_sys_error(loop, errno);
}
goto error;
}
if (uv_set_pipe_handle(loop, handle, handle->accept_reqs[0].pipeHandle)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
goto error;
}
@ -473,7 +473,7 @@ error:
if (pipeHandle != INVALID_HANDLE_VALUE) {
CloseHandle(pipeHandle);
}
uv_set_sys_error(loop, errno);
uv__set_sys_error(loop, errno);
return -1;
}
@ -575,7 +575,7 @@ int uv_pipe_accept(uv_pipe_t* server, uv_pipe_t* client) {
if (!req) {
/* No valid connections found, so we error out. */
uv_set_sys_error(loop, WSAEWOULDBLOCK);
uv__set_sys_error(loop, WSAEWOULDBLOCK);
return -1;
}
@ -607,19 +607,19 @@ int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
if (!(handle->flags & UV_HANDLE_BOUND) &&
!(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
uv_set_error(loop, UV_EINVAL, 0);
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_LISTENING ||
handle->flags & UV_HANDLE_READING) {
uv_set_error(loop, UV_EALREADY, 0);
uv__set_artificial_error(loop, UV_EALREADY);
return -1;
}
if (!(handle->flags & UV_HANDLE_PIPESERVER) &&
!(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
uv_set_error(loop, UV_ENOTSUP, 0);
uv__set_artificial_error(loop, UV_ENOTSUP);
return -1;
}
@ -638,7 +638,7 @@ int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
req->next_pending = NULL;
if (uv_set_pipe_handle(loop, handle, pipeHandle)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -698,17 +698,17 @@ int uv_pipe_read_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb,
uv_loop_t* loop = handle->loop;
if (!(handle->flags & UV_HANDLE_CONNECTION)) {
uv_set_error(loop, UV_EINVAL, 0);
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_READING) {
uv_set_error(loop, UV_EALREADY, 0);
uv__set_artificial_error(loop, UV_EALREADY);
return -1;
}
if (handle->flags & UV_HANDLE_EOF) {
uv_set_error(loop, UV_EOF, 0);
uv__set_artificial_error(loop, UV_EOF);
return -1;
}
@ -730,19 +730,19 @@ int uv_pipe_write(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle,
int result;
if (bufcnt != 1) {
uv_set_error(loop, UV_ENOTSUP, 0);
uv__set_artificial_error(loop, UV_ENOTSUP);
return -1;
}
assert(handle->handle != INVALID_HANDLE_VALUE);
if (!(handle->flags & UV_HANDLE_CONNECTION)) {
uv_set_error(loop, UV_EINVAL, 0);
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_SHUTTING) {
uv_set_error(loop, UV_EOF, 0);
uv__set_artificial_error(loop, UV_EOF);
return -1;
}
@ -759,7 +759,7 @@ int uv_pipe_write(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle,
&req->overlapped);
if (!result && GetLastError() != ERROR_IO_PENDING) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -788,7 +788,7 @@ static void uv_pipe_read_eof(uv_loop_t* loop, uv_pipe_t* handle,
handle->flags |= UV_HANDLE_EOF;
uv_read_stop((uv_stream_t*) handle);
uv_set_error(loop, UV_EOF, 0);
uv__set_artificial_error(loop, UV_EOF);
handle->read_cb((uv_stream_t*) handle, -1, uv_null_buf_);
}
@ -801,7 +801,7 @@ static void uv_pipe_read_error(uv_loop_t* loop, uv_pipe_t* handle, int error,
uv_read_stop((uv_stream_t*) handle);
uv_set_sys_error(loop, error);
uv__set_sys_error(loop, error);
handle->read_cb((uv_stream_t*)handle, -1, buf);
}

18
src/win/process.c
View File

@ -45,7 +45,7 @@ typedef struct env_var {
uv_fatal_error(ERROR_OUTOFMEMORY, "malloc"); \
} \
if (!uv_utf8_to_utf16(s, t, size / sizeof(wchar_t))) { \
uv_set_sys_error(loop, GetLastError()); \
uv__set_sys_error(loop, GetLastError()); \
err = -1; \
goto done; \
}
@ -746,7 +746,7 @@ static int uv_create_stdio_pipe_pair(uv_loop_t* loop, uv_pipe_t* server_pipe,
DWORD mode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT;
if (server_pipe->type != UV_NAMED_PIPE) {
uv_set_error(loop, UV_EINVAL, 0);
uv__set_artificial_error(loop, UV_EINVAL);
err = -1;
goto done;
}
@ -771,13 +771,13 @@ static int uv_create_stdio_pipe_pair(uv_loop_t* loop, uv_pipe_t* server_pipe,
NULL);
if (*child_pipe == INVALID_HANDLE_VALUE) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
err = -1;
goto done;
}
if (!SetNamedPipeHandleState(*child_pipe, &mode, NULL, NULL)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
err = -1;
goto done;
}
@ -787,7 +787,7 @@ static int uv_create_stdio_pipe_pair(uv_loop_t* loop, uv_pipe_t* server_pipe,
*/
if (!ConnectNamedPipe(server_pipe->handle, NULL)) {
if (GetLastError() != ERROR_PIPE_CONNECTED) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
err = -1;
goto done;
}
@ -822,7 +822,7 @@ static int duplicate_std_handle(uv_loop_t* loop, DWORD id, HANDLE* dup) {
return 0;
} else if (handle == INVALID_HANDLE_VALUE) {
*dup = INVALID_HANDLE_VALUE;
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -834,7 +834,7 @@ static int duplicate_std_handle(uv_loop_t* loop, DWORD id, HANDLE* dup) {
TRUE,
DUPLICATE_SAME_ACCESS)) {
*dup = INVALID_HANDLE_VALUE;
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -854,7 +854,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
PROCESS_INFORMATION info;
if (!options.file) {
uv_set_error(loop, UV_EINVAL, 0);
uv__set_artificial_error(loop, UV_EINVAL);
return -1;
}
@ -877,7 +877,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process,
}
GetCurrentDirectoryW(size, cwd);
} else {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
err = -1;
goto done;
}

2
src/win/stdio.c
View File

@ -69,7 +69,7 @@ uv_stream_t* uv_std_handle(uv_loop_t* loop, uv_std_type type) {
default:
assert(0);
uv_set_error(loop, UV_EINVAL, 0);
uv__set_artificial_error(loop, UV_EINVAL);
return NULL;
}
}

6
src/win/stream.c
View File

@ -115,7 +115,7 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
return uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, bufcnt, cb);
default:
assert(0);
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
}
@ -125,12 +125,12 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) {
uv_loop_t* loop = handle->loop;
if (!(handle->flags & UV_HANDLE_CONNECTION)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_SHUTTING) {
uv_set_sys_error(loop, WSAESHUTDOWN);
uv__set_sys_error(loop, WSAESHUTDOWN);
return -1;
}

78
src/win/tcp.c
View File

@ -54,13 +54,13 @@ static int uv_tcp_set_socket(uv_loop_t* loop, uv_tcp_t* handle,
/* Set the socket to nonblocking mode */
if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
/* Make the socket non-inheritable */
if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -70,7 +70,7 @@ static int uv_tcp_set_socket(uv_loop_t* loop, uv_tcp_t* handle,
loop->iocp,
(ULONG_PTR)socket,
0) == NULL) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -80,7 +80,7 @@ static int uv_tcp_set_socket(uv_loop_t* loop, uv_tcp_t* handle,
FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {
handle->flags |= UV_HANDLE_SYNC_BYPASS_IOCP;
} else if (GetLastError() != ERROR_INVALID_FUNCTION) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
}
@ -107,8 +107,8 @@ int uv_tcp_init(uv_loop_t* loop, uv_tcp_t* handle) {
void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
uv_err_t err;
int status;
int sys_error;
if (handle->flags & UV_HANDLE_CONNECTION &&
handle->flags & UV_HANDLE_SHUTTING &&
@ -120,11 +120,11 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
handle->flags |= UV_HANDLE_SHUT;
} else {
status = -1;
err = uv_new_sys_error(WSAGetLastError());
sys_error = WSAGetLastError();
}
if (handle->shutdown_req->cb) {
if (status == -1) {
loop->last_error = err;
uv__set_sys_error(sys_error);
}
handle->shutdown_req->cb(handle->shutdown_req, status);
}
@ -163,7 +163,7 @@ static int uv__bind(uv_loop_t* loop, uv_tcp_t* handle, int domain,
if (handle->socket == INVALID_SOCKET) {
sock = socket(domain, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -179,10 +179,10 @@ static int uv__bind(uv_loop_t* loop, uv_tcp_t* handle, int domain,
err = WSAGetLastError();
if (err == WSAEADDRINUSE) {
/* Some errors are not to be reported until connect() or listen() */
handle->bind_error = uv_new_sys_error(err);
handle->bind_error = err;
handle->flags |= UV_HANDLE_BIND_ERROR;
} else {
uv_set_sys_error(loop, err);
uv__set_sys_error(loop, err);
return -1;
}
}
@ -197,7 +197,7 @@ int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
uv_loop_t* loop = handle->loop;
if (handle->type != UV_TCP || addr.sin_family != AF_INET) {
uv_set_sys_error(loop, WSAEFAULT);
uv__set_sys_error(loop, WSAEFAULT);
return -1;
}
@ -213,7 +213,7 @@ int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
uv_loop_t* loop = handle->loop;
if (handle->type != UV_TCP || addr.sin6_family != AF_INET6) {
uv_set_sys_error(loop, WSAEFAULT);
uv__set_sys_error(loop, WSAEFAULT);
return -1;
}
@ -226,7 +226,7 @@ int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) {
sizeof(struct sockaddr_in6));
} else {
uv_set_sys_error(loop, WSAEAFNOSUPPORT);
uv__set_sys_error(loop, WSAEAFNOSUPPORT);
return -1;
}
}
@ -356,14 +356,14 @@ int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) {
assert(backlog > 0);
if (handle->flags & UV_HANDLE_BIND_ERROR) {
loop->last_error = handle->bind_error;
uv__set_sys_error(handle->bind_error);
return -1;
}
if (handle->flags & UV_HANDLE_LISTENING ||
handle->flags & UV_HANDLE_READING) {
/* Already listening. */
uv_set_sys_error(loop, WSAEALREADY);
uv__set_sys_error(loop, WSAEALREADY);
return -1;
}
@ -372,7 +372,7 @@ int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) {
return -1;
if (listen(handle->socket, backlog) == SOCKET_ERROR) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -407,12 +407,12 @@ int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client) {
if (!req) {
/* No valid connections found, so we error out. */
uv_set_sys_error(loop, WSAEWOULDBLOCK);
uv__set_sys_error(loop, WSAEWOULDBLOCK);
return -1;
}
if (req->accept_socket == INVALID_SOCKET) {
uv_set_sys_error(loop, WSAENOTCONN);
uv__set_sys_error(loop, WSAENOTCONN);
return -1;
}
@ -445,17 +445,17 @@ int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
uv_loop_t* loop = handle->loop;
if (!(handle->flags & UV_HANDLE_CONNECTION)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_READING) {
uv_set_sys_error(loop, WSAEALREADY);
uv__set_sys_error(loop, WSAEALREADY);
return -1;
}
if (handle->flags & UV_HANDLE_EOF) {
uv_set_sys_error(loop, WSAESHUTDOWN);
uv__set_sys_error(loop, WSAESHUTDOWN);
return -1;
}
@ -480,12 +480,12 @@ int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
DWORD bytes;
if (handle->flags & UV_HANDLE_BIND_ERROR) {
loop->last_error = handle->bind_error;
uv__set_sys_error(handle->bind_error);
return -1;
}
if (handle->type != UV_TCP || address.sin_family != AF_INET) {
uv_set_sys_error(loop, WSAEFAULT);
uv__set_sys_error(loop, WSAEFAULT);
return -1;
}
@ -515,7 +515,7 @@ int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle,
/* The req will be processed with IOCP. */
handle->reqs_pending++;
} else {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -536,12 +536,12 @@ int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
}
if (handle->flags & UV_HANDLE_BIND_ERROR) {
loop->last_error = handle->bind_error;
uv__set_sys_error(handle->bind_error);
return -1;
}
if (handle->type != UV_TCP || address.sin6_family != AF_INET6) {
uv_set_sys_error(loop, WSAEFAULT);
uv__set_sys_error(loop, WSAEFAULT);
return -1;
}
@ -569,7 +569,7 @@ int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
} else if (UV_SUCCEEDED_WITH_IOCP(success)) {
handle->reqs_pending++;
} else {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -583,18 +583,18 @@ int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name,
int result;
if (!(handle->flags & UV_HANDLE_BOUND)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_BIND_ERROR) {
loop->last_error = handle->bind_error;
uv__set_sys_error(handle->bind_error);
return -1;
}
result = getsockname(handle->socket, name, namelen);
if (result != 0) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -608,18 +608,18 @@ int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name,
int result;
if (!(handle->flags & UV_HANDLE_BOUND)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_BIND_ERROR) {
loop->last_error = handle->bind_error;
uv__set_sys_error(handle->bind_error);
return -1;
}
result = getpeername(handle->socket, name, namelen);
if (result != 0) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -633,12 +633,12 @@ int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
DWORD bytes;
if (!(handle->flags & UV_HANDLE_CONNECTION)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
if (handle->flags & UV_HANDLE_SHUTTING) {
uv_set_sys_error(loop, WSAESHUTDOWN);
uv__set_sys_error(loop, WSAESHUTDOWN);
return -1;
}
@ -670,7 +670,7 @@ int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
handle->write_queue_size += req->queued_bytes;
} else {
/* Send failed due to an error. */
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -753,11 +753,11 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle,
err = WSAGetLastError();
if (err == WSAEWOULDBLOCK) {
/* Read buffer was completely empty, report a 0-byte read. */
uv_set_sys_error(loop, WSAEWOULDBLOCK);
uv__set_sys_error(loop, WSAEWOULDBLOCK);
handle->read_cb((uv_stream_t*)handle, 0, buf);
} else {
/* Ouch! serious error. */
uv_set_sys_error(loop, err);
uv__set_sys_error(loop, err);
handle->flags &= ~UV_HANDLE_READING;
handle->read_cb((uv_stream_t*)handle, -1, buf);
}
@ -859,7 +859,7 @@ void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
active_tcp_streams++;
((uv_connect_cb)req->cb)(req, 0);
} else {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
((uv_connect_cb)req->cb)(req, -1);
}
} else {

2
src/win/threadpool.c
View File

@ -57,7 +57,7 @@ int uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb,
uv_work_req_init(loop, req, work_cb, after_work_cb);
if (!QueueUserWorkItem(&uv_work_thread_proc, req, WT_EXECUTELONGFUNCTION)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}

6
src/win/timer.c
View File

@ -77,12 +77,12 @@ uint64_t uv_hrtime(void) {
/* If the performance frequency is zero, there's no support. */
if (!uv_hrtime_frequency_) {
/* uv_set_sys_error(loop, ERROR_NOT_SUPPORTED); */
/* uv__set_sys_error(loop, ERROR_NOT_SUPPORTED); */
return 0;
}
if (!QueryPerformanceCounter(&counter)) {
/* uv_set_sys_error(loop, GetLastError()); */
/* uv__set_sys_error(loop, GetLastError()); */
return 0;
}
@ -181,7 +181,7 @@ int uv_timer_again(uv_timer_t* handle) {
/* If timer_cb is NULL that means that the timer was never started. */
if (!handle->timer_cb) {
uv_set_sys_error(loop, ERROR_INVALID_DATA);
uv__set_sys_error(loop, ERROR_INVALID_DATA);
return -1;
}

20
src/win/tty.c
View File

@ -92,12 +92,12 @@ int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, uv_file fd) {
win_handle = (HANDLE) _get_osfhandle(fd);
if (win_handle == INVALID_HANDLE_VALUE) {
uv_set_sys_error(loop, ERROR_INVALID_HANDLE);
uv__set_sys_error(loop, ERROR_INVALID_HANDLE);
return -1;
}
if (!GetConsoleMode(win_handle, &tty->original_console_mode)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -163,7 +163,7 @@ int uv_tty_set_mode(uv_tty_t* tty, int mode) {
}
if (!SetConsoleMode(tty->handle, flags)) {
uv_set_sys_error(tty->loop, GetLastError());
uv__set_sys_error(tty->loop, GetLastError());
return -1;
}
@ -203,7 +203,7 @@ int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(tty->handle, &info)) {
uv_set_sys_error(tty->loop, GetLastError());
uv__set_sys_error(tty->loop, GetLastError());
return -1;
}
@ -461,7 +461,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
/* Fetch the number of events */
if (!GetNumberOfConsoleInputEvents(handle->handle, &records_left)) {
handle->flags &= ~UV_HANDLE_READING;
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
handle->read_cb((uv_stream_t*)handle, -1, uv_null_buf_);
goto out;
}
@ -479,7 +479,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
&handle->last_input_record,
1,
&records_read)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
handle->flags &= ~UV_HANDLE_READING;
handle->read_cb((uv_stream_t*) handle, -1, buf);
goto out;
@ -579,7 +579,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
/* If the utf16 character(s) couldn't be converted something must */
/* be wrong. */
if (!char_len) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
handle->flags &= ~UV_HANDLE_READING;
handle->read_cb((uv_stream_t*) handle, -1, buf);
goto out;
@ -693,7 +693,7 @@ void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle,
handle->read_cb((uv_stream_t*) handle, -1, buf);
} else {
/* The read was cancelled, or whatever we don't care */
uv_set_sys_error(loop, WSAEWOULDBLOCK); /* maps to UV_EAGAIN */
uv__set_sys_error(loop, WSAEWOULDBLOCK); /* maps to UV_EAGAIN */
handle->read_cb((uv_stream_t*) handle, 0, buf);
}
@ -702,7 +702,7 @@ void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle,
/* TODO: read unicode, convert to utf-8 */
DWORD bytes = req->overlapped.InternalHigh;
if (bytes == 0) {
uv_set_sys_error(loop, WSAEWOULDBLOCK); /* maps to UV_EAGAIN */
uv__set_sys_error(loop, WSAEWOULDBLOCK); /* maps to UV_EAGAIN */
}
handle->read_cb((uv_stream_t*) handle, bytes, buf);
}
@ -770,7 +770,7 @@ int uv_tty_read_stop(uv_tty_t* handle) {
DWORD written;
memset(&record, 0, sizeof record);
if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) {
uv_set_sys_error(handle->loop, GetLastError());
uv__set_sys_error(handle->loop, GetLastError());
return -1;
}
}

30
src/win/udp.c
View File

@ -46,13 +46,13 @@ int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name,
int result;
if (!(handle->flags & UV_HANDLE_BOUND)) {
uv_set_sys_error(loop, WSAEINVAL);
uv__set_sys_error(loop, WSAEINVAL);
return -1;
}
result = getsockname(handle->socket, name, namelen);
if (result != 0) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -68,13 +68,13 @@ static int uv_udp_set_socket(uv_loop_t* loop, uv_udp_t* handle,
/* Set the socket to nonblocking mode */
if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
/* Make the socket non-inheritable */
if (!SetHandleInformation((HANDLE)socket, HANDLE_FLAG_INHERIT, 0)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -84,14 +84,14 @@ static int uv_udp_set_socket(uv_loop_t* loop, uv_udp_t* handle,
loop->iocp,
(ULONG_PTR)socket,
0) == NULL) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
if (pSetFileCompletionNotificationModes) {
if (!pSetFileCompletionNotificationModes((HANDLE)socket,
FILE_SKIP_SET_EVENT_ON_HANDLE | FILE_SKIP_COMPLETION_PORT_ON_SUCCESS)) {
uv_set_sys_error(loop, GetLastError());
uv__set_sys_error(loop, GetLastError());
return -1;
}
@ -148,14 +148,14 @@ static int uv__bind(uv_udp_t* handle, int domain, struct sockaddr* addr,
if ((flags & UV_UDP_IPV6ONLY) && domain != AF_INET6) {
/* UV_UDP_IPV6ONLY is supported only for IPV6 sockets */
uv_set_sys_error(loop, UV_EINVAL);
uv__set_sys_error(loop, UV_EINVAL);
return -1;
}
if (handle->socket == INVALID_SOCKET) {
sock = socket(domain, SOCK_DGRAM, 0);
if (sock == INVALID_SOCKET) {
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -184,7 +184,7 @@ static int uv__bind(uv_udp_t* handle, int domain, struct sockaddr* addr,
if (r == SOCKET_ERROR) {
err = WSAGetLastError();
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -199,7 +199,7 @@ int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr,
uv_loop_t* loop = handle->loop;
if (handle->type != UV_UDP || addr.sin_family != AF_INET) {
uv_set_sys_error(loop, WSAEFAULT);
uv__set_sys_error(loop, WSAEFAULT);
return -1;
}
@ -216,7 +216,7 @@ int uv_udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr,
uv_loop_t* loop = handle->loop;
if (handle->type != UV_UDP || addr.sin6_family != AF_INET6) {
uv_set_sys_error(loop, WSAEFAULT);
uv__set_sys_error(loop, WSAEFAULT);
return -1;
}
@ -330,7 +330,7 @@ int uv_udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb,
uv_loop_t* loop = handle->loop;
if (handle->flags & UV_HANDLE_READING) {
uv_set_sys_error(loop, WSAEALREADY);
uv__set_sys_error(loop, WSAEALREADY);
return -1;
}
@ -396,7 +396,7 @@ static int uv__udp_send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
handle->reqs_pending++;
} else {
/* Send failed due to an error. */
uv_set_sys_error(loop, WSAGetLastError());
uv__set_sys_error(loop, WSAGetLastError());
return -1;
}
@ -510,11 +510,11 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle,
} else {
err = WSAGetLastError();
if (err == WSAEWOULDBLOCK) {
uv_set_sys_error(loop, WSAEWOULDBLOCK);
uv__set_sys_error(loop, WSAEWOULDBLOCK);
handle->recv_cb(handle, 0, buf, NULL, 0);
} else {
/* Ouch! serious error. */
uv_set_sys_error(loop, err);
uv__set_sys_error(loop, err);
handle->recv_cb(handle, -1, buf, NULL, 0);
}
}

4
src/win/util.c
View File

@ -69,7 +69,7 @@ int uv_exepath(char* buffer, size_t* size) {
/* Get the path as UTF-16 */
utf16Size = GetModuleFileNameW(NULL, utf16Buffer, *size - 1);
if (utf16Size <= 0) {
/* uv_set_sys_error(loop, GetLastError()); */
/* uv__set_sys_error(loop, GetLastError()); */
retVal = -1;
goto done;
}
@ -79,7 +79,7 @@ int uv_exepath(char* buffer, size_t* size) {
/* Convert to UTF-8 */
*size = uv_utf16_to_utf8(utf16Buffer, utf16Size, buffer, *size);
if (!*size) {
/* uv_set_sys_error(loop, GetLastError()); */
/* uv__set_sys_error(loop, GetLastError()); */
retVal = -1;
goto done;
}