nodejs
/
node
mirror of https://github.com/nodejs/node.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

uv: upgrade to v0.11.12 

* upgrade deps/uv/ to v0.11.12.
* update files in src/ after a libuv API change.
This commit is contained in:
Ben Noordhuis 2013-09-03 00:42:59 +02:00
parent 185c515c9f
commit ed8d97f572
78 changed files with 1407 additions and 1198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
deps/uv/ChangeLog vendored
View File

@ -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:

6
deps/uv/include/uv-unix.h vendored
View File

@ -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; \

101
deps/uv/include/uv.h vendored
View File

@ -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);

46
deps/uv/src/unix/process.c vendored
View File

@ -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);

81
deps/uv/src/unix/stream.c vendored
View File

@ -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]));
memcpy(req->bufs, bufs, bufcnt * sizeof(uv_buf_t));
req->bufcnt = bufcnt;
if (req->bufs == NULL)
return -ENOMEM;
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);
}

55
deps/uv/src/unix/tcp.c vendored
View File

@ -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));
}

130
deps/uv/src/unix/udp.c vendored
View File

@ -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) {

147
deps/uv/src/uv-common.c vendored
View File

@ -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;
}

33
deps/uv/src/uv-common.h vendored
View File

@ -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);

2
deps/uv/src/version.c vendored
View File

@ -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

13
deps/uv/src/win/fs.c vendored
View File

@ -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);

14
deps/uv/src/win/internal.h vendored
View File

@ -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);

59
deps/uv/src/win/pipe.c vendored
View File

@ -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 */

7
deps/uv/src/win/process-stdio.c vendored
View File

@ -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;

54
deps/uv/src/win/process.c vendored
View File

@ -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) {

12
deps/uv/src/win/stream-inl.h vendored
View File

@ -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;
}

29
deps/uv/src/win/stream.c vendored
View File

@ -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);

180
deps/uv/src/win/tcp.c vendored
View File

@ -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;
}

52
deps/uv/src/win/tty.c vendored
View File

@ -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);

201
deps/uv/src/win/udp.c vendored
View File

@ -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;
}

2
deps/uv/src/win/winapi.h vendored
View File

@ -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

10
deps/uv/src/win/winsock.c vendored
View File

@ -20,6 +20,7 @@
*/
#include <assert.h>
#include <stdlib.h>
#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);

42
deps/uv/test/benchmark-multi-accept.c vendored
View File

@ -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));
}

46
deps/uv/test/benchmark-ping-pongs.c vendored
View File

@ -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);
}

23
deps/uv/test/benchmark-pound.c vendored
View File

@ -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);

44
deps/uv/test/benchmark-pump.c vendored
View File

@ -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();

14
deps/uv/test/benchmark-spawn.c vendored
View File

@ -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;

4
deps/uv/test/benchmark-tcp-write-batch.c vendored
View File

@ -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();

28
deps/uv/test/benchmark-udp-pummel.c vendored
View File

@ -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));
}

19
deps/uv/test/blackhole-server.c vendored
View File

@ -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);

42
deps/uv/test/dns-server.c vendored
View File

@ -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");

52
deps/uv/test/echo-server.c vendored
View File

