Browse Source

Upgrade libuv to 2c0fca9a41

v0.7.4-release
Bert Belder 13 years ago
committed by Ryan Dahl
parent
commit
c06af229dc
  1. 5
      deps/uv/common.gypi
  2. 28
      deps/uv/include/uv-private/uv-win.h
  3. 1
      deps/uv/src/unix/cares.c
  4. 19
      deps/uv/src/unix/fs.c
  5. 1
      deps/uv/src/unix/udp.c
  6. 3
      deps/uv/src/win/core.c
  7. 33
      deps/uv/src/win/handle.c
  8. 28
      deps/uv/src/win/internal.h
  9. 3
      deps/uv/src/win/pipe.c
  10. 6
      deps/uv/src/win/req.c
  11. 13
      deps/uv/src/win/stream.c
  12. 4
      deps/uv/src/win/tcp.c
  13. 1558
      deps/uv/src/win/tty.c
  14. 12
      deps/uv/test/test-list.h
  15. 47
      deps/uv/test/test-tcp-close.c
  16. 64
      deps/uv/test/test-tcp-write-error.c
  17. 40
      deps/uv/test/test-timer.c

5
deps/uv/common.gypi

@ -32,6 +32,11 @@
'LinkIncremental': 2, # enable incremental linking
},
},
'conditions': [
['OS != "win"', {
'defines': [ 'EV_VERIFY=2' ],
}],
]
},
'Release': {
'defines': [ 'NDEBUG' ],

28
deps/uv/include/uv-private/uv-win.h

@ -117,6 +117,7 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
HANDLE pipeHandle; \
struct uv_pipe_accept_s* next_pending; \
} uv_pipe_accept_t; \
\
typedef struct uv_tcp_accept_s { \
UV_REQ_FIELDS \
SOCKET accept_socket; \
@ -181,6 +182,31 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
struct { uv_pipe_connection_fields }; \
};
/* TODO: put the parser states in an union - TTY handles are always */
/* half-duplex so read-state can safely overlap write-state. */
#define UV_TTY_PRIVATE_FIELDS \
HANDLE handle; \
HANDLE read_line_handle; \
uv_buf_t read_line_buffer; \
HANDLE read_raw_wait; \
DWORD original_console_mode; \
/* Fields used for translating win */ \
/* keystrokes into vt100 characters */ \
char last_key[8]; \
unsigned char last_key_offset; \
unsigned char last_key_len; \
INPUT_RECORD last_input_record; \
WCHAR last_utf16_high_surrogate; \
/* utf8-to-utf16 conversion state */ \
unsigned char utf8_bytes_left; \
unsigned int utf8_codepoint; \
/* eol conversion state */ \
unsigned char previous_eol; \
/* ansi parser state */ \
unsigned char ansi_parser_state; \
unsigned char ansi_csi_argc; \
unsigned short ansi_csi_argv[4];
#define UV_TIMER_PRIVATE_FIELDS \
RB_ENTRY(uv_timer_s) tree_entry; \
int64_t due; \
@ -273,8 +299,6 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
int is_path_dir; \
char* buffer;
#define UV_TTY_PRIVATE_FIELDS /* empty */
int uv_utf16_to_utf8(const wchar_t* utf16Buffer, size_t utf16Size,
char* utf8Buffer, size_t utf8Size);
int uv_utf8_to_utf16(const char* utf8Buffer, wchar_t* utf16Buffer,

1
deps/uv/src/unix/cares.c

@ -67,6 +67,7 @@ static uv_ares_task_t* uv__ares_task_create(int fd) {
if (h == NULL) {
uv_fatal_error(ENOMEM, "malloc");
return NULL;
}
h->sock = fd;

19
deps/uv/src/unix/fs.c

@ -149,19 +149,20 @@ static int uv__fs_after(eio_req* eio) {
case UV_FS_READLINK:
if (req->result == -1) {
req->ptr = NULL;
} else {
assert(req->result > 0);
if ((name = realloc(req->eio->ptr2, req->result + 1)) == NULL) {
/* Not enough memory. Reuse buffer, chop off last byte. */
name = req->eio->ptr2;
req->result--;
}
break;
}
assert(req->result > 0);
/* Make zero-terminated copy of req->eio->ptr2 */
if ((req->ptr = name = malloc(req->result + 1))) {
memcpy(name, req->eio->ptr2, req->result);
name[req->result] = '\0';
req->ptr = name;
req->result = 0;
}
else {
req->errorno = ENOMEM;
req->result = -1;
}
break;
default:

1
deps/uv/src/unix/udp.c

@ -301,6 +301,7 @@ static int uv__udp_bind(uv_udp_t* handle,
saved_errno = errno;
status = -1;
fd = -1;
/* Check for bad flags. */
if (flags & ~UV_UDP_IPV6ONLY) {

3
deps/uv/src/win/core.c

@ -48,6 +48,9 @@ static void uv_init(void) {
/* Initialize FS */
uv_fs_init();
/* Initialize console */
uv_console_init();
}

33
deps/uv/src/win/handle.c

@ -20,11 +20,36 @@
*/
#include <assert.h>
#include <io.h>
#include "uv.h"
#include "internal.h"
uv_handle_type uv_guess_handle(uv_file file) {
HANDLE handle = (HANDLE) _get_osfhandle(file);
DWORD mode;
switch (GetFileType(handle)) {
case FILE_TYPE_CHAR:
if (GetConsoleMode(handle, &mode)) {
return UV_TTY;
} else {
return UV_UNKNOWN_HANDLE;
}
case FILE_TYPE_PIPE:
return UV_NAMED_PIPE;
case FILE_TYPE_DISK:
return UV_FILE;
default:
return UV_UNKNOWN_HANDLE;
}
}
int uv_is_active(uv_handle_t* handle) {
switch (handle->type) {
case UV_TIMER:
@ -80,6 +105,10 @@ void uv_close(uv_handle_t* handle, uv_close_cb cb) {
}
return;
case UV_TTY:
uv_tty_close((uv_tty_t*) handle);
return;
case UV_UDP:
udp = (uv_udp_t*) handle;
uv_udp_recv_stop(udp);
@ -159,6 +188,10 @@ void uv_process_endgames(uv_loop_t* loop) {
uv_pipe_endgame(loop, (uv_pipe_t*) handle);
break;
case UV_TTY:
uv_tty_endgame(loop, (uv_tty_t*) handle);
break;
case UV_UDP:
uv_udp_endgame(loop, (uv_udp_t*) handle);
break;

28
deps/uv/src/win/internal.h

@ -64,6 +64,7 @@ void uv_process_timers(uv_loop_t* loop);
#define UV_HANDLE_UV_ALLOCED 0x20000
#define UV_HANDLE_SYNC_BYPASS_IOCP 0x40000
#define UV_HANDLE_ZERO_READ 0x80000
#define UV_HANDLE_TTY_RAW 0x100000
void uv_want_endgame(uv_loop_t* loop, uv_handle_t* handle);
void uv_process_endgames(uv_loop_t* loop);
@ -173,6 +174,33 @@ void uv_process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle,
void uv_process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle,
uv_shutdown_t* req);
/*
* TTY
*/
void uv_console_init();
int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
uv_read_cb read_cb);
int uv_tty_read_stop(uv_tty_t* handle);
int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
uv_buf_t bufs[], int bufcnt, uv_write_cb cb);
void uv_tty_close(uv_tty_t* handle);
void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
uv_req_t* req);
void uv_process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
uv_write_t* req);
/* TODO: remove me */
void uv_process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
uv_req_t* raw_req);
/* TODO: remove me */
void uv_process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
uv_connect_t* req);
void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle);
/*
* Loop watchers
*/

