From d750927b360e5c7c1329992ca6cfcb2ab7e506a0 Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Fri, 16 Sep 2011 16:19:18 -0700 Subject: [PATCH] Upgrade libuv to 75a088e --- deps/uv/src/unix/internal.h | 4 + deps/uv/src/unix/stream.c | 16 ++- deps/uv/test/runner-unix.c | 2 + deps/uv/test/test-list.h | 2 + deps/uv/test/test-tcp-write-error.c | 154 ++++++++++++++++++++++++++++ 5 files changed, 176 insertions(+), 2 deletions(-) create mode 100644 deps/uv/test/test-tcp-write-error.c diff --git a/deps/uv/src/unix/internal.h b/deps/uv/src/unix/internal.h index 4ec6ced1cb..c30ef6e44d 100644 --- a/deps/uv/src/unix/internal.h +++ b/deps/uv/src/unix/internal.h @@ -51,6 +51,10 @@ #endif /* __linux__ */ +#ifdef __APPLE__ +# define HAVE_FUTIMES +#endif + /* flags */ enum { UV_CLOSING = 0x00000001, /* uv_close() called but not finished. */ diff --git a/deps/uv/src/unix/stream.c b/deps/uv/src/unix/stream.c index a5d860d0be..12c7173c3d 100644 --- a/deps/uv/src/unix/stream.c +++ b/deps/uv/src/unix/stream.c @@ -129,8 +129,8 @@ void uv__stream_destroy(uv_stream_t* stream) { req = ngx_queue_data(q, uv_write_t, queue); if (req->cb) { - uv_err_new_artificial(req->handle->loop, UV_OK); - req->cb(req, 0); + uv_err_new_artificial(stream->loop, req->error); + req->cb(req, req->error ? -1 : 0); } } } @@ -287,6 +287,17 @@ static void uv__drain(uv_stream_t* stream) { } +static size_t uv__write_req_size(uv_write_t* req) { + size_t size; + + size = uv__buf_count(req->bufs + req->write_index, + req->bufcnt - req->write_index); + assert(req->handle->write_queue_size >= size); + + return size; +} + + static void uv__write_req_finish(uv_write_t* req) { uv_stream_t* stream = req->handle; @@ -351,6 +362,7 @@ static void uv__write(uv_stream_t* stream) { if (errno != EAGAIN) { /* Error */ req->error = errno; + stream->write_queue_size -= uv__write_req_size(req); uv__write_req_finish(req); return; } diff --git a/deps/uv/test/runner-unix.c b/deps/uv/test/runner-unix.c index 0bbfd62e3d..6033d64294 100644 --- a/deps/uv/test/runner-unix.c +++ b/deps/uv/test/runner-unix.c @@ -65,6 +65,8 @@ void platform_init(int argc, char **argv) { #else strcpy(executable_path, argv[0]); #endif + + signal(SIGPIPE, SIG_IGN); } diff --git a/deps/uv/test/test-list.h b/deps/uv/test/test-list.h index 5f1100c9c0..bf84c6a947 100644 --- a/deps/uv/test/test-list.h +++ b/deps/uv/test/test-list.h @@ -32,6 +32,7 @@ TEST_DECLARE (tcp_bind_error_inval) TEST_DECLARE (tcp_bind_localhost_ok) TEST_DECLARE (tcp_listen_without_bind) TEST_DECLARE (tcp_close) +TEST_DECLARE (tcp_write_error) TEST_DECLARE (tcp_bind6_error_addrinuse) TEST_DECLARE (tcp_bind6_error_addrnotavail) TEST_DECLARE (tcp_bind6_error_fault) @@ -119,6 +120,7 @@ TASK_LIST_START TEST_ENTRY (tcp_bind_localhost_ok) TEST_ENTRY (tcp_listen_without_bind) TEST_ENTRY (tcp_close) + TEST_ENTRY (tcp_write_error) TEST_ENTRY (tcp_bind6_error_addrinuse) TEST_ENTRY (tcp_bind6_error_addrnotavail) diff --git a/deps/uv/test/test-tcp-write-error.c b/deps/uv/test/test-tcp-write-error.c new file mode 100644 index 0000000000..f3d12b8d6b --- /dev/null +++ b/deps/uv/test/test-tcp-write-error.c @@ -0,0 +1,154 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "uv.h" +#include "task.h" + +#include +#include +#include + +static void connection_cb(uv_stream_t* server, int status); +static void connect_cb(uv_connect_t* req, int status); +static void write_cb(uv_write_t* req, int status); +static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf); +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 void connection_cb(uv_stream_t* server, int status) { + int r; + + ASSERT(server == (uv_stream_t*)&tcp_server); + ASSERT(status == 0); + + r = uv_tcp_init(server->loop, &tcp_peer); + ASSERT(r == 0); + + r = uv_accept(server, (uv_stream_t*)&tcp_peer); + ASSERT(r == 0); + + r = uv_read_start((uv_stream_t*)&tcp_peer, alloc_cb, read_cb); + ASSERT(r == 0); +} + + +static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) { + static char slab[1024]; + return uv_buf_init(slab, sizeof slab); +} + + +static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) { + uv_close((uv_handle_t*)&tcp_server, NULL); + uv_close((uv_handle_t*)&tcp_peer, NULL); +} + + +static void connect_cb(uv_connect_t* req, int status) { + uv_buf_t buf; + size_t size; + char* data; + int r; + + 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); +} + + +static void write_cb(uv_write_t* req, int status) { + ASSERT(req == &write_req); + ASSERT(status == -1); + + /* This is what this test is all about. */ + ASSERT(tcp_client.write_queue_size == 0); + + free(write_req.data); + + uv_close((uv_handle_t*)&tcp_client, NULL); + + write_cb_called++; +} + + +/* + * Assert that a failing write does not leave + * the stream's write_queue_size in an inconsistent state. + */ +TEST_IMPL(tcp_write_error) { + uv_loop_t* loop; + int r; + + loop = uv_default_loop(); + ASSERT(loop != NULL); + + r = uv_tcp_init(loop, &tcp_server); + ASSERT(r == 0); + + r = uv_tcp_bind(&tcp_server, uv_ip4_addr("127.0.0.1", TEST_PORT)); + ASSERT(r == 0); + + r = uv_listen((uv_stream_t*)&tcp_server, 1, connection_cb); + ASSERT(r == 0); + + r = uv_tcp_init(loop, &tcp_client); + ASSERT(r == 0); + + r = uv_tcp_connect(&connect_req, + &tcp_client, + uv_ip4_addr("127.0.0.1", TEST_PORT), + connect_cb); + ASSERT(r == 0); + + ASSERT(write_cb_called == 0); + + r = uv_run(loop); + ASSERT(r == 0); + + ASSERT(write_cb_called == 1); + + return 0; +}