* upgrade deps/uv/ to v0.11.12.
* update files in src/ after a libuv API change.
-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:
#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]; \
#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; \
/*
- * 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`.
* 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
* 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);
* 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
* (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 {
*/
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,
* 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 {
* 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 {
* 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.
* 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);
* 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`,
* 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`
};
/* 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);
/*
/* 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);
/*
- * 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]) {
}
-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) {
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++) {
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);
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;
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;
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;
}
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;
}
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);
}
-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;
}
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;
*/
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();
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;
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);
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);
}
-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))
&& (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;
}
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);
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);
}
}
(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)
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) &&
req->send_handle = send_handle;
QUEUE_INIT(&req->queue);
- if (bufcnt <= (int) ARRAY_SIZE(req->bufsml))
- req->bufs = req->bufsml;
- else
- req->bufs = malloc(sizeof(uv_buf_t) * bufcnt);
+ req->bufs = req->bufsml;
+ if (nbufs > ARRAY_SIZE(req->bufsml))
+ req->bufs = malloc(nbufs * sizeof(bufs[0]));
+
+ if (req->bufs == NULL)
+ return -ENOMEM;
- memcpy(req->bufs, bufs, bufcnt * sizeof(uv_buf_t));
- req->bufcnt = bufcnt;
+ memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));
+ req->nbufs = nbufs;
req->write_index = 0;
- stream->write_queue_size += uv__buf_count(bufs, bufcnt);
+ stream->write_queue_size += uv_count_bufs(bufs, nbufs);
/* Append the request to write_queue. */
QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue);
/* 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);
}
}
-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;
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;
}
-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;
}
-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,
}
-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));
}
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) {
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);
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
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);
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;
handle->recv_cb(handle,
nread,
- buf,
- (struct sockaddr*)&peer,
+ &buf,
+ (const struct sockaddr*) &peer,
flags);
}
}
}
-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;
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;
#endif
}
- if (bind(fd, addr, len) == -1) {
+ if (bind(fd, addr, addrlen)) {
err = -errno;
goto out;
}
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)
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);
}
-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;
}
-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) {
#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, '%');
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;
}
}
-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;
}
# 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);
#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
}
-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];
return uv_translate_sys_error(err);
}
- req->file_flags;
+ req->file_flags = flags;
if (cb) {
QUEUE_FS_TP_JOB(loop, req);
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,
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);
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,
/*
* 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);
}
-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;
}
}
}
- if (bufcnt == 1) {
+ if (nbufs == 1) {
ipc_frame.header.flags |= UV_IPC_RAW_DATA;
ipc_frame.header.raw_data_length = bufs[0].len;
}
}
/* 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 */
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;
}
}
-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);
}
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_);
}
}
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);
}
}
}
}
- 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;
}
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) {
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 */
/* _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 ||
}
-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;
}
-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;
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;
}
}
- 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;
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 {
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
/* 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)) {
}
/* 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) {
}
-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;
}
}
-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;
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);
}
-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;
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);
}
-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();
}
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();
}
-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;
*/
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);
}
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;
}
}
-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;
}
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;
}
memset(&req->overlapped, 0, sizeof(req->overlapped));
success = handle->func_connectex(handle->socket,
- (struct sockaddr*) &address,
- addrsize,
+ addr,
+ addrlen,
NULL,
0,
&bytes,
}
-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;
}
-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;
}
result = WSASend(handle->socket,
- (WSABUF*)bufs,
- bufcnt,
+ (WSABUF*) bufs,
+ nbufs,
&bytes,
0,
&req->overlapped,
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);
handle->read_cb((uv_stream_t*)handle,
uv_translate_sys_error(err),
- buf);
+ &buf);
}
} else {
if (!(handle->flags & UV_HANDLE_ZERO_READ)) {
/* 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;
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);
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;
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;
handle->read_cb((uv_stream_t*)handle,
uv_translate_sys_error(err),
- buf);
+ &buf);
}
break;
}
}
} 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;
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;
+}
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);
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;
}
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;
}
DECREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb((uv_stream_t*) handle,
uv_translate_sys_error(GetLastError()),
- buf);
+ &buf);
goto out;
}
records_left--;
DECREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb((uv_stream_t*) handle,
uv_translate_sys_error(GetLastError()),
- buf);
+ &buf);
goto out;
}
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);
/* 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;
}
/* 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:
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. */
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) &&
}
-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 { \
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;
}
-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);
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);
}
-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. */
sizeof no);
}
- r = bind(handle->socket, addr, addrsize);
+ r = bind(handle->socket, addr, addrlen);
if (r == SOCKET_ERROR) {
return WSAGetLastError();
}
}
-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;
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);
}
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;
}
}
-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;
result = WSASendTo(handle->socket,
(WSABUF*)bufs,
- bufcnt,
+ nbufs,
&bytes,
0,
addr,
- addr_len,
+ addrlen,
&req->overlapped,
NULL);
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 {
}
-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;
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;
}
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;
/* 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);
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);
}
}
}
/* 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);
}
/* 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);
}
\
/* 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); \
} \
#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;
+}
# 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
*/
#include <assert.h>
+#include <stdlib.h>
#include "uv.h"
#include "internal.h"
}
/* 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);
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);
}
-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;
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);
}
-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);
}
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));
}
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]));
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));
}
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;
}
}
-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;
if (nread < 0) {
ASSERT(nread == UV_EOF);
- if (buf.base) {
+ if (buf->base) {
buf_free(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++;
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;
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);
}
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);
}
}
-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);
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);
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;
}
-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);
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++];
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;
}
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);
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();
}
-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* 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;
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;
}
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();
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);
}
&s->udp_handle,
bufs,
ARRAY_SIZE(bufs),
- s->addr,
+ &s->addr,
send_cb));
send_cb_called++;
}
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;
}
ASSERT(addr->sa_family == AF_INET);
- ASSERT(!memcmp(buf.base, EXPECTED, nread));
+ ASSERT(!memcmp(buf->base, EXPECTED, nread));
recv_cb_called++;
}
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);
}
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));
}
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);
}
-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;
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);
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);
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];
readbuf_remaining = dns->state.prevbuf_rem;
usingprev = 1;
} else {
- dnsreq = buf.base;
+ dnsreq = buf->base;
readbuf_remaining = nread;
}
hdrstart = dnsreq;
if (usingprev == 1) {
/* free previous buffer */
free(dns->state.prevbuf_ptr);
- dnsreq = buf.base;
+ dnsreq = buf->base;
readbuf_remaining = nread;
usingprev = 0;
} else {
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);
if (nread == 0) {
/* Everything OK, but nothing read. */
- free(buf.base);
+ free(buf->base);
return;
}
/* process requests and send responses */
}
-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;
}
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 */
return 1;
}
- r = uv_tcp_bind(&server, addr);
+ r = uv_tcp_bind(&server, &addr);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Bind error\n");
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);
}
-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;
/* 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);
if (nread == 0) {
/* Everything OK, but nothing read. */
- free(buf.base);
+ free(buf->base);
return;
}
*/
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 {
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");
}
}
-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;
}
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);
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);
}
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;
return 1;
}
- r = uv_tcp_bind(&tcpServer, addr);
+ r = uv_tcp_bind(&tcpServer, &addr);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Bind error\n");
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;
}
/* 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");
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);
}
}
-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;
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");
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--;
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);
/* 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);
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;
}
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);
}
-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) {
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);
}
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);
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;
}
}
-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);
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);
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;
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. */
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;
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;
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);
}
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);
}
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;
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();
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);
r = uv_write2(&ctx.write_req,
(uv_stream_t*)&ctx.channel,
- &buf, 1,
+ &wrbuf,
+ 1,
&ctx.recv.stream,
write2_cb);
ASSERT(r == 0);
}
-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;
}
r = uv_tcp_init(uv_default_loop(), &conn->conn);
ASSERT(r == 0);
- addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+ ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
- r = uv_tcp_connect(&conn->conn_req, (uv_tcp_t*)&conn->conn, addr, connect_cb);
+ r = uv_tcp_connect(&conn->conn_req,
+ (uv_tcp_t*) &conn->conn,
+ &addr,
+ connect_cb);
ASSERT(r == 0);
conn->conn.data = conn;
}
-static void on_read(uv_pipe_t* pipe, ssize_t nread, uv_buf_t buf,
- uv_handle_type pending) {
+static void on_read(uv_pipe_t* pipe,
+ ssize_t nread,
+ const uv_buf_t* buf,
+ uv_handle_type pending) {
int r;
uv_buf_t outbuf;
if (nread == 0) {
/* Everything OK, but nothing read. */
- free(buf.base);
+ free(buf->base);
return;
}
if (nread < 0) {
if (nread == UV_EOF) {
- free(buf.base);
+ free(buf->base);
return;
}
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. */
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);
/* 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);
}
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);
}
}
-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++;
}
-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;
}
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 */
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);
r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read);
ASSERT(r == 0);
- free(buf.base);
+ free(buf->base);
}
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);
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);
}
-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;
}
}
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);
(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);
* 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);
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) {
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);
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);
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);
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);
}
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)
} 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;
}
}
-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;
ASSERT(nread == UV_EOF);
puts("got EOF");
- free(buf.base);
+ free(buf->base);
uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);
/* 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)
}
}
- free(buf.base);
+ free(buf->base);
}
/* 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;
/* 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. */
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;
/* 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. */
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);
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;
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);
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);
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);
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);
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);
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);
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");
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);
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) {
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);
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);
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);
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);
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;
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);
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);
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);
/* 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);
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);
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);
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
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
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);
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);
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);
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);
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);
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);
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);
}
-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;
}
}
-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;
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);
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);
}
-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;
}
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);
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);
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);
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);
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);
/* 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);
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();
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);
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);
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);
/* 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);
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();
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));
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);
* 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. */
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);
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);
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);
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);
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);
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);
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);
}
-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);
}
}
-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);
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();
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);
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();
}
-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);
}
}
-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) {
}
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);
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);
}
-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");
}
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));
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
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;
}
-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);
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);
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);
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;
}
}
-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) {
uv_close((uv_handle_t*)tcp, close_cb);
}
- free(buf.base);
+ free(buf->base);
}
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);
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);
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);
}
static void ipv6_recv_fail(uv_udp_t* handle,
ssize_t nread,
- uv_buf_t buf,
- struct sockaddr* addr,
+ const uv_buf_t* buf,
+ const struct sockaddr* addr,
unsigned flags) {
ASSERT(0 && "this function should not have been called");
}
static void ipv6_recv_ok(uv_udp_t* handle,
ssize_t nread,
- uv_buf_t buf,
- struct sockaddr* addr,
+ const uv_buf_t* buf,
+ const struct sockaddr* addr,
unsigned flags) {
CHECK_HANDLE(handle);
ASSERT(nread >= 0);
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);
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);
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);
}
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);
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);
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);
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 */
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);
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);
/* 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);
}
-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);
}
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;
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);
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();
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);
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);
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);
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);
}
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);
ASSERT(addr != NULL);
ASSERT(nread == 4);
- ASSERT(!memcmp("PONG", buf.base, nread));
+ ASSERT(!memcmp("PONG", buf->base, nread));
cl_recv_cb_called++;
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) {
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
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);
uv_buf_t buf;
int r;
- addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
+ ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr));
r = uv_udp_init(uv_default_loop(), &server);
ASSERT(r == 0);
- r = uv_udp_bind(&server, addr, 0);
+ r = uv_udp_bind(&server, &addr, 0);
ASSERT(r == 0);
r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb);
ASSERT(r == 0);
- addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
+ ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));
r = uv_udp_init(uv_default_loop(), &client);
ASSERT(r == 0);
/* client sends "PING", expects "PONG" */
buf = uv_buf_init("PING", 4);
- r = uv_udp_send(&req, &client, &buf, 1, addr, cl_send_cb);
+ r = uv_udp_send(&req, &client, &buf, 1, &addr, cl_send_cb);
ASSERT(r == 0);
ASSERT(close_cb_called == 0);
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);
}
-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);
}
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);
}
-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);
}
}
-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);
};
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) {
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);
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);
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);
}
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);
}
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);
}
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);
}
}
-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
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);
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();
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();
}
-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;
}
};
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);
}
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_;
};
projects / platform / upstream / nodejs.git / commitdiff