From ed8d97f572fab15025da0c762e5edfbcbe45f425 Mon Sep 17 00:00:00 2001 From: Ben Noordhuis Date: Tue, 3 Sep 2013 00:42:59 +0200 Subject: [PATCH] uv: upgrade to v0.11.12 * upgrade deps/uv/ to v0.11.12. * update files in src/ after a libuv API change. --- deps/uv/ChangeLog | 35 +++- deps/uv/include/uv-unix.h | 6 +- deps/uv/include/uv.h | 101 +++++++---- deps/uv/src/unix/process.c | 46 ++--- deps/uv/src/unix/stream.c | 81 +++++---- deps/uv/src/unix/tcp.c | 55 ++---- deps/uv/src/unix/udp.c | 130 +++---------- deps/uv/src/uv-common.c | 147 ++++++++------- deps/uv/src/uv-common.h | 33 ++-- deps/uv/src/version.c | 2 +- deps/uv/src/win/fs.c | 13 +- deps/uv/src/win/internal.h | 14 +- deps/uv/src/win/pipe.c | 59 +++--- deps/uv/src/win/process-stdio.c | 7 +- deps/uv/src/win/process.c | 54 +++--- deps/uv/src/win/stream-inl.h | 12 +- deps/uv/src/win/stream.c | 29 ++- deps/uv/src/win/tcp.c | 180 ++++++++---------- deps/uv/src/win/tty.c | 52 +++--- deps/uv/src/win/udp.c | 201 ++++++++++----------- deps/uv/src/win/winapi.h | 2 +- deps/uv/src/win/winsock.c | 10 +- deps/uv/test/benchmark-multi-accept.c | 42 +++-- deps/uv/test/benchmark-ping-pongs.c | 46 ++--- deps/uv/test/benchmark-pound.c | 23 ++- deps/uv/test/benchmark-pump.c | 44 +++-- deps/uv/test/benchmark-spawn.c | 14 +- deps/uv/test/benchmark-tcp-write-batch.c | 4 +- deps/uv/test/benchmark-udp-pummel.c | 28 +-- deps/uv/test/blackhole-server.c | 19 +- deps/uv/test/dns-server.c | 42 +++-- deps/uv/test/echo-server.c | 52 ++++-- deps/uv/test/test-callback-stack.c | 20 +- deps/uv/test/test-connection-fail.c | 8 +- deps/uv/test/test-delayed-accept.c | 24 +-- deps/uv/test/test-embed.c | 5 +- deps/uv/test/test-getsockname.c | 48 +++-- deps/uv/test/test-ip6-addr.c | 2 +- deps/uv/test/test-ipc-send-recv.c | 24 ++- deps/uv/test/test-ipc.c | 110 ++++++----- deps/uv/test/test-multiple-listen.c | 11 +- deps/uv/test/test-osx-select.c | 10 +- deps/uv/test/test-ping-pong.c | 37 ++-- deps/uv/test/test-poll.c | 14 +- deps/uv/test/test-ref.c | 22 ++- deps/uv/test/test-shutdown-close.c | 5 +- deps/uv/test/test-shutdown-eof.c | 24 ++- deps/uv/test/test-spawn.c | 52 +++--- deps/uv/test/test-stdio-over-pipes.c | 27 +-- deps/uv/test/test-tcp-bind-error.c | 39 ++-- deps/uv/test/test-tcp-bind6-error.c | 34 ++-- deps/uv/test/test-tcp-close-while-connecting.c | 5 +- deps/uv/test/test-tcp-close.c | 15 +- deps/uv/test/test-tcp-connect-error-after-write.c | 4 +- deps/uv/test/test-tcp-connect-error.c | 9 +- deps/uv/test/test-tcp-connect-timeout.c | 4 +- deps/uv/test/test-tcp-connect6-error.c | 9 +- deps/uv/test/test-tcp-open.c | 19 +- deps/uv/test/test-tcp-read-stop.c | 4 +- deps/uv/test/test-tcp-shutdown-after-write.c | 13 +- deps/uv/test/test-tcp-unexpected-read.c | 14 +- .../test/test-tcp-write-to-half-open-connection.c | 23 ++- deps/uv/test/test-tcp-writealot.c | 15 +- deps/uv/test/test-udp-dgram-too-big.c | 4 +- deps/uv/test/test-udp-ipv6.c | 23 ++- deps/uv/test/test-udp-multicast-join.c | 25 +-- deps/uv/test/test-udp-multicast-ttl.c | 8 +- deps/uv/test/test-udp-open.c | 23 ++- deps/uv/test/test-udp-options.c | 5 +- deps/uv/test/test-udp-send-and-recv.c | 39 ++-- src/process_wrap.cc | 2 +- src/stream_wrap.cc | 51 +++--- src/stream_wrap.h | 26 ++- src/tcp_wrap.cc | 49 +++-- src/tls_wrap.cc | 11 +- src/tls_wrap.h | 6 +- src/udp_wrap.cc | 90 +++++---- src/udp_wrap.h | 10 +- 78 files changed, 1407 insertions(+), 1198 deletions(-) diff --git a/deps/uv/ChangeLog b/deps/uv/ChangeLog index ba73c14..93af51f 100644 --- a/deps/uv/ChangeLog +++ b/deps/uv/ChangeLog @@ -1,4 +1,37 @@ -2013.08.30, Version 0.11.11 (Unstable) +2013.09.03, Version 0.11.12 (Unstable) + +Changes since version 0.11.11: + +* test: fix epoll_wait() usage in test-embed.c (Ben Noordhuis) + +* include: uv_alloc_cb now takes uv_buf_t* (Ben Noordhuis) + +* include: uv_read{2}_cb now takes const uv_buf_t* (Ben Noordhuis) + +* include: uv_ip[46]_addr now takes sockaddr_in* (Ben Noordhuis) + +* include: uv_tcp_bind{6} now takes sockaddr_in* (Ben Noordhuis) + +* include: uv_tcp_connect{6} now takes sockaddr_in* (Ben Noordhuis) + +* include: uv_udp_recv_cb now takes const uv_buf_t* (Ben Noordhuis) + +* include: uv_udp_bind{6} now takes sockaddr_in* (Ben Noordhuis) + +* include: uv_udp_send{6} now takes sockaddr_in* (Ben Noordhuis) + +* include: uv_spawn takes const uv_process_options_t* (Ben Noordhuis) + +* include: make uv_write{2} const correct (Ben Noordhuis) + +* windows: fix flags assignment in uv_fs_readdir() (Ben Noordhuis) + +* windows: fix stray comments (Ben Noordhuis) + +* windows: remove unused is_path_dir() function (Ben Noordhuis) + + +2013.08.30, Version 0.11.11 (Unstable), ba876d53539ed0427c52039012419cd9374c6f0d Changes since version 0.11.10: diff --git a/deps/uv/include/uv-unix.h b/deps/uv/include/uv-unix.h index 408b44c..38c1853 100644 --- a/deps/uv/include/uv-unix.h +++ b/deps/uv/include/uv-unix.h @@ -199,9 +199,9 @@ typedef struct { #define UV_WRITE_PRIVATE_FIELDS \ void* queue[2]; \ - int write_index; \ + unsigned int write_index; \ uv_buf_t* bufs; \ - int bufcnt; \ + unsigned int nbufs; \ int error; \ uv_buf_t bufsml[4]; \ @@ -213,7 +213,7 @@ typedef struct { #define UV_UDP_SEND_PRIVATE_FIELDS \ void* queue[2]; \ struct sockaddr_in6 addr; \ - int bufcnt; \ + unsigned int nbufs; \ uv_buf_t* bufs; \ ssize_t status; \ uv_udp_send_cb send_cb; \ diff --git a/deps/uv/include/uv.h b/deps/uv/include/uv.h index 5700f94..fcef08b 100644 --- a/deps/uv/include/uv.h +++ b/deps/uv/include/uv.h @@ -338,7 +338,7 @@ UV_EXTERN int uv_backend_timeout(const uv_loop_t*); /* - * Should return a buffer that libuv can use to read data into. + * Should prepare a buffer that libuv can use to read data into. * * `suggested_size` is a hint. Returning a buffer that is smaller is perfectly * okay as long as `buf.len > 0`. @@ -349,7 +349,9 @@ UV_EXTERN int uv_backend_timeout(const uv_loop_t*); * Note that returning a zero-length buffer does not stop the handle, call * uv_read_stop() or uv_udp_recv_stop() for that. */ -typedef uv_buf_t (*uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size); +typedef void (*uv_alloc_cb)(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf); /* * `nread` is > 0 if there is data available, 0 if libuv is done reading for @@ -359,18 +361,22 @@ typedef uv_buf_t (*uv_alloc_cb)(uv_handle_t* handle, size_t suggested_size); * Trying to read from the stream again is undefined. * * The callee is responsible for freeing the buffer, libuv does not reuse it. - * The buffer may be a null buffer (where buf.base=NULL and buf.len=0) on EOF - * or error. + * The buffer may be a null buffer (where buf->base=NULL and buf->len=0) on + * EOF or error. */ -typedef void (*uv_read_cb)(uv_stream_t* stream, ssize_t nread, uv_buf_t buf); +typedef void (*uv_read_cb)(uv_stream_t* stream, + ssize_t nread, + const uv_buf_t* buf); /* * Just like the uv_read_cb except that if the pending parameter is true * then you can use uv_accept() to pull the new handle into the process. * If no handle is pending then pending will be UV_UNKNOWN_HANDLE. */ -typedef void (*uv_read2_cb)(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf, - uv_handle_type pending); +typedef void (*uv_read2_cb)(uv_pipe_t* pipe, + ssize_t nread, + const uv_buf_t* buf, + uv_handle_type pending); typedef void (*uv_write_cb)(uv_write_t* req, int status); typedef void (*uv_connect_cb)(uv_connect_t* req, int status); @@ -648,8 +654,11 @@ UV_EXTERN int uv_read2_start(uv_stream_t*, uv_alloc_cb alloc_cb, * uv_write(&req2, stream, b, 2); * */ -UV_EXTERN int uv_write(uv_write_t* req, uv_stream_t* handle, - uv_buf_t bufs[], int bufcnt, uv_write_cb cb); +UV_EXTERN int uv_write(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb); /* * Extended write function for sending handles over a pipe. The pipe must be @@ -658,8 +667,12 @@ UV_EXTERN int uv_write(uv_write_t* req, uv_stream_t* handle, * (listening or connected state). Bound sockets or pipes will be assumed to * be servers. */ -UV_EXTERN int uv_write2(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], - int bufcnt, uv_stream_t* send_handle, uv_write_cb cb); +UV_EXTERN int uv_write2(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle, + uv_write_cb cb); /* uv_write_t is a subclass of uv_req_t */ struct uv_write_s { @@ -753,8 +766,9 @@ UV_EXTERN int uv_tcp_keepalive(uv_tcp_t* handle, */ UV_EXTERN int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable); -UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in); -UV_EXTERN int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6); +UV_EXTERN int uv_tcp_bind(uv_tcp_t* handle, const struct sockaddr_in* addr); +UV_EXTERN int uv_tcp_bind6(uv_tcp_t* handle, const struct sockaddr_in6* addr); + UV_EXTERN int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen); UV_EXTERN int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name, @@ -766,10 +780,15 @@ UV_EXTERN int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name, * initialized TCP handle and an uninitialized uv_connect_t*. The callback * will be made when the connection is established. */ -UV_EXTERN int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle, - struct sockaddr_in address, uv_connect_cb cb); -UV_EXTERN int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle, - struct sockaddr_in6 address, uv_connect_cb cb); +UV_EXTERN int uv_tcp_connect(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr_in* addr, + uv_connect_cb cb); + +UV_EXTERN int uv_tcp_connect6(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr_in6* addr, + uv_connect_cb cb); /* uv_connect_t is a subclass of uv_req_t */ struct uv_connect_s { @@ -814,8 +833,11 @@ typedef void (*uv_udp_send_cb)(uv_udp_send_t* req, int status); * flags One or more OR'ed UV_UDP_* constants. * Right now only UV_UDP_PARTIAL is used. */ -typedef void (*uv_udp_recv_cb)(uv_udp_t* handle, ssize_t nread, uv_buf_t buf, - struct sockaddr* addr, unsigned flags); +typedef void (*uv_udp_recv_cb)(uv_udp_t* handle, + ssize_t nread, + const uv_buf_t* buf, + const struct sockaddr* addr, + unsigned flags); /* uv_udp_t is a subclass of uv_handle_t */ struct uv_udp_s { @@ -875,8 +897,9 @@ UV_EXTERN int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock); * This behavior is something of an anomaly and may be replaced by an explicit * opt-in mechanism in future versions of libuv. */ -UV_EXTERN int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr, - unsigned flags); +UV_EXTERN int uv_udp_bind(uv_udp_t* handle, + const struct sockaddr_in* addr, + unsigned flags); /* * Bind to a IPv6 address and port. @@ -889,8 +912,9 @@ UV_EXTERN int uv_udp_bind(uv_udp_t* handle, struct sockaddr_in addr, * Returns: * 0 on success, or an error code < 0 on failure. */ -UV_EXTERN int uv_udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, - unsigned flags); +UV_EXTERN int uv_udp_bind6(uv_udp_t* handle, + const struct sockaddr_in6* addr, + unsigned flags); UV_EXTERN int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name, int* namelen); @@ -974,16 +998,19 @@ UV_EXTERN int uv_udp_set_ttl(uv_udp_t* handle, int ttl); * req UDP request handle. Need not be initialized. * handle UDP handle. Should have been initialized with `uv_udp_init`. * bufs List of buffers to send. - * bufcnt Number of buffers in `bufs`. + * nbufs Number of buffers in `bufs`. * addr Address of the remote peer. See `uv_ip4_addr`. * send_cb Callback to invoke when the data has been sent out. * * Returns: * 0 on success, or an error code < 0 on failure. */ -UV_EXTERN int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle, - uv_buf_t bufs[], int bufcnt, struct sockaddr_in addr, - uv_udp_send_cb send_cb); +UV_EXTERN int uv_udp_send(uv_udp_send_t* req, + uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr_in* addr, + uv_udp_send_cb send_cb); /* * Send data. If the socket has not previously been bound with `uv_udp_bind6`, @@ -993,16 +1020,19 @@ UV_EXTERN int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle, * req UDP request handle. Need not be initialized. * handle UDP handle. Should have been initialized with `uv_udp_init`. * bufs List of buffers to send. - * bufcnt Number of buffers in `bufs`. + * nbufs Number of buffers in `bufs`. * addr Address of the remote peer. See `uv_ip6_addr`. * send_cb Callback to invoke when the data has been sent out. * * Returns: * 0 on success, or an error code < 0 on failure. */ -UV_EXTERN int uv_udp_send6(uv_udp_send_t* req, uv_udp_t* handle, - uv_buf_t bufs[], int bufcnt, struct sockaddr_in6 addr, - uv_udp_send_cb send_cb); +UV_EXTERN int uv_udp_send6(uv_udp_send_t* req, + uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr_in6* addr, + uv_udp_send_cb send_cb); /* * Receive data. If the socket has not previously been bound with `uv_udp_bind` @@ -1479,8 +1509,9 @@ struct uv_process_s { }; /* Initializes uv_process_t and starts the process. */ -UV_EXTERN int uv_spawn(uv_loop_t*, uv_process_t*, - uv_process_options_t options); +UV_EXTERN int uv_spawn(uv_loop_t* loop, + uv_process_t* handle, + const uv_process_options_t* options); /* @@ -1872,8 +1903,8 @@ UV_EXTERN int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle, /* Utility */ /* Convert string ip addresses to binary structures */ -UV_EXTERN struct sockaddr_in uv_ip4_addr(const char* ip, int port); -UV_EXTERN struct sockaddr_in6 uv_ip6_addr(const char* ip, int port); +UV_EXTERN int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr); +UV_EXTERN int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr); /* Convert binary addresses to strings */ UV_EXTERN int uv_ip4_name(struct sockaddr_in* src, char* dst, size_t size); diff --git a/deps/uv/src/unix/process.c b/deps/uv/src/unix/process.c index a9ecb45..990ea15 100644 --- a/deps/uv/src/unix/process.c +++ b/deps/uv/src/unix/process.c @@ -183,7 +183,7 @@ skip: /* - * Used for initializing stdio streams like options.stdin_stream. Returns + * Used for initializing stdio streams like options->stdin_stream. Returns * zero on success. */ static int uv__process_init_stdio(uv_stdio_container_t* container, int fds[2]) { @@ -270,7 +270,7 @@ static void uv__write_int(int fd, int val) { } -static void uv__process_child_init(uv_process_options_t options, +static void uv__process_child_init(const uv_process_options_t* options, int stdio_count, int (*pipes)[2], int error_fd) { @@ -278,7 +278,7 @@ static void uv__process_child_init(uv_process_options_t options, int use_fd; int fd; - if (options.flags & UV_PROCESS_DETACHED) + if (options->flags & UV_PROCESS_DETACHED) setsid(); for (fd = 0; fd < stdio_count; fd++) { @@ -313,29 +313,29 @@ static void uv__process_child_init(uv_process_options_t options, uv__nonblock(fd, 0); } - if (options.cwd && chdir(options.cwd)) { + if (options->cwd != NULL && chdir(options->cwd)) { uv__write_int(error_fd, -errno); perror("chdir()"); _exit(127); } - if ((options.flags & UV_PROCESS_SETGID) && setgid(options.gid)) { + if ((options->flags & UV_PROCESS_SETGID) && setgid(options->gid)) { uv__write_int(error_fd, -errno); perror("setgid()"); _exit(127); } - if ((options.flags & UV_PROCESS_SETUID) && setuid(options.uid)) { + if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid)) { uv__write_int(error_fd, -errno); perror("setuid()"); _exit(127); } - if (options.env) { - environ = options.env; + if (options->env != NULL) { + environ = options->env; } - execvp(options.file, options.args); + execvp(options->file, options->args); uv__write_int(error_fd, -errno); perror("execvp()"); _exit(127); @@ -344,7 +344,7 @@ static void uv__process_child_init(uv_process_options_t options, int uv_spawn(uv_loop_t* loop, uv_process_t* process, - const uv_process_options_t options) { + const uv_process_options_t* options) { int signal_pipe[2] = { -1, -1 }; int (*pipes)[2]; int stdio_count; @@ -354,17 +354,17 @@ int uv_spawn(uv_loop_t* loop, int err; int i; - assert(options.file != NULL); - assert(!(options.flags & ~(UV_PROCESS_DETACHED | - UV_PROCESS_SETGID | - UV_PROCESS_SETUID | - UV_PROCESS_WINDOWS_HIDE | - UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); + assert(options->file != NULL); + assert(!(options->flags & ~(UV_PROCESS_DETACHED | + UV_PROCESS_SETGID | + UV_PROCESS_SETUID | + UV_PROCESS_WINDOWS_HIDE | + UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS); QUEUE_INIT(&process->queue); - stdio_count = options.stdio_count; + stdio_count = options->stdio_count; if (stdio_count < 3) stdio_count = 3; @@ -378,8 +378,8 @@ int uv_spawn(uv_loop_t* loop, pipes[i][1] = -1; } - for (i = 0; i < options.stdio_count; i++) { - err = uv__process_init_stdio(options.stdio + i, pipes[i]); + for (i = 0; i < options->stdio_count; i++) { + err = uv__process_init_stdio(options->stdio + i, pipes[i]); if (err) goto error; } @@ -442,13 +442,13 @@ int uv_spawn(uv_loop_t* loop, close(signal_pipe[0]); - for (i = 0; i < options.stdio_count; i++) { - err = uv__process_open_stream(options.stdio + i, pipes[i], i == 0); + for (i = 0; i < options->stdio_count; i++) { + err = uv__process_open_stream(options->stdio + i, pipes[i], i == 0); if (err == 0) continue; while (i--) - uv__process_close_stream(options.stdio + i); + uv__process_close_stream(options->stdio + i); goto error; } @@ -457,7 +457,7 @@ int uv_spawn(uv_loop_t* loop, QUEUE_INSERT_TAIL(q, &process->queue); process->pid = pid; - process->exit_cb = options.exit_cb; + process->exit_cb = options->exit_cb; uv__handle_start(process); free(pipes); diff --git a/deps/uv/src/unix/stream.c b/deps/uv/src/unix/stream.c index 5f42c34..c8e9f6d 100644 --- a/deps/uv/src/unix/stream.c +++ b/deps/uv/src/unix/stream.c @@ -93,15 +93,15 @@ static int uv__open_cloexec(const char* path, int flags) { } -static size_t uv__buf_count(uv_buf_t bufs[], int bufcnt) { - size_t total = 0; - int i; +static size_t uv_count_bufs(const uv_buf_t bufs[], unsigned int nbufs) { + unsigned int i; + size_t bytes; - for (i = 0; i < bufcnt; i++) { - total += bufs[i].len; - } + bytes = 0; + for (i = 0; i < nbufs; i++) + bytes += bufs[i].len; - return total; + return bytes; } @@ -656,8 +656,8 @@ static size_t uv__write_req_size(uv_write_t* req) { size_t size; assert(req->bufs != NULL); - size = uv__buf_count(req->bufs + req->write_index, - req->bufcnt - req->write_index); + size = uv_count_bufs(req->bufs + req->write_index, + req->nbufs - req->write_index); assert(req->handle->write_queue_size >= size); return size; @@ -742,7 +742,7 @@ start: */ assert(sizeof(uv_buf_t) == sizeof(struct iovec)); iov = (struct iovec*) &(req->bufs[req->write_index]); - iovcnt = req->bufcnt - req->write_index; + iovcnt = req->nbufs - req->write_index; iovmax = uv__getiovmax(); @@ -819,7 +819,7 @@ start: uv_buf_t* buf = &(req->bufs[req->write_index]); size_t len = buf->len; - assert(req->write_index < req->bufcnt); + assert(req->write_index < req->nbufs); if ((size_t)n < len) { buf->base += n; @@ -849,7 +849,7 @@ start: assert(stream->write_queue_size >= len); stream->write_queue_size -= len; - if (req->write_index == req->bufcnt) { + if (req->write_index == req->nbufs) { /* Then we're done! */ assert(n == 0); uv__write_req_finish(req); @@ -938,7 +938,7 @@ static uv_handle_type uv__handle_type(int fd) { static void uv__stream_read_cb(uv_stream_t* stream, int status, - uv_buf_t buf, + const uv_buf_t* buf, uv_handle_type type) { if (stream->read_cb != NULL) stream->read_cb(stream, status, buf); @@ -947,7 +947,7 @@ static void uv__stream_read_cb(uv_stream_t* stream, } -static void uv__stream_eof(uv_stream_t* stream, uv_buf_t buf) { +static void uv__stream_eof(uv_stream_t* stream, const uv_buf_t* buf) { stream->flags |= UV_STREAM_READ_EOF; uv__io_stop(stream->loop, &stream->io_watcher, UV__POLLIN); if (!uv__io_active(&stream->io_watcher, UV__POLLOUT)) @@ -979,10 +979,10 @@ static void uv__read(uv_stream_t* stream) { && (count-- > 0)) { assert(stream->alloc_cb != NULL); - buf = stream->alloc_cb((uv_handle_t*)stream, 64 * 1024); + stream->alloc_cb((uv_handle_t*)stream, 64 * 1024, &buf); if (buf.len == 0) { /* User indicates it can't or won't handle the read. */ - uv__stream_read_cb(stream, UV_ENOBUFS, buf, UV_UNKNOWN_HANDLE); + uv__stream_read_cb(stream, UV_ENOBUFS, &buf, UV_UNKNOWN_HANDLE); return; } @@ -1019,23 +1019,23 @@ static void uv__read(uv_stream_t* stream) { if (stream->flags & UV_STREAM_READING) { uv__io_start(stream->loop, &stream->io_watcher, UV__POLLIN); } - uv__stream_read_cb(stream, 0, buf, UV_UNKNOWN_HANDLE); + uv__stream_read_cb(stream, 0, &buf, UV_UNKNOWN_HANDLE); } else { /* Error. User should call uv_close(). */ - uv__stream_read_cb(stream, -errno, buf, UV_UNKNOWN_HANDLE); + uv__stream_read_cb(stream, -errno, &buf, UV_UNKNOWN_HANDLE); assert(!uv__io_active(&stream->io_watcher, UV__POLLIN) && "stream->read_cb(status=-1) did not call uv_close()"); } return; } else if (nread == 0) { - uv__stream_eof(stream, buf); + uv__stream_eof(stream, &buf); return; } else { /* Successful read */ ssize_t buflen = buf.len; if (stream->read_cb) { - stream->read_cb(stream, nread, buf); + stream->read_cb(stream, nread, &buf); } else { assert(stream->read2_cb); @@ -1070,10 +1070,12 @@ static void uv__read(uv_stream_t* stream) { if (stream->accepted_fd >= 0) { - stream->read2_cb((uv_pipe_t*)stream, nread, buf, - uv__handle_type(stream->accepted_fd)); + stream->read2_cb((uv_pipe_t*) stream, + nread, + &buf, + uv__handle_type(stream->accepted_fd)); } else { - stream->read2_cb((uv_pipe_t*)stream, nread, buf, UV_UNKNOWN_HANDLE); + stream->read2_cb((uv_pipe_t*) stream, nread, &buf, UV_UNKNOWN_HANDLE); } } @@ -1147,7 +1149,7 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) { (stream->flags & UV_STREAM_READ_PARTIAL) && !(stream->flags & UV_STREAM_READ_EOF)) { uv_buf_t buf = { NULL, 0 }; - uv__stream_eof(stream, buf); + uv__stream_eof(stream, &buf); } if (uv__stream_fd(stream) == -1) @@ -1205,13 +1207,13 @@ static void uv__stream_connect(uv_stream_t* stream) { int uv_write2(uv_write_t* req, uv_stream_t* stream, - uv_buf_t bufs[], - int bufcnt, + const uv_buf_t bufs[], + unsigned int nbufs, uv_stream_t* send_handle, uv_write_cb cb) { int empty_queue; - assert(bufcnt > 0); + assert(nbufs > 0); assert((stream->type == UV_TCP || stream->type == UV_NAMED_PIPE || stream->type == UV_TTY) && @@ -1250,15 +1252,17 @@ int uv_write2(uv_write_t* req, req->send_handle = send_handle; QUEUE_INIT(&req->queue); - if (bufcnt <= (int) ARRAY_SIZE(req->bufsml)) - req->bufs = req->bufsml; - else - req->bufs = malloc(sizeof(uv_buf_t) * bufcnt); + req->bufs = req->bufsml; + if (nbufs > ARRAY_SIZE(req->bufsml)) + req->bufs = malloc(nbufs * sizeof(bufs[0])); + + if (req->bufs == NULL) + return -ENOMEM; - memcpy(req->bufs, bufs, bufcnt * sizeof(uv_buf_t)); - req->bufcnt = bufcnt; + memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0])); + req->nbufs = nbufs; req->write_index = 0; - stream->write_queue_size += uv__buf_count(bufs, bufcnt); + stream->write_queue_size += uv_count_bufs(bufs, nbufs); /* Append the request to write_queue. */ QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue); @@ -1290,9 +1294,12 @@ int uv_write2(uv_write_t* req, /* The buffers to be written must remain valid until the callback is called. * This is not required for the uv_buf_t array. */ -int uv_write(uv_write_t* req, uv_stream_t* stream, uv_buf_t bufs[], int bufcnt, - uv_write_cb cb) { - return uv_write2(req, stream, bufs, bufcnt, NULL, cb); +int uv_write(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb) { + return uv_write2(req, handle, bufs, nbufs, NULL, cb); } diff --git a/deps/uv/src/unix/tcp.c b/deps/uv/src/unix/tcp.c index 6257f7d..8ff26dc 100644 --- a/deps/uv/src/unix/tcp.c +++ b/deps/uv/src/unix/tcp.c @@ -56,14 +56,15 @@ static int maybe_new_socket(uv_tcp_t* handle, int domain, int flags) { } -static int uv__bind(uv_tcp_t* tcp, - int domain, - struct sockaddr* addr, - int addrsize) { +int uv__tcp_bind(uv_tcp_t* tcp, + const struct sockaddr* addr, + unsigned int addrlen) { int err; int on; - err = maybe_new_socket(tcp, domain, UV_STREAM_READABLE | UV_STREAM_WRITABLE); + err = maybe_new_socket(tcp, + addr->sa_family, + UV_STREAM_READABLE | UV_STREAM_WRITABLE); if (err) return err; @@ -72,7 +73,7 @@ static int uv__bind(uv_tcp_t* tcp, return -errno; errno = 0; - if (bind(tcp->io_watcher.fd, addr, addrsize) && errno != EADDRINUSE) + if (bind(tcp->io_watcher.fd, addr, addrlen) && errno != EADDRINUSE) return -errno; tcp->delayed_error = -errno; @@ -80,11 +81,11 @@ static int uv__bind(uv_tcp_t* tcp, } -static int uv__connect(uv_connect_t* req, - uv_tcp_t* handle, - struct sockaddr* addr, - socklen_t addrlen, - uv_connect_cb cb) { +int uv__tcp_connect(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + uv_connect_cb cb) { int err; int r; @@ -133,22 +134,6 @@ static int uv__connect(uv_connect_t* req, } -int uv__tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) { - return uv__bind(handle, - AF_INET, - (struct sockaddr*)&addr, - sizeof(struct sockaddr_in)); -} - - -int uv__tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) { - return uv__bind(handle, - AF_INET6, - (struct sockaddr*)&addr, - sizeof(struct sockaddr_in6)); -} - - int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) { return uv__stream_open((uv_stream_t*)handle, sock, @@ -232,22 +217,6 @@ int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) { } -int uv__tcp_connect(uv_connect_t* req, - uv_tcp_t* handle, - struct sockaddr_in addr, - uv_connect_cb cb) { - return uv__connect(req, handle, (struct sockaddr*) &addr, sizeof addr, cb); -} - - -int uv__tcp_connect6(uv_connect_t* req, - uv_tcp_t* handle, - struct sockaddr_in6 addr, - uv_connect_cb cb) { - return uv__connect(req, handle, (struct sockaddr*) &addr, sizeof addr, cb); -} - - int uv__tcp_nodelay(int fd, int on) { return setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)); } diff --git a/deps/uv/src/unix/udp.c b/deps/uv/src/unix/udp.c index 1413985..47e8b03 100644 --- a/deps/uv/src/unix/udp.c +++ b/deps/uv/src/unix/udp.c @@ -35,13 +35,6 @@ static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents); static void uv__udp_recvmsg(uv_loop_t* loop, uv__io_t* w, unsigned int revents); static void uv__udp_sendmsg(uv_loop_t* loop, uv__io_t* w, unsigned int revents); static int uv__udp_maybe_deferred_bind(uv_udp_t* handle, int domain); -static int uv__send(uv_udp_send_t* req, - uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr* addr, - socklen_t addrlen, - uv_udp_send_cb send_cb); void uv__udp_close(uv_udp_t* handle) { @@ -100,8 +93,8 @@ static void uv__udp_run_pending(uv_udp_t* handle) { h.msg_name = &req->addr; h.msg_namelen = (req->addr.sin6_family == AF_INET6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)); - h.msg_iov = (struct iovec*)req->bufs; - h.msg_iovlen = req->bufcnt; + h.msg_iov = (struct iovec*) req->bufs; + h.msg_iovlen = req->nbufs; do { size = sendmsg(handle->io_watcher.fd, &h, 0); @@ -116,19 +109,6 @@ static void uv__udp_run_pending(uv_udp_t* handle) { req->status = (size == -1 ? -errno : size); -#ifndef NDEBUG - /* Sanity check. */ - if (size != -1) { - ssize_t nbytes; - int i; - - for (nbytes = i = 0; i < req->bufcnt; i++) - nbytes += req->bufs[i].len; - - assert(size == nbytes); - } -#endif - /* Sending a datagram is an atomic operation: either all data * is written or nothing is (and EMSGSIZE is raised). That is * why we don't handle partial writes. Just pop the request @@ -205,9 +185,9 @@ static void uv__udp_recvmsg(uv_loop_t* loop, h.msg_name = &peer; do { - buf = handle->alloc_cb((uv_handle_t*) handle, 64 * 1024); + handle->alloc_cb((uv_handle_t*) handle, 64 * 1024, &buf); if (buf.len == 0) { - handle->recv_cb(handle, UV_ENOBUFS, buf, NULL, 0); + handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0); return; } assert(buf.base != NULL); @@ -223,9 +203,9 @@ static void uv__udp_recvmsg(uv_loop_t* loop, if (nread == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) - handle->recv_cb(handle, 0, buf, NULL, 0); + handle->recv_cb(handle, 0, &buf, NULL, 0); else - handle->recv_cb(handle, -errno, buf, NULL, 0); + handle->recv_cb(handle, -errno, &buf, NULL, 0); } else { flags = 0; @@ -235,8 +215,8 @@ static void uv__udp_recvmsg(uv_loop_t* loop, handle->recv_cb(handle, nread, - buf, - (struct sockaddr*)&peer, + &buf, + (const struct sockaddr*) &peer, flags); } } @@ -305,11 +285,10 @@ static int uv__set_reuse(int fd) { } -static int uv__bind(uv_udp_t* handle, - int domain, - struct sockaddr* addr, - socklen_t len, - unsigned flags) { +int uv__udp_bind(uv_udp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + unsigned int flags) { int err; int yes; int fd; @@ -322,12 +301,12 @@ static int uv__bind(uv_udp_t* handle, return -EINVAL; /* Cannot set IPv6-only mode on non-IPv6 socket. */ - if ((flags & UV_UDP_IPV6ONLY) && domain != AF_INET6) + if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) return -EINVAL; fd = handle->io_watcher.fd; if (fd == -1) { - fd = uv__socket(domain, SOCK_DGRAM, 0); + fd = uv__socket(addr->sa_family, SOCK_DGRAM, 0); if (fd == -1) return -errno; handle->io_watcher.fd = fd; @@ -350,7 +329,7 @@ static int uv__bind(uv_udp_t* handle, #endif } - if (bind(fd, addr, len) == -1) { + if (bind(fd, addr, addrlen)) { err = -errno; goto out; } @@ -397,20 +376,20 @@ static int uv__udp_maybe_deferred_bind(uv_udp_t* handle, int domain) { abort(); } - return uv__bind(handle, domain, (struct sockaddr*)&taddr, addrlen, 0); + return uv__udp_bind(handle, (const struct sockaddr*) &taddr, addrlen, 0); } -static int uv__send(uv_udp_send_t* req, - uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr* addr, - socklen_t addrlen, - uv_udp_send_cb send_cb) { +int uv__udp_send(uv_udp_send_t* req, + uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr, + unsigned int addrlen, + uv_udp_send_cb send_cb) { int err; - assert(bufcnt > 0); + assert(nbufs > 0); err = uv__udp_maybe_deferred_bind(handle, addr->sa_family); if (err) @@ -422,17 +401,16 @@ static int uv__send(uv_udp_send_t* req, memcpy(&req->addr, addr, addrlen); req->send_cb = send_cb; req->handle = handle; - req->bufcnt = bufcnt; + req->nbufs = nbufs; - if (bufcnt <= (int) ARRAY_SIZE(req->bufsml)) - req->bufs = req->bufsml; - else - req->bufs = malloc(bufcnt * sizeof(*bufs)); + req->bufs = req->bufsml; + if (nbufs > ARRAY_SIZE(req->bufsml)) + req->bufs = malloc(nbufs * sizeof(bufs[0])); if (req->bufs == NULL) return -ENOMEM; - memcpy(req->bufs, bufs, bufcnt * sizeof(bufs[0])); + memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0])); QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue); uv__io_start(handle->loop, &handle->io_watcher, UV__POLLOUT); uv__handle_start(handle); @@ -452,24 +430,6 @@ int uv_udp_init(uv_loop_t* loop, uv_udp_t* handle) { } -int uv__udp_bind(uv_udp_t* handle, struct sockaddr_in addr, unsigned flags) { - return uv__bind(handle, - AF_INET, - (struct sockaddr*)&addr, - sizeof addr, - flags); -} - - -int uv__udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, unsigned flags) { - return uv__bind(handle, - AF_INET6, - (struct sockaddr*)&addr, - sizeof addr, - flags); -} - - int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) { int err; @@ -594,38 +554,6 @@ int uv_udp_getsockname(uv_udp_t* handle, struct sockaddr* name, int* namelen) { } -int uv__udp_send(uv_udp_send_t* req, - uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr_in addr, - uv_udp_send_cb send_cb) { - return uv__send(req, - handle, - bufs, - bufcnt, - (struct sockaddr*)&addr, - sizeof addr, - send_cb); -} - - -int uv__udp_send6(uv_udp_send_t* req, - uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr_in6 addr, - uv_udp_send_cb send_cb) { - return uv__send(req, - handle, - bufs, - bufcnt, - (struct sockaddr*)&addr, - sizeof addr, - send_cb); -} - - int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb, uv_udp_recv_cb recv_cb) { diff --git a/deps/uv/src/uv-common.c b/deps/uv/src/uv-common.c index 95f5011..bc96029 100644 --- a/deps/uv/src/uv-common.c +++ b/deps/uv/src/uv-common.c @@ -125,31 +125,26 @@ const char* uv_strerror(int err) { #undef UV_STRERROR_GEN -struct sockaddr_in uv_ip4_addr(const char* ip, int port) { - struct sockaddr_in addr; - - memset(&addr, 0, sizeof(struct sockaddr_in)); - - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - addr.sin_addr.s_addr = inet_addr(ip); - - return addr; +int uv_ip4_addr(const char* ip, int port, struct sockaddr_in* addr) { + memset(addr, 0, sizeof(*addr)); + addr->sin_family = AF_INET; + addr->sin_port = htons(port); + /* TODO(bnoordhuis) Don't use inet_addr(), no good way to detect errors. */ + addr->sin_addr.s_addr = inet_addr(ip); + return 0; } -struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) { - struct sockaddr_in6 addr; +int uv_ip6_addr(const char* ip, int port, struct sockaddr_in6* addr) { #if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS) char address_part[40]; size_t address_part_size; const char* zone_index; #endif - memset(&addr, 0, sizeof(struct sockaddr_in6)); - - addr.sin6_family = AF_INET6; - addr.sin6_port = htons(port); + memset(addr, 0, sizeof(*addr)); + addr->sin6_family = AF_INET6; + addr->sin6_port = htons(port); #if defined(UV_PLATFORM_HAS_IP6_LINK_LOCAL_ADDRESS) zone_index = strchr(ip, '%'); @@ -165,17 +160,17 @@ struct sockaddr_in6 uv_ip6_addr(const char* ip, int port) { zone_index++; /* skip '%' */ /* NOTE: unknown interface (id=0) is silently ignored */ #ifdef _WIN32 - addr.sin6_scope_id = atoi(zone_index); + addr->sin6_scope_id = atoi(zone_index); #else - addr.sin6_scope_id = if_nametoindex(zone_index); + addr->sin6_scope_id = if_nametoindex(zone_index); #endif } #endif - /* result code is ignored - we assume ip is a valid IPv6 address */ - uv_inet_pton(AF_INET6, ip, &addr.sin6_addr); + /* TODO(bnoordhuis) Return an error when the address is bad. */ + uv_inet_pton(AF_INET6, ip, &addr->sin6_addr); - return addr; + return 0; } @@ -189,87 +184,113 @@ int uv_ip6_name(struct sockaddr_in6* src, char* dst, size_t size) { } -int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) { - if (handle->type != UV_TCP || addr.sin_family != AF_INET) - return UV_EINVAL; +int uv_tcp_bind(uv_tcp_t* handle, const struct sockaddr_in* addr) { + if (handle->type == UV_TCP && addr->sin_family == AF_INET) + return uv__tcp_bind(handle, (const struct sockaddr*) addr, sizeof(*addr)); else - return uv__tcp_bind(handle, addr); + return UV_EINVAL; } -int uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) { - if (handle->type != UV_TCP || addr.sin6_family != AF_INET6) - return UV_EINVAL; +int uv_tcp_bind6(uv_tcp_t* handle, const struct sockaddr_in6* addr) { + if (handle->type == UV_TCP && addr->sin6_family == AF_INET6) + return uv__tcp_bind(handle, (const struct sockaddr*) addr, sizeof(*addr)); else - return uv__tcp_bind6(handle, addr); + return UV_EINVAL; } int uv_udp_bind(uv_udp_t* handle, - struct sockaddr_in addr, + const struct sockaddr_in* addr, unsigned int flags) { - if (handle->type != UV_UDP || addr.sin_family != AF_INET) - return UV_EINVAL; - else - return uv__udp_bind(handle, addr, flags); + if (handle->type == UV_UDP && addr->sin_family == AF_INET) { + return uv__udp_bind(handle, + (const struct sockaddr*) addr, + sizeof(*addr), + flags); + } + return UV_EINVAL; } int uv_udp_bind6(uv_udp_t* handle, - struct sockaddr_in6 addr, + const struct sockaddr_in6* addr, unsigned int flags) { - if (handle->type != UV_UDP || addr.sin6_family != AF_INET6) - return UV_EINVAL; - else - return uv__udp_bind6(handle, addr, flags); + if (handle->type == UV_UDP && addr->sin6_family == AF_INET6) { + return uv__udp_bind(handle, + (const struct sockaddr*) addr, + sizeof(*addr), + flags); + } + return UV_EINVAL; } int uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle, - struct sockaddr_in address, + const struct sockaddr_in* addr, uv_connect_cb cb) { - if (handle->type != UV_TCP || address.sin_family != AF_INET) - return UV_EINVAL; - else - return uv__tcp_connect(req, handle, address, cb); + if (handle->type == UV_TCP && addr->sin_family == AF_INET) { + return uv__tcp_connect(req, + handle, + (const struct sockaddr*) addr, + sizeof(*addr), + cb); + } + return UV_EINVAL; } int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle, - struct sockaddr_in6 address, + const struct sockaddr_in6* addr, uv_connect_cb cb) { - if (handle->type != UV_TCP || address.sin6_family != AF_INET6) - return UV_EINVAL; - else - return uv__tcp_connect6(req, handle, address, cb); + if (handle->type == UV_TCP && addr->sin6_family == AF_INET6) { + return uv__tcp_connect(req, + handle, + (const struct sockaddr*) addr, + sizeof(*addr), + cb); + } + return UV_EINVAL; } int uv_udp_send(uv_udp_send_t* req, uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr_in addr, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr_in* addr, uv_udp_send_cb send_cb) { - if (handle->type != UV_UDP || addr.sin_family != AF_INET) - return UV_EINVAL; - else - return uv__udp_send(req, handle, bufs, bufcnt, addr, send_cb); + if (handle->type == UV_UDP && addr->sin_family == AF_INET) { + return uv__udp_send(req, + handle, + bufs, + nbufs, + (const struct sockaddr*) addr, + sizeof(*addr), + send_cb); + } + return UV_EINVAL; } int uv_udp_send6(uv_udp_send_t* req, uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr_in6 addr, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr_in6* addr, uv_udp_send_cb send_cb) { - if (handle->type != UV_UDP || addr.sin6_family != AF_INET6) - return UV_EINVAL; - else - return uv__udp_send6(req, handle, bufs, bufcnt, addr, send_cb); + if (handle->type == UV_UDP && addr->sin6_family == AF_INET6) { + return uv__udp_send(req, + handle, + bufs, + nbufs, + (const struct sockaddr*) addr, + sizeof(*addr), + send_cb); + } + return UV_EINVAL; } diff --git a/deps/uv/src/uv-common.h b/deps/uv/src/uv-common.h index dc15091..6fcc212 100644 --- a/deps/uv/src/uv-common.h +++ b/deps/uv/src/uv-common.h @@ -59,36 +59,29 @@ enum { # define UV__HANDLE_CLOSING 0x01 #endif -int uv__tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr); -int uv__tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr); - -int uv__udp_bind(uv_udp_t* handle, struct sockaddr_in addr, unsigned flags); -int uv__udp_bind6(uv_udp_t* handle, struct sockaddr_in6 addr, unsigned flags); +int uv__tcp_bind(uv_tcp_t* tcp, + const struct sockaddr* addr, + unsigned int addrlen); int uv__tcp_connect(uv_connect_t* req, uv_tcp_t* handle, - struct sockaddr_in address, + const struct sockaddr* addr, + unsigned int addrlen, uv_connect_cb cb); -int uv__tcp_connect6(uv_connect_t* req, - uv_tcp_t* handle, - struct sockaddr_in6 address, - uv_connect_cb cb); +int uv__udp_bind(uv_udp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + unsigned int flags); int uv__udp_send(uv_udp_send_t* req, uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr_in addr, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr, + unsigned int addrlen, uv_udp_send_cb send_cb); -int uv__udp_send6(uv_udp_send_t* req, - uv_udp_t* handle, - uv_buf_t bufs[], - int bufcnt, - struct sockaddr_in6 addr, - uv_udp_send_cb send_cb); - int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloccb, uv_udp_recv_cb recv_cb); diff --git a/deps/uv/src/version.c b/deps/uv/src/version.c index c15506d..9c9575b 100644 --- a/deps/uv/src/version.c +++ b/deps/uv/src/version.c @@ -31,7 +31,7 @@ #define UV_VERSION_MAJOR 0 #define UV_VERSION_MINOR 11 -#define UV_VERSION_PATCH 11 +#define UV_VERSION_PATCH 12 #define UV_VERSION_IS_RELEASE 1 diff --git a/deps/uv/src/win/fs.c b/deps/uv/src/win/fs.c index 8c35cab..879f1f1 100644 --- a/deps/uv/src/win/fs.c +++ b/deps/uv/src/win/fs.c @@ -229,17 +229,6 @@ INLINE static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req, } -static int is_path_dir(const WCHAR* path) { - DWORD attr = GetFileAttributesW(path); - - if (attr != INVALID_FILE_ATTRIBUTES) { - return attr & FILE_ATTRIBUTE_DIRECTORY ? 1 : 0; - } else { - return 0; - } -} - - INLINE static int fs__readlink_handle(HANDLE handle, char** target_ptr, uint64_t* target_len_ptr) { char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE]; @@ -1672,7 +1661,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, return uv_translate_sys_error(err); } - req->file_flags; + req->file_flags = flags; if (cb) { QUEUE_FS_TP_JOB(loop, req); diff --git a/deps/uv/src/win/internal.h b/deps/uv/src/win/internal.h index 98c96a7..6a4fb46 100644 --- a/deps/uv/src/win/internal.h +++ b/deps/uv/src/win/internal.h @@ -106,7 +106,7 @@ int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client); int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb); int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle, - uv_buf_t bufs[], int bufcnt, uv_write_cb cb); + const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb); void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, uv_req_t* req); void uv_process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle, @@ -150,9 +150,10 @@ int uv_pipe_read_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb, int uv_pipe_read2_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb, uv_read2_cb read_cb); int uv_pipe_write(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle, - uv_buf_t bufs[], int bufcnt, uv_write_cb cb); + const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb); int uv_pipe_write2(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle, - uv_buf_t bufs[], int bufcnt, uv_stream_t* send_handle, uv_write_cb cb); + const uv_buf_t bufs[], unsigned int nbufs, uv_stream_t* send_handle, + uv_write_cb cb); void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle, uv_req_t* req); @@ -179,7 +180,7 @@ 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); + const uv_buf_t bufs[], unsigned int nbufs, 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, @@ -311,8 +312,9 @@ void uv_fatal_error(const int errorno, const char* syscall); /* * Process stdio handles. */ -int uv__stdio_create(uv_loop_t* loop, uv_process_options_t* options, - BYTE** buffer_ptr); +int uv__stdio_create(uv_loop_t* loop, + const uv_process_options_t* options, + BYTE** buffer_ptr); void uv__stdio_destroy(BYTE* buffer); void uv__stdio_noinherit(BYTE* buffer); int uv__stdio_verify(BYTE* buffer, WORD size); diff --git a/deps/uv/src/win/pipe.c b/deps/uv/src/win/pipe.c index 586adbf..bf98b77 100644 --- a/deps/uv/src/win/pipe.c +++ b/deps/uv/src/win/pipe.c @@ -1030,16 +1030,20 @@ static void uv_queue_non_overlapped_write(uv_pipe_t* handle) { } -static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req, - uv_pipe_t* handle, uv_buf_t bufs[], int bufcnt, - uv_stream_t* send_handle, uv_write_cb cb) { +static int uv_pipe_write_impl(uv_loop_t* loop, + uv_write_t* req, + uv_pipe_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle, + uv_write_cb cb) { int err; int result; uv_tcp_t* tcp_send_handle; uv_write_t* ipc_header_req; uv_ipc_frame_uv_stream ipc_frame; - if (bufcnt != 1 && (bufcnt != 0 || !send_handle)) { + if (nbufs != 1 && (nbufs != 0 || !send_handle)) { return ERROR_NOT_SUPPORTED; } @@ -1081,7 +1085,7 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req, } } - if (bufcnt == 1) { + if (nbufs == 1) { ipc_frame.header.flags |= UV_IPC_RAW_DATA; ipc_frame.header.raw_data_length = bufs[0].len; } @@ -1189,7 +1193,7 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req, } /* Request queued by the kernel. */ - req->queued_bytes = uv_count_bufs(bufs, bufcnt); + req->queued_bytes = uv_count_bufs(bufs, nbufs); handle->write_queue_size += req->queued_bytes; } else if (handle->flags & UV_HANDLE_BLOCKING_WRITES) { /* Using overlapped IO, but wait for completion before returning */ @@ -1245,7 +1249,7 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req, req->queued_bytes = 0; } else { /* Request queued by the kernel. */ - req->queued_bytes = uv_count_bufs(bufs, bufcnt); + req->queued_bytes = uv_count_bufs(bufs, nbufs); handle->write_queue_size += req->queued_bytes; } @@ -1270,19 +1274,28 @@ static int uv_pipe_write_impl(uv_loop_t* loop, uv_write_t* req, } -int uv_pipe_write(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle, - uv_buf_t bufs[], int bufcnt, uv_write_cb cb) { - return uv_pipe_write_impl(loop, req, handle, bufs, bufcnt, NULL, cb); +int uv_pipe_write(uv_loop_t* loop, + uv_write_t* req, + uv_pipe_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb) { + return uv_pipe_write_impl(loop, req, handle, bufs, nbufs, NULL, cb); } -int uv_pipe_write2(uv_loop_t* loop, uv_write_t* req, uv_pipe_t* handle, - uv_buf_t bufs[], int bufcnt, uv_stream_t* send_handle, uv_write_cb cb) { +int uv_pipe_write2(uv_loop_t* loop, + uv_write_t* req, + uv_pipe_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle, + uv_write_cb cb) { if (!handle->ipc) { return WSAEINVAL; } - return uv_pipe_write_impl(loop, req, handle, bufs, bufcnt, send_handle, cb); + return uv_pipe_write_impl(loop, req, handle, bufs, nbufs, send_handle, cb); } @@ -1296,9 +1309,9 @@ static void uv_pipe_read_eof(uv_loop_t* loop, uv_pipe_t* handle, uv_read_stop((uv_stream_t*) handle); if (handle->read2_cb) { - handle->read2_cb(handle, UV_EOF, uv_null_buf_, UV_UNKNOWN_HANDLE); + handle->read2_cb(handle, UV_EOF, &uv_null_buf_, UV_UNKNOWN_HANDLE); } else { - handle->read_cb((uv_stream_t*) handle, UV_EOF, uv_null_buf_); + handle->read_cb((uv_stream_t*) handle, UV_EOF, &uv_null_buf_); } } @@ -1314,10 +1327,10 @@ static void uv_pipe_read_error(uv_loop_t* loop, uv_pipe_t* handle, int error, if (handle->read2_cb) { handle->read2_cb(handle, uv_translate_sys_error(error), - buf, + &buf, UV_UNKNOWN_HANDLE); } else { - handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(error), buf); + handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(error), &buf); } } @@ -1429,12 +1442,12 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle, } } - buf = handle->alloc_cb((uv_handle_t*) handle, avail); + handle->alloc_cb((uv_handle_t*) handle, avail, &buf); if (buf.len == 0) { if (handle->read2_cb) { - handle->read2_cb(handle, UV_ENOBUFS, buf, UV_UNKNOWN_HANDLE); + handle->read2_cb(handle, UV_ENOBUFS, &buf, UV_UNKNOWN_HANDLE); } else if (handle->read_cb) { - handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, buf); + handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf); } break; } @@ -1451,10 +1464,10 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle, handle->remaining_ipc_rawdata_bytes = handle->remaining_ipc_rawdata_bytes - bytes; if (handle->read2_cb) { - handle->read2_cb(handle, bytes, buf, + handle->read2_cb(handle, bytes, &buf, handle->pending_ipc_info.socket_info ? UV_TCP : UV_UNKNOWN_HANDLE); } else if (handle->read_cb) { - handle->read_cb((uv_stream_t*)handle, bytes, buf); + handle->read_cb((uv_stream_t*)handle, bytes, &buf); } if (handle->pending_ipc_info.socket_info) { @@ -1462,7 +1475,7 @@ void uv_process_pipe_read_req(uv_loop_t* loop, uv_pipe_t* handle, handle->pending_ipc_info.socket_info = NULL; } } else { - handle->read_cb((uv_stream_t*)handle, bytes, buf); + handle->read_cb((uv_stream_t*)handle, bytes, &buf); } /* Read again only if bytes == buf.len */ diff --git a/deps/uv/src/win/process-stdio.c b/deps/uv/src/win/process-stdio.c index 612f6be..44a67fd 100644 --- a/deps/uv/src/win/process-stdio.c +++ b/deps/uv/src/win/process-stdio.c @@ -195,7 +195,7 @@ static int uv__duplicate_handle(uv_loop_t* loop, HANDLE handle, HANDLE* dup) { /* _get_osfhandle will sometimes return -2 in case of an error. This seems */ /* to happen when fd <= 2 and the process' corresponding stdio handle is */ - /* set to NULL. Unfortunately DuplicateHandle will happily duplicate /* + /* set to NULL. Unfortunately DuplicateHandle will happily duplicate */ /* (HANDLE) -2, so this situation goes unnoticed until someone tries to */ /* use the duplicate. Therefore we filter out known-invalid handles here. */ if (handle == INVALID_HANDLE_VALUE || @@ -260,8 +260,9 @@ int uv__create_nul_handle(HANDLE* handle_ptr, } -int uv__stdio_create(uv_loop_t* loop, uv_process_options_t* options, - BYTE** buffer_ptr) { +int uv__stdio_create(uv_loop_t* loop, + const uv_process_options_t* options, + BYTE** buffer_ptr) { BYTE* buffer; int count, i; int err; diff --git a/deps/uv/src/win/process.c b/deps/uv/src/win/process.c index 477e5e4..218ea8f 100644 --- a/deps/uv/src/win/process.c +++ b/deps/uv/src/win/process.c @@ -802,8 +802,9 @@ void uv_process_endgame(uv_loop_t* loop, uv_process_t* handle) { } -int uv_spawn(uv_loop_t* loop, uv_process_t* process, - uv_process_options_t options) { +int uv_spawn(uv_loop_t* loop, + uv_process_t* process, + const uv_process_options_t* options) { int i; int err = 0; WCHAR* path = NULL; @@ -814,44 +815,45 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process, PROCESS_INFORMATION info; DWORD process_flags; - if (options.flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) { + if (options->flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) { return UV_ENOTSUP; } - if (options.file == NULL || - options.args == NULL) { + if (options->file == NULL || + options->args == NULL) { return UV_EINVAL; } - assert(options.file != NULL); - assert(!(options.flags & ~(UV_PROCESS_DETACHED | - UV_PROCESS_SETGID | - UV_PROCESS_SETUID | - UV_PROCESS_WINDOWS_HIDE | - UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); + assert(options->file != NULL); + assert(!(options->flags & ~(UV_PROCESS_DETACHED | + UV_PROCESS_SETGID | + UV_PROCESS_SETUID | + UV_PROCESS_WINDOWS_HIDE | + UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); uv_process_init(loop, process); - process->exit_cb = options.exit_cb; + process->exit_cb = options->exit_cb; - err = uv_utf8_to_utf16_alloc(options.file, &application); + err = uv_utf8_to_utf16_alloc(options->file, &application); if (err) goto immediate_failure; - err = make_program_args(options.args, - options.flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS, - &arguments); + err = make_program_args( + options->args, + options->flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS, + &arguments); if (err) goto immediate_failure; - if (options.env) { - err = make_program_env(options.env, &env); + if (options->env) { + err = make_program_env(options->env, &env); if (err) goto immediate_failure; } - if (options.cwd) { + if (options->cwd) { /* Explicit cwd */ - err = uv_utf8_to_utf16_alloc(options.cwd, &cwd); + err = uv_utf8_to_utf16_alloc(options->cwd, &cwd); if (err) goto immediate_failure; @@ -901,7 +903,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process, } } - err = uv__stdio_create(loop, &options, &process->child_stdio_buffer); + err = uv__stdio_create(loop, options, &process->child_stdio_buffer); if (err) goto immediate_failure; @@ -929,7 +931,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process, startup.hStdOutput = uv__stdio_handle(process->child_stdio_buffer, 1); startup.hStdError = uv__stdio_handle(process->child_stdio_buffer, 2); - if (options.flags & UV_PROCESS_WINDOWS_HIDE) { + if (options->flags & UV_PROCESS_WINDOWS_HIDE) { /* Use SW_HIDE to avoid any potential process window. */ startup.wShowWindow = SW_HIDE; } else { @@ -938,7 +940,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process, process_flags = CREATE_UNICODE_ENVIRONMENT; - if (options.flags & UV_PROCESS_DETACHED) { + if (options->flags & UV_PROCESS_DETACHED) { /* Note that we're not setting the CREATE_BREAKAWAY_FROM_JOB flag. That * means that libuv might not let you create a fully deamonized process * when run under job control. However the type of job control that libuv @@ -968,7 +970,7 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process, /* If the process isn't spawned as detached, assign to the global job */ /* object so windows will kill it when the parent process dies. */ - if (!(options.flags & UV_PROCESS_DETACHED)) { + if (!(options->flags & UV_PROCESS_DETACHED)) { uv_once(&uv_global_job_handle_init_guard_, uv__init_global_job_handle); if (!AssignProcessToJobObject(uv_global_job_handle_, info.hProcess)) { @@ -989,8 +991,8 @@ int uv_spawn(uv_loop_t* loop, uv_process_t* process, } /* Set IPC pid to all IPC pipes. */ - for (i = 0; i < options.stdio_count; i++) { - const uv_stdio_container_t* fdopt = &options.stdio[i]; + for (i = 0; i < options->stdio_count; i++) { + const uv_stdio_container_t* fdopt = &options->stdio[i]; if (fdopt->flags & UV_CREATE_PIPE && fdopt->data.stream->type == UV_NAMED_PIPE && ((uv_pipe_t*) fdopt->data.stream)->ipc) { diff --git a/deps/uv/src/win/stream-inl.h b/deps/uv/src/win/stream-inl.h index 3cde668..e4bf086 100644 --- a/deps/uv/src/win/stream-inl.h +++ b/deps/uv/src/win/stream-inl.h @@ -53,13 +53,13 @@ INLINE static void uv_connection_init(uv_stream_t* handle) { } -INLINE static size_t uv_count_bufs(uv_buf_t bufs[], int count) { - size_t bytes = 0; - int i; +INLINE static size_t uv_count_bufs(const uv_buf_t bufs[], unsigned int nbufs) { + unsigned int i; + size_t bytes; - for (i = 0; i < count; i++) { - bytes += (size_t)bufs[i].len; - } + bytes = 0; + for (i = 0; i < nbufs; i++) + bytes += (size_t) bufs[i].len; return bytes; } diff --git a/deps/uv/src/win/stream.c b/deps/uv/src/win/stream.c index 2351dd3..e77ce1c 100644 --- a/deps/uv/src/win/stream.c +++ b/deps/uv/src/win/stream.c @@ -139,8 +139,11 @@ int uv_read_stop(uv_stream_t* handle) { } -int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt, - uv_write_cb cb) { +int uv_write(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb) { uv_loop_t* loop = handle->loop; int err; @@ -151,13 +154,13 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt, err = ERROR_INVALID_PARAMETER; switch (handle->type) { case UV_TCP: - err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, bufcnt, cb); + err = uv_tcp_write(loop, req, (uv_tcp_t*) handle, bufs, nbufs, cb); break; case UV_NAMED_PIPE: - err = uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, cb); + err = uv_pipe_write(loop, req, (uv_pipe_t*) handle, bufs, nbufs, cb); break; case UV_TTY: - err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, bufcnt, cb); + err = uv_tty_write(loop, req, (uv_tty_t*) handle, bufs, nbufs, cb); break; default: assert(0); @@ -167,8 +170,12 @@ int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt, } -int uv_write2(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt, - uv_stream_t* send_handle, uv_write_cb cb) { +int uv_write2(uv_write_t* req, + uv_stream_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_stream_t* send_handle, + uv_write_cb cb) { uv_loop_t* loop = handle->loop; int err; @@ -179,7 +186,13 @@ int uv_write2(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt, err = ERROR_INVALID_PARAMETER; switch (handle->type) { case UV_NAMED_PIPE: - err = uv_pipe_write2(loop, req, (uv_pipe_t*) handle, bufs, bufcnt, send_handle, cb); + err = uv_pipe_write2(loop, + req, + (uv_pipe_t*) handle, + bufs, + nbufs, + send_handle, + cb); break; default: assert(0); diff --git a/deps/uv/src/win/tcp.c b/deps/uv/src/win/tcp.c index 5ed7976..31526b6 100644 --- a/deps/uv/src/win/tcp.c +++ b/deps/uv/src/win/tcp.c @@ -235,15 +235,14 @@ void uv_tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) { } -static int uv__bind(uv_tcp_t* handle, - int family, - struct sockaddr* addr, - int addrsize) { +static int uv_tcp_try_bind(uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen) { DWORD err; int r; if (handle->socket == INVALID_SOCKET) { - SOCKET sock = socket(family, SOCK_STREAM, 0); + SOCKET sock = socket(addr->sa_family, SOCK_STREAM, 0); if (sock == INVALID_SOCKET) { return WSAGetLastError(); } @@ -255,14 +254,14 @@ static int uv__bind(uv_tcp_t* handle, return err; } - err = uv_tcp_set_socket(handle->loop, handle, sock, family, 0); + err = uv_tcp_set_socket(handle->loop, handle, sock, addr->sa_family, 0); if (err) { closesocket(sock); return err; } } - r = bind(handle->socket, addr, addrsize); + r = bind(handle->socket, addr, addrlen); if (r == SOCKET_ERROR) { err = WSAGetLastError(); @@ -281,18 +280,6 @@ static int uv__bind(uv_tcp_t* handle, } -int uv__tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) { - return uv_translate_sys_error( - uv__bind(handle, AF_INET, (struct sockaddr*) &addr, sizeof(addr))); -} - - -int uv__tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6 addr) { - return uv_translate_sys_error( - uv__bind(handle, AF_INET6, (struct sockaddr*) &addr, sizeof(addr))); -} - - static void CALLBACK post_completion(void* context, BOOLEAN timed_out) { uv_req_t* req; uv_tcp_t* handle; @@ -434,9 +421,9 @@ static void uv_tcp_queue_read(uv_loop_t* loop, uv_tcp_t* handle) { */ if (loop->active_tcp_streams < uv_active_tcp_streams_threshold) { handle->flags &= ~UV_HANDLE_ZERO_READ; - handle->read_buffer = handle->alloc_cb((uv_handle_t*) handle, 65536); + handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->read_buffer); if (handle->read_buffer.len == 0) { - handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, handle->read_buffer); + handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &handle->read_buffer); return; } assert(handle->read_buffer.base != NULL); @@ -511,7 +498,9 @@ int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) { } if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv_tcp_bind(handle, uv_addr_ip4_any_); + err = uv_tcp_try_bind(handle, + (const struct sockaddr*) &uv_addr_ip4_any_, + sizeof(uv_addr_ip4_any_)); if (err) return err; } @@ -673,12 +662,13 @@ int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb, } -int uv__tcp_connect(uv_connect_t* req, - uv_tcp_t* handle, - struct sockaddr_in address, - uv_connect_cb cb) { +static int uv_tcp_try_connect(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + uv_connect_cb cb) { uv_loop_t* loop = handle->loop; - int addrsize = sizeof(struct sockaddr_in); + const struct sockaddr* bind_addr; BOOL success; DWORD bytes; int err; @@ -688,7 +678,14 @@ int uv__tcp_connect(uv_connect_t* req, } if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv_tcp_bind(handle, uv_addr_ip4_any_); + if (addrlen == sizeof(uv_addr_ip4_any_)) { + bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_; + } else if (addrlen == sizeof(uv_addr_ip6_any_)) { + bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_; + } else { + abort(); + } + err = uv_tcp_try_bind(handle, bind_addr, addrlen); if (err) return err; } @@ -706,8 +703,8 @@ int uv__tcp_connect(uv_connect_t* req, memset(&req->overlapped, 0, sizeof(req->overlapped)); success = handle->func_connectex(handle->socket, - (struct sockaddr*) &address, - addrsize, + addr, + addrlen, NULL, 0, &bytes, @@ -730,61 +727,6 @@ int uv__tcp_connect(uv_connect_t* req, } -int uv__tcp_connect6(uv_connect_t* req, - uv_tcp_t* handle, - struct sockaddr_in6 address, - uv_connect_cb cb) { - uv_loop_t* loop = handle->loop; - int addrsize = sizeof(struct sockaddr_in6); - BOOL success; - DWORD bytes; - int err; - - if (handle->flags & UV_HANDLE_BIND_ERROR) { - return handle->bind_error; - } - - if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv_tcp_bind6(handle, uv_addr_ip6_any_); - if (err) - return err; - } - - if (!handle->func_connectex) { - if (!uv_get_connectex_function(handle->socket, &handle->func_connectex)) { - return WSAEAFNOSUPPORT; - } - } - - uv_req_init(loop, (uv_req_t*) req); - req->type = UV_CONNECT; - req->handle = (uv_stream_t*) handle; - req->cb = cb; - memset(&req->overlapped, 0, sizeof(req->overlapped)); - - success = handle->func_connectex(handle->socket, - (struct sockaddr*) &address, - addrsize, - NULL, - 0, - &bytes, - &req->overlapped); - - if (UV_SUCCEEDED_WITHOUT_IOCP(success)) { - handle->reqs_pending++; - REGISTER_HANDLE_REQ(loop, handle, req); - uv_insert_pending_req(loop, (uv_req_t*)req); - } else if (UV_SUCCEEDED_WITH_IOCP(success)) { - handle->reqs_pending++; - REGISTER_HANDLE_REQ(loop, handle, req); - } else { - return WSAGetLastError(); - } - - return 0; -} - - int uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen) { int result; @@ -827,8 +769,12 @@ int uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name, } -int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle, - uv_buf_t bufs[], int bufcnt, uv_write_cb cb) { +int uv_tcp_write(uv_loop_t* loop, + uv_write_t* req, + uv_tcp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb) { int result; DWORD bytes; @@ -850,8 +796,8 @@ int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle, } result = WSASend(handle->socket, - (WSABUF*)bufs, - bufcnt, + (WSABUF*) bufs, + nbufs, &bytes, 0, &req->overlapped, @@ -866,7 +812,7 @@ int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle, uv_insert_pending_req(loop, (uv_req_t*) req); } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) { /* Request queued by the kernel. */ - req->queued_bytes = uv_count_bufs(bufs, bufcnt); + req->queued_bytes = uv_count_bufs(bufs, nbufs); handle->reqs_pending++; handle->write_reqs_pending++; REGISTER_HANDLE_REQ(loop, handle, req); @@ -916,7 +862,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(err), - buf); + &buf); } } else { if (!(handle->flags & UV_HANDLE_ZERO_READ)) { @@ -925,7 +871,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, /* Successful read */ handle->read_cb((uv_stream_t*)handle, req->overlapped.InternalHigh, - handle->read_buffer); + &handle->read_buffer); /* Read again only if bytes == buf.len */ if (req->overlapped.InternalHigh < handle->read_buffer.len) { goto done; @@ -940,16 +886,16 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, buf.base = 0; buf.len = 0; - handle->read_cb((uv_stream_t*)handle, UV_EOF, handle->read_buffer); + handle->read_cb((uv_stream_t*)handle, UV_EOF, &handle->read_buffer); goto done; } } /* Do nonblocking reads until the buffer is empty */ while (handle->flags & UV_HANDLE_READING) { - buf = handle->alloc_cb((uv_handle_t*) handle, 65536); + handle->alloc_cb((uv_handle_t*) handle, 65536, &buf); if (buf.len == 0) { - handle->read_cb(handle, UV_ENOBUFS, buf); + handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf); break; } assert(buf.base != NULL); @@ -964,7 +910,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, NULL) != SOCKET_ERROR) { if (bytes > 0) { /* Successful read */ - handle->read_cb((uv_stream_t*)handle, bytes, buf); + handle->read_cb((uv_stream_t*)handle, bytes, &buf); /* Read again only if bytes == buf.len */ if (bytes < buf.len) { break; @@ -974,14 +920,14 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, handle->flags &= ~(UV_HANDLE_READING | UV_HANDLE_READABLE); DECREASE_ACTIVE_COUNT(loop, handle); - handle->read_cb((uv_stream_t*)handle, UV_EOF, buf); + handle->read_cb((uv_stream_t*)handle, UV_EOF, &buf); break; } } else { err = WSAGetLastError(); if (err == WSAEWOULDBLOCK) { /* Read buffer was completely empty, report a 0-byte read. */ - handle->read_cb((uv_stream_t*)handle, 0, buf); + handle->read_cb((uv_stream_t*)handle, 0, &buf); } else { /* Ouch! serious error. */ handle->flags &= ~UV_HANDLE_READING; @@ -995,7 +941,7 @@ void uv_process_tcp_read_req(uv_loop_t* loop, uv_tcp_t* handle, handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(err), - buf); + &buf); } break; } @@ -1084,7 +1030,7 @@ void uv_process_tcp_accept_req(uv_loop_t* loop, uv_tcp_t* handle, } } else { /* Error related to accepted socket is ignored because the server */ - /* socket may still be healthy. If the server socket is broken + /* socket may still be healthy. If the server socket is broken */ /* uv_queue_accept will detect it. */ closesocket(req->accept_socket); req->accept_socket = INVALID_SOCKET; @@ -1413,3 +1359,37 @@ int uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock) { return 0; } + + +/* This function is an egress point, i.e. it returns libuv errors rather than + * system errors. + */ +int uv__tcp_bind(uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen) { + int err; + + err = uv_tcp_try_bind(handle, addr, addrlen); + if (err) + return uv_translate_sys_error(err); + + return 0; +} + + +/* This function is an egress point, i.e. it returns libuv errors rather than + * system errors. + */ +int uv__tcp_connect(uv_connect_t* req, + uv_tcp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + uv_connect_cb cb) { + int err; + + err = uv_tcp_try_connect(req, handle, addr, addrlen, cb); + if (err) + return uv_translate_sys_error(err); + + return 0; +} diff --git a/deps/uv/src/win/tty.c b/deps/uv/src/win/tty.c index e6077a9..d380cd0 100644 --- a/deps/uv/src/win/tty.c +++ b/deps/uv/src/win/tty.c @@ -347,9 +347,11 @@ static void uv_tty_queue_read_line(uv_loop_t* loop, uv_tty_t* handle) { req = &handle->read_req; memset(&req->overlapped, 0, sizeof(req->overlapped)); - handle->read_line_buffer = handle->alloc_cb((uv_handle_t*) handle, 8192); + handle->alloc_cb((uv_handle_t*) handle, 8192, &handle->read_line_buffer); if (handle->read_line_buffer.len == 0) { - handle->read_cb(handle, UV_ENOBUFS, handle->read_line_buffer); + handle->read_cb((uv_stream_t*) handle, + UV_ENOBUFS, + &handle->read_line_buffer); return; } assert(handle->read_line_buffer.base != NULL); @@ -486,7 +488,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, handle->flags &= ~UV_HANDLE_READING; handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(GET_REQ_ERROR(req)), - uv_null_buf_); + &uv_null_buf_); } goto out; } @@ -497,7 +499,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, DECREASE_ACTIVE_COUNT(loop, handle); handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(GetLastError()), - uv_null_buf_); + &uv_null_buf_); goto out; } @@ -518,7 +520,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, DECREASE_ACTIVE_COUNT(loop, handle); handle->read_cb((uv_stream_t*) handle, uv_translate_sys_error(GetLastError()), - buf); + &buf); goto out; } records_left--; @@ -638,7 +640,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, DECREASE_ACTIVE_COUNT(loop, handle); handle->read_cb((uv_stream_t*) handle, uv_translate_sys_error(GetLastError()), - buf); + &buf); goto out; } @@ -684,9 +686,9 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, if (handle->last_key_offset < handle->last_key_len) { /* Allocate a buffer if needed */ if (buf_used == 0) { - buf = handle->alloc_cb((uv_handle_t*) handle, 1024); + handle->alloc_cb((uv_handle_t*) handle, 1024, &buf); if (buf.len == 0) { - handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, buf); + handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf); goto out; } assert(buf.base != NULL); @@ -696,7 +698,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, /* If the buffer is full, emit it */ if (buf_used == buf.len) { - handle->read_cb((uv_stream_t*) handle, buf_used, buf); + handle->read_cb((uv_stream_t*) handle, buf_used, &buf); buf = uv_null_buf_; buf_used = 0; } @@ -717,7 +719,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, /* Send the buffer back to the user */ if (buf_used > 0) { - handle->read_cb((uv_stream_t*) handle, buf_used, buf); + handle->read_cb((uv_stream_t*) handle, buf_used, &buf); } out: @@ -755,17 +757,17 @@ void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle, DECREASE_ACTIVE_COUNT(loop, handle); handle->read_cb((uv_stream_t*) handle, uv_translate_sys_error(GET_REQ_ERROR(req)), - buf); + &buf); } else { /* The read was cancelled, or whatever we don't care */ - handle->read_cb((uv_stream_t*) handle, 0, buf); + handle->read_cb((uv_stream_t*) handle, 0, &buf); } } else { /* Read successful */ /* TODO: read unicode, convert to utf-8 */ DWORD bytes = req->overlapped.InternalHigh; - handle->read_cb((uv_stream_t*) handle, bytes, buf); + handle->read_cb((uv_stream_t*) handle, bytes, &buf); } /* Wait for more input events. */ @@ -828,10 +830,8 @@ int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb, int uv_tty_read_stop(uv_tty_t* handle) { - uv_loop_t* loop = handle->loop; - handle->flags &= ~UV_HANDLE_READING; - DECREASE_ACTIVE_COUNT(loop, handle); + DECREASE_ACTIVE_COUNT(handle->loop, handle); /* Cancel raw read */ if ((handle->flags & UV_HANDLE_READ_PENDING) && @@ -1316,13 +1316,15 @@ static int uv_tty_restore_state(uv_tty_t* handle, } -static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt, - DWORD* error) { +static int uv_tty_write_bufs(uv_tty_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + DWORD* error) { /* We can only write 8k characters at a time. Windows can't handle */ /* much more characters in a single console write anyway. */ WCHAR utf16_buf[8192]; DWORD utf16_buf_used = 0; - int i; + unsigned int i; #define FLUSH_TEXT() \ do { \ @@ -1345,7 +1347,7 @@ static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt, EnterCriticalSection(&uv_tty_output_lock); - for (i = 0; i < bufcnt; i++) { + for (i = 0; i < nbufs; i++) { uv_buf_t buf = bufs[i]; unsigned int j; @@ -1743,8 +1745,12 @@ static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt, } -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) { +int uv_tty_write(uv_loop_t* loop, + uv_write_t* req, + uv_tty_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + uv_write_cb cb) { DWORD error; uv_req_init(loop, (uv_req_t*) req); @@ -1758,7 +1764,7 @@ int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle, req->queued_bytes = 0; - if (!uv_tty_write_bufs(handle, bufs, bufcnt, &error)) { + if (!uv_tty_write_bufs(handle, bufs, nbufs, &error)) { SET_REQ_SUCCESS(req); } else { SET_REQ_ERROR(req, error); diff --git a/deps/uv/src/win/udp.c b/deps/uv/src/win/udp.c index ba21b54..49de701 100644 --- a/deps/uv/src/win/udp.c +++ b/deps/uv/src/win/udp.c @@ -167,37 +167,36 @@ void uv_udp_endgame(uv_loop_t* loop, uv_udp_t* handle) { } -static int uv__bind(uv_udp_t* handle, - int family, - struct sockaddr* addr, - int addrsize, - unsigned int flags) { +static int uv_udp_try_bind(uv_udp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + unsigned int flags) { int r; int err; DWORD no = 0; - if ((flags & UV_UDP_IPV6ONLY) && family != AF_INET6) { + if ((flags & UV_UDP_IPV6ONLY) && addr->sa_family != AF_INET6) { /* UV_UDP_IPV6ONLY is supported only for IPV6 sockets */ return ERROR_INVALID_PARAMETER; } if (handle->socket == INVALID_SOCKET) { - SOCKET sock = socket(family, SOCK_DGRAM, 0); + SOCKET sock = socket(addr->sa_family, SOCK_DGRAM, 0); if (sock == INVALID_SOCKET) { return WSAGetLastError(); } - err = uv_udp_set_socket(handle->loop, handle, sock, family); + err = uv_udp_set_socket(handle->loop, handle, sock, addr->sa_family); if (err) { closesocket(sock); return err; } - if (family == AF_INET6) + if (addr->sa_family == AF_INET6) handle->flags |= UV_HANDLE_IPV6; } - if (family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) { + if (addr->sa_family == AF_INET6 && !(flags & UV_UDP_IPV6ONLY)) { /* On windows IPV6ONLY is on by default. */ /* If the user doesn't specify it libuv turns it off. */ @@ -211,7 +210,7 @@ static int uv__bind(uv_udp_t* handle, sizeof no); } - r = bind(handle->socket, addr, addrsize); + r = bind(handle->socket, addr, addrlen); if (r == SOCKET_ERROR) { return WSAGetLastError(); } @@ -222,36 +221,6 @@ static int uv__bind(uv_udp_t* handle, } -int uv__udp_bind(uv_udp_t* handle, - struct sockaddr_in addr, - unsigned int flags) { - int err; - - err = uv__bind(handle, - AF_INET, - (struct sockaddr*) &addr, - sizeof(addr), - flags); - - return uv_translate_sys_error(err); -} - - -int uv__udp_bind6(uv_udp_t* handle, - struct sockaddr_in6 addr, - unsigned int flags) { - int err; - - err = uv__bind(handle, - AF_INET6, - (struct sockaddr*) &addr, - sizeof(addr), - flags); - - return uv_translate_sys_error(err); -} - - static void uv_udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) { uv_req_t* req; uv_buf_t buf; @@ -271,9 +240,9 @@ static void uv_udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) { if (loop->active_udp_streams < uv_active_udp_streams_threshold) { handle->flags &= ~UV_HANDLE_ZERO_READ; - handle->recv_buffer = handle->alloc_cb((uv_handle_t*) handle, 65536); + handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->recv_buffer); if (handle->recv_buffer.len == 0) { - handle->recv_cb(handle, UV_ENOBUFS, handle->recv_buffer, NULL, 0); + handle->recv_cb(handle, UV_ENOBUFS, &handle->recv_buffer, NULL, 0); return; } assert(handle->recv_buffer.base != NULL); @@ -355,7 +324,10 @@ int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb, } if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv_udp_bind(handle, uv_addr_ip4_any_, 0); + err = uv_udp_try_bind(handle, + (const struct sockaddr*) &uv_addr_ip4_any_, + sizeof(uv_addr_ip4_any_), + 0); if (err) return err; } @@ -387,8 +359,13 @@ int uv__udp_recv_stop(uv_udp_t* handle) { } -static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[], - int bufcnt, struct sockaddr* addr, int addr_len, uv_udp_send_cb cb) { +static int uv__send(uv_udp_send_t* req, + uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr, + unsigned int addrlen, + uv_udp_send_cb cb) { uv_loop_t* loop = handle->loop; DWORD result, bytes; @@ -400,11 +377,11 @@ static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[], result = WSASendTo(handle->socket, (WSABUF*)bufs, - bufcnt, + nbufs, &bytes, 0, addr, - addr_len, + addrlen, &req->overlapped, NULL); @@ -416,7 +393,7 @@ static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[], uv_insert_pending_req(loop, (uv_req_t*)req); } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) { /* Request queued by the kernel. */ - req->queued_bytes = uv_count_bufs(bufs, bufcnt); + req->queued_bytes = uv_count_bufs(bufs, nbufs); handle->reqs_pending++; REGISTER_HANDLE_REQ(loop, handle, req); } else { @@ -428,46 +405,6 @@ static int uv__send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[], } -int uv__udp_send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[], - int bufcnt, struct sockaddr_in addr, uv_udp_send_cb cb) { - int err; - - if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv_udp_bind(handle, uv_addr_ip4_any_, 0); - if (err) - return err; - } - - return uv__send(req, - handle, - bufs, - bufcnt, - (struct sockaddr*) &addr, - sizeof addr, - cb); -} - - -int uv__udp_send6(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[], - int bufcnt, struct sockaddr_in6 addr, uv_udp_send_cb cb) { - int err; - - if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv_udp_bind6(handle, uv_addr_ip6_any_, 0); - if (err) - return err; - } - - return uv__send(req, - handle, - bufs, - bufcnt, - (struct sockaddr*) &addr, - sizeof addr, - cb); -} - - void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_req_t* req) { uv_buf_t buf; @@ -497,7 +434,7 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, uv_udp_recv_stop(handle); buf = (handle->flags & UV_HANDLE_ZERO_READ) ? uv_buf_init(NULL, 0) : handle->recv_buffer; - handle->recv_cb(handle, uv_translate_sys_error(err), buf, NULL, 0); + handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0); } goto done; } @@ -508,8 +445,8 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, partial = !REQ_SUCCESS(req); handle->recv_cb(handle, req->overlapped.InternalHigh, - handle->recv_buffer, - (struct sockaddr*) &handle->recv_from, + &handle->recv_buffer, + (const struct sockaddr*) &handle->recv_from, partial ? UV_UDP_PARTIAL : 0); } else if (handle->flags & UV_HANDLE_READING) { DWORD bytes, err, flags; @@ -518,9 +455,9 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, /* Do a nonblocking receive */ /* TODO: try to read multiple datagrams at once. FIONREAD maybe? */ - buf = handle->alloc_cb((uv_handle_t*) handle, 65536); + handle->alloc_cb((uv_handle_t*) handle, 65536, &buf); if (buf.len == 0) { - handle->recv_cb(handle, UV_ENOBUFS, buf, NULL, 0); + handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0); goto done; } assert(buf.base != NULL); @@ -541,24 +478,24 @@ void uv_process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, NULL) != SOCKET_ERROR) { /* Message received */ - handle->recv_cb(handle, bytes, buf, (struct sockaddr*) &from, 0); + handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0); } else { err = WSAGetLastError(); if (err == WSAEMSGSIZE) { /* Message truncated */ handle->recv_cb(handle, bytes, - buf, - (struct sockaddr*) &from, + &buf, + (const struct sockaddr*) &from, UV_UDP_PARTIAL); } if (err == WSAEWOULDBLOCK) { /* Kernel buffer empty */ - handle->recv_cb(handle, 0, buf, NULL, 0); + handle->recv_cb(handle, 0, &buf, NULL, 0); } else if (err != WSAECONNRESET && err != WSAENETRESET) { /* Serious error. WSAECONNRESET/WSANETRESET is ignored because this */ /* just indicates that a previous sendto operation failed. */ uv_udp_recv_stop(handle); - handle->recv_cb(handle, uv_translate_sys_error(err), buf, NULL, 0); + handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0); } } } @@ -602,7 +539,10 @@ int uv_udp_set_membership(uv_udp_t* handle, const char* multicast_addr, /* If the socket is unbound, bind to inaddr_any. */ if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv__udp_bind(handle, uv_addr_ip4_any_, 0); + err = uv_udp_try_bind(handle, + (const struct sockaddr*) &uv_addr_ip4_any_, + sizeof(uv_addr_ip4_any_), + 0); if (err) return uv_translate_sys_error(err); } @@ -650,7 +590,10 @@ int uv_udp_set_broadcast(uv_udp_t* handle, int value) { /* If the socket is unbound, bind to inaddr_any. */ if (!(handle->flags & UV_HANDLE_BOUND)) { - err = uv__udp_bind(handle, uv_addr_ip4_any_, 0); + err = uv_udp_try_bind(handle, + (const struct sockaddr*) &uv_addr_ip4_any_, + sizeof(uv_addr_ip4_any_), + 0); if (err) return uv_translate_sys_error(err); } @@ -701,7 +644,10 @@ int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) { \ /* If the socket is unbound, bind to inaddr_any. */ \ if (!(handle->flags & UV_HANDLE_BOUND)) { \ - err = uv__udp_bind(handle, uv_addr_ip4_any_, 0); \ + err = uv_udp_try_bind(handle, \ + (const struct sockaddr*) &uv_addr_ip4_any_, \ + sizeof(uv_addr_ip4_any_), \ + 0); \ if (err) \ return uv_translate_sys_error(err); \ } \ @@ -749,3 +695,54 @@ SOCKOPT_SETTER(multicast_loop, #undef VALIDATE_TTL #undef VALIDATE_MULTICAST_TTL #undef VALIDATE_MULTICAST_LOOP + + +/* This function is an egress point, i.e. it returns libuv errors rather than + * system errors. + */ +int uv__udp_bind(uv_udp_t* handle, + const struct sockaddr* addr, + unsigned int addrlen, + unsigned int flags) { + int err; + + err = uv_udp_try_bind(handle, addr, addrlen, flags); + if (err) + return uv_translate_sys_error(err); + + return 0; +} + + +/* This function is an egress point, i.e. it returns libuv errors rather than + * system errors. + */ +int uv__udp_send(uv_udp_send_t* req, + uv_udp_t* handle, + const uv_buf_t bufs[], + unsigned int nbufs, + const struct sockaddr* addr, + unsigned int addrlen, + uv_udp_send_cb send_cb) { + const struct sockaddr* bind_addr; + int err; + + if (!(handle->flags & UV_HANDLE_BOUND)) { + if (addrlen == sizeof(uv_addr_ip4_any_)) { + bind_addr = (const struct sockaddr*) &uv_addr_ip4_any_; + } else if (addrlen == sizeof(uv_addr_ip6_any_)) { + bind_addr = (const struct sockaddr*) &uv_addr_ip6_any_; + } else { + abort(); + } + err = uv_udp_try_bind(handle, bind_addr, addrlen, 0); + if (err) + return uv_translate_sys_error(err); + } + + err = uv__send(req, handle, bufs, nbufs, addr, addrlen, send_cb); + if (err) + return uv_translate_sys_error(err); + + return 0; +} diff --git a/deps/uv/src/win/winapi.h b/deps/uv/src/win/winapi.h index b1cf0a9..21d7fe4 100644 --- a/deps/uv/src/win/winapi.h +++ b/deps/uv/src/win/winapi.h @@ -4076,7 +4076,7 @@ # define STATUS_HASH_NOT_PRESENT ((NTSTATUS) 0xC000A101L) #endif -/* This is not the NTSTATUS_FROM_WIN32 that the DDK provides, because the +/* This is not the NTSTATUS_FROM_WIN32 that the DDK provides, because the */ /* DDK got it wrong! */ #ifdef NTSTATUS_FROM_WIN32 # undef NTSTATUS_FROM_WIN32 diff --git a/deps/uv/src/win/winsock.c b/deps/uv/src/win/winsock.c index cf6d031..bf1c70f 100644 --- a/deps/uv/src/win/winsock.c +++ b/deps/uv/src/win/winsock.c @@ -20,6 +20,7 @@ */ #include +#include #include "uv.h" #include "internal.h" @@ -92,8 +93,13 @@ void uv_winsock_init() { } /* Set implicit binding address used by connectEx */ - uv_addr_ip4_any_ = uv_ip4_addr("0.0.0.0", 0); - uv_addr_ip6_any_ = uv_ip6_addr("::", 0); + if (uv_ip4_addr("0.0.0.0", 0, &uv_addr_ip4_any_)) { + abort(); + } + + if (uv_ip6_addr("::", 0, &uv_addr_ip6_any_)) { + abort(); + } /* Detect non-IFS LSPs */ dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); diff --git a/deps/uv/test/benchmark-multi-accept.c b/deps/uv/test/benchmark-multi-accept.c index eb57464..81614bc 100644 --- a/deps/uv/test/benchmark-multi-accept.c +++ b/deps/uv/test/benchmark-multi-accept.c @@ -85,14 +85,18 @@ static void ipc_close_cb(uv_handle_t* handle); static void ipc_connect_cb(uv_connect_t* req, int status); static void ipc_read2_cb(uv_pipe_t* ipc_pipe, ssize_t nread, - uv_buf_t buf, + const uv_buf_t* buf, uv_handle_type type); -static uv_buf_t ipc_alloc_cb(uv_handle_t* handle, size_t suggested_size); +static void ipc_alloc_cb(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf); static void sv_async_cb(uv_async_t* handle, int status); static void sv_connection_cb(uv_stream_t* server_handle, int status); -static void sv_read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf); -static uv_buf_t sv_alloc_cb(uv_handle_t* handle, size_t suggested_size); +static void sv_read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf); +static void sv_alloc_cb(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf); static void cl_connect_cb(uv_connect_t* req, int status); static void cl_idle_cb(uv_idle_t* handle, int status); @@ -157,16 +161,19 @@ static void ipc_connect_cb(uv_connect_t* req, int status) { } -static uv_buf_t ipc_alloc_cb(uv_handle_t* handle, size_t suggested_size) { +static void ipc_alloc_cb(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf) { struct ipc_client_ctx* ctx; ctx = container_of(handle, struct ipc_client_ctx, ipc_pipe); - return uv_buf_init(ctx->scratch, sizeof(ctx->scratch)); + buf->base = ctx->scratch; + buf->len = sizeof(ctx->scratch); } static void ipc_read2_cb(uv_pipe_t* ipc_pipe, ssize_t nread, - uv_buf_t buf, + const uv_buf_t* buf, uv_handle_type type) { struct ipc_client_ctx* ctx; uv_loop_t* loop; @@ -202,7 +209,7 @@ static void send_listen_handles(uv_handle_type type, if (type == UV_TCP) { ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle)); - ASSERT(0 == uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, listen_addr)); + ASSERT(0 == uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, &listen_addr)); } else ASSERT(0); @@ -295,13 +302,18 @@ static void sv_connection_cb(uv_stream_t* server_handle, int status) { } -static uv_buf_t sv_alloc_cb(uv_handle_t* handle, size_t suggested_size) { - static char buf[32]; - return uv_buf_init(buf, sizeof(buf)); +static void sv_alloc_cb(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf) { + static char slab[32]; + buf->base = slab; + buf->len = sizeof(slab); } -static void sv_read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) { +static void sv_read_cb(uv_stream_t* handle, + ssize_t nread, + const uv_buf_t* buf) { ASSERT(nread == UV_EOF); uv_close((uv_handle_t*) handle, (uv_close_cb) free); } @@ -334,7 +346,7 @@ static void cl_close_cb(uv_handle_t* handle) { ASSERT(0 == uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle)); ASSERT(0 == uv_tcp_connect(&ctx->connect_req, (uv_tcp_t*) &ctx->client_handle, - listen_addr, + &listen_addr, cl_connect_cb)); } @@ -347,7 +359,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { unsigned int i; double time; - listen_addr = uv_ip4_addr("127.0.0.1", TEST_PORT); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr)); loop = uv_default_loop(); servers = calloc(num_servers, sizeof(servers[0])); @@ -375,7 +387,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { ASSERT(0 == uv_tcp_init(loop, handle)); ASSERT(0 == uv_tcp_connect(&ctx->connect_req, handle, - listen_addr, + &listen_addr, cl_connect_cb)); ASSERT(0 == uv_idle_init(loop, &ctx->idle_handle)); } diff --git a/deps/uv/test/benchmark-ping-pongs.c b/deps/uv/test/benchmark-ping-pongs.c index 0012cfd..c5c11fe 100644 --- a/deps/uv/test/benchmark-ping-pongs.c +++ b/deps/uv/test/benchmark-ping-pongs.c @@ -53,27 +53,24 @@ static int completed_pingers = 0; static int64_t start_time; -static uv_buf_t buf_alloc(uv_handle_t* tcp, size_t size) { +static void buf_alloc(uv_handle_t* tcp, size_t size, uv_buf_t* buf) { buf_t* ab; ab = buf_freelist; - - if (ab != NULL) { + if (ab != NULL) buf_freelist = ab->next; - return ab->uv_buf_t; + else { + ab = malloc(size + sizeof(*ab)); + ab->uv_buf_t.len = size; + ab->uv_buf_t.base = (char*) (ab + 1); } - ab = (buf_t*) malloc(size + sizeof *ab); - ab->uv_buf_t.len = size; - ab->uv_buf_t.base = ((char*) ab) + sizeof *ab; - - return ab->uv_buf_t; + *buf = ab->uv_buf_t; } -static void buf_free(uv_buf_t uv_buf_t) { - buf_t* ab = (buf_t*) (uv_buf_t.base - sizeof *ab); - +static void buf_free(const uv_buf_t* buf) { + buf_t* ab = (buf_t*) buf->base - 1; ab->next = buf_freelist; buf_freelist = ab; } @@ -123,7 +120,9 @@ static void pinger_shutdown_cb(uv_shutdown_t* req, int status) { } -static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) { +static void pinger_read_cb(uv_stream_t* tcp, + ssize_t nread, + const uv_buf_t* buf) { ssize_t i; pinger_t* pinger; @@ -132,7 +131,7 @@ static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) { if (nread < 0) { ASSERT(nread == UV_EOF); - if (buf.base) { + if (buf->base) { buf_free(buf); } @@ -144,7 +143,7 @@ static void pinger_read_cb(uv_stream_t* tcp, 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) { pinger->pongs++; @@ -175,12 +174,14 @@ static void pinger_connect_cb(uv_connect_t* req, int status) { static void pinger_new(void) { - int r; - struct sockaddr_in client_addr = uv_ip4_addr("0.0.0.0", 0); - struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT); + struct sockaddr_in client_addr; + struct sockaddr_in server_addr; pinger_t *pinger; + int r; - pinger = (pinger_t*)malloc(sizeof(*pinger)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + pinger = malloc(sizeof(*pinger)); pinger->state = 0; pinger->pongs = 0; @@ -190,9 +191,12 @@ static void pinger_new(void) { pinger->tcp.data = pinger; - uv_tcp_bind(&pinger->tcp, client_addr); + uv_tcp_bind(&pinger->tcp, &client_addr); - r = uv_tcp_connect(&pinger->connect_req, &pinger->tcp, server_addr, pinger_connect_cb); + r = uv_tcp_connect(&pinger->connect_req, + &pinger->tcp, + &server_addr, + pinger_connect_cb); ASSERT(!r); } diff --git a/deps/uv/test/benchmark-pound.c b/deps/uv/test/benchmark-pound.c index df19c98..7531f55 100644 --- a/deps/uv/test/benchmark-pound.c +++ b/deps/uv/test/benchmark-pound.c @@ -75,18 +75,18 @@ static uint64_t start; /* in ms */ static int closed_streams; static int conns_failed; -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 void connect_cb(uv_connect_t* conn_req, int status); -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); 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[65536]; - uv_buf_t buf; - buf.base = slab; - buf.len = sizeof(slab); - return buf; + buf->base = slab; + buf->len = sizeof(slab); } @@ -135,7 +135,7 @@ static void connect_cb(uv_connect_t* req, int status) { } -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) { ASSERT(stream != NULL); @@ -194,14 +194,17 @@ static void pipe_do_setup(int num, void* arg) { static void tcp_make_connect(conn_rec* p) { struct sockaddr_in addr; + tcp_conn_rec* tp; int r; + tp = (tcp_conn_rec*) p; + r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream); 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(&((tcp_conn_rec*)p)->conn_req, (uv_tcp_t*)&p->stream, addr, connect_cb); + r = uv_tcp_connect(&tp->conn_req, (uv_tcp_t*) &p->stream, &addr, connect_cb); if (r) { fprintf(stderr, "uv_tcp_connect error %s\n", uv_err_name(r)); ASSERT(0); diff --git a/deps/uv/test/benchmark-pump.c b/deps/uv/test/benchmark-pump.c index 5b4db3c..ac132cb 100644 --- a/deps/uv/test/benchmark-pump.c +++ b/deps/uv/test/benchmark-pump.c @@ -41,8 +41,8 @@ static void maybe_connect_some(); static uv_req_t* req_alloc(); static void req_free(uv_req_t* uv_req); -static uv_buf_t buf_alloc(uv_handle_t*, size_t size); -static void buf_free(uv_buf_t uv_buf_t); +static void buf_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf); +static void buf_free(const uv_buf_t* buf); static uv_loop_t* loop; @@ -158,7 +158,7 @@ static void start_stats_collection(void) { } -static void read_cb(uv_stream_t* stream, ssize_t bytes, uv_buf_t buf) { +static void read_cb(uv_stream_t* stream, ssize_t bytes, const uv_buf_t* buf) { if (nrecv_total == 0) { ASSERT(start_time == 0); uv_update_time(loop); @@ -240,7 +240,7 @@ static void maybe_connect_some(void) { ASSERT(r == 0); req = (uv_connect_t*) req_alloc(); - r = uv_tcp_connect(req, tcp, connect_addr, connect_cb); + r = uv_tcp_connect(req, tcp, &connect_addr, connect_cb); ASSERT(r == 0); } else { pipe = &pipe_write_handles[max_connect_socket++]; @@ -331,28 +331,26 @@ typedef struct buf_list_s { static buf_list_t* buf_freelist = NULL; -static uv_buf_t buf_alloc(uv_handle_t* handle, size_t size) { - buf_list_t* buf; +static void buf_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf) { + buf_list_t* ab; - buf = buf_freelist; - if (buf != NULL) { - buf_freelist = buf->next; - return buf->uv_buf_t; + ab = buf_freelist; + if (ab != NULL) + buf_freelist = ab->next; + else { + ab = malloc(size + sizeof(*ab)); + ab->uv_buf_t.len = size; + ab->uv_buf_t.base = (char*) (ab + 1); } - buf = (buf_list_t*) malloc(size + sizeof *buf); - buf->uv_buf_t.len = (unsigned int)size; - buf->uv_buf_t.base = ((char*) buf) + sizeof *buf; - - return buf->uv_buf_t; + *buf = ab->uv_buf_t; } -static void buf_free(uv_buf_t uv_buf_t) { - buf_list_t* buf = (buf_list_t*) (uv_buf_t.base - sizeof *buf); - - buf->next = buf_freelist; - buf_freelist = buf; +static void buf_free(const uv_buf_t* buf) { + buf_list_t* ab = (buf_list_t*) buf->base - 1; + ab->next = buf_freelist; + buf_freelist = ab; } @@ -362,13 +360,13 @@ HELPER_IMPL(tcp_pump_server) { type = TCP; loop = uv_default_loop(); - listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr)); /* Server */ server = (uv_stream_t*)&tcpServer; r = uv_tcp_init(loop, &tcpServer); ASSERT(r == 0); - r = uv_tcp_bind(&tcpServer, listen_addr); + r = uv_tcp_bind(&tcpServer, &listen_addr); ASSERT(r == 0); r = uv_listen((uv_stream_t*)&tcpServer, MAX_WRITE_HANDLES, connection_cb); ASSERT(r == 0); @@ -408,7 +406,7 @@ static void tcp_pump(int n) { loop = uv_default_loop(); - connect_addr = uv_ip4_addr("127.0.0.1", TEST_PORT); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr)); /* Start making connections */ maybe_connect_some(); diff --git a/deps/uv/test/benchmark-spawn.c b/deps/uv/test/benchmark-spawn.c index 140bfa7..9cae41a 100644 --- a/deps/uv/test/benchmark-spawn.c +++ b/deps/uv/test/benchmark-spawn.c @@ -73,11 +73,11 @@ static void exit_cb(uv_process_t* process, } -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; } @@ -88,7 +88,7 @@ static void pipe_close_cb(uv_handle_t* pipe) { } -static void on_read(uv_stream_t* pipe, ssize_t nread, uv_buf_t buf) { +static void on_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) { if (nread > 0) { ASSERT(pipe_open == 1); output_used += nread; @@ -122,7 +122,7 @@ static void spawn(void) { options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE; options.stdio[1].data.stream = (uv_stream_t*)&out; - r = uv_spawn(loop, &process, options); + r = uv_spawn(loop, &process, &options); ASSERT(r == 0); process_open = 1; diff --git a/deps/uv/test/benchmark-tcp-write-batch.c b/deps/uv/test/benchmark-tcp-write-batch.c index 978cde0..09b93c2 100644 --- a/deps/uv/test/benchmark-tcp-write-batch.c +++ b/deps/uv/test/benchmark-tcp-write-batch.c @@ -112,12 +112,12 @@ BENCHMARK_IMPL(tcp_write_batch) { } loop = uv_default_loop(); - 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_init(loop, &tcp_client); ASSERT(r == 0); - r = uv_tcp_connect(&connect_req, &tcp_client, addr, connect_cb); + r = uv_tcp_connect(&connect_req, &tcp_client, &addr, connect_cb); ASSERT(r == 0); start = uv_hrtime(); diff --git a/deps/uv/test/benchmark-udp-pummel.c b/deps/uv/test/benchmark-udp-pummel.c index 2590f57..3dec263 100644 --- a/deps/uv/test/benchmark-udp-pummel.c +++ b/deps/uv/test/benchmark-udp-pummel.c @@ -59,10 +59,13 @@ static int timed; static int exiting; -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); } @@ -97,7 +100,7 @@ send: &s->udp_handle, bufs, ARRAY_SIZE(bufs), - s->addr, + &s->addr, send_cb)); send_cb_called++; } @@ -105,8 +108,8 @@ send: 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) { if (nread == 0) return; @@ -117,7 +120,7 @@ static void recv_cb(uv_udp_t* handle, } ASSERT(addr->sa_family == AF_INET); - ASSERT(!memcmp(buf.base, EXPECTED, nread)); + ASSERT(!memcmp(buf->base, EXPECTED, nread)); recv_cb_called++; } @@ -168,9 +171,10 @@ static int pummel(unsigned int n_senders, for (i = 0; i < n_receivers; i++) { struct receiver_state* s = receivers + i; - struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", BASE_PORT + i); + struct sockaddr_in addr; + ASSERT(0 == uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr)); ASSERT(0 == uv_udp_init(loop, &s->udp_handle)); - ASSERT(0 == uv_udp_bind(&s->udp_handle, addr, 0)); + ASSERT(0 == uv_udp_bind(&s->udp_handle, &addr, 0)); ASSERT(0 == uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb)); uv_unref((uv_handle_t*)&s->udp_handle); } @@ -183,13 +187,15 @@ static int pummel(unsigned int n_senders, for (i = 0; i < n_senders; i++) { struct sender_state* s = senders + i; - s->addr = uv_ip4_addr("127.0.0.1", BASE_PORT + (i % n_receivers)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", + BASE_PORT + (i % n_receivers), + &s->addr)); ASSERT(0 == uv_udp_init(loop, &s->udp_handle)); ASSERT(0 == uv_udp_send(&s->send_req, &s->udp_handle, bufs, ARRAY_SIZE(bufs), - s->addr, + &s->addr, send_cb)); } diff --git a/deps/uv/test/blackhole-server.c b/deps/uv/test/blackhole-server.c index ade49b4..75f8456 100644 --- a/deps/uv/test/blackhole-server.c +++ b/deps/uv/test/blackhole-server.c @@ -33,8 +33,8 @@ typedef struct { static uv_tcp_t tcp_server; static void connection_cb(uv_stream_t* stream, int status); -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, uv_buf_t buf); +static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf); +static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf); static void shutdown_cb(uv_shutdown_t* req, int status); static void close_cb(uv_handle_t* handle); @@ -60,13 +60,16 @@ static void connection_cb(uv_stream_t* stream, int status) { } -static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) { - static char buf[65536]; - return uv_buf_init(buf, sizeof buf); +static void alloc_cb(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf) { + static char slab[65536]; + 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) { conn_rec* conn; int r; @@ -100,12 +103,12 @@ HELPER_IMPL(tcp4_blackhole_server) { int r; loop = uv_default_loop(); - 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_init(loop, &tcp_server); ASSERT(r == 0); - r = uv_tcp_bind(&tcp_server, addr); + r = uv_tcp_bind(&tcp_server, &addr); ASSERT(r == 0); r = uv_listen((uv_stream_t*)&tcp_server, 128, connection_cb); diff --git a/deps/uv/test/dns-server.c b/deps/uv/test/dns-server.c index 17e7ecf..aabded5 100644 --- a/deps/uv/test/dns-server.c +++ b/deps/uv/test/dns-server.c @@ -54,7 +54,7 @@ static uv_tcp_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_connection(uv_stream_t*, int status); @@ -124,7 +124,9 @@ static void addrsp(write_req_t* wr, char* hdr) { wr->buf.len += rsplen; } -static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) { +static void process_req(uv_stream_t* handle, + ssize_t nread, + const uv_buf_t* buf) { write_req_t* wr; dnshandle* dns = (dnshandle*)handle; char hdrbuf[DNSREC_LEN]; @@ -144,7 +146,7 @@ static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) { readbuf_remaining = dns->state.prevbuf_rem; usingprev = 1; } else { - dnsreq = buf.base; + dnsreq = buf->base; readbuf_remaining = nread; } hdrstart = dnsreq; @@ -194,7 +196,7 @@ static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) { if (usingprev == 1) { /* free previous buffer */ free(dns->state.prevbuf_ptr); - dnsreq = buf.base; + dnsreq = buf->base; readbuf_remaining = nread; usingprev = 0; } else { @@ -211,27 +213,29 @@ static void process_req(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) { if (readbuf_remaining > 0) { /* save start of record position, so we can continue on next read */ - dns->state.prevbuf_ptr = buf.base; - dns->state.prevbuf_pos = hdrstart - buf.base; + dns->state.prevbuf_ptr = buf->base; + dns->state.prevbuf_pos = hdrstart - buf->base; dns->state.prevbuf_rem = nread - dns->state.prevbuf_pos; } else { /* nothing left in this buffer */ dns->state.prevbuf_ptr = NULL; dns->state.prevbuf_pos = 0; dns->state.prevbuf_rem = 0; - free(buf.base); + free(buf->base); } } -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; if (nread < 0) { /* Error or EOF */ ASSERT(nread == UV_EOF); - if (buf.base) { - free(buf.base); + if (buf->base) { + free(buf->base); } req = malloc(sizeof *req); @@ -242,7 +246,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; } /* process requests and send responses */ @@ -255,11 +259,11 @@ static void on_close(uv_handle_t* peer) { } -static uv_buf_t buf_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 buf_alloc(uv_handle_t* handle, + size_t suggested_size, + uv_buf_t* buf) { + buf->base = malloc(suggested_size); + buf->len = suggested_size; } @@ -289,9 +293,11 @@ static void on_connection(uv_stream_t* server, int status) { static int dns_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)); + r = uv_tcp_init(loop, &server); if (r) { /* TODO: Error codes */ @@ -299,7 +305,7 @@ static int dns_start(int port) { return 1; } - r = uv_tcp_bind(&server, addr); + r = uv_tcp_bind(&server, &addr); if (r) { /* TODO: Error codes */ fprintf(stderr, "Bind error\n"); diff --git a/deps/uv/test/echo-server.c b/deps/uv/test/echo-server.c index a9891d2..6974201 100644 --- a/deps/uv/test/echo-server.c +++ b/deps/uv/test/echo-server.c @@ -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"); diff --git a/deps/uv/test/test-callback-stack.c b/deps/uv/test/test-callback-stack.c index 1774fdf..ff6e93c 100644 --- a/deps/uv/test/test-callback-stack.c +++ b/deps/uv/test/test-callback-stack.c @@ -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--; diff --git a/deps/uv/test/test-connection-fail.c b/deps/uv/test/test-connection-fail.c index 8dfb38e..8009930 100644 --- a/deps/uv/test/test-connection-fail.c +++ b/deps/uv/test/test-connection-fail.c @@ -90,10 +90,10 @@ 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); @@ -101,8 +101,8 @@ static void connection_fail(uv_connect_cb connect_cb) { /* 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); diff --git a/deps/uv/test/test-delayed-accept.c b/deps/uv/test/test-delayed-accept.c index cd0b026..a7d3188 100644 --- a/deps/uv/test/test-delayed-accept.c +++ b/deps/uv/test/test-delayed-accept.c @@ -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,15 +99,16 @@ 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); @@ -117,11 +116,11 @@ static void start_server(void) { } -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); } diff --git a/deps/uv/test/test-embed.c b/deps/uv/test/test-embed.c index 7f485d1..ac1b3b6 100644 --- a/deps/uv/test/test-embed.c +++ b/deps/uv/test/test-embed.c @@ -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); diff --git a/deps/uv/test/test-getsockname.c b/deps/uv/test/test-getsockname.c index e3f09ec..87bb616 100644 --- a/deps/uv/test/test-getsockname.c +++ b/deps/uv/test/test-getsockname.c @@ -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); } diff --git a/deps/uv/test/test-ip6-addr.c b/deps/uv/test/test-ip6-addr.c index 91891bf..ddd0812 100644 --- a/deps/uv/test/test-ip6-addr.c +++ b/deps/uv/test/test-ip6-addr.c @@ -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); } diff --git a/deps/uv/test/test-ipc-send-recv.c b/deps/uv/test/test-ipc-send-recv.c index 90ac69f..5119b31 100644 --- a/deps/uv/test/test-ipc-send-recv.c +++ b/deps/uv/test/test-ipc-send-recv.c @@ -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); diff --git a/deps/uv/test/test-ipc.c b/deps/uv/test/test-ipc.c index 0918a92..7085ea3 100644 --- a/deps/uv/test/test-ipc.c +++ b/deps/uv/test/test-ipc.c @@ -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,9 +125,12 @@ 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; @@ -132,20 +138,22 @@ static void make_many_connections(void) { } -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,7 +181,7 @@ 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); @@ -181,14 +189,14 @@ static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf, /* 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); diff --git a/deps/uv/test/test-multiple-listen.c b/deps/uv/test/test-multiple-listen.c index 4d52be1..c19ec71 100644 --- a/deps/uv/test/test-multiple-listen.c +++ b/deps/uv/test/test-multiple-listen.c @@ -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); } diff --git a/deps/uv/test/test-osx-select.c b/deps/uv/test/test-osx-select.c index bf4c395..e5e1bf8 100644 --- a/deps/uv/test/test-osx-select.c +++ b/deps/uv/test/test-osx-select.c @@ -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) diff --git a/deps/uv/test/test-ping-pong.c b/deps/uv/test/test-ping-pong.c index 719f2d1..0c880d7 100644 --- a/deps/uv/test/test-ping-pong.c +++ b/deps/uv/test/test-ping-pong.c @@ -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. */ diff --git a/deps/uv/test/test-poll.c b/deps/uv/test/test-poll.c index 1ca9c92..135c729 100644 --- a/deps/uv/test/test-poll.c +++ b/deps/uv/test/test-poll.c @@ -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; diff --git a/deps/uv/test/test-ref.c b/deps/uv/test/test-ref.c index 37279ac..7bb4277 100644 --- a/deps/uv/test/test-ref.c +++ b/deps/uv/test/test-ref.c @@ -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); diff --git a/deps/uv/test/test-shutdown-close.c b/deps/uv/test/test-shutdown-close.c index 957fc88..ca30857 100644 --- a/deps/uv/test/test-shutdown-close.c +++ b/deps/uv/test/test-shutdown-close.c @@ -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); diff --git a/deps/uv/test/test-shutdown-eof.c b/deps/uv/test/test-shutdown-eof.c index 9c84891..92e7312 100644 --- a/deps/uv/test/test-shutdown-eof.c +++ b/deps/uv/test/test-shutdown-eof.c @@ -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); diff --git a/deps/uv/test/test-spawn.c b/deps/uv/test/test-spawn.c index 96cc307..97d08d5 100644 --- a/deps/uv/test/test-spawn.c +++ b/deps/uv/test/test-spawn.c @@ -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); diff --git a/deps/uv/test/test-stdio-over-pipes.c b/deps/uv/test/test-stdio-over-pipes.c index 1d6191e..5f2226c 100644 --- a/deps/uv/test/test-stdio-over-pipes.c +++ b/deps/uv/test/test-stdio-over-pipes.c @@ -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); diff --git a/deps/uv/test/test-tcp-bind-error.c b/deps/uv/test/test-tcp-bind-error.c index 2b2106e..306372a 100644 --- a/deps/uv/test/test-tcp-bind-error.c +++ b/deps/uv/test/test-tcp-bind-error.c @@ -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(); diff --git a/deps/uv/test/test-tcp-bind6-error.c b/deps/uv/test/test-tcp-bind6-error.c index 46e147b..e92afef 100644 --- a/deps/uv/test/test-tcp-bind6-error.c +++ b/deps/uv/test/test-tcp-bind6-error.c @@ -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(); diff --git a/deps/uv/test/test-tcp-close-while-connecting.c b/deps/uv/test/test-tcp-close-while-connecting.c index d3d12fd..9e83552 100644 --- a/deps/uv/test/test-tcp-close-while-connecting.c +++ b/deps/uv/test/test-tcp-close-while-connecting.c @@ -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)); diff --git a/deps/uv/test/test-tcp-close.c b/deps/uv/test/test-tcp-close.c index 5902932..183e9af 100644 --- a/deps/uv/test/test-tcp-close.c +++ b/deps/uv/test/test-tcp-close.c @@ -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); diff --git a/deps/uv/test/test-tcp-connect-error-after-write.c b/deps/uv/test/test-tcp-connect-error-after-write.c index 4c8fdc2..b437bf3 100644 --- a/deps/uv/test/test-tcp-connect-error-after-write.c +++ b/deps/uv/test/test-tcp-connect-error-after-write.c @@ -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); diff --git a/deps/uv/test/test-tcp-connect-error.c b/deps/uv/test/test-tcp-connect-error.c index 836e62f..278548a 100644 --- a/deps/uv/test/test-tcp-connect-error.c +++ b/deps/uv/test/test-tcp-connect-error.c @@ -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); diff --git a/deps/uv/test/test-tcp-connect-timeout.c b/deps/uv/test/test-tcp-connect-timeout.c index 8be4c64..a14a89d 100644 --- a/deps/uv/test/test-tcp-connect-timeout.c +++ b/deps/uv/test/test-tcp-connect-timeout.c @@ -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); diff --git a/deps/uv/test/test-tcp-connect6-error.c b/deps/uv/test/test-tcp-connect6-error.c index ad5d2e4..c0e8262 100644 --- a/deps/uv/test/test-tcp-connect6-error.c +++ b/deps/uv/test/test-tcp-connect6-error.c @@ -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); diff --git a/deps/uv/test/test-tcp-open.c b/deps/uv/test/test-tcp-open.c index cd69035..ddf8d50 100644 --- a/deps/uv/test/test-tcp-open.c +++ b/deps/uv/test/test-tcp-open.c @@ -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); diff --git a/deps/uv/test/test-tcp-read-stop.c b/deps/uv/test/test-tcp-read-stop.c index cc6dd2e..3dc9d87 100644 --- a/deps/uv/test/test-tcp-read-stop.c +++ b/deps/uv/test/test-tcp-read-stop.c @@ -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(); diff --git a/deps/uv/test/test-tcp-shutdown-after-write.c b/deps/uv/test/test-tcp-shutdown-after-write.c index a2e9e0f..de6f557 100644 --- a/deps/uv/test/test-tcp-shutdown-after-write.c +++ b/deps/uv/test/test-tcp-shutdown-after-write.c @@ -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); diff --git a/deps/uv/test/test-tcp-unexpected-read.c b/deps/uv/test/test-tcp-unexpected-read.c index e8fc53c..14fd682 100644 --- a/deps/uv/test/test-tcp-unexpected-read.c +++ b/deps/uv/test/test-tcp-unexpected-read.c @@ -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 diff --git a/deps/uv/test/test-tcp-write-to-half-open-connection.c b/deps/uv/test/test-tcp-write-to-half-open-connection.c index e3557bc..b33deee 100644 --- a/deps/uv/test/test-tcp-write-to-half-open-connection.c +++ b/deps/uv/test/test-tcp-write-to-half-open-connection.c @@ -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); diff --git a/deps/uv/test/test-tcp-writealot.c b/deps/uv/test/test-tcp-writealot.c index e83aeb9..88f499b 100644 --- a/deps/uv/test/test-tcp-writealot.c +++ b/deps/uv/test/test-tcp-writealot.c @@ -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); diff --git a/deps/uv/test/test-udp-dgram-too-big.c b/deps/uv/test/test-udp-dgram-too-big.c index bb8cc6b..ecbafa9 100644 --- a/deps/uv/test/test-udp-dgram-too-big.c +++ b/deps/uv/test/test-udp-dgram-too-big.c @@ -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); diff --git a/deps/uv/test/test-udp-ipv6.c b/deps/uv/test/test-udp-ipv6.c index 247fe8b..f545f81 100644 --- a/deps/uv/test/test-udp-ipv6.c +++ b/deps/uv/test/test-udp-ipv6.c @@ -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,8 +70,8 @@ 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"); } @@ -76,8 +79,8 @@ static void ipv6_recv_fail(uv_udp_t* handle, 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); diff --git a/deps/uv/test/test-udp-multicast-join.c b/deps/uv/test/test-udp-multicast-join.c index 83ec46b..0e750d8 100644 --- a/deps/uv/test/test-udp-multicast-join.c +++ b/deps/uv/test/test-udp-multicast-join.c @@ -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); diff --git a/deps/uv/test/test-udp-multicast-ttl.c b/deps/uv/test/test-udp-multicast-ttl.c index 6d36983..390ea57 100644 --- a/deps/uv/test/test-udp-multicast-ttl.c +++ b/deps/uv/test/test-udp-multicast-ttl.c @@ -57,12 +57,13 @@ 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); @@ -70,7 +71,8 @@ TEST_IMPL(udp_multicast_ttl) { /* 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); diff --git a/deps/uv/test/test-udp-open.c b/deps/uv/test/test-udp-open.c index 5d27bdc..3d64b00 100644 --- a/deps/uv/test/test-udp-open.c +++ b/deps/uv/test/test-udp-open.c @@ -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); diff --git a/deps/uv/test/test-udp-options.c b/deps/uv/test/test-udp-options.c index 610892f..af90a57 100644 --- a/deps/uv/test/test-udp-options.c +++ b/deps/uv/test/test-udp-options.c @@ -29,10 +29,13 @@ 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); @@ -40,7 +43,7 @@ TEST_IMPL(udp_options) { 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); diff --git a/deps/uv/test/test-udp-send-and-recv.c b/deps/uv/test/test-udp-send-and-recv.c index 1ffa6aa..d8da37b 100644 --- a/deps/uv/test/test-udp-send-and-recv.c +++ b/deps/uv/test/test-udp-send-and-recv.c @@ -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,18 +170,18 @@ 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); @@ -188,7 +189,7 @@ TEST_IMPL(udp_send_and_recv) { /* 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); diff --git a/src/process_wrap.cc b/src/process_wrap.cc index aebed82..1784a16 100644 --- a/src/process_wrap.cc +++ b/src/process_wrap.cc @@ -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); diff --git a/src/stream_wrap.cc b/src/stream_wrap.cc index e2c6843..6a5ff16 100644 --- a/src/stream_wrap.cc +++ b/src/stream_wrap.cc @@ -127,10 +127,12 @@ void StreamWrap::ReadStop(const FunctionCallbackInfo& 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(handle->data); assert(wrap->stream() == reinterpret_cast(handle)); - return wrap->callbacks()->DoAlloc(handle, suggested_size); + wrap->callbacks()->DoAlloc(handle, suggested_size, buf); } @@ -157,7 +159,7 @@ static Local 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(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(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(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(realloc(buf.base, nread)); - assert(static_cast(nread) <= buf.len); - argv[1] = Buffer::Use(buf.base, nread); + char* base = static_cast(realloc(buf->base, nread)); + assert(static_cast(nread) <= buf->len); + argv[1] = Buffer::Use(base, nread); Local pending_obj; if (pending == UV_TCP) { diff --git a/src/stream_wrap.h b/src/stream_wrap.h index 7f8f74a..6731fdb 100644 --- a/src/stream_wrap.h +++ b/src/stream_wrap.h @@ -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 static void WriteStringImpl(const v8::FunctionCallbackInfo& args); diff --git a/src/tcp_wrap.cc b/src/tcp_wrap.cc index d24fb50..43a6f90 100644 --- a/src/tcp_wrap.cc +++ b/src/tcp_wrap.cc @@ -269,8 +269,10 @@ void TCPWrap::Bind(const FunctionCallbackInfo& 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& 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& 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& 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); } diff --git a/src/tls_wrap.cc b/src/tls_wrap.cc index f2e27ee..cff2cde 100644 --- a/src/tls_wrap.cc +++ b/src/tls_wrap.cc @@ -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 diff --git a/src/tls_wrap.h b/src/tls_wrap.h index 6470643..83f54c3 100644 --- a/src/tls_wrap.h +++ b/src/tls_wrap.h @@ -50,10 +50,12 @@ class TLSCallbacks : public crypto::SSLWrap, 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); diff --git a/src/udp_wrap.cc b/src/udp_wrap.cc index d72727a..8ea9345 100644 --- a/src/udp_wrap.cc +++ b/src/udp_wrap.cc @@ -159,11 +159,21 @@ void UDPWrap::DoBind(const FunctionCallbackInfo& 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& 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(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(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(realloc(buf.base, nread)); - - argv[2] = Buffer::Use(buf.base, nread); + char* base = static_cast(realloc(buf->base, nread)); + argv[2] = Buffer::Use(base, nread); argv[3] = AddressToJS(addr); MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv); } diff --git a/src/udp_wrap.h b/src/udp_wrap.h index fb73647..e0cfc7b 100644 --- a/src/udp_wrap.h +++ b/src/udp_wrap.h @@ -64,13 +64,15 @@ class UDPWrap: public HandleWrap { static void SetMembership(const v8::FunctionCallbackInfo& 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_; }; -- 2.7.4