3
deps/uv/src/win/pipe.c

@ -231,6 +231,7 @@ void uv_pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) {
if (result) {
/* Mark the handle as shut now to avoid going through this again. */
handle->flags |= UV_HANDLE_SHUT;
return;
} else {
/* Failure. */
@ -678,6 +679,8 @@ static void uv_pipe_queue_read(uv_loop_t* loop, uv_pipe_t* handle) {
/* Make this req pending reporting an error. */
SET_REQ_ERROR(req, WSAGetLastError());
uv_insert_pending_req(loop, req);
handle->flags |= UV_HANDLE_READ_PENDING;
handle->reqs_pending++;
return;
}

6
deps/uv/src/win/req.c

@ -87,6 +87,12 @@ static uv_req_t* uv_remove_pending_req(uv_loop_t* loop) {
req); \
break; \
\
case UV_TTY: \
uv_process_tty_##method##_req(loop, \
(uv_tty_t*) ((req)->handle_at), \
req); \
break; \
\
default: \
assert(0); \
} \

13
deps/uv/src/win/stream.c

@ -83,6 +83,8 @@ int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
return uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
case UV_NAMED_PIPE:
return uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
case UV_TTY:
return uv_tty_read_start((uv_tty_t*) handle, alloc_cb, read_cb);
default:
assert(0);
return -1;
@ -91,9 +93,12 @@ int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb,
int uv_read_stop(uv_stream_t* handle) {
handle->flags &= ~UV_HANDLE_READING;
return 0;
if (handle->type = UV_TTY) {
return uv_tty_read_stop((uv_tty_t*) handle);
} else {
handle->flags &= ~UV_HANDLE_READING;
return 0;
}
}
@ -106,6 +111,8 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
return uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
case UV_NAMED_PIPE:
return uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
case UV_TTY:
return uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, bufcnt, cb);
default:
assert(0);
uv_set_sys_error(loop, WSAEINVAL);

