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

unix,win: merge handle flags

Browse Source 
Some long overdue refactoring that unifies more of the UNIX and Windows
backends.

PR-URL: https://github.com/libuv/libuv/pull/1904
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Saúl Ibarra Corretgé <saghul@gmail.com>
This commit is contained in:
Ben Noordhuis 2018-06-28 15:03:09 +02:00
parent 71bb0cc25a
commit 619937c783
30 changed files with 225 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/fs-poll.c
View File

@ -83,7 +83,7 @@ int uv_fs_poll_start(uv_fs_poll_t* handle,
if (err < 0) if (err < 0)
goto error; goto error;
ctx->timer_handle.flags |= UV__HANDLE_INTERNAL; ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
uv__handle_unref(&ctx->timer_handle); uv__handle_unref(&ctx->timer_handle);
err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb); err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
@ -248,7 +248,7 @@ static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
#include "win/handle-inl.h" #include "win/handle-inl.h"
void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) { void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) {
assert(handle->flags & UV__HANDLE_CLOSING); assert(handle->flags & UV_HANDLE_CLOSING);
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
uv__handle_close(handle); uv__handle_close(handle);
} }

18
src/unix/core.c
View File

@ -116,7 +116,7 @@ uint64_t uv_hrtime(void) {
void uv_close(uv_handle_t* handle, uv_close_cb close_cb) { void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
assert(!uv__is_closing(handle)); assert(!uv__is_closing(handle));
handle->flags |= UV_CLOSING; handle->flags |= UV_HANDLE_CLOSING;
handle->close_cb = close_cb; handle->close_cb = close_cb;
switch (handle->type) { switch (handle->type) {
@ -214,8 +214,8 @@ int uv__socket_sockopt(uv_handle_t* handle, int optname, int* value) {
} }
void uv__make_close_pending(uv_handle_t* handle) { void uv__make_close_pending(uv_handle_t* handle) {
assert(handle->flags & UV_CLOSING); assert(handle->flags & UV_HANDLE_CLOSING);
assert(!(handle->flags & UV_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
handle->next_closing = handle->loop->closing_handles; handle->next_closing = handle->loop->closing_handles;
handle->loop->closing_handles = handle; handle->loop->closing_handles = handle;
} }
@ -241,15 +241,17 @@ int uv__getiovmax(void) {
static void uv__finish_close(uv_handle_t* handle) { static void uv__finish_close(uv_handle_t* handle) {
/* Note: while the handle is in the UV_CLOSING state now, it's still possible /* Note: while the handle is in the UV_HANDLE_CLOSING state now, it's still
* for it to be active in the sense that uv__is_active() returns true. * possible for it to be active in the sense that uv__is_active() returns
* true.
*
* A good example is when the user calls uv_shutdown(), immediately followed * A good example is when the user calls uv_shutdown(), immediately followed
* by uv_close(). The handle is considered active at this point because the * by uv_close(). The handle is considered active at this point because the
* completion of the shutdown req is still pending. * completion of the shutdown req is still pending.
*/ */
assert(handle->flags & UV_CLOSING); assert(handle->flags & UV_HANDLE_CLOSING);
assert(!(handle->flags & UV_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
handle->flags |= UV_CLOSED; handle->flags |= UV_HANDLE_CLOSED;
switch (handle->type) { switch (handle->type) {
case UV_PREPARE: case UV_PREPARE:

2
src/unix/fsevents.c
View File

@ -836,7 +836,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) {
handle->cf_cb->data = handle; handle->cf_cb->data = handle;
uv_async_init(handle->loop, handle->cf_cb, uv__fsevents_cb); uv_async_init(handle->loop, handle->cf_cb, uv__fsevents_cb);
handle->cf_cb->flags |= UV__HANDLE_INTERNAL; handle->cf_cb->flags |= UV_HANDLE_INTERNAL;
uv_unref((uv_handle_t*) handle->cf_cb); uv_unref((uv_handle_t*) handle->cf_cb);
err = uv_mutex_init(&handle->cf_mutex); err = uv_mutex_init(&handle->cf_mutex);

20
src/unix/internal.h
View File

@ -127,26 +127,6 @@ int uv__pthread_sigmask(int how, const sigset_t* set, sigset_t* oset);
typedef struct uv__stream_queued_fds_s uv__stream_queued_fds_t; typedef struct uv__stream_queued_fds_s uv__stream_queued_fds_t;
/* handle flags */
enum {
UV_CLOSING = 0x01, /* uv_close() called but not finished. */
UV_CLOSED = 0x02, /* close(2) finished. */
UV_STREAM_READING = 0x04, /* uv_read_start() called. */
UV_STREAM_SHUTTING = 0x08, /* uv_shutdown() called but not complete. */
UV_STREAM_SHUT = 0x10, /* Write side closed. */
UV_STREAM_READABLE = 0x20, /* The stream is readable */
UV_STREAM_WRITABLE = 0x40, /* The stream is writable */
UV_STREAM_BLOCKING = 0x80, /* Synchronous writes. */
UV_STREAM_READ_PARTIAL = 0x100, /* read(2) read less than requested. */
UV_STREAM_READ_EOF = 0x200, /* read(2) read EOF. */
UV_TCP_NODELAY = 0x400, /* Disable Nagle. */
UV_TCP_KEEPALIVE = 0x800, /* Turn on keep-alive. */
UV_TCP_SINGLE_ACCEPT = 0x1000, /* Only accept() when idle. */
UV_HANDLE_IPV6 = 0x10000, /* Handle is bound to a IPv6 socket. */
UV_UDP_PROCESSING = 0x20000, /* Handle is running the send callback queue. */
UV_HANDLE_BOUND = 0x40000 /* Handle is bound to an address and port */
};
/* loop flags */ /* loop flags */
enum { enum {
UV_LOOP_BLOCK_SIGPROF = 1 UV_LOOP_BLOCK_SIGPROF = 1

4
src/unix/loop.c
View File

@ -74,7 +74,7 @@ int uv_loop_init(uv_loop_t* loop) {
goto fail_signal_init; goto fail_signal_init;
uv__handle_unref(&loop->child_watcher); uv__handle_unref(&loop->child_watcher);
loop->child_watcher.flags |= UV__HANDLE_INTERNAL; loop->child_watcher.flags |= UV_HANDLE_INTERNAL;
QUEUE_INIT(&loop->process_handles); QUEUE_INIT(&loop->process_handles);
err = uv_rwlock_init(&loop->cloexec_lock); err = uv_rwlock_init(&loop->cloexec_lock);
@ -90,7 +90,7 @@ int uv_loop_init(uv_loop_t* loop) {
goto fail_async_init; goto fail_async_init;
uv__handle_unref(&loop->wq_async); uv__handle_unref(&loop->wq_async);
loop->wq_async.flags |= UV__HANDLE_INTERNAL; loop->wq_async.flags |= UV_HANDLE_INTERNAL;
return 0; return 0;

4
src/unix/pipe.c
View File

@ -149,7 +149,7 @@ int uv_pipe_open(uv_pipe_t* handle, uv_file fd) {
return uv__stream_open((uv_stream_t*)handle, return uv__stream_open((uv_stream_t*)handle,
fd, fd,
UV_STREAM_READABLE | UV_STREAM_WRITABLE); UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
} }
@ -199,7 +199,7 @@ void uv_pipe_connect(uv_connect_t* req,
if (new_sock) { if (new_sock) {
err = uv__stream_open((uv_stream_t*)handle, err = uv__stream_open((uv_stream_t*)handle,
uv__stream_fd(handle), uv__stream_fd(handle),
UV_STREAM_READABLE | UV_STREAM_WRITABLE); UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
} }
if (err == 0) if (err == 0)

4
src/unix/process.c
View File

@ -239,9 +239,9 @@ static int uv__process_open_stream(uv_stdio_container_t* container,
flags = 0; flags = 0;
if (container->flags & UV_WRITABLE_PIPE) if (container->flags & UV_WRITABLE_PIPE)
flags |= UV_STREAM_READABLE; flags |= UV_HANDLE_READABLE;
if (container->flags & UV_READABLE_PIPE) if (container->flags & UV_READABLE_PIPE)
flags |= UV_STREAM_WRITABLE; flags |= UV_HANDLE_WRITABLE;
return uv__stream_open(container->data.stream, pipefds[0], flags); return uv__stream_open(container->data.stream, pipefds[0], flags);
} }

20
src/unix/signal.c
View File

@ -396,7 +396,7 @@ static int uv__signal_start(uv_signal_t* handle,
*/ */
first_handle = uv__signal_first_handle(signum); first_handle = uv__signal_first_handle(signum);
if (first_handle == NULL || if (first_handle == NULL ||
(!oneshot && (first_handle->flags & UV__SIGNAL_ONE_SHOT))) { (!oneshot && (first_handle->flags & UV_SIGNAL_ONE_SHOT))) {
err = uv__signal_register_handler(signum, oneshot); err = uv__signal_register_handler(signum, oneshot);
if (err) { if (err) {
/* Registering the signal handler failed. Must be an invalid signal. */ /* Registering the signal handler failed. Must be an invalid signal. */
@ -407,7 +407,7 @@ static int uv__signal_start(uv_signal_t* handle,
handle->signum = signum; handle->signum = signum;
if (oneshot) if (oneshot)
handle->flags |= UV__SIGNAL_ONE_SHOT; handle->flags |= UV_SIGNAL_ONE_SHOT;
RB_INSERT(uv__signal_tree_s, &uv__signal_tree, handle); RB_INSERT(uv__signal_tree_s, &uv__signal_tree, handle);
@ -464,20 +464,20 @@ static void uv__signal_event(uv_loop_t* loop,
handle = msg->handle; handle = msg->handle;
if (msg->signum == handle->signum) { if (msg->signum == handle->signum) {
assert(!(handle->flags & UV_CLOSING)); assert(!(handle->flags & UV_HANDLE_CLOSING));
handle->signal_cb(handle, handle->signum); handle->signal_cb(handle, handle->signum);
} }
handle->dispatched_signals++; handle->dispatched_signals++;
if (handle->flags & UV__SIGNAL_ONE_SHOT) if (handle->flags & UV_SIGNAL_ONE_SHOT)
uv__signal_stop(handle); uv__signal_stop(handle);
/* If uv_close was called while there were caught signals that were not /* If uv_close was called while there were caught signals that were not
* yet dispatched, the uv__finish_close was deferred. Make close pending * yet dispatched, the uv__finish_close was deferred. Make close pending
* now if this has happened. * now if this has happened.
*/ */
if ((handle->flags & UV_CLOSING) && if ((handle->flags & UV_HANDLE_CLOSING) &&
(handle->caught_signals == handle->dispatched_signals)) { (handle->caught_signals == handle->dispatched_signals)) {
uv__make_close_pending((uv_handle_t*) handle); uv__make_close_pending((uv_handle_t*) handle);
} }
@ -505,11 +505,11 @@ static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
if (w1->signum < w2->signum) return -1; if (w1->signum < w2->signum) return -1;
if (w1->signum > w2->signum) return 1; if (w1->signum > w2->signum) return 1;
/* Handlers without UV__SIGNAL_ONE_SHOT set will come first, so if the first /* Handlers without UV_SIGNAL_ONE_SHOT set will come first, so if the first
* handler returned is a one-shot handler, the rest will be too. * handler returned is a one-shot handler, the rest will be too.
*/ */
f1 = w1->flags & UV__SIGNAL_ONE_SHOT; f1 = w1->flags & UV_SIGNAL_ONE_SHOT;
f2 = w2->flags & UV__SIGNAL_ONE_SHOT; f2 = w2->flags & UV_SIGNAL_ONE_SHOT;
if (f1 < f2) return -1; if (f1 < f2) return -1;
if (f1 > f2) return 1; if (f1 > f2) return 1;
@ -558,8 +558,8 @@ static void uv__signal_stop(uv_signal_t* handle) {
if (first_handle == NULL) { if (first_handle == NULL) {
uv__signal_unregister_handler(handle->signum); uv__signal_unregister_handler(handle->signum);
} else { } else {
rem_oneshot = handle->flags & UV__SIGNAL_ONE_SHOT; rem_oneshot = handle->flags & UV_SIGNAL_ONE_SHOT;
first_oneshot = first_handle->flags & UV__SIGNAL_ONE_SHOT; first_oneshot = first_handle->flags & UV_SIGNAL_ONE_SHOT;
if (first_oneshot && !rem_oneshot) { if (first_oneshot && !rem_oneshot) {
ret = uv__signal_register_handler(handle->signum, 1); ret = uv__signal_register_handler(handle->signum, 1);
assert(ret == 0); assert(ret == 0);

91
src/unix/stream.c
View File

@ -220,7 +220,7 @@ static void uv__stream_osx_select(void* arg) {
uv_sem_wait(&s->async_sem); uv_sem_wait(&s->async_sem);
/* Should be processed at this stage */ /* Should be processed at this stage */
assert((s->events == 0) || (stream->flags & UV_CLOSING)); assert((s->events == 0) || (stream->flags & UV_HANDLE_CLOSING));
} }
} }
} }
@ -248,7 +248,7 @@ static void uv__stream_osx_select_cb(uv_async_t* handle) {
if ((events & POLLOUT) && uv__io_active(&stream->io_watcher, POLLOUT)) if ((events & POLLOUT) && uv__io_active(&stream->io_watcher, POLLOUT))
uv__stream_io(stream->loop, &stream->io_watcher, POLLOUT); uv__stream_io(stream->loop, &stream->io_watcher, POLLOUT);
if (stream->flags & UV_CLOSING) if (stream->flags & UV_HANDLE_CLOSING)
return; return;
/* NOTE: It is important to do it here, otherwise `select()` might be called /* NOTE: It is important to do it here, otherwise `select()` might be called
@ -342,7 +342,7 @@ int uv__stream_try_select(uv_stream_t* stream, int* fd) {
if (err) if (err)
goto failed_async_init; goto failed_async_init;
s->async.flags |= UV__HANDLE_INTERNAL; s->async.flags |= UV_HANDLE_INTERNAL;
uv__handle_unref(&s->async); uv__handle_unref(&s->async);
err = uv_sem_init(&s->close_sem, 0); err = uv_sem_init(&s->close_sem, 0);
@ -407,12 +407,14 @@ int uv__stream_open(uv_stream_t* stream, int fd, int flags) {
stream->flags |= flags; stream->flags |= flags;
if (stream->type == UV_TCP) { if (stream->type == UV_TCP) {
if ((stream->flags & UV_TCP_NODELAY) && uv__tcp_nodelay(fd, 1)) if ((stream->flags & UV_HANDLE_TCP_NODELAY) && uv__tcp_nodelay(fd, 1))
return UV__ERR(errno); return UV__ERR(errno);
/* TODO Use delay the user passed in. */ /* TODO Use delay the user passed in. */
if ((stream->flags & UV_TCP_KEEPALIVE) && uv__tcp_keepalive(fd, 1, 60)) if ((stream->flags & UV_HANDLE_TCP_KEEPALIVE) &&
uv__tcp_keepalive(fd, 1, 60)) {
return UV__ERR(errno); return UV__ERR(errno);
}
} }
#if defined(__APPLE__) #if defined(__APPLE__)
@ -447,7 +449,7 @@ void uv__stream_flush_write_queue(uv_stream_t* stream, int error) {
void uv__stream_destroy(uv_stream_t* stream) { void uv__stream_destroy(uv_stream_t* stream) {
assert(!uv__io_active(&stream->io_watcher, POLLIN | POLLOUT)); assert(!uv__io_active(&stream->io_watcher, POLLIN | POLLOUT));
assert(stream->flags & UV_CLOSED); assert(stream->flags & UV_HANDLE_CLOSED);
if (stream->connect_req) { if (stream->connect_req) {
uv__req_unregister(stream->loop, stream->connect_req); uv__req_unregister(stream->loop, stream->connect_req);
@ -522,7 +524,7 @@ void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
stream = container_of(w, uv_stream_t, io_watcher); stream = container_of(w, uv_stream_t, io_watcher);
assert(events & POLLIN); assert(events & POLLIN);
assert(stream->accepted_fd == -1); assert(stream->accepted_fd == -1);
assert(!(stream->flags & UV_CLOSING)); assert(!(stream->flags & UV_HANDLE_CLOSING));
uv__io_start(stream->loop, &stream->io_watcher, POLLIN); uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
@ -565,7 +567,8 @@ void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
return; return;
} }
if (stream->type == UV_TCP && (stream->flags & UV_TCP_SINGLE_ACCEPT)) { if (stream->type == UV_TCP &&
(stream->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) {
/* Give other processes a chance to accept connections. */ /* Give other processes a chance to accept connections. */
struct timespec timeout = { 0, 1 }; struct timespec timeout = { 0, 1 };
nanosleep(&timeout, NULL); nanosleep(&timeout, NULL);
@ -590,7 +593,7 @@ int uv_accept(uv_stream_t* server, uv_stream_t* client) {
case UV_TCP: case UV_TCP:
err = uv__stream_open(client, err = uv__stream_open(client,
server->accepted_fd, server->accepted_fd,
UV_STREAM_READABLE | UV_STREAM_WRITABLE); UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
if (err) { if (err) {
/* TODO handle error */ /* TODO handle error */
uv__close(server->accepted_fd); uv__close(server->accepted_fd);
@ -674,14 +677,14 @@ static void uv__drain(uv_stream_t* stream) {
uv__stream_osx_interrupt_select(stream); uv__stream_osx_interrupt_select(stream);
/* Shutdown? */ /* Shutdown? */
if ((stream->flags & UV_STREAM_SHUTTING) && if ((stream->flags & UV_HANDLE_SHUTTING) &&
!(stream->flags & UV_CLOSING) && !(stream->flags & UV_HANDLE_CLOSING) &&
!(stream->flags & UV_STREAM_SHUT)) { !(stream->flags & UV_HANDLE_SHUT)) {
assert(stream->shutdown_req); assert(stream->shutdown_req);
req = stream->shutdown_req; req = stream->shutdown_req;
stream->shutdown_req = NULL; stream->shutdown_req = NULL;
stream->flags &= ~UV_STREAM_SHUTTING; stream->flags &= ~UV_HANDLE_SHUTTING;
uv__req_unregister(stream->loop, req); uv__req_unregister(stream->loop, req);
err = 0; err = 0;
@ -689,7 +692,7 @@ static void uv__drain(uv_stream_t* stream) {
err = UV__ERR(errno); err = UV__ERR(errno);
if (err == 0) if (err == 0)
stream->flags |= UV_STREAM_SHUT; stream->flags |= UV_HANDLE_SHUT;
if (req->cb != NULL) if (req->cb != NULL)
req->cb(req, err); req->cb(req, err);
@ -868,7 +871,7 @@ start:
if (!WRITE_RETRY_ON_ERROR(req->send_handle)) { if (!WRITE_RETRY_ON_ERROR(req->send_handle)) {
err = UV__ERR(errno); err = UV__ERR(errno);
goto error; goto error;
} else if (stream->flags & UV_STREAM_BLOCKING) { } else if (stream->flags & UV_HANDLE_BLOCKING_WRITES) {
/* If this is a blocking stream, try again. */ /* If this is a blocking stream, try again. */
goto start; goto start;
} }
@ -888,7 +891,7 @@ start:
n = 0; n = 0;
/* There is more to write. */ /* There is more to write. */
if (stream->flags & UV_STREAM_BLOCKING) { if (stream->flags & UV_HANDLE_BLOCKING_WRITES) {
/* /*
* If we're blocking then we should not be enabling the write * If we're blocking then we should not be enabling the write
* watcher - instead we need to try again. * watcher - instead we need to try again.
@ -924,7 +927,7 @@ start:
assert(n == 0 || n == -1); assert(n == 0 || n == -1);
/* Only non-blocking streams should use the write_watcher. */ /* Only non-blocking streams should use the write_watcher. */
assert(!(stream->flags & UV_STREAM_BLOCKING)); assert(!(stream->flags & UV_HANDLE_BLOCKING_WRITES));
/* We're not done. */ /* We're not done. */
uv__io_start(stream->loop, &stream->io_watcher, POLLOUT); uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
@ -1015,13 +1018,13 @@ uv_handle_type uv__handle_type(int fd) {
static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) { static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) {
stream->flags |= UV_STREAM_READ_EOF; stream->flags |= UV_HANDLE_READ_EOF;
uv__io_stop(stream->loop, &stream->io_watcher, POLLIN); uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
if (!uv__io_active(&stream->io_watcher, POLLOUT)) if (!uv__io_active(&stream->io_watcher, POLLOUT))
uv__handle_stop(stream); uv__handle_stop(stream);
uv__stream_osx_interrupt_select(stream); uv__stream_osx_interrupt_select(stream);
stream->read_cb(stream, UV_EOF, buf); stream->read_cb(stream, UV_EOF, buf);
stream->flags &= ~UV_STREAM_READING; stream->flags &= ~UV_HANDLE_READING;
} }
@ -1133,7 +1136,7 @@ static void uv__read(uv_stream_t* stream) {
int err; int err;
int is_ipc; int is_ipc;
stream->flags &= ~UV_STREAM_READ_PARTIAL; stream->flags &= ~UV_HANDLE_READ_PARTIAL;
/* Prevent loop starvation when the data comes in as fast as (or faster than) /* Prevent loop starvation when the data comes in as fast as (or faster than)
* we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O. * we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O.
@ -1142,11 +1145,11 @@ static void uv__read(uv_stream_t* stream) {
is_ipc = stream->type == UV_NAMED_PIPE && ((uv_pipe_t*) stream)->ipc; is_ipc = stream->type == UV_NAMED_PIPE && ((uv_pipe_t*) stream)->ipc;
/* XXX: Maybe instead of having UV_STREAM_READING we just test if /* XXX: Maybe instead of having UV_HANDLE_READING we just test if
* tcp->read_cb is NULL or not? * tcp->read_cb is NULL or not?
*/ */
while (stream->read_cb while (stream->read_cb
&& (stream->flags & UV_STREAM_READING) && (stream->flags & UV_HANDLE_READING)
&& (count-- > 0)) { && (count-- > 0)) {
assert(stream->alloc_cb != NULL); assert(stream->alloc_cb != NULL);
@ -1187,7 +1190,7 @@ static void uv__read(uv_stream_t* stream) {
/* Error */ /* Error */
if (errno == EAGAIN || errno == EWOULDBLOCK) { if (errno == EAGAIN || errno == EWOULDBLOCK) {
/* Wait for the next one. */ /* Wait for the next one. */
if (stream->flags & UV_STREAM_READING) { if (stream->flags & UV_HANDLE_READING) {
uv__io_start(stream->loop, &stream->io_watcher, POLLIN); uv__io_start(stream->loop, &stream->io_watcher, POLLIN);
uv__stream_osx_interrupt_select(stream); uv__stream_osx_interrupt_select(stream);
} }
@ -1200,8 +1203,8 @@ static void uv__read(uv_stream_t* stream) {
} else { } else {
/* Error. User should call uv_close(). */ /* Error. User should call uv_close(). */
stream->read_cb(stream, UV__ERR(errno), &buf); stream->read_cb(stream, UV__ERR(errno), &buf);
if (stream->flags & UV_STREAM_READING) { if (stream->flags & UV_HANDLE_READING) {
stream->flags &= ~UV_STREAM_READING; stream->flags &= ~UV_HANDLE_READING;
uv__io_stop(stream->loop, &stream->io_watcher, POLLIN); uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
if (!uv__io_active(&stream->io_watcher, POLLOUT)) if (!uv__io_active(&stream->io_watcher, POLLOUT))
uv__handle_stop(stream); uv__handle_stop(stream);
@ -1251,7 +1254,7 @@ static void uv__read(uv_stream_t* stream) {
/* Return if we didn't fill the buffer, there is no more data to read. */ /* Return if we didn't fill the buffer, there is no more data to read. */
if (nread < buflen) { if (nread < buflen) {
stream->flags |= UV_STREAM_READ_PARTIAL; stream->flags |= UV_HANDLE_READ_PARTIAL;
return; return;
} }
} }
@ -1272,9 +1275,9 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
stream->type == UV_TTY || stream->type == UV_TTY ||
stream->type == UV_NAMED_PIPE); stream->type == UV_NAMED_PIPE);
if (!(stream->flags & UV_STREAM_WRITABLE) || if (!(stream->flags & UV_HANDLE_WRITABLE) ||
stream->flags & UV_STREAM_SHUT || stream->flags & UV_HANDLE_SHUT ||
stream->flags & UV_STREAM_SHUTTING || stream->flags & UV_HANDLE_SHUTTING ||
uv__is_closing(stream)) { uv__is_closing(stream)) {
return UV_ENOTCONN; return UV_ENOTCONN;
} }
@ -1286,7 +1289,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) {
req->handle = stream; req->handle = stream;
req->cb = cb; req->cb = cb;
stream->shutdown_req = req; stream->shutdown_req = req;
stream->flags |= UV_STREAM_SHUTTING; stream->flags |= UV_HANDLE_SHUTTING;
uv__io_start(stream->loop, &stream->io_watcher, POLLOUT); uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
uv__stream_osx_interrupt_select(stream); uv__stream_osx_interrupt_select(stream);
@ -1303,7 +1306,7 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
assert(stream->type == UV_TCP || assert(stream->type == UV_TCP ||
stream->type == UV_NAMED_PIPE || stream->type == UV_NAMED_PIPE ||
stream->type == UV_TTY); stream->type == UV_TTY);
assert(!(stream->flags & UV_CLOSING)); assert(!(stream->flags & UV_HANDLE_CLOSING));
if (stream->connect_req) { if (stream->connect_req) {
uv__stream_connect(stream); uv__stream_connect(stream);
@ -1326,9 +1329,9 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
* report the EOF yet because there is still data to read. * report the EOF yet because there is still data to read.
*/ */
if ((events & POLLHUP) && if ((events & POLLHUP) &&
(stream->flags & UV_STREAM_READING) && (stream->flags & UV_HANDLE_READING) &&
(stream->flags & UV_STREAM_READ_PARTIAL) && (stream->flags & UV_HANDLE_READ_PARTIAL) &&
!(stream->flags & UV_STREAM_READ_EOF)) { !(stream->flags & UV_HANDLE_READ_EOF)) {
uv_buf_t buf = { NULL, 0 }; uv_buf_t buf = { NULL, 0 };
uv__stream_eof(stream, &buf); uv__stream_eof(stream, &buf);
} }
@ -1418,7 +1421,7 @@ int uv_write2(uv_write_t* req,
if (uv__stream_fd(stream) < 0) if (uv__stream_fd(stream) < 0)
return UV_EBADF; return UV_EBADF;
if (!(stream->flags & UV_STREAM_WRITABLE)) if (!(stream->flags & UV_HANDLE_WRITABLE))
return -EPIPE; return -EPIPE;
if (send_handle) { if (send_handle) {
@ -1488,7 +1491,7 @@ int uv_write2(uv_write_t* req,
* if this assert fires then somehow the blocking stream isn't being * if this assert fires then somehow the blocking stream isn't being
* sufficiently flushed in uv__write. * sufficiently flushed in uv__write.
*/ */
assert(!(stream->flags & UV_STREAM_BLOCKING)); assert(!(stream->flags & UV_HANDLE_BLOCKING_WRITES));
uv__io_start(stream->loop, &stream->io_watcher, POLLOUT); uv__io_start(stream->loop, &stream->io_watcher, POLLOUT);
uv__stream_osx_interrupt_select(stream); uv__stream_osx_interrupt_select(stream);
} }
@ -1569,16 +1572,16 @@ int uv_read_start(uv_stream_t* stream,
assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE || assert(stream->type == UV_TCP || stream->type == UV_NAMED_PIPE ||
stream->type == UV_TTY); stream->type == UV_TTY);
if (stream->flags & UV_CLOSING) if (stream->flags & UV_HANDLE_CLOSING)
return UV_EINVAL; return UV_EINVAL;
if (!(stream->flags & UV_STREAM_READABLE)) if (!(stream->flags & UV_HANDLE_READABLE))
return -ENOTCONN; return -ENOTCONN;
/* The UV_STREAM_READING flag is irrelevant of the state of the tcp - it just /* The UV_HANDLE_READING flag is irrelevant of the state of the tcp - it just
* expresses the desired state of the user. * expresses the desired state of the user.
*/ */
stream->flags |= UV_STREAM_READING; stream->flags |= UV_HANDLE_READING;
/* TODO: try to do the read inline? */ /* TODO: try to do the read inline? */
/* TODO: keep track of tcp state. If we've gotten a EOF then we should /* TODO: keep track of tcp state. If we've gotten a EOF then we should
@ -1599,10 +1602,10 @@ int uv_read_start(uv_stream_t* stream,
int uv_read_stop(uv_stream_t* stream) { int uv_read_stop(uv_stream_t* stream) {
if (!(stream->flags & UV_STREAM_READING)) if (!(stream->flags & UV_HANDLE_READING))
return 0; return 0;
stream->flags &= ~UV_STREAM_READING; stream->flags &= ~UV_HANDLE_READING;
uv__io_stop(stream->loop, &stream->io_watcher, POLLIN); uv__io_stop(stream->loop, &stream->io_watcher, POLLIN);
if (!uv__io_active(&stream->io_watcher, POLLOUT)) if (!uv__io_active(&stream->io_watcher, POLLOUT))
uv__handle_stop(stream); uv__handle_stop(stream);
@ -1615,12 +1618,12 @@ int uv_read_stop(uv_stream_t* stream) {
int uv_is_readable(const uv_stream_t* stream) { int uv_is_readable(const uv_stream_t* stream) {
return !!(stream->flags & UV_STREAM_READABLE); return !!(stream->flags & UV_HANDLE_READABLE);
} }
int uv_is_writable(const uv_stream_t* stream) { int uv_is_writable(const uv_stream_t* stream) {
return !!(stream->flags & UV_STREAM_WRITABLE); return !!(stream->flags & UV_HANDLE_WRITABLE);
} }

18
src/unix/tcp.c
View File

@ -216,7 +216,7 @@ int uv__tcp_connect(uv_connect_t* req,
err = maybe_new_socket(handle, err = maybe_new_socket(handle,
addr->sa_family, addr->sa_family,
UV_STREAM_READABLE | UV_STREAM_WRITABLE); UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
if (err) if (err)
return err; return err;
@ -272,7 +272,7 @@ int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) {
return uv__stream_open((uv_stream_t*)handle, return uv__stream_open((uv_stream_t*)handle,
sock, sock,
UV_STREAM_READABLE | UV_STREAM_WRITABLE); UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
} }
@ -334,7 +334,7 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
} }
if (single_accept) if (single_accept)
tcp->flags |= UV_TCP_SINGLE_ACCEPT; tcp->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
flags = 0; flags = 0;
#if defined(__MVS__) #if defined(__MVS__)
@ -401,9 +401,9 @@ int uv_tcp_nodelay(uv_tcp_t* handle, int on) {
} }
if (on) if (on)
handle->flags |= UV_TCP_NODELAY; handle->flags |= UV_HANDLE_TCP_NODELAY;
else else
handle->flags &= ~UV_TCP_NODELAY; handle->flags &= ~UV_HANDLE_TCP_NODELAY;
return 0; return 0;
} }
@ -419,9 +419,9 @@ int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
} }
if (on) if (on)
handle->flags |= UV_TCP_KEEPALIVE; handle->flags |= UV_HANDLE_TCP_KEEPALIVE;
else else
handle->flags &= ~UV_TCP_KEEPALIVE; handle->flags &= ~UV_HANDLE_TCP_KEEPALIVE;
/* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge /* TODO Store delay if uv__stream_fd(handle) == -1 but don't want to enlarge
* uv_tcp_t with an int that's almost never used... * uv_tcp_t with an int that's almost never used...
@ -433,9 +433,9 @@ int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) {
int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) { int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) {
if (enable) if (enable)
handle->flags &= ~UV_TCP_SINGLE_ACCEPT; handle->flags &= ~UV_HANDLE_TCP_SINGLE_ACCEPT;
else else
handle->flags |= UV_TCP_SINGLE_ACCEPT; handle->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT;
return 0; return 0;
} }

8
src/unix/tty.c
View File

@ -135,7 +135,7 @@ int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int readable) {
if (r < 0) { if (r < 0) {
/* fallback to using blocking writes */ /* fallback to using blocking writes */
if (!readable) if (!readable)
flags |= UV_STREAM_BLOCKING; flags |= UV_HANDLE_BLOCKING_WRITES;
goto skip; goto skip;
} }
@ -177,7 +177,7 @@ skip:
* the handle queue, since it was added by uv__handle_init in uv_stream_init. * the handle queue, since it was added by uv__handle_init in uv_stream_init.
*/ */
if (!(flags & UV_STREAM_BLOCKING)) if (!(flags & UV_HANDLE_BLOCKING_WRITES))
uv__nonblock(fd, 1); uv__nonblock(fd, 1);
#if defined(__APPLE__) #if defined(__APPLE__)
@ -195,9 +195,9 @@ skip:
#endif #endif
if (readable) if (readable)
flags |= UV_STREAM_READABLE; flags |= UV_HANDLE_READABLE;
else else
flags |= UV_STREAM_WRITABLE; flags |= UV_HANDLE_WRITABLE;
uv__stream_open((uv_stream_t*) tty, fd, flags); uv__stream_open((uv_stream_t*) tty, fd, flags);
tty->mode = UV_TTY_MODE_NORMAL; tty->mode = UV_TTY_MODE_NORMAL;

8
src/unix/udp.c
View File

@ -92,8 +92,8 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
uv_udp_send_t* req; uv_udp_send_t* req;
QUEUE* q; QUEUE* q;
assert(!(handle->flags & UV_UDP_PROCESSING)); assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING));
handle->flags |= UV_UDP_PROCESSING; handle->flags |= UV_HANDLE_UDP_PROCESSING;
while (!QUEUE_EMPTY(&handle->write_completed_queue)) { while (!QUEUE_EMPTY(&handle->write_completed_queue)) {
q = QUEUE_HEAD(&handle->write_completed_queue); q = QUEUE_HEAD(&handle->write_completed_queue);
@ -128,7 +128,7 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
uv__handle_stop(handle); uv__handle_stop(handle);
} }
handle->flags &= ~UV_UDP_PROCESSING; handle->flags &= ~UV_HANDLE_UDP_PROCESSING;
} }
@ -427,7 +427,7 @@ int uv__udp_send(uv_udp_send_t* req,
QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue); QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);
uv__handle_start(handle); uv__handle_start(handle);
if (empty_queue && !(handle->flags & UV_UDP_PROCESSING)) { if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) {
uv__udp_sendmsg(handle); uv__udp_sendmsg(handle);
/* `uv__udp_sendmsg` may not be able to do non-blocking write straight /* `uv__udp_sendmsg` may not be able to do non-blocking write straight

10
src/uv-common.c
View File

@ -357,7 +357,7 @@ void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
QUEUE_REMOVE(q); QUEUE_REMOVE(q);
QUEUE_INSERT_TAIL(&loop->handle_queue, q); QUEUE_INSERT_TAIL(&loop->handle_queue, q);
if (h->flags & UV__HANDLE_INTERNAL) continue; if (h->flags & UV_HANDLE_INTERNAL) continue;
walk_cb(h, arg); walk_cb(h, arg);
} }
} }
@ -386,9 +386,9 @@ static void uv__print_handles(uv_loop_t* loop, int only_active, FILE* stream) {
fprintf(stream, fprintf(stream,
"[%c%c%c] %-8s %p\n", "[%c%c%c] %-8s %p\n",
"R-"[!(h->flags & UV__HANDLE_REF)], "R-"[!(h->flags & UV_HANDLE_REF)],
"A-"[!(h->flags & UV__HANDLE_ACTIVE)], "A-"[!(h->flags & UV_HANDLE_ACTIVE)],
"I-"[!(h->flags & UV__HANDLE_INTERNAL)], "I-"[!(h->flags & UV_HANDLE_INTERNAL)],
type, type,
(void*)h); (void*)h);
} }
@ -632,7 +632,7 @@ int uv_loop_close(uv_loop_t* loop) {
QUEUE_FOREACH(q, &loop->handle_queue) { QUEUE_FOREACH(q, &loop->handle_queue) {
h = QUEUE_DATA(q, uv_handle_t, handle_queue); h = QUEUE_DATA(q, uv_handle_t, handle_queue);
if (!(h->flags & UV__HANDLE_INTERNAL)) if (!(h->flags & UV_HANDLE_INTERNAL))
return UV_EBUSY; return UV_EBUSY;
} }

111
src/uv-common.h
View File

@ -59,22 +59,67 @@ extern int snprintf(char*, size_t, const char*, ...);
#define STATIC_ASSERT(expr) \ #define STATIC_ASSERT(expr) \
void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)]) void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)])
#ifndef _WIN32 /* Handle flags. Some flags are specific to Windows or UNIX. */
enum { enum {
UV__SIGNAL_ONE_SHOT = 0x80000, /* On signal reception remove sighandler */ /* Used by all handles. */
UV__HANDLE_INTERNAL = 0x8000, UV_HANDLE_CLOSING = 0x00000001,
UV__HANDLE_ACTIVE = 0x4000, UV_HANDLE_CLOSED = 0x00000002,
UV__HANDLE_REF = 0x2000, UV_HANDLE_ACTIVE = 0x00000004,
UV__HANDLE_CLOSING = 0 /* no-op on unix */ UV_HANDLE_REF = 0x00000008,
UV_HANDLE_INTERNAL = 0x00000010,
UV_HANDLE_ENDGAME_QUEUED = 0x00000020,
/* Used by streams. */
UV_HANDLE_LISTENING = 0x00000040,
UV_HANDLE_CONNECTION = 0x00000080,
UV_HANDLE_SHUTTING = 0x00000100,
UV_HANDLE_SHUT = 0x00000200,
UV_HANDLE_READ_PARTIAL = 0x00000400,
UV_HANDLE_READ_EOF = 0x00000800,
/* Used by streams and UDP handles. */
UV_HANDLE_READING = 0x00001000,
UV_HANDLE_BOUND = 0x00002000,
UV_HANDLE_READABLE = 0x00004000,
UV_HANDLE_WRITABLE = 0x00008000,
UV_HANDLE_READ_PENDING = 0x00010000,
UV_HANDLE_SYNC_BYPASS_IOCP = 0x00020000,
UV_HANDLE_ZERO_READ = 0x00040000,
UV_HANDLE_EMULATE_IOCP = 0x00080000,
UV_HANDLE_BLOCKING_WRITES = 0x00100000,
UV_HANDLE_CANCELLATION_PENDING = 0x00200000,
/* Used by uv_tcp_t and uv_udp_t handles */
UV_HANDLE_IPV6 = 0x00400000,
/* Only used by uv_tcp_t handles. */
UV_HANDLE_TCP_NODELAY = 0x01000000,
UV_HANDLE_TCP_KEEPALIVE = 0x02000000,
UV_HANDLE_TCP_SINGLE_ACCEPT = 0x04000000,
UV_HANDLE_TCP_ACCEPT_STATE_CHANGING = 0x08000000,
UV_HANDLE_TCP_SOCKET_CLOSED = 0x10000000,
UV_HANDLE_SHARED_TCP_SOCKET = 0x20000000,
/* Only used by uv_udp_t handles. */
UV_HANDLE_UDP_PROCESSING = 0x01000000,
/* Only used by uv_pipe_t handles. */
UV_HANDLE_NON_OVERLAPPED_PIPE = 0x01000000,
UV_HANDLE_PIPESERVER = 0x02000000,
/* Only used by uv_tty_t handles. */
UV_HANDLE_TTY_READABLE = 0x01000000,
UV_HANDLE_TTY_RAW = 0x02000000,
UV_HANDLE_TTY_SAVED_POSITION = 0x04000000,
UV_HANDLE_TTY_SAVED_ATTRIBUTES = 0x08000000,
/* Only used by uv_signal_t handles. */
UV_SIGNAL_ONE_SHOT_DISPATCHED = 0x01000000,
UV_SIGNAL_ONE_SHOT = 0x02000000,
/* Only used by uv_poll_t handles. */
UV_HANDLE_POLL_SLOW = 0x01000000
}; };
#else
# define UV__SIGNAL_ONE_SHOT_DISPATCHED 0x200
# define UV__SIGNAL_ONE_SHOT 0x100
# define UV__HANDLE_INTERNAL 0x80
# define UV__HANDLE_ACTIVE 0x40
# define UV__HANDLE_REF 0x20
# define UV__HANDLE_CLOSING 0x01
#endif
int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap); int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap);
@ -168,49 +213,47 @@ void uv__timer_close(uv_timer_t* handle);
while (0) while (0)
#define uv__is_active(h) \ #define uv__is_active(h) \
(((h)->flags & UV__HANDLE_ACTIVE) != 0) (((h)->flags & UV_HANDLE_ACTIVE) != 0)
#define uv__is_closing(h) \ #define uv__is_closing(h) \
(((h)->flags & (UV_CLOSING | UV_CLOSED)) != 0) (((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0)
#define uv__handle_start(h) \ #define uv__handle_start(h) \
do { \ do { \
assert(((h)->flags & UV__HANDLE_CLOSING) == 0); \ if (((h)->flags & UV_HANDLE_ACTIVE) != 0) break; \
if (((h)->flags & UV__HANDLE_ACTIVE) != 0) break; \ (h)->flags |= UV_HANDLE_ACTIVE; \
(h)->flags |= UV__HANDLE_ACTIVE; \ if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_add(h); \
if (((h)->flags & UV__HANDLE_REF) != 0) uv__active_handle_add(h); \
} \ } \
while (0) while (0)
#define uv__handle_stop(h) \ #define uv__handle_stop(h) \
do { \ do { \
assert(((h)->flags & UV__HANDLE_CLOSING) == 0); \ if (((h)->flags & UV_HANDLE_ACTIVE) == 0) break; \
if (((h)->flags & UV__HANDLE_ACTIVE) == 0) break; \ (h)->flags &= ~UV_HANDLE_ACTIVE; \
(h)->flags &= ~UV__HANDLE_ACTIVE; \ if (((h)->flags & UV_HANDLE_REF) != 0) uv__active_handle_rm(h); \
if (((h)->flags & UV__HANDLE_REF) != 0) uv__active_handle_rm(h); \
} \ } \
while (0) while (0)
#define uv__handle_ref(h) \ #define uv__handle_ref(h) \
do { \ do { \
if (((h)->flags & UV__HANDLE_REF) != 0) break; \ if (((h)->flags & UV_HANDLE_REF) != 0) break; \
(h)->flags |= UV__HANDLE_REF; \ (h)->flags |= UV_HANDLE_REF; \
if (((h)->flags & UV__HANDLE_CLOSING) != 0) break; \ if (((h)->flags & UV_HANDLE_CLOSING) != 0) break; \
if (((h)->flags & UV__HANDLE_ACTIVE) != 0) uv__active_handle_add(h); \ if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_add(h); \
} \ } \
while (0) while (0)
#define uv__handle_unref(h) \ #define uv__handle_unref(h) \
do { \ do { \
if (((h)->flags & UV__HANDLE_REF) == 0) break; \ if (((h)->flags & UV_HANDLE_REF) == 0) break; \
(h)->flags &= ~UV__HANDLE_REF; \ (h)->flags &= ~UV_HANDLE_REF; \
if (((h)->flags & UV__HANDLE_CLOSING) != 0) break; \ if (((h)->flags & UV_HANDLE_CLOSING) != 0) break; \
if (((h)->flags & UV__HANDLE_ACTIVE) != 0) uv__active_handle_rm(h); \ if (((h)->flags & UV_HANDLE_ACTIVE) != 0) uv__active_handle_rm(h); \
} \ } \
while (0) while (0)
#define uv__has_ref(h) \ #define uv__has_ref(h) \
(((h)->flags & UV__HANDLE_REF) != 0) (((h)->flags & UV_HANDLE_REF) != 0)
#if defined(_WIN32) #if defined(_WIN32)
# define uv__handle_platform_init(h) ((h)->u.fd = -1) # define uv__handle_platform_init(h) ((h)->u.fd = -1)
@ -222,7 +265,7 @@ void uv__timer_close(uv_timer_t* handle);
do { \ do { \
(h)->loop = (loop_); \ (h)->loop = (loop_); \
(h)->type = (type_); \ (h)->type = (type_); \
(h)->flags = UV__HANDLE_REF; /* Ref the loop when active. */ \ (h)->flags = UV_HANDLE_REF; /* Ref the loop when active. */ \
QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue); \ QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue); \
uv__handle_platform_init(h); \ uv__handle_platform_init(h); \
} \ } \

6
src/win/async.c
View File

@ -29,7 +29,7 @@
void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle) { void uv_async_endgame(uv_loop_t* loop, uv_async_t* handle) {
if (handle->flags & UV__HANDLE_CLOSING && if (handle->flags & UV_HANDLE_CLOSING &&
!handle->async_sent) { !handle->async_sent) {
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
uv__handle_close(handle); uv__handle_close(handle);
@ -73,7 +73,7 @@ int uv_async_send(uv_async_t* handle) {
/* The user should make sure never to call uv_async_send to a closing or /* The user should make sure never to call uv_async_send to a closing or
* closed handle. */ * closed handle. */
assert(!(handle->flags & UV__HANDLE_CLOSING)); assert(!(handle->flags & UV_HANDLE_CLOSING));
if (!uv__atomic_exchange_set(&handle->async_sent)) { if (!uv__atomic_exchange_set(&handle->async_sent)) {
POST_COMPLETION_FOR_REQ(loop, &handle->async_req); POST_COMPLETION_FOR_REQ(loop, &handle->async_req);
@ -90,7 +90,7 @@ void uv_process_async_wakeup_req(uv_loop_t* loop, uv_async_t* handle,
handle->async_sent = 0; handle->async_sent = 0;
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
uv_want_endgame(loop, (uv_handle_t*)handle); uv_want_endgame(loop, (uv_handle_t*)handle);
} else if (handle->async_cb != NULL) { } else if (handle->async_cb != NULL) {
handle->async_cb(handle); handle->async_cb(handle);

2
src/win/core.c
View File

@ -279,7 +279,7 @@ int uv_loop_init(uv_loop_t* loop) {
goto fail_async_init; goto fail_async_init;
uv__handle_unref(&loop->wq_async); uv__handle_unref(&loop->wq_async);
loop->wq_async.flags |= UV__HANDLE_INTERNAL; loop->wq_async.flags |= UV_HANDLE_INTERNAL;
err = uv__loops_add(loop); err = uv__loops_add(loop);
if (err) if (err)

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

@ -419,7 +419,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
* - We are not active, just ignore the callback * - We are not active, just ignore the callback
*/ */
if (!uv__is_active(handle)) { if (!uv__is_active(handle)) {
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
uv_want_endgame(loop, (uv_handle_t*) handle); uv_want_endgame(loop, (uv_handle_t*) handle);
} }
return; return;
@ -543,7 +543,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
} }
offset = file_info->NextEntryOffset; offset = file_info->NextEntryOffset;
} while (offset && !(handle->flags & UV__HANDLE_CLOSING)); } while (offset && !(handle->flags & UV_HANDLE_CLOSING));
} else { } else {
handle->cb(handle, NULL, UV_CHANGE, 0); handle->cb(handle, NULL, UV_CHANGE, 0);
} }
@ -552,7 +552,7 @@ void uv_process_fs_event_req(uv_loop_t* loop, uv_req_t* req,
handle->cb(handle, NULL, 0, uv_translate_sys_error(err)); handle->cb(handle, NULL, 0, uv_translate_sys_error(err));
} }
if (!(handle->flags & UV__HANDLE_CLOSING)) { if (!(handle->flags & UV_HANDLE_CLOSING)) {
uv_fs_event_queue_readdirchanges(loop, handle); uv_fs_event_queue_readdirchanges(loop, handle);
} else { } else {
uv_want_endgame(loop, (uv_handle_t*)handle); uv_want_endgame(loop, (uv_handle_t*)handle);
@ -573,7 +573,7 @@ void uv_fs_event_close(uv_loop_t* loop, uv_fs_event_t* handle) {
void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) { void uv_fs_event_endgame(uv_loop_t* loop, uv_fs_event_t* handle) {
if ((handle->flags & UV__HANDLE_CLOSING) && !handle->req_pending) { if ((handle->flags & UV_HANDLE_CLOSING) && !handle->req_pending) {
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
if (handle->buffer) { if (handle->buffer) {

14
src/win/handle-inl.h
View File

@ -32,7 +32,7 @@
#define DECREASE_ACTIVE_COUNT(loop, handle) \ #define DECREASE_ACTIVE_COUNT(loop, handle) \
do { \ do { \
if (--(handle)->activecnt == 0 && \ if (--(handle)->activecnt == 0 && \
!((handle)->flags & UV__HANDLE_CLOSING)) { \ !((handle)->flags & UV_HANDLE_CLOSING)) { \
uv__handle_stop((handle)); \ uv__handle_stop((handle)); \
} \ } \
assert((handle)->activecnt >= 0); \ assert((handle)->activecnt >= 0); \
@ -53,7 +53,7 @@
assert(handle->reqs_pending > 0); \ assert(handle->reqs_pending > 0); \
handle->reqs_pending--; \ handle->reqs_pending--; \
\ \
if (handle->flags & UV__HANDLE_CLOSING && \ if (handle->flags & UV_HANDLE_CLOSING && \
handle->reqs_pending == 0) { \ handle->reqs_pending == 0) { \
uv_want_endgame(loop, (uv_handle_t*)handle); \ uv_want_endgame(loop, (uv_handle_t*)handle); \
} \ } \
@ -62,14 +62,14 @@
#define uv__handle_closing(handle) \ #define uv__handle_closing(handle) \
do { \ do { \
assert(!((handle)->flags & UV__HANDLE_CLOSING)); \ assert(!((handle)->flags & UV_HANDLE_CLOSING)); \
\ \
if (!(((handle)->flags & UV__HANDLE_ACTIVE) && \ if (!(((handle)->flags & UV_HANDLE_ACTIVE) && \
((handle)->flags & UV__HANDLE_REF))) \ ((handle)->flags & UV_HANDLE_REF))) \
uv__active_handle_add((uv_handle_t*) (handle)); \ uv__active_handle_add((uv_handle_t*) (handle)); \
\ \
(handle)->flags |= UV__HANDLE_CLOSING; \ (handle)->flags |= UV_HANDLE_CLOSING; \
(handle)->flags &= ~UV__HANDLE_ACTIVE; \ (handle)->flags &= ~UV_HANDLE_ACTIVE; \
} while (0) } while (0)

8
src/win/handle.c
View File

@ -59,15 +59,15 @@ uv_handle_type uv_guess_handle(uv_file file) {
int uv_is_active(const uv_handle_t* handle) { int uv_is_active(const uv_handle_t* handle) {
return (handle->flags & UV__HANDLE_ACTIVE) && return (handle->flags & UV_HANDLE_ACTIVE) &&
!(handle->flags & UV__HANDLE_CLOSING); !(handle->flags & UV_HANDLE_CLOSING);
} }
void uv_close(uv_handle_t* handle, uv_close_cb cb) { void uv_close(uv_handle_t* handle, uv_close_cb cb) {
uv_loop_t* loop = handle->loop; uv_loop_t* loop = handle->loop;
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
assert(0); assert(0);
return; return;
} }
@ -150,7 +150,7 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
int uv_is_closing(const uv_handle_t* handle) { int uv_is_closing(const uv_handle_t* handle) {
return !!(handle->flags & (UV__HANDLE_CLOSING | UV_HANDLE_CLOSED)); return !!(handle->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED));
} }

63
src/win/internal.h
View File

@ -57,69 +57,6 @@ extern UV_THREAD_LOCAL int uv__crt_assert_enabled;
#define UV_END_DISABLE_CRT_ASSERT() #define UV_END_DISABLE_CRT_ASSERT()
#endif #endif
/*
* Handles
* (also see handle-inl.h)
*/
/* Used by all handles. */
#define UV_HANDLE_CLOSED 0x00000002
#define UV_HANDLE_ENDGAME_QUEUED 0x00000008
/* uv-common.h: #define UV__HANDLE_CLOSING 0x00000001 */
/* uv-common.h: #define UV__HANDLE_ACTIVE 0x00000040 */
/* uv-common.h: #define UV__HANDLE_REF 0x00000020 */
/* uv-common.h: #define UV_HANDLE_INTERNAL 0x00000080 */
/* Used by streams and UDP handles. */
#define UV_HANDLE_READING 0x00000100
#define UV_HANDLE_BOUND 0x00000200
#define UV_HANDLE_LISTENING 0x00000800
#define UV_HANDLE_CONNECTION 0x00001000
#define UV_HANDLE_READABLE 0x00008000
#define UV_HANDLE_WRITABLE 0x00010000
#define UV_HANDLE_READ_PENDING 0x00020000
#define UV_HANDLE_SYNC_BYPASS_IOCP 0x00040000
#define UV_HANDLE_ZERO_READ 0x00080000
#define UV_HANDLE_EMULATE_IOCP 0x00100000
#define UV_HANDLE_BLOCKING_WRITES 0x00200000
#define UV_HANDLE_CANCELLATION_PENDING 0x00400000
/* Used by uv_tcp_t and uv_udp_t handles */
#define UV_HANDLE_IPV6 0x01000000
/* Only used by uv_tcp_t handles. */
#define UV_HANDLE_TCP_NODELAY 0x02000000
#define UV_HANDLE_TCP_KEEPALIVE 0x04000000
#define UV_HANDLE_TCP_SINGLE_ACCEPT 0x08000000
#define UV_HANDLE_TCP_ACCEPT_STATE_CHANGING 0x10000000
#define UV_HANDLE_TCP_SOCKET_CLOSED 0x20000000
#define UV_HANDLE_SHARED_TCP_SOCKET 0x40000000
/* Only used by uv_pipe_t handles. */
#define UV_HANDLE_NON_OVERLAPPED_PIPE 0x01000000
#define UV_HANDLE_PIPESERVER 0x02000000
/* Only used by uv_tty_t handles. */
#define UV_HANDLE_TTY_READABLE 0x01000000
#define UV_HANDLE_TTY_RAW 0x02000000
#define UV_HANDLE_TTY_SAVED_POSITION 0x04000000
#define UV_HANDLE_TTY_SAVED_ATTRIBUTES 0x08000000
/* Only used by uv_poll_t handles. */
#define UV_HANDLE_POLL_SLOW 0x02000000
/*
* Requests: see req-inl.h
*/
/*
* Streams: see stream-inl.h
*/
/* /*
* TCP * TCP
*/ */

2
src/win/loop-watcher.c
View File

@ -27,7 +27,7 @@
void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle) { void uv_loop_watcher_endgame(uv_loop_t* loop, uv_handle_t* handle) {
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
handle->flags |= UV_HANDLE_CLOSED; handle->flags |= UV_HANDLE_CLOSED;
uv__handle_close(handle); uv__handle_close(handle);

10
src/win/pipe.c
View File

@ -346,7 +346,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
/* Clear the shutdown_req field so we don't go here again. */ /* Clear the shutdown_req field so we don't go here again. */
handle->stream.conn.shutdown_req = NULL; handle->stream.conn.shutdown_req = NULL;
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
UNREGISTER_HANDLE_REQ(loop, handle, req); UNREGISTER_HANDLE_REQ(loop, handle, req);
/* Already closing. Cancel the shutdown. */ /* Already closing. Cancel the shutdown. */
@ -407,7 +407,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
} }
} }
if (handle->flags & UV__HANDLE_CLOSING && if (handle->flags & UV_HANDLE_CLOSING &&
handle->reqs_pending == 0) { handle->reqs_pending == 0) {
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
@ -906,7 +906,7 @@ int uv_pipe_accept(uv_pipe_t* server, uv_stream_t* client) {
req->next_pending = NULL; req->next_pending = NULL;
req->pipeHandle = INVALID_HANDLE_VALUE; req->pipeHandle = INVALID_HANDLE_VALUE;
if (!(server->flags & UV__HANDLE_CLOSING)) { if (!(server->flags & UV_HANDLE_CLOSING)) {
uv_pipe_queue_accept(loop, server, req, FALSE); uv_pipe_queue_accept(loop, server, req, FALSE);
} }
} }
@ -1855,7 +1855,7 @@ void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
assert(handle->type == UV_NAMED_PIPE); assert(handle->type == UV_NAMED_PIPE);
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
/* The req->pipeHandle should be freed already in uv_pipe_cleanup(). */ /* The req->pipeHandle should be freed already in uv_pipe_cleanup(). */
assert(req->pipeHandle == INVALID_HANDLE_VALUE); assert(req->pipeHandle == INVALID_HANDLE_VALUE);
DECREASE_PENDING_REQ_COUNT(handle); DECREASE_PENDING_REQ_COUNT(handle);
@ -1875,7 +1875,7 @@ void uv_process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle,
CloseHandle(req->pipeHandle); CloseHandle(req->pipeHandle);
req->pipeHandle = INVALID_HANDLE_VALUE; req->pipeHandle = INVALID_HANDLE_VALUE;
} }
if (!(handle->flags & UV__HANDLE_CLOSING)) { if (!(handle->flags & UV_HANDLE_CLOSING)) {
uv_pipe_queue_accept(loop, handle, req, FALSE); uv_pipe_queue_accept(loop, handle, req, FALSE);
} }
} }

10
src/win/poll.c
View File

@ -218,7 +218,7 @@ static void uv__fast_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
if ((handle->events & ~(handle->submitted_events_1 | if ((handle->events & ~(handle->submitted_events_1 |
handle->submitted_events_2)) != 0) { handle->submitted_events_2)) != 0) {
uv__fast_poll_submit_poll_req(loop, handle); uv__fast_poll_submit_poll_req(loop, handle);
} else if ((handle->flags & UV__HANDLE_CLOSING) && } else if ((handle->flags & UV_HANDLE_CLOSING) &&
handle->submitted_events_1 == 0 && handle->submitted_events_1 == 0 &&
handle->submitted_events_2 == 0) { handle->submitted_events_2 == 0) {
uv_want_endgame(loop, (uv_handle_t*) handle); uv_want_endgame(loop, (uv_handle_t*) handle);
@ -228,7 +228,7 @@ static void uv__fast_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
static int uv__fast_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) { static int uv__fast_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) {
assert(handle->type == UV_POLL); assert(handle->type == UV_POLL);
assert(!(handle->flags & UV__HANDLE_CLOSING)); assert(!(handle->flags & UV_HANDLE_CLOSING));
assert((events & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT)) == 0); assert((events & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT)) == 0);
handle->events = events; handle->events = events;
@ -461,7 +461,7 @@ static void uv__slow_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
if ((handle->events & ~(handle->submitted_events_1 | if ((handle->events & ~(handle->submitted_events_1 |
handle->submitted_events_2)) != 0) { handle->submitted_events_2)) != 0) {
uv__slow_poll_submit_poll_req(loop, handle); uv__slow_poll_submit_poll_req(loop, handle);
} else if ((handle->flags & UV__HANDLE_CLOSING) && } else if ((handle->flags & UV_HANDLE_CLOSING) &&
handle->submitted_events_1 == 0 && handle->submitted_events_1 == 0 &&
handle->submitted_events_2 == 0) { handle->submitted_events_2 == 0) {
uv_want_endgame(loop, (uv_handle_t*) handle); uv_want_endgame(loop, (uv_handle_t*) handle);
@ -471,7 +471,7 @@ static void uv__slow_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
static int uv__slow_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) { static int uv__slow_poll_set(uv_loop_t* loop, uv_poll_t* handle, int events) {
assert(handle->type == UV_POLL); assert(handle->type == UV_POLL);
assert(!(handle->flags & UV__HANDLE_CLOSING)); assert(!(handle->flags & UV_HANDLE_CLOSING));
assert((events & ~(UV_READABLE | UV_WRITABLE)) == 0); assert((events & ~(UV_READABLE | UV_WRITABLE)) == 0);
handle->events = events; handle->events = events;
@ -633,7 +633,7 @@ int uv_poll_close(uv_loop_t* loop, uv_poll_t* handle) {
void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle) { void uv_poll_endgame(uv_loop_t* loop, uv_poll_t* handle) {
assert(handle->flags & UV__HANDLE_CLOSING); assert(handle->flags & UV_HANDLE_CLOSING);
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
assert(handle->submitted_events_1 == 0); assert(handle->submitted_events_1 == 0);

4
src/win/process.c
View File

@ -872,7 +872,7 @@ void uv_process_proc_exit(uv_loop_t* loop, uv_process_t* handle) {
/* If we're closing, don't call the exit callback. Just schedule a close /* If we're closing, don't call the exit callback. Just schedule a close
* callback now. */ * callback now. */
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
uv_want_endgame(loop, (uv_handle_t*) handle); uv_want_endgame(loop, (uv_handle_t*) handle);
return; return;
} }
@ -924,7 +924,7 @@ void uv_process_close(uv_loop_t* loop, uv_process_t* handle) {
void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) { void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) {
assert(!handle->exit_cb_pending); assert(!handle->exit_cb_pending);
assert(handle->flags & UV__HANDLE_CLOSING); assert(handle->flags & UV_HANDLE_CLOSING);
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
/* Clean-up the process handle. */ /* Clean-up the process handle. */

14
src/win/signal.c
View File

@ -90,7 +90,7 @@ int uv__signal_dispatch(int signum) {
unsigned long previous = InterlockedExchange( unsigned long previous = InterlockedExchange(
(volatile LONG*) &handle->pending_signum, signum); (volatile LONG*) &handle->pending_signum, signum);
if (handle->flags & UV__SIGNAL_ONE_SHOT_DISPATCHED) if (handle->flags & UV_SIGNAL_ONE_SHOT_DISPATCHED)
continue; continue;
if (!previous) { if (!previous) {
@ -98,8 +98,8 @@ int uv__signal_dispatch(int signum) {
} }
dispatched = 1; dispatched = 1;
if (handle->flags & UV__SIGNAL_ONE_SHOT) if (handle->flags & UV_SIGNAL_ONE_SHOT)
handle->flags |= UV__SIGNAL_ONE_SHOT_DISPATCHED; handle->flags |= UV_SIGNAL_ONE_SHOT_DISPATCHED;
} }
LeaveCriticalSection(&uv__signal_lock); LeaveCriticalSection(&uv__signal_lock);
@ -213,7 +213,7 @@ int uv__signal_start(uv_signal_t* handle,
handle->signum = signum; handle->signum = signum;
if (oneshot) if (oneshot)
handle->flags |= UV__SIGNAL_ONE_SHOT; handle->flags |= UV_SIGNAL_ONE_SHOT;
RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle); RB_INSERT(uv_signal_tree_s, &uv__signal_tree, handle);
@ -243,10 +243,10 @@ void uv_process_signal_req(uv_loop_t* loop, uv_signal_t* handle,
if (dispatched_signum == handle->signum) if (dispatched_signum == handle->signum)
handle->signal_cb(handle, dispatched_signum); handle->signal_cb(handle, dispatched_signum);
if (handle->flags & UV__SIGNAL_ONE_SHOT) if (handle->flags & UV_SIGNAL_ONE_SHOT)
uv_signal_stop(handle); uv_signal_stop(handle);
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
/* When it is closing, it must be stopped at this point. */ /* When it is closing, it must be stopped at this point. */
assert(handle->signum == 0); assert(handle->signum == 0);
uv_want_endgame(loop, (uv_handle_t*) handle); uv_want_endgame(loop, (uv_handle_t*) handle);
@ -265,7 +265,7 @@ void uv_signal_close(uv_loop_t* loop, uv_signal_t* handle) {
void uv_signal_endgame(uv_loop_t* loop, uv_signal_t* handle) { void uv_signal_endgame(uv_loop_t* loop, uv_signal_t* handle) {
assert(handle->flags & UV__HANDLE_CLOSING); assert(handle->flags & UV_HANDLE_CLOSING);
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
assert(handle->signum == 0); assert(handle->signum == 0);

2
src/win/stream.c
View File

@ -176,7 +176,7 @@ int uv_write2(uv_write_t* req,
int uv_try_write(uv_stream_t* stream, int uv_try_write(uv_stream_t* stream,
const uv_buf_t bufs[], const uv_buf_t bufs[],
unsigned int nbufs) { unsigned int nbufs) {
if (stream->flags & UV__HANDLE_CLOSING) if (stream->flags & UV_HANDLE_CLOSING)
return UV_EBADF; return UV_EBADF;
if (!(stream->flags & UV_HANDLE_WRITABLE)) if (!(stream->flags & UV_HANDLE_WRITABLE))
return UV_EPIPE; return UV_EPIPE;

8
src/win/tcp.c
View File

@ -217,7 +217,7 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req); UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
err = 0; err = 0;
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
err = ERROR_OPERATION_ABORTED; err = ERROR_OPERATION_ABORTED;
} else if (shutdown(handle->socket, SD_SEND) == SOCKET_ERROR) { } else if (shutdown(handle->socket, SD_SEND) == SOCKET_ERROR) {
err = WSAGetLastError(); err = WSAGetLastError();
@ -233,7 +233,7 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
return; return;
} }
if (handle->flags & UV__HANDLE_CLOSING && if (handle->flags & UV_HANDLE_CLOSING &&
handle->reqs_pending == 0) { handle->reqs_pending == 0) {
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
@ -680,7 +680,7 @@ int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client) {
req->next_pending = NULL; req->next_pending = NULL;
req->accept_socket = INVALID_SOCKET; req->accept_socket = INVALID_SOCKET;
if (!(server->flags & UV__HANDLE_CLOSING)) { if (!(server->flags & UV_HANDLE_CLOSING)) {
/* Check if we're in a middle of changing the number of pending accepts. */ /* Check if we're in a middle of changing the number of pending accepts. */
if (!(server->flags & UV_HANDLE_TCP_ACCEPT_STATE_CHANGING)) { if (!(server->flags & UV_HANDLE_TCP_ACCEPT_STATE_CHANGING)) {
uv_tcp_queue_accept(server, req); uv_tcp_queue_accept(server, req);
@ -1166,7 +1166,7 @@ void uv_process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle,
err = 0; err = 0;
if (REQ_SUCCESS(req)) { if (REQ_SUCCESS(req)) {
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
/* use UV_ECANCELED for consistency with Unix */ /* use UV_ECANCELED for consistency with Unix */
err = ERROR_OPERATION_ABORTED; err = ERROR_OPERATION_ABORTED;
} else if (setsockopt(handle->socket, } else if (setsockopt(handle->socket,

4
src/win/tty.c
View File

@ -2208,7 +2208,7 @@ void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
/* TTY shutdown is really just a no-op */ /* TTY shutdown is really just a no-op */
if (handle->stream.conn.shutdown_req->cb) { if (handle->stream.conn.shutdown_req->cb) {
if (handle->flags & UV__HANDLE_CLOSING) { if (handle->flags & UV_HANDLE_CLOSING) {
handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, UV_ECANCELED); handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, UV_ECANCELED);
} else { } else {
handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, 0); handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, 0);
@ -2221,7 +2221,7 @@ void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
return; return;
} }
if (handle->flags & UV__HANDLE_CLOSING && if (handle->flags & UV_HANDLE_CLOSING &&
handle->reqs_pending == 0) { handle->reqs_pending == 0) {
/* The wait handle used for raw reading should be unregistered when the /* The wait handle used for raw reading should be unregistered when the
* wait callback runs. */ * wait callback runs. */

2
src/win/udp.c
View File

@ -188,7 +188,7 @@ void uv_udp_close(uv_loop_t* loop, uv_udp_t* handle) {
void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle) { void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle) {
if (handle->flags & UV__HANDLE_CLOSING && if (handle->flags & UV_HANDLE_CLOSING &&
handle->reqs_pending == 0) { handle->reqs_pending == 0) {
assert(!(handle->flags & UV_HANDLE_CLOSED)); assert(!(handle->flags & UV_HANDLE_CLOSED));
uv__handle_close(handle); uv__handle_close(handle);

6
test/test-tty.c
View File

@ -371,12 +371,12 @@ TEST_IMPL(tty_pty) {
ASSERT(0 == uv_tty_init(&loop, &slave_tty, slave_fd, 0)); ASSERT(0 == uv_tty_init(&loop, &slave_tty, slave_fd, 0));
ASSERT(0 == uv_tty_init(&loop, &master_tty, master_fd, 0)); ASSERT(0 == uv_tty_init(&loop, &master_tty, master_fd, 0));
/* Check if the file descriptor was reopened. If it is, /* Check if the file descriptor was reopened. If it is,
* UV_STREAM_BLOCKING (value 0x80) isn't set on flags. * UV_HANDLE_BLOCKING_WRITES (value 0x100000) isn't set on flags.
*/ */
ASSERT(0 == (slave_tty.flags & 0x80)); ASSERT(0 == (slave_tty.flags & 0x100000));
/* The master_fd of a pty should never be reopened. /* The master_fd of a pty should never be reopened.
*/ */
ASSERT(master_tty.flags & 0x80); ASSERT(master_tty.flags & 0x100000);
ASSERT(0 == close(slave_fd)); ASSERT(0 == close(slave_fd));
uv_close((uv_handle_t*) &slave_tty, NULL); uv_close((uv_handle_t*) &slave_tty, NULL);
ASSERT(0 == close(master_fd)); ASSERT(0 == close(master_fd));