static void read_cb(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* rdbuf) {
uv_buf_t wrbuf;
uv_pipe_t* pipe;
uv_handle_type pending;
int r;
union handles* recv;
uv_write_t* write_req;
if (nread == UV_EOF || nread == UV_ECONNABORTED) {
return;
}
pipe = (uv_pipe_t*) handle;
do {
if (++read_cb_count == 2) {
recv = &ctx2.recv;
write_req = &ctx2.write_req;
} else {
recv = &ctx2.recv2;
write_req = &ctx2.write_req2;
}
ASSERT(pipe == &ctx2.channel);
ASSERT(nread >= 0);
ASSERT(uv_pipe_pending_count(pipe) > 0);
pending = uv_pipe_pending_type(pipe);
ASSERT(pending == UV_NAMED_PIPE || pending == UV_TCP);
if (pending == UV_NAMED_PIPE)
r = uv_pipe_init(ctx2.channel.loop, &recv->pipe, 0);
else if (pending == UV_TCP)
r = uv_tcp_init(ctx2.channel.loop, &recv->tcp);
else
abort();
ASSERT(r == 0);
r = uv_accept(handle, &recv->stream);
ASSERT(r == 0);
wrbuf = uv_buf_init(".", 1);
r = uv_write2(write_req,
(uv_stream_t*)&ctx2.channel,
&wrbuf,
1,
&recv->stream,
write2_cb);
ASSERT(r == 0);
ASSERT(write_req->send_handle == &recv->stream);
} while (uv_pipe_pending_count(pipe) > 0);
}
static void recv_cb(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
uv_handle_type pending;
uv_pipe_t* pipe;
int r;
union handles* recv;
pipe = (uv_pipe_t*) handle;
ASSERT(pipe == &ctx.channel);
do {
if (++recv_cb_count == 1) {
recv = &ctx.recv;
} else {
recv = &ctx.recv2;
}
/* Depending on the OS, the final recv_cb can be called after
* the child process has terminated which can result in nread
* being UV_EOF instead of the number of bytes read. Since
* the other end of the pipe has closed this UV_EOF is an
* acceptable value. */
if (nread == UV_EOF) {
/* UV_EOF is only acceptable for the final recv_cb call */
ASSERT(recv_cb_count == 2);
} else {
ASSERT(nread >= 0);
ASSERT(uv_pipe_pending_count(pipe) > 0);
pending = uv_pipe_pending_type(pipe);
ASSERT(pending == ctx.expected_type);
if (pending == UV_NAMED_PIPE)
r = uv_pipe_init(ctx.channel.loop, &recv->pipe, 0);
else if (pending == UV_TCP)
r = uv_tcp_init(ctx.channel.loop, &recv->tcp);
else
abort();
ASSERT(r == 0);
r = uv_accept(handle, &recv->stream);
ASSERT(r == 0);
}
} while (uv_pipe_pending_count(pipe) > 0);
/* Close after two writes received */
if (recv_cb_count == 2) {
uv_close((uv_handle_t*)&ctx.channel, NULL);
}
}
void bud_worker_read_cb(uv_stream_t* stream,
ssize_t nread,
const uv_buf_t* buf) {
uv_pipe_t* pipe;
bud_config_t* config;
pipe = (uv_pipe_t*) stream;
config = pipe->data;
ASSERT(config != NULL, "worker ipc failed to get config");
ASSERT(nread >= 0 || nread == UV_EOF, "worker ipc read failure");
while (uv_pipe_pending_count(pipe) > 0) {
uv_handle_type pending;
pending = uv_pipe_pending_type(pipe);
/* Ignore reads without handles */
if (pending == UV_UNKNOWN_HANDLE)
return;
ASSERT(pending == UV_TCP, "worker received non-tcp handle on ipc");
bud_log(config, kBudLogDebug, "worker received handle");
/* Accept client */
bud_client_create(config, (uv_stream_t*) config->ipc);
}
}
static void read_cb(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
uv_pipe_t* p;
uv_pipe_t* inc;
uv_handle_type pending;
unsigned int i;
p = (uv_pipe_t*) handle;
ASSERT(nread >= 0);
while (uv_pipe_pending_count(p) != 0) {
pending = uv_pipe_pending_type(p);
ASSERT(pending == UV_NAMED_PIPE);
ASSERT(incoming_count < ARRAY_SIZE(incoming));
inc = &incoming[incoming_count++];
ASSERT(0 == uv_pipe_init(p->loop, inc, 0));
ASSERT(0 == uv_accept(handle, (uv_stream_t*) inc));
}
if (incoming_count != ARRAY_SIZE(incoming))
return;
ASSERT(0 == uv_read_stop((uv_stream_t*) p));
uv_close((uv_handle_t*) p, close_cb);
for (i = 0; i < ARRAY_SIZE(incoming); i++)
uv_close((uv_handle_t*) &incoming[i], close_cb);
}
static void on_read_connection(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
int r;
uv_buf_t outbuf;
uv_pipe_t* pipe;
uv_handle_type pending;
pipe = (uv_pipe_t*) handle;
if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf->base);
return;
}
if (nread < 0) {
if (nread == UV_EOF) {
free(buf->base);
return;
}
printf("error recving on channel: %s\n", uv_strerror(nread));
abort();
}
fprintf(stderr, "got %d bytes\n", (int)nread);
ASSERT(1 == uv_pipe_pending_count(pipe));
pending = uv_pipe_pending_type(pipe);
ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
read_cb_called++;
/* Accept the pending TCP connection */
ASSERT(pending == UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_connection);
ASSERT(r == 0);
r = uv_accept(handle, (uv_stream_t*)&tcp_connection);
ASSERT(r == 0);
/* Make sure that the expected data is correctly multiplexed. */
ASSERT(memcmp("hello\n", buf->base, nread) == 0);
/* Write/read to/from the connection */
outbuf = uv_buf_init("world\n", 6);
r = uv_write(&write_req, (uv_stream_t*)&tcp_connection, &outbuf, 1,
on_tcp_write);
ASSERT(r == 0);
r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read);
ASSERT(r == 0);
free(buf->base);
}
static void on_read_listen_after_bound_twice(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
int r;
uv_pipe_t* pipe;
uv_handle_type pending;
pipe = (uv_pipe_t*) handle;
if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf->base);
return;
}
if (nread < 0) {
if (nread == UV_EOF) {
free(buf->base);
return;
}
printf("error recving on channel: %s\n", uv_strerror(nread));
abort();
}
fprintf(stderr, "got %d bytes\n", (int)nread);
ASSERT(uv_pipe_pending_count(pipe) > 0);
pending = uv_pipe_pending_type(pipe);
ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
read_cb_called++;
if (read_cb_called == 1) {
/* Accept the first TCP server, and start listening on it. */
ASSERT(pending == UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
ASSERT(r == 0);
} else if (read_cb_called == 2) {
/* Accept the second TCP server, and start listening on it. */
ASSERT(pending == UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server2);
ASSERT(r == 0);
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server2);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server2, BACKLOG, on_connection);
ASSERT(r == UV_EADDRINUSE);
uv_close((uv_handle_t*)&tcp_server, NULL);
uv_close((uv_handle_t*)&tcp_server2, NULL);
ASSERT(0 == uv_pipe_pending_count(pipe));
uv_close((uv_handle_t*)&channel, NULL);
}
free(buf->base);
}
static void on_read(uv_stream_t* handle,
ssize_t nread,
const uv_buf_t* buf) {
int r;
uv_pipe_t* pipe;
uv_handle_type pending;
uv_buf_t outbuf;
pipe = (uv_pipe_t*) handle;
if (nread == 0) {
/* Everything OK, but nothing read. */
free(buf->base);
return;
}
if (nread < 0) {
if (nread == UV_EOF) {
free(buf->base);
return;
}
printf("error recving on channel: %s\n", uv_strerror(nread));
abort();
}
fprintf(stderr, "got %d bytes\n", (int)nread);
pending = uv_pipe_pending_type(pipe);
if (!tcp_server_listening) {
ASSERT(1 == uv_pipe_pending_count(pipe));
ASSERT(nread > 0 && buf->base && pending != UV_UNKNOWN_HANDLE);
read_cb_called++;
/* Accept the pending TCP server, and start listening on it. */
ASSERT(pending == UV_TCP);
r = uv_tcp_init(uv_default_loop(), &tcp_server);
ASSERT(r == 0);
r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server);
ASSERT(r == 0);
r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection);
ASSERT(r == 0);
tcp_server_listening = 1;
/* Make sure that the expected data is correctly multiplexed. */
ASSERT(memcmp("hello\n", buf->base, nread) == 0);
outbuf = uv_buf_init("world\n", 6);
r = uv_write(&write_req, (uv_stream_t*)pipe, &outbuf, 1, NULL);
ASSERT(r == 0);
/* Create a bunch of connections to get both servers to accept. */
make_many_connections();
} else if (memcmp("accepted_connection\n", buf->base, nread) == 0) {
/* Remote server has accepted a connection. Close the channel. */
ASSERT(0 == uv_pipe_pending_count(pipe));
ASSERT(pending == UV_UNKNOWN_HANDLE);
remote_conn_accepted = 1;
uv_close((uv_handle_t*)&channel, NULL);
}
free(buf->base);
}
int pending_count()
{
return uv_pipe_pending_count(get());
}
