Lines Matching defs:req
30 #include "req-inl.h"
88 uv_write_t req; /* Internal heap-allocated write request. */
529 uv_pipe_accept_t* req, BOOL firstInstance) {
530 assert(req->pipeHandle == INVALID_HANDLE_VALUE);
532 req->pipeHandle =
539 if (req->pipeHandle == INVALID_HANDLE_VALUE) {
544 if (CreateIoCompletionPort(req->pipeHandle,
554 handle->handle = req->pipeHandle;
563 uv_shutdown_t* req;
565 req = (uv_shutdown_t*) parameter;
566 assert(req);
567 handle = (uv_pipe_t*) req->handle;
575 POST_COMPLETION_FOR_REQ(loop, req);
581 void uv__pipe_shutdown(uv_loop_t* loop, uv_pipe_t* handle, uv_shutdown_t *req) {
588 assert(req != NULL);
590 SET_REQ_SUCCESS(req);
593 uv__insert_pending_req(loop, (uv_req_t*) req);
605 SET_REQ_ERROR(req, pRtlNtStatusToDosError(nt_status));
607 uv__insert_pending_req(loop, (uv_req_t*) req);
614 uv__insert_pending_req(loop, (uv_req_t*) req);
620 req,
623 SET_REQ_ERROR(req, GetLastError());
625 uv__insert_pending_req(loop, (uv_req_t*) req);
699 uv_pipe_accept_t* req;
722 req = &handle->pipe.serv.accept_reqs[i];
723 UV_REQ_INIT(req, UV_ACCEPT);
724 req->data = handle;
725 req->pipeHandle = INVALID_HANDLE_VALUE;
726 req->next_pending = NULL;
782 uv_connect_t* req;
786 req = (uv_connect_t*) parameter;
787 assert(req);
788 handle = (uv_pipe_t*) req->handle;
805 SET_REQ_SUCCESS(req);
806 req->u.connect.pipeHandle = pipeHandle;
807 req->u.connect.duplex_flags = duplex_flags;
809 SET_REQ_ERROR(req, GetLastError());
813 POST_COMPLETION_FOR_REQ(loop, req);
819 void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle,
826 UV_REQ_INIT(req, UV_CONNECT);
827 req->handle = (uv_stream_t*) handle;
828 req->cb = cb;
829 req->u.connect.pipeHandle = INVALID_HANDLE_VALUE;
830 req->u.connect.duplex_flags = 0;
864 req,
870 REGISTER_HANDLE_REQ(loop, handle, req);
880 req->u.connect.pipeHandle = pipeHandle;
881 req->u.connect.duplex_flags = duplex_flags;
882 SET_REQ_SUCCESS(req);
883 uv__insert_pending_req(loop, (uv_req_t*) req);
885 REGISTER_HANDLE_REQ(loop, handle, req);
897 /* Make this req pending reporting an error. */
898 SET_REQ_ERROR(req, err);
899 uv__insert_pending_req(loop, (uv_req_t*) req);
901 REGISTER_HANDLE_REQ(loop, handle, req);
1014 uv_pipe_accept_t* req, BOOL firstInstance) {
1017 if (!firstInstance && !pipe_alloc_accept(loop, handle, req, FALSE)) {
1018 SET_REQ_ERROR(req, GetLastError());
1019 uv__insert_pending_req(loop, (uv_req_t*) req);
1024 assert(req->pipeHandle != INVALID_HANDLE_VALUE);
1027 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
1029 if (!ConnectNamedPipe(req->pipeHandle, &req->u.io.overlapped) &&
1032 SET_REQ_SUCCESS(req);
1034 CloseHandle(req->pipeHandle);
1035 req->pipeHandle = INVALID_HANDLE_VALUE;
1036 /* Make this req pending reporting an error. */
1037 SET_REQ_ERROR(req, GetLastError());
1039 uv__insert_pending_req(loop, (uv_req_t*) req);
1052 uv_pipe_accept_t* req;
1081 req = server->pipe.serv.pending_accepts;
1083 if (!req) {
1089 pipe_client->handle = req->pipeHandle;
1092 /* Prepare the req to pick up a new connection */
1093 server->pipe.serv.pending_accepts = req->next_pending;
1094 req->next_pending = NULL;
1095 req->pipeHandle = INVALID_HANDLE_VALUE;
1099 uv__pipe_queue_accept(loop, server, req, FALSE);
1148 uv_read_t* req = (uv_read_t*) arg;
1149 uv_pipe_t* handle = (uv_pipe_t*) req->data;
1157 assert(req->type == UV_READ);
1211 SET_REQ_ERROR(req, err);
1213 SET_REQ_SUCCESS(req);
1214 POST_COMPLETION_FOR_REQ(loop, req);
1223 uv_write_t* req = (uv_write_t*) parameter;
1224 uv_pipe_t* handle = (uv_pipe_t*) req->handle;
1227 assert(req != NULL);
1228 assert(req->type == UV_WRITE);
1232 req->write_buffer.base,
1233 req->write_buffer.len,
1238 SET_REQ_ERROR(req, GetLastError());
1241 POST_COMPLETION_FOR_REQ(loop, req);
1247 uv_read_t* req;
1250 req = (uv_read_t*) context;
1251 assert(req != NULL);
1252 handle = (uv_tcp_t*)req->data;
1257 req->u.io.overlapped.InternalHigh,
1259 &req->u.io.overlapped)) {
1266 uv_write_t* req;
1269 req = (uv_write_t*) context;
1270 assert(req != NULL);
1271 handle = (uv_tcp_t*)req->handle;
1276 req->u.io.overlapped.InternalHigh,
1278 &req->u.io.overlapped)) {
1285 uv_read_t* req;
1293 req = &handle->read_req;
1298 req,
1300 /* Make this req pending reporting an error. */
1301 SET_REQ_ERROR(req, GetLastError());
1305 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
1307 assert(req->event_handle != NULL);
1308 req->u.io.overlapped.hEvent = (HANDLE) ((uintptr_t) req->event_handle | 1);
1316 &req->u.io.overlapped);
1319 /* Make this req pending reporting an error. */
1320 SET_REQ_ERROR(req, GetLastError());
1325 if (req->wait_handle == INVALID_HANDLE_VALUE) {
1326 if (!RegisterWaitForSingleObject(&req->wait_handle,
1327 req->event_handle, post_completion_read_wait, (void*) req,
1329 SET_REQ_ERROR(req, GetLastError());
1343 uv__insert_pending_req(loop, (uv_req_t*)req);
1377 uv_write_t* req) {
1378 req->next_req = NULL;
1380 req->next_req =
1382 handle->pipe.conn.non_overlapped_writes_tail->next_req = (uv_req_t*)req;
1383 handle->pipe.conn.non_overlapped_writes_tail = req;
1385 req->next_req = (uv_req_t*)req;
1386 handle->pipe.conn.non_overlapped_writes_tail = req;
1392 uv_write_t* req;
1395 req = (uv_write_t*)handle->pipe.conn.non_overlapped_writes_tail->next_req;
1397 if (req == handle->pipe.conn.non_overlapped_writes_tail) {
1401 req->next_req;
1404 return req;
1413 uv_write_t* req = uv_remove_non_overlapped_write_req(handle);
1414 if (req) {
1416 req,
1462 coalesced_write_req->req = *user_req; /* copy (a) */
1463 coalesced_write_req->req.coalesced = 1;
1478 *req_out = &coalesced_write_req->req;
1485 uv_write_t* req,
1497 UV_REQ_INIT(req, UV_WRITE);
1498 req->handle = (uv_stream_t*) handle;
1499 req->send_handle = NULL;
1500 req->cb = cb;
1502 req->coalesced = 0;
1503 req->event_handle = NULL;
1504 req->wait_handle = INVALID_HANDLE_VALUE;
1507 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
1509 req->event_handle = CreateEvent(NULL, 0, 0, NULL);
1510 if (req->event_handle == NULL) {
1513 req->u.io.overlapped.hEvent = (HANDLE) ((uintptr_t) req->event_handle | 1);
1515 req->write_buffer = uv_null_buf_;
1526 err = uv__build_coalesced_write_req(req, bufs, nbufs, &req, &write_buf);
1543 req->u.io.queued_bytes = 0;
1546 REGISTER_HANDLE_REQ(loop, handle, req);
1549 POST_COMPLETION_FOR_REQ(loop, req);
1552 req->write_buffer = write_buf;
1553 uv__insert_non_overlapped_write_req(handle, req);
1559 req->u.io.queued_bytes = write_buf.len;
1560 handle->write_queue_size += req->u.io.queued_bytes;
1567 &req->u.io.overlapped);
1571 CloseHandle(req->event_handle);
1572 req->event_handle = NULL;
1578 req->u.io.queued_bytes = 0;
1581 req->u.io.queued_bytes = write_buf.len;
1582 handle->write_queue_size += req->u.io.queued_bytes;
1583 if (WaitForSingleObject(req->event_handle, INFINITE) !=
1586 CloseHandle(req->event_handle);
1587 req->event_handle = NULL;
1591 CloseHandle(req->event_handle);
1592 req->event_handle = NULL;
1594 REGISTER_HANDLE_REQ(loop, handle, req);
1603 &req->u.io.overlapped);
1611 req->u.io.queued_bytes = 0;
1614 req->u.io.queued_bytes = write_buf.len;
1615 handle->write_queue_size += req->u.io.queued_bytes;
1619 if (!RegisterWaitForSingleObject(&req->wait_handle,
1620 req->event_handle, post_completion_write_wait, (void*) req,
1627 REGISTER_HANDLE_REQ(loop, handle, req);
1649 uv_write_t* req,
1739 err = uv__pipe_write_data(loop, req, handle, bufs, buf_count, cb, 1);
1751 uv_write_t* req,
1759 return uv__pipe_write_ipc(loop, req, handle, bufs, nbufs, send_handle, cb);
1763 return uv__pipe_write_data(loop, req, handle, bufs, nbufs, cb, 0);
1962 uv_req_t* req) {
1975 if (!REQ_SUCCESS(req)) {
1977 DWORD err = GET_REQ_ERROR(req);
2028 uv_write_t* req) {
2033 assert(handle->write_queue_size >= req->u.io.queued_bytes);
2034 handle->write_queue_size -= req->u.io.queued_bytes;
2036 UNREGISTER_HANDLE_REQ(loop, handle, req);
2039 if (req->wait_handle != INVALID_HANDLE_VALUE) {
2040 UnregisterWait(req->wait_handle);
2041 req->wait_handle = INVALID_HANDLE_VALUE;
2043 if (req->event_handle) {
2044 CloseHandle(req->event_handle);
2045 req->event_handle = NULL;
2049 err = GET_REQ_ERROR(req);
2053 * then free the heap-allocated write req. */
2054 if (req->coalesced) {
2056 container_of(req, uv__coalesced_write_t, req);
2057 req = coalesced_write->user_req;
2060 if (req->cb) {
2061 req->cb(req, uv_translate_sys_error(err));
2082 uv_pipe_accept_t* req = (uv_pipe_accept_t*) raw_req;
2087 /* The req->pipeHandle should be freed already in uv__pipe_close(). */
2088 assert(req->pipeHandle == INVALID_HANDLE_VALUE);
2093 if (REQ_SUCCESS(req)) {
2094 assert(req->pipeHandle != INVALID_HANDLE_VALUE);
2095 req->next_pending = handle->pipe.serv.pending_accepts;
2096 handle->pipe.serv.pending_accepts = req;
2102 if (req->pipeHandle != INVALID_HANDLE_VALUE) {
2103 CloseHandle(req->pipeHandle);
2104 req->pipeHandle = INVALID_HANDLE_VALUE;
2107 uv__pipe_queue_accept(loop, handle, req, FALSE);
2116 uv_connect_t* req) {
2123 UNREGISTER_HANDLE_REQ(loop, handle, req);
2126 if (REQ_SUCCESS(req)) {
2127 pipeHandle = req->u.connect.pipeHandle;
2128 duplex_flags = req->u.connect.duplex_flags;
2133 err = uv_translate_sys_error(GET_REQ_ERROR(req));
2136 if (req->cb)
2137 req->cb(req, err);
2145 uv_shutdown_t* req) {
2153 UNREGISTER_HANDLE_REQ(loop, handle, req);
2158 } else if (!REQ_SUCCESS(req)) {
2160 err = uv_translate_sys_error(GET_REQ_ERROR(req));
2181 if (req->cb)
2182 req->cb(req, err);