struct addrinfo* res; \
int retcode;
+#define UV_PROCESS_PRIVATE_FIELDS \
+ ev_child child_watcher;
+
#endif /* UV_UNIX_H */
typedef struct uv_idle_s uv_idle_t;
typedef struct uv_async_s uv_async_t;
typedef struct uv_getaddrinfo_s uv_getaddrinfo_t;
+typedef struct uv_process_s uv_process_t;
/* Request types */
typedef struct uv_req_s uv_req_t;
typedef struct uv_shutdown_s uv_shutdown_t;
typedef void (*uv_write_cb)(uv_write_t* req, int status);
typedef void (*uv_connect_cb)(uv_connect_t* req, int status);
typedef void (*uv_shutdown_cb)(uv_shutdown_t* req, int status);
-typedef void (*uv_connection_cb)(uv_handle_t* server, int status);
+typedef void (*uv_connection_cb)(uv_stream_t* server, int status);
typedef void (*uv_close_cb)(uv_handle_t* handle);
typedef void (*uv_timer_cb)(uv_timer_t* handle, int status);
/* TODO: do these really need a status argument? */
typedef void (*uv_check_cb)(uv_check_t* handle, int status);
typedef void (*uv_idle_cb)(uv_idle_t* handle, int status);
typedef void (*uv_getaddrinfo_cb)(uv_getaddrinfo_t* handle, int status, struct addrinfo* res);
+typedef void (*uv_exit_cb)(uv_process_t*, int exit_status, int term_signal);
/* Expand this list if necessary. */
UV_ASYNC,
UV_ARES_TASK,
UV_ARES_EVENT,
- UV_GETADDRINFO
+ UV_GETADDRINFO,
+ UV_PROCESS
} uv_handle_type;
typedef enum {
UV_STREAM_FIELDS
};
+int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb);
+
/* This call is used in conjunction with uv_listen() to accept incoming
* connections. Call uv_accept after receiving a uv_connection_cb to accept
* the connection. Before calling uv_accept use uv_*_init() must be
* once, it may fail. It is suggested to only call uv_accept once per
* uv_connection_cb call.
*/
-int uv_accept(uv_handle_t* server, uv_stream_t* client);
+int uv_accept(uv_stream_t* server, uv_stream_t* client);
/* Read data from an incoming stream. The callback will be made several
* several times until there is no more data to read or uv_read_stop is
int uv_read_stop(uv_stream_t*);
+typedef enum {
+ UV_STDIN = 0,
+ UV_STDOUT,
+ UV_STDERR
+} uv_std_type;
+
+uv_stream_t* uv_std_handle(uv_std_type type);
+
/*
* Write data to stream. Buffers are written in order. Example:
*
int uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle,
struct sockaddr_in6 address, uv_connect_cb cb);
-int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb);
-
int uv_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen);
int uv_pipe_bind(uv_pipe_t* handle, const char* name);
-int uv_pipe_listen(uv_pipe_t* handle, uv_connection_cb cb);
-
int uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
const char* name, uv_connect_cb cb);
const char* service,
const struct addrinfo* hints);
+/*
+ * Child process. Subclass of uv_handle_t.
+ */
+typedef struct uv_process_options_s {
+ uv_exit_cb exit_cb;
+ const char* file;
+ char** args;
+ char** env;
+ char* cwd;
+ /*
+ * The user should supply pointers to uninitialized uv_pipe_t structs for
+ * stdio. They will be initialized by uv_spawn. The user is reponsible for
+ * calling uv_close on them.
+ */
+ uv_pipe_t* stdin_stream;
+ uv_pipe_t* stdout_stream;
+ uv_pipe_t* stderr_stream;
+} uv_process_options_t;
+
+struct uv_process_s {
+ UV_HANDLE_FIELDS
+ uv_exit_cb exit_cb;
+ int pid;
+ UV_PROCESS_PRIVATE_FIELDS
+};
+
+/* Initializes uv_process_t and starts the process. */
+int uv_spawn(uv_process_t*, uv_process_options_t options);
+
+/*
+ * Kills the process with the specified signal. The user must still
+ * call uv_close on the process.
+ */
+int uv_process_kill(uv_process_t*, int signum);
+
/*
* Most functions return boolean: 0 for success and -1 for failure.
uint64_t idle_init;
uint64_t async_init;
uint64_t timer_init;
+ uint64_t process_init;
} uv_counters_t;
uv_counters_t* uv_counters();
<ClCompile Include="..\src\win\loop-watcher.c" />
<ClCompile Include="..\src\win\pipe.c" />
<ClCompile Include="..\src\win\req.c" />
+ <ClCompile Include="..\src\win\stdio.c" />
<ClCompile Include="..\src\win\stream.c" />
<ClCompile Include="..\src\win\tcp.c" />
<ClCompile Include="..\src\win\timer.c" />
#endif
+# ifdef __APPLE__
+# include <crt_externs.h>
+# define environ (*_NSGetEnviron())
+# else
+extern char **environ;
+# endif
+
+
static uv_err_t last_err;
struct uv_ares_data_s {
static void uv__finish_close(uv_handle_t* handle);
static uv_err_t uv_err_new(uv_handle_t* handle, int sys_error);
+static int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb);
+static int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
static uv_write_t* uv__write(uv_stream_t* stream);
static void uv__read(uv_stream_t* stream);
static void uv__stream_connect(uv_stream_t*);
uv_pipe_t* pipe;
uv_async_t* async;
uv_timer_t* timer;
+ uv_process_t* process;
handle->close_cb = close_cb;
ev_io_stop(EV_DEFAULT_ &pipe->write_watcher);
break;
+ case UV_PROCESS:
+ process = (uv_process_t*)handle;
+ ev_child_stop(EV_DEFAULT_UC_ &process->child_watcher);
+ break;
+
default:
assert(0);
}
}
-int uv__bind(uv_tcp_t* tcp, int domain, struct sockaddr* addr, int addrsize) {
+static int uv__bind(uv_tcp_t* tcp, int domain, struct sockaddr* addr,
+ int addrsize) {
int saved_errno;
int status;
int fd;
return -1;
}
- return uv__bind(tcp, AF_INET, (struct sockaddr*)&addr, sizeof(struct sockaddr_in));
+ return uv__bind(tcp, AF_INET, (struct sockaddr*)&addr,
+ sizeof(struct sockaddr_in));
}
return -1;
}
- return uv__bind(tcp, AF_INET6, (struct sockaddr*)&addr, sizeof(struct sockaddr_in6));
+ return uv__bind(tcp, AF_INET6, (struct sockaddr*)&addr,
+ sizeof(struct sockaddr_in6));
}
return;
} else {
uv_err_new((uv_handle_t*)stream, errno);
- stream->connection_cb((uv_handle_t*)stream, -1);
+ stream->connection_cb((uv_stream_t*)stream, -1);
}
} else {
stream->accepted_fd = fd;
- stream->connection_cb((uv_handle_t*)stream, 0);
+ stream->connection_cb((uv_stream_t*)stream, 0);
if (stream->accepted_fd >= 0) {
/* The user hasn't yet accepted called uv_accept() */
ev_io_stop(EV_DEFAULT_ &stream->read_watcher);
}
-int uv_accept(uv_handle_t* server, uv_stream_t* client) {
+int uv_accept(uv_stream_t* server, uv_stream_t* client) {
uv_stream_t* streamServer;
uv_stream_t* streamClient;
int saved_errno;
streamClient = (uv_stream_t*)client;
if (streamServer->accepted_fd < 0) {
- uv_err_new(server, EAGAIN);
+ uv_err_new((uv_handle_t*)server, EAGAIN);
goto out;
}
}
-int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
+int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
+ switch (stream->type) {
+ case UV_TCP:
+ return uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
+ case UV_NAMED_PIPE:
+ return uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
+ default:
+ assert(0);
+ return -1;
+ }
+}
+
+
+static int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
int r;
int fd;
break;
}
+ case UV_PROCESS:
+ assert(!ev_is_active(&((uv_process_t*)handle)->child_watcher));
+ break;
+
default:
assert(0);
break;
/*
- * This is called once per second by ares_data.timer. It is used to
+ * This is called once per second by ares_data.timer. It is used to
* constantly callback into c-ares for possibly processing timeouts.
*/
static void uv__ares_timeout(EV_P_ struct ev_timer* watcher, int revents) {
}
-int uv_pipe_listen(uv_pipe_t* handle, uv_connection_cb cb) {
+static int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
int saved_errno;
int status;
}
assert(handle->fd >= 0);
- if ((status = listen(handle->fd, SOMAXCONN)) == -1) {
+ if ((status = listen(handle->fd, backlog)) == -1) {
uv_err_new((uv_handle_t*)handle, errno);
} else {
handle->connection_cb = cb;
}
} else {
pipe->accepted_fd = sockfd;
- pipe->connection_cb((uv_handle_t*)pipe, 0);
+ pipe->connection_cb((uv_stream_t*)pipe, 0);
if (pipe->accepted_fd == sockfd) {
/* The user hasn't yet accepted called uv_accept() */
ev_io_stop(EV_DEFAULT_ &pipe->read_watcher);
return src - org;
}
+
+
+uv_stream_t* uv_std_handle(uv_std_type type) {
+ assert(0 && "implement me");
+}
+
+
+static void uv__chld(EV_P_ ev_child* watcher, int revents) {
+ int status = watcher->rstatus;
+ int exit_status = 0;
+ int term_signal = 0;
+ uv_process_t *process = watcher->data;
+
+ assert(&process->child_watcher == watcher);
+ assert(revents & EV_CHILD);
+
+ ev_child_stop(EV_A_ &process->child_watcher);
+
+ if (WIFEXITED(status)) {
+ exit_status = WEXITSTATUS(status);
+ }
+
+ if (WIFSIGNALED(status)) {
+ term_signal = WTERMSIG(status);
+ }
+
+ if (process->exit_cb) {
+ process->exit_cb(process, exit_status, term_signal);
+ }
+}
+
+
+int uv_spawn(uv_process_t* process, uv_process_options_t options) {
+ /*
+ * Save environ in the case that we get it clobbered
+ * by the child process.
+ */
+ char** save_our_env = environ;
+ int stdin_pipe[2] = { -1, -1 };
+ int stdout_pipe[2] = { -1, -1 };
+ int stderr_pipe[2] = { -1, -1 };
+ pid_t pid;
+
+ uv__handle_init((uv_handle_t*)process, UV_PROCESS);
+ uv_counters()->process_init++;
+
+ process->exit_cb = options.exit_cb;
+
+
+ if (options.stdin_stream && pipe(stdin_pipe) < 0) {
+ goto error;
+ }
+
+ if (options.stdout_stream && pipe(stdout_pipe) < 0) {
+ goto error;
+ }
+
+ if (options.stderr_stream && pipe(stderr_pipe) < 0) {
+ goto error;
+ }
+
+ pid = fork();
+
+ if (pid == 0) {
+ if (stdin_pipe[0] >= 0) {
+ close(stdin_pipe[1]);
+ dup2(stdin_pipe[0], STDIN_FILENO);
+ }
+
+ if (stdout_pipe[1] >= 0) {
+ close(stdout_pipe[0]);
+ dup2(stdout_pipe[1], STDOUT_FILENO);
+ }
+
+ if (stderr_pipe[1] >= 0) {
+ close(stderr_pipe[0]);
+ dup2(stderr_pipe[1], STDERR_FILENO);
+ }
+
+ if (options.cwd && chdir(options.cwd)) {
+ perror("chdir()");
+ _exit(127);
+ }
+
+ environ = options.env;
+
+ execvp(options.file, options.args);
+ perror("execvp()");
+ _exit(127);
+ /* Execution never reaches here. */
+ } else if (pid == -1) {
+ /* Restore environment. */
+ environ = save_our_env;
+ goto error;
+ }
+
+ /* Parent. */
+
+ /* Restore environment. */
+ environ = save_our_env;
+
+ process->pid = pid;
+
+ ev_child_init(&process->child_watcher, uv__chld, pid, 0);
+ ev_child_start(EV_DEFAULT_UC_ &process->child_watcher);
+ process->child_watcher.data = process;
+
+ if (stdin_pipe[1] >= 0) {
+ assert(options.stdin_stream);
+ assert(stdin_pipe[0] >= 0);
+ close(stdin_pipe[0]);
+ uv__nonblock(stdin_pipe[1], 1);
+ uv_pipe_init(options.stdin_stream);
+ uv__stream_open((uv_stream_t*)options.stdin_stream, stdin_pipe[1]);
+ }
+
+ if (stdout_pipe[0] >= 0) {
+ assert(options.stdout_stream);
+ assert(stdout_pipe[1] >= 0);
+ close(stdout_pipe[1]);
+ uv__nonblock(stdout_pipe[0], 1);
+ uv_pipe_init(options.stdout_stream);
+ uv__stream_open((uv_stream_t*)options.stdout_stream, stdout_pipe[0]);
+ }
+
+ if (stderr_pipe[0] >= 0) {
+ assert(options.stderr_stream);
+ assert(stderr_pipe[1] >= 0);
+ close(stderr_pipe[1]);
+ uv__nonblock(stderr_pipe[0], 1);
+ uv_pipe_init(options.stderr_stream);
+ uv__stream_open((uv_stream_t*)options.stderr_stream, stderr_pipe[0]);
+ }
+
+ return 0;
+
+error:
+ uv_err_new((uv_handle_t*)process, errno);
+ close(stdin_pipe[0]);
+ close(stdin_pipe[1]);
+ close(stdout_pipe[0]);
+ close(stdout_pipe[1]);
+ close(stderr_pipe[0]);
+ close(stderr_pipe[1]);
+ return -1;
+}
+
+
+int uv_process_kill(uv_process_t* process, int signum) {
+ int r = kill(process->pid, signum);
+
+ if (r) {
+ uv_err_new((uv_handle_t*)process, errno);
+ return -1;
+ } else {
+ return 0;
+ }
+}
#define UV_HANDLE_IPV6 0x2000
#define UV_HANDLE_PIPESERVER 0x4000
#define UV_HANDLE_READ_PENDING 0x8000
+#define UV_HANDLE_GIVEN_OS_HANDLE 0x10000
+#define UV_HANDLE_UV_ALLOCED 0x20000
void uv_want_endgame(uv_handle_t* handle);
void uv_process_endgames();
void uv_tcp_endgame(uv_tcp_t* handle);
+int uv_tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb);
int uv_tcp_accept(uv_tcp_t* server, uv_tcp_t* client);
int uv_tcp_read_start(uv_tcp_t* handle, uv_alloc_cb alloc_cb,
uv_read_cb read_cb);
/*
* Pipes
*/
+int uv_pipe_init_with_handle(uv_pipe_t* handle, HANDLE pipeHandle);
void close_pipe(uv_pipe_t* handle, int* status, uv_err_t* err);
void uv_pipe_endgame(uv_pipe_t* handle);
+int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb);
int uv_pipe_accept(uv_pipe_t* server, uv_pipe_t* client);
int uv_pipe_read_start(uv_pipe_t* handle, uv_alloc_cb alloc_cb,
uv_read_cb read_cb);
}
+int uv_pipe_init_with_handle(uv_pipe_t* handle, HANDLE pipeHandle) {
+ int err = uv_pipe_init(handle);
+
+ if (!err) {
+ /*
+ * At this point we don't know whether the pipe will be used as a client
+ * or a server. So, we assume that it will be a client until
+ * uv_listen is called.
+ */
+ handle->handle = pipeHandle;
+ handle->flags |= UV_HANDLE_GIVEN_OS_HANDLE;
+ }
+
+ return err;
+}
+
+
static int uv_set_pipe_handle(uv_pipe_t* handle, HANDLE pipeHandle) {
DWORD mode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT;
handle->close_cb((uv_handle_t*)handle);
}
+ if (handle->flags & UV_HANDLE_UV_ALLOCED) {
+ free(handle);
+ }
+
uv_unref();
}
}
req->next_pending = NULL;
req->pipeHandle = INVALID_HANDLE_VALUE;
- if (!(server->flags & UV_HANDLE_CLOSING)) {
+ if (!(server->flags & UV_HANDLE_CLOSING) &&
+ !(server->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
uv_pipe_queue_accept(server, req, FALSE);
}
/* Starts listening for connections for the given pipe. */
-int uv_pipe_listen(uv_pipe_t* handle, uv_connection_cb cb) {
+int uv_pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) {
int i, errno;
+ uv_pipe_accept_t* req;
+ HANDLE pipeHandle;
if (handle->flags & UV_HANDLE_BIND_ERROR) {
LOOP->last_error = handle->error;
return -1;
}
- if (!(handle->flags & UV_HANDLE_BOUND)) {
+ if (!(handle->flags & UV_HANDLE_BOUND) &&
+ !(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
uv_set_error(UV_ENOTCONN, 0);
return -1;
}
return -1;
}
- if (!(handle->flags & UV_HANDLE_PIPESERVER)) {
+ if (!(handle->flags & UV_HANDLE_PIPESERVER) &&
+ !(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
uv_set_error(UV_ENOTSUP, 0);
return -1;
}
handle->flags |= UV_HANDLE_LISTENING;
handle->connection_cb = cb;
- /* First pipe handle should have already been created in uv_pipe_bind */
- assert(handle->accept_reqs[0].pipeHandle != INVALID_HANDLE_VALUE);
+ if (handle->flags & UV_HANDLE_GIVEN_OS_HANDLE) {
+ handle->flags |= UV_HANDLE_PIPESERVER;
+ pipeHandle = handle->handle;
+ assert(pipeHandle != INVALID_HANDLE_VALUE);
+ req = &handle->accept_reqs[0];
+ uv_req_init((uv_req_t*) req);
+ req->pipeHandle = pipeHandle;
+ req->type = UV_ACCEPT;
+ req->data = handle;
+ req->next_pending = NULL;
- for (i = 0; i < COUNTOF(handle->accept_reqs); i++) {
- uv_pipe_queue_accept(handle, &handle->accept_reqs[i], i == 0);
+ if (uv_set_pipe_handle(handle, pipeHandle)) {
+ uv_set_sys_error(GetLastError());
+ return -1;
+ }
+
+ uv_pipe_queue_accept(handle, req, TRUE);
+ } else {
+ /* First pipe handle should have already been created in uv_pipe_bind */
+ assert(handle->accept_reqs[0].pipeHandle != INVALID_HANDLE_VALUE);
+
+ for (i = 0; i < COUNTOF(handle->accept_reqs); i++) {
+ uv_pipe_queue_accept(handle, &handle->accept_reqs[i], i == 0);
+ }
}
return 0;
handle->pending_accepts = req;
if (handle->connection_cb) {
- handle->connection_cb((uv_handle_t*)handle, 0);
+ handle->connection_cb((uv_stream_t*)handle, 0);
}
} else {
if (req->pipeHandle != INVALID_HANDLE_VALUE) {
CloseHandle(req->pipeHandle);
req->pipeHandle = INVALID_HANDLE_VALUE;
}
- if (!(handle->flags & UV_HANDLE_CLOSING)) {
+ if (!(handle->flags & UV_HANDLE_CLOSING) &&
+ !(handle->flags & UV_HANDLE_GIVEN_OS_HANDLE)) {
uv_pipe_queue_accept(handle, req, FALSE);
}
}
--- /dev/null
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <assert.h>
+#include <string.h>
+
+#include "uv.h"
+#include "../uv-common.h"
+#include "internal.h"
+
+
+static uv_pipe_t* uv_make_pipe_for_std_handle(HANDLE handle) {
+ uv_pipe_t* pipe = NULL;
+
+ pipe = (uv_pipe_t*)malloc(sizeof(uv_pipe_t));
+ if (!pipe) {
+ uv_fatal_error(ERROR_OUTOFMEMORY, "malloc");
+ }
+
+ if (uv_pipe_init_with_handle(pipe, handle)) {
+ free(pipe);
+ return NULL;
+ }
+
+ pipe->flags |= UV_HANDLE_UV_ALLOCED;
+ return pipe;
+}
+
+
+uv_stream_t* uv_std_handle(uv_std_type type) {
+ HANDLE handle;
+
+ switch (type) {
+ case UV_STDIN:
+ handle = GetStdHandle(STD_INPUT_HANDLE);
+ if (handle == INVALID_HANDLE_VALUE) {
+ return NULL;
+ }
+
+ /* Assume only named pipes for now. */
+ return (uv_stream_t*)uv_make_pipe_for_std_handle(handle);
+ break;
+
+ case UV_STDOUT:
+ return NULL;
+ break;
+
+ case UV_STDERR:
+ return NULL;
+ break;
+
+ default:
+ assert(0);
+ uv_set_error(UV_EINVAL, 0);
+ return NULL;
+ }
+}
}
-int uv_accept(uv_handle_t* server, uv_stream_t* client) {
+int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
+ switch (stream->type) {
+ case UV_TCP:
+ return uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
+ case UV_NAMED_PIPE:
+ return uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
+ default:
+ assert(0);
+ return -1;
+ }
+}
+
+
+int uv_accept(uv_stream_t* server, uv_stream_t* client) {
assert(client->type == server->type);
- if (server->type == UV_TCP) {
- return uv_tcp_accept((uv_tcp_t*)server, (uv_tcp_t*)client);
- } else if (server->type == UV_NAMED_PIPE) {
- return uv_pipe_accept((uv_pipe_t*)server, (uv_pipe_t*)client);
+ switch (server->type) {
+ case UV_TCP:
+ return uv_tcp_accept((uv_tcp_t*)server, (uv_tcp_t*)client);
+ case UV_NAMED_PIPE:
+ return uv_pipe_accept((uv_pipe_t*)server, (uv_pipe_t*)client);
+ default:
+ assert(0);
+ return -1;
}
-
- return -1;
}
int uv_read_start(uv_stream_t* handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb) {
- if (handle->type == UV_TCP) {
- return uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
- } else if (handle->type == UV_NAMED_PIPE) {
- return uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
+ switch (handle->type) {
+ case UV_TCP:
+ return uv_tcp_read_start((uv_tcp_t*)handle, alloc_cb, read_cb);
+ case UV_NAMED_PIPE:
+ return uv_pipe_read_start((uv_pipe_t*)handle, alloc_cb, read_cb);
+ default:
+ assert(0);
+ return -1;
}
-
- return -1;
}
int uv_write(uv_write_t* req, uv_stream_t* handle, uv_buf_t bufs[], int bufcnt,
uv_write_cb cb) {
- if (handle->type == UV_TCP) {
- return uv_tcp_write(req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
- } else if (handle->type == UV_NAMED_PIPE) {
- return uv_pipe_write(req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
+ switch (handle->type) {
+ case UV_TCP:
+ return uv_tcp_write(req, (uv_tcp_t*) handle, bufs, bufcnt, cb);
+ case UV_NAMED_PIPE:
+ return uv_pipe_write(req, (uv_pipe_t*) handle, bufs, bufcnt, cb);
+ default:
+ assert(0);
+ uv_set_sys_error(WSAEINVAL);
+ return -1;
}
-
- uv_set_sys_error(WSAEINVAL);
- return -1;
}
handle->flags &= ~UV_HANDLE_LISTENING;
if (handle->connection_cb) {
LOOP->last_error = req->error;
- handle->connection_cb((uv_handle_t*)handle, -1);
+ handle->connection_cb((uv_stream_t*)handle, -1);
}
}
} else if (req->error.code == UV_OK &&
sizeof(handle->socket)) == 0) {
/* Accept and SO_UPDATE_ACCEPT_CONTEXT were successful. */
if (handle->connection_cb) {
- handle->connection_cb((uv_handle_t*)handle, 0);
+ handle->connection_cb((uv_stream_t*)handle, 0);
}
} else {
/* Error related to accepted socket is ignored because the server */
static uv_tcp_t tcpServer;
static uv_pipe_t pipeServer;
-static uv_handle_t* server;
+static uv_stream_t* server;
static struct sockaddr_in listen_addr;
static struct sockaddr_in connect_addr;
*/
if (uv_now() - start_time > 1000 && read_sockets == 0) {
read_show_stats();
- uv_close(server, NULL);
+ uv_close((uv_handle_t*)server, NULL);
}
}
}
-static void connection_cb(uv_handle_t* s, int status) {
+static void connection_cb(uv_stream_t* s, int status) {
uv_stream_t* stream;
int r;
listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
/* Server */
- server = (uv_handle_t*)&tcpServer;
+ server = (uv_stream_t*)&tcpServer;
r = uv_tcp_init(&tcpServer);
ASSERT(r == 0);
r = uv_tcp_bind(&tcpServer, listen_addr);
ASSERT(r == 0);
- r = uv_tcp_listen(&tcpServer, MAX_WRITE_HANDLES, connection_cb);
+ r = uv_listen((uv_stream_t*)&tcpServer, MAX_WRITE_HANDLES, connection_cb);
ASSERT(r == 0);
uv_run();
uv_init();
/* Server */
- server = (uv_handle_t*)&pipeServer;
+ server = (uv_stream_t*)&pipeServer;
r = uv_pipe_init(&pipeServer);
ASSERT(r == 0);
r = uv_pipe_bind(&pipeServer, TEST_PIPENAME);
ASSERT(r == 0);
- r = uv_pipe_listen(&pipeServer, connection_cb);
+ r = uv_listen((uv_stream_t*)&pipeServer, MAX_WRITE_HANDLES, connection_cb);
ASSERT(r == 0);
uv_run();
static void after_read(uv_stream_t*, ssize_t nread, 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_handle_t*, int status);
+static void on_connection(uv_stream_t*, int status);
#define WRITE_BUF_LEN (64*1024)
#define DNSREC_LEN (4)
}
-static void on_connection(uv_handle_t* server, int status) {
+static void on_connection(uv_stream_t* server, int status) {
dnshandle* handle;
int r;
return 1;
}
- r = uv_tcp_listen(&server, 128, on_connection);
+ r = uv_listen((uv_stream_t*)&server, 128, on_connection);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Listen error\n");
static void after_read(uv_stream_t*, ssize_t nread, 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_handle_t*, int status);
+static void on_connection(uv_stream_t*, int status);
static void after_write(uv_write_t* req, int status) {
}
-static void on_connection(uv_handle_t* server, int status) {
+static void on_connection(uv_stream_t* server, int status) {
uv_stream_t* stream;
int r;
return 1;
}
- r = uv_tcp_listen(&tcpServer, 128, on_connection);
+ r = uv_listen((uv_stream_t*)&tcpServer, 128, on_connection);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Listen error\n");
return 0;
}
- r = uv_tcp_listen(&tcpServer, 128, on_connection);
+ r = uv_listen((uv_stream_t*)&tcpServer, 128, on_connection);
if (r) {
/* TODO: Error codes */
fprintf(stderr, "Listen error\n");
return 1;
}
- r = uv_pipe_listen(&pipeServer, on_connection);
+ r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);
if (r) {
fprintf(stderr, "uv_pipe_listen: %s\n", uv_strerror(uv_last_error()));
return 1;
int main(int argc, char **argv) {
+ int i;
+
platform_init(argc, argv);
switch (argc) {
case 1: return run_tests(TEST_TIMEOUT, 0);
- case 2: return run_test(argv[1], TEST_TIMEOUT, 0);
+ case 2: {
+ if (strcmp(argv[1], "spawn_helper1") == 0) {
+ return 1;
+ }
+
+ if (strcmp(argv[1], "spawn_helper2") == 0) {
+ printf("hello world\n");
+ return 1;
+ }
+
+ return run_test(argv[1], TEST_TIMEOUT, 0);
+ }
case 3: return run_test_part(argv[1], argv[2]);
default:
LOGF("Too many arguments.\n");
tcpcnt = uv_counters()->tcp_init;
server = (uv_tcp_t*)timer_handle->data;
- r = uv_accept((uv_handle_t*)server, (uv_stream_t*)accepted_handle);
+ r = uv_accept((uv_stream_t*)server, (uv_stream_t*)accepted_handle);
ASSERT(r == 0);
ASSERT(uv_counters()->tcp_init == tcpcnt);
}
-static void connection_cb(uv_handle_t* tcp, int status) {
+static void connection_cb(uv_stream_t* tcp, int status) {
int r;
uv_timer_t* timer_handle;
r = uv_tcp_bind(server, addr);
ASSERT(r == 0);
- r = uv_tcp_listen(server, 128, connection_cb);
+ r = uv_listen((uv_stream_t*)server, 128, connection_cb);
ASSERT(r == 0);
}
}
-static void on_connection(uv_handle_t* server, int status) {
+static void on_connection(uv_stream_t* server, int status) {
struct sockaddr sockname;
int namelen = sizeof(sockname);
uv_handle_t* handle;
return 1;
}
- r = uv_tcp_listen(&tcpServer, 128, on_connection);
+ r = uv_listen((uv_stream_t*)&tcpServer, 128, on_connection);
if (r) {
fprintf(stderr, "Listen error\n");
return 1;
TEST_DECLARE (getsockname)
TEST_DECLARE (fail_always)
TEST_DECLARE (pass_always)
+TEST_DECLARE (spawn_exit_code)
+TEST_DECLARE (spawn_stdout)
HELPER_DECLARE (tcp4_echo_server)
HELPER_DECLARE (tcp6_echo_server)
HELPER_DECLARE (pipe_echo_server)
TEST_ENTRY (getsockname)
+ TEST_ENTRY (spawn_exit_code)
+ TEST_ENTRY (spawn_stdout)
+
#if 0
/* These are for testing the test runner. */
TEST_ENTRY (fail_always)
ASSERT(uv_last_error().code == UV_EADDRINUSE);
- r = uv_pipe_listen(&server1, NULL);
+ r = uv_listen((uv_stream_t*)&server1, SOMAXCONN, NULL);
ASSERT(r == 0);
- r = uv_pipe_listen(&server2, NULL);
+ r = uv_listen((uv_stream_t*)&server2, SOMAXCONN, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRINUSE);
r = uv_pipe_init(&server);
ASSERT(r == 0);
- r = uv_pipe_listen(&server, NULL);
+ r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_ENOTCONN);
--- /dev/null
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "uv.h"
+#include "task.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+static int close_cb_called;
+static int exit_cb_called;
+static uv_process_t process;
+static uv_process_options_t options = { 0 };
+static char exepath[1024];
+static size_t exepath_size = 1024;
+static char* args[3];
+
+#define OUTPUT_SIZE 1024
+static char output[OUTPUT_SIZE];
+static int output_used;
+
+
+static void close_cb(uv_handle_t* handle) {
+ printf("close_cb\n");
+ close_cb_called++;
+}
+
+
+static void exit_cb(uv_process_t* process, int exit_status, int term_signal) {
+ printf("exit_cb\n");
+ exit_cb_called++;
+ ASSERT(exit_status == 1);
+ ASSERT(term_signal == 0);
+ uv_close((uv_handle_t*)process, close_cb);
+}
+
+
+uv_buf_t on_alloc(uv_stream_t* tcp, size_t suggested_size) {
+ uv_buf_t buf;
+ buf.base = output + output_used;
+ buf.len = OUTPUT_SIZE - output_used;
+ return buf;
+}
+
+
+void on_read(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
+ uv_err_t err = uv_last_error();
+
+ if (nread > 0) {
+ output_used += nread;
+ } else if (nread < 0) {
+ if (err.code == UV_EOF) {
+ uv_close((uv_handle_t*)tcp, close_cb);
+ }
+ }
+}
+
+
+static void init_process_options(char* test) {
+ /* Note spawn_helper1 defined in test/run-tests.c */
+ int r = uv_exepath(exepath, &exepath_size);
+ ASSERT(r == 0);
+ exepath[exepath_size] = '\0';
+ args[0] = exepath;
+ args[1] = test;
+ args[2] = NULL;
+ options.file = exepath;
+ options.args = args;
+ options.exit_cb = exit_cb;
+}
+
+
+TEST_IMPL(spawn_exit_code) {
+ int r;
+
+ uv_init();
+
+ init_process_options("spawn_helper1");
+
+ r = uv_spawn(&process, options);
+ ASSERT(r == 0);
+
+ r = uv_run();
+ ASSERT(r == 0);
+
+ ASSERT(exit_cb_called == 1);
+ ASSERT(close_cb_called == 1);
+
+ return 0;
+}
+
+
+TEST_IMPL(spawn_stdout) {
+ int r;
+ uv_pipe_t out;
+
+ uv_init();
+
+ init_process_options("spawn_helper2");
+ options.stdout_stream = &out;
+
+ r = uv_spawn(&process, options);
+ ASSERT(r == 0);
+
+ r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read);
+ ASSERT(r == 0);
+
+ r = uv_run();
+ ASSERT(r == 0);
+
+ ASSERT(exit_cb_called == 1);
+ ASSERT(close_cb_called == 2); /* Once for process once for the pipe. */
+ ASSERT(strcmp("hello world\n", output) == 0);
+
+ return 0;
+}
+
r = uv_tcp_bind(&server2, addr);
ASSERT(r == 0);
- r = uv_tcp_listen(&server1, 128, NULL);
+ r = uv_listen((uv_stream_t*)&server1, 128, NULL);
ASSERT(r == 0);
- r = uv_tcp_listen(&server2, 128, NULL);
+ r = uv_listen((uv_stream_t*)&server2, 128, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRINUSE);
uv_init();
r = uv_tcp_init(&server);
ASSERT(r == 0);
- r = uv_tcp_listen(&server, 128, NULL);
+ r = uv_listen((uv_stream_t*)&server, 128, NULL);
ASSERT(r == 0);
return 0;
r = uv_tcp_bind6(&server2, addr);
ASSERT(r == 0);
- r = uv_tcp_listen(&server1, 128, NULL);
+ r = uv_listen((uv_stream_t*)&server1, 128, NULL);
ASSERT(r == 0);
- r = uv_tcp_listen(&server2, 128, NULL);
+ r = uv_listen((uv_stream_t*)&server2, 128, NULL);
ASSERT(r == -1);
ASSERT(uv_last_error().code == UV_EADDRINUSE);
projects / platform / upstream / nodejs.git / commitdiff