Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

gh-94512: Fix forced arg format in AC-processed overlapped (GH-94516)

This commit is contained in:
Oleg Iarygin 2022-07-29 01:09:46 +03:00 committed by GitHub
parent 38bb2068fe
commit 26d4af0ba5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 335 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

371
Modules/clinic/overlapped.c.h generated
View File

@ -26,8 +26,22 @@ _overlapped_CreateIoCompletionPort(PyObject *module, PyObject *const *args, Py_s
ULONG_PTR CompletionKey;
DWORD NumberOfConcurrentThreads;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_ULONG_PTR"k:CreateIoCompletionPort",
&FileHandle, &ExistingCompletionPort, &CompletionKey, &NumberOfConcurrentThreads)) {
if (!_PyArg_CheckPositional("CreateIoCompletionPort", nargs, 4, 4)) {
goto exit;
}
FileHandle = PyLong_AsVoidPtr(args[0]);
if (!FileHandle && PyErr_Occurred()) {
goto exit;
}
ExistingCompletionPort = PyLong_AsVoidPtr(args[1]);
if (!ExistingCompletionPort && PyErr_Occurred()) {
goto exit;
}
CompletionKey = PyLong_AsVoidPtr(args[2]);
if (!CompletionKey && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[3], &NumberOfConcurrentThreads)) {
goto exit;
}
return_value = _overlapped_CreateIoCompletionPort_impl(module, FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads);
@ -59,8 +73,14 @@ _overlapped_GetQueuedCompletionStatus(PyObject *module, PyObject *const *args, P
HANDLE CompletionPort;
DWORD Milliseconds;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:GetQueuedCompletionStatus",
&CompletionPort, &Milliseconds)) {
if (!_PyArg_CheckPositional("GetQueuedCompletionStatus", nargs, 2, 2)) {
goto exit;
}
CompletionPort = PyLong_AsVoidPtr(args[0]);
if (!CompletionPort && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[1], &Milliseconds)) {
goto exit;
}
return_value = _overlapped_GetQueuedCompletionStatus_impl(module, CompletionPort, Milliseconds);
@ -94,8 +114,22 @@ _overlapped_PostQueuedCompletionStatus(PyObject *module, PyObject *const *args,
ULONG_PTR CompletionKey;
OVERLAPPED *Overlapped;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k"F_ULONG_PTR""F_POINTER":PostQueuedCompletionStatus",
&CompletionPort, &NumberOfBytes, &CompletionKey, &Overlapped)) {
if (!_PyArg_CheckPositional("PostQueuedCompletionStatus", nargs, 4, 4)) {
goto exit;
}
CompletionPort = PyLong_AsVoidPtr(args[0]);
if (!CompletionPort && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[1], &NumberOfBytes)) {
goto exit;
}
CompletionKey = PyLong_AsVoidPtr(args[2]);
if (!CompletionKey && PyErr_Occurred()) {
goto exit;
}
Overlapped = PyLong_AsVoidPtr(args[3]);
if (!Overlapped && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_PostQueuedCompletionStatus_impl(module, CompletionPort, NumberOfBytes, CompletionKey, Overlapped);
@ -129,8 +163,22 @@ _overlapped_RegisterWaitWithQueue(PyObject *module, PyObject *const *args, Py_ss
OVERLAPPED *Overlapped;
DWORD Milliseconds;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_POINTER"k:RegisterWaitWithQueue",
&Object, &CompletionPort, &Overlapped, &Milliseconds)) {
if (!_PyArg_CheckPositional("RegisterWaitWithQueue", nargs, 4, 4)) {
goto exit;
}
Object = PyLong_AsVoidPtr(args[0]);
if (!Object && PyErr_Occurred()) {
goto exit;
}
CompletionPort = PyLong_AsVoidPtr(args[1]);
if (!CompletionPort && PyErr_Occurred()) {
goto exit;
}
Overlapped = PyLong_AsVoidPtr(args[2]);
if (!Overlapped && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[3], &Milliseconds)) {
goto exit;
}
return_value = _overlapped_RegisterWaitWithQueue_impl(module, Object, CompletionPort, Overlapped, Milliseconds);
@ -157,7 +205,8 @@ _overlapped_UnregisterWait(PyObject *module, PyObject *arg)
PyObject *return_value = NULL;
HANDLE WaitHandle;
if (!PyArg_Parse(arg, ""F_HANDLE":UnregisterWait", &WaitHandle)) {
WaitHandle = PyLong_AsVoidPtr(arg);
if (!WaitHandle && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_UnregisterWait_impl(module, WaitHandle);
@ -186,8 +235,15 @@ _overlapped_UnregisterWaitEx(PyObject *module, PyObject *const *args, Py_ssize_t
HANDLE WaitHandle;
HANDLE Event;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":UnregisterWaitEx",
&WaitHandle, &Event)) {
if (!_PyArg_CheckPositional("UnregisterWaitEx", nargs, 2, 2)) {
goto exit;
}
WaitHandle = PyLong_AsVoidPtr(args[0]);
if (!WaitHandle && PyErr_Occurred()) {
goto exit;
}
Event = PyLong_AsVoidPtr(args[1]);
if (!Event && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_UnregisterWaitEx_impl(module, WaitHandle, Event);
@ -222,8 +278,29 @@ _overlapped_CreateEvent(PyObject *module, PyObject *const *args, Py_ssize_t narg
BOOL InitialState;
const Py_UNICODE *Name;
if (!_PyArg_ParseStack(args, nargs, "OiiO&:CreateEvent",
&EventAttributes, &ManualReset, &InitialState, _PyUnicode_WideCharString_Opt_Converter, &Name)) {
if (!_PyArg_CheckPositional("CreateEvent", nargs, 4, 4)) {
goto exit;
}
EventAttributes = args[0];
ManualReset = _PyLong_AsInt(args[1]);
if (ManualReset == -1 && PyErr_Occurred()) {
goto exit;
}
InitialState = _PyLong_AsInt(args[2]);
if (InitialState == -1 && PyErr_Occurred()) {
goto exit;
}
if (args[3] == Py_None) {
Name = NULL;
}
else if (PyUnicode_Check(args[3])) {
Name = PyUnicode_AsWideCharString(args[3], NULL);
if (Name == NULL) {
goto exit;
}
}
else {
_PyArg_BadArgument("CreateEvent", "argument 4", "str or None", args[3]);
goto exit;
}
return_value = _overlapped_CreateEvent_impl(module, EventAttributes, ManualReset, InitialState, Name);
@ -253,7 +330,8 @@ _overlapped_SetEvent(PyObject *module, PyObject *arg)
PyObject *return_value = NULL;
HANDLE Handle;
if (!PyArg_Parse(arg, ""F_HANDLE":SetEvent", &Handle)) {
Handle = PyLong_AsVoidPtr(arg);
if (!Handle && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_SetEvent_impl(module, Handle);
@ -280,7 +358,8 @@ _overlapped_ResetEvent(PyObject *module, PyObject *arg)
PyObject *return_value = NULL;
HANDLE Handle;
if (!PyArg_Parse(arg, ""F_HANDLE":ResetEvent", &Handle)) {
Handle = PyLong_AsVoidPtr(arg);
if (!Handle && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_ResetEvent_impl(module, Handle);
@ -310,8 +389,15 @@ _overlapped_BindLocal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
HANDLE Socket;
int Family;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"i:BindLocal",
&Socket, &Family)) {
if (!_PyArg_CheckPositional("BindLocal", nargs, 2, 2)) {
goto exit;
}
Socket = PyLong_AsVoidPtr(args[0]);
if (!Socket && PyErr_Occurred()) {
goto exit;
}
Family = _PyLong_AsInt(args[1]);
if (Family == -1 && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_BindLocal_impl(module, Socket, Family);
@ -338,7 +424,7 @@ _overlapped_FormatMessage(PyObject *module, PyObject *arg)
PyObject *return_value = NULL;
DWORD code;
if (!PyArg_Parse(arg, "k:FormatMessage", &code)) {
if (!_PyLong_UnsignedLong_Converter(arg, &code)) {
goto exit;
}
return_value = _overlapped_FormatMessage_impl(module, code);
@ -361,13 +447,25 @@ _overlapped_Overlapped(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"event", NULL};
static _PyArg_Parser _parser = {"|"F_HANDLE":Overlapped", _keywords, 0};
static _PyArg_Parser _parser = {NULL, _keywords, "Overlapped", 0};
PyObject *argsbuf[1];
PyObject * const *fastargs;
Py_ssize_t nargs = PyTuple_GET_SIZE(args);
Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
HANDLE event = INVALID_HANDLE_VALUE;
if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
&event)) {
fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf);
if (!fastargs) {
goto exit;
}
if (!noptargs) {
goto skip_optional_pos;
}
event = PyLong_AsVoidPtr(fastargs[0]);
if (!event && PyErr_Occurred()) {
goto exit;
}
skip_optional_pos:
return_value = _overlapped_Overlapped_impl(type, event);
exit:
@ -413,10 +511,17 @@ _overlapped_Overlapped_getresult(OverlappedObject *self, PyObject *const *args,
PyObject *return_value = NULL;
BOOL wait = FALSE;
if (!_PyArg_ParseStack(args, nargs, "|i:getresult",
&wait)) {
if (!_PyArg_CheckPositional("getresult", nargs, 0, 1)) {
goto exit;
}
if (nargs < 1) {
goto skip_optional;
}
wait = _PyLong_AsInt(args[0]);
if (wait == -1 && PyErr_Occurred()) {
goto exit;
}
skip_optional:
return_value = _overlapped_Overlapped_getresult_impl(self, wait);
exit:
@ -443,8 +548,14 @@ _overlapped_Overlapped_ReadFile(OverlappedObject *self, PyObject *const *args, P
HANDLE handle;
DWORD size;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:ReadFile",
&handle, &size)) {
if (!_PyArg_CheckPositional("ReadFile", nargs, 2, 2)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
goto exit;
}
return_value = _overlapped_Overlapped_ReadFile_impl(self, handle, size);
@ -473,8 +584,18 @@ _overlapped_Overlapped_ReadFileInto(OverlappedObject *self, PyObject *const *arg
HANDLE handle;
Py_buffer bufobj = {NULL, NULL};
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*:ReadFileInto",
&handle, &bufobj)) {
if (!_PyArg_CheckPositional("ReadFileInto", nargs, 2, 2)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
goto exit;
}
if (!PyBuffer_IsContiguous(&bufobj, 'C')) {
_PyArg_BadArgument("ReadFileInto", "argument 2", "contiguous buffer", args[1]);
goto exit;
}
return_value = _overlapped_Overlapped_ReadFileInto_impl(self, handle, &bufobj);
@ -509,10 +630,23 @@ _overlapped_Overlapped_WSARecv(OverlappedObject *self, PyObject *const *args, Py
DWORD size;
DWORD flags = 0;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecv",
&handle, &size, &flags)) {
if (!_PyArg_CheckPositional("WSARecv", nargs, 2, 3)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
goto exit;
}
if (nargs < 3) {
goto skip_optional;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
goto exit;
}
skip_optional:
return_value = _overlapped_Overlapped_WSARecv_impl(self, handle, size, flags);
exit:
@ -541,8 +675,21 @@ _overlapped_Overlapped_WSARecvInto(OverlappedObject *self, PyObject *const *args
Py_buffer bufobj = {NULL, NULL};
DWORD flags;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*k:WSARecvInto",
&handle, &bufobj, &flags)) {
if (!_PyArg_CheckPositional("WSARecvInto", nargs, 3, 3)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
goto exit;
}
if (!PyBuffer_IsContiguous(&bufobj, 'C')) {
_PyArg_BadArgument("WSARecvInto", "argument 2", "contiguous buffer", args[1]);
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
goto exit;
}
return_value = _overlapped_Overlapped_WSARecvInto_impl(self, handle, &bufobj, flags);
@ -576,8 +723,18 @@ _overlapped_Overlapped_WriteFile(OverlappedObject *self, PyObject *const *args,
HANDLE handle;
Py_buffer bufobj = {NULL, NULL};
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*:WriteFile",
&handle, &bufobj)) {
if (!_PyArg_CheckPositional("WriteFile", nargs, 2, 2)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
goto exit;
}
if (!PyBuffer_IsContiguous(&bufobj, 'C')) {
_PyArg_BadArgument("WriteFile", "argument 2", "contiguous buffer", args[1]);
goto exit;
}
return_value = _overlapped_Overlapped_WriteFile_impl(self, handle, &bufobj);
@ -612,8 +769,21 @@ _overlapped_Overlapped_WSASend(OverlappedObject *self, PyObject *const *args, Py
Py_buffer bufobj = {NULL, NULL};
DWORD flags;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*k:WSASend",
&handle, &bufobj, &flags)) {
if (!_PyArg_CheckPositional("WSASend", nargs, 3, 3)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
goto exit;
}
if (!PyBuffer_IsContiguous(&bufobj, 'C')) {
_PyArg_BadArgument("WSASend", "argument 2", "contiguous buffer", args[1]);
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
goto exit;
}
return_value = _overlapped_Overlapped_WSASend_impl(self, handle, &bufobj, flags);
@ -648,8 +818,15 @@ _overlapped_Overlapped_AcceptEx(OverlappedObject *self, PyObject *const *args, P
HANDLE ListenSocket;
HANDLE AcceptSocket;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":AcceptEx",
&ListenSocket, &AcceptSocket)) {
if (!_PyArg_CheckPositional("AcceptEx", nargs, 2, 2)) {
goto exit;
}
ListenSocket = PyLong_AsVoidPtr(args[0]);
if (!ListenSocket && PyErr_Occurred()) {
goto exit;
}
AcceptSocket = PyLong_AsVoidPtr(args[1]);
if (!AcceptSocket && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_Overlapped_AcceptEx_impl(self, ListenSocket, AcceptSocket);
@ -681,10 +858,18 @@ _overlapped_Overlapped_ConnectEx(OverlappedObject *self, PyObject *const *args,
HANDLE ConnectSocket;
PyObject *AddressObj;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O!:ConnectEx",
&ConnectSocket, &PyTuple_Type, &AddressObj)) {
if (!_PyArg_CheckPositional("ConnectEx", nargs, 2, 2)) {
goto exit;
}
ConnectSocket = PyLong_AsVoidPtr(args[0]);
if (!ConnectSocket && PyErr_Occurred()) {
goto exit;
}
if (!PyTuple_Check(args[1])) {
_PyArg_BadArgument("ConnectEx", "argument 2", "tuple", args[1]);
goto exit;
}
AddressObj = args[1];
return_value = _overlapped_Overlapped_ConnectEx_impl(self, ConnectSocket, AddressObj);
exit:
@ -710,8 +895,14 @@ _overlapped_Overlapped_DisconnectEx(OverlappedObject *self, PyObject *const *arg
HANDLE Socket;
DWORD flags;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:DisconnectEx",
&Socket, &flags)) {
if (!_PyArg_CheckPositional("DisconnectEx", nargs, 2, 2)) {
goto exit;
}
Socket = PyLong_AsVoidPtr(args[0]);
if (!Socket && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[1], &flags)) {
goto exit;
}
return_value = _overlapped_Overlapped_DisconnectEx_impl(self, Socket, flags);
@ -749,8 +940,30 @@ _overlapped_Overlapped_TransmitFile(OverlappedObject *self, PyObject *const *arg
DWORD count_per_send;
DWORD flags;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE"kkkkk:TransmitFile",
&Socket, &File, &offset, &offset_high, &count_to_write, &count_per_send, &flags)) {
if (!_PyArg_CheckPositional("TransmitFile", nargs, 7, 7)) {
goto exit;
}
Socket = PyLong_AsVoidPtr(args[0]);
if (!Socket && PyErr_Occurred()) {
goto exit;
}
File = PyLong_AsVoidPtr(args[1]);
if (!File && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &offset)) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[3], &offset_high)) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[4], &count_to_write)) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[5], &count_per_send)) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[6], &flags)) {
goto exit;
}
return_value = _overlapped_Overlapped_TransmitFile_impl(self, Socket, File, offset, offset_high, count_to_write, count_per_send, flags);
@ -778,7 +991,8 @@ _overlapped_Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *arg)
PyObject *return_value = NULL;
HANDLE Pipe;
if (!PyArg_Parse(arg, ""F_HANDLE":ConnectNamedPipe", &Pipe)) {
Pipe = PyLong_AsVoidPtr(arg);
if (!Pipe && PyErr_Occurred()) {
goto exit;
}
return_value = _overlapped_Overlapped_ConnectNamedPipe_impl(self, Pipe);
@ -843,10 +1057,14 @@ _overlapped_WSAConnect(PyObject *module, PyObject *const *args, Py_ssize_t nargs
HANDLE ConnectSocket;
PyObject *AddressObj;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:WSAConnect",
&ConnectSocket, &AddressObj)) {
if (!_PyArg_CheckPositional("WSAConnect", nargs, 2, 2)) {
goto exit;
}
ConnectSocket = PyLong_AsVoidPtr(args[0]);
if (!ConnectSocket && PyErr_Occurred()) {
goto exit;
}
AddressObj = args[1];
return_value = _overlapped_WSAConnect_impl(module, ConnectSocket, AddressObj);
exit:
@ -876,10 +1094,24 @@ _overlapped_Overlapped_WSASendTo(OverlappedObject *self, PyObject *const *args,
DWORD flags;
PyObject *AddressObj;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*kO:WSASendTo",
&handle, &bufobj, &flags, &AddressObj)) {
if (!_PyArg_CheckPositional("WSASendTo", nargs, 4, 4)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
goto exit;
}
if (!PyBuffer_IsContiguous(&bufobj, 'C')) {
_PyArg_BadArgument("WSASendTo", "argument 2", "contiguous buffer", args[1]);
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
goto exit;
}
AddressObj = args[3];
return_value = _overlapped_Overlapped_WSASendTo_impl(self, handle, &bufobj, flags, AddressObj);
exit:
@ -913,10 +1145,23 @@ _overlapped_Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *const *args
DWORD size;
DWORD flags = 0;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecvFrom",
&handle, &size, &flags)) {
if (!_PyArg_CheckPositional("WSARecvFrom", nargs, 2, 3)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
goto exit;
}
if (nargs < 3) {
goto skip_optional;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
goto exit;
}
skip_optional:
return_value = _overlapped_Overlapped_WSARecvFrom_impl(self, handle, size, flags);
exit:
@ -946,10 +1191,30 @@ _overlapped_Overlapped_WSARecvFromInto(OverlappedObject *self, PyObject *const *
DWORD size;
DWORD flags = 0;
if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*k|k:WSARecvFromInto",
&handle, &bufobj, &size, &flags)) {
if (!_PyArg_CheckPositional("WSARecvFromInto", nargs, 3, 4)) {
goto exit;
}
handle = PyLong_AsVoidPtr(args[0]);
if (!handle && PyErr_Occurred()) {
goto exit;
}
if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
goto exit;
}
if (!PyBuffer_IsContiguous(&bufobj, 'C')) {
_PyArg_BadArgument("WSARecvFromInto", "argument 2", "contiguous buffer", args[1]);
goto exit;
}
if (!_PyLong_UnsignedLong_Converter(args[2], &size)) {
goto exit;
}
if (nargs < 4) {
goto skip_optional;
}
if (!_PyLong_UnsignedLong_Converter(args[3], &flags)) {
goto exit;
}
skip_optional:
return_value = _overlapped_Overlapped_WSARecvFromInto_impl(self, handle, &bufobj, size, flags);
exit:
@ -960,4 +1225,4 @@ exit:
return return_value;
}
/*[clinic end generated code: output=9078d9f9984864a2 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d90cda84e49a7c23 input=a9049054013a1b77]*/

