Lines Matching refs:handle
98 static void eof_timer_close_cb(uv_handle_t* handle);
106 int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) { in uv_pipe_init() argument
107 uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE); in uv_pipe_init()
109 handle->reqs_pending = 0; in uv_pipe_init()
110 handle->handle = INVALID_HANDLE_VALUE; in uv_pipe_init()
111 handle->name = NULL; in uv_pipe_init()
112 handle->pipe.conn.ipc_remote_pid = 0; in uv_pipe_init()
113 handle->pipe.conn.ipc_data_frame.payload_remaining = 0; in uv_pipe_init()
114 QUEUE_INIT(&handle->pipe.conn.ipc_xfer_queue); in uv_pipe_init()
115 handle->pipe.conn.ipc_xfer_queue_length = 0; in uv_pipe_init()
116 handle->ipc = ipc; in uv_pipe_init()
117 handle->pipe.conn.non_overlapped_writes_tail = NULL; in uv_pipe_init()
123 static void uv__pipe_connection_init(uv_pipe_t* handle) { in uv__pipe_connection_init() argument
124 uv__connection_init((uv_stream_t*) handle); in uv__pipe_connection_init()
125 handle->read_req.data = handle; in uv__pipe_connection_init()
126 handle->pipe.conn.eof_timer = NULL; in uv__pipe_connection_init()
127 assert(!(handle->flags & UV_HANDLE_PIPESERVER)); in uv__pipe_connection_init()
128 if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) { in uv__pipe_connection_init()
129 handle->pipe.conn.readfile_thread_handle = NULL; in uv__pipe_connection_init()
130 InitializeCriticalSection(&handle->pipe.conn.readfile_thread_lock); in uv__pipe_connection_init()
196 CloseHandle(pipe->handle); in close_pipe()
201 pipe->handle = INVALID_HANDLE_VALUE; in close_pipe()
431 parent_pipe->handle = server_pipe; in uv__create_stdio_pipe_pair()
454 uv_pipe_t* handle, in uv__set_pipe_handle() argument
465 if (handle->flags & UV_HANDLE_PIPESERVER) in uv__set_pipe_handle()
467 if (handle->handle != INVALID_HANDLE_VALUE) in uv__set_pipe_handle()
509 handle->flags |= UV_HANDLE_NON_OVERLAPPED_PIPE; in uv__set_pipe_handle()
514 (ULONG_PTR) handle, in uv__set_pipe_handle()
516 handle->flags |= UV_HANDLE_EMULATE_IOCP; in uv__set_pipe_handle()
520 handle->handle = pipeHandle; in uv__set_pipe_handle()
521 handle->u.fd = fd; in uv__set_pipe_handle()
522 handle->flags |= duplex_flags; in uv__set_pipe_handle()
528 static int pipe_alloc_accept(uv_loop_t* loop, uv_pipe_t* handle, in pipe_alloc_accept() argument
533 CreateNamedPipeW(handle->name, in pipe_alloc_accept()
546 (ULONG_PTR) handle, in pipe_alloc_accept()
554 handle->handle = req->pipeHandle; in pipe_alloc_accept()
562 uv_pipe_t* handle; in pipe_shutdown_thread_proc() local
567 handle = (uv_pipe_t*) req->handle; in pipe_shutdown_thread_proc()
568 assert(handle); in pipe_shutdown_thread_proc()
569 loop = handle->loop; in pipe_shutdown_thread_proc()
572 FlushFileBuffers(handle->handle); in pipe_shutdown_thread_proc()
581 void uv__pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) { in uv__pipe_endgame() argument
590 if ((handle->flags & UV_HANDLE_CONNECTION) && in uv__pipe_endgame()
591 handle->stream.conn.shutdown_req != NULL && in uv__pipe_endgame()
592 handle->stream.conn.write_reqs_pending == 0) { in uv__pipe_endgame()
593 req = handle->stream.conn.shutdown_req; in uv__pipe_endgame()
596 handle->stream.conn.shutdown_req = NULL; in uv__pipe_endgame()
598 if (handle->flags & UV_HANDLE_CLOSING) { in uv__pipe_endgame()
599 UNREGISTER_HANDLE_REQ(loop, handle, req); in uv__pipe_endgame()
606 DECREASE_PENDING_REQ_COUNT(handle); in uv__pipe_endgame()
611 nt_status = pNtQueryInformationFile(handle->handle, in uv__pipe_endgame()
619 UNREGISTER_HANDLE_REQ(loop, handle, req); in uv__pipe_endgame()
621 handle->flags |= UV_HANDLE_WRITABLE; /* Questionable */ in uv__pipe_endgame()
627 DECREASE_PENDING_REQ_COUNT(handle); in uv__pipe_endgame()
646 UNREGISTER_HANDLE_REQ(loop, handle, req); in uv__pipe_endgame()
648 handle->flags |= UV_HANDLE_WRITABLE; /* Questionable */ in uv__pipe_endgame()
654 DECREASE_PENDING_REQ_COUNT(handle); in uv__pipe_endgame()
659 if (handle->flags & UV_HANDLE_CLOSING && in uv__pipe_endgame()
660 handle->reqs_pending == 0) { in uv__pipe_endgame()
661 assert(!(handle->flags & UV_HANDLE_CLOSED)); in uv__pipe_endgame()
663 if (handle->flags & UV_HANDLE_CONNECTION) { in uv__pipe_endgame()
665 while (!QUEUE_EMPTY(&handle->pipe.conn.ipc_xfer_queue)) { in uv__pipe_endgame()
669 q = QUEUE_HEAD(&handle->pipe.conn.ipc_xfer_queue); in uv__pipe_endgame()
685 handle->pipe.conn.ipc_xfer_queue_length = 0; in uv__pipe_endgame()
687 if (handle->flags & UV_HANDLE_EMULATE_IOCP) { in uv__pipe_endgame()
688 if (handle->read_req.wait_handle != INVALID_HANDLE_VALUE) { in uv__pipe_endgame()
689 UnregisterWait(handle->read_req.wait_handle); in uv__pipe_endgame()
690 handle->read_req.wait_handle = INVALID_HANDLE_VALUE; in uv__pipe_endgame()
692 if (handle->read_req.event_handle != NULL) { in uv__pipe_endgame()
693 CloseHandle(handle->read_req.event_handle); in uv__pipe_endgame()
694 handle->read_req.event_handle = NULL; in uv__pipe_endgame()
698 if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) in uv__pipe_endgame()
699 DeleteCriticalSection(&handle->pipe.conn.readfile_thread_lock); in uv__pipe_endgame()
702 if (handle->flags & UV_HANDLE_PIPESERVER) { in uv__pipe_endgame()
703 assert(handle->pipe.serv.accept_reqs); in uv__pipe_endgame()
704 uv__free(handle->pipe.serv.accept_reqs); in uv__pipe_endgame()
705 handle->pipe.serv.accept_reqs = NULL; in uv__pipe_endgame()
708 uv__handle_close(handle); in uv__pipe_endgame()
713 void uv_pipe_pending_instances(uv_pipe_t* handle, int count) { in uv_pipe_pending_instances() argument
714 if (handle->flags & UV_HANDLE_BOUND) in uv_pipe_pending_instances()
716 handle->pipe.serv.pending_instances = count; in uv_pipe_pending_instances()
717 handle->flags |= UV_HANDLE_PIPESERVER; in uv_pipe_pending_instances()
722 int uv_pipe_bind(uv_pipe_t* handle, const char* name) { in uv_pipe_bind() argument
723 uv_loop_t* loop = handle->loop; in uv_pipe_bind()
727 if (handle->flags & UV_HANDLE_BOUND) { in uv_pipe_bind()
735 if (!(handle->flags & UV_HANDLE_PIPESERVER)) { in uv_pipe_bind()
736 handle->pipe.serv.pending_instances = default_pending_pipe_instances; in uv_pipe_bind()
739 handle->pipe.serv.accept_reqs = (uv_pipe_accept_t*) in uv_pipe_bind()
740 uv__malloc(sizeof(uv_pipe_accept_t) * handle->pipe.serv.pending_instances); in uv_pipe_bind()
741 if (!handle->pipe.serv.accept_reqs) { in uv_pipe_bind()
745 for (i = 0; i < handle->pipe.serv.pending_instances; i++) { in uv_pipe_bind()
746 req = &handle->pipe.serv.accept_reqs[i]; in uv_pipe_bind()
748 req->data = handle; in uv_pipe_bind()
755 handle->name = uv__malloc(nameSize); in uv_pipe_bind()
756 if (!handle->name) { in uv_pipe_bind()
764 handle->name, in uv_pipe_bind()
775 handle, in uv_pipe_bind()
776 &handle->pipe.serv.accept_reqs[0], in uv_pipe_bind()
787 handle->pipe.serv.pending_accepts = NULL; in uv_pipe_bind()
788 handle->flags |= UV_HANDLE_PIPESERVER; in uv_pipe_bind()
789 handle->flags |= UV_HANDLE_BOUND; in uv_pipe_bind()
794 if (handle->name) { in uv_pipe_bind()
795 uv__free(handle->name); in uv_pipe_bind()
796 handle->name = NULL; in uv_pipe_bind()
805 uv_pipe_t* handle; in pipe_connect_thread_proc() local
812 handle = (uv_pipe_t*) req->handle; in pipe_connect_thread_proc()
813 assert(handle); in pipe_connect_thread_proc()
814 loop = handle->loop; in pipe_connect_thread_proc()
819 while (WaitNamedPipeW(handle->name, 30000)) { in pipe_connect_thread_proc()
821 pipeHandle = open_named_pipe(handle->name, &duplex_flags); in pipe_connect_thread_proc()
829 !uv__set_pipe_handle(loop, handle, pipeHandle, -1, duplex_flags)) { in pipe_connect_thread_proc()
842 void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, in uv_pipe_connect() argument
844 uv_loop_t* loop = handle->loop; in uv_pipe_connect()
850 req->handle = (uv_stream_t*) handle; in uv_pipe_connect()
855 handle->name = uv__malloc(nameSize); in uv_pipe_connect()
856 if (!handle->name) { in uv_pipe_connect()
864 handle->name, in uv_pipe_connect()
870 pipeHandle = open_named_pipe(handle->name, &duplex_flags); in uv_pipe_connect()
881 REGISTER_HANDLE_REQ(loop, handle, req); in uv_pipe_connect()
882 handle->reqs_pending++; in uv_pipe_connect()
894 (uv_pipe_t*) req->handle, in uv_pipe_connect()
904 handle->reqs_pending++; in uv_pipe_connect()
905 REGISTER_HANDLE_REQ(loop, handle, req); in uv_pipe_connect()
909 if (handle->name) { in uv_pipe_connect()
910 uv__free(handle->name); in uv_pipe_connect()
911 handle->name = NULL; in uv_pipe_connect()
920 handle->reqs_pending++; in uv_pipe_connect()
921 REGISTER_HANDLE_REQ(loop, handle, req); in uv_pipe_connect()
926 void uv__pipe_interrupt_read(uv_pipe_t* handle) { in uv__pipe_interrupt_read() argument
929 if (!(handle->flags & UV_HANDLE_READ_PENDING)) in uv__pipe_interrupt_read()
931 if (handle->flags & UV_HANDLE_CANCELLATION_PENDING) in uv__pipe_interrupt_read()
933 if (handle->handle == INVALID_HANDLE_VALUE) in uv__pipe_interrupt_read()
936 if (!(handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE)) { in uv__pipe_interrupt_read()
938 r = CancelIoEx(handle->handle, &handle->read_req.u.io.overlapped); in uv__pipe_interrupt_read()
944 volatile HANDLE* thread_ptr = &handle->pipe.conn.readfile_thread_handle; in uv__pipe_interrupt_read()
946 EnterCriticalSection(&handle->pipe.conn.readfile_thread_lock); in uv__pipe_interrupt_read()
965 LeaveCriticalSection(&handle->pipe.conn.readfile_thread_lock); in uv__pipe_interrupt_read()
969 handle->flags |= UV_HANDLE_CANCELLATION_PENDING; in uv__pipe_interrupt_read()
973 void uv__pipe_read_stop(uv_pipe_t* handle) { in uv__pipe_read_stop() argument
974 handle->flags &= ~UV_HANDLE_READING; in uv__pipe_read_stop()
975 DECREASE_ACTIVE_COUNT(handle->loop, handle); in uv__pipe_read_stop()
977 uv__pipe_interrupt_read(handle); in uv__pipe_read_stop()
983 void uv__pipe_cleanup(uv_loop_t* loop, uv_pipe_t* handle) { in uv__pipe_cleanup() argument
987 uv__pipe_interrupt_read(handle); in uv__pipe_cleanup()
989 if (handle->name) { in uv__pipe_cleanup()
990 uv__free(handle->name); in uv__pipe_cleanup()
991 handle->name = NULL; in uv__pipe_cleanup()
994 if (handle->flags & UV_HANDLE_PIPESERVER) { in uv__pipe_cleanup()
995 for (i = 0; i < handle->pipe.serv.pending_instances; i++) { in uv__pipe_cleanup()
996 pipeHandle = handle->pipe.serv.accept_reqs[i].pipeHandle; in uv__pipe_cleanup()
999 handle->pipe.serv.accept_reqs[i].pipeHandle = INVALID_HANDLE_VALUE; in uv__pipe_cleanup()
1002 handle->handle = INVALID_HANDLE_VALUE; in uv__pipe_cleanup()
1005 if (handle->flags & UV_HANDLE_CONNECTION) { in uv__pipe_cleanup()
1006 handle->flags &= ~UV_HANDLE_WRITABLE; in uv__pipe_cleanup()
1007 eof_timer_destroy(handle); in uv__pipe_cleanup()
1010 if ((handle->flags & UV_HANDLE_CONNECTION) in uv__pipe_cleanup()
1011 && handle->handle != INVALID_HANDLE_VALUE) in uv__pipe_cleanup()
1012 close_pipe(handle); in uv__pipe_cleanup()
1016 void uv__pipe_close(uv_loop_t* loop, uv_pipe_t* handle) { in uv__pipe_close() argument
1017 if (handle->flags & UV_HANDLE_READING) { in uv__pipe_close()
1018 handle->flags &= ~UV_HANDLE_READING; in uv__pipe_close()
1019 DECREASE_ACTIVE_COUNT(loop, handle); in uv__pipe_close()
1022 if (handle->flags & UV_HANDLE_LISTENING) { in uv__pipe_close()
1023 handle->flags &= ~UV_HANDLE_LISTENING; in uv__pipe_close()
1024 DECREASE_ACTIVE_COUNT(loop, handle); in uv__pipe_close()
1027 uv__pipe_cleanup(loop, handle); in uv__pipe_close()
1029 if (handle->reqs_pending == 0) { in uv__pipe_close()
1030 uv__want_endgame(loop, (uv_handle_t*) handle); in uv__pipe_close()
1033 handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE); in uv__pipe_close()
1034 uv__handle_closing(handle); in uv__pipe_close()
1038 static void uv__pipe_queue_accept(uv_loop_t* loop, uv_pipe_t* handle, in uv__pipe_queue_accept() argument
1040 assert(handle->flags & UV_HANDLE_LISTENING); in uv__pipe_queue_accept()
1042 if (!firstInstance && !pipe_alloc_accept(loop, handle, req, FALSE)) { in uv__pipe_queue_accept()
1045 handle->reqs_pending++; in uv__pipe_queue_accept()
1065 handle->reqs_pending++; in uv__pipe_queue_accept()
1070 handle->reqs_pending++; in uv__pipe_queue_accept()
1114 pipe_client->handle = req->pipeHandle; in uv__pipe_accept()
1122 server->handle = INVALID_HANDLE_VALUE; in uv__pipe_accept()
1133 int uv__pipe_listen(uv_pipe_t* handle, int backlog, uv_connection_cb cb) { in uv__pipe_listen() argument
1134 uv_loop_t* loop = handle->loop; in uv__pipe_listen()
1137 if (handle->flags & UV_HANDLE_LISTENING) { in uv__pipe_listen()
1138 handle->stream.serv.connection_cb = cb; in uv__pipe_listen()
1141 if (!(handle->flags & UV_HANDLE_BOUND)) { in uv__pipe_listen()
1145 if (handle->flags & UV_HANDLE_READING) { in uv__pipe_listen()
1149 if (!(handle->flags & UV_HANDLE_PIPESERVER)) { in uv__pipe_listen()
1153 if (handle->ipc) { in uv__pipe_listen()
1157 handle->flags |= UV_HANDLE_LISTENING; in uv__pipe_listen()
1158 INCREASE_ACTIVE_COUNT(loop, handle); in uv__pipe_listen()
1159 handle->stream.serv.connection_cb = cb; in uv__pipe_listen()
1162 assert(handle->pipe.serv.accept_reqs[0].pipeHandle != INVALID_HANDLE_VALUE); in uv__pipe_listen()
1164 for (i = 0; i < handle->pipe.serv.pending_instances; i++) { in uv__pipe_listen()
1165 uv__pipe_queue_accept(loop, handle, &handle->pipe.serv.accept_reqs[i], i == 0); in uv__pipe_listen()
1174 uv_pipe_t* handle = (uv_pipe_t*) req->data; in uv_pipe_zero_readfile_thread_proc() local
1175 uv_loop_t* loop = handle->loop; in uv_pipe_zero_readfile_thread_proc()
1176 volatile HANDLE* thread_ptr = &handle->pipe.conn.readfile_thread_handle; in uv_pipe_zero_readfile_thread_proc()
1177 CRITICAL_SECTION* lock = &handle->pipe.conn.readfile_thread_lock; in uv_pipe_zero_readfile_thread_proc()
1183 assert(handle->type == UV_NAMED_PIPE); in uv_pipe_zero_readfile_thread_proc()
1216 if (!ReadFile(handle->handle, &uv_zero_, 0, &bytes, NULL)) in uv_pipe_zero_readfile_thread_proc()
1249 uv_pipe_t* handle = (uv_pipe_t*) req->handle; in uv_pipe_writefile_thread_proc() local
1250 uv_loop_t* loop = handle->loop; in uv_pipe_writefile_thread_proc()
1254 assert(handle->type == UV_NAMED_PIPE); in uv_pipe_writefile_thread_proc()
1256 result = WriteFile(handle->handle, in uv_pipe_writefile_thread_proc()
1273 uv_tcp_t* handle; in post_completion_read_wait() local
1277 handle = (uv_tcp_t*)req->data; in post_completion_read_wait()
1278 assert(handle != NULL); in post_completion_read_wait()
1281 if (!PostQueuedCompletionStatus(handle->loop->iocp, in post_completion_read_wait()
1292 uv_tcp_t* handle; in post_completion_write_wait() local
1296 handle = (uv_tcp_t*)req->handle; in post_completion_write_wait()
1297 assert(handle != NULL); in post_completion_write_wait()
1300 if (!PostQueuedCompletionStatus(handle->loop->iocp, in post_completion_write_wait()
1309 static void uv__pipe_queue_read(uv_loop_t* loop, uv_pipe_t* handle) { in uv__pipe_queue_read() argument
1313 assert(handle->flags & UV_HANDLE_READING); in uv__pipe_queue_read()
1314 assert(!(handle->flags & UV_HANDLE_READ_PENDING)); in uv__pipe_queue_read()
1316 assert(handle->handle != INVALID_HANDLE_VALUE); in uv__pipe_queue_read()
1318 req = &handle->read_req; in uv__pipe_queue_read()
1320 if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) { in uv__pipe_queue_read()
1321 handle->pipe.conn.readfile_thread_handle = NULL; /* Reset cancellation. */ in uv__pipe_queue_read()
1331 if (handle->flags & UV_HANDLE_EMULATE_IOCP) { in uv__pipe_queue_read()
1337 result = ReadFile(handle->handle, in uv__pipe_queue_read()
1349 if (handle->flags & UV_HANDLE_EMULATE_IOCP) { in uv__pipe_queue_read()
1362 eof_timer_start(handle); in uv__pipe_queue_read()
1363 handle->flags |= UV_HANDLE_READ_PENDING; in uv__pipe_queue_read()
1364 handle->reqs_pending++; in uv__pipe_queue_read()
1369 handle->flags |= UV_HANDLE_READ_PENDING; in uv__pipe_queue_read()
1370 handle->reqs_pending++; in uv__pipe_queue_read()
1374 int uv__pipe_read_start(uv_pipe_t* handle, in uv__pipe_read_start() argument
1377 uv_loop_t* loop = handle->loop; in uv__pipe_read_start()
1379 handle->flags |= UV_HANDLE_READING; in uv__pipe_read_start()
1380 INCREASE_ACTIVE_COUNT(loop, handle); in uv__pipe_read_start()
1381 handle->read_cb = read_cb; in uv__pipe_read_start()
1382 handle->alloc_cb = alloc_cb; in uv__pipe_read_start()
1386 if (!(handle->flags & UV_HANDLE_READ_PENDING)) { in uv__pipe_read_start()
1387 if (handle->flags & UV_HANDLE_EMULATE_IOCP && in uv__pipe_read_start()
1388 handle->read_req.event_handle == NULL) { in uv__pipe_read_start()
1389 handle->read_req.event_handle = CreateEvent(NULL, 0, 0, NULL); in uv__pipe_read_start()
1390 if (handle->read_req.event_handle == NULL) { in uv__pipe_read_start()
1394 uv__pipe_queue_read(loop, handle); in uv__pipe_read_start()
1401 static void uv__insert_non_overlapped_write_req(uv_pipe_t* handle, in uv__insert_non_overlapped_write_req() argument
1404 if (handle->pipe.conn.non_overlapped_writes_tail) { in uv__insert_non_overlapped_write_req()
1406 handle->pipe.conn.non_overlapped_writes_tail->next_req; in uv__insert_non_overlapped_write_req()
1407 handle->pipe.conn.non_overlapped_writes_tail->next_req = (uv_req_t*)req; in uv__insert_non_overlapped_write_req()
1408 handle->pipe.conn.non_overlapped_writes_tail = req; in uv__insert_non_overlapped_write_req()
1411 handle->pipe.conn.non_overlapped_writes_tail = req; in uv__insert_non_overlapped_write_req()
1416 static uv_write_t* uv_remove_non_overlapped_write_req(uv_pipe_t* handle) { in uv_remove_non_overlapped_write_req() argument
1419 if (handle->pipe.conn.non_overlapped_writes_tail) { in uv_remove_non_overlapped_write_req()
1420 req = (uv_write_t*)handle->pipe.conn.non_overlapped_writes_tail->next_req; in uv_remove_non_overlapped_write_req()
1422 if (req == handle->pipe.conn.non_overlapped_writes_tail) { in uv_remove_non_overlapped_write_req()
1423 handle->pipe.conn.non_overlapped_writes_tail = NULL; in uv_remove_non_overlapped_write_req()
1425 handle->pipe.conn.non_overlapped_writes_tail->next_req = in uv_remove_non_overlapped_write_req()
1437 static void uv__queue_non_overlapped_write(uv_pipe_t* handle) { in uv__queue_non_overlapped_write() argument
1438 uv_write_t* req = uv_remove_non_overlapped_write_req(handle); in uv__queue_non_overlapped_write()
1511 uv_pipe_t* handle, in uv__pipe_write_data() argument
1520 assert(handle->handle != INVALID_HANDLE_VALUE); in uv__pipe_write_data()
1523 req->handle = (uv_stream_t*) handle; in uv__pipe_write_data()
1533 if (handle->flags & (UV_HANDLE_EMULATE_IOCP | UV_HANDLE_BLOCKING_WRITES)) { in uv__pipe_write_data()
1556 if ((handle->flags & in uv__pipe_write_data()
1561 WriteFile(handle->handle, write_buf.base, write_buf.len, &bytes, NULL); in uv__pipe_write_data()
1571 REGISTER_HANDLE_REQ(loop, handle, req); in uv__pipe_write_data()
1572 handle->reqs_pending++; in uv__pipe_write_data()
1573 handle->stream.conn.write_reqs_pending++; in uv__pipe_write_data()
1576 } else if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) { in uv__pipe_write_data()
1578 uv__insert_non_overlapped_write_req(handle, req); in uv__pipe_write_data()
1579 if (handle->stream.conn.write_reqs_pending == 0) { in uv__pipe_write_data()
1580 uv__queue_non_overlapped_write(handle); in uv__pipe_write_data()
1585 handle->write_queue_size += req->u.io.queued_bytes; in uv__pipe_write_data()
1586 } else if (handle->flags & UV_HANDLE_BLOCKING_WRITES) { in uv__pipe_write_data()
1588 result = WriteFile(handle->handle, in uv__pipe_write_data()
1607 handle->write_queue_size += req->u.io.queued_bytes; in uv__pipe_write_data()
1619 REGISTER_HANDLE_REQ(loop, handle, req); in uv__pipe_write_data()
1620 handle->reqs_pending++; in uv__pipe_write_data()
1621 handle->stream.conn.write_reqs_pending++; in uv__pipe_write_data()
1624 result = WriteFile(handle->handle, in uv__pipe_write_data()
1640 handle->write_queue_size += req->u.io.queued_bytes; in uv__pipe_write_data()
1643 if (handle->flags & UV_HANDLE_EMULATE_IOCP) { in uv__pipe_write_data()
1652 REGISTER_HANDLE_REQ(loop, handle, req); in uv__pipe_write_data()
1653 handle->reqs_pending++; in uv__pipe_write_data()
1654 handle->stream.conn.write_reqs_pending++; in uv__pipe_write_data()
1660 static DWORD uv__pipe_get_ipc_remote_pid(uv_pipe_t* handle) { in uv__pipe_get_ipc_remote_pid() argument
1661 DWORD* pid = &handle->pipe.conn.ipc_remote_pid; in uv__pipe_get_ipc_remote_pid()
1675 uv_pipe_t* handle, in uv__pipe_write_ipc() argument
1707 uv__pipe_get_ipc_remote_pid(handle), in uv__pipe_write_ipc()
1764 err = uv__pipe_write_data(loop, req, handle, bufs, buf_count, cb, 1); in uv__pipe_write_ipc()
1777 uv_pipe_t* handle, in uv__pipe_write() argument
1782 if (handle->ipc) { in uv__pipe_write()
1784 return uv__pipe_write_ipc(loop, req, handle, bufs, nbufs, send_handle, cb); in uv__pipe_write()
1788 return uv__pipe_write_data(loop, req, handle, bufs, nbufs, cb, 0); in uv__pipe_write()
1793 static void uv__pipe_read_eof(uv_loop_t* loop, uv_pipe_t* handle, in uv__pipe_read_eof() argument
1797 eof_timer_destroy(handle); in uv__pipe_read_eof()
1799 uv_read_stop((uv_stream_t*) handle); in uv__pipe_read_eof()
1801 handle->read_cb((uv_stream_t*) handle, UV_EOF, &buf); in uv__pipe_read_eof()
1805 static void uv__pipe_read_error(uv_loop_t* loop, uv_pipe_t* handle, int error, in uv__pipe_read_error() argument
1809 eof_timer_destroy(handle); in uv__pipe_read_error()
1811 uv_read_stop((uv_stream_t*) handle); in uv__pipe_read_error()
1813 handle->read_cb((uv_stream_t*)handle, uv_translate_sys_error(error), &buf); in uv__pipe_read_error()
1817 static void uv__pipe_read_error_or_eof(uv_loop_t* loop, uv_pipe_t* handle, in uv__pipe_read_error_or_eof() argument
1820 uv__pipe_read_eof(loop, handle, buf); in uv__pipe_read_error_or_eof()
1822 uv__pipe_read_error(loop, handle, error, buf); in uv__pipe_read_error_or_eof()
1828 uv_pipe_t* handle, in uv__pipe_queue_ipc_xfer_info() argument
1840 QUEUE_INSERT_TAIL(&handle->pipe.conn.ipc_xfer_queue, &item->member); in uv__pipe_queue_ipc_xfer_info()
1841 handle->pipe.conn.ipc_xfer_queue_length++; in uv__pipe_queue_ipc_xfer_info()
1870 uv_pipe_t* handle, in uv__pipe_read_data() argument
1878 handle->alloc_cb((uv_handle_t*) handle, suggested_bytes, &buf); in uv__pipe_read_data()
1880 handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf); in uv__pipe_read_data()
1892 if (!ReadFile(handle->handle, buf.base, max_bytes, &bytes_read, NULL)) { in uv__pipe_read_data()
1893 uv__pipe_read_error_or_eof(loop, handle, GetLastError(), buf); in uv__pipe_read_data()
1898 handle->read_cb((uv_stream_t*) handle, bytes_read, &buf); in uv__pipe_read_data()
1904 static DWORD uv__pipe_read_ipc(uv_loop_t* loop, uv_pipe_t* handle) { in uv__pipe_read_ipc() argument
1905 uint32_t* data_remaining = &handle->pipe.conn.ipc_data_frame.payload_remaining; in uv__pipe_read_ipc()
1911 uv__pipe_read_data(loop, handle, *data_remaining, *data_remaining); in uv__pipe_read_ipc()
1924 handle->handle, &frame_header, sizeof frame_header); in uv__pipe_read_ipc()
1964 err = uv__pipe_read_exactly(handle->handle, &xfer_info, sizeof xfer_info); in uv__pipe_read_ipc()
1969 uv__pipe_queue_ipc_xfer_info(handle, xfer_type, &xfer_info); in uv__pipe_read_ipc()
1980 uv__pipe_read_error_or_eof(loop, handle, err, uv_null_buf_); in uv__pipe_read_ipc()
1986 uv_pipe_t* handle, in uv__process_pipe_read_req() argument
1988 assert(handle->type == UV_NAMED_PIPE); in uv__process_pipe_read_req()
1990 handle->flags &= ~(UV_HANDLE_READ_PENDING | UV_HANDLE_CANCELLATION_PENDING); in uv__process_pipe_read_req()
1991 DECREASE_PENDING_REQ_COUNT(handle); in uv__process_pipe_read_req()
1992 eof_timer_stop(handle); in uv__process_pipe_read_req()
1997 if (!(handle->flags & UV_HANDLE_READING)) in uv__process_pipe_read_req()
2008 uv__pipe_read_error_or_eof(loop, handle, err, uv_null_buf_); in uv__process_pipe_read_req()
2017 if (!PeekNamedPipe(handle->handle, NULL, 0, NULL, &avail, NULL)) in uv__process_pipe_read_req()
2018 uv__pipe_read_error_or_eof(loop, handle, GetLastError(), uv_null_buf_); in uv__process_pipe_read_req()
2022 while (avail > 0 && handle->flags & UV_HANDLE_READING) { in uv__process_pipe_read_req()
2025 handle->ipc ? uv__pipe_read_ipc(loop, handle) in uv__process_pipe_read_req()
2026 : uv__pipe_read_data(loop, handle, avail, (DWORD) -1); in uv__process_pipe_read_req()
2045 if ((handle->flags & UV_HANDLE_READING) && in uv__process_pipe_read_req()
2046 !(handle->flags & UV_HANDLE_READ_PENDING)) { in uv__process_pipe_read_req()
2047 uv__pipe_queue_read(loop, handle); in uv__process_pipe_read_req()
2052 void uv__process_pipe_write_req(uv_loop_t* loop, uv_pipe_t* handle, in uv__process_pipe_write_req() argument
2056 assert(handle->type == UV_NAMED_PIPE); in uv__process_pipe_write_req()
2058 assert(handle->write_queue_size >= req->u.io.queued_bytes); in uv__process_pipe_write_req()
2059 handle->write_queue_size -= req->u.io.queued_bytes; in uv__process_pipe_write_req()
2061 UNREGISTER_HANDLE_REQ(loop, handle, req); in uv__process_pipe_write_req()
2063 if (handle->flags & UV_HANDLE_EMULATE_IOCP) { in uv__process_pipe_write_req()
2089 handle->stream.conn.write_reqs_pending--; in uv__process_pipe_write_req()
2091 if (handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE && in uv__process_pipe_write_req()
2092 handle->pipe.conn.non_overlapped_writes_tail) { in uv__process_pipe_write_req()
2093 assert(handle->stream.conn.write_reqs_pending > 0); in uv__process_pipe_write_req()
2094 uv__queue_non_overlapped_write(handle); in uv__process_pipe_write_req()
2097 if (handle->stream.conn.shutdown_req != NULL && in uv__process_pipe_write_req()
2098 handle->stream.conn.write_reqs_pending == 0) { in uv__process_pipe_write_req()
2099 uv__want_endgame(loop, (uv_handle_t*)handle); in uv__process_pipe_write_req()
2102 DECREASE_PENDING_REQ_COUNT(handle); in uv__process_pipe_write_req()
2106 void uv__process_pipe_accept_req(uv_loop_t* loop, uv_pipe_t* handle, in uv__process_pipe_accept_req() argument
2110 assert(handle->type == UV_NAMED_PIPE); in uv__process_pipe_accept_req()
2112 if (handle->flags & UV_HANDLE_CLOSING) { in uv__process_pipe_accept_req()
2115 DECREASE_PENDING_REQ_COUNT(handle); in uv__process_pipe_accept_req()
2121 req->next_pending = handle->pipe.serv.pending_accepts; in uv__process_pipe_accept_req()
2122 handle->pipe.serv.pending_accepts = req; in uv__process_pipe_accept_req()
2124 if (handle->stream.serv.connection_cb) { in uv__process_pipe_accept_req()
2125 handle->stream.serv.connection_cb((uv_stream_t*)handle, 0); in uv__process_pipe_accept_req()
2132 if (!(handle->flags & UV_HANDLE_CLOSING)) { in uv__process_pipe_accept_req()
2133 uv__pipe_queue_accept(loop, handle, req, FALSE); in uv__process_pipe_accept_req()
2137 DECREASE_PENDING_REQ_COUNT(handle); in uv__process_pipe_accept_req()
2141 void uv__process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle, in uv__process_pipe_connect_req() argument
2145 assert(handle->type == UV_NAMED_PIPE); in uv__process_pipe_connect_req()
2147 UNREGISTER_HANDLE_REQ(loop, handle, req); in uv__process_pipe_connect_req()
2152 uv__pipe_connection_init(handle); in uv__process_pipe_connect_req()
2159 DECREASE_PENDING_REQ_COUNT(handle); in uv__process_pipe_connect_req()
2163 void uv__process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle, in uv__process_pipe_shutdown_req() argument
2165 assert(handle->type == UV_NAMED_PIPE); in uv__process_pipe_shutdown_req()
2167 UNREGISTER_HANDLE_REQ(loop, handle, req); in uv__process_pipe_shutdown_req()
2169 if (handle->flags & UV_HANDLE_READABLE) { in uv__process_pipe_shutdown_req()
2172 eof_timer_init(handle); in uv__process_pipe_shutdown_req()
2176 if (handle->flags & UV_HANDLE_READ_PENDING) { in uv__process_pipe_shutdown_req()
2177 eof_timer_start(handle); in uv__process_pipe_shutdown_req()
2183 close_pipe(handle); in uv__process_pipe_shutdown_req()
2190 DECREASE_PENDING_REQ_COUNT(handle); in uv__process_pipe_shutdown_req()
2271 static void eof_timer_close_cb(uv_handle_t* handle) { in eof_timer_close_cb() argument
2272 assert(handle->type == UV_TIMER); in eof_timer_close_cb()
2273 uv__free(handle); in eof_timer_close_cb()
2350 static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) { in uv__pipe_getname() argument
2364 if (handle->handle == INVALID_HANDLE_VALUE) { in uv__pipe_getname()
2374 if (handle->flags & UV_HANDLE_CONNECTION && in uv__pipe_getname()
2375 handle->flags & UV_HANDLE_NON_OVERLAPPED_PIPE) { in uv__pipe_getname()
2376 uv__pipe_interrupt_read((uv_pipe_t*) handle); /* cast away const warning */ in uv__pipe_getname()
2379 nt_status = pNtQueryInformationFile(handle->handle, in uv__pipe_getname()
2393 nt_status = pNtQueryInformationFile(handle->handle, in uv__pipe_getname()
2472 int uv_pipe_pending_count(uv_pipe_t* handle) { in uv_pipe_pending_count() argument
2473 if (!handle->ipc) in uv_pipe_pending_count()
2475 return handle->pipe.conn.ipc_xfer_queue_length; in uv_pipe_pending_count()
2479 int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size) { in uv_pipe_getsockname() argument
2480 if (handle->flags & UV_HANDLE_BOUND) in uv_pipe_getsockname()
2481 return uv__pipe_getname(handle, buffer, size); in uv_pipe_getsockname()
2483 if (handle->flags & UV_HANDLE_CONNECTION || in uv_pipe_getsockname()
2484 handle->handle != INVALID_HANDLE_VALUE) { in uv_pipe_getsockname()
2493 int uv_pipe_getpeername(const uv_pipe_t* handle, char* buffer, size_t* size) { in uv_pipe_getpeername() argument
2495 if (handle->flags & UV_HANDLE_BOUND) in uv_pipe_getpeername()
2498 if (handle->handle != INVALID_HANDLE_VALUE) in uv_pipe_getpeername()
2499 return uv__pipe_getname(handle, buffer, size); in uv_pipe_getpeername()
2505 uv_handle_type uv_pipe_pending_type(uv_pipe_t* handle) { in uv_pipe_pending_type() argument
2506 if (!handle->ipc) in uv_pipe_pending_type()
2508 if (handle->pipe.conn.ipc_xfer_queue_length == 0) in uv_pipe_pending_type()
2514 int uv_pipe_chmod(uv_pipe_t* handle, int mode) { in uv_pipe_chmod() argument
2522 if (handle == NULL || handle->handle == INVALID_HANDLE_VALUE) in uv_pipe_chmod()
2539 if (GetSecurityInfo(handle->handle, in uv_pipe_chmod()
2568 if (SetSecurityInfo(handle->handle, in uv_pipe_chmod()