@ -39,7 +39,7 @@ static uv_pipe_t pipeServer;
static uv_handle_t* server;
static void after_write(uv_write_t* req, int status);
static void after_read(uv_stream_t*, ssize_t nread, uv_buf_t buf);
static void after_read(uv_stream_t*, ssize_t nread, const uv_buf_t* buf);
static void on_close(uv_handle_t* peer);
static void on_server_close(uv_handle_t* handle);
static void on_connection(uv_stream_t*, int status);
@ -72,7 +72,9 @@ static void after_shutdown(uv_shutdown_t* req, int status) {
}
static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void after_read(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
int i;
write_req_t *wr;
uv_shutdown_t* req;
@ -81,8 +83,8 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
/* Error or EOF */
ASSERT(nread == UV_EOF);
if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}
req = (uv_shutdown_t*) malloc(sizeof *req);
@ -93,7 +95,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf.base);
free(buf->base);
return;
}
@ -103,9 +105,9 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
*/
if (!server_closed) {
for (i = 0; i < nread; i++) {
if (buf.base[i] == 'Q') {
if (i + 1 < nread && buf.base[i + 1] == 'S') {
free(buf.base);
if (buf->base[i] == 'Q') {
if (i + 1 < nread && buf->base[i + 1] == 'S') {
free(buf->base);
uv_close((uv_handle_t*)handle, on_close);
return;
} else {
@ -118,7 +120,7 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
wr = (write_req_t*) malloc(sizeof *wr);
wr->buf = uv_buf_init(buf.base, nread);
wr->buf = uv_buf_init(buf->base, nread);
if (uv_write(&wr->req, handle, &wr->buf, 1, after_write)) {
FATAL("uv_write failed");
}
@ -130,8 +132,11 @@ static void on_close(uv_handle_t* peer) {
}
static uv_buf_t echo_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(malloc(suggested_size), suggested_size);
static void echo_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}
@ -185,10 +190,11 @@ static void on_send(uv_udp_send_t* req, int status);
static void on_recv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* rcvbuf,
const struct sockaddr* addr,
unsigned flags) {
uv_udp_send_t* req;
uv_buf_t sndbuf;
int r;
ASSERT(nread > 0);
@ -197,7 +203,13 @@ static void on_recv(uv_udp_t* handle,
req = malloc(sizeof(*req));
ASSERT(req != NULL);
r = uv_udp_send(req, handle, &buf, 1, *(struct sockaddr_in*)addr, on_send);
sndbuf = *rcvbuf;
r = uv_udp_send(req,
handle,
&sndbuf,
1,
(const struct sockaddr_in*) addr,
on_send);
ASSERT(r == 0);
}
@ -209,9 +221,11 @@ static void on_send(uv_udp_send_t* req, int status) {
static int tcp4_echo_start(int port) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", port);
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", port, &addr));
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
@ -222,7 +236,7 @@ static int tcp4_echo_start(int port) {
return 1;
}
r = uv_tcp_bind(&tcpServer, addr);
r = uv_tcp_bind(&tcpServer, &addr);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Bind error\n");
@ -241,9 +255,11 @@ static int tcp4_echo_start(int port) {
static int tcp6_echo_start(int port) {
struct sockaddr_in6 addr6 = uv_ip6_addr("::1", port);
struct sockaddr_in6 addr6;
int r;
ASSERT(0 == uv_ip6_addr("::1", port, &addr6));
server = (uv_handle_t*)&tcpServer;
serverType = TCP;
@ -255,7 +271,7 @@ static int tcp6_echo_start(int port) {
}
/* IPv6 is optional as not all platforms support it */
r = uv_tcp_bind6(&tcpServer, addr6);
r = uv_tcp_bind6(&tcpServer, &addr6);
if (r) {
/* show message but return OK */
fprintf(stderr, "IPv6 not supported\n");

20
deps/uv/test/test-callback-stack.c vendored
View File

@ -45,12 +45,10 @@ static int bytes_received = 0;
static int shutdown_cb_called = 0;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.len = size;
buf.base = (char*) malloc(size);
ASSERT(buf.base);
return buf;
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->len = size;
buf->base = malloc(size);
ASSERT(buf->base != NULL);
}
@ -69,11 +67,11 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
}
static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(nested == 0 && "read_cb must be called from a fresh stack");
printf("Read. nread == %d\n", (int)nread);
free(buf.base);
free(buf->base);
if (nread == 0) {
return;
@ -173,7 +171,9 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(callback_stack) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
if (uv_tcp_init(uv_default_loop(), &client)) {
FATAL("uv_tcp_init failed");
@ -183,7 +183,7 @@ TEST_IMPL(callback_stack) {
nested++;
if (uv_tcp_connect(&connect_req, &client, addr, connect_cb)) {
if (uv_tcp_connect(&connect_req, &client, &addr, connect_cb)) {
FATAL("uv_tcp_connect failed");
}
nested--;

8
deps/uv/test/test-connection-fail.c vendored
View File

@ -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);

24
deps/uv/test/test-delayed-accept.c vendored
View File

@ -30,11 +30,9 @@ static int close_cb_called = 0;
static int connect_cb_called = 0;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.base = (char*)malloc(size);
buf.len = size;
return buf;
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}
@ -101,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);
}

5
deps/uv/test/test-embed.c vendored
View File

@ -78,7 +78,10 @@ static void embed_thread_runner(void* arg) {
ts.tv_nsec = (timeout % 1000) * 1000000;
r = kevent(fd, NULL, 0, NULL, 0, &ts);
#elif defined(HAVE_EPOLL)
r = epoll_wait(fd, NULL, 0, timeout);
{
struct epoll_event ev;
r = epoll_wait(fd, &ev, 1, timeout);
}
#endif
} while (r == -1 && errno == EINTR);
uv_async_send(&embed_async);

48
deps/uv/test/test-getsockname.c vendored
View File

@ -42,11 +42,9 @@ static uv_udp_t udpServer;
static uv_udp_send_t send_req;
static uv_buf_t alloc(uv_handle_t* handle, size_t suggested_size) {
uv_buf_t buf;
buf.base = (char*) malloc(suggested_size);
buf.len = suggested_size;
return buf;
static void alloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}
@ -62,12 +60,14 @@ static void after_shutdown(uv_shutdown_t* req, int status) {
}
static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void after_read(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
uv_shutdown_t* req;
int r;
if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}
req = (uv_shutdown_t*) malloc(sizeof *req);
@ -79,10 +79,12 @@ static void after_read(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void check_sockname(struct sockaddr* addr, const char* compare_ip,
int compare_port, const char* context) {
struct sockaddr_in check_addr = *(struct sockaddr_in*) addr;
struct sockaddr_in compare_addr = uv_ip4_addr(compare_ip, compare_port);
struct sockaddr_in compare_addr;
char check_ip[17];
int r;
ASSERT(0 == uv_ip4_addr(compare_ip, compare_port, &compare_addr));
/* Both addresses should be ipv4 */
ASSERT(check_addr.sin_family == AF_INET);
ASSERT(compare_addr.sin_family == AF_INET);
@ -165,18 +167,20 @@ static void on_connect(uv_connect_t* req, int status) {
static int tcp_listener(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr_in addr;
struct sockaddr sockname, peername;
int namelen;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
r = uv_tcp_init(loop, &tcpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
}
r = uv_tcp_bind(&tcpServer, addr);
r = uv_tcp_bind(&tcpServer, &addr);
if (r) {
fprintf(stderr, "Bind error\n");
return 1;
@ -205,15 +209,17 @@ static int tcp_listener(void) {
static void tcp_connector(void) {
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", server_port);
struct sockaddr_in server_addr;
struct sockaddr sockname;
int r, namelen;
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_tcp_init(loop, &tcp);
tcp.data = &connect_req;
ASSERT(!r);
r = uv_tcp_connect(&connect_req, &tcp, server_addr, on_connect);
r = uv_tcp_connect(&connect_req, &tcp, &server_addr, on_connect);
ASSERT(!r);
/* Fetch the actual port used by the connecting socket. */
@ -228,15 +234,15 @@ static void tcp_connector(void) {
static void udp_recv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
struct sockaddr sockname;
int namelen;
int r;
ASSERT(nread >= 0);
free(buf.base);
free(buf->base);
if (nread == 0) {
return;
@ -260,18 +266,20 @@ static void udp_send(uv_udp_send_t* req, int status) {
static int udp_listener(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", server_port);
struct sockaddr_in addr;
struct sockaddr sockname;
int namelen;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr));
r = uv_udp_init(loop, &udpServer);
if (r) {
fprintf(stderr, "Socket creation error\n");
return 1;
}
r = uv_udp_bind(&udpServer, addr, 0);
r = uv_udp_bind(&udpServer, &addr, 0);
if (r) {
fprintf(stderr, "Bind error\n");
return 1;
@ -300,9 +308,9 @@ static void udp_sender(void) {
ASSERT(!r);
buf = uv_buf_init("PING", 4);
server_addr = uv_ip4_addr("127.0.0.1", server_port);
ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr));
r = uv_udp_send(&send_req, &udp, &buf, 1, server_addr, udp_send);
r = uv_udp_send(&send_req, &udp, &buf, 1, &server_addr, udp_send);
ASSERT(!r);
}

2
deps/uv/test/test-ip6-addr.c vendored
View File

@ -84,7 +84,7 @@ TEST_IMPL(ip6_addr_link_local) {
iface_index,
device_name);
addr = uv_ip6_addr(scoped_addr, TEST_PORT);
ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr));
LOGF("Got scope_id 0x%02x\n", addr.sin6_scope_id);
ASSERT(iface_index == addr.sin6_scope_id);
}

24
deps/uv/test/test-ipc-send-recv.c vendored
View File

@ -50,16 +50,19 @@ static struct echo_ctx ctx;
static int num_recv_handles;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
/* we're not actually reading anything so a small buffer is okay */
static char buf[8];
return uv_buf_init(buf, sizeof(buf));
static char slab[8];
buf->base = slab;
buf->len = sizeof(slab);
}
static void recv_cb(uv_pipe_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
int r;
@ -132,14 +135,17 @@ TEST_IMPL(ipc_send_recv_pipe) {
TEST_IMPL(ipc_send_recv_tcp) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ctx.expected_type = UV_TCP;
r = uv_tcp_init(uv_default_loop(), &ctx.send.tcp);
ASSERT(r == 0);
r = uv_tcp_bind(&ctx.send.tcp, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(&ctx.send.tcp, &addr);
ASSERT(r == 0);
r = run_test();
@ -161,15 +167,16 @@ static void write2_cb(uv_write_t* req, int status) {
static void read2_cb(uv_pipe_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* rdbuf,
uv_handle_type pending) {
uv_buf_t wrbuf;
int r;
ASSERT(pending == UV_NAMED_PIPE || pending == UV_TCP);
ASSERT(handle == &ctx.channel);
ASSERT(nread >= 0);
buf = uv_buf_init(".", 1);
wrbuf = uv_buf_init(".", 1);
if (pending == UV_NAMED_PIPE)
r = uv_pipe_init(ctx.channel.loop, &ctx.recv.pipe, 0);
@ -184,7 +191,8 @@ static void read2_cb(uv_pipe_t* handle,
r = uv_write2(&ctx.write_req,
(uv_stream_t*)&ctx.channel,
&buf, 1,
&wrbuf,
1,
&ctx.recv.stream,
write2_cb);
ASSERT(r == 0);

110
deps/uv/test/test-ipc.c vendored
View File

@ -94,8 +94,11 @@ static void exit_cb(uv_process_t* process,
}
static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(malloc(suggested_size), suggested_size);
static void on_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}
@ -122,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);

11
deps/uv/test/test-multiple-listen.c vendored
View File

@ -45,13 +45,15 @@ static void connection_cb(uv_stream_t* tcp, int status) {
static void start_server(void) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&server, 128, connection_cb);
@ -72,16 +74,17 @@ static void connect_cb(uv_connect_t* req, int status) {
static void client_connect(void) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_connect_t* connect_req = malloc(sizeof *connect_req);
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(connect_req != NULL);
r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);
r = uv_tcp_connect(connect_req, &client, addr, connect_cb);
r = uv_tcp_connect(connect_req, &client, &addr, connect_cb);
ASSERT(r == 0);
}

10
deps/uv/test/test-osx-select.c vendored
View File

@ -30,14 +30,14 @@
static int read_count;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
static char buf[1024];
return uv_buf_init(buf, ARRAY_SIZE(buf));
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
static char slab[1024];
buf->base = slab;
buf->len = sizeof(slab);
}
static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
fprintf(stdout, "got data %d\n", ++read_count);
if (read_count == 3)

37
deps/uv/test/test-ping-pong.c vendored
View File

@ -48,8 +48,9 @@ typedef struct {
} pinger_t;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
return uv_buf_init(malloc(size), size);
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}
@ -85,7 +86,9 @@ static void pinger_write_ping(pinger_t* pinger) {
}
static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
static void pinger_read_cb(uv_stream_t* stream,
ssize_t nread,
const uv_buf_t* buf) {
ssize_t i;
pinger_t* pinger;
@ -95,7 +98,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
ASSERT(nread == UV_EOF);
puts("got EOF");
free(buf.base);
free(buf->base);
uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
@ -104,7 +107,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
/* Now we count the pings */
for (i = 0; i < nread; i++) {
ASSERT(buf.base[i] == PING[pinger->state]);
ASSERT(buf->base[i] == PING[pinger->state]);
pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
if (pinger->state != 0)
@ -121,7 +124,7 @@ static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
}
}
free(buf.base);
free(buf->base);
}
@ -145,10 +148,11 @@ static void pinger_on_connect(uv_connect_t *req, int status) {
/* same ping-pong test, but using IPv6 connection */
static void tcp_pinger_v6_new(void) {
int r;
struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);
struct sockaddr_in6 server_addr;
pinger_t *pinger;
pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 ==uv_ip6_addr("::1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
@ -159,8 +163,10 @@ static void tcp_pinger_v6_new(void) {
/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect6(&pinger->connect_req, &pinger->stream.tcp, server_addr,
pinger_on_connect);
r = uv_tcp_connect6(&pinger->connect_req,
&pinger->stream.tcp,
&server_addr,
pinger_on_connect);
ASSERT(!r);
/* Synchronous connect callbacks are not allowed. */
@ -170,10 +176,11 @@ static void tcp_pinger_v6_new(void) {
static void tcp_pinger_new(void) {
int r;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in server_addr;
pinger_t *pinger;
pinger = (pinger_t*)malloc(sizeof(*pinger));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
pinger = malloc(sizeof(*pinger));
pinger->state = 0;
pinger->pongs = 0;
@ -184,8 +191,10 @@ static void tcp_pinger_new(void) {
/* We are never doing multiple reads/connects at a time anyway. */
/* so these handles can be pre-initialized. */
r = uv_tcp_connect(&pinger->connect_req, &pinger->stream.tcp, server_addr,
pinger_on_connect);
r = uv_tcp_connect(&pinger->connect_req,
&pinger->stream.tcp,
&server_addr,
pinger_on_connect);
ASSERT(!r);
/* Synchronous connect callbacks are not allowed. */

14
deps/uv/test/test-poll.c vendored
View File

@ -496,11 +496,13 @@ static void server_poll_cb(uv_poll_t* handle, int status, int events) {
static void start_server(void) {
uv_os_sock_t sock;
server_context_t* context;
struct sockaddr_in addr;
uv_os_sock_t sock;
int r;
sock = create_nonblocking_bound_socket(uv_ip4_addr("127.0.0.1", TEST_PORT));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
sock = create_nonblocking_bound_socket(addr);
context = create_server_context(sock);
r = listen(sock, 100);
@ -514,10 +516,14 @@ static void start_server(void) {
static void start_client(void) {
uv_os_sock_t sock;
connection_context_t* context;
struct sockaddr_in server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in server_addr;
struct sockaddr_in addr;
int r;
sock = create_nonblocking_bound_socket(uv_ip4_addr("0.0.0.0", 0));
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr));
sock = create_nonblocking_bound_socket(addr);
context = create_connection_context(sock, 0);
context->events = UV_READABLE | UV_WRITABLE;

22
deps/uv/test/test-ref.c vendored
View File

@ -254,10 +254,11 @@ TEST_IMPL(tcp_ref2b) {
TEST_IMPL(tcp_ref3) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_tcp_init(uv_default_loop(), &h);
uv_tcp_connect(&connect_req, &h, addr, connect_and_shutdown);
uv_tcp_connect(&connect_req, &h, &addr, connect_and_shutdown);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_called == 1);
@ -269,10 +270,11 @@ TEST_IMPL(tcp_ref3) {
TEST_IMPL(tcp_ref4) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_tcp_init(uv_default_loop(), &h);
uv_tcp_connect(&connect_req, &h, addr, connect_and_write);
uv_tcp_connect(&connect_req, &h, &addr, connect_and_write);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(connect_cb_called == 1);
@ -296,10 +298,11 @@ TEST_IMPL(udp_ref) {
TEST_IMPL(udp_ref2) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_udp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_udp_init(uv_default_loop(), &h);
uv_udp_bind(&h, addr, 0);
uv_udp_bind(&h, &addr, 0);
uv_udp_recv_start(&h, (uv_alloc_cb)fail_cb, (uv_udp_recv_cb)fail_cb);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -310,13 +313,14 @@ TEST_IMPL(udp_ref2) {
TEST_IMPL(udp_ref3) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_buf_t buf = uv_buf_init("PING", 4);
uv_udp_send_t req;
uv_udp_t h;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
uv_udp_init(uv_default_loop(), &h);
uv_udp_send(&req, &h, &buf, 1, addr, (uv_udp_send_cb)req_cb);
uv_udp_send(&req, &h, &buf, 1, &addr, (uv_udp_send_cb)req_cb);
uv_unref((uv_handle_t*)&h);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(req_cb_called == 1);
@ -399,7 +403,7 @@ TEST_IMPL(process_ref) {
options.args = argv;
options.exit_cb = NULL;
r = uv_spawn(uv_default_loop(), &h, options);
r = uv_spawn(uv_default_loop(), &h, &options);
ASSERT(r == 0);
uv_unref((uv_handle_t*)&h);

5
deps/uv/test/test-shutdown-close.c vendored
View File

@ -65,13 +65,14 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(shutdown_close_tcp) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t h;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &h);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &h, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &h, &addr, connect_cb);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
ASSERT(r == 0);

24
deps/uv/test/test-shutdown-eof.c vendored
View File

@ -39,33 +39,31 @@ static int called_timer_close_cb;
static int called_timer_cb;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
uv_buf_t buf;
buf.base = (char*)malloc(size);
buf.len = size;
return buf;
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}
static void read_cb(uv_stream_t* t, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) {
ASSERT((uv_tcp_t*)t == &tcp);
if (nread == 0) {
free(buf.base);
free(buf->base);
return;
}
if (!got_q) {
ASSERT(nread == 1);
ASSERT(!got_eof);
ASSERT(buf.base[0] == 'Q');
free(buf.base);
ASSERT(buf->base[0] == 'Q');
free(buf->base);
got_q = 1;
puts("got Q");
} else {
ASSERT(nread == UV_EOF);
if (buf.base) {
free(buf.base);
if (buf->base) {
free(buf->base);
}
got_eof = 1;
puts("got EOF");
@ -158,11 +156,11 @@ TEST_IMPL(shutdown_eof) {
uv_timer_start(&timer, timer_cb, 100, 0);
server_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr));
r = uv_tcp_init(uv_default_loop(), &tcp);
ASSERT(!r);
r = uv_tcp_connect(&connect_req, &tcp, server_addr, connect_cb);
r = uv_tcp_connect(&connect_req, &tcp, &server_addr, connect_cb);
ASSERT(!r);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

52
deps/uv/test/test-spawn.c vendored
View File

@ -118,15 +118,15 @@ static void detach_failure_cb(uv_process_t* process, int64_t exit_status, int te
exit_cb_called++;
}
static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
uv_buf_t buf;
buf.base = output + output_used;
buf.len = OUTPUT_SIZE - output_used;
return buf;
static void on_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = output + output_used;
buf->len = OUTPUT_SIZE - output_used;
}
static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
if (nread > 0) {
output_used += nread;
} else if (nread < 0) {
@ -166,7 +166,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
TEST_IMPL(spawn_fails) {
init_process_options("", exit_cb_expect_enoent);
options.file = options.args[0] = "program-that-had-better-not-exist";
ASSERT(0 == uv_spawn(uv_default_loop(), &process, options));
ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options));
ASSERT(0 != uv_is_active((uv_handle_t*)&process));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(1 == exit_cb_called);
@ -181,7 +181,7 @@ TEST_IMPL(spawn_exit_code) {
init_process_options("spawn_helper1", exit_cb);
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -209,7 +209,7 @@ TEST_IMPL(spawn_stdout) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@ -252,7 +252,7 @@ TEST_IMPL(spawn_stdout_to_file) {
options.stdio[1].data.fd = file;
options.stdio_count = 2;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -301,7 +301,7 @@ TEST_IMPL(spawn_stdin) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
buf.base = buffer;
@ -340,7 +340,7 @@ TEST_IMPL(spawn_stdio_greater_than_3) {
options.stdio[3].data.stream = (uv_stream_t*)&pipe;
options.stdio_count = 4;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*) &pipe, on_alloc, on_read);
@ -367,7 +367,7 @@ TEST_IMPL(spawn_ignored_stdio) {
options.stdio = NULL;
options.stdio_count = 0;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -386,7 +386,7 @@ TEST_IMPL(spawn_and_kill) {
init_process_options("spawn_helper4", kill_cb);
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_timer_init(uv_default_loop(), &timer);
@ -426,7 +426,7 @@ TEST_IMPL(spawn_preserve_env) {
/* Explicitly set options.env to NULL to test for env clobbering. */
options.env = NULL;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@ -453,7 +453,7 @@ TEST_IMPL(spawn_detached) {
options.flags |= UV_PROCESS_DETACHED;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
uv_unref((uv_handle_t*)&process);
@ -502,7 +502,7 @@ TEST_IMPL(spawn_and_kill_with_std) {
options.stdio[2].data.stream = (uv_stream_t*)&err;
options.stdio_count = 3;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
buf = uv_buf_init(message, sizeof message);
@ -551,7 +551,7 @@ TEST_IMPL(spawn_and_ping) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
/* Sending signum == 0 should check if the
@ -588,7 +588,7 @@ TEST_IMPL(kill) {
init_process_options("spawn_helper4", kill_cb);
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
/* Sending signum == 0 should check if the
@ -641,7 +641,7 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) {
NULL);
ASSERT(pipe_handle != INVALID_HANDLE_VALUE);
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@ -806,7 +806,7 @@ TEST_IMPL(spawn_setuid_setgid) {
options.gid = pw->pw_gid;
options.flags = UV_PROCESS_SETUID | UV_PROCESS_SETGID;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -840,7 +840,7 @@ TEST_IMPL(spawn_setuid_fails) {
options.flags |= UV_PROCESS_SETUID;
options.uid = 0;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -872,7 +872,7 @@ TEST_IMPL(spawn_setgid_fails) {
options.flags |= UV_PROCESS_SETGID;
options.gid = 0;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -904,7 +904,7 @@ TEST_IMPL(spawn_setuid_fails) {
options.flags |= UV_PROCESS_SETUID;
options.uid = (uv_uid_t) -42424242;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == UV_ENOTSUP);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -925,7 +925,7 @@ TEST_IMPL(spawn_setgid_fails) {
options.flags |= UV_PROCESS_SETGID;
options.gid = (uv_gid_t) -42424242;
r = uv_spawn(uv_default_loop(), &process, options);
r = uv_spawn(uv_default_loop(), &process, &options);
ASSERT(r == UV_ENOTSUP);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);
@ -941,7 +941,7 @@ TEST_IMPL(spawn_setgid_fails) {
TEST_IMPL(spawn_auto_unref) {
init_process_options("spawn_helper1", NULL);
ASSERT(0 == uv_spawn(uv_default_loop(), &process, options));
ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
ASSERT(0 == uv_is_closing((uv_handle_t*) &process));
uv_close((uv_handle_t*) &process, NULL);

27
deps/uv/test/test-stdio-over-pipes.c vendored
View File

@ -74,8 +74,11 @@ static void init_process_options(char* test, uv_exit_cb exit_cb) {
}
static uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(output + output_used, OUTPUT_SIZE - output_used);
static void on_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = output + output_used;
buf->len = OUTPUT_SIZE - output_used;
}
@ -92,7 +95,7 @@ static void after_write(uv_write_t* req, int status) {
}
static void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t rdbuf) {
static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* rdbuf) {
uv_write_t* req;
uv_buf_t wrbuf;
int r;
@ -133,7 +136,7 @@ TEST_IMPL(stdio_over_pipes) {
options.stdio[1].data.stream = (uv_stream_t*)&out;
options.stdio_count = 2;
r = uv_spawn(loop, &process, options);
r = uv_spawn(loop, &process, &options);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
@ -161,12 +164,12 @@ static int after_write_called;
static uv_pipe_t stdin_pipe;
static uv_pipe_t stdout_pipe;
static void on_pipe_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void on_pipe_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(nread > 0);
ASSERT(memcmp("hello world\n", buf.base, nread) == 0);
ASSERT(memcmp("hello world\n", buf->base, nread) == 0);
on_pipe_read_called++;
free(buf.base);
free(buf->base);
uv_close((uv_handle_t*)&stdin_pipe, close_cb);
uv_close((uv_handle_t*)&stdout_pipe, close_cb);
@ -179,8 +182,11 @@ static void after_pipe_write(uv_write_t* req, int status) {
}
static uv_buf_t on_read_alloc(uv_handle_t* handle, size_t suggested_size) {
return uv_buf_init(malloc(suggested_size), suggested_size);
static void on_read_alloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = malloc(suggested_size);
buf->len = suggested_size;
}
@ -236,8 +242,7 @@ int stdio_over_pipes_helper(void) {
uv_ref((uv_handle_t*)&stdout_pipe);
uv_ref((uv_handle_t*)&stdin_pipe);
r = uv_read_start((uv_stream_t*)&stdin_pipe, on_read_alloc,
on_pipe_read);
r = uv_read_start((uv_stream_t*)&stdin_pipe, on_read_alloc, on_pipe_read);
ASSERT(r == 0);
uv_run(loop, UV_RUN_DEFAULT);

39
deps/uv/test/test-tcp-bind-error.c vendored
View File

@ -35,18 +35,19 @@ static void close_cb(uv_handle_t* handle) {
TEST_IMPL(tcp_bind_error_addrinuse) {
struct sockaddr_in addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server1, server2;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind(&server1, addr);
r = uv_tcp_bind(&server1, &addr);
ASSERT(r == 0);
r = uv_tcp_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_tcp_bind(&server2, addr);
r = uv_tcp_bind(&server2, &addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&server1, 128, NULL);
@ -67,15 +68,17 @@ TEST_IMPL(tcp_bind_error_addrinuse) {
TEST_IMPL(tcp_bind_error_addrnotavail_1) {
struct sockaddr_in addr = uv_ip4_addr("127.255.255.255", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("127.255.255.255", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
/* It seems that Linux is broken here - bind succeeds. */
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0 || r == UV_EADDRNOTAVAIL);
uv_close((uv_handle_t*)&server, close_cb);
@ -90,13 +93,15 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) {
TEST_IMPL(tcp_bind_error_addrnotavail_2) {
struct sockaddr_in addr = uv_ip4_addr("4.4.4.4", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("4.4.4.4", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == UV_EADDRNOTAVAIL);
uv_close((uv_handle_t*)&server, close_cb);
@ -120,7 +125,7 @@ TEST_IMPL(tcp_bind_error_fault) {
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, *garbage_addr);
r = uv_tcp_bind(&server, garbage_addr);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
@ -136,16 +141,19 @@ TEST_IMPL(tcp_bind_error_fault) {
/* Notes: On Linux uv_bind(server, NULL) will segfault the program. */
TEST_IMPL(tcp_bind_error_inval) {
struct sockaddr_in addr1 = uv_ip4_addr("0.0.0.0", TEST_PORT);
struct sockaddr_in addr2 = uv_ip4_addr("0.0.0.0", TEST_PORT_2);
struct sockaddr_in addr1;
struct sockaddr_in addr2;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr1));
ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT_2, &addr2));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr1);
r = uv_tcp_bind(&server, &addr1);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr2);
r = uv_tcp_bind(&server, &addr2);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
@ -160,14 +168,15 @@ TEST_IMPL(tcp_bind_error_inval) {
TEST_IMPL(tcp_bind_localhost_ok) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind(&server, addr);
r = uv_tcp_bind(&server, &addr);
ASSERT(r == 0);
MAKE_VALGRIND_HAPPY();

34
deps/uv/test/test-tcp-bind6-error.c vendored
View File

@ -35,18 +35,20 @@ static void close_cb(uv_handle_t* handle) {
TEST_IMPL(tcp_bind6_error_addrinuse) {
struct sockaddr_in6 addr = uv_ip6_addr("::", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server1, server2;
int r;
ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server1, addr);
r = uv_tcp_bind6(&server1, &addr);
ASSERT(r == 0);
r = uv_tcp_init(uv_default_loop(), &server2);
ASSERT(r == 0);
r = uv_tcp_bind6(&server2, addr);
r = uv_tcp_bind6(&server2, &addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&server1, 128, NULL);
@ -67,13 +69,15 @@ TEST_IMPL(tcp_bind6_error_addrinuse) {
TEST_IMPL(tcp_bind6_error_addrnotavail) {
struct sockaddr_in6 addr = uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
r = uv_tcp_bind6(&server, &addr);
ASSERT(r == UV_EADDRNOTAVAIL);
uv_close((uv_handle_t*)&server, close_cb);
@ -97,7 +101,7 @@ TEST_IMPL(tcp_bind6_error_fault) {
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, *garbage_addr);
r = uv_tcp_bind6(&server, garbage_addr);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
@ -113,16 +117,19 @@ TEST_IMPL(tcp_bind6_error_fault) {
/* Notes: On Linux uv_bind6(server, NULL) will segfault the program. */
TEST_IMPL(tcp_bind6_error_inval) {
struct sockaddr_in6 addr1 = uv_ip6_addr("::", TEST_PORT);
struct sockaddr_in6 addr2 = uv_ip6_addr("::", TEST_PORT_2);
struct sockaddr_in6 addr1;
struct sockaddr_in6 addr2;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr1));
ASSERT(0 == uv_ip6_addr("::", TEST_PORT_2, &addr2));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr1);
r = uv_tcp_bind6(&server, &addr1);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr2);
r = uv_tcp_bind6(&server, &addr2);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);
@ -137,14 +144,15 @@ TEST_IMPL(tcp_bind6_error_inval) {
TEST_IMPL(tcp_bind6_localhost_ok) {
struct sockaddr_in6 addr = uv_ip6_addr("::1", TEST_PORT);
struct sockaddr_in6 addr;
uv_tcp_t server;
int r;
ASSERT(0 == uv_ip6_addr("::1", TEST_PORT, &addr));
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_bind6(&server, addr);
r = uv_tcp_bind6(&server, &addr);
ASSERT(r == 0);
MAKE_VALGRIND_HAPPY();

5
deps/uv/test/test-tcp-close-while-connecting.c vendored
View File

@ -60,11 +60,10 @@ TEST_IMPL(tcp_close_while_connecting) {
struct sockaddr_in addr;
uv_loop_t* loop;
addr = uv_ip4_addr("1.2.3.4", TEST_PORT);
loop = uv_default_loop();
ASSERT(0 == uv_ip4_addr("1.2.3.4", TEST_PORT, &addr));
ASSERT(0 == uv_tcp_init(loop, &tcp_handle));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb));
ASSERT(0 == uv_timer_init(loop, &timer1_handle));
ASSERT(0 == uv_timer_start(&timer1_handle, timer1_cb, 50, 0));
ASSERT(0 == uv_timer_init(loop, &timer2_handle));

15
deps/uv/test/test-tcp-close.c vendored
View File

@ -77,12 +77,15 @@ static void connection_cb(uv_stream_t* server, int status) {
static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
struct sockaddr_in addr;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_tcp_init(loop, handle);
ASSERT(r == 0);
r = uv_tcp_bind(handle, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(handle, &addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)handle, 128, connection_cb);
@ -96,10 +99,13 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) {
* invoked when the handle is closed.
*/
TEST_IMPL(tcp_close) {
uv_loop_t* loop;
struct sockaddr_in addr;
uv_tcp_t tcp_server;
uv_loop_t* loop;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
/* We can't use the echo server, it doesn't handle ECONNRESET. */
@ -108,10 +114,7 @@ TEST_IMPL(tcp_close) {
r = uv_tcp_init(loop, &tcp_handle);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req,
&tcp_handle,
uv_ip4_addr("127.0.0.1", TEST_PORT),
connect_cb);
r = uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb);
ASSERT(r == 0);
ASSERT(write_cb_called == 0);

4
deps/uv/test/test-tcp-connect-error-after-write.c vendored
View File

@ -68,7 +68,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
return 0; /* windows slackers... */
#endif
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
buf = uv_buf_init("TEST", 4);
r = uv_tcp_init(uv_default_loop(), &conn);
@ -77,7 +77,7 @@ TEST_IMPL(tcp_connect_error_after_write) {
r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);
ASSERT(r == UV_EBADF);
r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
ASSERT(r == 0);
r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb);

9
deps/uv/test/test-tcp-connect-error.c vendored
View File

@ -44,17 +44,18 @@ static void close_cb(uv_handle_t* handle) {
TEST_IMPL(tcp_connect_error_fault) {
char garbage[] = "blah blah blah blah blah blah blah blah blah blah blah blah";
struct sockaddr_in* garbage_addr;
const char garbage[] =
"blah blah blah blah blah blah blah blah blah blah blah blah";
const struct sockaddr_in* garbage_addr;
uv_tcp_t server;
int r;
uv_connect_t req;
garbage_addr = (struct sockaddr_in*) &garbage;
garbage_addr = (const struct sockaddr_in*) &garbage;
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_connect(&req, &server, *garbage_addr, connect_cb);
r = uv_tcp_connect(&req, &server, garbage_addr, connect_cb);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);

4
deps/uv/test/test-tcp-connect-timeout.c vendored
View File

@ -64,7 +64,7 @@ TEST_IMPL(tcp_connect_timeout) {
struct sockaddr_in addr;
int r;
addr = uv_ip4_addr("8.8.8.8", 9999);
ASSERT(0 == uv_ip4_addr("8.8.8.8", 9999, &addr));
r = uv_timer_init(uv_default_loop(), &timer);
ASSERT(r == 0);
@ -75,7 +75,7 @@ TEST_IMPL(tcp_connect_timeout) {
r = uv_tcp_init(uv_default_loop(), &conn);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
ASSERT(r == 0);
r = uv_run(uv_default_loop(), UV_RUN_DEFAULT);

9
deps/uv/test/test-tcp-connect6-error.c vendored
View File

@ -42,17 +42,18 @@ static void close_cb(uv_handle_t* handle) {
TEST_IMPL(tcp_connect6_error_fault) {
char garbage[] = "blah blah blah blah blah blah blah blah blah blah blah blah";
struct sockaddr_in6* garbage_addr;
const char garbage[] =
"blah blah blah blah blah blah blah blah blah blah blah blah";
const struct sockaddr_in6* garbage_addr;
uv_tcp_t server;
int r;
uv_connect_t req;
garbage_addr = (struct sockaddr_in6*) &garbage;
garbage_addr = (const struct sockaddr_in6*) &garbage;
r = uv_tcp_init(uv_default_loop(), &server);
ASSERT(r == 0);
r = uv_tcp_connect6(&req, &server, *garbage_addr, connect_cb);
r = uv_tcp_connect6(&req, &server, garbage_addr, connect_cb);
ASSERT(r == UV_EINVAL);
uv_close((uv_handle_t*)&server, close_cb);

19
deps/uv/test/test-tcp-open.c vendored
View File

@ -71,10 +71,13 @@ static uv_os_sock_t create_tcp_socket(void) {
}
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
ASSERT(suggested_size <= sizeof slab);
return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
@ -93,12 +96,12 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
}
static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(tcp != NULL);
if (nread >= 0) {
ASSERT(nread == 4);
ASSERT(memcmp("PING", buf.base, nread) == 0);
ASSERT(memcmp("PING", buf->base, nread) == 0);
}
else {
ASSERT(nread == UV_EOF);
@ -145,11 +148,13 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(tcp_open) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t client;
uv_os_sock_t sock;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
startup();
sock = create_tcp_socket();
@ -159,7 +164,7 @@ TEST_IMPL(tcp_open) {
r = uv_tcp_open(&client, sock);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
ASSERT(r == 0);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

4
deps/uv/test/test-tcp-read-stop.c vendored
View File

@ -62,10 +62,10 @@ TEST_IMPL(tcp_read_stop) {
uv_connect_t connect_req;
struct sockaddr_in addr;
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle));
ASSERT(0 == uv_tcp_init(uv_default_loop(), &tcp_handle));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &tcp_handle, &addr, connect_cb));
ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT));
MAKE_VALGRIND_HAPPY();

13
deps/uv/test/test-tcp-shutdown-after-write.c vendored
View File

@ -49,9 +49,12 @@ static void close_cb(uv_handle_t* handle) {
}
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[64];
return uv_buf_init(slab, sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
@ -70,7 +73,7 @@ static void timer_cb(uv_timer_t* handle, int status) {
}
static void read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
}
@ -103,7 +106,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
uv_loop_t* loop;
int r;
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
r = uv_timer_init(loop, &timer);
@ -115,7 +118,7 @@ TEST_IMPL(tcp_shutdown_after_write) {
r = uv_tcp_init(loop, &conn);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &conn, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &conn, &addr, connect_cb);
ASSERT(r == 0);
r = uv_run(loop, UV_RUN_DEFAULT);

14
deps/uv/test/test-tcp-unexpected-read.c vendored
View File

@ -47,14 +47,14 @@ static void timer_cb(uv_timer_t* handle, int status) {
}
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
ASSERT(0 && "alloc_cb should not have been called");
/* Satisfy the compiler. */
return uv_buf_init(NULL, 0);
}
static void read_cb(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
ASSERT(0 && "read_cb should not have been called");
}
@ -88,7 +88,7 @@ TEST_IMPL(tcp_unexpected_read) {
struct sockaddr_in addr;
uv_loop_t* loop;
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
ASSERT(0 == uv_timer_init(loop, &timer_handle));
@ -98,9 +98,9 @@ TEST_IMPL(tcp_unexpected_read) {
ASSERT(0 == uv_tcp_init(loop, &server_handle));
ASSERT(0 == uv_tcp_init(loop, &client_handle));
ASSERT(0 == uv_tcp_init(loop, &peer_handle));
ASSERT(0 == uv_tcp_bind(&server_handle, addr));
ASSERT(0 == uv_tcp_bind(&server_handle, &addr));
ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, addr, connect_cb));
ASSERT(0 == uv_tcp_connect(&connect_req, &client_handle, &addr, connect_cb));
ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT));
/* This is somewhat inexact but the idea is that the event loop should not

23
deps/uv/test/test-tcp-write-to-half-open-connection.c vendored
View File

@ -29,8 +29,8 @@
static void connection_cb(uv_stream_t* server, int status);
static void connect_cb(uv_connect_t* req, int status);
static void write_cb(uv_write_t* req, int status);
static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf);
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf);
static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf);
static uv_tcp_t tcp_server;
static uv_tcp_t tcp_client;
@ -65,13 +65,16 @@ static void connection_cb(uv_stream_t* server, int status) {
}
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[1024];
return uv_buf_init(slab, sizeof slab);
buf->base = slab;
buf->len = sizeof(slab);
}
static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
if (nread < 0) {
fprintf(stderr, "read_cb error: %s\n", uv_err_name(nread));
ASSERT(nread == UV_ECONNRESET || nread == UV_EOF);
@ -100,16 +103,19 @@ static void write_cb(uv_write_t* req, int status) {
TEST_IMPL(tcp_write_to_half_open_connection) {
struct sockaddr_in addr;
uv_loop_t* loop;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
loop = uv_default_loop();
ASSERT(loop != NULL);
r = uv_tcp_init(loop, &tcp_server);
ASSERT(r == 0);
r = uv_tcp_bind(&tcp_server, uv_ip4_addr("127.0.0.1", TEST_PORT));
r = uv_tcp_bind(&tcp_server, &addr);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server, 1, connection_cb);
@ -118,10 +124,7 @@ TEST_IMPL(tcp_write_to_half_open_connection) {
r = uv_tcp_init(loop, &tcp_client);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req,
&tcp_client,
uv_ip4_addr("127.0.0.1", TEST_PORT),
connect_cb);
r = uv_tcp_connect(&connect_req, &tcp_client, &addr, connect_cb);
ASSERT(r == 0);
r = uv_run(loop, UV_RUN_DEFAULT);

15
deps/uv/test/test-tcp-writealot.c vendored
View File

@ -46,8 +46,9 @@ static uv_shutdown_t shutdown_req;
static uv_write_t write_reqs[WRITES];
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t size) {
return uv_buf_init(malloc(size), size);
static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) {
buf->base = malloc(size);
buf->len = size;
}
@ -76,7 +77,7 @@ static void shutdown_cb(uv_shutdown_t* req, int status) {
}
static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {
ASSERT(tcp != NULL);
if (nread >= 0) {
@ -88,7 +89,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
uv_close((uv_handle_t*)tcp, close_cb);
}
free(buf.base);
free(buf->base);
}
@ -140,17 +141,19 @@ static void connect_cb(uv_connect_t* req, int status) {
TEST_IMPL(tcp_writealot) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_tcp_t client;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
send_buffer = calloc(1, TOTAL_BYTES);
ASSERT(send_buffer != NULL);
r = uv_tcp_init(uv_default_loop(), &client);
ASSERT(r == 0);
r = uv_tcp_connect(&connect_req, &client, addr, connect_cb);
r = uv_tcp_connect(&connect_req, &client, &addr, connect_cb);
ASSERT(r == 0);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

4
deps/uv/test/test-udp-dgram-too-big.c vendored
View File

@ -68,9 +68,9 @@ TEST_IMPL(udp_dgram_too_big) {
ASSERT(r == 0);
buf = uv_buf_init(dgram, sizeof dgram);
addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_send(&req_, &handle_, &buf, 1, addr, send_cb);
r = uv_udp_send(&req_, &handle_, &buf, 1, &addr, send_cb);
ASSERT(r == 0);
ASSERT(close_cb_called == 0);

23
deps/uv/test/test-udp-ipv6.c vendored
View File

@ -44,10 +44,13 @@ static int recv_cb_called;
static int close_cb_called;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
CHECK_HANDLE(handle);
return uv_buf_init(slab, sizeof slab);
buf->base = slab;
buf->len = sizeof(slab);
}
@ -67,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);

25
deps/uv/test/test-udp-multicast-join.c vendored
View File

@ -38,13 +38,14 @@ static int sv_send_cb_called;
static int close_cb_called;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
CHECK_HANDLE(handle);
ASSERT(suggested_size <= sizeof slab);
return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
@ -67,8 +68,8 @@ static void sv_send_cb(uv_udp_send_t* req, int status) {
static void cl_recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(flags == 0);
@ -88,7 +89,7 @@ static void cl_recv_cb(uv_udp_t* handle,
ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(!memcmp("PING", buf.base, nread));
ASSERT(!memcmp("PING", buf->base, nread));
/* we are done with the client handle, we can close it */
uv_close((uv_handle_t*) &client, close_cb);
@ -99,7 +100,9 @@ TEST_IMPL(udp_multicast_join) {
int r;
uv_udp_send_t req;
uv_buf_t buf;
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
@ -108,7 +111,7 @@ TEST_IMPL(udp_multicast_join) {
ASSERT(r == 0);
/* bind to the desired port */
r = uv_udp_bind(&client, addr, 0);
r = uv_udp_bind(&client, &addr, 0);
ASSERT(r == 0);
/* join the multicast channel */
@ -121,7 +124,7 @@ TEST_IMPL(udp_multicast_join) {
buf = uv_buf_init("PING", 4);
/* server sends "PING" */
r = uv_udp_send(&req, &server, &buf, 1, addr, sv_send_cb);
r = uv_udp_send(&req, &server, &buf, 1, &addr, sv_send_cb);
ASSERT(r == 0);
ASSERT(close_cb_called == 0);

8
deps/uv/test/test-udp-multicast-ttl.c vendored
View File

@ -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);

23
deps/uv/test/test-udp-open.c vendored
View File

@ -67,10 +67,13 @@ static uv_os_sock_t create_udp_socket(void) {
}
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
ASSERT(suggested_size <= sizeof slab);
return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
@ -82,8 +85,8 @@ static void close_cb(uv_handle_t* handle) {
static void recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
int r;
@ -102,7 +105,7 @@ static void recv_cb(uv_udp_t* handle,
ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(memcmp("PING", buf.base, nread) == 0);
ASSERT(memcmp("PING", buf->base, nread) == 0);
r = uv_udp_recv_stop(handle);
ASSERT(r == 0);
@ -120,12 +123,14 @@ static void send_cb(uv_udp_send_t* req, int status) {
TEST_IMPL(udp_open) {
struct sockaddr_in addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
struct sockaddr_in addr;
uv_buf_t buf = uv_buf_init("PING", 4);
uv_udp_t client;
uv_os_sock_t sock;
int r;
ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
startup();
sock = create_udp_socket();
@ -135,13 +140,13 @@ TEST_IMPL(udp_open) {
r = uv_udp_open(&client, sock);
ASSERT(r == 0);
r = uv_udp_bind(&client, addr, 0);
r = uv_udp_bind(&client, &addr, 0);
ASSERT(r == 0);
r = uv_udp_recv_start(&client, alloc_cb, recv_cb);
ASSERT(r == 0);
r = uv_udp_send(&send_req, &client, &buf, 1, addr, send_cb);
r = uv_udp_send(&send_req, &client, &buf, 1, &addr, send_cb);
ASSERT(r == 0);
uv_run(uv_default_loop(), UV_RUN_DEFAULT);

5
deps/uv/test/test-udp-options.c vendored
View File

@ -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);

39
deps/uv/test/test-udp-send-and-recv.c vendored
View File

@ -41,13 +41,14 @@ static int sv_recv_cb_called;
static int close_cb_called;
static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
static void alloc_cb(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
static char slab[65536];
CHECK_HANDLE(handle);
ASSERT(suggested_size <= sizeof slab);
return uv_buf_init(slab, sizeof slab);
ASSERT(suggested_size <= sizeof(slab));
buf->base = slab;
buf->len = sizeof(slab);
}
@ -60,8 +61,8 @@ static void close_cb(uv_handle_t* handle) {
static void cl_recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(flags == 0);
@ -79,7 +80,7 @@ static void cl_recv_cb(uv_udp_t* handle,
ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(!memcmp("PONG", buf.base, nread));
ASSERT(!memcmp("PONG", buf->base, nread));
cl_recv_cb_called++;
@ -115,10 +116,11 @@ static void sv_send_cb(uv_udp_send_t* req, int status) {
static void sv_recv_cb(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
const uv_buf_t* rcvbuf,
const struct sockaddr* addr,
unsigned flags) {
uv_udp_send_t* req;
uv_buf_t sndbuf;
int r;
if (nread < 0) {
@ -137,7 +139,7 @@ static void sv_recv_cb(uv_udp_t* handle,
ASSERT(addr != NULL);
ASSERT(nread == 4);
ASSERT(!memcmp("PING", buf.base, nread));
ASSERT(!memcmp("PING", rcvbuf->base, nread));
/* FIXME? `uv_udp_recv_stop` does what it says: recv_cb is not called
* anymore. That's problematic because the read buffer won't be returned
@ -149,13 +151,12 @@ static void sv_recv_cb(uv_udp_t* handle,
req = malloc(sizeof *req);
ASSERT(req != NULL);
buf = uv_buf_init("PONG", 4);
sndbuf = uv_buf_init("PONG", 4);
r = uv_udp_send(req,
handle,
&buf,
&sndbuf,
1,
*(struct sockaddr_in*)addr,
(const struct sockaddr_in*) addr,
sv_send_cb);
ASSERT(r == 0);
@ -169,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);

2
src/process_wrap.cc
View File

@ -232,7 +232,7 @@ class ProcessWrap : public HandleWrap {
options.flags |= UV_PROCESS_DETACHED;
}
int err = uv_spawn(uv_default_loop(), &wrap->process_, options);
int err = uv_spawn(uv_default_loop(), &wrap->process_, &options);
if (err == 0) {
assert(wrap->process_.data == wrap);

51
src/stream_wrap.cc
View File

@ -127,10 +127,12 @@ void StreamWrap::ReadStop(const FunctionCallbackInfo<Value>& args) {
}
uv_buf_t StreamWrap::OnAlloc(uv_handle_t* handle, size_t suggested_size) {
void StreamWrap::OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
StreamWrap* wrap = static_cast<StreamWrap*>(handle->data);
assert(wrap->stream() == reinterpret_cast<uv_stream_t*>(handle));
return wrap->callbacks()->DoAlloc(handle, suggested_size);
wrap->callbacks()->DoAlloc(handle, suggested_size, buf);
}
@ -157,7 +159,7 @@ static Local<Object> AcceptHandle(uv_stream_t* pipe) {
void StreamWrap::OnReadCommon(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
HandleScope scope(node_isolate);
@ -179,13 +181,17 @@ void StreamWrap::OnReadCommon(uv_stream_t* handle,
}
void StreamWrap::OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf) {
void StreamWrap::OnRead(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
OnReadCommon(handle, nread, buf, UV_UNKNOWN_HANDLE);
}
void StreamWrap::OnRead2(uv_pipe_t* handle, ssize_t nread, uv_buf_t buf,
uv_handle_type pending) {
void StreamWrap::OnRead2(uv_pipe_t* handle,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending) {
OnReadCommon(reinterpret_cast<uv_stream_t*>(handle), nread, buf, pending);
}
@ -544,20 +550,23 @@ void StreamWrapCallbacks::AfterWrite(WriteWrap* w) {
}
uv_buf_t StreamWrapCallbacks::DoAlloc(uv_handle_t* handle,
size_t suggested_size) {
char* data = static_cast<char*>(malloc(suggested_size));
if (data == NULL && suggested_size > 0) {
FatalError("node::StreamWrapCallbacks::DoAlloc(uv_handle_t*, size_t)",
"Out Of Memory");
void StreamWrapCallbacks::DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = static_cast<char*>(malloc(suggested_size));
buf->len = suggested_size;
if (buf->base == NULL && suggested_size > 0) {
FatalError(
"node::StreamWrapCallbacks::DoAlloc(uv_handle_t*, size_t, uv_buf_t*)",
"Out Of Memory");
}
return uv_buf_init(data, suggested_size);
}
void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
HandleScope scope(node_isolate);
@ -568,21 +577,21 @@ void StreamWrapCallbacks::DoRead(uv_stream_t* handle,
};
if (nread < 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
MakeCallback(Self(), onread_sym, ARRAY_SIZE(argv), argv);
return;
}
if (nread == 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
return;
}
buf.base = static_cast<char*>(realloc(buf.base, nread));
assert(static_cast<size_t>(nread) <= buf.len);
argv[1] = Buffer::Use(buf.base, nread);
char* base = static_cast<char*>(realloc(buf->base, nread));
assert(static_cast<size_t>(nread) <= buf->len);
argv[1] = Buffer::Use(base, nread);
Local<Object> pending_obj;
if (pending == UV_TCP) {

26
src/stream_wrap.h
View File

@ -79,10 +79,12 @@ class StreamWrapCallbacks {
uv_stream_t* send_handle,
uv_write_cb cb);
virtual void AfterWrite(WriteWrap* w);
virtual uv_buf_t DoAlloc(uv_handle_t* handle, size_t suggested_size);
virtual void DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
virtual void DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending);
virtual int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);
@ -161,14 +163,22 @@ class StreamWrap : public HandleWrap {
private:
// Callbacks for libuv
static void AfterWrite(uv_write_t* req, int status);
static uv_buf_t OnAlloc(uv_handle_t* handle, size_t suggested_size);
static void OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
static void AfterShutdown(uv_shutdown_t* req, int status);
static void OnRead(uv_stream_t* handle, ssize_t nread, uv_buf_t buf);
static void OnRead2(uv_pipe_t* handle, ssize_t nread, uv_buf_t buf,
uv_handle_type pending);
static void OnReadCommon(uv_stream_t* handle, ssize_t nread,
uv_buf_t buf, uv_handle_type pending);
static void OnRead(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf);
static void OnRead2(uv_pipe_t* handle,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending);
static void OnReadCommon(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf,
uv_handle_type pending);
template <enum encoding encoding>
static void WriteStringImpl(const v8::FunctionCallbackInfo<v8::Value>& args);

49
src/tcp_wrap.cc
View File

@ -269,8 +269,10 @@ void TCPWrap::Bind(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip_address(args[0]);
int port = args[1]->Int32Value();
struct sockaddr_in address = uv_ip4_addr(*ip_address, port);
int err = uv_tcp_bind(&wrap->handle_, address);
sockaddr_in addr;
int err = uv_ip4_addr(*ip_address, port, &addr);
if (err == 0)
err = uv_tcp_bind(&wrap->handle_, &addr);
args.GetReturnValue().Set(err);
}
@ -285,8 +287,10 @@ void TCPWrap::Bind6(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip6_address(args[0]);
int port = args[1]->Int32Value();
struct sockaddr_in6 address = uv_ip6_addr(*ip6_address, port);
int err = uv_tcp_bind6(&wrap->handle_, address);
sockaddr_in6 addr;
int err = uv_ip6_addr(*ip6_address, port, &addr);
if (err == 0)
err = uv_tcp_bind6(&wrap->handle_, &addr);
args.GetReturnValue().Set(err);
}
@ -378,19 +382,15 @@ void TCPWrap::Connect(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip_address(args[1]);
int port = args[2]->Uint32Value();
struct sockaddr_in address = uv_ip4_addr(*ip_address, port);
sockaddr_in addr;
int err = uv_ip4_addr(*ip_address, port, &addr);
// I hate when people program C++ like it was C, and yet I do it too.
// I'm too lazy to come up with the perfect class hierarchy here. Let's
// just do some type munging.
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
int err = uv_tcp_connect(&req_wrap->req_,
&wrap->handle_,
address,
AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
if (err == 0) {
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
err = uv_tcp_connect(&req_wrap->req_, &wrap->handle_, &addr, AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
}
args.GetReturnValue().Set(err);
}
@ -410,16 +410,15 @@ void TCPWrap::Connect6(const FunctionCallbackInfo<Value>& args) {
String::AsciiValue ip_address(args[1]);
int port = args[2]->Int32Value();
struct sockaddr_in6 address = uv_ip6_addr(*ip_address, port);
sockaddr_in6 addr;
int err = uv_ip6_addr(*ip_address, port, &addr);
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
int err = uv_tcp_connect6(&req_wrap->req_,
&wrap->handle_,
address,
AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
if (err == 0) {
ConnectWrap* req_wrap = new ConnectWrap(req_wrap_obj);
err = uv_tcp_connect6(&req_wrap->req_, &wrap->handle_, &addr, AfterConnect);
req_wrap->Dispatched();
if (err) delete req_wrap;
}
args.GetReturnValue().Set(err);
}

11
src/tls_wrap.cc
View File

@ -512,16 +512,17 @@ void TLSCallbacks::AfterWrite(WriteWrap* w) {
}
uv_buf_t TLSCallbacks::DoAlloc(uv_handle_t* handle, size_t suggested_size) {
size_t size = suggested_size;
char* data = NodeBIO::FromBIO(enc_in_)->PeekWritable(&size);
return uv_buf_init(data, size);
void TLSCallbacks::DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = NodeBIO::FromBIO(enc_in_)->PeekWritable(&suggested_size);
buf->len = suggested_size;
}
void TLSCallbacks::DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending) {
if (nread < 0) {
// Error should be emitted only after all data was read

6
src/tls_wrap.h
View File

@ -50,10 +50,12 @@ class TLSCallbacks : public crypto::SSLWrap<TLSCallbacks>,
uv_stream_t* send_handle,
uv_write_cb cb);
void AfterWrite(WriteWrap* w);
uv_buf_t DoAlloc(uv_handle_t* handle, size_t suggested_size);
void DoAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
void DoRead(uv_stream_t* handle,
ssize_t nread,
uv_buf_t buf,
const uv_buf_t* buf,
uv_handle_type pending);
int DoShutdown(ShutdownWrap* req_wrap, uv_shutdown_cb cb);

90
src/udp_wrap.cc
View File

@ -159,11 +159,21 @@ void UDPWrap::DoBind(const FunctionCallbackInfo<Value>& args, int family) {
switch (family) {
case AF_INET:
err = uv_udp_bind(&wrap->handle_, uv_ip4_addr(*address, port), flags);
break;
{
sockaddr_in addr;
err = uv_ip4_addr(*address, port, &addr);
if (err == 0)
err = uv_udp_bind(&wrap->handle_, &addr, flags);
break;
}
case AF_INET6:
err = uv_udp_bind6(&wrap->handle_, uv_ip6_addr(*address, port), flags);
break;
{
sockaddr_in6 addr;
err = uv_ip6_addr(*address, port, &addr);
if (err == 0)
err = uv_udp_bind6(&wrap->handle_, &addr, flags);
break;
}
default:
assert(0 && "unexpected address family");
abort();
@ -270,21 +280,33 @@ void UDPWrap::DoSend(const FunctionCallbackInfo<Value>& args, int family) {
switch (family) {
case AF_INET:
err = uv_udp_send(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
uv_ip4_addr(*address, port),
OnSend);
break;
{
sockaddr_in addr;
err = uv_ip4_addr(*address, port, &addr);
if (err == 0) {
err = uv_udp_send(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
&addr,
OnSend);
}
break;
}
case AF_INET6:
err = uv_udp_send6(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
uv_ip6_addr(*address, port),
OnSend);
break;
{
sockaddr_in6 addr;
err = uv_ip6_addr(*address, port, &addr);
if (err == 0) {
err = uv_udp_send6(&req_wrap->req_,
&wrap->handle_,
&buf,
1,
&addr,
OnSend);
}
break;
}
default:
assert(0 && "unexpected address family");
abort();
@ -365,24 +387,27 @@ void UDPWrap::OnSend(uv_udp_send_t* req, int status) {
}
uv_buf_t UDPWrap::OnAlloc(uv_handle_t* handle, size_t suggested_size) {
char* data = static_cast<char*>(malloc(suggested_size));
if (data == NULL && suggested_size > 0) {
FatalError("node::UDPWrap::OnAlloc(uv_handle_t*, size_t)",
void UDPWrap::OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf) {
buf->base = static_cast<char*>(malloc(suggested_size));
buf->len = suggested_size;
if (buf->base == NULL && suggested_size > 0) {
FatalError("node::UDPWrap::OnAlloc(uv_handle_t*, size_t, uv_buf_t*)",
"Out Of Memory");
}
return uv_buf_init(data, suggested_size);
}
void UDPWrap::OnRecv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
unsigned flags) {
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned int flags) {
if (nread == 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
return;
}
@ -398,15 +423,14 @@ void UDPWrap::OnRecv(uv_udp_t* handle,
};
if (nread < 0) {
if (buf.base != NULL)
free(buf.base);
if (buf->base != NULL)
free(buf->base);
MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
return;
}
buf.base = static_cast<char*>(realloc(buf.base, nread));
argv[2] = Buffer::Use(buf.base, nread);
char* base = static_cast<char*>(realloc(buf->base, nread));
argv[2] = Buffer::Use(base, nread);
argv[3] = AddressToJS(addr);
MakeCallback(wrap_obj, onmessage_sym, ARRAY_SIZE(argv), argv);
}

10
src/udp_wrap.h
View File

@ -64,13 +64,15 @@ class UDPWrap: public HandleWrap {
static void SetMembership(const v8::FunctionCallbackInfo<v8::Value>& args,
uv_membership membership);
static uv_buf_t OnAlloc(uv_handle_t* handle, size_t suggested_size);
static void OnAlloc(uv_handle_t* handle,
size_t suggested_size,
uv_buf_t* buf);
static void OnSend(uv_udp_send_t* req, int status);
static void OnRecv(uv_udp_t* handle,
ssize_t nread,
uv_buf_t buf,
struct sockaddr* addr,
unsigned flags);
const uv_buf_t* buf,
const struct sockaddr* addr,
unsigned int flags);
uv_udp_t handle_;
};