PyObject * _PyMp_SetError(PyObject *Type, int num) { switch (num) { #ifdef MS_WINDOWS case MP_STANDARD_ERROR: if (Type == NULL) Type = PyExc_OSError; PyErr_SetExcFromWindowsErr(Type, 0); break; case MP_SOCKET_ERROR: if (Type == NULL) Type = PyExc_OSError; PyErr_SetExcFromWindowsErr(Type, WSAGetLastError()); break; #else /* !MS_WINDOWS */ case MP_STANDARD_ERROR: case MP_SOCKET_ERROR: if (Type == NULL) Type = PyExc_OSError; PyErr_SetFromErrno(Type); break; #endif /* !MS_WINDOWS */ case MP_MEMORY_ERROR: PyErr_NoMemory(); break; case MP_EXCEPTION_HAS_BEEN_SET: break; default: PyErr_Format(PyExc_RuntimeError, "unknown error number %d", num); } return NULL; }
static PyObject * Billiard_recv(PyObject *self, PyObject *args) { HANDLE handle; int size, nread; PyObject *buf; if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size)) return NULL; buf = PyBytes_FromStringAndSize(NULL, size); if (!buf) return NULL; Py_BEGIN_ALLOW_THREADS nread = recv((SOCKET) handle, PyBytes_AS_STRING(buf), size, 0); Py_END_ALLOW_THREADS if (nread < 0) { Py_DECREF(buf); return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError()); } _PyBytes_Resize(&buf, nread); return buf; }
static PyObject * _winapi_Overlapped_GetOverlappedResult_impl(OverlappedObject *self, int wait) /*[clinic end generated code: output=bdd0c1ed6518cd03 input=194505ee8e0e3565]*/ { BOOL res; DWORD transferred = 0; DWORD err; Py_BEGIN_ALLOW_THREADS res = GetOverlappedResult(self->handle, &self->overlapped, &transferred, wait != 0); Py_END_ALLOW_THREADS err = res ? ERROR_SUCCESS : GetLastError(); switch (err) { case ERROR_SUCCESS: case ERROR_MORE_DATA: case ERROR_OPERATION_ABORTED: self->completed = 1; self->pending = 0; break; case ERROR_IO_INCOMPLETE: break; default: self->pending = 0; return PyErr_SetExcFromWindowsErr(PyExc_IOError, err); } if (self->completed && self->read_buffer != NULL) { assert(PyBytes_CheckExact(self->read_buffer)); if (transferred != PyBytes_GET_SIZE(self->read_buffer) && _PyBytes_Resize(&self->read_buffer, transferred)) return NULL; } return Py_BuildValue("II", (unsigned) transferred, (unsigned) err); }
PyObject * Billiard_SetError(PyObject *Type, int num) { switch (num) { case MP_SUCCESS: break; #ifdef MS_WINDOWS case MP_STANDARD_ERROR: if (Type == NULL) Type = PyExc_WindowsError; PyErr_SetExcFromWindowsErr(Type, 0); break; case MP_SOCKET_ERROR: if (Type == NULL) Type = PyExc_WindowsError; PyErr_SetExcFromWindowsErr(Type, WSAGetLastError()); break; #else /* !MS_WINDOWS */ case MP_STANDARD_ERROR: case MP_SOCKET_ERROR: if (Type == NULL) Type = PyExc_OSError; PyErr_SetFromErrno(Type); break; #endif /* !MS_WINDOWS */ case MP_MEMORY_ERROR: PyErr_NoMemory(); break; case MP_END_OF_FILE: PyErr_SetNone(PyExc_EOFError); break; case MP_EARLY_END_OF_FILE: PyErr_SetString(PyExc_IOError, "got end of file during message"); break; case MP_BAD_MESSAGE_LENGTH: PyErr_SetString(PyExc_IOError, "bad message length"); break; case MP_EXCEPTION_HAS_BEEN_SET: break; default: PyErr_Format(PyExc_RuntimeError, "unkown error number %d", num); } return NULL; }
static PyObject * Billiard_closesocket(PyObject *self, PyObject *args) { HANDLE handle; int ret; if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle)) return NULL; Py_BEGIN_ALLOW_THREADS ret = closesocket((SOCKET) handle); Py_END_ALLOW_THREADS if (ret) return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError()); Py_RETURN_NONE; }
//----------------------------------------------------------------------------- // ExtGetWindowsDir() // Return the Windows directory (C:\Windows for example). //----------------------------------------------------------------------------- static PyObject *ExtGetWindowsDir( PyObject *self, // passthrough argument PyObject *args) // arguments (ignored) { #if PY_MAJOR_VERSION >= 3 OLECHAR dir[MAX_PATH + 1]; if (GetWindowsDirectoryW(dir, sizeof(dir))) return PyUnicode_FromUnicode(dir, wcslen(dir)); #else char dir[MAX_PATH + 1]; if (GetWindowsDirectory(dir, sizeof(dir))) return PyString_FromString(dir); #endif PyErr_SetExcFromWindowsErr(PyExc_RuntimeError, GetLastError()); return NULL; }
//----------------------------------------------------------------------------- // ExtEndUpdateResource() // Wrapper for EndUpdateResource(). //----------------------------------------------------------------------------- static PyObject *ExtEndUpdateResource( PyObject *self, // passthrough argument PyObject *args) // arguments { BOOL discardChanges; HANDLE handle; discardChanges = FALSE; if (!PyArg_ParseTuple(args, "i|i", &handle, &discardChanges)) return NULL; if (!EndUpdateResource(handle, discardChanges)) { PyErr_SetExcFromWindowsErr(PyExc_WindowsError, GetLastError()); return NULL; } Py_INCREF(Py_None); return Py_None; }
static PyObject * SetFromWindowsErr(DWORD err) { PyObject *exception_type; if (err == 0) err = GetLastError(); switch (err) { case ERROR_CONNECTION_REFUSED: exception_type = PyExc_ConnectionRefusedError; break; case ERROR_CONNECTION_ABORTED: exception_type = PyExc_ConnectionAbortedError; break; default: exception_type = PyExc_OSError; } return PyErr_SetExcFromWindowsErr(exception_type, err); }
static PyObject * Billiard_send(PyObject *self, PyObject *args) { HANDLE handle; Py_buffer buf; int ret, length; if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf)) return NULL; length = (int)Py_MIN(buf.len, INT_MAX); Py_BEGIN_ALLOW_THREADS ret = send((SOCKET) handle, buf.buf, length, 0); Py_END_ALLOW_THREADS PyBuffer_Release(&buf); if (ret < 0) return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError()); return PyLong_FromLong(ret); }
//----------------------------------------------------------------------------- // ExtUpdateResource() // Wrapper for UpdateResource(). //----------------------------------------------------------------------------- static PyObject *ExtUpdateResource( PyObject *self, // passthrough argument PyObject *args) // arguments { int resourceType, resourceId, resourceDataSize; char *resourceData; HANDLE handle; if (!PyArg_ParseTuple(args, "iiis#", &handle, &resourceType, &resourceId, &resourceData, &resourceDataSize)) return NULL; if (!UpdateResource(handle, MAKEINTRESOURCE(resourceType), MAKEINTRESOURCE(resourceId), MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), resourceData, resourceDataSize)) { PyErr_SetExcFromWindowsErr(PyExc_WindowsError, GetLastError()); return NULL; } Py_INCREF(Py_None); return Py_None; }
static PyObject * overlapped_GetOverlappedResult(OverlappedObject *self, PyObject *waitobj) { int wait; BOOL res; DWORD transferred = 0; DWORD err; wait = PyObject_IsTrue(waitobj); if (wait < 0) return NULL; Py_BEGIN_ALLOW_THREADS res = GetOverlappedResult(self->handle, &self->overlapped, &transferred, wait != 0); Py_END_ALLOW_THREADS err = res ? ERROR_SUCCESS : GetLastError(); switch (err) { case ERROR_SUCCESS: case ERROR_MORE_DATA: case ERROR_OPERATION_ABORTED: self->completed = 1; self->pending = 0; break; case ERROR_IO_INCOMPLETE: break; default: self->pending = 0; return PyErr_SetExcFromWindowsErr(PyExc_IOError, err); } if (self->completed && self->read_buffer != NULL) { assert(PyBytes_CheckExact(self->read_buffer)); if (transferred != PyBytes_GET_SIZE(self->read_buffer) && _PyBytes_Resize(&self->read_buffer, transferred)) return NULL; } return Py_BuildValue("II", (unsigned) transferred, (unsigned) err); }
static PyObject * select_select(PyObject *self, PyObject *args) { #ifdef SELECT_USES_HEAP pylist *rfd2obj, *wfd2obj, *efd2obj; #else /* !SELECT_USES_HEAP */ /* XXX: All this should probably be implemented as follows: * - find the highest descriptor we're interested in * - add one * - that's the size * See: Stevens, APitUE, $12.5.1 */ pylist rfd2obj[FD_SETSIZE + 1]; pylist wfd2obj[FD_SETSIZE + 1]; pylist efd2obj[FD_SETSIZE + 1]; #endif /* SELECT_USES_HEAP */ PyObject *ifdlist, *ofdlist, *efdlist; PyObject *ret = NULL; PyObject *tout = Py_None; fd_set ifdset, ofdset, efdset; double timeout; struct timeval tv, *tvp; long seconds; int imax, omax, emax, max; int n; /* convert arguments */ if (!PyArg_ParseTuple(args, "OOO|O:select", &ifdlist, &ofdlist, &efdlist, &tout)) return NULL; if (tout == Py_None) tvp = (struct timeval *)0; else if (!PyNumber_Check(tout)) { PyErr_SetString(PyExc_TypeError, "timeout must be a float or None"); return NULL; } else { timeout = PyFloat_AsDouble(tout); if (timeout == -1 && PyErr_Occurred()) return NULL; if (timeout > (double)LONG_MAX) { PyErr_SetString(PyExc_OverflowError, "timeout period too long"); return NULL; } seconds = (long)timeout; timeout = timeout - (double)seconds; tv.tv_sec = seconds; tv.tv_usec = (long)(timeout*1000000.0); tvp = &tv; } #ifdef SELECT_USES_HEAP /* Allocate memory for the lists */ rfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1); wfd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1); efd2obj = PyMem_NEW(pylist, FD_SETSIZE + 1); if (rfd2obj == NULL || wfd2obj == NULL || efd2obj == NULL) { if (rfd2obj) PyMem_DEL(rfd2obj); if (wfd2obj) PyMem_DEL(wfd2obj); if (efd2obj) PyMem_DEL(efd2obj); return PyErr_NoMemory(); } #endif /* SELECT_USES_HEAP */ /* Convert sequences to fd_sets, and get maximum fd number * propagates the Python exception set in seq2set() */ rfd2obj[0].sentinel = -1; wfd2obj[0].sentinel = -1; efd2obj[0].sentinel = -1; if ((imax=seq2set(ifdlist, &ifdset, rfd2obj)) < 0) goto finally; if ((omax=seq2set(ofdlist, &ofdset, wfd2obj)) < 0) goto finally; if ((emax=seq2set(efdlist, &efdset, efd2obj)) < 0) goto finally; max = imax; if (omax > max) max = omax; if (emax > max) max = emax; Py_BEGIN_ALLOW_THREADS n = select(max, &ifdset, &ofdset, &efdset, tvp); Py_END_ALLOW_THREADS #ifdef MS_WINDOWS if (n == SOCKET_ERROR) { PyErr_SetExcFromWindowsErr(SelectError, WSAGetLastError()); } #else if (n < 0) { PyErr_SetFromErrno(SelectError); } #endif else if (n == 0) { /* optimization */ ifdlist = PyList_New(0); if (ifdlist) { ret = PyTuple_Pack(3, ifdlist, ifdlist, ifdlist); Py_DECREF(ifdlist); } } else { /* any of these three calls can raise an exception. it's more convenient to test for this after all three calls... but is that acceptable? */ ifdlist = set2list(&ifdset, rfd2obj); ofdlist = set2list(&ofdset, wfd2obj); efdlist = set2list(&efdset, efd2obj); if (PyErr_Occurred()) ret = NULL; else ret = PyTuple_Pack(3, ifdlist, ofdlist, efdlist); Py_DECREF(ifdlist); Py_DECREF(ofdlist); Py_DECREF(efdlist); } finally: reap_obj(rfd2obj); reap_obj(wfd2obj); reap_obj(efd2obj); #ifdef SELECT_USES_HEAP PyMem_DEL(rfd2obj); PyMem_DEL(wfd2obj); PyMem_DEL(efd2obj); #endif /* SELECT_USES_HEAP */ return ret; }