void TcpConnection::stop() { assert(dispatcher != nullptr); assert(!stopped); if (readContext != nullptr) { TcpConnectionContext* context = static_cast<TcpConnectionContext*>(readContext); if (!context->interrupted) { if (CancelIoEx(reinterpret_cast<HANDLE>(connection), context) != TRUE) { DWORD lastError = GetLastError(); if (lastError != ERROR_NOT_FOUND) { throw std::runtime_error("TcpConnection::stop, CancelIoEx failed, result=" + std::to_string(GetLastError())); } } context->interrupted = true; } } if (writeContext != nullptr) { TcpConnectionContext* context = static_cast<TcpConnectionContext*>(writeContext); if (!context->interrupted) { if (CancelIoEx(reinterpret_cast<HANDLE>(connection), context) != TRUE) { DWORD lastError = GetLastError(); if (lastError != ERROR_NOT_FOUND) { throw std::runtime_error("TcpConnection::stop, CancelIoEx failed, result=" + std::to_string(GetLastError())); } } context->interrupted = true; } } stopped = true; }
void FDirectoryWatchRequestWindows::EndWatchRequest() { if ( !bEndWatchRequestInvoked && !bPendingDelete ) { if ( DirectoryHandle != INVALID_HANDLE_VALUE ) { #if WINVER >= 0x600 // CancelIoEx() is only supported on Windows Vista and higher CancelIoEx(DirectoryHandle, &Overlapped); #else CancelIo(DirectoryHandle); #endif // Clear the handle so we don't setup any more requests, and wait for the operation to finish HANDLE TempDirectoryHandle = DirectoryHandle; DirectoryHandle = INVALID_HANDLE_VALUE; WaitForSingleObjectEx(TempDirectoryHandle, 1000, true); ::CloseHandle(TempDirectoryHandle); } else { // The directory handle was never opened bPendingDelete = true; } // Only allow this to be invoked once bEndWatchRequestInvoked = true; } }
static void tr_watchdir_win32_free (tr_watchdir_backend * backend_base) { tr_watchdir_win32 * const backend = BACKEND_UPCAST (backend_base); if (backend == NULL) return; assert (backend->base.free_func == &tr_watchdir_win32_free); if (backend->fd != INVALID_HANDLE_VALUE) CancelIoEx (backend->fd, &backend->overlapped); if (backend->thread != NULL) { WaitForSingleObject (backend->thread, INFINITE); CloseHandle (backend->thread); } if (backend->event != NULL) bufferevent_free (backend->event); if (backend->notify_pipe[0] != TR_BAD_SOCKET) evutil_closesocket (backend->notify_pipe[0]); if (backend->notify_pipe[1] != TR_BAD_SOCKET) evutil_closesocket (backend->notify_pipe[1]); if (backend->fd != INVALID_HANDLE_VALUE) CloseHandle (backend->fd); tr_free (backend); }
AsyncIO::~AsyncIO() { if (*this) { if (CancelIoEx(m_fh, nullptr)) waitForCompletion(); CloseHandle(m_fh); } }
void SarClient::stop() { if (_mmNotificationClientRegistered) { _mmEnumerator->UnregisterEndpointNotificationCallback( _mmNotificationClient); _mmNotificationClientRegistered = false; } if (_mmNotificationClient) { _mmNotificationClient->Release(); _mmNotificationClient = nullptr; } if (_mmEnumerator) { _mmEnumerator = nullptr; } if (_device != INVALID_HANDLE_VALUE) { CancelIoEx(_device, nullptr); CloseHandle(_device); _device = INVALID_HANDLE_VALUE; } if (_completionPort) { CloseHandle(_completionPort); _completionPort = nullptr; } }
void Watch::close() { if (directory != NULL) { CancelIoEx(*directory, *this); directory->close(); Directory::dec_ref(*directory); directory = NULL; } }
//------------------------------------------------------------------------------ void system_stopSyncThread(void) { CancelIoEx(syncThreadInstance_l.hSyncThreadHandle, NULL); // Signal to stop the thread and wait for the thread to terminate syncThreadInstance_l.fThreadExit = TRUE; WaitForSingleObject(syncThreadInstance_l.hSyncThreadHandle, 1000); }
static void cancelWindowsTransferOperation (OperationEntry *operation) { FunctionEntry *function = operation->function; DWORD count; if (CancelIoEx(function->fileDescriptor, &function->windows.overlapped)) { GetOverlappedResult(function->fileDescriptor, &function->windows.overlapped, &count, TRUE); } }
/** *@错误回调,从连接池中回收部分socket后,需要新增部分socket,否则最后可能socket资源耗尽,造成无法服务 */ void iocp_onerror( iocp_overlapped* &pOL ){ CancelIoEx((HANDLE)pOL->m_skClient,&pOL->m_ol); shutdown( pOL->m_skClient, SD_BOTH); iocp_create_client( pOL->m_skServer , pOL->m_timeout ); pOL->m_usenum = 0; //iocp_remove_form_map 清理发生错误的socket }
void DirectoryWatcherImpl::setActive(const bool active) { if (!active && m_active && m_fileHandle) { m_active = false; CancelIoEx(m_fileHandle, NULL); } m_active = active; }
DirectoryWatcherImpl::~DirectoryWatcherImpl() { m_shouldClose = true; m_active = false; if (m_fileHandle) CancelIoEx(m_fileHandle, NULL); m_thread.join(); }
virtual ~FileSystemWatcherPC() { if (m_task) { CancelIoEx(m_task->m_handle, nullptr); CloseHandle(m_task->m_handle); m_task->destroy(); LUMIX_DELETE(m_allocator, m_task); } }
void CClient::Restart(NETOP curOp) { CLock lock(&m_criticalSection); LOG("Restart client[%d], current status[%s] and operation[%s].", GetID(), NETSTATUSSTR[m_status], NETOPSTR[curOp]); switch (m_status) { case NETSTATUS_Dead: { if (curOp == NETOP_Accept) LOG("Cann't start client[%d].", GetID()); } break; case NETSTATUS_Connected: { if (curOp == NETOP_Accept) { Stop(); if (!Start()) LOG("Fail to start client[%d].", GetID()); } } break; case NETSTATUS_CompletionNotify: { if (CancelIoEx((HANDLE)m_socket, NULL) == 0) { if (GetLastError() != ERROR_NOT_FOUND) LOG("Client[%d] fail to call CancelIoEx.", GetID()); } if (!AppendDisconnect(true)) { LOG("Client[%d] fail to append disconnect.", GetID()); Stop(); if (!Start()) LOG("Fail to start client[%d].", GetID()); } } break; case NETSTATUS_Disconnecting: case NETSTATUS_Disconnected: { if (curOp==NETOP_Disconnect || curOp==NETOP_Accept) { Stop(); if (!Start()) LOG("Fail to start client[%d].", GetID()); } } break; default: LOG("Client[%d] get an unexpected status[%s].", GetID(), NETSTATUSSTR[m_status]); break; } }
VOID STDCALL OSMonitorFileDestroy (OSFileChangeData *data) { if(!HasOverlappedIoCompleted(&data->directoryChange)) { CancelIoEx(data->hDirectory, &data->directoryChange); WaitForSingleObject(data->directoryChange.hEvent, INFINITE); } CloseHandle(data->directoryChange.hEvent); CloseHandle(data->hDirectory); Free(data); }
void triebWerk::CFileWatcher::StopWatching() { m_Events.clear(); m_Active = false; if (m_FileHandle != INVALID_HANDLE_VALUE) { //Stop the ReadDirectoryChangesW so the thread can be joined CancelIoEx(m_FileHandle, NULL); m_Thread.join(); } }
AsyncIO& AsyncIO::operator=(AsyncIO&& other) { if (*this) { if (CancelIoEx(m_fh, nullptr)) waitForCompletion(); CloseHandle(m_fh); } m_fh = other.m_fh; other.m_fh = INVALID_HANDLE_VALUE; m_queue = std::move(other.m_queue); m_maxBlock = other.m_maxBlock; return *this; }
SocketSender::~SocketSender() { #ifdef USE_WINDOWS_STYLE_SOCKETS # if defined(USE_WINDOWS8_API) BOOL result = CancelIoEx((HANDLE) m_s.GetSocket(), NULL); assert(result || (!result && GetLastError() == ERROR_NOT_FOUND)); # else BOOL result = CancelIo((HANDLE) m_s.GetSocket()); assert(result || (!result && GetLastError() == ERROR_NOT_FOUND)); # endif #endif }
void DriverShutdown() { // Signal to driver to stop and cancel any in-progress io operations SetEvent(g_hStopTheadEvent); if (g_hDriver != INVALID_HANDLE_VALUE) { // Canceling pending io operations CancelIoEx(g_hDriver, NULL); } // Wait for the thread which takes care of closing the device driver WaitForSingleObject(g_hThread, INFINITE); UnloadKernelDriver(); }
static int win_close(w_stm_t stm) { struct win_handle *h = stm->handle; EnterCriticalSection(&h->mtx); if (h->read_pending) { if (CancelIoEx(h->h, &h->read_pending->olap)) { free(h->read_pending); h->read_pending = NULL; } } if (h->write_pending) { if (CancelIoEx(h->h, &h->write_pending->olap)) { free(h->write_pending); h->write_pending = NULL; } while (h->write_head) { struct write_buf *b = h->write_head; h->write_head = b->next; free(b->data); free(b); } } if (h->h != INVALID_HANDLE_VALUE) { CloseHandle(h->h); h->h = INVALID_HANDLE_VALUE; } if (h->waitable) { CloseHandle(h->waitable); } free(h); stm->handle = NULL; return 0; }
static void request_cancel(struct mp_input_src *src) { struct priv *p = src->priv; MP_VERBOSE(src, "Exiting...\n"); atomic_store(&p->cancel_requested, true); // The thread might not be peforming I/O at the exact moment when // CancelIoEx is called, so call it in a loop until it succeeds or the // thread exits do { if (CancelIoEx(p->file, NULL)) break; } while (WaitForSingleObject(p->thread, 1) != WAIT_OBJECT_0); }
int FilterThread( FILE* ChildOutput, DWORD millisecTimeout ) { FilterThreadData data = { ThreadId, &BufSize, &StartPointer, ThreadOut, ThreadFull, ChildOutput }; HANDLE hThreadWorker = (HANDLE)_beginthreadex(nullptr, 0, FilterWorker, &data, 0, nullptr); if (hThreadWorker == 0) { LogError("Failed to create FilterWorker thread - error = %d", GetLastError()); return -1; } DWORD waitresult = WaitForSingleObject(hThreadWorker, millisecTimeout); int rc = 0; if (waitresult == WAIT_TIMEOUT) { // Abort the worker thread by cancelling the IO operations on the pipe CancelIoEx((HANDLE)_get_osfhandle(_fileno(ChildOutput)), nullptr); WaitForSingleObject(hThreadWorker, INFINITE); rc = WAIT_TIMEOUT; } else { DWORD ec; if (!GetExitCodeThread(hThreadWorker, &ec)) { LogError("Could not get exit code from FilterWorker worker thread - error = %d", GetLastError()); rc = -1; } if (ec != 0) { LogError("Pipe read failed - errno = %d\n", ec); rc = -1; } } CloseHandle(hThreadWorker); return rc; }
FileWatchdog::~FileWatchdog() { memset( m_WorkingDirectory, 0, FILENAME_MAX * sizeof( char ) ); CancelIoEx( m_Watchdog, nullptr ); CloseHandle( m_Watchdog ); m_Watchdog = nullptr; if( m_ToReload.size() ) { file_watched_t* file = m_ToReload.front(); while( file ) { m_ToReload.pop(); SAFE_DELETE( file ) if( !m_ToReload.size() ) break; file = m_ToReload.front(); } file = nullptr; }
void ipc_pipe_server_free(ipc_pipe_server_t *pipe) { if (!pipe) return; if (pipe->thread) { CancelIoEx(pipe->handle, &pipe->overlap); SetEvent(pipe->ready_event); WaitForSingleObject(pipe->thread, INFINITE); CloseHandle(pipe->thread); } if (pipe->ready_event) CloseHandle(pipe->ready_event); if (pipe->handle) CloseHandle(pipe->handle); free(pipe->read_data); memset(pipe, 0, sizeof(*pipe)); }
void Server::Destroy() { m_ShuttingDown = true; if (m_AcceptTPWORK != NULL) { WaitForThreadpoolWorkCallbacks(m_AcceptTPWORK, true); CloseThreadpoolWork(m_AcceptTPWORK); m_AcceptTPWORK = NULL; } if (m_listenSocket != INVALID_SOCKET) { Network::CloseSocket(m_listenSocket); CancelIoEx(reinterpret_cast<HANDLE>(m_listenSocket), NULL); m_listenSocket = INVALID_SOCKET; } if (m_pTPIO != NULL) { WaitForThreadpoolIoCallbacks(m_pTPIO, true); CloseThreadpoolIo(m_pTPIO); m_pTPIO = NULL; } if (m_ClientTPCLEAN != NULL) { CloseThreadpoolCleanupGroupMembers(m_ClientTPCLEAN, false, NULL); CloseThreadpoolCleanupGroup(m_ClientTPCLEAN); DestroyThreadpoolEnvironment(&m_ClientTPENV); m_ClientTPCLEAN = NULL; } EnterCriticalSection(&m_CSForClients); for (auto client : m_Clients) { delete client; } m_Clients.clear(); LeaveCriticalSection(&m_CSForClients); DeleteCriticalSection(&m_CSForClients); }
void Socket::CloseSocket() { if (m_s != INVALID_SOCKET) { #ifdef USE_WINDOWS_STYLE_SOCKETS # if defined(USE_WINDOWS8_API) BOOL result = CancelIoEx((HANDLE) m_s, NULL); assert(result || (!result && GetLastError() == ERROR_NOT_FOUND)); CheckAndHandleError_int("closesocket", closesocket(m_s)); # else BOOL result = CancelIo((HANDLE) m_s); assert(result || (!result && GetLastError() == ERROR_NOT_FOUND)); CheckAndHandleError_int("closesocket", closesocket(m_s)); # endif #else CheckAndHandleError_int("close", close(m_s)); #endif m_s = INVALID_SOCKET; SocketChanged(); } }
void CEXIETHERNET::Deactivate() { if (!IsActivated()) return; // Signal read thread to exit. readEnabled.Clear(); readThreadShutdown.Set(); // Cancel any outstanding requests from both this thread (writes), and the read thread. CancelIoEx(mHAdapter, nullptr); // Wait for read thread to exit. if (readThread.joinable()) readThread.join(); // Clean-up handles CloseHandle(mReadOverlapped.hEvent); CloseHandle(mWriteOverlapped.hEvent); CloseHandle(mHAdapter); mHAdapter = INVALID_HANDLE_VALUE; memset(&mReadOverlapped, 0, sizeof(mReadOverlapped)); memset(&mWriteOverlapped, 0, sizeof(mWriteOverlapped)); }
TcpConnection TcpListener::accept() { assert(dispatcher != nullptr); assert(context == nullptr); if (dispatcher->interrupted()) { throw InterruptedException(); } std::string message; SOCKET connection = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (connection == INVALID_SOCKET) { message = "socket failed, " + errorMessage(WSAGetLastError()); } else { uint8_t addresses[sizeof sockaddr_in * 2 + 32]; DWORD received; TcpListenerContext context2; context2.hEvent = NULL; if (acceptEx(listener, connection, addresses, 0, sizeof(sockaddr_in) + 16, sizeof(sockaddr_in) + 16, &received, &context2) == TRUE) { message = "AcceptEx returned immediately, which is not supported."; } else { int lastError = WSAGetLastError(); if (lastError != WSA_IO_PENDING) { message = "AcceptEx failed, " + errorMessage(lastError); } else { context2.context = dispatcher->getCurrentContext(); context2.interrupted = false; context = &context2; dispatcher->getCurrentContext()->interruptProcedure = [&]() { assert(dispatcher != nullptr); assert(context != nullptr); TcpListenerContext* context2 = static_cast<TcpListenerContext*>(context); if (!context2->interrupted) { if (CancelIoEx(reinterpret_cast<HANDLE>(listener), context2) != TRUE) { DWORD lastError = GetLastError(); if (lastError != ERROR_NOT_FOUND) { throw std::runtime_error("TcpListener::stop, CancelIoEx failed, " + lastErrorMessage()); } context2->context->interrupted = true; } context2->interrupted = true; } }; dispatcher->dispatch(); dispatcher->getCurrentContext()->interruptProcedure = nullptr; assert(context2.context == dispatcher->getCurrentContext()); assert(dispatcher != nullptr); assert(context == &context2); context = nullptr; DWORD transferred; DWORD flags; if (WSAGetOverlappedResult(listener, &context2, &transferred, FALSE, &flags) != TRUE) { lastError = WSAGetLastError(); if (lastError != ERROR_OPERATION_ABORTED) { message = "AcceptEx failed, " + errorMessage(lastError); } else { assert(context2.interrupted); if (closesocket(connection) != 0) { throw std::runtime_error("TcpListener::accept, closesocket failed, " + errorMessage(WSAGetLastError())); } else { throw InterruptedException(); } } } else { assert(transferred == 0); assert(flags == 0); if (setsockopt(connection, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, reinterpret_cast<char*>(&listener), sizeof listener) != 0) { message = "setsockopt failed, " + errorMessage(WSAGetLastError()); } else { if (CreateIoCompletionPort(reinterpret_cast<HANDLE>(connection), dispatcher->getCompletionPort(), 0, 0) != dispatcher->getCompletionPort()) { message = "CreateIoCompletionPort failed, " + lastErrorMessage(); } else { return TcpConnection(*dispatcher, connection); } } } } } int result = closesocket(connection); assert(result == 0); } throw std::runtime_error("TcpListener::accept, " + message); }
VOID UserScanSynchronizedCancel ( _In_ PUSER_SCAN_CONTEXT Context ) /*++ Routine Description: This routine tries to abort all the scanning threads and wait for them to terminate. Arguments: Context - User scan context, please see userscan.h Return Value: Please consult WaitForMultipleObjects(...) --*/ { ULONG i; PSCANNER_THREAD_CONTEXT scanThreadCtxes = Context->ScanThreadCtxes; if (NULL == scanThreadCtxes) { fprintf(stderr, "Scan thread contexes are NOT suppoed to be NULL.\n"); return; } // // Tell all scanning threads that the program is going to exit. // Context->Finalized = TRUE; // // Signal cancellation events for all scanning threads. // for (i = 0; i < USER_SCAN_THREAD_COUNT; i ++ ) { scanThreadCtxes[i].Aborted = TRUE; } // // Wake up the listening thread if it is waiting for message // via GetQueuedCompletionStatus() // CancelIoEx(Context->ConnectionPort, NULL); // // Wait for all scan threads to complete cancellation, // so we will be able to close the connection port and etc. // WaitForAll(scanThreadCtxes); return; }
void ImageMaker::stop() { CancelIoEx(m_driveHandle, nullptr); m_shouldHalt.signal(); }
virtual ~FileSystemWatcherPC() { CancelIoEx(m_handle, nullptr); CloseHandle(m_handle); }