52 deps/uv/test/echo-server.c
View file
@@ -39,7 +39,7 @@ static uv_pipe_t pipeServer;
static uv_handle_t* server;

static void after_write(uv_write_t* req, int status);
static void after_read(uv_stream_t*, ssize_t nread, uv_buf_t buf);
static void after_read(uv_stream_t*, ssize_t nread, const uv_buf_t* buf);
static void on_close(uv_handle_t* peer);
static void on_server_close(uv_handle_t* handle);
static void on_connection(uv_stream_t*, int status);
@@ -72,7 +72,9 @@ static void after_shutdown(uv_shutdown_t* req, int status) {
}


static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void after_read(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
int i;
write_req_t *wr;
uv_shutdown_t* req;
@@ -81,8 +83,8 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
/* Error or EOF */
ASSERT(nread == UV_EOF);

if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}

req = (uv_shutdown_t*) malloc(sizeof *req);
@@ -93,7 +95,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {

if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf.base);
free(buf->base);
return;
}

@@ -103,9 +105,9 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
*/
if (!server_closed) {
for (i = 0; i < nread; i++) {
if (buf.base[i] == 'Q') {
if (i + 1 < nread && buf.base[i + 1] == 'S') {
free(buf.base);
if (buf->base[i] == 'Q') {
if (i + 1 < nread && buf->base[i + 1] == 'S') {
free(buf->base);
uv_close((uv_handle_t*)handle, on_close);
return;
} else {
@@ -118,7 +120,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {

wr = (write_req_t*) malloc(sizeof *wr);

wr->buf = uv_buf_init(buf.base, nread);
wr->buf = uv_buf_init(buf->base, nread);
if (uv_write(&wr->req, handle, &wr->buf, 1, after_write)) {
FATAL("uv_write failed");
}
@@ -130,8 +132,11 @@ static void on_close(uv_handle_t* peer) {
}


static uv_buf_t echo_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(malloc(suggested_size), suggested_size);
static void echo_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}


@@ -185,10 +190,11 @@ static void on_send(uv_udp_send_t* req, int status);

static void on_recv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* rcvbuf,
const struct sockaddr* addr,
unsigned flags) {
uv_udp_send_t* req;
uv_buf_t sndbuf;
int r;

ASSERT(nread > 0);
@@ -197,7 +203,13 @@ static void on_recv(uv_udp_t* handle,
req = malloc(sizeof(*req));
ASSERT(req != NULL);

r = uv_udp_send(req, handle, &buf, 1, *(struct sockaddr_in*)addr, on_send);
sndbuf = *rcvbuf;
r = uv_udp_send(req,
handle,
&sndbuf,
1,
(const struct sockaddr_in*) addr,
on_send);
ASSERT(r == 0);
}

@@ -209,9 +221,11 @@ static void on_send(uv_udp_send_t* req, int status) {


static int tcp4_echo_start(int port) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
struct sockaddr_in addr;
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", port, &addr));

server = (uv_handle_t*)&tcpServer;
serverType = TCP;

@@ -222,7 +236,7 @@ static int tcp4_echo_start(int port) {
return 1;
}

r = uv_tcp_bind(&tcpServer, addr);
r = uv_tcp_bind(&tcpServer, &addr);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Bind error\n");
@@ -241,9 +255,11 @@ static int tcp4_echo_start(int port) {


static int tcp6_echo_start(int port) {
struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);
struct sockaddr_in6 addr6;
int r;

ASSERT(0 == uv_ip6_addr("::1", port, &addr6));

server = (uv_handle_t*)&tcpServer;
serverType = TCP;

@@ -255,7 +271,7 @@ static int tcp6_echo_start(int port) {
}

/* IPv6 is optional as not all platforms support it */
r = uv_tcp_bind6(&tcpServer, addr6);
r = uv_tcp_bind6(&tcpServer, &addr6);
if (r) {
/* show message but return OK */
fprintf(stderr, "IPv6 not supported\n");
20 deps/uv/test/test-callback-stack.c
View file
@@ -45,12 +45,10 @@ static int bytes_received = 0;
static int shutdown_cb_called = 0;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.len = size;
buf.base = (char*) malloc(size);
ASSERT(buf.base);
return buf;
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->len = size;
buf->base = malloc(size);
ASSERT(buf->base != NULL);
}


@@ -69,11 +67,11 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
}


static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(nested == 0 && "read_cb must be called from a fresh stack");

printf("Read. nread == %d\n", (int)nread);
free(buf.base);
free(buf->base);

if (nread == 0) {
return;
@@ -173,7 +171,9 @@ static void connect_cb(uv_connect_t* req, int status) {


TEST_IMPL(callback_stack) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

if (uv_tcp_init(uv_default_loop(), &client)) {
FATAL("uv_tcp_init failed");
@@ -183,7 +183,7 @@ TEST_IMPL(callback_stack) {

nested++;

if (uv_tcp_connect(&connect_req, &client, addr, connect_cb)) {
if (uv_tcp_connect(&connect_req, &client, &addr, connect_cb)) {
FATAL("uv_tcp_connect failed");
}
nested--;
8 deps/uv/test/test-connection-fail.c
View file
@@ -90,19 +90,19 @@ static void connection_fail(uv_connect_cb connect_cb) {
struct sockaddr_in client_addr, server_addr;
int r;

client_addr = uv_ip4_addr("0.0.0.0", 0);
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr));

/* There should be no servers listening on this port. */
server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));

/* Try to connect to the server and do NUM_PINGS ping-pongs. */
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);

/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
uv_tcp_bind(&tcp, client_addr);
r = uv_tcp_connect(&req, &tcp, server_addr, connect_cb);
uv_tcp_bind(&tcp, &client_addr);
r = uv_tcp_connect(&req, &tcp, &server_addr, connect_cb);
ASSERT(!r);

uv_run(uv_default_loop(), UV_RUN_DEFAULT);
24 deps/uv/test/test-delayed-accept.c
View file
@@ -30,11 +30,9 @@ static int close_cb_called = 0;
static int connect_cb_called = 0;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.base = (char*)malloc(size);
buf.len = size;
return buf;
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}


@@ -101,27 +99,28 @@ static void connection_cb(uv_stream_t* tcp, int status) {


static void start_server(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t* server = (uv_tcp_t*)malloc(sizeof *server);
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
ASSERT(server != NULL);

r = uv_tcp_init(uv_default_loop(), server);
ASSERT(r == 0);
r = uv_tcp_bind(server, addr);
r = uv_tcp_bind(server, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)server, 128, connection_cb);
ASSERT(r == 0);
}


static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
/* The server will not send anything, it should close gracefully. */

if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}

if (nread >= 0) {
@@ -152,18 +151,19 @@ static void connect_cb(uv_connect_t* req, int status) {


static void client_connect(void) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t* client = (uv_tcp_t*)malloc(sizeof *client);
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(client != NULL);
ASSERT(connect_req != NULL);

r = uv_tcp_init(uv_default_loop(), client);
ASSERT(r == 0);

r = uv_tcp_connect(connect_req, client, addr, connect_cb);
r = uv_tcp_connect(connect_req, client, &addr, connect_cb);
ASSERT(r == 0);
}

5 deps/uv/test/test-embed.c
View file
@@ -78,7 +78,10 @@ static void embed_thread_runner(void* arg) {
ts.tv_nsec = (timeout % 1000) * 1000000;
r = kevent(fd, NULL, 0, NULL, 0, &ts);
#elif defined(HAVE_EPOLL)
r = epoll_wait(fd, NULL, 0, timeout);
{
struct epoll_event ev;
r = epoll_wait(fd, &ev, 1, timeout);
}
#endif
} while (r == -1 && errno == EINTR);
uv_async_send(&embed_async);
48 deps/uv/test/test-getsockname.c
View file
@@ -42,11 +42,9 @@ static uv_udp_t udpServer;
static uv_udp_send_t send_req;


static uv_buf_t alloc(uv_handle_t* handle, size_t suggested_size) {
uv_buf_t buf;
buf.base = (char*) malloc(suggested_size);
buf.len = suggested_size;
return buf;
static void alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}


@@ -62,12 +60,14 @@ static void after_shutdown(uv_shutdown_t* req, int status) {
}


static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void after_read(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
uv_shutdown_t* req;
int r;

if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}

req = (uv_shutdown_t*) malloc(sizeof *req);
@@ -79,10 +79,12 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void check_sockname(struct sockaddr* addr, const char* compare_ip,
int compare_port, const char* context) {
struct sockaddr_in check_addr = *(struct sockaddr_in*) addr;
struct sockaddr_in compare_addr = uv_ip4_addr(compare_ip, compare_port);
struct sockaddr_in compare_addr;
char check_ip[17];
int r;

ASSERT(0 == uv_ip4_addr(compare_ip, compare_port, &compare_addr));

/* Both addresses should be ipv4 */
ASSERT(check_addr.sin_family == AF_INET);
ASSERT(compare_addr.sin_family == AF_INET);
@@ -165,18 +167,20 @@ static void on_connect(uv_connect_t* req, int status) {


static int tcp_listener(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr_in addr;
struct sockaddr sockname, peername;
int namelen;
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));

r = uv_tcp_init(loop, &tcpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
}

r = uv_tcp_bind(&tcpServer, addr);
r = uv_tcp_bind(&tcpServer, &addr);
if (r) {
fprintf(stderr, "Bind error\n");
return 1;
@@ -205,15 +209,17 @@ static int tcp_listener(void) {


static void tcp_connector(void) {
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", server_port);
struct sockaddr_in server_addr;
struct sockaddr sockname;
int r, namelen;

ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));

r = uv_tcp_init(loop, &tcp);
tcp.data = &connect_req;
ASSERT(!r);

r = uv_tcp_connect(&connect_req, &tcp, server_addr, on_connect);
r = uv_tcp_connect(&connect_req, &tcp, &server_addr, on_connect);
ASSERT(!r);

/* Fetch the actual port used by the connecting socket. */
@@ -228,15 +234,15 @@ static void tcp_connector(void) {

static void udp_recv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
struct sockaddr sockname;
int namelen;
int r;

ASSERT(nread >= 0);
free(buf.base);
free(buf->base);

if (nread == 0) {
return;
@@ -260,18 +266,20 @@ static void udp_send(uv_udp_send_t* req, int status) {


static int udp_listener(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr_in addr;
struct sockaddr sockname;
int namelen;
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));

r = uv_udp_init(loop, &udpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
}

r = uv_udp_bind(&udpServer, addr, 0);
r = uv_udp_bind(&udpServer, &addr, 0);
if (r) {
fprintf(stderr, "Bind error\n");
return 1;
@@ -300,9 +308,9 @@ static void udp_sender(void) {
ASSERT(!r);

buf = uv_buf_init("PING", 4);
server_addr = uv_ip4_addr("127.0.0.1", server_port);
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));

r = uv_udp_send(&send_req, &udp, &buf, 1, server_addr, udp_send);
r = uv_udp_send(&send_req, &udp, &buf, 1, &server_addr, udp_send);
ASSERT(!r);
}

2 deps/uv/test/test-ip6-addr.c
View file
@@ -84,7 +84,7 @@ TEST_IMPL(ip6_addr_link_local) {
iface_index,
device_name);

addr = uv_ip6_addr(scoped_addr, TEST_PORT);
ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
LOGF("Got scope_id 0x%02x\n", addr.sin6_scope_id);
ASSERT(iface_index == addr.sin6_scope_id);
}
24 deps/uv/test/test-ipc-send-recv.c
View file
@@ -50,16 +50,19 @@ static struct echo_ctx ctx;
static int num_recv_handles;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
/* we're not actually reading anything so a small buffer is okay */
static char buf[8];
return uv_buf_init(buf, sizeof(buf));
static char slab[8];
buf->base = slab;
buf->len = sizeof(slab);
}


static void recv_cb(uv_pipe_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
int r;

@@ -132,14 +135,17 @@ TEST_IMPL(ipc_send_recv_pipe) {


TEST_IMPL(ipc_send_recv_tcp) {
struct sockaddr_in addr;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

ctx.expected_type = UV_TCP;

r = uv_tcp_init(uv_default_loop(), &ctx.send.tcp);
ASSERT(r == 0);

r = uv_tcp_bind(&ctx.send.tcp, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(&ctx.send.tcp, &addr);
ASSERT(r == 0);

r = run_test();
@@ -161,15 +167,16 @@ static void write2_cb(uv_write_t* req, int status) {

static void read2_cb(uv_pipe_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* rdbuf,
uv_handle_type pending) {
uv_buf_t wrbuf;
int r;

ASSERT(pending == UV_NAMED_PIPE || pending == UV_TCP);
ASSERT(handle == &ctx.channel);
ASSERT(nread >= 0);

buf = uv_buf_init(".", 1);
wrbuf = uv_buf_init(".", 1);

if (pending == UV_NAMED_PIPE)
r = uv_pipe_init(ctx.channel.loop, &ctx.recv.pipe, 0);
@@ -184,7 +191,8 @@ static void read2_cb(uv_pipe_t* handle,

r = uv_write2(&ctx.write_req,
(uv_stream_t*)&ctx.channel,
&buf, 1,
&wrbuf,
1,
&ctx.recv.stream,
write2_cb);
ASSERT(r == 0);
110 deps/uv/test/test-ipc.c
View file
@@ -94,8 +94,11 @@ static void exit_cb(uv_process_t* process,
}


static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(malloc(suggested_size), suggested_size);
static void on_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}


@@ -122,30 +125,35 @@ static void make_many_connections(void) {
r = uv_tcp_init(uv_default_loop(), &conn->conn);
ASSERT(r == 0);

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_tcp_connect(&conn->conn_req, (uv_tcp_t*)&conn->conn, addr, connect_cb);
r = uv_tcp_connect(&conn->conn_req,
(uv_tcp_t*) &conn->conn,
&addr,
connect_cb);
ASSERT(r == 0);

conn->conn.data = conn;
}
}


static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
uv_handle_type pending) {
static void on_read(uv_pipe_t* pipe,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending) {
int r;
uv_buf_t outbuf;

if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf.base);
free(buf->base);
return;
}

if (nread < 0) {
if (nread == UV_EOF) {
free(buf.base);
free(buf->base);
return;
}

@@ -156,7 +164,7 @@ static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
fprintf(stderr, "got %d bytes\n", (int)nread);

if (!tcp_server_listening) {
ASSERT(nread > 0 && buf.base && pending != UV_UNKNOWN_HANDLE);
ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
read2_cb_called++;

/* Accept the pending TCP server, and start listening on it. */
@@ -173,22 +181,22 @@ static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
tcp_server_listening = 1;

/* Make sure that the expected data is correctly multiplexed. */
ASSERT(memcmp("hello\n", buf.base, nread) == 0);
ASSERT(memcmp("hello\n", buf->base, nread) == 0);

outbuf = uv_buf_init("world\n", 6);
r = uv_write(&write_req, (uv_stream_t*)pipe, &outbuf, 1, NULL);
ASSERT(r == 0);

/* Create a bunch of connections to get both servers to accept. */
make_many_connections();
} else if (memcmp("accepted_connection\n", buf.base, nread) == 0) {
} else if (memcmp("accepted_connection\n", buf->base, nread) == 0) {
/* Remote server has accepted a connection. Close the channel. */
ASSERT(pending == UV_UNKNOWN_HANDLE);
remote_conn_accepted = 1;
uv_close((uv_handle_t*)&channel, NULL);
}

free(buf.base);
free(buf->base);
}


@@ -226,7 +234,7 @@ void spawn_helper(uv_pipe_t* channel,
options.stdio[0].data.stream = (uv_stream_t*)channel;
options.stdio_count = 1;

r = uv_spawn(uv_default_loop(), process, options);
r = uv_spawn(uv_default_loop(), process, &options);
ASSERT(r == 0);
}

@@ -238,19 +246,19 @@ static void on_tcp_write(uv_write_t* req, int status) {
}


static uv_buf_t on_read_alloc(uv_handle_t* handle, size_t suggested_size) {
uv_buf_t buf;
buf.base = (char*)malloc(suggested_size);
buf.len = suggested_size;
return buf;
static void on_read_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}


static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(nread > 0);
ASSERT(memcmp("hello again\n", buf.base, nread) == 0);
ASSERT(memcmp("hello again\n", buf->base, nread) == 0);
ASSERT(tcp == (uv_stream_t*)&tcp_connection);
free(buf.base);
free(buf->base);

tcp_read_cb_called++;

@@ -259,20 +267,22 @@ static void on_tcp_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
}


static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
uv_handle_type pending) {
static void on_read_connection(uv_pipe_t* pipe,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending) {
int r;
uv_buf_t outbuf;

if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf.base);
free(buf->base);
return;
}

if (nread < 0) {
if (nread == UV_EOF) {
free(buf.base);
free(buf->base);
return;
}

@@ -282,7 +292,7 @@ static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,

fprintf(stderr, "got %d bytes\n", (int)nread);

ASSERT(nread > 0 && buf.base && pending != UV_UNKNOWN_HANDLE);
ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
read2_cb_called++;

/* Accept the pending TCP connection */
@@ -294,7 +304,7 @@ static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
ASSERT(r == 0);

/* Make sure that the expected data is correctly multiplexed. */
ASSERT(memcmp("hello\n", buf.base, nread) == 0);
ASSERT(memcmp("hello\n", buf->base, nread) == 0);

/* Write/read to/from the connection */
outbuf = uv_buf_init("world\n", 6);
@@ -305,7 +315,7 @@ static void on_read_connection(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read);
ASSERT(r == 0);

free(buf.base);
free(buf->base);
}


@@ -358,12 +368,14 @@ TEST_IMPL(ipc_tcp_connection) {
TEST_IMPL(listen_with_simultaneous_accepts) {
uv_tcp_t server;
int r;
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);

r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0);

r = uv_tcp_simultaneous_accepts(&server, 1);
@@ -381,12 +393,14 @@ TEST_IMPL(listen_with_simultaneous_accepts) {
TEST_IMPL(listen_no_simultaneous_accepts) {
uv_tcp_t server;
int r;
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);

r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0);

r = uv_tcp_simultaneous_accepts(&server, 0);
@@ -427,13 +441,15 @@ static void tcp_connection_write_cb(uv_write_t* req, int status) {
}


static void on_tcp_child_process_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void on_tcp_child_process_read(uv_stream_t* tcp,
ssize_t nread,
const uv_buf_t* buf) {
uv_buf_t outbuf;
int r;

if (nread < 0) {
if (nread == UV_EOF) {
free(buf.base);
free(buf->base);
return;
}

@@ -442,9 +458,9 @@ static void on_tcp_child_process_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t
}

ASSERT(nread > 0);
ASSERT(memcmp("world\n", buf.base, nread) == 0);
ASSERT(memcmp("world\n", buf->base, nread) == 0);
on_pipe_read_called++;
free(buf.base);
free(buf->base);

/* Write to the socket */
outbuf = uv_buf_init("hello again\n", 12);
@@ -517,7 +533,9 @@ static void ipc_on_connection_tcp_conn(uv_stream_t* server, int status) {
(uv_stream_t*)conn, NULL);
ASSERT(r == 0);

r = uv_read_start((uv_stream_t*)conn, on_read_alloc, on_tcp_child_process_read);
r = uv_read_start((uv_stream_t*) conn,
on_read_alloc,
on_tcp_child_process_read);
ASSERT(r == 0);

uv_close((uv_handle_t*)conn, close_cb);
@@ -529,11 +547,13 @@ int ipc_helper(int listen_after_write) {
* This is launched from test-ipc.c. stdin is a duplex channel that we
* over which a handle will be transmitted.
*/

struct sockaddr_in addr;
uv_write_t write_req;
int r;
uv_buf_t buf;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

r = uv_pipe_init(uv_default_loop(), &channel, 1);
ASSERT(r == 0);

@@ -546,7 +566,7 @@ int ipc_helper(int listen_after_write) {
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);

r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT));
r = uv_tcp_bind(&tcp_server, &addr);
ASSERT(r == 0);

if (!listen_after_write) {
@@ -596,7 +616,9 @@ int ipc_helper_tcp_connection(void) {
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);

r = uv_tcp_bind(&tcp_server, uv_ip4_addr("0.0.0.0", TEST_PORT));
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

r = uv_tcp_bind(&tcp_server, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)&tcp_server, 12, ipc_on_connection_tcp_conn);
@@ -606,8 +628,12 @@ int ipc_helper_tcp_connection(void) {
r = uv_tcp_init(uv_default_loop(), &conn.conn);
ASSERT(r == 0);

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
r = uv_tcp_connect(&conn.conn_req, (uv_tcp_t*)&conn.conn, addr, connect_child_process_cb);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_tcp_connect(&conn.conn_req,
(uv_tcp_t*) &conn.conn,
&addr,
connect_child_process_cb);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
11 deps/uv/test/test-multiple-listen.c
View file
@@ -45,13 +45,15 @@ static void connection_cb(uv_stream_t* tcp, int status) {


static void start_server(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);

r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)&server, 128, connection_cb);
@@ -72,16 +74,17 @@ static void connect_cb(uv_connect_t* req, int status) {


static void client_connect(void) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(connect_req != NULL);

r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);

r = uv_tcp_connect(connect_req, &client, addr, connect_cb);
r = uv_tcp_connect(connect_req, &client, &addr, connect_cb);
ASSERT(r == 0);
}

10 deps/uv/test/test-osx-select.c
View file
@@ -30,14 +30,14 @@
static int read_count;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
static char buf[1024];

return uv_buf_init(buf, ARRAY_SIZE(buf));
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
static char slab[1024];
buf->base = slab;
buf->len = sizeof(slab);
}


static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
fprintf(stdout, "got data %d\n", ++read_count);

if (read_count == 3)
37 deps/uv/test/test-ping-pong.c
View file
@@ -48,8 +48,9 @@ typedef struct {
} pinger_t;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
return uv_buf_init(malloc(size), size);
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}


@@ -85,7 +86,9 @@ static void pinger_write_ping(pinger_t* pinger) {
}


static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
static void pinger_read_cb(uv_stream_t* stream,
ssize_t nread,
const uv_buf_t* buf) {
ssize_t i;
pinger_t* pinger;

@@ -95,7 +98,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
ASSERT(nread == UV_EOF);

puts("got EOF");
free(buf.base);
free(buf->base);

uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);

@@ -104,7 +107,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {

/* Now we count the pings */
for (i = 0; i < nread; i++) {
ASSERT(buf.base[i] == PING[pinger->state]);
ASSERT(buf->base[i] == PING[pinger->state]);
pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);

if (pinger->state != 0)
@@ -121,7 +124,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
}
}

free(buf.base);
free(buf->base);
}


@@ -145,10 +148,11 @@ static void pinger_on_connect(uv_connect_t *req, int status) {
/* same ping-pong test, but using IPv6 connection */
static void tcp_pinger_v6_new(void) {
int r;
struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
struct sockaddr_in6 server_addr;
pinger_t *pinger;

pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;

@@ -159,8 +163,10 @@ static void tcp_pinger_v6_new(void) {

/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect6(&pinger->connect_req, &pinger->stream.tcp, server_addr,
pinger_on_connect);
r = uv_tcp_connect6(&pinger->connect_req,
&pinger->stream.tcp,
&server_addr,
pinger_on_connect);
ASSERT(!r);

/* Synchronous connect callbacks are not allowed. */
@@ -170,10 +176,11 @@ static void tcp_pinger_v6_new(void) {

static void tcp_pinger_new(void) {
int r;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in server_addr;
pinger_t *pinger;

pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;

@@ -184,8 +191,10 @@ static void tcp_pinger_new(void) {

/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect(&pinger->connect_req, &pinger->stream.tcp, server_addr,
pinger_on_connect);
r = uv_tcp_connect(&pinger->connect_req,
&pinger->stream.tcp,
&server_addr,
pinger_on_connect);
ASSERT(!r);

/* Synchronous connect callbacks are not allowed. */
14 deps/uv/test/test-poll.c
View file
@@ -496,11 +496,13 @@ static void server_poll_cb(uv_poll_t* handle, int status, int events) {


static void start_server(void) {
uv_os_sock_t sock;
server_context_t* context;
struct sockaddr_in addr;
uv_os_sock_t sock;
int r;

sock = create_nonblocking_bound_socket(uv_ip4_addr("127.0.0.1", TEST_PORT));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
sock = create_nonblocking_bound_socket(addr);
context = create_server_context(sock);

r = listen(sock, 100);
@@ -514,10 +516,14 @@ static void start_server(void) {
static void start_client(void) {
uv_os_sock_t sock;
connection_context_t* context;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in server_addr;
struct sockaddr_in addr;
int r;

sock = create_nonblocking_bound_socket(uv_ip4_addr("0.0.0.0", 0));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));

sock = create_nonblocking_bound_socket(addr);
context = create_connection_context(sock, 0);

context->events = UV_READABLE | UV_WRITABLE;
22 deps/uv/test/test-ref.c
View file
@@ -254,10 +254,11 @@ TEST_IMPL(tcp_ref2b) {


TEST_IMPL(tcp_ref3) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_tcp_init(uv_default_loop(), &h);
uv_tcp_connect(&connect_req, &h, addr, connect_and_shutdown);
uv_tcp_connect(&connect_req, &h, &addr, connect_and_shutdown);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_called == 1);
@@ -269,10 +270,11 @@ TEST_IMPL(tcp_ref3) {


TEST_IMPL(tcp_ref4) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_tcp_init(uv_default_loop(), &h);
uv_tcp_connect(&connect_req, &h, addr, connect_and_write);
uv_tcp_connect(&connect_req, &h, &addr, connect_and_write);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_called == 1);
@@ -296,10 +298,11 @@ TEST_IMPL(udp_ref) {


TEST_IMPL(udp_ref2) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_udp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_udp_init(uv_default_loop(), &h);
uv_udp_bind(&h, addr, 0);
uv_udp_bind(&h, &addr, 0);
uv_udp_recv_start(&h, (uv_alloc_cb)fail_cb, (uv_udp_recv_cb)fail_cb);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -310,13 +313,14 @@ TEST_IMPL(udp_ref2) {


TEST_IMPL(udp_ref3) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_buf_t buf = uv_buf_init("PING", 4);
uv_udp_send_t req;
uv_udp_t h;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_udp_init(uv_default_loop(), &h);
uv_udp_send(&req, &h, &buf, 1, addr, (uv_udp_send_cb)req_cb);
uv_udp_send(&req, &h, &buf, 1, &addr, (uv_udp_send_cb)req_cb);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(req_cb_called == 1);
@@ -399,7 +403,7 @@ TEST_IMPL(process_ref) {
options.args = argv;
options.exit_cb = NULL;

r = uv_spawn(uv_default_loop(), &h, options);
r = uv_spawn(uv_default_loop(), &h, &options);
ASSERT(r == 0);

uv_unref((uv_handle_t*)&h);
5 deps/uv/test/test-shutdown-close.c
View file
@@ -65,13 +65,14 @@ static void connect_cb(uv_connect_t* req, int status) {


TEST_IMPL(shutdown_close_tcp) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &h);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &h, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &h, &addr, connect_cb);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);
24 deps/uv/test/test-shutdown-eof.c
View file
@@ -39,33 +39,31 @@ static int called_timer_close_cb;
static int called_timer_cb;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.base = (char*)malloc(size);
buf.len = size;
return buf;
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}


static void read_cb(uv_stream_t* t, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) {
ASSERT((uv_tcp_t*)t == &tcp);

if (nread == 0) {
free(buf.base);
free(buf->base);
return;
}

if (!got_q) {
ASSERT(nread == 1);
ASSERT(!got_eof);
ASSERT(buf.base[0] == 'Q');
free(buf.base);
ASSERT(buf->base[0] == 'Q');
free(buf->base);
got_q = 1;
puts("got Q");
} else {
ASSERT(nread == UV_EOF);
if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}
got_eof = 1;
puts("got EOF");
@@ -158,11 +156,11 @@ TEST_IMPL(shutdown_eof) {

uv_timer_start(&timer, timer_cb, 100, 0);

server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);

r = uv_tcp_connect(&connect_req, &tcp, server_addr, connect_cb);
r = uv_tcp_connect(&connect_req, &tcp, &server_addr, connect_cb);
ASSERT(!r);

uv_run(uv_default_loop(), UV_RUN_DEFAULT);
52 deps/uv/test/test-spawn.c
View file
@@ -118,15 +118,15 @@ static void detach_failure_cb(uv_process_t* process, int64_t exit_status, int te
exit_cb_called++;
}

static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
uv_buf_t buf;
buf.base = output + output_used;
buf.len = OUTPUT_SIZE - output_used;
return buf;
static void on_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = output + output_used;
buf->len = OUTPUT_SIZE - output_used;
}


static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
if (nread > 0) {
output_used += nread;
} else if (nread < 0) {
@@ -166,7 +166,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
TEST_IMPL(spawn_fails) {
init_process_options("", exit_cb_expect_enoent);
options.file = options.args[0] = "program-that-had-better-not-exist";
ASSERT(0 == uv_spawn(uv_default_loop(), &process, options));
ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options));
ASSERT(0 != uv_is_active((uv_handle_t*)&process));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(1 == exit_cb_called);
@@ -181,7 +181,7 @@ TEST_IMPL(spawn_exit_code) {

init_process_options("spawn_helper1", exit_cb);

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -209,7 +209,7 @@ TEST_IMPL(spawn_stdout) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -252,7 +252,7 @@ TEST_IMPL(spawn_stdout_to_file) {
options.stdio[1].data.fd = file;
options.stdio_count = 2;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -301,7 +301,7 @@ TEST_IMPL(spawn_stdin) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

buf.base = buffer;
@@ -340,7 +340,7 @@ TEST_IMPL(spawn_stdio_greater_than_3) {
options.stdio[3].data.stream = (uv_stream_t*)&pipe;
options.stdio_count = 4;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_read_start((uv_stream_t*) &pipe, on_alloc, on_read);
@@ -367,7 +367,7 @@ TEST_IMPL(spawn_ignored_stdio) {
options.stdio = NULL;
options.stdio_count = 0;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -386,7 +386,7 @@ TEST_IMPL(spawn_and_kill) {

init_process_options("spawn_helper4", kill_cb);

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_timer_init(uv_default_loop(), &timer);
@@ -426,7 +426,7 @@ TEST_IMPL(spawn_preserve_env) {
/* Explicitly set options.env to NULL to test for env clobbering. */
options.env = NULL;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -453,7 +453,7 @@ TEST_IMPL(spawn_detached) {

options.flags |= UV_PROCESS_DETACHED;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

uv_unref((uv_handle_t*)&process);
@@ -502,7 +502,7 @@ TEST_IMPL(spawn_and_kill_with_std) {
options.stdio[2].data.stream = (uv_stream_t*)&err;
options.stdio_count = 3;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

buf = uv_buf_init(message, sizeof message);
@@ -551,7 +551,7 @@ TEST_IMPL(spawn_and_ping) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

/* Sending signum == 0 should check if the
@@ -588,7 +588,7 @@ TEST_IMPL(kill) {

init_process_options("spawn_helper4", kill_cb);

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

/* Sending signum == 0 should check if the
@@ -641,7 +641,7 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
NULL);
ASSERT(pipe_handle != INVALID_HANDLE_VALUE);

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -806,7 +806,7 @@ TEST_IMPL(spawn_setuid_setgid) {
options.gid = pw->pw_gid;
options.flags = UV_PROCESS_SETUID | UV_PROCESS_SETGID;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -840,7 +840,7 @@ TEST_IMPL(spawn_setuid_fails) {
options.flags |= UV_PROCESS_SETUID;
options.uid = 0;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -872,7 +872,7 @@ TEST_IMPL(spawn_setgid_fails) {
options.flags |= UV_PROCESS_SETGID;
options.gid = 0;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -904,7 +904,7 @@ TEST_IMPL(spawn_setuid_fails) {
options.flags |= UV_PROCESS_SETUID;
options.uid = (uv_uid_t) -42424242;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == UV_ENOTSUP);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -925,7 +925,7 @@ TEST_IMPL(spawn_setgid_fails) {
options.flags |= UV_PROCESS_SETGID;
options.gid = (uv_gid_t) -42424242;

r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == UV_ENOTSUP);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@@ -941,7 +941,7 @@ TEST_IMPL(spawn_setgid_fails) {

TEST_IMPL(spawn_auto_unref) {
init_process_options("spawn_helper1", NULL);
ASSERT(0 == uv_spawn(uv_default_loop(), &process, options));
ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(0 == uv_is_closing((uv_handle_t*) &process));
uv_close((uv_handle_t*) &process, NULL);
27 deps/uv/test/test-stdio-over-pipes.c
View file
@@ -74,8 +74,11 @@ static void init_process_options(char* test, uv_exit_cb exit_cb) {
}


static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(output + output_used, OUTPUT_SIZE - output_used);
static void on_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = output + output_used;
buf->len = OUTPUT_SIZE - output_used;
}


@@ -92,7 +95,7 @@ static void after_write(uv_write_t* req, int status) {
}


static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t rdbuf) {
static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* rdbuf) {
uv_write_t* req;
uv_buf_t wrbuf;
int r;
@@ -133,7 +136,7 @@ TEST_IMPL(stdio_over_pipes) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;

r = uv_spawn(loop, &process, options);
r = uv_spawn(loop, &process, &options);
ASSERT(r == 0);

r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@@ -161,12 +164,12 @@ static int after_write_called;
static uv_pipe_t stdin_pipe;
static uv_pipe_t stdout_pipe;

static void on_pipe_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void on_pipe_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(nread > 0);
ASSERT(memcmp("hello world\n", buf.base, nread) == 0);
ASSERT(memcmp("hello world\n", buf->base, nread) == 0);
on_pipe_read_called++;

free(buf.base);
free(buf->base);

uv_close((uv_handle_t*)&stdin_pipe, close_cb);
uv_close((uv_handle_t*)&stdout_pipe, close_cb);
@@ -179,8 +182,11 @@ static void after_pipe_write(uv_write_t* req, int status) {
}


static uv_buf_t on_read_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(malloc(suggested_size), suggested_size);
static void on_read_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}


@@ -236,8 +242,7 @@ int stdio_over_pipes_helper(void) {
uv_ref((uv_handle_t*)&stdout_pipe);
uv_ref((uv_handle_t*)&stdin_pipe);

r = uv_read_start((uv_stream_t*)&stdin_pipe, on_read_alloc,
on_pipe_read);
r = uv_read_start((uv_stream_t*)&stdin_pipe, on_read_alloc, on_pipe_read);
ASSERT(r == 0);

uv_run(loop, UV_RUN_DEFAULT);
39 deps/uv/test/test-tcp-bind-error.c
View file
@@ -35,18 +35,19 @@ static void close_cb(uv_handle_t* handle) {


TEST_IMPL(tcp_bind_error_addrinuse) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server1, server2;
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind(&server1, addr);
r = uv_tcp_bind(&server1, &addr);
ASSERT(r == 0);

r = uv_tcp_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_tcp_bind(&server2, addr);
r = uv_tcp_bind(&server2, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)&server1, 128, NULL);
@@ -67,15 +68,17 @@ TEST_IMPL(tcp_bind_error_addrinuse) {


TEST_IMPL(tcp_bind_error_addrnotavail_1) {
struct sockaddr_in addr = uv_ip4_addr("127.255.255.255", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip4_addr("127.255.255.255", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);

/* It seems that Linux is broken here - bind succeeds. */
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0 || r == UV_EADDRNOTAVAIL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -90,13 +93,15 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) {


TEST_IMPL(tcp_bind_error_addrnotavail_2) {
struct sockaddr_in addr = uv_ip4_addr("4.4.4.4", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip4_addr("4.4.4.4", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == UV_EADDRNOTAVAIL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -120,7 +125,7 @@ TEST_IMPL(tcp_bind_error_fault) {

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, *garbage_addr);
r = uv_tcp_bind(&server, garbage_addr);
ASSERT(r == UV_EINVAL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -136,16 +141,19 @@ TEST_IMPL(tcp_bind_error_fault) {
/* Notes: On Linux uv_bind(server, NULL) will segfault the program. */

TEST_IMPL(tcp_bind_error_inval) {
struct sockaddr_in addr1 = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr2 = uv_ip4_addr("0.0.0.0", TEST_PORT_2);
struct sockaddr_in addr1;
struct sockaddr_in addr2;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr1));
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT_2, &addr2));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr1);
r = uv_tcp_bind(&server, &addr1);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr2);
r = uv_tcp_bind(&server, &addr2);
ASSERT(r == UV_EINVAL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -160,14 +168,15 @@ TEST_IMPL(tcp_bind_error_inval) {


TEST_IMPL(tcp_bind_localhost_ok) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);

struct sockaddr_in addr;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0);

MAKE_VALGRIND_HAPPY();
34 deps/uv/test/test-tcp-bind6-error.c
View file
@@ -35,18 +35,20 @@ static void close_cb(uv_handle_t* handle) {


TEST_IMPL(tcp_bind6_error_addrinuse) {
struct sockaddr_in6 addr = uv_ip6_addr("::", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server1, server2;
int r;

ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server1, addr);
r = uv_tcp_bind6(&server1, &addr);
ASSERT(r == 0);

r = uv_tcp_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_tcp_bind6(&server2, addr);
r = uv_tcp_bind6(&server2, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)&server1, 128, NULL);
@@ -67,13 +69,15 @@ TEST_IMPL(tcp_bind6_error_addrinuse) {


TEST_IMPL(tcp_bind6_error_addrnotavail) {
struct sockaddr_in6 addr = uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
r = uv_tcp_bind6(&server, &addr);
ASSERT(r == UV_EADDRNOTAVAIL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -97,7 +101,7 @@ TEST_IMPL(tcp_bind6_error_fault) {

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, *garbage_addr);
r = uv_tcp_bind6(&server, garbage_addr);
ASSERT(r == UV_EINVAL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -113,16 +117,19 @@ TEST_IMPL(tcp_bind6_error_fault) {
/* Notes: On Linux uv_bind6(server, NULL) will segfault the program. */

TEST_IMPL(tcp_bind6_error_inval) {
struct sockaddr_in6 addr1 = uv_ip6_addr("::", TEST_PORT);
struct sockaddr_in6 addr2 = uv_ip6_addr("::", TEST_PORT_2);
struct sockaddr_in6 addr1;
struct sockaddr_in6 addr2;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr1));
ASSERT(0 == uv_ip6_addr("::", TEST_PORT_2, &addr2));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr1);
r = uv_tcp_bind6(&server, &addr1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr2);
r = uv_tcp_bind6(&server, &addr2);
ASSERT(r == UV_EINVAL);

uv_close((uv_handle_t*)&server, close_cb);
@@ -137,14 +144,15 @@ TEST_IMPL(tcp_bind6_error_inval) {


TEST_IMPL(tcp_bind6_localhost_ok) {
struct sockaddr_in6 addr = uv_ip6_addr("::1", TEST_PORT);

struct sockaddr_in6 addr;
uv_tcp_t server;
int r;

ASSERT(0 == uv_ip6_addr("::1", TEST_PORT, &addr));

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
r = uv_tcp_bind6(&server, &addr);
ASSERT(r == 0);

MAKE_VALGRIND_HAPPY();
5 deps/uv/test/test-tcp-close-while-connecting.c
View file
@@ -60,11 +60,10 @@ TEST_IMPL(tcp_close_while_connecting) {
struct sockaddr_in addr;
uv_loop_t* loop;

addr = uv_ip4_addr("1.2.3.4", TEST_PORT);
loop = uv_default_loop();

ASSERT(0 == uv_ip4_addr("1.2.3.4", TEST_PORT, &addr));
ASSERT(0 == uv_tcp_init(loop, &tcp_handle));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb));
ASSERT(0 == uv_timer_init(loop, &timer1_handle));
ASSERT(0 == uv_timer_start(&timer1_handle, timer1_cb, 50, 0));
ASSERT(0 == uv_timer_init(loop, &timer2_handle));
15 deps/uv/test/test-tcp-close.c
View file
@@ -77,12 +77,15 @@ static void connection_cb(uv_stream_t* server, int status) {


static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
struct sockaddr_in addr;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_tcp_init(loop, handle);
ASSERT(r == 0);

r = uv_tcp_bind(handle, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(handle, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)handle, 128, connection_cb);
@@ -96,10 +99,13 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
* invoked when the handle is closed.
*/
TEST_IMPL(tcp_close) {
uv_loop_t* loop;
struct sockaddr_in addr;
uv_tcp_t tcp_server;
uv_loop_t* loop;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

loop = uv_default_loop();

/* We can't use the echo server, it doesn't handle ECONNRESET. */
@@ -108,10 +114,7 @@ TEST_IMPL(tcp_close) {
r = uv_tcp_init(loop, &tcp_handle);
ASSERT(r == 0);

r = uv_tcp_connect(&connect_req,
&tcp_handle,
uv_ip4_addr("127.0.0.1", TEST_PORT),
connect_cb);
r = uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb);
ASSERT(r == 0);

ASSERT(write_cb_called == 0);
4 deps/uv/test/test-tcp-connect-error-after-write.c
View file
@@ -68,7 +68,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
return 0; /* windows slackers... */
#endif

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
buf = uv_buf_init("TEST", 4);

r = uv_tcp_init(uv_default_loop(), &conn);
@@ -77,7 +77,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);
ASSERT(r == UV_EBADF);

r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
ASSERT(r == 0);

r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);
9 deps/uv/test/test-tcp-connect-error.c
View file
@@ -44,17 +44,18 @@ static void close_cb(uv_handle_t* handle) {


TEST_IMPL(tcp_connect_error_fault) {
char garbage[] = "blah blah blah blah blah blah blah blah blah blah blah blah";
struct sockaddr_in* garbage_addr;
const char garbage[] =
"blah blah blah blah blah blah blah blah blah blah blah blah";
const struct sockaddr_in* garbage_addr;
uv_tcp_t server;
int r;
uv_connect_t req;

garbage_addr = (struct sockaddr_in*) &garbage;
garbage_addr = (const struct sockaddr_in*) &garbage;

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_connect(&req, &server, *garbage_addr, connect_cb);
r = uv_tcp_connect(&req, &server, garbage_addr, connect_cb);
ASSERT(r == UV_EINVAL);

uv_close((uv_handle_t*)&server, close_cb);
4 deps/uv/test/test-tcp-connect-timeout.c
View file
@@ -64,7 +64,7 @@ TEST_IMPL(tcp_connect_timeout) {
struct sockaddr_in addr;
int r;

addr = uv_ip4_addr("8.8.8.8", 9999);
ASSERT(0 == uv_ip4_addr("8.8.8.8", 9999, &addr));

r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
@@ -75,7 +75,7 @@ TEST_IMPL(tcp_connect_timeout) {
r = uv_tcp_init(uv_default_loop(), &conn);
ASSERT(r == 0);

r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
ASSERT(r == 0);

r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
9 deps/uv/test/test-tcp-connect6-error.c
View file
@@ -42,17 +42,18 @@ static void close_cb(uv_handle_t* handle) {


TEST_IMPL(tcp_connect6_error_fault) {
char garbage[] = "blah blah blah blah blah blah blah blah blah blah blah blah";
struct sockaddr_in6* garbage_addr;
const char garbage[] =
"blah blah blah blah blah blah blah blah blah blah blah blah";
const struct sockaddr_in6* garbage_addr;
uv_tcp_t server;
int r;
uv_connect_t req;

garbage_addr = (struct sockaddr_in6*) &garbage;
garbage_addr = (const struct sockaddr_in6*) &garbage;

r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_connect6(&req, &server, *garbage_addr, connect_cb);
r = uv_tcp_connect6(&req, &server, garbage_addr, connect_cb);
ASSERT(r == UV_EINVAL);

uv_close((uv_handle_t*)&server, close_cb);
19 deps/uv/test/test-tcp-open.c
View file
@@ -71,10 +71,13 @@ static uv_os_sock_t create_tcp_socket(void) {
}


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
ASSERT(suggested_size <= sizeof slab);
return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}


@@ -93,12 +96,12 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
}


static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(tcp != NULL);

if (nread >= 0) {
ASSERT(nread == 4);
ASSERT(memcmp("PING", buf.base, nread) == 0);
ASSERT(memcmp("PING", buf->base, nread) == 0);
}
else {
ASSERT(nread == UV_EOF);
@@ -145,11 +148,13 @@ static void connect_cb(uv_connect_t* req, int status) {


TEST_IMPL(tcp_open) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t client;
uv_os_sock_t sock;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

startup();
sock = create_tcp_socket();

@@ -159,7 +164,7 @@ TEST_IMPL(tcp_open) {
r = uv_tcp_open(&client, sock);
ASSERT(r == 0);

r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
ASSERT(r == 0);

uv_run(uv_default_loop(), UV_RUN_DEFAULT);
4 deps/uv/test/test-tcp-read-stop.c
View file
@@ -62,10 +62,10 @@ TEST_IMPL(tcp_read_stop) {
uv_connect_t connect_req;
struct sockaddr_in addr;

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle));
ASSERT(0 == uv_tcp_init(uv_default_loop(), &tcp_handle));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY();

13 deps/uv/test/test-tcp-shutdown-after-write.c
View file
@@ -49,9 +49,12 @@ static void close_cb(uv_handle_t* handle) {
}


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[64];
return uv_buf_init(slab, sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}


@@ -70,7 +73,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
}


static void read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
}


@@ -103,7 +106,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
uv_loop_t* loop;
int r;

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();

r = uv_timer_init(loop, &timer);
@@ -115,7 +118,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
r = uv_tcp_init(loop, &conn);
ASSERT(r == 0);

r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
ASSERT(r == 0);

r = uv_run(loop, UV_RUN_DEFAULT);
14 deps/uv/test/test-tcp-unexpected-read.c
View file
@@ -47,14 +47,14 @@ static void timer_cb(uv_timer_t* handle, int status) {
}


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
ASSERT(0 && "alloc_cb should not have been called");
/* Satisfy the compiler. */
return uv_buf_init(NULL, 0);
}


static void read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
ASSERT(0 && "read_cb should not have been called");
}

@@ -88,7 +88,7 @@ TEST_IMPL(tcp_unexpected_read) {
struct sockaddr_in addr;
uv_loop_t* loop;

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();

ASSERT(0 == uv_timer_init(loop, &timer_handle));
@@ -98,9 +98,9 @@ TEST_IMPL(tcp_unexpected_read) {
ASSERT(0 == uv_tcp_init(loop, &server_handle));
ASSERT(0 == uv_tcp_init(loop, &client_handle));
ASSERT(0 == uv_tcp_init(loop, &peer_handle));
ASSERT(0 == uv_tcp_bind(&server_handle, addr));
ASSERT(0 == uv_tcp_bind(&server_handle, &addr));
ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, &addr, connect_cb));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));

/* This is somewhat inexact but the idea is that the event loop should not
23 deps/uv/test/test-tcp-write-to-half-open-connection.c
View file
@@ -29,8 +29,8 @@
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 void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);

static uv_tcp_t tcp_server;
static uv_tcp_t tcp_client;
@@ -65,13 +65,16 @@ static void connection_cb(uv_stream_t* server, int status) {
}


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[1024];
return uv_buf_init(slab, sizeof slab);
buf->base = slab;
buf->len = sizeof(slab);
}


static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
if (nread < 0) {
fprintf(stderr, "read_cb error: %s\n", uv_err_name(nread));
ASSERT(nread == UV_ECONNRESET || nread == UV_EOF);
@@ -100,16 +103,19 @@ static void write_cb(uv_write_t* req, int status) {


TEST_IMPL(tcp_write_to_half_open_connection) {
struct sockaddr_in addr;
uv_loop_t* loop;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

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));
r = uv_tcp_bind(&tcp_server, &addr);
ASSERT(r == 0);

r = uv_listen((uv_stream_t*)&tcp_server, 1, connection_cb);
@@ -118,10 +124,7 @@ TEST_IMPL(tcp_write_to_half_open_connection) {
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);
r = uv_tcp_connect(&connect_req, &tcp_client, &addr, connect_cb);
ASSERT(r == 0);

r = uv_run(loop, UV_RUN_DEFAULT);
15 deps/uv/test/test-tcp-writealot.c
View file
@@ -46,8 +46,9 @@ static uv_shutdown_t shutdown_req;
static uv_write_t write_reqs[WRITES];


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
return uv_buf_init(malloc(size), size);
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}


@@ -76,7 +77,7 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
}


static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(tcp != NULL);

if (nread >= 0) {
@@ -88,7 +89,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
uv_close((uv_handle_t*)tcp, close_cb);
}

free(buf.base);
free(buf->base);
}


@@ -140,17 +141,19 @@ static void connect_cb(uv_connect_t* req, int status) {


TEST_IMPL(tcp_writealot) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t client;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

send_buffer = calloc(1, TOTAL_BYTES);
ASSERT(send_buffer != NULL);

r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);

r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
ASSERT(r == 0);

uv_run(uv_default_loop(), UV_RUN_DEFAULT);
4 deps/uv/test/test-udp-dgram-too-big.c
View file
@@ -68,9 +68,9 @@ TEST_IMPL(udp_dgram_too_big) {
ASSERT(r == 0);

buf = uv_buf_init(dgram, sizeof dgram);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_udp_send(&req_, &handle_, &buf, 1, addr, send_cb);
r = uv_udp_send(&req_, &handle_, &buf, 1, &addr, send_cb);
ASSERT(r == 0);

ASSERT(close_cb_called == 0);
23 deps/uv/test/test-udp-ipv6.c
View file
@@ -44,10 +44,13 @@ static int recv_cb_called;
static int close_cb_called;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
CHECK_HANDLE(handle);
return uv_buf_init(slab, sizeof slab);
buf->base = slab;
buf->len = sizeof(slab);
}


@@ -67,17 +70,17 @@ static void send_cb(uv_udp_send_t* req, int status) {

static void ipv6_recv_fail(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
ASSERT(0 && "this function should not have been called");
}


static void ipv6_recv_ok(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(nread >= 0);
@@ -100,12 +103,12 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
uv_buf_t buf;
int r;

addr6 = uv_ip6_addr("::0", TEST_PORT);
ASSERT(0 == uv_ip6_addr("::0", TEST_PORT, &addr6));

r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);

r = uv_udp_bind6(&server, addr6, bind_flags);
r = uv_udp_bind6(&server, &addr6, bind_flags);
ASSERT(r == 0);

r = uv_udp_recv_start(&server, alloc_cb, recv_cb);
@@ -115,9 +118,9 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) {
ASSERT(r == 0);

buf = uv_buf_init("PING", 4);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_udp_send(&req_, &client, &buf, 1, addr, send_cb);
r = uv_udp_send(&req_, &client, &buf, 1, &addr, send_cb);
ASSERT(r == 0);

r = uv_timer_init(uv_default_loop(), &timeout);
25 deps/uv/test/test-udp-multicast-join.c
View file
@@ -38,13 +38,14 @@ static int sv_send_cb_called;

static int close_cb_called;

static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];

CHECK_HANDLE(handle);
ASSERT(suggested_size <= sizeof slab);

return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}


@@ -67,8 +68,8 @@ static void sv_send_cb(uv_udp_send_t* req, int status) {

static void cl_recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(flags == 0);
@@ -88,7 +89,7 @@ static void cl_recv_cb(uv_udp_t* handle,

ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(!memcmp("PING", buf.base, nread));
ASSERT(!memcmp("PING", buf->base, nread));

/* we are done with the client handle, we can close it */
uv_close((uv_handle_t*) &client, close_cb);
@@ -99,7 +100,9 @@ TEST_IMPL(udp_multicast_join) {
int r;
uv_udp_send_t req;
uv_buf_t buf;
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@@ -108,7 +111,7 @@ TEST_IMPL(udp_multicast_join) {
ASSERT(r == 0);

/* bind to the desired port */
r = uv_udp_bind(&client, addr, 0);
r = uv_udp_bind(&client, &addr, 0);
ASSERT(r == 0);

/* join the multicast channel */
@@ -121,7 +124,7 @@ TEST_IMPL(udp_multicast_join) {
buf = uv_buf_init("PING", 4);

/* server sends "PING" */
r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
r = uv_udp_send(&req, &server, &buf, 1, &addr, sv_send_cb);
ASSERT(r == 0);

ASSERT(close_cb_called == 0);
8 deps/uv/test/test-udp-multicast-ttl.c
View file
@@ -57,20 +57,22 @@ TEST_IMPL(udp_multicast_ttl) {
int r;
uv_udp_send_t req;
uv_buf_t buf;
struct sockaddr_in addr = uv_ip4_addr("239.255.0.1", TEST_PORT);
struct sockaddr_in addr;

r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);

r = uv_udp_bind(&server, uv_ip4_addr("0.0.0.0", 0), 0);
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));
r = uv_udp_bind(&server, &addr, 0);
ASSERT(r == 0);

r = uv_udp_set_multicast_ttl(&server, 32);
ASSERT(r == 0);

/* server sends "PING" */
buf = uv_buf_init("PING", 4);
r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
ASSERT(0 == uv_ip4_addr("239.255.0.1", TEST_PORT, &addr));
r = uv_udp_send(&req, &server, &buf, 1, &addr, sv_send_cb);
ASSERT(r == 0);

ASSERT(close_cb_called == 0);
23 deps/uv/test/test-udp-open.c
View file
@@ -67,10 +67,13 @@ static uv_os_sock_t create_udp_socket(void) {
}


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
ASSERT(suggested_size <= sizeof slab);
return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}


@@ -82,8 +85,8 @@ static void close_cb(uv_handle_t* handle) {

static void recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
int r;

@@ -102,7 +105,7 @@ static void recv_cb(uv_udp_t* handle,

ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(memcmp("PING", buf.base, nread) == 0);
ASSERT(memcmp("PING", buf->base, nread) == 0);

r = uv_udp_recv_stop(handle);
ASSERT(r == 0);
@@ -120,12 +123,14 @@ static void send_cb(uv_udp_send_t* req, int status) {


TEST_IMPL(udp_open) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_buf_t buf = uv_buf_init("PING", 4);
uv_udp_t client;
uv_os_sock_t sock;
int r;

ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

startup();
sock = create_udp_socket();

@@ -135,13 +140,13 @@ TEST_IMPL(udp_open) {
r = uv_udp_open(&client, sock);
ASSERT(r == 0);

r = uv_udp_bind(&client, addr, 0);
r = uv_udp_bind(&client, &addr, 0);
ASSERT(r == 0);

r = uv_udp_recv_start(&client, alloc_cb, recv_cb);
ASSERT(r == 0);

r = uv_udp_send(&send_req, &client, &buf, 1, addr, send_cb);
r = uv_udp_send(&send_req, &client, &buf, 1, &addr, send_cb);
ASSERT(r == 0);

uv_run(uv_default_loop(), UV_RUN_DEFAULT);
5 deps/uv/test/test-udp-options.c
View file
@@ -29,18 +29,21 @@

TEST_IMPL(udp_options) {
static int invalid_ttls[] = { -1, 0, 256 };
struct sockaddr_in addr;
uv_loop_t* loop;
uv_udp_t h;
int i, r;

ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

loop = uv_default_loop();

r = uv_udp_init(loop, &h);
ASSERT(r == 0);

uv_unref((uv_handle_t*)&h); /* don't keep the loop alive */

r = uv_udp_bind(&h, uv_ip4_addr("0.0.0.0", TEST_PORT), 0);
r = uv_udp_bind(&h, &addr, 0);
ASSERT(r == 0);

r = uv_udp_set_broadcast(&h, 1);
39 deps/uv/test/test-udp-send-and-recv.c
View file
@@ -41,13 +41,14 @@ static int sv_recv_cb_called;
static int close_cb_called;


static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];

CHECK_HANDLE(handle);
ASSERT(suggested_size <= sizeof slab);

return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}


@@ -60,8 +61,8 @@ static void close_cb(uv_handle_t* handle) {

static void cl_recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(flags == 0);
@@ -79,7 +80,7 @@ static void cl_recv_cb(uv_udp_t* handle,

ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(!memcmp("PONG", buf.base, nread));
ASSERT(!memcmp("PONG", buf->base, nread));

cl_recv_cb_called++;

@@ -115,10 +116,11 @@ static void sv_send_cb(uv_udp_send_t* req, int status) {

static void sv_recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* rcvbuf,
const struct sockaddr* addr,
unsigned flags) {
uv_udp_send_t* req;
uv_buf_t sndbuf;
int r;

if (nread < 0) {
@@ -137,7 +139,7 @@ static void sv_recv_cb(uv_udp_t* handle,

ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(!memcmp("PING", buf.base, nread));
ASSERT(!memcmp("PING", rcvbuf->base, nread));

/* FIXME? `uv_udp_recv_stop` does what it says: recv_cb is not called
* anymore. That's problematic because the read buffer won't be returned
@@ -149,13 +151,12 @@ static void sv_recv_cb(uv_udp_t* handle,
req = malloc(sizeof *req);
ASSERT(req != NULL);

buf = uv_buf_init("PONG", 4);

sndbuf = uv_buf_init("PONG", 4);
r = uv_udp_send(req,
handle,
&buf,
&sndbuf,
1,
*(struct sockaddr_in*)addr,
(const struct sockaddr_in*) addr,
sv_send_cb);
ASSERT(r == 0);

@@ -169,26 +170,26 @@ TEST_IMPL(udp_send_and_recv) {
uv_buf_t buf;
int r;

addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));

r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);

r = uv_udp_bind(&server, addr, 0);
r = uv_udp_bind(&server, &addr, 0);
ASSERT(r == 0);

r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb);
ASSERT(r == 0);

addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));

r = uv_udp_init(uv_default_loop(), &client);
ASSERT(r == 0);

/* client sends "PING", expects "PONG" */
buf = uv_buf_init("PING", 4);

r = uv_udp_send(&req, &client, &buf, 1, addr, cl_send_cb);
r = uv_udp_send(&req, &client, &buf, 1, &addr, cl_send_cb);
ASSERT(r == 0);

ASSERT(close_cb_called == 0);
2 src/process_wrap.cc
View file
@@ -232,7 +232,7 @@ class ProcessWrap : public HandleWrap {
options.flags |= UV_PROCESS_DETACHED;
}

int err = uv_spawn(uv_default_loop(), &wrap->process_, options);
int err = uv_spawn(uv_default_loop(), &wrap->process_, &options);

if (err == 0) {
assert(wrap->process_.data == wrap);
51 src/stream_wrap.cc
View file
@@ -127,10 +127,12 @@ void StreamWrap::ReadStop(const FunctionCallbackInfo<Value>& args) {
}


uv_buf_t StreamWrap::OnAlloc(uv_handle_t* handle, size_t suggested_size) {
void StreamWrap::OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
StreamWrap* wrap = static_cast<StreamWrap*>(handle->data);
assert(wrap->stream() == reinterpret_cast<uv_stream_t*>(handle));
return wrap->callbacks()->DoAlloc(handle, suggested_size);
wrap->callbacks()->DoAlloc(handle, suggested_size, buf);
}


@@ -157,7 +159,7 @@ static Local<Object> AcceptHandle(uv_stream_t* pipe) {

void StreamWrap::OnReadCommon(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
HandleScope scope(node_isolate);

@@ -179,13 +181,17 @@ void StreamWrap::OnReadCommon(uv_stream_t* handle,
}


void StreamWrap::OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
void StreamWrap::OnRead(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
OnReadCommon(handle, nread, buf, UV_UNKNOWN_HANDLE);
}


void StreamWrap::OnRead2(uv_pipe_t* handle, ssize_t nread, uv_buf_t buf,
uv_handle_type pending) {
void StreamWrap::OnRead2(uv_pipe_t* handle,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending) {
OnReadCommon(reinterpret_cast<uv_stream_t*>(handle), nread, buf, pending);
}

@@ -544,20 +550,23 @@ void StreamWrapCallbacks::AfterWrite(WriteWrap* w) {
}


uv_buf_t StreamWrapCallbacks::DoAlloc(uv_handle_t* handle,
size_t suggested_size) {
char* data = static_cast<char*>(malloc(suggested_size));
if (data == NULL && suggested_size > 0) {
FatalError("node::StreamWrapCallbacks::DoAlloc(uv_handle_t*, size_t)",
"Out Of Memory");
void StreamWrapCallbacks::DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = static_cast<char*>(malloc(suggested_size));
buf->len = suggested_size;

if (buf->base == NULL && suggested_size > 0) {
FatalError(
"node::StreamWrapCallbacks::DoAlloc(uv_handle_t*, size_t, uv_buf_t*)",
"Out Of Memory");
}
return uv_buf_init(data, suggested_size);
}


void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
HandleScope scope(node_isolate);

@@ -568,21 +577,21 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
};

if (nread < 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
MakeCallback(Self(), onread_sym, ARRAY_SIZE(argv), argv);
return;
}

if (nread == 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
return;
}

buf.base = static_cast<char*>(realloc(buf.base, nread));
assert(static_cast<size_t>(nread) <= buf.len);
argv[1] = Buffer::Use(buf.base, nread);
char* base = static_cast<char*>(realloc(buf->base, nread));
assert(static_cast<size_t>(nread) <= buf->len);
argv[1] = Buffer::Use(base, nread);

Local<Object> pending_obj;
if (pending == UV_TCP) {
26 src/stream_wrap.h
View file
@@ -79,10 +79,12 @@ class StreamWrapCallbacks {
uv_stream_t* send_handle,
uv_write_cb cb);
virtual void AfterWrite(WriteWrap* w);
virtual uv_buf_t DoAlloc(uv_handle_t* handle, size_t suggested_size);
virtual void DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
virtual void DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending);
virtual int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);

@@ -161,14 +163,22 @@ class StreamWrap : public HandleWrap {
private:
// Callbacks for libuv
static void AfterWrite(uv_write_t* req, int status);
static uv_buf_t OnAlloc(uv_handle_t* handle, size_t suggested_size);
static void OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
static void AfterShutdown(uv_shutdown_t* req, int status);

static void OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf);
static void OnRead2(uv_pipe_t* handle, ssize_t nread, uv_buf_t buf,
uv_handle_type pending);
static void OnReadCommon(uv_stream_t* handle, ssize_t nread,
uv_buf_t buf, uv_handle_type pending);
static void OnRead(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf);
static void OnRead2(uv_pipe_t* handle,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending);
static void OnReadCommon(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending);

template <enum encoding encoding>
static void WriteStringImpl(const v8::FunctionCallbackInfo<v8::Value>& args);
49 src/tcp_wrap.cc
View file
@@ -269,8 +269,10 @@ void TCPWrap::Bind(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip_address(args[0]);
int port = args[1]->Int32Value();

struct sockaddr_in address = uv_ip4_addr(*ip_address, port);
int err = uv_tcp_bind(&wrap->handle_, address);
sockaddr_in addr;
int err = uv_ip4_addr(*ip_address, port, &addr);
if (err == 0)
err = uv_tcp_bind(&wrap->handle_, &addr);

args.GetReturnValue().Set(err);
}
@@ -285,8 +287,10 @@ void TCPWrap::Bind6(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip6_address(args[0]);
int port = args[1]->Int32Value();

struct sockaddr_in6 address = uv_ip6_addr(*ip6_address, port);
int err = uv_tcp_bind6(&wrap->handle_, address);
sockaddr_in6 addr;
int err = uv_ip6_addr(*ip6_address, port, &addr);
if (err == 0)
err = uv_tcp_bind6(&wrap->handle_, &addr);

args.GetReturnValue().Set(err);
}
@@ -378,19 +382,15 @@ void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip_address(args[1]);
int port = args[2]->Uint32Value();

struct sockaddr_in address = uv_ip4_addr(*ip_address, port);
sockaddr_in addr;
int err = uv_ip4_addr(*ip_address, port, &addr);

// I hate when people program C++ like it was C, and yet I do it too.
// I'm too lazy to come up with the perfect class hierarchy here. Let's
// just do some type munging.
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);

int err = uv_tcp_connect(&req_wrap->req_,
&wrap->handle_,
address,
AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
if (err == 0) {
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
err = uv_tcp_connect(&req_wrap->req_, &wrap->handle_, &addr, AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
}

args.GetReturnValue().Set(err);
}
@@ -410,16 +410,15 @@ void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip_address(args[1]);
int port = args[2]->Int32Value();

struct sockaddr_in6 address = uv_ip6_addr(*ip_address, port);
sockaddr_in6 addr;
int err = uv_ip6_addr(*ip_address, port, &addr);

ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);

int err = uv_tcp_connect6(&req_wrap->req_,
&wrap->handle_,
address,
AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
if (err == 0) {
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
err = uv_tcp_connect6(&req_wrap->req_, &wrap->handle_, &addr, AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
}

args.GetReturnValue().Set(err);
}
11 src/tls_wrap.cc
View file
@@ -512,16 +512,17 @@ void TLSCallbacks::AfterWrite(WriteWrap* w) {
}


uv_buf_t TLSCallbacks::DoAlloc(uv_handle_t* handle, size_t suggested_size) {
size_t size = suggested_size;
char* data = NodeBIO::FromBIO(enc_in_)->PeekWritable(&size);
return uv_buf_init(data, size);
void TLSCallbacks::DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = NodeBIO::FromBIO(enc_in_)->PeekWritable(&suggested_size);
buf->len = suggested_size;
}


void TLSCallbacks::DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
if (nread < 0) {
// Error should be emitted only after all data was read
6 src/tls_wrap.h
View file
@@ -50,10 +50,12 @@ class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
uv_stream_t* send_handle,
uv_write_cb cb);
void AfterWrite(WriteWrap* w);
uv_buf_t DoAlloc(uv_handle_t* handle, size_t suggested_size);
void DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
void DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending);
int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);

90 src/udp_wrap.cc
View file
@@ -159,11 +159,21 @@ void UDPWrap::DoBind(const FunctionCallbackInfo<Value>& args, int family) {

switch (family) {
case AF_INET:
err = uv_udp_bind(&wrap->handle_, uv_ip4_addr(*address, port), flags);
break;
{
sockaddr_in addr;
err = uv_ip4_addr(*address, port, &addr);
if (err == 0)
err = uv_udp_bind(&wrap->handle_, &addr, flags);
break;
}
case AF_INET6:
err = uv_udp_bind6(&wrap->handle_, uv_ip6_addr(*address, port), flags);
break;
{
sockaddr_in6 addr;
err = uv_ip6_addr(*address, port, &addr);
if (err == 0)
err = uv_udp_bind6(&wrap->handle_, &addr, flags);
break;
}
default:
assert(0 && "unexpected address family");
abort();
@@ -270,21 +280,33 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {

switch (family) {
case AF_INET:
err = uv_udp_send(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
uv_ip4_addr(*address, port),
OnSend);
break;
{
sockaddr_in addr;
err = uv_ip4_addr(*address, port, &addr);
if (err == 0) {
err = uv_udp_send(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
&addr,
OnSend);
}
break;
}
case AF_INET6:
err = uv_udp_send6(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
uv_ip6_addr(*address, port),
OnSend);
break;
{
sockaddr_in6 addr;
err = uv_ip6_addr(*address, port, &addr);
if (err == 0) {
err = uv_udp_send6(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
&addr,
OnSend);
}
break;
}
default:
assert(0 && "unexpected address family");
abort();
@@ -365,24 +387,27 @@ void UDPWrap::OnSend(uv_udp_send_t* req, int status) {
}


uv_buf_t UDPWrap::OnAlloc(uv_handle_t* handle, size_t suggested_size) {
char* data = static_cast<char*>(malloc(suggested_size));
if (data == NULL && suggested_size > 0) {
FatalError("node::UDPWrap::OnAlloc(uv_handle_t*, size_t)",
void UDPWrap::OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = static_cast<char*>(malloc(suggested_size));
buf->len = suggested_size;

if (buf->base == NULL && suggested_size > 0) {
FatalError("node::UDPWrap::OnAlloc(uv_handle_t*, size_t, uv_buf_t*)",
"Out Of Memory");
}
return uv_buf_init(data, suggested_size);
}


void UDPWrap::OnRecv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
unsigned flags) {
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned int flags) {
if (nread == 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
return;
}

@@ -398,15 +423,14 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
};

if (nread < 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
return;
}

buf.base = static_cast<char*>(realloc(buf.base, nread));

argv[2] = Buffer::Use(buf.base, nread);
char* base = static_cast<char*>(realloc(buf->base, nread));
argv[2] = Buffer::Use(base, nread);
argv[3] = AddressToJS(addr);
MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
}
10 src/udp_wrap.h
View file
@@ -64,13 +64,15 @@ class UDPWrap: public HandleWrap {
static void SetMembership(const v8::FunctionCallbackInfo<v8::Value>& args,
uv_membership membership);

static uv_buf_t OnAlloc(uv_handle_t* handle, size_t suggested_size);
static void OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
static void OnSend(uv_udp_send_t* req, int status);
static void OnRecv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
unsigned flags);
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned int flags);

uv_udp_t handle_;
};