0 + lm_JJhȮ41h߿ q_I| :mod:`fcntl` --- The :func:`fcntl` and :func:`ioctl` system calls ================================================================= .. module:: fcntl :platform: Unix :synopsis: The fcntl() and ioctl() system calls. .. sectionauthor:: Jaap Vermeulen .. index:: pair: UNIX; file control pair: UNIX; I/O control This module performs file control and I/O control on file descriptors. It is an interface to the :c:func:`fcntl` and :c:func:`ioctl` Unix routines. All functions in this module take a file descriptor *fd* as their first argument. This can be an integer file descriptor, such as returned by ``sys.stdin.fileno()``, or a file object, such as ``sys.stdin`` itself, which provides a :meth:`fileno` which returns a genuine file descriptor. The module defines the following functions: .. function:: fcntl(fd, op[, arg]) Perform the requested operation on file descriptor *fd* (file objects providing a :meth:`fileno` method are accepted as well). The operation is defined by *op* and is operating system dependent. These codes are also found in the :mod:`fcntl` module. The argument *arg* is optional, and defaults to the integer value ``0``. When present, it can either be an integer value, or a string. With the argument missing or an integer value, the return value of this function is the integer return value of the C :c:func:`fcntl` call. When the argument is a string it represents a binary structure, e.g. created by :func:`struct.pack`. The binary data is copied to a buffer whose address is passed to the C :c:func:`fcntl` call. The return value after a successful call is the contents of the buffer, converted to a string object. The length of the returned string will be the same as the length of the *arg* argument. This is limited to 1024 bytes. If the information returned in the buffer by the operating system is larger than 1024 bytes, this is most likely to result in a segmentation violation or a more subtle data corruption. If the :c:func:`fcntl` fails, an :exc:`IOError` is raised. .. function:: ioctl(fd, op[, arg[, mutate_flag]]) This function is identical to the :func:`fcntl` function, except that the operations are typically defined in the library module :mod:`termios` and the argument handling is even more complicated. The op parameter is limited to values that can fit in 32-bits. The parameter *arg* can be one of an integer, absent (treated identically to the integer ``0``), an object supporting the read-only buffer interface (most likely a plain Python string) or an object supporting the read-write buffer interface. In all but the last case, behaviour is as for the :func:`fcntl` function. If a mutable buffer is passed, then the behaviour is determined by the value of the *mutate_flag* parameter. If it is false, the buffer's mutability is ignored and behaviour is as for a read-only buffer, except that the 1024 byte limit mentioned above is avoided -- so long as the buffer you pass is as least as long as what the operating system wants to put there, things should work. If *mutate_flag* is true, then the buffer is (in effect) passed to the underlying :func:`ioctl` system call, the latter's return code is passed back to the calling Python, and the buffer's new contents reflect the action of the :func:`ioctl`. This is a slight simplification, because if the supplied buffer is less than 1024 bytes long it is first copied into a static buffer 1024 bytes long which is then passed to :func:`ioctl` and copied back into the supplied buffer. If *mutate_flag* is not supplied, then from Python 2.5 it defaults to true, which is a change from versions 2.3 and 2.4. Supply the argument explicitly if version portability is a priority. An example:: >>> import array, fcntl, struct, termios, os >>> os.getpgrp() 13341 >>> struct.unpack('h', fcntl.ioctl(0, termios.TIOCGPGRP, " "))[0] 13341