28
Modules/overlapped.c
View File

@ -32,27 +32,33 @@
#define T_HANDLE T_POINTER
/*[python input]
class OVERLAPPED_converter(CConverter):
type = 'OVERLAPPED *'
class pointer_converter(CConverter):
format_unit = '"F_POINTER"'
class HANDLE_converter(CConverter):
def parse_arg(self, argname, displayname):
return """
{paramname} = PyLong_AsVoidPtr({argname});
if (!{paramname} && PyErr_Occurred()) {{{{
goto exit;
}}}}
""".format(argname=argname, paramname=self.parser_name)
class OVERLAPPED_converter(pointer_converter):
type = 'OVERLAPPED *'
class HANDLE_converter(pointer_converter):
type = 'HANDLE'
format_unit = '"F_HANDLE"'
class ULONG_PTR_converter(CConverter):
class ULONG_PTR_converter(pointer_converter):
type = 'ULONG_PTR'
format_unit = '"F_ULONG_PTR"'
class DWORD_converter(CConverter):
class DWORD_converter(unsigned_long_converter):
type = 'DWORD'
format_unit = 'k'
class BOOL_converter(CConverter):
class BOOL_converter(int_converter):
type = 'BOOL'
format_unit = 'i'
[python start generated code]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=83bb8c2c2514f2a8]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=a19133a9e14fae9c]*/
/*[clinic input]
module _overlapped