summaryrefslogtreecommitdiffstats
path: root/Doc/lib/libfcntl.tex
blob: e1350ecb230f305d10c965b895dc725164064d78 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
\section{\module{fcntl} ---
         The \function{fcntl()} and \function{ioctl()} system calls}

\declaremodule{builtin}{fcntl}
  \platform{Unix}
\modulesynopsis{The \function{fcntl()} and \function{ioctl()} system calls.}
\sectionauthor{Jaap Vermeulen}{}

\indexii{UNIX@\UNIX}{file control}
\indexii{UNIX@\UNIX}{I/O control}

This module performs file control and I/O control on file descriptors.
It is an interface to the \cfunction{fcntl()} and \cfunction{ioctl()}
\UNIX{} routines.

All functions in this module take a file descriptor \var{fd} as their
first argument.  This can be an integer file descriptor, such as
returned by \code{sys.stdin.fileno()}, or a file object, such as
\code{sys.stdin} itself, which provides a \method{fileno()} which
returns a genuine file descriptor.

The module defines the following functions:


\begin{funcdesc}{fcntl}{fd, op\optional{, arg}}
  Perform the requested operation on file descriptor \var{fd} (file
  objects providing a \method{fileno()} method are accepted as well).
  The operation is defined by \var{op} and is operating system
  dependent.  These codes are also found in the \module{fcntl}
  module. The argument \var{arg} is optional, and defaults to the
  integer value \code{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 \cfunction{fcntl()} call.  When the argument is a string it
  represents a binary structure, e.g.\ created by
  \function{\refmodule{struct}.pack()}. The binary data is copied to a buffer
  whose address is passed to the C \cfunction{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 \var{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 \cfunction{fcntl()} fails, an \exception{IOError} is
  raised.
\end{funcdesc}

\begin{funcdesc}{ioctl}{fd, op\optional{, arg\optional{, mutate_flag}}}
  This function is identical to the \function{fcntl()} function,
  except that the operations are typically defined in the library
  module \refmodule{termios} and the argument handling is even more
  complicated.
  
  The parameter \var{arg} can be one of an integer, absent (treated
  identically to the integer \code{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 \function{fcntl()}
  function.
  
  If a mutable buffer is passed, then the behaviour is determined by
  the value of the \var{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 \var{mutate_flag} is true, then the buffer is (in effect) passed
  to the underlying \function{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 \function{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 \function{ioctl()} and copied back into
  the supplied buffer.
  
  If \var{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:

\begin{verbatim}
>>> import array, fcntl, struct, termios, os
>>> os.getpgrp()
13341
>>> struct.unpack('h', fcntl.ioctl(0, termios.TIOCGPGRP, "  "))[0]
13341
>>> buf = array.array('h', [0])
>>> fcntl.ioctl(0, termios.TIOCGPGRP, buf, 1)
0
>>> buf
array('h', [13341])
\end{verbatim}
\end{funcdesc}

\begin{funcdesc}{flock}{fd, op}
Perform the lock operation \var{op} on file descriptor \var{fd} (file
  objects providing a \method{fileno()} method are accepted as well).
See the \UNIX{} manual \manpage{flock}{3} for details.  (On some
systems, this function is emulated using \cfunction{fcntl()}.)
\end{funcdesc}

\begin{funcdesc}{lockf}{fd, operation,
    \optional{length, \optional{start, \optional{whence}}}}
This is essentially a wrapper around the \function{fcntl()} locking
calls.  \var{fd} is the file descriptor of the file to lock or unlock,
and \var{operation} is one of the following values:

\begin{itemize}
\item \constant{LOCK_UN} -- unlock
\item \constant{LOCK_SH} -- acquire a shared lock
\item \constant{LOCK_EX} -- acquire an exclusive lock
\end{itemize}

When \var{operation} is \constant{LOCK_SH} or \constant{LOCK_EX}, it
can also be bit-wise OR'd with \constant{LOCK_NB} to avoid blocking on
lock acquisition.  If \constant{LOCK_NB} is used and the lock cannot
be acquired, an \exception{IOError} will be raised and the exception
will have an \var{errno} attribute set to \constant{EACCES} or
\constant{EAGAIN} (depending on the operating system; for portability,
check for both values).  On at least some systems, \constant{LOCK_EX}
can only be used if the file descriptor refers to a file opened for
writing.

\var{length} is the number of bytes to lock, \var{start} is the byte
offset at which the lock starts, relative to \var{whence}, and
\var{whence} is as with \function{fileobj.seek()}, specifically:

\begin{itemize}
\item \constant{0} -- relative to the start of the file
      (\constant{SEEK_SET})
\item \constant{1} -- relative to the current buffer position
      (\constant{SEEK_CUR})
\item \constant{2} -- relative to the end of the file
      (\constant{SEEK_END})
\end{itemize}

The default for \var{start} is 0, which means to start at the
beginning of the file.  The default for \var{length} is 0 which means
to lock to the end of the file.  The default for \var{whence} is also
0.
\end{funcdesc}

Examples (all on a SVR4 compliant system):

\begin{verbatim}
import struct, fcntl, os

f = open(...)
rv = fcntl.fcntl(f, fcntl.F_SETFL, os.O_NDELAY)

lockdata = struct.pack('hhllhh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)
rv = fcntl.fcntl(f, fcntl.F_SETLKW, lockdata)
\end{verbatim}

Note that in the first example the return value variable \var{rv} will
hold an integer value; in the second example it will hold a string
value.  The structure lay-out for the \var{lockdata} variable is
system dependent --- therefore using the \function{flock()} call may be
better.

\begin{seealso}
  \seemodule{os}{The \function{os.open()} function supports locking flags
                 and is available on a wider variety of platforms than
                 the \function{lockf()} and \function{flock()}
                 functions, providing a more platform-independent file
                 locking facility.}
\end{seealso}