Lines Matching defs:req
29 #include "req-inl.h"
200 void uv__process_tcp_shutdown_req(uv_loop_t* loop, uv_tcp_t* stream, uv_shutdown_t *req) {
203 assert(req);
209 UNREGISTER_HANDLE_REQ(loop, stream, req);
220 if (req->cb)
221 req->cb(req, err);
229 uv_tcp_accept_t* req;
239 req = &handle->tcp.serv.accept_reqs[i];
240 if (req->wait_handle != INVALID_HANDLE_VALUE) {
241 UnregisterWait(req->wait_handle);
242 req->wait_handle = INVALID_HANDLE_VALUE;
244 if (req->event_handle != NULL) {
245 CloseHandle(req->event_handle);
246 req->event_handle = NULL;
344 uv_req_t* req;
347 req = (uv_req_t*) context;
348 assert(req != NULL);
349 handle = (uv_tcp_t*)req->data;
354 req->u.io.overlapped.InternalHigh,
356 &req->u.io.overlapped)) {
363 uv_write_t* req;
366 req = (uv_write_t*) context;
367 assert(req != NULL);
368 handle = (uv_tcp_t*)req->handle;
373 req->u.io.overlapped.InternalHigh,
375 &req->u.io.overlapped)) {
381 static void uv__tcp_queue_accept(uv_tcp_t* handle, uv_tcp_accept_t* req) {
389 assert(req->accept_socket == INVALID_SOCKET);
401 SET_REQ_ERROR(req, WSAGetLastError());
402 uv__insert_pending_req(loop, (uv_req_t*)req);
409 SET_REQ_ERROR(req, GetLastError());
410 uv__insert_pending_req(loop, (uv_req_t*)req);
417 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
419 assert(req->event_handle != NULL);
420 req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
425 (void*)req->accept_buffer,
430 &req->u.io.overlapped);
433 /* Process the req without IOCP. */
434 req->accept_socket = accept_socket;
436 uv__insert_pending_req(loop, (uv_req_t*)req);
438 /* The req will be processed with IOCP. */
439 req->accept_socket = accept_socket;
442 req->wait_handle == INVALID_HANDLE_VALUE &&
443 !RegisterWaitForSingleObject(&req->wait_handle,
444 req->event_handle, post_completion, (void*) req,
446 SET_REQ_ERROR(req, GetLastError());
447 uv__insert_pending_req(loop, (uv_req_t*)req);
450 /* Make this req pending reporting an error. */
451 SET_REQ_ERROR(req, WSAGetLastError());
452 uv__insert_pending_req(loop, (uv_req_t*)req);
458 CloseHandle(req->event_handle);
459 req->event_handle = NULL;
466 uv_read_t* req;
474 req = &handle->read_req;
475 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
482 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
484 assert(req->event_handle != NULL);
485 req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
494 &req->u.io.overlapped,
501 /* Process the req without IOCP. */
502 req->u.io.overlapped.InternalHigh = bytes;
503 uv__insert_pending_req(loop, (uv_req_t*)req);
505 /* The req will be processed with IOCP. */
507 req->wait_handle == INVALID_HANDLE_VALUE &&
508 !RegisterWaitForSingleObject(&req->wait_handle,
509 req->event_handle, post_completion, (void*) req,
511 SET_REQ_ERROR(req, GetLastError());
512 uv__insert_pending_req(loop, (uv_req_t*)req);
515 /* Make this req pending reporting an error. */
516 SET_REQ_ERROR(req, WSAGetLastError());
517 uv__insert_pending_req(loop, (uv_req_t*)req);
539 uv_tcp_accept_t* req;
594 req = &handle->tcp.serv.accept_reqs[i];
595 UV_REQ_INIT(req, UV_ACCEPT);
596 req->accept_socket = INVALID_SOCKET;
597 req->data = handle;
599 req->wait_handle = INVALID_HANDLE_VALUE;
601 req->event_handle = CreateEvent(NULL, 0, 0, NULL);
602 if (req->event_handle == NULL) {
606 req->event_handle = NULL;
609 uv__tcp_queue_accept(handle, req);
616 req = &handle->tcp.serv.accept_reqs[i];
617 UV_REQ_INIT(req, UV_ACCEPT);
618 req->accept_socket = INVALID_SOCKET;
619 req->data = handle;
620 req->wait_handle = INVALID_HANDLE_VALUE;
621 req->event_handle = NULL;
633 uv_tcp_accept_t* req = server->tcp.serv.pending_accepts;
635 if (!req) {
640 if (req->accept_socket == INVALID_SOCKET) {
652 req->accept_socket,
656 closesocket(req->accept_socket);
663 /* Prepare the req to pick up a new connection */
664 server->tcp.serv.pending_accepts = req->next_pending;
665 req->next_pending = NULL;
666 req->accept_socket = INVALID_SOCKET;
671 uv__tcp_queue_accept(server, req);
755 static int uv__tcp_try_connect(uv_connect_t* req,
817 UV_REQ_INIT(req, UV_CONNECT);
818 req->handle = (uv_stream_t*) handle;
819 req->cb = cb;
820 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
823 /* Process the req without IOCP. */
825 REGISTER_HANDLE_REQ(loop, handle, req);
826 uv__insert_pending_req(loop, (uv_req_t*)req);
836 &req->u.io.overlapped);
839 /* Process the req without IOCP. */
841 REGISTER_HANDLE_REQ(loop, handle, req);
842 uv__insert_pending_req(loop, (uv_req_t*)req);
844 /* The req will be processed with IOCP. */
846 REGISTER_HANDLE_REQ(loop, handle, req);
880 uv_write_t* req,
888 UV_REQ_INIT(req, UV_WRITE);
889 req->handle = (uv_stream_t*) handle;
890 req->cb = cb;
893 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
895 req->event_handle = CreateEvent(NULL, 0, 0, NULL);
896 if (req->event_handle == NULL) {
899 req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
900 req->wait_handle = INVALID_HANDLE_VALUE;
908 &req->u.io.overlapped,
913 req->u.io.queued_bytes = 0;
916 REGISTER_HANDLE_REQ(loop, handle, req);
917 uv__insert_pending_req(loop, (uv_req_t*) req);
920 req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);
923 REGISTER_HANDLE_REQ(loop, handle, req);
924 handle->write_queue_size += req->u.io.queued_bytes;
926 !RegisterWaitForSingleObject(&req->wait_handle,
927 req->event_handle, post_write_completion, (void*) req,
929 SET_REQ_ERROR(req, GetLastError());
930 uv__insert_pending_req(loop, (uv_req_t*)req);
934 req->u.io.queued_bytes = 0;
937 REGISTER_HANDLE_REQ(loop, handle, req);
938 SET_REQ_ERROR(req, WSAGetLastError());
939 uv__insert_pending_req(loop, (uv_req_t*) req);
971 uv_req_t* req) {
980 if (!REQ_SUCCESS(req)) {
989 err = GET_REQ_SOCK_ERROR(req);
1005 if (req->u.io.overlapped.InternalHigh > 0) {
1008 req->u.io.overlapped.InternalHigh,
1011 if (req->u.io.overlapped.InternalHigh < handle->tcp.conn.read_buffer.len) {
1100 uv_write_t* req) {
1105 assert(handle->write_queue_size >= req->u.io.queued_bytes);
1106 handle->write_queue_size -= req->u.io.queued_bytes;
1108 UNREGISTER_HANDLE_REQ(loop, handle, req);
1111 if (req->wait_handle != INVALID_HANDLE_VALUE) {
1112 UnregisterWait(req->wait_handle);
1113 req->wait_handle = INVALID_HANDLE_VALUE;
1115 if (req->event_handle != NULL) {
1116 CloseHandle(req->event_handle);
1117 req->event_handle = NULL;
1121 if (req->cb) {
1122 err = uv_translate_sys_error(GET_REQ_SOCK_ERROR(req));
1127 req->cb(req, err);
1148 uv_tcp_accept_t* req = (uv_tcp_accept_t*) raw_req;
1156 if (req->accept_socket == INVALID_SOCKET) {
1161 err = GET_REQ_SOCK_ERROR(req);
1166 } else if (REQ_SUCCESS(req) &&
1167 setsockopt(req->accept_socket,
1172 req->next_pending = handle->tcp.serv.pending_accepts;
1173 handle->tcp.serv.pending_accepts = req;
1183 closesocket(req->accept_socket);
1184 req->accept_socket = INVALID_SOCKET;
1186 uv__tcp_queue_accept(handle, req);
1195 uv_connect_t* req) {
1200 UNREGISTER_HANDLE_REQ(loop, handle, req);
1210 } else if (REQ_SUCCESS(req)) {
1225 err = GET_REQ_SOCK_ERROR(req);
1227 req->cb(req, uv_translate_sys_error(err));
1443 uv_tcp_accept_t* req = &tcp->tcp.serv.accept_reqs[i];
1444 if (req->accept_socket != INVALID_SOCKET) {
1445 closesocket(req->accept_socket);
1446 req->accept_socket = INVALID_SOCKET;
1461 /* If any overlapped req failed to cancel, calling `closesocket` now would
1540 int uv__tcp_connect(uv_connect_t* req,
1547 err = uv__tcp_try_connect(req, handle, addr, addrlen, cb);