blob: 4197339e2f18edc8b9d1b9e4b3988e95f438cb16 [file] [log] [blame]
Guido van Rossum02975121992-08-17 08:55:12 +00001
2/* fcntl module */
3
Roger E. Masse919213a1996-12-17 17:42:22 +00004#include "Python.h"
Guido van Rossum02975121992-08-17 08:55:12 +00005
Guido van Rossuma376cc51996-12-05 23:43:35 +00006#ifdef HAVE_SYS_FILE_H
7#include <sys/file.h>
8#endif
9
Guido van Rossum3d65fa31996-12-09 18:49:14 +000010#include <sys/ioctl.h>
Guido van Rossum3c0b79c1996-06-11 15:11:34 +000011#include <fcntl.h>
Martin v. Löwis14e73b12003-01-01 09:51:12 +000012#ifdef HAVE_STROPTS_H
13#include <stropts.h>
14#endif
Guido van Rossum02975121992-08-17 08:55:12 +000015
Fred Drake152a25e2001-05-09 21:02:02 +000016static int
17conv_descriptor(PyObject *object, int *target)
18{
19 int fd = PyObject_AsFileDescriptor(object);
20
21 if (fd < 0)
22 return 0;
23 *target = fd;
24 return 1;
25}
26
27
Guido van Rossum02975121992-08-17 08:55:12 +000028/* fcntl(fd, opt, [arg]) */
29
Roger E. Masse919213a1996-12-17 17:42:22 +000030static PyObject *
Peter Schneider-Kamp8bc8f0d2000-07-10 17:15:07 +000031fcntl_fcntl(PyObject *self, PyObject *args)
Guido van Rossum02975121992-08-17 08:55:12 +000032{
33 int fd;
34 int code;
35 int arg;
36 int ret;
37 char *str;
38 int len;
39 char buf[1024];
40
Fred Drake152a25e2001-05-09 21:02:02 +000041 if (PyArg_ParseTuple(args, "O&is#:fcntl",
42 conv_descriptor, &fd, &code, &str, &len)) {
Guido van Rossum02975121992-08-17 08:55:12 +000043 if (len > sizeof buf) {
Roger E. Masse919213a1996-12-17 17:42:22 +000044 PyErr_SetString(PyExc_ValueError,
45 "fcntl string arg too long");
Guido van Rossum02975121992-08-17 08:55:12 +000046 return NULL;
47 }
48 memcpy(buf, str, len);
Roger E. Masse919213a1996-12-17 17:42:22 +000049 Py_BEGIN_ALLOW_THREADS
Guido van Rossum903f4871995-10-07 19:18:22 +000050 ret = fcntl(fd, code, buf);
Roger E. Masse919213a1996-12-17 17:42:22 +000051 Py_END_ALLOW_THREADS
Guido van Rossum903f4871995-10-07 19:18:22 +000052 if (ret < 0) {
Roger E. Masse919213a1996-12-17 17:42:22 +000053 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum02975121992-08-17 08:55:12 +000054 return NULL;
55 }
Roger E. Masse919213a1996-12-17 17:42:22 +000056 return PyString_FromStringAndSize(buf, len);
Guido van Rossum02975121992-08-17 08:55:12 +000057 }
58
Roger E. Masse919213a1996-12-17 17:42:22 +000059 PyErr_Clear();
Guido van Rossuma2214c32000-08-02 20:46:51 +000060 arg = 0;
Fred Drake152a25e2001-05-09 21:02:02 +000061 if (!PyArg_ParseTuple(args,
62 "O&i|i;fcntl requires a file or file descriptor,"
63 " an integer and optionally a third integer or a string",
64 conv_descriptor, &fd, &code, &arg)) {
Guido van Rossuma2214c32000-08-02 20:46:51 +000065 return NULL;
Guido van Rossum02975121992-08-17 08:55:12 +000066 }
Roger E. Masse919213a1996-12-17 17:42:22 +000067 Py_BEGIN_ALLOW_THREADS
Guido van Rossum02975121992-08-17 08:55:12 +000068 ret = fcntl(fd, code, arg);
Roger E. Masse919213a1996-12-17 17:42:22 +000069 Py_END_ALLOW_THREADS
Guido van Rossum02975121992-08-17 08:55:12 +000070 if (ret < 0) {
Roger E. Masse919213a1996-12-17 17:42:22 +000071 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum02975121992-08-17 08:55:12 +000072 return NULL;
73 }
Roger E. Masse919213a1996-12-17 17:42:22 +000074 return PyInt_FromLong((long)ret);
Guido van Rossum02975121992-08-17 08:55:12 +000075}
76
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000077PyDoc_STRVAR(fcntl_doc,
Guido van Rossum185ead61998-11-23 15:32:55 +000078"fcntl(fd, opt, [arg])\n\
79\n\
80Perform the requested operation on file descriptor fd. The operation\n\
Fred Drake1d531992001-05-10 15:54:32 +000081is defined by op and is operating system dependent. These constants are\n\
82available from the fcntl module. The argument arg is optional, and\n\
83defaults to 0; it may be an int or a string. If arg is given as a string,\n\
84the return value of fcntl is a string of that length, containing the\n\
85resulting value put in the arg buffer by the operating system.The length\n\
86of the arg string is not allowed to exceed 1024 bytes. If the arg given\n\
87is an integer or if none is specified, the result value is an integer\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000088corresponding to the return value of the fcntl call in the C code.");
Guido van Rossum185ead61998-11-23 15:32:55 +000089
Guido van Rossum02975121992-08-17 08:55:12 +000090
91/* ioctl(fd, opt, [arg]) */
92
Roger E. Masse919213a1996-12-17 17:42:22 +000093static PyObject *
Peter Schneider-Kamp8bc8f0d2000-07-10 17:15:07 +000094fcntl_ioctl(PyObject *self, PyObject *args)
Guido van Rossum02975121992-08-17 08:55:12 +000095{
96 int fd;
97 int code;
98 int arg;
99 int ret;
100 char *str;
101 int len;
Michael W. Hudson02d74f62004-11-30 14:31:54 +0000102 int mutate_arg = 1;
Guido van Rossum02975121992-08-17 08:55:12 +0000103 char buf[1024];
104
Michael W. Hudson8137bea2005-07-27 20:24:40 +0000105 if (PyArg_ParseTuple(args, "O&Iw#|i:ioctl",
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000106 conv_descriptor, &fd, &code,
107 &str, &len, &mutate_arg)) {
108 char *arg;
109
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000110 if (mutate_arg) {
111 if (len <= sizeof buf) {
112 memcpy(buf, str, len);
113 arg = buf;
114 }
115 else {
116 arg = str;
117 }
118 }
119 else {
120 if (len > sizeof buf) {
121 PyErr_SetString(PyExc_ValueError,
122 "ioctl string arg too long");
123 return NULL;
124 }
125 else {
126 memcpy(buf, str, len);
127 arg = buf;
128 }
129 }
130 if (buf == arg) {
131 Py_BEGIN_ALLOW_THREADS /* think array.resize() */
132 ret = ioctl(fd, code, arg);
133 Py_END_ALLOW_THREADS
134 }
135 else {
136 ret = ioctl(fd, code, arg);
137 }
138 if (mutate_arg && (len < sizeof buf)) {
139 memcpy(str, buf, len);
140 }
141 if (ret < 0) {
142 PyErr_SetFromErrno(PyExc_IOError);
143 return NULL;
144 }
145 if (mutate_arg) {
146 return PyInt_FromLong(ret);
147 }
148 else {
149 return PyString_FromStringAndSize(buf, len);
150 }
151 }
152
153 PyErr_Clear();
Michael W. Hudson8137bea2005-07-27 20:24:40 +0000154 if (PyArg_ParseTuple(args, "O&Is#:ioctl",
Fred Drake152a25e2001-05-09 21:02:02 +0000155 conv_descriptor, &fd, &code, &str, &len)) {
Guido van Rossum02975121992-08-17 08:55:12 +0000156 if (len > sizeof buf) {
Roger E. Masse919213a1996-12-17 17:42:22 +0000157 PyErr_SetString(PyExc_ValueError,
158 "ioctl string arg too long");
Guido van Rossum02975121992-08-17 08:55:12 +0000159 return NULL;
160 }
161 memcpy(buf, str, len);
Roger E. Masse919213a1996-12-17 17:42:22 +0000162 Py_BEGIN_ALLOW_THREADS
Guido van Rossum903f4871995-10-07 19:18:22 +0000163 ret = ioctl(fd, code, buf);
Roger E. Masse919213a1996-12-17 17:42:22 +0000164 Py_END_ALLOW_THREADS
Guido van Rossum903f4871995-10-07 19:18:22 +0000165 if (ret < 0) {
Roger E. Masse919213a1996-12-17 17:42:22 +0000166 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum02975121992-08-17 08:55:12 +0000167 return NULL;
168 }
Roger E. Masse919213a1996-12-17 17:42:22 +0000169 return PyString_FromStringAndSize(buf, len);
Guido van Rossum02975121992-08-17 08:55:12 +0000170 }
171
Roger E. Masse919213a1996-12-17 17:42:22 +0000172 PyErr_Clear();
Guido van Rossuma2214c32000-08-02 20:46:51 +0000173 arg = 0;
Fred Drake460f0692001-05-14 21:02:36 +0000174 if (!PyArg_ParseTuple(args,
Michael W. Hudson8137bea2005-07-27 20:24:40 +0000175 "O&I|i;ioctl requires a file or file descriptor,"
Hye-Shik Chang97bb8ad2005-07-28 05:57:19 +0000176 " an integer and optionally an integer or buffer argument",
Fred Drake152a25e2001-05-09 21:02:02 +0000177 conv_descriptor, &fd, &code, &arg)) {
Guido van Rossuma2214c32000-08-02 20:46:51 +0000178 return NULL;
Guido van Rossum02975121992-08-17 08:55:12 +0000179 }
Roger E. Masse919213a1996-12-17 17:42:22 +0000180 Py_BEGIN_ALLOW_THREADS
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +0000181#ifdef __VMS
182 ret = ioctl(fd, code, (void *)arg);
183#else
Guido van Rossum02975121992-08-17 08:55:12 +0000184 ret = ioctl(fd, code, arg);
Martin v. Löwisc16f3bd2003-05-03 09:14:54 +0000185#endif
Roger E. Masse919213a1996-12-17 17:42:22 +0000186 Py_END_ALLOW_THREADS
Guido van Rossum02975121992-08-17 08:55:12 +0000187 if (ret < 0) {
Roger E. Masse919213a1996-12-17 17:42:22 +0000188 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum02975121992-08-17 08:55:12 +0000189 return NULL;
190 }
Roger E. Masse919213a1996-12-17 17:42:22 +0000191 return PyInt_FromLong((long)ret);
Guido van Rossum02975121992-08-17 08:55:12 +0000192}
193
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000194PyDoc_STRVAR(ioctl_doc,
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000195"ioctl(fd, opt[, arg[, mutate_flag]])\n\
Guido van Rossum185ead61998-11-23 15:32:55 +0000196\n\
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000197Perform the requested operation on file descriptor fd. The operation is\n\
Neal Norwitz47308802003-06-30 01:54:04 +0000198defined by opt and is operating system dependent. Typically these codes are\n\
Michael W. Hudsonf0089982003-03-03 12:29:42 +0000199retrieved from the fcntl or termios library modules.\n\
200\n\
201The argument arg is optional, and defaults to 0; it may be an int or a\n\
202buffer containing character data (most likely a string or an array). \n\
203\n\
204If the argument is a mutable buffer (such as an array) and if the\n\
205mutate_flag argument (which is only allowed in this case) is true then the\n\
206buffer is (in effect) passed to the operating system and changes made by\n\
207the OS will be reflected in the contents of the buffer after the call has\n\
208returned. The return value is the integer returned by the ioctl system\n\
209call.\n\
210\n\
211If the argument is a mutable buffer and the mutable_flag argument is not\n\
212passed or is false, the behavior is as if a string had been passed. This\n\
213behavior will change in future releases of Python.\n\
214\n\
215If the argument is an immutable buffer (most likely a string) then a copy\n\
216of the buffer is passed to the operating system and the return value is a\n\
217string of the same length containing whatever the operating system put in\n\
218the buffer. The length of the arg buffer in this case is not allowed to\n\
219exceed 1024 bytes.\n\
220\n\
221If the arg given is an integer or if none is specified, the result value is\n\
222an integer corresponding to the return value of the ioctl call in the C\n\
223code.");
Guido van Rossum185ead61998-11-23 15:32:55 +0000224
Guido van Rossum02975121992-08-17 08:55:12 +0000225
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000226/* flock(fd, operation) */
227
Roger E. Masse919213a1996-12-17 17:42:22 +0000228static PyObject *
Peter Schneider-Kamp8bc8f0d2000-07-10 17:15:07 +0000229fcntl_flock(PyObject *self, PyObject *args)
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000230{
231 int fd;
232 int code;
233 int ret;
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000234
Fred Drake152a25e2001-05-09 21:02:02 +0000235 if (!PyArg_ParseTuple(args, "O&i:flock",
236 conv_descriptor, &fd, &code))
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000237 return NULL;
238
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000239#ifdef HAVE_FLOCK
Guido van Rossum056bad91999-01-06 18:44:23 +0000240 Py_BEGIN_ALLOW_THREADS
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000241 ret = flock(fd, code);
Guido van Rossum056bad91999-01-06 18:44:23 +0000242 Py_END_ALLOW_THREADS
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000243#else
244
245#ifndef LOCK_SH
246#define LOCK_SH 1 /* shared lock */
247#define LOCK_EX 2 /* exclusive lock */
248#define LOCK_NB 4 /* don't block when locking */
249#define LOCK_UN 8 /* unlock */
250#endif
251 {
252 struct flock l;
253 if (code == LOCK_UN)
254 l.l_type = F_UNLCK;
255 else if (code & LOCK_SH)
256 l.l_type = F_RDLCK;
257 else if (code & LOCK_EX)
258 l.l_type = F_WRLCK;
259 else {
Roger E. Masse919213a1996-12-17 17:42:22 +0000260 PyErr_SetString(PyExc_ValueError,
261 "unrecognized flock argument");
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000262 return NULL;
263 }
264 l.l_whence = l.l_start = l.l_len = 0;
Guido van Rossum056bad91999-01-06 18:44:23 +0000265 Py_BEGIN_ALLOW_THREADS
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000266 ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
Guido van Rossum056bad91999-01-06 18:44:23 +0000267 Py_END_ALLOW_THREADS
Guido van Rossum3c0b79c1996-06-11 15:11:34 +0000268 }
269#endif /* HAVE_FLOCK */
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000270 if (ret < 0) {
Roger E. Masse919213a1996-12-17 17:42:22 +0000271 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000272 return NULL;
273 }
Roger E. Masse919213a1996-12-17 17:42:22 +0000274 Py_INCREF(Py_None);
275 return Py_None;
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000276}
277
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000278PyDoc_STRVAR(flock_doc,
Guido van Rossum185ead61998-11-23 15:32:55 +0000279"flock(fd, operation)\n\
280\n\
281Perform the lock operation op on file descriptor fd. See the Unix \n\
282manual flock(3) for details. (On some systems, this function is\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000283emulated using fcntl().)");
Guido van Rossum185ead61998-11-23 15:32:55 +0000284
285
Guido van Rossumc8643641996-09-11 23:17:20 +0000286/* lockf(fd, operation) */
Roger E. Masse919213a1996-12-17 17:42:22 +0000287static PyObject *
Peter Schneider-Kamp8bc8f0d2000-07-10 17:15:07 +0000288fcntl_lockf(PyObject *self, PyObject *args)
Guido van Rossumc8643641996-09-11 23:17:20 +0000289{
Guido van Rossum056bad91999-01-06 18:44:23 +0000290 int fd, code, ret, whence = 0;
291 PyObject *lenobj = NULL, *startobj = NULL;
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000292
Fred Drake152a25e2001-05-09 21:02:02 +0000293 if (!PyArg_ParseTuple(args, "O&i|OOi:lockf",
294 conv_descriptor, &fd, &code,
Guido van Rossum056bad91999-01-06 18:44:23 +0000295 &lenobj, &startobj, &whence))
Guido van Rossumc8643641996-09-11 23:17:20 +0000296 return NULL;
297
Andrew MacIntyre7bf68332002-03-03 02:59:16 +0000298#if defined(PYOS_OS2) && defined(PYCC_GCC)
299 PyErr_SetString(PyExc_NotImplementedError,
300 "lockf not supported on OS/2 (EMX)");
301 return NULL;
302#else
Guido van Rossumc8643641996-09-11 23:17:20 +0000303#ifndef LOCK_SH
304#define LOCK_SH 1 /* shared lock */
305#define LOCK_EX 2 /* exclusive lock */
306#define LOCK_NB 4 /* don't block when locking */
307#define LOCK_UN 8 /* unlock */
Andrew MacIntyre7bf68332002-03-03 02:59:16 +0000308#endif /* LOCK_SH */
Guido van Rossumc8643641996-09-11 23:17:20 +0000309 {
310 struct flock l;
311 if (code == LOCK_UN)
312 l.l_type = F_UNLCK;
313 else if (code & LOCK_SH)
314 l.l_type = F_RDLCK;
315 else if (code & LOCK_EX)
316 l.l_type = F_WRLCK;
317 else {
Roger E. Masse919213a1996-12-17 17:42:22 +0000318 PyErr_SetString(PyExc_ValueError,
319 "unrecognized flock argument");
Guido van Rossumc8643641996-09-11 23:17:20 +0000320 return NULL;
321 }
Guido van Rossum056bad91999-01-06 18:44:23 +0000322 l.l_start = l.l_len = 0;
323 if (startobj != NULL) {
324#if !defined(HAVE_LARGEFILE_SUPPORT)
325 l.l_start = PyInt_AsLong(startobj);
326#else
327 l.l_start = PyLong_Check(startobj) ?
328 PyLong_AsLongLong(startobj) :
329 PyInt_AsLong(startobj);
330#endif
331 if (PyErr_Occurred())
332 return NULL;
333 }
334 if (lenobj != NULL) {
335#if !defined(HAVE_LARGEFILE_SUPPORT)
336 l.l_len = PyInt_AsLong(lenobj);
337#else
338 l.l_len = PyLong_Check(lenobj) ?
339 PyLong_AsLongLong(lenobj) :
340 PyInt_AsLong(lenobj);
341#endif
342 if (PyErr_Occurred())
343 return NULL;
344 }
Guido van Rossumc8643641996-09-11 23:17:20 +0000345 l.l_whence = whence;
Guido van Rossum056bad91999-01-06 18:44:23 +0000346 Py_BEGIN_ALLOW_THREADS
Guido van Rossumc8643641996-09-11 23:17:20 +0000347 ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
Guido van Rossum056bad91999-01-06 18:44:23 +0000348 Py_END_ALLOW_THREADS
Guido van Rossumc8643641996-09-11 23:17:20 +0000349 }
Guido van Rossumc8643641996-09-11 23:17:20 +0000350 if (ret < 0) {
Roger E. Masse919213a1996-12-17 17:42:22 +0000351 PyErr_SetFromErrno(PyExc_IOError);
Guido van Rossumc8643641996-09-11 23:17:20 +0000352 return NULL;
353 }
Roger E. Masse919213a1996-12-17 17:42:22 +0000354 Py_INCREF(Py_None);
355 return Py_None;
Andrew MacIntyre7bf68332002-03-03 02:59:16 +0000356#endif /* defined(PYOS_OS2) && defined(PYCC_GCC) */
Guido van Rossumc8643641996-09-11 23:17:20 +0000357}
Guido van Rossum3539b1e1996-05-23 22:56:38 +0000358
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000359PyDoc_STRVAR(lockf_doc,
Sjoerd Mullender82e00d62001-01-25 10:10:39 +0000360"lockf (fd, operation, length=0, start=0, whence=0)\n\
361\n\
362This is essentially a wrapper around the fcntl() locking calls. fd is the\n\
363file descriptor of the file to lock or unlock, and operation is one of the\n\
364following values:\n\
365\n\
366 LOCK_UN - unlock\n\
367 LOCK_SH - acquire a shared lock\n\
368 LOCK_EX - acquire an exclusive lock\n\
369\n\
370When operation is LOCK_SH or LOCK_EX, it can also be bit-wise OR'd with\n\
371LOCK_NB to avoid blocking on lock acquisition. If LOCK_NB is used and the\n\
372lock cannot be acquired, an IOError will be raised and the exception will\n\
373have an errno attribute set to EACCES or EAGAIN (depending on the operating\n\
374system -- for portability, check for either value).\n\
375\n\
376length is the number of bytes to lock, with the default meaning to lock to\n\
377EOF. start is the byte offset, relative to whence, to that the lock\n\
378starts. whence is as with fileobj.seek(), specifically:\n\
379\n\
380 0 - relative to the start of the file (SEEK_SET)\n\
381 1 - relative to the current buffer position (SEEK_CUR)\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000382 2 - relative to the end of the file (SEEK_END)");
Guido van Rossum185ead61998-11-23 15:32:55 +0000383
Guido van Rossum02975121992-08-17 08:55:12 +0000384/* List of functions */
385
Roger E. Masse919213a1996-12-17 17:42:22 +0000386static PyMethodDef fcntl_methods[] = {
Guido van Rossuma2214c32000-08-02 20:46:51 +0000387 {"fcntl", fcntl_fcntl, METH_VARARGS, fcntl_doc},
388 {"ioctl", fcntl_ioctl, METH_VARARGS, ioctl_doc},
389 {"flock", fcntl_flock, METH_VARARGS, flock_doc},
390 {"lockf", fcntl_lockf, METH_VARARGS, lockf_doc},
Guido van Rossum02975121992-08-17 08:55:12 +0000391 {NULL, NULL} /* sentinel */
392};
393
394
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000395PyDoc_STRVAR(module_doc,
Guido van Rossum185ead61998-11-23 15:32:55 +0000396"This module performs file control and I/O control on file \n\
397descriptors. It is an interface to the fcntl() and ioctl() Unix\n\
398routines. File descriptors can be obtained with the fileno() method of\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000399a file or socket object.");
Guido van Rossum185ead61998-11-23 15:32:55 +0000400
Guido van Rossum02975121992-08-17 08:55:12 +0000401/* Module initialisation */
402
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000403static int
Peter Schneider-Kamp8bc8f0d2000-07-10 17:15:07 +0000404ins(PyObject* d, char* symbol, long value)
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000405{
406 PyObject* v = PyInt_FromLong(value);
407 if (!v || PyDict_SetItemString(d, symbol, v) < 0)
408 return -1;
409
410 Py_DECREF(v);
411 return 0;
412}
413
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000414#define INS(x) if (ins(d, #x, (long)x)) return -1
415
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000416static int
Peter Schneider-Kamp8bc8f0d2000-07-10 17:15:07 +0000417all_ins(PyObject* d)
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000418{
419 if (ins(d, "LOCK_SH", (long)LOCK_SH)) return -1;
420 if (ins(d, "LOCK_EX", (long)LOCK_EX)) return -1;
421 if (ins(d, "LOCK_NB", (long)LOCK_NB)) return -1;
422 if (ins(d, "LOCK_UN", (long)LOCK_UN)) return -1;
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000423/* GNU extensions, as of glibc 2.2.4 */
424#ifdef LOCK_MAND
425 if (ins(d, "LOCK_MAND", (long)LOCK_MAND)) return -1;
426#endif
427#ifdef LOCK_READ
428 if (ins(d, "LOCK_READ", (long)LOCK_READ)) return -1;
429#endif
430#ifdef LOCK_WRITE
431 if (ins(d, "LOCK_WRITE", (long)LOCK_WRITE)) return -1;
432#endif
433#ifdef LOCK_RW
434 if (ins(d, "LOCK_RW", (long)LOCK_RW)) return -1;
435#endif
436
Fred Drake152a25e2001-05-09 21:02:02 +0000437#ifdef F_DUPFD
438 if (ins(d, "F_DUPFD", (long)F_DUPFD)) return -1;
439#endif
440#ifdef F_GETFD
441 if (ins(d, "F_GETFD", (long)F_GETFD)) return -1;
442#endif
443#ifdef F_SETFD
444 if (ins(d, "F_SETFD", (long)F_SETFD)) return -1;
445#endif
446#ifdef F_GETFL
447 if (ins(d, "F_GETFL", (long)F_GETFL)) return -1;
448#endif
449#ifdef F_SETFL
450 if (ins(d, "F_SETFL", (long)F_SETFL)) return -1;
451#endif
452#ifdef F_GETLK
453 if (ins(d, "F_GETLK", (long)F_GETLK)) return -1;
454#endif
455#ifdef F_SETLK
456 if (ins(d, "F_SETLK", (long)F_SETLK)) return -1;
457#endif
458#ifdef F_SETLKW
459 if (ins(d, "F_SETLKW", (long)F_SETLKW)) return -1;
460#endif
461#ifdef F_GETOWN
462 if (ins(d, "F_GETOWN", (long)F_GETOWN)) return -1;
463#endif
464#ifdef F_SETOWN
465 if (ins(d, "F_SETOWN", (long)F_SETOWN)) return -1;
466#endif
467#ifdef F_GETSIG
468 if (ins(d, "F_GETSIG", (long)F_GETSIG)) return -1;
469#endif
470#ifdef F_SETSIG
471 if (ins(d, "F_SETSIG", (long)F_SETSIG)) return -1;
472#endif
473#ifdef F_RDLCK
474 if (ins(d, "F_RDLCK", (long)F_RDLCK)) return -1;
475#endif
476#ifdef F_WRLCK
477 if (ins(d, "F_WRLCK", (long)F_WRLCK)) return -1;
478#endif
479#ifdef F_UNLCK
480 if (ins(d, "F_UNLCK", (long)F_UNLCK)) return -1;
481#endif
Martin v. Löwis1baeba62001-12-28 21:08:12 +0000482/* LFS constants */
483#ifdef F_GETLK64
484 if (ins(d, "F_GETLK64", (long)F_GETLK64)) return -1;
485#endif
486#ifdef F_SETLK64
487 if (ins(d, "F_SETLK64", (long)F_SETLK64)) return -1;
488#endif
489#ifdef F_SETLKW64
490 if (ins(d, "F_SETLKW64", (long)F_SETLKW64)) return -1;
491#endif
492/* GNU extensions, as of glibc 2.2.4. */
493#ifdef F_SETLEASE
494 if (ins(d, "F_SETLEASE", (long)F_SETLEASE)) return -1;
495#endif
496#ifdef F_GETLEASE
497 if (ins(d, "F_GETLEASE", (long)F_GETLEASE)) return -1;
498#endif
499#ifdef F_NOTIFY
500 if (ins(d, "F_NOTIFY", (long)F_NOTIFY)) return -1;
501#endif
502/* Old BSD flock(). */
503#ifdef F_EXLCK
504 if (ins(d, "F_EXLCK", (long)F_EXLCK)) return -1;
505#endif
506#ifdef F_SHLCK
507 if (ins(d, "F_SHLCK", (long)F_SHLCK)) return -1;
508#endif
509
510/* For F_{GET|SET}FL */
511#ifdef FD_CLOEXEC
512 if (ins(d, "FD_CLOEXEC", (long)FD_CLOEXEC)) return -1;
513#endif
514
515/* For F_NOTIFY */
516#ifdef DN_ACCESS
517 if (ins(d, "DN_ACCESS", (long)DN_ACCESS)) return -1;
518#endif
519#ifdef DN_MODIFY
520 if (ins(d, "DN_MODIFY", (long)DN_MODIFY)) return -1;
521#endif
522#ifdef DN_CREATE
523 if (ins(d, "DN_CREATE", (long)DN_CREATE)) return -1;
524#endif
525#ifdef DN_DELETE
526 if (ins(d, "DN_DELETE", (long)DN_DELETE)) return -1;
527#endif
528#ifdef DN_RENAME
529 if (ins(d, "DN_RENAME", (long)DN_RENAME)) return -1;
530#endif
531#ifdef DN_ATTRIB
532 if (ins(d, "DN_ATTRIB", (long)DN_ATTRIB)) return -1;
533#endif
534#ifdef DN_MULTISHOT
535 if (ins(d, "DN_MULTISHOT", (long)DN_MULTISHOT)) return -1;
536#endif
537
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000538#ifdef HAVE_STROPTS_H
539 /* Unix 98 guarantees that these are in stropts.h. */
540 INS(I_PUSH);
541 INS(I_POP);
542 INS(I_LOOK);
543 INS(I_FLUSH);
544 INS(I_FLUSHBAND);
545 INS(I_SETSIG);
546 INS(I_GETSIG);
547 INS(I_FIND);
548 INS(I_PEEK);
549 INS(I_SRDOPT);
550 INS(I_GRDOPT);
551 INS(I_NREAD);
552 INS(I_FDINSERT);
553 INS(I_STR);
554 INS(I_SWROPT);
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000555#ifdef I_GWROPT
556 /* despite the comment above, old-ish glibcs miss a couple... */
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000557 INS(I_GWROPT);
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000558#endif
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000559 INS(I_SENDFD);
560 INS(I_RECVFD);
561 INS(I_LIST);
562 INS(I_ATMARK);
563 INS(I_CKBAND);
564 INS(I_GETBAND);
565 INS(I_CANPUT);
566 INS(I_SETCLTIME);
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000567#ifdef I_GETCLTIME
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000568 INS(I_GETCLTIME);
Michael W. Hudson505c4c22003-05-09 10:45:20 +0000569#endif
Martin v. Löwis14e73b12003-01-01 09:51:12 +0000570 INS(I_LINK);
571 INS(I_UNLINK);
572 INS(I_PLINK);
573 INS(I_PUNLINK);
574#endif
575
Guido van Rossum7c141031997-08-15 02:52:08 +0000576 return 0;
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000577}
578
Mark Hammondfe51c6d2002-08-02 02:27:13 +0000579PyMODINIT_FUNC
Thomas Woutersf3f33dc2000-07-21 06:00:07 +0000580initfcntl(void)
Guido van Rossum02975121992-08-17 08:55:12 +0000581{
Roger E. Masse919213a1996-12-17 17:42:22 +0000582 PyObject *m, *d;
Guido van Rossum02975121992-08-17 08:55:12 +0000583
Guido van Rossum185ead61998-11-23 15:32:55 +0000584 /* Create the module and add the functions and documentation */
585 m = Py_InitModule3("fcntl", fcntl_methods, module_doc);
Neal Norwitz1ac754f2006-01-19 06:09:39 +0000586 if (m == NULL)
587 return;
Guido van Rossum02975121992-08-17 08:55:12 +0000588
589 /* Add some symbolic constants to the module */
Roger E. Masse919213a1996-12-17 17:42:22 +0000590 d = PyModule_GetDict(m);
Guido van Rossumf4e32c71997-07-31 19:39:54 +0000591 all_ins(d);
Guido van Rossum02975121992-08-17 08:55:12 +0000592}