You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
272 lines
8.4 KiB
272 lines
8.4 KiB
/*[clinic input]
|
|
preserve
|
|
[clinic start generated code]*/
|
|
|
|
PyDoc_STRVAR(fcntl_fcntl__doc__,
|
|
"fcntl($module, fd, cmd, arg=0, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Perform the operation `cmd` on file descriptor fd.\n"
|
|
"\n"
|
|
"The values used for `cmd` are operating system dependent, and are available\n"
|
|
"as constants in the fcntl module, using the same names as used in\n"
|
|
"the relevant C header files. The argument arg is optional, and\n"
|
|
"defaults to 0; it may be an int or a string. If arg is given as a string,\n"
|
|
"the return value of fcntl is a string of that length, containing the\n"
|
|
"resulting value put in the arg buffer by the operating system. The length\n"
|
|
"of the arg string is not allowed to exceed 1024 bytes. If the arg given\n"
|
|
"is an integer or if none is specified, the result value is an integer\n"
|
|
"corresponding to the return value of the fcntl call in the C code.");
|
|
|
|
#define FCNTL_FCNTL_METHODDEF \
|
|
{"fcntl", (PyCFunction)(void(*)(void))fcntl_fcntl, METH_FASTCALL, fcntl_fcntl__doc__},
|
|
|
|
static PyObject *
|
|
fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg);
|
|
|
|
static PyObject *
|
|
fcntl_fcntl(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
int fd;
|
|
int code;
|
|
PyObject *arg = NULL;
|
|
|
|
if (!_PyArg_CheckPositional("fcntl", nargs, 2, 3)) {
|
|
goto exit;
|
|
}
|
|
if (!conv_descriptor(args[0], &fd)) {
|
|
goto exit;
|
|
}
|
|
if (PyFloat_Check(args[1])) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"integer argument expected, got float" );
|
|
goto exit;
|
|
}
|
|
code = _PyLong_AsInt(args[1]);
|
|
if (code == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (nargs < 3) {
|
|
goto skip_optional;
|
|
}
|
|
arg = args[2];
|
|
skip_optional:
|
|
return_value = fcntl_fcntl_impl(module, fd, code, arg);
|
|
|
|
exit:
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(fcntl_ioctl__doc__,
|
|
"ioctl($module, fd, request, arg=0, mutate_flag=True, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Perform the operation `request` on file descriptor `fd`.\n"
|
|
"\n"
|
|
"The values used for `request` are operating system dependent, and are available\n"
|
|
"as constants in the fcntl or termios library modules, using the same names as\n"
|
|
"used in the relevant C header files.\n"
|
|
"\n"
|
|
"The argument `arg` is optional, and defaults to 0; it may be an int or a\n"
|
|
"buffer containing character data (most likely a string or an array).\n"
|
|
"\n"
|
|
"If the argument is a mutable buffer (such as an array) and if the\n"
|
|
"mutate_flag argument (which is only allowed in this case) is true then the\n"
|
|
"buffer is (in effect) passed to the operating system and changes made by\n"
|
|
"the OS will be reflected in the contents of the buffer after the call has\n"
|
|
"returned. The return value is the integer returned by the ioctl system\n"
|
|
"call.\n"
|
|
"\n"
|
|
"If the argument is a mutable buffer and the mutable_flag argument is false,\n"
|
|
"the behavior is as if a string had been passed.\n"
|
|
"\n"
|
|
"If the argument is an immutable buffer (most likely a string) then a copy\n"
|
|
"of the buffer is passed to the operating system and the return value is a\n"
|
|
"string of the same length containing whatever the operating system put in\n"
|
|
"the buffer. The length of the arg buffer in this case is not allowed to\n"
|
|
"exceed 1024 bytes.\n"
|
|
"\n"
|
|
"If the arg given is an integer or if none is specified, the result value is\n"
|
|
"an integer corresponding to the return value of the ioctl call in the C\n"
|
|
"code.");
|
|
|
|
#define FCNTL_IOCTL_METHODDEF \
|
|
{"ioctl", (PyCFunction)(void(*)(void))fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
|
|
|
|
static PyObject *
|
|
fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,
|
|
PyObject *ob_arg, int mutate_arg);
|
|
|
|
static PyObject *
|
|
fcntl_ioctl(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
int fd;
|
|
unsigned int code;
|
|
PyObject *ob_arg = NULL;
|
|
int mutate_arg = 1;
|
|
|
|
if (!_PyArg_CheckPositional("ioctl", nargs, 2, 4)) {
|
|
goto exit;
|
|
}
|
|
if (!conv_descriptor(args[0], &fd)) {
|
|
goto exit;
|
|
}
|
|
if (PyFloat_Check(args[1])) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"integer argument expected, got float" );
|
|
goto exit;
|
|
}
|
|
code = (unsigned int)PyLong_AsUnsignedLongMask(args[1]);
|
|
if (code == (unsigned int)-1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (nargs < 3) {
|
|
goto skip_optional;
|
|
}
|
|
ob_arg = args[2];
|
|
if (nargs < 4) {
|
|
goto skip_optional;
|
|
}
|
|
mutate_arg = PyObject_IsTrue(args[3]);
|
|
if (mutate_arg < 0) {
|
|
goto exit;
|
|
}
|
|
skip_optional:
|
|
return_value = fcntl_ioctl_impl(module, fd, code, ob_arg, mutate_arg);
|
|
|
|
exit:
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(fcntl_flock__doc__,
|
|
"flock($module, fd, operation, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"Perform the lock operation `operation` on file descriptor `fd`.\n"
|
|
"\n"
|
|
"See the Unix manual page for flock(2) for details (On some systems, this\n"
|
|
"function is emulated using fcntl()).");
|
|
|
|
#define FCNTL_FLOCK_METHODDEF \
|
|
{"flock", (PyCFunction)(void(*)(void))fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
|
|
|
|
static PyObject *
|
|
fcntl_flock_impl(PyObject *module, int fd, int code);
|
|
|
|
static PyObject *
|
|
fcntl_flock(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
int fd;
|
|
int code;
|
|
|
|
if (!_PyArg_CheckPositional("flock", nargs, 2, 2)) {
|
|
goto exit;
|
|
}
|
|
if (!conv_descriptor(args[0], &fd)) {
|
|
goto exit;
|
|
}
|
|
if (PyFloat_Check(args[1])) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"integer argument expected, got float" );
|
|
goto exit;
|
|
}
|
|
code = _PyLong_AsInt(args[1]);
|
|
if (code == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
return_value = fcntl_flock_impl(module, fd, code);
|
|
|
|
exit:
|
|
return return_value;
|
|
}
|
|
|
|
PyDoc_STRVAR(fcntl_lockf__doc__,
|
|
"lockf($module, fd, cmd, len=0, start=0, whence=0, /)\n"
|
|
"--\n"
|
|
"\n"
|
|
"A wrapper around the fcntl() locking calls.\n"
|
|
"\n"
|
|
"`fd` is the file descriptor of the file to lock or unlock, and operation is one\n"
|
|
"of the following values:\n"
|
|
"\n"
|
|
" LOCK_UN - unlock\n"
|
|
" LOCK_SH - acquire a shared lock\n"
|
|
" LOCK_EX - acquire an exclusive lock\n"
|
|
"\n"
|
|
"When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\n"
|
|
"LOCK_NB to avoid blocking on lock acquisition. If LOCK_NB is used and the\n"
|
|
"lock cannot be acquired, an OSError will be raised and the exception will\n"
|
|
"have an errno attribute set to EACCES or EAGAIN (depending on the operating\n"
|
|
"system -- for portability, check for either value).\n"
|
|
"\n"
|
|
"`len` is the number of bytes to lock, with the default meaning to lock to\n"
|
|
"EOF. `start` is the byte offset, relative to `whence`, to that the lock\n"
|
|
"starts. `whence` is as with fileobj.seek(), specifically:\n"
|
|
"\n"
|
|
" 0 - relative to the start of the file (SEEK_SET)\n"
|
|
" 1 - relative to the current buffer position (SEEK_CUR)\n"
|
|
" 2 - relative to the end of the file (SEEK_END)");
|
|
|
|
#define FCNTL_LOCKF_METHODDEF \
|
|
{"lockf", (PyCFunction)(void(*)(void))fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
|
|
|
|
static PyObject *
|
|
fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
|
|
PyObject *startobj, int whence);
|
|
|
|
static PyObject *
|
|
fcntl_lockf(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
|
|
{
|
|
PyObject *return_value = NULL;
|
|
int fd;
|
|
int code;
|
|
PyObject *lenobj = NULL;
|
|
PyObject *startobj = NULL;
|
|
int whence = 0;
|
|
|
|
if (!_PyArg_CheckPositional("lockf", nargs, 2, 5)) {
|
|
goto exit;
|
|
}
|
|
if (!conv_descriptor(args[0], &fd)) {
|
|
goto exit;
|
|
}
|
|
if (PyFloat_Check(args[1])) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"integer argument expected, got float" );
|
|
goto exit;
|
|
}
|
|
code = _PyLong_AsInt(args[1]);
|
|
if (code == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
if (nargs < 3) {
|
|
goto skip_optional;
|
|
}
|
|
lenobj = args[2];
|
|
if (nargs < 4) {
|
|
goto skip_optional;
|
|
}
|
|
startobj = args[3];
|
|
if (nargs < 5) {
|
|
goto skip_optional;
|
|
}
|
|
if (PyFloat_Check(args[4])) {
|
|
PyErr_SetString(PyExc_TypeError,
|
|
"integer argument expected, got float" );
|
|
goto exit;
|
|
}
|
|
whence = _PyLong_AsInt(args[4]);
|
|
if (whence == -1 && PyErr_Occurred()) {
|
|
goto exit;
|
|
}
|
|
skip_optional:
|
|
return_value = fcntl_lockf_impl(module, fd, code, lenobj, startobj, whence);
|
|
|
|
exit:
|
|
return return_value;
|
|
}
|
|
/*[clinic end generated code: output=e912d25e28362c52 input=a9049054013a1b77]*/
|