Lines Matching refs:req
30 #include "req-inl.h"
88 uv_write_t req; /* Internal heap-allocated write request. */
537 uv_pipe_accept_t* req, BOOL firstInstance) {
538 assert(req->pipeHandle == INVALID_HANDLE_VALUE);
540 req->pipeHandle =
547 if (req->pipeHandle == INVALID_HANDLE_VALUE) {
552 if (CreateIoCompletionPort(req->pipeHandle,
562 handle->handle = req->pipeHandle;
571 uv_shutdown_t* req;
573 req = (uv_shutdown_t*) parameter;
574 assert(req);
575 handle = (uv_pipe_t*) req->handle;
583 POST_COMPLETION_FOR_REQ(loop, req);
589 void uv__pipe_shutdown(uv_loop_t* loop, uv_pipe_t* handle, uv_shutdown_t *req) {
596 assert(req != NULL);
598 SET_REQ_SUCCESS(req);
601 uv__insert_pending_req(loop, (uv_req_t*) req);
613 SET_REQ_ERROR(req, pRtlNtStatusToDosError(nt_status));
615 uv__insert_pending_req(loop, (uv_req_t*) req);
622 uv__insert_pending_req(loop, (uv_req_t*) req);
628 req,
631 SET_REQ_ERROR(req, GetLastError());
633 uv__insert_pending_req(loop, (uv_req_t*) req);
715 uv_pipe_accept_t* req;
762 req = &handle->pipe.serv.accept_reqs[i];
763 UV_REQ_INIT(req, UV_ACCEPT);
764 req->data = handle;
765 req->pipeHandle = INVALID_HANDLE_VALUE;
766 req->next_pending = NULL;
817 uv_connect_t* req;
821 req = (uv_connect_t*) parameter;
822 assert(req);
823 handle = (uv_pipe_t*) req->handle;
830 while (WaitNamedPipeW(req->u.connect.name, 30000)) {
832 pipeHandle = open_named_pipe(req->u.connect.name, &duplex_flags);
839 uv__free(req->u.connect.name);
840 req->u.connect.name = NULL;
842 SET_REQ_SUCCESS(req);
843 req->u.connect.pipeHandle = pipeHandle;
844 req->u.connect.duplex_flags = duplex_flags;
846 SET_REQ_ERROR(req, GetLastError());
850 POST_COMPLETION_FOR_REQ(loop, req);
856 void uv_pipe_connect(uv_connect_t* req,
863 err = uv_pipe_connect2(req, handle, name, strlen(name), 0, cb);
867 /* Make this req pending reporting an error. */
868 SET_REQ_ERROR(req, err);
869 uv__insert_pending_req(loop, (uv_req_t*) req);
871 REGISTER_HANDLE_REQ(loop, handle, req);
876 int uv_pipe_connect2(uv_connect_t* req,
890 UV_REQ_INIT(req, UV_CONNECT);
891 req->handle = (uv_stream_t*) handle;
892 req->cb = cb;
893 req->u.connect.pipeHandle = INVALID_HANDLE_VALUE;
894 req->u.connect.duplex_flags = 0;
895 req->u.connect.name = NULL;
945 req->u.connect.name = uv__malloc(nameSize);
946 if (!req->u.connect.name) {
950 memcpy(req->u.connect.name, handle->name, nameSize);
954 req,
956 uv__free(req->u.connect.name);
957 req->u.connect.name = NULL;
962 REGISTER_HANDLE_REQ(loop, handle, req);
972 req->u.connect.pipeHandle = pipeHandle;
973 req->u.connect.duplex_flags = duplex_flags;
974 SET_REQ_SUCCESS(req);
975 uv__insert_pending_req(loop, (uv_req_t*) req);
977 REGISTER_HANDLE_REQ(loop, handle, req);
991 /* Make this req pending reporting an error. */
992 SET_REQ_ERROR(req, err);
993 uv__insert_pending_req(loop, (uv_req_t*) req);
995 REGISTER_HANDLE_REQ(loop, handle, req);
1108 uv_pipe_accept_t* req, BOOL firstInstance) {
1111 if (!firstInstance && !pipe_alloc_accept(loop, handle, req, FALSE)) {
1112 SET_REQ_ERROR(req, GetLastError());
1113 uv__insert_pending_req(loop, (uv_req_t*) req);
1118 assert(req->pipeHandle != INVALID_HANDLE_VALUE);
1121 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
1123 if (!ConnectNamedPipe(req->pipeHandle, &req->u.io.overlapped) &&
1126 SET_REQ_SUCCESS(req);
1128 CloseHandle(req->pipeHandle);
1129 req->pipeHandle = INVALID_HANDLE_VALUE;
1130 /* Make this req pending reporting an error. */
1131 SET_REQ_ERROR(req, GetLastError());
1133 uv__insert_pending_req(loop, (uv_req_t*) req);
1146 uv_pipe_accept_t* req;
1176 req = server->pipe.serv.pending_accepts;
1178 if (!req) {
1184 pipe_client->handle = req->pipeHandle;
1187 /* Prepare the req to pick up a new connection */
1188 server->pipe.serv.pending_accepts = req->next_pending;
1189 req->next_pending = NULL;
1190 req->pipeHandle = INVALID_HANDLE_VALUE;
1194 uv__pipe_queue_accept(loop, server, req, FALSE);
1243 uv_read_t* req = (uv_read_t*) arg;
1244 uv_pipe_t* handle = (uv_pipe_t*) req->data;
1252 assert(req->type == UV_READ);
1306 SET_REQ_ERROR(req, err);
1308 SET_REQ_SUCCESS(req);
1309 POST_COMPLETION_FOR_REQ(loop, req);
1318 uv_write_t* req = (uv_write_t*) parameter;
1319 uv_pipe_t* handle = (uv_pipe_t*) req->handle;
1322 assert(req != NULL);
1323 assert(req->type == UV_WRITE);
1327 req->write_buffer.base,
1328 req->write_buffer.len,
1333 SET_REQ_ERROR(req, GetLastError());
1336 POST_COMPLETION_FOR_REQ(loop, req);
1342 uv_read_t* req;
1345 req = (uv_read_t*) context;
1346 assert(req != NULL);
1347 handle = (uv_tcp_t*)req->data;
1352 req->u.io.overlapped.InternalHigh,
1354 &req->u.io.overlapped)) {
1361 uv_write_t* req;
1364 req = (uv_write_t*) context;
1365 assert(req != NULL);
1366 handle = (uv_tcp_t*)req->handle;
1371 req->u.io.overlapped.InternalHigh,
1373 &req->u.io.overlapped)) {
1380 uv_read_t* req;
1388 req = &handle->read_req;
1393 req,
1395 /* Make this req pending reporting an error. */
1396 SET_REQ_ERROR(req, GetLastError());
1400 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
1402 assert(req->event_handle != NULL);
1403 req->u.io.overlapped.hEvent = (HANDLE) ((uintptr_t) req->event_handle | 1);
1411 &req->u.io.overlapped);
1414 /* Make this req pending reporting an error. */
1415 SET_REQ_ERROR(req, GetLastError());
1420 if (req->wait_handle == INVALID_HANDLE_VALUE) {
1421 if (!RegisterWaitForSingleObject(&req->wait_handle,
1422 req->event_handle, post_completion_read_wait, (void*) req,
1424 SET_REQ_ERROR(req, GetLastError());
1438 uv__insert_pending_req(loop, (uv_req_t*)req);
1472 uv_write_t* req) {
1473 req->next_req = NULL;
1475 req->next_req =
1477 handle->pipe.conn.non_overlapped_writes_tail->next_req = (uv_req_t*)req;
1478 handle->pipe.conn.non_overlapped_writes_tail = req;
1480 req->next_req = (uv_req_t*)req;
1481 handle->pipe.conn.non_overlapped_writes_tail = req;
1487 uv_write_t* req;
1490 req = (uv_write_t*)handle->pipe.conn.non_overlapped_writes_tail->next_req;
1492 if (req == handle->pipe.conn.non_overlapped_writes_tail) {
1496 req->next_req;
1499 return req;
1508 uv_write_t* req = uv_remove_non_overlapped_write_req(handle);
1509 if (req) {
1511 req,
1557 coalesced_write_req->req = *user_req; /* copy (a) */
1558 coalesced_write_req->req.coalesced = 1;
1573 *req_out = &coalesced_write_req->req;
1580 uv_write_t* req,
1592 UV_REQ_INIT(req, UV_WRITE);
1593 req->handle = (uv_stream_t*) handle;
1594 req->send_handle = NULL;
1595 req->cb = cb;
1597 req->coalesced = 0;
1598 req->event_handle = NULL;
1599 req->wait_handle = INVALID_HANDLE_VALUE;
1602 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
1604 req->event_handle = CreateEvent(NULL, 0, 0, NULL);
1605 if (req->event_handle == NULL) {
1608 req->u.io.overlapped.hEvent = (HANDLE) ((uintptr_t) req->event_handle | 1);
1610 req->write_buffer = uv_null_buf_;
1621 err = uv__build_coalesced_write_req(req, bufs, nbufs, &req, &write_buf);
1638 req->u.io.queued_bytes = 0;
1641 REGISTER_HANDLE_REQ(loop, handle, req);
1644 POST_COMPLETION_FOR_REQ(loop, req);
1647 req->write_buffer = write_buf;
1648 uv__insert_non_overlapped_write_req(handle, req);
1654 req->u.io.queued_bytes = write_buf.len;
1655 handle->write_queue_size += req->u.io.queued_bytes;
1662 &req->u.io.overlapped);
1666 CloseHandle(req->event_handle);
1667 req->event_handle = NULL;
1673 req->u.io.queued_bytes = 0;
1676 req->u.io.queued_bytes = write_buf.len;
1677 handle->write_queue_size += req->u.io.queued_bytes;
1678 if (WaitForSingleObject(req->event_handle, INFINITE) !=
1681 CloseHandle(req->event_handle);
1682 req->event_handle = NULL;
1686 CloseHandle(req->event_handle);
1687 req->event_handle = NULL;
1689 REGISTER_HANDLE_REQ(loop, handle, req);
1698 &req->u.io.overlapped);
1706 req->u.io.queued_bytes = 0;
1709 req->u.io.queued_bytes = write_buf.len;
1710 handle->write_queue_size += req->u.io.queued_bytes;
1714 if (!RegisterWaitForSingleObject(&req->wait_handle,
1715 req->event_handle, post_completion_write_wait, (void*) req,
1722 REGISTER_HANDLE_REQ(loop, handle, req);
1748 uv_write_t* req,
1838 err = uv__pipe_write_data(loop, req, handle, bufs, buf_count, cb, 1);
1850 uv_write_t* req,
1858 return uv__pipe_write_ipc(loop, req, handle, bufs, nbufs, send_handle, cb);
1862 return uv__pipe_write_data(loop, req, handle, bufs, nbufs, cb, 0);
2061 uv_req_t* req) {
2074 if (!REQ_SUCCESS(req)) {
2076 DWORD err = GET_REQ_ERROR(req);
2127 uv_write_t* req) {
2132 assert(handle->write_queue_size >= req->u.io.queued_bytes);
2133 handle->write_queue_size -= req->u.io.queued_bytes;
2135 UNREGISTER_HANDLE_REQ(loop, handle, req);
2138 if (req->wait_handle != INVALID_HANDLE_VALUE) {
2139 UnregisterWait(req->wait_handle);
2140 req->wait_handle = INVALID_HANDLE_VALUE;
2142 if (req->event_handle) {
2143 CloseHandle(req->event_handle);
2144 req->event_handle = NULL;
2148 err = GET_REQ_ERROR(req);
2152 * then free the heap-allocated write req. */
2153 if (req->coalesced) {
2155 container_of(req, uv__coalesced_write_t, req);
2156 req = coalesced_write->user_req;
2159 if (req->cb) {
2160 req->cb(req, uv_translate_sys_error(err));
2181 uv_pipe_accept_t* req = (uv_pipe_accept_t*) raw_req;
2186 /* The req->pipeHandle should be freed already in uv__pipe_close(). */
2187 assert(req->pipeHandle == INVALID_HANDLE_VALUE);
2192 if (REQ_SUCCESS(req)) {
2193 assert(req->pipeHandle != INVALID_HANDLE_VALUE);
2194 req->next_pending = handle->pipe.serv.pending_accepts;
2195 handle->pipe.serv.pending_accepts = req;
2201 if (req->pipeHandle != INVALID_HANDLE_VALUE) {
2202 CloseHandle(req->pipeHandle);
2203 req->pipeHandle = INVALID_HANDLE_VALUE;
2206 uv__pipe_queue_accept(loop, handle, req, FALSE);
2215 uv_connect_t* req) {
2222 UNREGISTER_HANDLE_REQ(loop, handle, req);
2225 if (REQ_SUCCESS(req)) {
2226 pipeHandle = req->u.connect.pipeHandle;
2227 duplex_flags = req->u.connect.duplex_flags;
2235 err = uv_translate_sys_error(GET_REQ_ERROR(req));
2238 if (req->cb)
2239 req->cb(req, err);
2247 uv_shutdown_t* req) {
2254 UNREGISTER_HANDLE_REQ(loop, handle, req);
2259 } else if (!REQ_SUCCESS(req)) {
2261 err = uv_translate_sys_error(GET_REQ_ERROR(req));
2282 if (req->cb)
2283 req->cb(req, err);