4
deps/uv/src/win/tcp.c

@ -128,7 +128,9 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) {
}
handle->shutdown_req->cb(handle->shutdown_req, status);
}
handle->reqs_pending--;
DECREASE_PENDING_REQ_COUNT(handle);
return;
}
if (handle->flags & UV_HANDLE_CLOSING &&

1558
deps/uv/src/win/tty.c

File diff suppressed because it is too large

12
deps/uv/test/test-list.h

@ -22,6 +22,8 @@
TEST_DECLARE (tty)
TEST_DECLARE (tcp_ping_pong)
TEST_DECLARE (tcp_ping_pong_v6)
TEST_DECLARE (tcp_ref)
TEST_DECLARE (tcp_ref2)
TEST_DECLARE (pipe_ping_pong)
TEST_DECLARE (delayed_accept)
TEST_DECLARE (tcp_writealot)
@ -52,6 +54,8 @@ TEST_DECLARE (connection_fail_doesnt_auto_close)
TEST_DECLARE (shutdown_eof)
TEST_DECLARE (callback_stack)
TEST_DECLARE (timer)
TEST_DECLARE (timer_ref)
TEST_DECLARE (timer_ref2)
TEST_DECLARE (timer_again)
TEST_DECLARE (idle_starvation)
TEST_DECLARE (loop_handles)
@ -104,6 +108,12 @@ HELPER_DECLARE (pipe_echo_server)
TASK_LIST_START
TEST_ENTRY (tty)
TEST_ENTRY (tcp_ref)
TEST_ENTRY (tcp_ref2)
TEST_HELPER (tcp_ref2, tcp4_echo_server)
TEST_ENTRY (tcp_ping_pong)
TEST_HELPER (tcp_ping_pong, tcp4_echo_server)
@ -154,6 +164,8 @@ TASK_LIST_START
TEST_HELPER (callback_stack, tcp4_echo_server)
TEST_ENTRY (timer)
TEST_ENTRY (timer_ref)
TEST_ENTRY (timer_ref2)
TEST_ENTRY (timer_again)

47
deps/uv/test/test-tcp-close.c

@ -127,3 +127,50 @@ TEST_IMPL(tcp_close) {
return 0;
}
TEST_IMPL(tcp_ref) {
uv_tcp_t never;
int r;
/* A tcp just initialized should count as one reference. */
r = uv_tcp_init(uv_default_loop(), &never);
ASSERT(r == 0);
/* One unref should set the loop ref count to zero. */
uv_unref(uv_default_loop());
/* Therefore this does not block */
uv_run(uv_default_loop());
return 0;
}
static void never_cb(uv_connect_t* conn_req, int status) {
FATAL("never_cb should never be called");
}
TEST_IMPL(tcp_ref2) {
uv_tcp_t never;
int r;
/* A tcp just initialized should count as one reference. */
r = uv_tcp_init(uv_default_loop(), &never);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req,
&never,
uv_ip4_addr("127.0.0.1", TEST_PORT),
never_cb);
ASSERT(r == 0);
/* One unref should set the loop ref count to zero. */
uv_unref(uv_default_loop());
/* Therefore this does not block */
uv_run(uv_default_loop());
return 0;
}

