static PyObject * overlapped_cancel(OverlappedObject *self) { BOOL res = TRUE; if (self->pending) { Py_BEGIN_ALLOW_THREADS if (check_CancelIoEx()) res = Py_CancelIoEx(self->handle, &self->overlapped); else res = CancelIo(self->handle); Py_END_ALLOW_THREADS }
static PyObject * _winapi_Overlapped_cancel_impl(OverlappedObject *self) /*[clinic end generated code: output=fcb9ab5df4ebdae5 input=cbf3da142290039f]*/ { BOOL res = TRUE; if (self->pending) { Py_BEGIN_ALLOW_THREADS if (check_CancelIoEx()) res = Py_CancelIoEx(self->handle, &self->overlapped); else res = CancelIo(self->handle); Py_END_ALLOW_THREADS }
static void Overlapped_dealloc(OverlappedObject *self) { DWORD bytes; DWORD olderr = GetLastError(); BOOL wait = FALSE; BOOL ret; if (!HasOverlappedIoCompleted(&self->overlapped) && self->type != TYPE_NOT_STARTED) { if (Py_CancelIoEx && Py_CancelIoEx(self->handle, &self->overlapped)) wait = TRUE; Py_BEGIN_ALLOW_THREADS ret = GetOverlappedResult(self->handle, &self->overlapped, &bytes, wait); Py_END_ALLOW_THREADS switch (ret ? ERROR_SUCCESS : GetLastError()) { case ERROR_SUCCESS: case ERROR_NOT_FOUND: case ERROR_OPERATION_ABORTED: break; default: PyErr_Format( PyExc_RuntimeError, "%R still has pending operation at " "deallocation, the process may crash", self); PyErr_WriteUnraisable(NULL); } } if (self->overlapped.hEvent != NULL) CloseHandle(self->overlapped.hEvent); switch (self->type) { case TYPE_READ: case TYPE_ACCEPT: Py_CLEAR(self->allocated_buffer); break; case TYPE_WRITE: case TYPE_READINTO: if (self->user_buffer.obj) PyBuffer_Release(&self->user_buffer); break; } PyObject_Del(self); SetLastError(olderr); }
static PyObject * Overlapped_cancel(OverlappedObject *self) { BOOL ret = TRUE; if (self->type == TYPE_NOT_STARTED || self->type == TYPE_WAIT_NAMED_PIPE_AND_CONNECT) Py_RETURN_NONE; if (!HasOverlappedIoCompleted(&self->overlapped)) { Py_BEGIN_ALLOW_THREADS if (Py_CancelIoEx) ret = Py_CancelIoEx(self->handle, &self->overlapped); else ret = CancelIo(self->handle); Py_END_ALLOW_THREADS }
static void overlapped_dealloc(OverlappedObject *self) { DWORD bytes; int err = GetLastError(); if (self->pending) { if (check_CancelIoEx() && Py_CancelIoEx(self->handle, &self->overlapped) && GetOverlappedResult(self->handle, &self->overlapped, &bytes, TRUE)) { /* The operation is no longer pending -- nothing to do. */ } else if (_Py_Finalizing == NULL) { /* The operation is still pending -- give a warning. This will probably only happen on Windows XP. */ PyErr_SetString(PyExc_RuntimeError, "I/O operations still in flight while destroying " "Overlapped object, the process may crash"); PyErr_WriteUnraisable(NULL); } else { /* The operation is still pending, but the process is probably about to exit, so we need not worry too much about memory leaks. Leaking self prevents a potential crash. This can happen when a daemon thread is cleaned up at exit -- see #19565. We only expect to get here on Windows XP. */ CloseHandle(self->overlapped.hEvent); SetLastError(err); return; } } CloseHandle(self->overlapped.hEvent); SetLastError(err); if (self->write_buffer.obj) PyBuffer_Release(&self->write_buffer); Py_CLEAR(self->read_buffer); PyObject_Del(self); }
static void overlapped_dealloc(OverlappedObject *self) { DWORD bytes; int err = GetLastError(); if (self->pending) { /* make it a programming error to deallocate while operation is pending, even if we can safely cancel it */ if (check_CancelIoEx() && Py_CancelIoEx(self->handle, &self->overlapped)) GetOverlappedResult(self->handle, &self->overlapped, &bytes, TRUE); PyErr_SetString(PyExc_RuntimeError, "I/O operations still in flight while destroying " "Overlapped object, the process may crash"); PyErr_WriteUnraisable(NULL); } CloseHandle(self->overlapped.hEvent); SetLastError(err); if (self->write_buffer.obj) PyBuffer_Release(&self->write_buffer); Py_CLEAR(self->read_buffer); PyObject_Del(self); }