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 PyObject * Pipe_func_pending_handle_type(Pipe *self) { RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); return PyInt_FromLong(uv_pipe_pending_type(&self->pipe_h)); }
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 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); } }
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); }
uv_handle_type pending_type() { return uv_pipe_pending_type(get()); }