Lines Matching defs:self
634 OverlappedObject *self;
642 self = PyObject_New(OverlappedObject, type);
643 if (self == NULL) {
649 self->handle = NULL;
650 self->error = 0;
651 self->type = TYPE_NONE;
652 self->allocated_buffer = NULL;
653 memset(&self->overlapped, 0, sizeof(OVERLAPPED));
654 memset(&self->user_buffer, 0, sizeof(Py_buffer));
656 self->overlapped.hEvent = event;
657 return (PyObject *)self;
664 Overlapped_clear(OverlappedObject *self)
666 switch (self->type) {
669 Py_CLEAR(self->allocated_buffer);
676 if(self->read_from.result) {
678 Py_CLEAR(self->read_from.result);
680 if(self->read_from.allocated_buffer) {
681 Py_CLEAR(self->read_from.allocated_buffer);
686 if (self->read_from_into.result) {
688 Py_CLEAR(self->read_from_into.result);
690 if (self->read_from_into.user_buffer.obj) {
691 PyBuffer_Release(&self->read_from_into.user_buffer);
698 if (self->user_buffer.obj) {
699 PyBuffer_Release(&self->user_buffer);
704 self->type = TYPE_NOT_STARTED;
709 Overlapped_dealloc(OverlappedObject *self)
716 if (!HasOverlappedIoCompleted(&self->overlapped) &&
717 self->type != TYPE_NOT_STARTED)
720 if (CancelIoEx(self->handle, &self->overlapped))
723 ret = GetOverlappedResult(self->handle, &self->overlapped,
736 "deallocation, the process may crash", self);
741 if (self->overlapped.hEvent != NULL) {
742 CloseHandle(self->overlapped.hEvent);
745 Overlapped_clear(self);
748 PyTypeObject *tp = Py_TYPE(self);
749 PyObject_Free(self);
824 _overlapped_Overlapped_cancel_impl(OverlappedObject *self)
829 if (self->type == TYPE_NOT_STARTED
830 || self->type == TYPE_WAIT_NAMED_PIPE_AND_CONNECT)
833 if (!HasOverlappedIoCompleted(&self->overlapped)) {
835 ret = CancelIoEx(self->handle, &self->overlapped);
858 _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
866 if (self->type == TYPE_NONE) {
871 if (self->type == TYPE_NOT_STARTED) {
877 ret = GetOverlappedResult(self->handle, &self->overlapped, &transferred,
881 self->error = err = ret ? ERROR_SUCCESS : GetLastError();
887 if (self->type == TYPE_READ || self->type == TYPE_READINTO) {
890 else if (self->type == TYPE_READ_FROM &&
891 (self->read_from.result != NULL ||
892 self->read_from.allocated_buffer != NULL))
896 else if (self->type == TYPE_READ_FROM_INTO &&
897 self->read_from_into.result != NULL)
906 switch (self->type) {
908 assert(PyBytes_CheckExact(self->allocated_buffer));
909 if (transferred != PyBytes_GET_SIZE(self->allocated_buffer) &&
910 _PyBytes_Resize(&self->allocated_buffer, transferred))
913 Py_INCREF(self->allocated_buffer);
914 return self->allocated_buffer;
916 assert(PyBytes_CheckExact(self->read_from.allocated_buffer));
919 self->read_from.allocated_buffer) &&
920 _PyBytes_Resize(&self->read_from.allocated_buffer, transferred))
926 addr = unparse_address((SOCKADDR*)&self->read_from.address,
927 self->read_from.address_length);
934 self->read_from.result = PyTuple_New(2);
935 if (self->read_from.result == NULL) {
941 Py_INCREF(self->read_from.allocated_buffer);
942 PyTuple_SET_ITEM(self->read_from.result, 0,
943 self->read_from.allocated_buffer);
945 PyTuple_SET_ITEM(self->read_from.result, 1, addr);
947 Py_INCREF(self->read_from.result);
948 return self->read_from.result;
951 addr = unparse_address((SOCKADDR*)&self->read_from_into.address,
952 self->read_from_into.address_length);
959 self->read_from_into.result = PyTuple_New(2);
960 if (self->read_from_into.result == NULL) {
966 PyTuple_SET_ITEM(self->read_from_into.result, 0,
969 PyTuple_SET_ITEM(self->read_from_into.result, 1, addr);
971 Py_INCREF(self->read_from_into.result);
972 return self->read_from_into.result;
979 do_ReadFile(OverlappedObject *self, HANDLE handle,
988 &self->overlapped);
991 self->error = err = ret ? ERROR_SUCCESS : GetLastError();
994 mark_as_completed(&self->overlapped);
1001 Overlapped_clear(self);
1017 _overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
1023 if (self->type != TYPE_NONE) {
1035 self->type = TYPE_READ;
1036 self->handle = handle;
1037 self->allocated_buffer = buf;
1039 return do_ReadFile(self, handle, PyBytes_AS_STRING(buf), size);
1053 _overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
1057 if (self->type != TYPE_NONE) {
1068 steal_buffer(&self->user_buffer, bufobj);
1070 self->type = TYPE_READINTO;
1071 self->handle = handle;
1073 return do_ReadFile(self, handle, self->user_buffer.buf,
1074 (DWORD)self->user_buffer.len);
1078 do_WSARecv(OverlappedObject *self, HANDLE handle,
1091 &self->overlapped, NULL);
1094 self->error = err = (ret < 0 ? WSAGetLastError() : ERROR_SUCCESS);
1097 mark_as_completed(&self->overlapped);
1104 Overlapped_clear(self);
1122 _overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
1128 if (self->type != TYPE_NONE) {
1140 self->type = TYPE_READ;
1141 self->handle = handle;
1142 self->allocated_buffer = buf;
1144 return do_WSARecv(self, handle, PyBytes_AS_STRING(buf), size, flags);
1159 _overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
1164 if (self->type != TYPE_NONE) {
1175 steal_buffer(&self->user_buffer, bufobj);
1177 self->type = TYPE_READINTO;
1178 self->handle = handle;
1180 return do_WSARecv(self, handle, self->user_buffer.buf,
1181 (DWORD)self->user_buffer.len, flags);
1195 _overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
1203 if (self->type != TYPE_NONE) {
1214 steal_buffer(&self->user_buffer, bufobj);
1216 self->type = TYPE_WRITE;
1217 self->handle = handle;
1220 ret = WriteFile(handle, self->user_buffer.buf,
1221 (DWORD)self->user_buffer.len,
1222 &written, &self->overlapped);
1225 self->error = err = ret ? ERROR_SUCCESS : GetLastError();
1231 Overlapped_clear(self);
1248 _overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
1257 if (self->type != TYPE_NONE) {
1268 steal_buffer(&self->user_buffer, bufobj);
1270 self->type = TYPE_WRITE;
1271 self->handle = handle;
1272 wsabuf.len = (DWORD)self->user_buffer.len;
1273 wsabuf.buf = self->user_buffer.buf;
1277 &self->overlapped, NULL);
1280 self->error = err = (ret < 0 ? WSAGetLastError() : ERROR_SUCCESS);
1286 Overlapped_clear(self);
1302 _overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
1313 if (self->type != TYPE_NONE) {
1323 self->type = TYPE_ACCEPT;
1324 self->handle = ListenSocket;
1325 self->allocated_buffer = buf;
1330 &self->overlapped);
1333 self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
1339 Overlapped_clear(self);
1431 _overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
1442 if (self->type != TYPE_NONE) {
1452 self->type = TYPE_CONNECT;
1453 self->handle = ConnectSocket;
1457 NULL, 0, NULL, &self->overlapped);
1460 self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
1466 Overlapped_clear(self);
1481 _overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
1488 if (self->type != TYPE_NONE) {
1493 self->type = TYPE_DISCONNECT;
1494 self->handle = Socket;
1497 ret = Py_DisconnectEx((SOCKET)Socket, &self->overlapped, flags, 0);
1500 self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
1506 Overlapped_clear(self);
1527 _overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
1537 if (self->type != TYPE_NONE) {
1542 self->type = TYPE_TRANSMIT_FILE;
1543 self->handle = Socket;
1544 self->overlapped.Offset = offset;
1545 self->overlapped.OffsetHigh = offset_high;
1549 count_per_send, &self->overlapped, NULL, flags);
1552 self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
1558 Overlapped_clear(self);
1573 _overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
1580 if (self->type != TYPE_NONE) {
1585 self->type = TYPE_CONNECT_NAMED_PIPE;
1586 self->handle = Pipe;
1589 ret = ConnectNamedPipe(Pipe, &self->overlapped);
1592 self->error = err = ret ? ERROR_SUCCESS : GetLastError();
1595 mark_as_completed(&self->overlapped);
1601 Overlapped_clear(self);
1616 _overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
1635 Overlapped_getaddress(OverlappedObject *self)
1637 return PyLong_FromVoidPtr(&self->overlapped);
1641 Overlapped_getpending(OverlappedObject *self)
1643 return PyBool_FromLong(!HasOverlappedIoCompleted(&self->overlapped) &&
1644 self->type != TYPE_NOT_STARTED);
1648 Overlapped_traverse(OverlappedObject *self, visitproc visit, void *arg)
1650 switch (self->type) {
1653 Py_VISIT(self->allocated_buffer);
1658 if (self->user_buffer.obj) {
1659 Py_VISIT(&self->user_buffer.obj);
1663 Py_VISIT(self->read_from.result);
1664 Py_VISIT(self->read_from.allocated_buffer);
1667 Py_VISIT(self->read_from_into.result);
1668 if (self->read_from_into.user_buffer.obj) {
1669 Py_VISIT(&self->read_from_into.user_buffer.obj);
1737 _overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
1757 if (self->type != TYPE_NONE) {
1768 steal_buffer(&self->user_buffer, bufobj);
1770 self->type = TYPE_WRITE_TO;
1771 self->handle = handle;
1772 wsabuf.len = (DWORD)self->user_buffer.len;
1773 wsabuf.buf = self->user_buffer.buf;
1777 Address, AddressLength, &self->overlapped, NULL);
1780 self->error = err = (ret == SOCKET_ERROR ? WSAGetLastError() :
1788 self->type = TYPE_NOT_STARTED;
1812 _overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
1823 if (self->type != TYPE_NONE) {
1839 self->type = TYPE_READ_FROM;
1840 self->handle = handle;
1841 self->read_from.allocated_buffer = buf;
1842 memset(&self->read_from.address, 0, sizeof(self->read_from.address));
1843 self->read_from.address_length = sizeof(self->read_from.address);
1847 (SOCKADDR*)&self->read_from.address,
1848 &self->read_from.address_length,
1849 &self->overlapped, NULL);
1852 self->error = err = (ret < 0 ? WSAGetLastError() : ERROR_SUCCESS);
1855 mark_as_completed(&self->overlapped);
1862 self->type = TYPE_NOT_STARTED;
1881 _overlapped_Overlapped_WSARecvFromInto_impl(OverlappedObject *self,
1891 if (self->type != TYPE_NONE) {
1906 self->type = TYPE_READ_FROM_INTO;
1907 self->handle = handle;
1908 steal_buffer(&self->read_from_into.user_buffer, bufobj);
1909 memset(&self->read_from_into.address, 0, sizeof(self->read_from_into.address));
1910 self->read_from_into.address_length = sizeof(self->read_from_into.address);
1914 (SOCKADDR*)&self->read_from_into.address,
1915 &self->read_from_into.address_length,
1916 &self->overlapped, NULL);
1919 self->error = err = (ret < 0 ? WSAGetLastError() : ERROR_SUCCESS);
1922 mark_as_completed(&self->overlapped);
1929 self->type = TYPE_NOT_STARTED;