blob: 97ff07c12e98362948f1c3e523f97e4eef3e4392 [file] [log] [blame]
Guido van Rossum02975121992-08-17 08:55:12 +00001
2/* fcntl module */
3
Thomas Wouters26cc63f2006-03-02 00:21:10 +00004#define PY_SSIZE_T_CLEAN
5
Roger E. Masse919213a1996-12-17 17:42:22 +00006#include "Python.h"
Guido van Rossum02975121992-08-17 08:55:12 +00007
Guido van Rossuma376cc51996-12-05 23:43:35 +00008#ifdef HAVE_SYS_FILE_H
9#include <sys/file.h>
10#endif
11
Guido van Rossum3d65fa31996-12-09 18:49:14 +000012#include <sys/ioctl.h>
Guido van Rossum3c0b79c1996-06-11 15:11:34 +000013#include <fcntl.h>
Martin v. Löwis14e73b12003-01-01 09:51:12 +000014#ifdef HAVE_STROPTS_H
15#include <stropts.h>
16#endif
Guido van Rossum02975121992-08-17 08:55:12 +000017
Brett Cannonb7299dd2014-11-09 20:22:01 -050018/*[clinic input]
Brett Cannonb7299dd2014-11-09 20:22:01 -050019module fcntl
20[clinic start generated code]*/
Serhiy Storchaka1009bf12015-04-03 23:53:51 +030021/*[clinic end generated code: output=da39a3ee5e6b4b0d input=124b58387c158179]*/
Brett Cannonb7299dd2014-11-09 20:22:01 -050022
Fred Drake152a25e2001-05-09 21:02:02 +000023static int
24conv_descriptor(PyObject *object, int *target)
25{
26 int fd = PyObject_AsFileDescriptor(object);
27
28 if (fd < 0)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000029 return 0;
Fred Drake152a25e2001-05-09 21:02:02 +000030 *target = fd;
31 return 1;
32}
33
Brett Cannonb7299dd2014-11-09 20:22:01 -050034/* Must come after conv_descriptor definition. */
35#include "clinic/fcntlmodule.c.h"
Fred Drake152a25e2001-05-09 21:02:02 +000036
Brett Cannonb7299dd2014-11-09 20:22:01 -050037/*[clinic input]
38fcntl.fcntl
39
40 fd: object(type='int', converter='conv_descriptor')
Serhiy Storchaka17d3a582015-03-20 20:04:21 +020041 cmd as code: int
42 arg: object(c_default='NULL') = 0
Brett Cannonb7299dd2014-11-09 20:22:01 -050043 /
44
Serhiy Storchaka17d3a582015-03-20 20:04:21 +020045Perform the operation `cmd` on file descriptor fd.
Brett Cannonb7299dd2014-11-09 20:22:01 -050046
Serhiy Storchaka17d3a582015-03-20 20:04:21 +020047The values used for `cmd` are operating system dependent, and are available
Brett Cannonb7299dd2014-11-09 20:22:01 -050048as constants in the fcntl module, using the same names as used in
49the relevant C header files. The argument arg is optional, and
50defaults to 0; it may be an int or a string. If arg is given as a string,
51the return value of fcntl is a string of that length, containing the
52resulting value put in the arg buffer by the operating system. The length
53of the arg string is not allowed to exceed 1024 bytes. If the arg given
54is an integer or if none is specified, the result value is an integer
55corresponding to the return value of the fcntl call in the C code.
56[clinic start generated code]*/
Guido van Rossum02975121992-08-17 08:55:12 +000057
Roger E. Masse919213a1996-12-17 17:42:22 +000058static PyObject *
Brett Cannonb7299dd2014-11-09 20:22:01 -050059fcntl_fcntl_impl(PyModuleDef *module, int fd, int code, PyObject *arg)
Serhiy Storchaka17d3a582015-03-20 20:04:21 +020060/*[clinic end generated code: output=afc5bfa74a03ef0d input=8cefbe59b29efbe2]*/
Guido van Rossum02975121992-08-17 08:55:12 +000061{
Serhiy Storchaka5a8dacf2014-11-10 11:25:50 +020062 unsigned int int_arg = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000063 int ret;
64 char *str;
65 Py_ssize_t len;
66 char buf[1024];
Guido van Rossum02975121992-08-17 08:55:12 +000067
Brett Cannonb7299dd2014-11-09 20:22:01 -050068 if (arg != NULL) {
69 int parse_result;
70
71 if (PyArg_Parse(arg, "s#", &str, &len)) {
72 if ((size_t)len > sizeof buf) {
73 PyErr_SetString(PyExc_ValueError,
74 "fcntl string arg too long");
75 return NULL;
76 }
77 memcpy(buf, str, len);
78 Py_BEGIN_ALLOW_THREADS
79 ret = fcntl(fd, code, buf);
80 Py_END_ALLOW_THREADS
81 if (ret < 0) {
82 PyErr_SetFromErrno(PyExc_IOError);
83 return NULL;
84 }
85 return PyBytes_FromStringAndSize(buf, len);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000086 }
Brett Cannonb7299dd2014-11-09 20:22:01 -050087
88 PyErr_Clear();
89 parse_result = PyArg_Parse(arg,
Serhiy Storchaka5a8dacf2014-11-10 11:25:50 +020090 "I;fcntl requires a file or file descriptor,"
Brett Cannonb7299dd2014-11-09 20:22:01 -050091 " an integer and optionally a third integer or a string",
92 &int_arg);
93 if (!parse_result) {
94 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000095 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000096 }
Guido van Rossum02975121992-08-17 08:55:12 +000097
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000098 Py_BEGIN_ALLOW_THREADS
Serhiy Storchaka5a8dacf2014-11-10 11:25:50 +020099 ret = fcntl(fd, code, (int)int_arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000100 Py_END_ALLOW_THREADS
101 if (ret < 0) {
102 PyErr_SetFromErrno(PyExc_IOError);
103 return NULL;
104 }
105 return PyLong_FromLong((long)ret);
Guido van Rossum02975121992-08-17 08:55:12 +0000106}
107
Guido van Rossum185ead61998-11-23 15:32:55 +0000108
Brett Cannonb7299dd2014-11-09 20:22:01 -0500109/*[clinic input]
110fcntl.ioctl
Guido van Rossum02975121992-08-17 08:55:12 +0000111
Brett Cannonb7299dd2014-11-09 20:22:01 -0500112 fd: object(type='int', converter='conv_descriptor')
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200113 request as code: unsigned_int(bitwise=True)
114 arg as ob_arg: object(c_default='NULL') = 0
Brett Cannonb7299dd2014-11-09 20:22:01 -0500115 mutate_flag as mutate_arg: bool = True
116 /
117
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200118Perform the operation `request` on file descriptor `fd`.
Brett Cannonb7299dd2014-11-09 20:22:01 -0500119
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200120The values used for `request` are operating system dependent, and are available
121as constants in the fcntl or termios library modules, using the same names as
Brett Cannonb7299dd2014-11-09 20:22:01 -0500122used in the relevant C header files.
123
124The argument `arg` is optional, and defaults to 0; it may be an int or a
125buffer containing character data (most likely a string or an array).
126
127If the argument is a mutable buffer (such as an array) and if the
128mutate_flag argument (which is only allowed in this case) is true then the
129buffer is (in effect) passed to the operating system and changes made by
130the OS will be reflected in the contents of the buffer after the call has
131returned. The return value is the integer returned by the ioctl system
132call.
133
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200134If the argument is a mutable buffer and the mutable_flag argument is false,
135the behavior is as if a string had been passed.
Brett Cannonb7299dd2014-11-09 20:22:01 -0500136
137If the argument is an immutable buffer (most likely a string) then a copy
138of the buffer is passed to the operating system and the return value is a
139string of the same length containing whatever the operating system put in
140the buffer. The length of the arg buffer in this case is not allowed to
141exceed 1024 bytes.
142
143If the arg given is an integer or if none is specified, the result value is
144an integer corresponding to the return value of the ioctl call in the C
145code.
146[clinic start generated code]*/
Guido van Rossum02975121992-08-17 08:55:12 +0000147
Roger E. Masse919213a1996-12-17 17:42:22 +0000148static PyObject *
Larry Hastings89964c42015-04-14 18:07:59 -0400149fcntl_ioctl_impl(PyModuleDef *module, int fd, unsigned int code,
150 PyObject *ob_arg, int mutate_arg)
151/*[clinic end generated code: output=102faa0f7ebe2210 input=ede70c433cccbbb2]*/
Guido van Rossum02975121992-08-17 08:55:12 +0000152{
Thomas Wouters477c8d52006-05-27 19:21:47 +0000153#define IOCTL_BUFSZ 1024
Serhiy Storchaka483405b2015-02-17 10:14:30 +0200154 /* We use the unsigned non-checked 'I' format for the 'code' parameter
155 because the system expects it to be a 32bit bit field value
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000156 regardless of it being passed as an int or unsigned long on
157 various platforms. See the termios.TIOCSWINSZ constant across
R David Murrayd5a2f0b2013-11-07 10:51:07 -0500158 platforms for an example of this.
Christian Heimese25f35e2008-03-20 10:49:03 +0000159
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000160 If any of the 64bit platforms ever decide to use more than 32bits
161 in their unsigned long ioctl codes this will break and need
162 special casing based on the platform being built on.
163 */
Brett Cannonb7299dd2014-11-09 20:22:01 -0500164 int arg = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000165 int ret;
166 Py_buffer pstr;
167 char *str;
168 Py_ssize_t len;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000169 char buf[IOCTL_BUFSZ+1]; /* argument plus NUL byte */
Guido van Rossum02975121992-08-17 08:55:12 +0000170
Brett Cannonb7299dd2014-11-09 20:22:01 -0500171 if (ob_arg != NULL) {
172 if (PyArg_Parse(ob_arg, "w*:ioctl", &pstr)) {
173 char *arg;
174 str = pstr.buf;
175 len = pstr.len;
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000176
Brett Cannonb7299dd2014-11-09 20:22:01 -0500177 if (mutate_arg) {
178 if (len <= IOCTL_BUFSZ) {
179 memcpy(buf, str, len);
180 buf[len] = '\0';
181 arg = buf;
182 }
183 else {
184 arg = str;
185 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000186 }
187 else {
Brett Cannonb7299dd2014-11-09 20:22:01 -0500188 if (len > IOCTL_BUFSZ) {
189 PyBuffer_Release(&pstr);
190 PyErr_SetString(PyExc_ValueError,
191 "ioctl string arg too long");
192 return NULL;
193 }
194 else {
195 memcpy(buf, str, len);
196 buf[len] = '\0';
197 arg = buf;
198 }
199 }
200 if (buf == arg) {
201 Py_BEGIN_ALLOW_THREADS /* think array.resize() */
202 ret = ioctl(fd, code, arg);
203 Py_END_ALLOW_THREADS
204 }
205 else {
206 ret = ioctl(fd, code, arg);
207 }
208 if (mutate_arg && (len <= IOCTL_BUFSZ)) {
209 memcpy(str, buf, len);
210 }
211 PyBuffer_Release(&pstr); /* No further access to str below this point */
212 if (ret < 0) {
213 PyErr_SetFromErrno(PyExc_IOError);
214 return NULL;
215 }
216 if (mutate_arg) {
217 return PyLong_FromLong(ret);
218 }
219 else {
220 return PyBytes_FromStringAndSize(buf, len);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000221 }
222 }
Brett Cannonb7299dd2014-11-09 20:22:01 -0500223
224 PyErr_Clear();
225 if (PyArg_Parse(ob_arg, "s*:ioctl", &pstr)) {
226 str = pstr.buf;
227 len = pstr.len;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000228 if (len > IOCTL_BUFSZ) {
229 PyBuffer_Release(&pstr);
230 PyErr_SetString(PyExc_ValueError,
Brett Cannonb7299dd2014-11-09 20:22:01 -0500231 "ioctl string arg too long");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000232 return NULL;
233 }
Brett Cannonb7299dd2014-11-09 20:22:01 -0500234 memcpy(buf, str, len);
235 buf[len] = '\0';
236 Py_BEGIN_ALLOW_THREADS
237 ret = ioctl(fd, code, buf);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000238 Py_END_ALLOW_THREADS
Brett Cannonb7299dd2014-11-09 20:22:01 -0500239 if (ret < 0) {
240 PyBuffer_Release(&pstr);
241 PyErr_SetFromErrno(PyExc_IOError);
242 return NULL;
243 }
244 PyBuffer_Release(&pstr);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000245 return PyBytes_FromStringAndSize(buf, len);
246 }
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000247
Brett Cannonb7299dd2014-11-09 20:22:01 -0500248 PyErr_Clear();
249 if (!PyArg_Parse(ob_arg,
250 "i;ioctl requires a file or file descriptor,"
251 " an integer and optionally an integer or buffer argument",
252 &arg)) {
253 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000254 }
Brett Cannonb7299dd2014-11-09 20:22:01 -0500255 // Fall-through to outside the 'if' statement.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000256 }
257 Py_BEGIN_ALLOW_THREADS
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000258 ret = ioctl(fd, code, arg);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000259 Py_END_ALLOW_THREADS
260 if (ret < 0) {
261 PyErr_SetFromErrno(PyExc_IOError);
262 return NULL;
263 }
264 return PyLong_FromLong((long)ret);
Thomas Wouters477c8d52006-05-27 19:21:47 +0000265#undef IOCTL_BUFSZ
Guido van Rossum02975121992-08-17 08:55:12 +0000266}
267
Brett Cannonb7299dd2014-11-09 20:22:01 -0500268/*[clinic input]
269fcntl.flock
Guido van Rossum185ead61998-11-23 15:32:55 +0000270
Brett Cannonb7299dd2014-11-09 20:22:01 -0500271 fd: object(type='int', converter='conv_descriptor')
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200272 operation as code: int
Brett Cannonb7299dd2014-11-09 20:22:01 -0500273 /
Guido van Rossum02975121992-08-17 08:55:12 +0000274
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200275Perform the lock operation `operation` on file descriptor `fd`.
Brett Cannonb7299dd2014-11-09 20:22:01 -0500276
277See the Unix manual page for flock(2) for details (On some systems, this
278function is emulated using fcntl()).
279[clinic start generated code]*/
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000280
Roger E. Masse919213a1996-12-17 17:42:22 +0000281static PyObject *
Brett Cannonb7299dd2014-11-09 20:22:01 -0500282fcntl_flock_impl(PyModuleDef *module, int fd, int code)
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200283/*[clinic end generated code: output=c9035133a7dbfc96 input=b70a0a41ca22a8a0]*/
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000284{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000285 int ret;
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000286
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000287#ifdef HAVE_FLOCK
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000288 Py_BEGIN_ALLOW_THREADS
289 ret = flock(fd, code);
290 Py_END_ALLOW_THREADS
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000291#else
292
293#ifndef LOCK_SH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000294#define LOCK_SH 1 /* shared lock */
295#define LOCK_EX 2 /* exclusive lock */
296#define LOCK_NB 4 /* don't block when locking */
297#define LOCK_UN 8 /* unlock */
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000298#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000299 {
300 struct flock l;
301 if (code == LOCK_UN)
302 l.l_type = F_UNLCK;
303 else if (code & LOCK_SH)
304 l.l_type = F_RDLCK;
305 else if (code & LOCK_EX)
306 l.l_type = F_WRLCK;
307 else {
308 PyErr_SetString(PyExc_ValueError,
309 "unrecognized flock argument");
310 return NULL;
311 }
312 l.l_whence = l.l_start = l.l_len = 0;
313 Py_BEGIN_ALLOW_THREADS
314 ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
315 Py_END_ALLOW_THREADS
316 }
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000317#endif /* HAVE_FLOCK */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000318 if (ret < 0) {
319 PyErr_SetFromErrno(PyExc_IOError);
320 return NULL;
321 }
Brett Cannonb7299dd2014-11-09 20:22:01 -0500322 Py_RETURN_NONE;
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000323}
324
Guido van Rossum185ead61998-11-23 15:32:55 +0000325
Brett Cannonb7299dd2014-11-09 20:22:01 -0500326/*[clinic input]
327fcntl.lockf
Guido van Rossum185ead61998-11-23 15:32:55 +0000328
Brett Cannonb7299dd2014-11-09 20:22:01 -0500329 fd: object(type='int', converter='conv_descriptor')
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200330 cmd as code: int
331 len as lenobj: object(c_default='NULL') = 0
332 start as startobj: object(c_default='NULL') = 0
Brett Cannonb7299dd2014-11-09 20:22:01 -0500333 whence: int = 0
334 /
335
336A wrapper around the fcntl() locking calls.
337
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200338`fd` is the file descriptor of the file to lock or unlock, and operation is one
Brett Cannonb7299dd2014-11-09 20:22:01 -0500339of the following values:
340
341 LOCK_UN - unlock
342 LOCK_SH - acquire a shared lock
343 LOCK_EX - acquire an exclusive lock
344
345When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with
346LOCK_NB to avoid blocking on lock acquisition. If LOCK_NB is used and the
347lock cannot be acquired, an IOError will be raised and the exception will
348have an errno attribute set to EACCES or EAGAIN (depending on the operating
349system -- for portability, check for either value).
350
Serhiy Storchaka17d3a582015-03-20 20:04:21 +0200351`len` is the number of bytes to lock, with the default meaning to lock to
352EOF. `start` is the byte offset, relative to `whence`, to that the lock
353starts. `whence` is as with fileobj.seek(), specifically:
Brett Cannonb7299dd2014-11-09 20:22:01 -0500354
355 0 - relative to the start of the file (SEEK_SET)
356 1 - relative to the current buffer position (SEEK_CUR)
357 2 - relative to the end of the file (SEEK_END)
358[clinic start generated code]*/
359
Roger E. Masse919213a1996-12-17 17:42:22 +0000360static PyObject *
Larry Hastings89964c42015-04-14 18:07:59 -0400361fcntl_lockf_impl(PyModuleDef *module, int fd, int code, PyObject *lenobj,
362 PyObject *startobj, int whence)
363/*[clinic end generated code: output=31af35eba08b9af7 input=9c594391de821f24]*/
Guido van Rossumc8643641996-09-11 23:17:20 +0000364{
Brett Cannonb7299dd2014-11-09 20:22:01 -0500365 int ret;
Guido van Rossumc8643641996-09-11 23:17:20 +0000366
Guido van Rossumc8643641996-09-11 23:17:20 +0000367#ifndef LOCK_SH
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000368#define LOCK_SH 1 /* shared lock */
369#define LOCK_EX 2 /* exclusive lock */
370#define LOCK_NB 4 /* don't block when locking */
371#define LOCK_UN 8 /* unlock */
Andrew MacIntyre7bf68332002-03-03 02:59:16 +0000372#endif /* LOCK_SH */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000373 {
374 struct flock l;
375 if (code == LOCK_UN)
376 l.l_type = F_UNLCK;
377 else if (code & LOCK_SH)
378 l.l_type = F_RDLCK;
379 else if (code & LOCK_EX)
380 l.l_type = F_WRLCK;
381 else {
382 PyErr_SetString(PyExc_ValueError,
383 "unrecognized lockf argument");
384 return NULL;
385 }
386 l.l_start = l.l_len = 0;
387 if (startobj != NULL) {
Guido van Rossum056bad91999-01-06 18:44:23 +0000388#if !defined(HAVE_LARGEFILE_SUPPORT)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000389 l.l_start = PyLong_AsLong(startobj);
Guido van Rossum056bad91999-01-06 18:44:23 +0000390#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000391 l.l_start = PyLong_Check(startobj) ?
392 PyLong_AsLongLong(startobj) :
393 PyLong_AsLong(startobj);
Guido van Rossum056bad91999-01-06 18:44:23 +0000394#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000395 if (PyErr_Occurred())
396 return NULL;
397 }
398 if (lenobj != NULL) {
Guido van Rossum056bad91999-01-06 18:44:23 +0000399#if !defined(HAVE_LARGEFILE_SUPPORT)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000400 l.l_len = PyLong_AsLong(lenobj);
Guido van Rossum056bad91999-01-06 18:44:23 +0000401#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000402 l.l_len = PyLong_Check(lenobj) ?
403 PyLong_AsLongLong(lenobj) :
404 PyLong_AsLong(lenobj);
Guido van Rossum056bad91999-01-06 18:44:23 +0000405#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000406 if (PyErr_Occurred())
407 return NULL;
408 }
409 l.l_whence = whence;
410 Py_BEGIN_ALLOW_THREADS
411 ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
412 Py_END_ALLOW_THREADS
413 }
414 if (ret < 0) {
415 PyErr_SetFromErrno(PyExc_IOError);
416 return NULL;
417 }
Brett Cannonb7299dd2014-11-09 20:22:01 -0500418 Py_RETURN_NONE;
Guido van Rossumc8643641996-09-11 23:17:20 +0000419}
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000420
Guido van Rossum02975121992-08-17 08:55:12 +0000421/* List of functions */
422
Roger E. Masse919213a1996-12-17 17:42:22 +0000423static PyMethodDef fcntl_methods[] = {
Brett Cannonb7299dd2014-11-09 20:22:01 -0500424 FCNTL_FCNTL_METHODDEF
425 FCNTL_IOCTL_METHODDEF
426 FCNTL_FLOCK_METHODDEF
427 FCNTL_LOCKF_METHODDEF
428 {NULL, NULL} /* sentinel */
Guido van Rossum02975121992-08-17 08:55:12 +0000429};
430
431
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000432PyDoc_STRVAR(module_doc,
Guido van Rossum185ead61998-11-23 15:32:55 +0000433"This module performs file control and I/O control on file \n\
434descriptors. It is an interface to the fcntl() and ioctl() Unix\n\
435routines. File descriptors can be obtained with the fileno() method of\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000436a file or socket object.");
Guido van Rossum185ead61998-11-23 15:32:55 +0000437
Guido van Rossum02975121992-08-17 08:55:12 +0000438/* Module initialisation */
439
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000440
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000441static int
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200442all_ins(PyObject* m)
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000443{
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200444 if (PyModule_AddIntMacro(m, LOCK_SH)) return -1;
445 if (PyModule_AddIntMacro(m, LOCK_EX)) return -1;
446 if (PyModule_AddIntMacro(m, LOCK_NB)) return -1;
447 if (PyModule_AddIntMacro(m, LOCK_UN)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000448/* GNU extensions, as of glibc 2.2.4 */
449#ifdef LOCK_MAND
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200450 if (PyModule_AddIntMacro(m, LOCK_MAND)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000451#endif
452#ifdef LOCK_READ
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200453 if (PyModule_AddIntMacro(m, LOCK_READ)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000454#endif
455#ifdef LOCK_WRITE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200456 if (PyModule_AddIntMacro(m, LOCK_WRITE)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000457#endif
458#ifdef LOCK_RW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200459 if (PyModule_AddIntMacro(m, LOCK_RW)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000460#endif
461
Fred Drake152a25e2001-05-09 21:02:02 +0000462#ifdef F_DUPFD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200463 if (PyModule_AddIntMacro(m, F_DUPFD)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000464#endif
Victor Stinner2716d532013-01-08 00:52:40 +0100465#ifdef F_DUPFD_CLOEXEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200466 if (PyModule_AddIntMacro(m, F_DUPFD_CLOEXEC)) return -1;
Victor Stinner2716d532013-01-08 00:52:40 +0100467#endif
Fred Drake152a25e2001-05-09 21:02:02 +0000468#ifdef F_GETFD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200469 if (PyModule_AddIntMacro(m, F_GETFD)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000470#endif
471#ifdef F_SETFD
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200472 if (PyModule_AddIntMacro(m, F_SETFD)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000473#endif
474#ifdef F_GETFL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200475 if (PyModule_AddIntMacro(m, F_GETFL)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000476#endif
477#ifdef F_SETFL
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200478 if (PyModule_AddIntMacro(m, F_SETFL)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000479#endif
480#ifdef F_GETLK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200481 if (PyModule_AddIntMacro(m, F_GETLK)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000482#endif
483#ifdef F_SETLK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200484 if (PyModule_AddIntMacro(m, F_SETLK)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000485#endif
486#ifdef F_SETLKW
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200487 if (PyModule_AddIntMacro(m, F_SETLKW)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000488#endif
489#ifdef F_GETOWN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200490 if (PyModule_AddIntMacro(m, F_GETOWN)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000491#endif
492#ifdef F_SETOWN
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200493 if (PyModule_AddIntMacro(m, F_SETOWN)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000494#endif
495#ifdef F_GETSIG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200496 if (PyModule_AddIntMacro(m, F_GETSIG)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000497#endif
498#ifdef F_SETSIG
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200499 if (PyModule_AddIntMacro(m, F_SETSIG)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000500#endif
501#ifdef F_RDLCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200502 if (PyModule_AddIntMacro(m, F_RDLCK)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000503#endif
504#ifdef F_WRLCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200505 if (PyModule_AddIntMacro(m, F_WRLCK)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000506#endif
507#ifdef F_UNLCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200508 if (PyModule_AddIntMacro(m, F_UNLCK)) return -1;
Fred Drake152a25e2001-05-09 21:02:02 +0000509#endif
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000510/* LFS constants */
511#ifdef F_GETLK64
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200512 if (PyModule_AddIntMacro(m, F_GETLK64)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000513#endif
514#ifdef F_SETLK64
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200515 if (PyModule_AddIntMacro(m, F_SETLK64)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000516#endif
517#ifdef F_SETLKW64
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200518 if (PyModule_AddIntMacro(m, F_SETLKW64)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000519#endif
520/* GNU extensions, as of glibc 2.2.4. */
Alexandre Vassalottibee32532008-05-16 18:15:12 +0000521#ifdef FASYNC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200522 if (PyModule_AddIntMacro(m, FASYNC)) return -1;
Alexandre Vassalottibee32532008-05-16 18:15:12 +0000523#endif
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000524#ifdef F_SETLEASE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200525 if (PyModule_AddIntMacro(m, F_SETLEASE)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000526#endif
527#ifdef F_GETLEASE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200528 if (PyModule_AddIntMacro(m, F_GETLEASE)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000529#endif
530#ifdef F_NOTIFY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200531 if (PyModule_AddIntMacro(m, F_NOTIFY)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000532#endif
533/* Old BSD flock(). */
534#ifdef F_EXLCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200535 if (PyModule_AddIntMacro(m, F_EXLCK)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000536#endif
537#ifdef F_SHLCK
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200538 if (PyModule_AddIntMacro(m, F_SHLCK)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000539#endif
540
Charles-François Natali23e1ecb2011-11-02 18:58:25 +0100541/* OS X specifics */
Georg Brandl6aa2d1f2008-08-12 08:35:52 +0000542#ifdef F_FULLFSYNC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200543 if (PyModule_AddIntMacro(m, F_FULLFSYNC)) return -1;
Georg Brandl6aa2d1f2008-08-12 08:35:52 +0000544#endif
Charles-François Natali23e1ecb2011-11-02 18:58:25 +0100545#ifdef F_NOCACHE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200546 if (PyModule_AddIntMacro(m, F_NOCACHE)) return -1;
Charles-François Natali23e1ecb2011-11-02 18:58:25 +0100547#endif
Georg Brandl6aa2d1f2008-08-12 08:35:52 +0000548
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000549/* For F_{GET|SET}FL */
550#ifdef FD_CLOEXEC
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200551 if (PyModule_AddIntMacro(m, FD_CLOEXEC)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000552#endif
553
554/* For F_NOTIFY */
555#ifdef DN_ACCESS
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200556 if (PyModule_AddIntMacro(m, DN_ACCESS)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000557#endif
558#ifdef DN_MODIFY
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200559 if (PyModule_AddIntMacro(m, DN_MODIFY)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000560#endif
561#ifdef DN_CREATE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200562 if (PyModule_AddIntMacro(m, DN_CREATE)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000563#endif
564#ifdef DN_DELETE
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200565 if (PyModule_AddIntMacro(m, DN_DELETE)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000566#endif
567#ifdef DN_RENAME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200568 if (PyModule_AddIntMacro(m, DN_RENAME)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000569#endif
570#ifdef DN_ATTRIB
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200571 if (PyModule_AddIntMacro(m, DN_ATTRIB)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000572#endif
573#ifdef DN_MULTISHOT
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200574 if (PyModule_AddIntMacro(m, DN_MULTISHOT)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000575#endif
576
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000577#ifdef HAVE_STROPTS_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000578 /* Unix 98 guarantees that these are in stropts.h. */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200579 if (PyModule_AddIntMacro(m, I_PUSH)) return -1;
580 if (PyModule_AddIntMacro(m, I_POP)) return -1;
581 if (PyModule_AddIntMacro(m, I_LOOK)) return -1;
582 if (PyModule_AddIntMacro(m, I_FLUSH)) return -1;
583 if (PyModule_AddIntMacro(m, I_FLUSHBAND)) return -1;
584 if (PyModule_AddIntMacro(m, I_SETSIG)) return -1;
585 if (PyModule_AddIntMacro(m, I_GETSIG)) return -1;
586 if (PyModule_AddIntMacro(m, I_FIND)) return -1;
587 if (PyModule_AddIntMacro(m, I_PEEK)) return -1;
588 if (PyModule_AddIntMacro(m, I_SRDOPT)) return -1;
589 if (PyModule_AddIntMacro(m, I_GRDOPT)) return -1;
590 if (PyModule_AddIntMacro(m, I_NREAD)) return -1;
591 if (PyModule_AddIntMacro(m, I_FDINSERT)) return -1;
592 if (PyModule_AddIntMacro(m, I_STR)) return -1;
593 if (PyModule_AddIntMacro(m, I_SWROPT)) return -1;
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000594#ifdef I_GWROPT
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000595 /* despite the comment above, old-ish glibcs miss a couple... */
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200596 if (PyModule_AddIntMacro(m, I_GWROPT)) return -1;
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000597#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200598 if (PyModule_AddIntMacro(m, I_SENDFD)) return -1;
599 if (PyModule_AddIntMacro(m, I_RECVFD)) return -1;
600 if (PyModule_AddIntMacro(m, I_LIST)) return -1;
601 if (PyModule_AddIntMacro(m, I_ATMARK)) return -1;
602 if (PyModule_AddIntMacro(m, I_CKBAND)) return -1;
603 if (PyModule_AddIntMacro(m, I_GETBAND)) return -1;
604 if (PyModule_AddIntMacro(m, I_CANPUT)) return -1;
605 if (PyModule_AddIntMacro(m, I_SETCLTIME)) return -1;
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000606#ifdef I_GETCLTIME
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200607 if (PyModule_AddIntMacro(m, I_GETCLTIME)) return -1;
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000608#endif
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200609 if (PyModule_AddIntMacro(m, I_LINK)) return -1;
610 if (PyModule_AddIntMacro(m, I_UNLINK)) return -1;
611 if (PyModule_AddIntMacro(m, I_PLINK)) return -1;
612 if (PyModule_AddIntMacro(m, I_PUNLINK)) return -1;
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000613#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000614
615 return 0;
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000616}
617
Martin v. Löwis1a214512008-06-11 05:26:20 +0000618
619static struct PyModuleDef fcntlmodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000620 PyModuleDef_HEAD_INIT,
621 "fcntl",
622 module_doc,
623 -1,
624 fcntl_methods,
625 NULL,
626 NULL,
627 NULL,
628 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +0000629};
630
Mark Hammondfe51c6d2002-08-02 02:27:13 +0000631PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +0000632PyInit_fcntl(void)
Guido van Rossum02975121992-08-17 08:55:12 +0000633{
Charles-Francois Natali74ca8862013-05-20 19:13:19 +0200634 PyObject *m;
Guido van Rossum02975121992-08-17 08:55:12 +0000635
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000636 /* Create the module and add the functions and documentation */
637 m = PyModule_Create(&fcntlmodule);
638 if (m == NULL)
639 return NULL;
Guido van Rossum02975121992-08-17 08:55:12 +0000640
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000641 /* Add some symbolic constants to the module */
Charles-François Natali5abca142013-12-01 14:30:47 +0100642 if (all_ins(m) < 0)
643 return NULL;
644
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000645 return m;
Guido van Rossum02975121992-08-17 08:55:12 +0000646}