64
deps/uv/test/test-tcp-write-error.c

@ -35,10 +35,15 @@ static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
static uv_tcp_t tcp_server;
static uv_tcp_t tcp_client;
static uv_tcp_t tcp_peer; /* client socket as accept()-ed by server */
static uv_write_t write_req;
static uv_connect_t connect_req;
static int write_cb_called;
static int write_cb_error_called;
typedef struct {
uv_write_t req;
uv_buf_t buf;
} write_req_t;
static void connection_cb(uv_stream_t* server, int status) {
@ -75,40 +80,47 @@ static void connect_cb(uv_connect_t* req, int status) {
size_t size;
char* data;
int r;
write_req_t* wr;
ASSERT(req == &connect_req);
ASSERT(status == 0);
size = 10*1024*1024;
data = malloc(size);
ASSERT(data != NULL);
memset(data, '$', size);
buf = uv_buf_init(data, size);
write_req.data = data;
r = uv_write(&write_req, req->handle, &buf, 1, write_cb);
ASSERT(r == 0);
/* Write queue should have been updated. */
ASSERT(req->handle->write_queue_size > 0);
/* write_queue_size <= size, part may have already been written. */
ASSERT(req->handle->write_queue_size <= size);
while (1) {
size = 10 * 1024 * 1024;
data = malloc(size);
ASSERT(data != NULL);
memset(data, '$', size);
buf = uv_buf_init(data, size);
wr = (write_req_t*) malloc(sizeof *wr);
wr->buf = buf;
wr->req.data = data;
r = uv_write(&(wr->req), req->handle, &wr->buf, 1, write_cb);
ASSERT(r == 0);
if (req->handle->write_queue_size > 0) {
break;
}
}
}
static void write_cb(uv_write_t* req, int status) {
ASSERT(req == &write_req);
ASSERT(status == -1);
write_req_t* wr;
wr = (write_req_t*) req;
/* This is what this test is all about. */
ASSERT(tcp_client.write_queue_size == 0);
if (status == -1) {
write_cb_error_called++;
}
free(write_req.data);
if (req->handle->write_queue_size == 0) {
uv_close((uv_handle_t*)&tcp_client, NULL);
}
uv_close((uv_handle_t*)&tcp_client, NULL);
free(wr->buf.base);
free(wr);
write_cb_called++;
}
@ -148,7 +160,9 @@ TEST_IMPL(tcp_write_error) {
r = uv_run(loop);
ASSERT(r == 0);
ASSERT(write_cb_called == 1);
ASSERT(write_cb_called > 0);
ASSERT(write_cb_error_called == 1);
ASSERT(tcp_client.write_queue_size == 0);
return 0;
}

40
deps/uv/test/test-timer.c

@ -130,3 +130,43 @@ TEST_IMPL(timer) {
return 0;
}
TEST_IMPL(timer_ref) {
uv_timer_t never;
int r;
/* A timer just initialized should count as one reference. */
r = uv_timer_init(uv_default_loop(), &never);
ASSERT(r == 0);
/* One unref should set the loop ref count to zero. */
uv_unref(uv_default_loop());
/* Therefore this does not block */
uv_run(uv_default_loop());
return 0;
}
TEST_IMPL(timer_ref2) {
uv_timer_t never;
int r;
/* A timer just initialized should count as one reference. */
r = uv_timer_init(uv_default_loop(), &never);
ASSERT(r == 0);
/* We start the timer, this should not effect the ref count. */
r = uv_timer_start(&never, never_cb, 1000, 1000);
ASSERT(r == 0);
/* One unref should set the loop ref count to zero. */
uv_unref(uv_default_loop());
/* Therefore this does not block */
uv_run(uv_default_loop());
return 0;
}

Loading…
Cancel
Save