1:mod:`fcntl` --- The ``fcntl`` and ``ioctl`` system calls
2=========================================================
3
4.. module:: fcntl
5   :platform: Unix
6   :synopsis: The fcntl() and ioctl() system calls.
7.. sectionauthor:: Jaap Vermeulen
8
9
10.. index::
11   pair: UNIX; file control
12   pair: UNIX; I/O control
13
14This module performs file control and I/O control on file descriptors. It is an
15interface to the :c:func:`fcntl` and :c:func:`ioctl` Unix routines.  For a
16complete description of these calls, see :manpage:`fcntl(2)` and
17:manpage:`ioctl(2)` Unix manual pages.
18
19All functions in this module take a file descriptor *fd* as their first
20argument.  This can be an integer file descriptor, such as returned by
21``sys.stdin.fileno()``, or a file object, such as ``sys.stdin`` itself, which
22provides a :meth:`~io.IOBase.fileno` which returns a genuine file descriptor.
23
24The module defines the following functions:
25
26
27.. function:: fcntl(fd, op[, arg])
28
29   Perform the operation *op* on file descriptor *fd* (file objects providing
30   a :meth:`~io.IOBase.fileno` method are accepted as well).  The values used
31   for for *op* are operating system dependent, and are available as constants
32   in the :mod:`fcntl` module, using the same names as used in the relevant C
33   header files.  The argument *arg* is optional, and defaults to the integer
34   value ``0``.  When present, it can either be an integer value, or a string.
35   With the argument missing or an integer value, the return value of this function
36   is the integer return value of the C :c:func:`fcntl` call.  When the argument is
37   a string it represents a binary structure, e.g. created by :func:`struct.pack`.
38   The binary data is copied to a buffer whose address is passed to the C
39   :c:func:`fcntl` call.  The return value after a successful call is the contents
40   of the buffer, converted to a string object.  The length of the returned string
41   will be the same as the length of the *arg* argument.  This is limited to 1024
42   bytes.  If the information returned in the buffer by the operating system is
43   larger than 1024 bytes, this is most likely to result in a segmentation
44   violation or a more subtle data corruption.
45
46   If the :c:func:`fcntl` fails, an :exc:`IOError` is raised.
47
48
49.. function:: ioctl(fd, op[, arg[, mutate_flag]])
50
51   This function is identical to the :func:`~fcntl.fcntl` function, except that the
52   operations are typically defined in the library module :mod:`termios` and the
53   argument handling is even more complicated.
54
55   The op parameter is limited to values that can fit in 32-bits.
56   Additional constants of interest for use as the *op* argument can be
57   found in the :mod:`termios` module, under the same names as used in
58   the relevant C header files.
59
60   The parameter *arg* can be one of an integer, absent (treated identically to the
61   integer ``0``), an object supporting the read-only buffer interface (most likely
62   a plain Python string) or an object supporting the read-write buffer interface.
63
64   In all but the last case, behaviour is as for the :func:`~fcntl.fcntl`
65   function.
66
67   If a mutable buffer is passed, then the behaviour is determined by the value of
68   the *mutate_flag* parameter.
69
70   If it is false, the buffer's mutability is ignored and behaviour is as for a
71   read-only buffer, except that the 1024 byte limit mentioned above is avoided --
72   so long as the buffer you pass is as least as long as what the operating system
73   wants to put there, things should work.
74
75   If *mutate_flag* is true, then the buffer is (in effect) passed to the
76   underlying :func:`ioctl` system call, the latter's return code is passed back to
77   the calling Python, and the buffer's new contents reflect the action of the
78   :func:`ioctl`.  This is a slight simplification, because if the supplied buffer
79   is less than 1024 bytes long it is first copied into a static buffer 1024 bytes
80   long which is then passed to :func:`ioctl` and copied back into the supplied
81   buffer.
82
83   If *mutate_flag* is not supplied, then from Python 2.5 it defaults to true,
84   which is a change from versions 2.3 and 2.4. Supply the argument explicitly if
85   version portability is a priority.
86
87   If the :c:func:`ioctl` fails, an :exc:`IOError` exception is raised.
88
89   An example::
90
91      >>> import array, fcntl, struct, termios, os
92      >>> os.getpgrp()
93      13341
94      >>> struct.unpack('h', fcntl.ioctl(0, termios.TIOCGPGRP, "  "))[0]
95      13341
96      >>> buf = array.array('h', [0])
97      >>> fcntl.ioctl(0, termios.TIOCGPGRP, buf, 1)
98      0
99      >>> buf
100      array('h', [13341])
101
102
103.. function:: flock(fd, op)
104
105   Perform the lock operation *op* on file descriptor *fd* (file objects providing
106   a :meth:`~io.IOBase.fileno` method are accepted as well). See the Unix manual
107   :manpage:`flock(2)` for details.  (On some systems, this function is emulated
108   using :c:func:`fcntl`.)
109
110   If the :c:func:`flock` fails, an :exc:`IOError` exception is raised.
111
112
113.. function:: lockf(fd, operation, [length, [start, [whence]]])
114
115   This is essentially a wrapper around the :func:`~fcntl.fcntl` locking calls.
116   *fd* is the file descriptor of the file to lock or unlock, and *operation*
117   is one of the following values:
118
119   * :const:`LOCK_UN` -- unlock
120   * :const:`LOCK_SH` -- acquire a shared lock
121   * :const:`LOCK_EX` -- acquire an exclusive lock
122
123   When *operation* is :const:`LOCK_SH` or :const:`LOCK_EX`, it can also be
124   bitwise ORed with :const:`LOCK_NB` to avoid blocking on lock acquisition.
125   If :const:`LOCK_NB` is used and the lock cannot be acquired, an
126   :exc:`IOError` will be raised and the exception will have an *errno*
127   attribute set to :const:`EACCES` or :const:`EAGAIN` (depending on the
128   operating system; for portability, check for both values).  On at least some
129   systems, :const:`LOCK_EX` can only be used if the file descriptor refers to a
130   file opened for writing.
131
132   *length* is the number of bytes to lock, *start* is the byte offset at
133   which the lock starts, relative to *whence*, and *whence* is as with
134   :func:`io.IOBase.seek`, specifically:
135
136   * :const:`0` -- relative to the start of the file (:data:`os.SEEK_SET`)
137   * :const:`1` -- relative to the current buffer position (:data:`os.SEEK_CUR`)
138   * :const:`2` -- relative to the end of the file (:data:`os.SEEK_END`)
139
140   The default for *start* is 0, which means to start at the beginning of the file.
141   The default for *length* is 0 which means to lock to the end of the file.  The
142   default for *whence* is also 0.
143
144Examples (all on a SVR4 compliant system)::
145
146   import struct, fcntl, os
147
148   f = open(...)
149   rv = fcntl.fcntl(f, fcntl.F_SETFL, os.O_NDELAY)
150
151   lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)
152   rv = fcntl.fcntl(f, fcntl.F_SETLKW, lockdata)
153
154Note that in the first example the return value variable *rv* will hold an
155integer value; in the second example it will hold a string value.  The structure
156lay-out for the *lockdata* variable is system dependent --- therefore using the
157:func:`flock` call may be better.
158
159
160.. seealso::
161
162   Module :mod:`os`
163      If the locking flags :data:`~os.O_SHLOCK` and :data:`~os.O_EXLOCK` are
164      present in the :mod:`os` module (on BSD only), the :func:`os.open`
165      function provides an alternative to the :func:`lockf` and :func:`flock`
166      functions.
167
168