Lines Matching defs:req
29 #include "req-inl.h"
208 void uv__process_tcp_shutdown_req(uv_loop_t* loop, uv_tcp_t* stream, uv_shutdown_t *req) {
211 assert(req);
218 UNREGISTER_HANDLE_REQ(loop, stream, req);
229 if (req->cb)
230 req->cb(req, err);
238 uv_tcp_accept_t* req;
248 req = &handle->tcp.serv.accept_reqs[i];
249 if (req->wait_handle != INVALID_HANDLE_VALUE) {
250 UnregisterWait(req->wait_handle);
251 req->wait_handle = INVALID_HANDLE_VALUE;
253 if (req->event_handle != NULL) {
254 CloseHandle(req->event_handle);
255 req->event_handle = NULL;
354 uv_req_t* req;
357 req = (uv_req_t*) context;
358 assert(req != NULL);
359 handle = (uv_tcp_t*)req->data;
364 req->u.io.overlapped.InternalHigh,
366 &req->u.io.overlapped)) {
373 uv_write_t* req;
376 req = (uv_write_t*) context;
377 assert(req != NULL);
378 handle = (uv_tcp_t*)req->handle;
383 req->u.io.overlapped.InternalHigh,
385 &req->u.io.overlapped)) {
391 static void uv__tcp_queue_accept(uv_tcp_t* handle, uv_tcp_accept_t* req) {
399 assert(req->accept_socket == INVALID_SOCKET);
411 SET_REQ_ERROR(req, WSAGetLastError());
412 uv__insert_pending_req(loop, (uv_req_t*)req);
419 SET_REQ_ERROR(req, GetLastError());
420 uv__insert_pending_req(loop, (uv_req_t*)req);
427 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
429 assert(req->event_handle != NULL);
430 req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
435 (void*)req->accept_buffer,
440 &req->u.io.overlapped);
443 /* Process the req without IOCP. */
444 req->accept_socket = accept_socket;
446 uv__insert_pending_req(loop, (uv_req_t*)req);
448 /* The req will be processed with IOCP. */
449 req->accept_socket = accept_socket;
452 req->wait_handle == INVALID_HANDLE_VALUE &&
453 !RegisterWaitForSingleObject(&req->wait_handle,
454 req->event_handle, post_completion, (void*) req,
456 SET_REQ_ERROR(req, GetLastError());
457 uv__insert_pending_req(loop, (uv_req_t*)req);
460 /* Make this req pending reporting an error. */
461 SET_REQ_ERROR(req, WSAGetLastError());
462 uv__insert_pending_req(loop, (uv_req_t*)req);
468 CloseHandle(req->event_handle);
469 req->event_handle = NULL;
476 uv_read_t* req;
484 req = &handle->read_req;
485 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
509 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
511 assert(req->event_handle != NULL);
512 req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
521 &req->u.io.overlapped,
528 /* Process the req without IOCP. */
529 req->u.io.overlapped.InternalHigh = bytes;
530 uv__insert_pending_req(loop, (uv_req_t*)req);
532 /* The req will be processed with IOCP. */
534 req->wait_handle == INVALID_HANDLE_VALUE &&
535 !RegisterWaitForSingleObject(&req->wait_handle,
536 req->event_handle, post_completion, (void*) req,
538 SET_REQ_ERROR(req, GetLastError());
539 uv__insert_pending_req(loop, (uv_req_t*)req);
542 /* Make this req pending reporting an error. */
543 SET_REQ_ERROR(req, WSAGetLastError());
544 uv__insert_pending_req(loop, (uv_req_t*)req);
566 uv_tcp_accept_t* req;
621 req = &handle->tcp.serv.accept_reqs[i];
622 UV_REQ_INIT(req, UV_ACCEPT);
623 req->accept_socket = INVALID_SOCKET;
624 req->data = handle;
626 req->wait_handle = INVALID_HANDLE_VALUE;
628 req->event_handle = CreateEvent(NULL, 0, 0, NULL);
629 if (req->event_handle == NULL) {
633 req->event_handle = NULL;
636 uv__tcp_queue_accept(handle, req);
643 req = &handle->tcp.serv.accept_reqs[i];
644 UV_REQ_INIT(req, UV_ACCEPT);
645 req->accept_socket = INVALID_SOCKET;
646 req->data = handle;
647 req->wait_handle = INVALID_HANDLE_VALUE;
648 req->event_handle = NULL;
661 uv_tcp_accept_t* req = server->tcp.serv.pending_accepts;
663 if (!req) {
668 if (req->accept_socket == INVALID_SOCKET) {
680 req->accept_socket,
684 closesocket(req->accept_socket);
691 /* Prepare the req to pick up a new connection */
692 server->tcp.serv.pending_accepts = req->next_pending;
693 req->next_pending = NULL;
694 req->accept_socket = INVALID_SOCKET;
699 uv__tcp_queue_accept(server, req);
785 static int uv__tcp_try_connect(uv_connect_t* req,
847 UV_REQ_INIT(req, UV_CONNECT);
848 req->handle = (uv_stream_t*) handle;
849 req->cb = cb;
850 memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
853 /* Process the req without IOCP. */
855 REGISTER_HANDLE_REQ(loop, handle, req);
856 uv__insert_pending_req(loop, (uv_req_t*)req);
866 &req->u.io.overlapped);
869 /* Process the req without IOCP. */
871 REGISTER_HANDLE_REQ(loop, handle, req);
872 uv__insert_pending_req(loop, (uv_req_t*)req);
874 /* The req will be processed with IOCP. */
876 REGISTER_HANDLE_REQ(loop, handle, req);
910 uv_write_t* req,
918 UV_REQ_INIT(req, UV_WRITE);
919 req->handle = (uv_stream_t*) handle;
920 req->cb = cb;
923 memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped));
925 req->event_handle = CreateEvent(NULL, 0, 0, NULL);
926 if (req->event_handle == NULL) {
929 req->u.io.overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
930 req->wait_handle = INVALID_HANDLE_VALUE;
938 &req->u.io.overlapped,
943 req->u.io.queued_bytes = 0;
946 REGISTER_HANDLE_REQ(loop, handle, req);
947 uv__insert_pending_req(loop, (uv_req_t*) req);
950 req->u.io.queued_bytes = uv__count_bufs(bufs, nbufs);
953 REGISTER_HANDLE_REQ(loop, handle, req);
954 handle->write_queue_size += req->u.io.queued_bytes;
956 !RegisterWaitForSingleObject(&req->wait_handle,
957 req->event_handle, post_write_completion, (void*) req,
959 SET_REQ_ERROR(req, GetLastError());
960 uv__insert_pending_req(loop, (uv_req_t*)req);
964 req->u.io.queued_bytes = 0;
967 REGISTER_HANDLE_REQ(loop, handle, req);
968 SET_REQ_ERROR(req, WSAGetLastError());
969 uv__insert_pending_req(loop, (uv_req_t*) req);
1001 uv_req_t* req) {
1010 if (!REQ_SUCCESS(req)) {
1019 err = GET_REQ_SOCK_ERROR(req);
1035 if (req->u.io.overlapped.InternalHigh > 0) {
1038 req->u.io.overlapped.InternalHigh,
1041 if (req->u.io.overlapped.InternalHigh < handle->tcp.conn.read_buffer.len) {
1130 uv_write_t* req) {
1135 assert(handle->write_queue_size >= req->u.io.queued_bytes);
1136 handle->write_queue_size -= req->u.io.queued_bytes;
1138 UNREGISTER_HANDLE_REQ(loop, handle, req);
1141 if (req->wait_handle != INVALID_HANDLE_VALUE) {
1142 UnregisterWait(req->wait_handle);
1143 req->wait_handle = INVALID_HANDLE_VALUE;
1145 if (req->event_handle != NULL) {
1146 CloseHandle(req->event_handle);
1147 req->event_handle = NULL;
1151 if (req->cb) {
1152 err = uv_translate_sys_error(GET_REQ_SOCK_ERROR(req));
1157 req->cb(req, err);
1178 uv_tcp_accept_t* req = (uv_tcp_accept_t*) raw_req;
1186 if (req->accept_socket == INVALID_SOCKET) {
1191 err = GET_REQ_SOCK_ERROR(req);
1196 } else if (REQ_SUCCESS(req) &&
1197 setsockopt(req->accept_socket,
1202 req->next_pending = handle->tcp.serv.pending_accepts;
1203 handle->tcp.serv.pending_accepts = req;
1213 closesocket(req->accept_socket);
1214 req->accept_socket = INVALID_SOCKET;
1216 uv__tcp_queue_accept(handle, req);
1225 uv_connect_t* req) {
1230 UNREGISTER_HANDLE_REQ(loop, handle, req);
1240 } else if (REQ_SUCCESS(req)) {
1256 err = GET_REQ_SOCK_ERROR(req);
1258 req->cb(req, uv_translate_sys_error(err));
1475 uv_tcp_accept_t* req = &tcp->tcp.serv.accept_reqs[i];
1476 if (req->accept_socket != INVALID_SOCKET) {
1477 closesocket(req->accept_socket);
1478 req->accept_socket = INVALID_SOCKET;
1493 /* If any overlapped req failed to cancel, calling `closesocket` now would
1572 int uv__tcp_connect(uv_connect_t* req,
1579 err = uv__tcp_try_connect(req, handle, addr, addrlen, cb);