← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Modules/fcntlmodule.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Modules/fcntlmodule.c
 
1
 
 
2
/* fcntl module */
 
3
 
 
4
#define PY_SSIZE_T_CLEAN
 
5
 
 
6
#include "Python.h"
 
7
 
 
8
#ifdef HAVE_SYS_FILE_H
 
9
#include <sys/file.h>
 
10
#endif
 
11
 
 
12
#include <sys/ioctl.h>
 
13
#include <fcntl.h>
 
14
#ifdef HAVE_STROPTS_H
 
15
#include <stropts.h>
 
16
#endif
 
17
 
 
18
static int
 
19
conv_descriptor(PyObject *object, int *target)
 
20
{
 
21
    int fd = PyObject_AsFileDescriptor(object);
 
22
 
 
23
    if (fd < 0)
 
24
        return 0;
 
25
    *target = fd;
 
26
    return 1;
 
27
}
 
28
 
 
29
 
 
30
/* fcntl(fd, opt, [arg]) */
 
31
 
 
32
static PyObject *
 
33
fcntl_fcntl(PyObject *self, PyObject *args)
 
34
{
 
35
        int fd;
 
36
        int code;
 
37
        int arg;
 
38
        int ret;
 
39
        char *str;
 
40
        Py_ssize_t len;
 
41
        char buf[1024];
 
42
 
 
43
        if (PyArg_ParseTuple(args, "O&is#:fcntl",
 
44
                             conv_descriptor, &fd, &code, &str, &len)) {
 
45
                if (len > sizeof buf) {
 
46
                        PyErr_SetString(PyExc_ValueError,
 
47
                                        "fcntl string arg too long");
 
48
                        return NULL;
 
49
                }
 
50
                memcpy(buf, str, len);
 
51
                Py_BEGIN_ALLOW_THREADS
 
52
                ret = fcntl(fd, code, buf);
 
53
                Py_END_ALLOW_THREADS
 
54
                if (ret < 0) {
 
55
                        PyErr_SetFromErrno(PyExc_IOError);
 
56
                        return NULL;
 
57
                }
 
58
                return PyString_FromStringAndSize(buf, len);
 
59
        }
 
60
 
 
61
        PyErr_Clear();
 
62
        arg = 0;
 
63
        if (!PyArg_ParseTuple(args,
 
64
             "O&i|i;fcntl requires a file or file descriptor,"
 
65
             " an integer and optionally a third integer or a string", 
 
66
                              conv_descriptor, &fd, &code, &arg)) {
 
67
          return NULL;
 
68
        }
 
69
        Py_BEGIN_ALLOW_THREADS
 
70
        ret = fcntl(fd, code, arg);
 
71
        Py_END_ALLOW_THREADS
 
72
        if (ret < 0) {
 
73
                PyErr_SetFromErrno(PyExc_IOError);
 
74
                return NULL;
 
75
        }
 
76
        return PyInt_FromLong((long)ret);
 
77
}
 
78
 
 
79
PyDoc_STRVAR(fcntl_doc,
 
80
"fcntl(fd, opt, [arg])\n\
 
81
\n\
 
82
Perform the requested operation on file descriptor fd.  The operation\n\
 
83
is defined by op and is operating system dependent.  These constants are\n\
 
84
available from the fcntl module.  The argument arg is optional, and\n\
 
85
defaults to 0; it may be an int or a string. If arg is given as a string,\n\
 
86
the return value of fcntl is a string of that length, containing the\n\
 
87
resulting value put in the arg buffer by the operating system.The length\n\
 
88
of the arg string is not allowed to exceed 1024 bytes. If the arg given\n\
 
89
is an integer or if none is specified, the result value is an integer\n\
 
90
corresponding to the return value of the fcntl call in the C code.");
 
91
 
 
92
 
 
93
/* ioctl(fd, opt, [arg]) */
 
94
 
 
95
static PyObject *
 
96
fcntl_ioctl(PyObject *self, PyObject *args)
 
97
{
 
98
#define IOCTL_BUFSZ 1024
 
99
        int fd;
 
100
        /* In PyArg_ParseTuple below, we use the unsigned non-checked 'I'
 
101
           format for the 'code' parameter because Python turns 0x8000000
 
102
           into either a large positive number (PyLong or PyInt on 64-bit
 
103
           platforms) or a negative number on others (32-bit PyInt)
 
104
           whereas the system expects it to be a 32bit bit field value
 
105
           regardless of it being passed as an int or unsigned long on
 
106
           various platforms.  See the termios.TIOCSWINSZ constant across
 
107
           platforms for an example of thise.
 
108
 
 
109
           If any of the 64bit platforms ever decide to use more than 32bits
 
110
           in their unsigned long ioctl codes this will break and need
 
111
           special casing based on the platform being built on.
 
112
         */
 
113
        unsigned int code;
 
114
        int arg;
 
115
        int ret;
 
116
        char *str;
 
117
        Py_ssize_t len;
 
118
        int mutate_arg = 1;
 
119
        char buf[IOCTL_BUFSZ+1];  /* argument plus NUL byte */
 
120
 
 
121
        if (PyArg_ParseTuple(args, "O&Iw#|i:ioctl",
 
122
                             conv_descriptor, &fd, &code, 
 
123
                             &str, &len, &mutate_arg)) {
 
124
                char *arg;
 
125
 
 
126
                if (mutate_arg) {
 
127
                        if (len <= IOCTL_BUFSZ) {
 
128
                                memcpy(buf, str, len);
 
129
                                buf[len] = '\0';
 
130
                                arg = buf;
 
131
                        } 
 
132
                        else {
 
133
                                arg = str;
 
134
                        }
 
135
                }
 
136
                else {
 
137
                        if (len > IOCTL_BUFSZ) {
 
138
                                PyErr_SetString(PyExc_ValueError,
 
139
                                        "ioctl string arg too long");
 
140
                                return NULL;
 
141
                        }
 
142
                        else {
 
143
                                memcpy(buf, str, len);
 
144
                                buf[len] = '\0';
 
145
                                arg = buf;
 
146
                        }
 
147
                }
 
148
                if (buf == arg) {
 
149
                        Py_BEGIN_ALLOW_THREADS /* think array.resize() */
 
150
                        ret = ioctl(fd, code, arg);
 
151
                        Py_END_ALLOW_THREADS
 
152
                }
 
153
                else {
 
154
                        ret = ioctl(fd, code, arg);
 
155
                }
 
156
                if (mutate_arg && (len < IOCTL_BUFSZ)) {
 
157
                        memcpy(str, buf, len);
 
158
                }
 
159
                if (ret < 0) {
 
160
                        PyErr_SetFromErrno(PyExc_IOError);
 
161
                        return NULL;
 
162
                }
 
163
                if (mutate_arg) {
 
164
                        return PyInt_FromLong(ret);
 
165
                }
 
166
                else {
 
167
                        return PyString_FromStringAndSize(buf, len);
 
168
                }
 
169
        }
 
170
 
 
171
        PyErr_Clear();
 
172
        if (PyArg_ParseTuple(args, "O&Is#:ioctl",
 
173
                             conv_descriptor, &fd, &code, &str, &len)) {
 
174
                if (len > IOCTL_BUFSZ) {
 
175
                        PyErr_SetString(PyExc_ValueError,
 
176
                                        "ioctl string arg too long");
 
177
                        return NULL;
 
178
                }
 
179
                memcpy(buf, str, len);
 
180
                buf[len] = '\0';
 
181
                Py_BEGIN_ALLOW_THREADS
 
182
                ret = ioctl(fd, code, buf);
 
183
                Py_END_ALLOW_THREADS
 
184
                if (ret < 0) {
 
185
                        PyErr_SetFromErrno(PyExc_IOError);
 
186
                        return NULL;
 
187
                }
 
188
                return PyString_FromStringAndSize(buf, len);
 
189
        }
 
190
 
 
191
        PyErr_Clear();
 
192
        arg = 0;
 
193
        if (!PyArg_ParseTuple(args,
 
194
             "O&I|i;ioctl requires a file or file descriptor,"
 
195
             " an integer and optionally an integer or buffer argument",
 
196
                              conv_descriptor, &fd, &code, &arg)) {
 
197
          return NULL;
 
198
        }
 
199
        Py_BEGIN_ALLOW_THREADS
 
200
#ifdef __VMS
 
201
        ret = ioctl(fd, code, (void *)arg);
 
202
#else
 
203
        ret = ioctl(fd, code, arg);
 
204
#endif
 
205
        Py_END_ALLOW_THREADS
 
206
        if (ret < 0) {
 
207
                PyErr_SetFromErrno(PyExc_IOError);
 
208
                return NULL;
 
209
        }
 
210
        return PyInt_FromLong((long)ret);
 
211
#undef IOCTL_BUFSZ
 
212
}
 
213
 
 
214
PyDoc_STRVAR(ioctl_doc,
 
215
"ioctl(fd, opt[, arg[, mutate_flag]])\n\
 
216
\n\
 
217
Perform the requested operation on file descriptor fd.  The operation is\n\
 
218
defined by opt and is operating system dependent.  Typically these codes are\n\
 
219
retrieved from the fcntl or termios library modules.\n\
 
220
\n\
 
221
The argument arg is optional, and defaults to 0; it may be an int or a\n\
 
222
buffer containing character data (most likely a string or an array). \n\
 
223
\n\
 
224
If the argument is a mutable buffer (such as an array) and if the\n\
 
225
mutate_flag argument (which is only allowed in this case) is true then the\n\
 
226
buffer is (in effect) passed to the operating system and changes made by\n\
 
227
the OS will be reflected in the contents of the buffer after the call has\n\
 
228
returned.  The return value is the integer returned by the ioctl system\n\
 
229
call.\n\
 
230
\n\
 
231
If the argument is a mutable buffer and the mutable_flag argument is not\n\
 
232
passed or is false, the behavior is as if a string had been passed.  This\n\
 
233
behavior will change in future releases of Python.\n\
 
234
\n\
 
235
If the argument is an immutable buffer (most likely a string) then a copy\n\
 
236
of the buffer is passed to the operating system and the return value is a\n\
 
237
string of the same length containing whatever the operating system put in\n\
 
238
the buffer.  The length of the arg buffer in this case is not allowed to\n\
 
239
exceed 1024 bytes.\n\
 
240
\n\
 
241
If the arg given is an integer or if none is specified, the result value is\n\
 
242
an integer corresponding to the return value of the ioctl call in the C\n\
 
243
code.");
 
244
 
 
245
 
 
246
/* flock(fd, operation) */
 
247
 
 
248
static PyObject *
 
249
fcntl_flock(PyObject *self, PyObject *args)
 
250
{
 
251
        int fd;
 
252
        int code;
 
253
        int ret;
 
254
 
 
255
        if (!PyArg_ParseTuple(args, "O&i:flock",
 
256
                              conv_descriptor, &fd, &code))
 
257
                return NULL;
 
258
 
 
259
#ifdef HAVE_FLOCK
 
260
        Py_BEGIN_ALLOW_THREADS
 
261
        ret = flock(fd, code);
 
262
        Py_END_ALLOW_THREADS
 
263
#else
 
264
 
 
265
#ifndef LOCK_SH
 
266
#define LOCK_SH         1       /* shared lock */
 
267
#define LOCK_EX         2       /* exclusive lock */
 
268
#define LOCK_NB         4       /* don't block when locking */
 
269
#define LOCK_UN         8       /* unlock */
 
270
#endif
 
271
        {
 
272
                struct flock l;
 
273
                if (code == LOCK_UN)
 
274
                        l.l_type = F_UNLCK;
 
275
                else if (code & LOCK_SH)
 
276
                        l.l_type = F_RDLCK;
 
277
                else if (code & LOCK_EX)
 
278
                        l.l_type = F_WRLCK;
 
279
                else {
 
280
                        PyErr_SetString(PyExc_ValueError,
 
281
                                        "unrecognized flock argument");
 
282
                        return NULL;
 
283
                }
 
284
                l.l_whence = l.l_start = l.l_len = 0;
 
285
                Py_BEGIN_ALLOW_THREADS
 
286
                ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
 
287
                Py_END_ALLOW_THREADS
 
288
        }
 
289
#endif /* HAVE_FLOCK */
 
290
        if (ret < 0) {
 
291
                PyErr_SetFromErrno(PyExc_IOError);
 
292
                return NULL;
 
293
        }
 
294
        Py_INCREF(Py_None);
 
295
        return Py_None;
 
296
}
 
297
 
 
298
PyDoc_STRVAR(flock_doc,
 
299
"flock(fd, operation)\n\
 
300
\n\
 
301
Perform the lock operation op on file descriptor fd.  See the Unix \n\
 
302
manual page for flock(3) for details.  (On some systems, this function is\n\
 
303
emulated using fcntl().)");
 
304
 
 
305
 
 
306
/* lockf(fd, operation) */
 
307
static PyObject *
 
308
fcntl_lockf(PyObject *self, PyObject *args)
 
309
{
 
310
        int fd, code, ret, whence = 0;
 
311
        PyObject *lenobj = NULL, *startobj = NULL;
 
312
 
 
313
        if (!PyArg_ParseTuple(args, "O&i|OOi:lockf",
 
314
                              conv_descriptor, &fd, &code,
 
315
                              &lenobj, &startobj, &whence))
 
316
            return NULL;
 
317
 
 
318
#if defined(PYOS_OS2) && defined(PYCC_GCC)
 
319
        PyErr_SetString(PyExc_NotImplementedError,
 
320
                        "lockf not supported on OS/2 (EMX)");
 
321
        return NULL;
 
322
#else
 
323
#ifndef LOCK_SH
 
324
#define LOCK_SH         1       /* shared lock */
 
325
#define LOCK_EX         2       /* exclusive lock */
 
326
#define LOCK_NB         4       /* don't block when locking */
 
327
#define LOCK_UN         8       /* unlock */
 
328
#endif  /* LOCK_SH */
 
329
        {
 
330
                struct flock l;
 
331
                if (code == LOCK_UN)
 
332
                        l.l_type = F_UNLCK;
 
333
                else if (code & LOCK_SH)
 
334
                        l.l_type = F_RDLCK;
 
335
                else if (code & LOCK_EX)
 
336
                        l.l_type = F_WRLCK;
 
337
                else {
 
338
                        PyErr_SetString(PyExc_ValueError,
 
339
                                        "unrecognized lockf argument");
 
340
                        return NULL;
 
341
                }
 
342
                l.l_start = l.l_len = 0;
 
343
                if (startobj != NULL) {
 
344
#if !defined(HAVE_LARGEFILE_SUPPORT)
 
345
                        l.l_start = PyInt_AsLong(startobj);
 
346
#else
 
347
                        l.l_start = PyLong_Check(startobj) ?
 
348
                                        PyLong_AsLongLong(startobj) :
 
349
                                        PyInt_AsLong(startobj);
 
350
#endif
 
351
                        if (PyErr_Occurred())
 
352
                                return NULL;
 
353
                }
 
354
                if (lenobj != NULL) {
 
355
#if !defined(HAVE_LARGEFILE_SUPPORT)
 
356
                        l.l_len = PyInt_AsLong(lenobj);
 
357
#else
 
358
                        l.l_len = PyLong_Check(lenobj) ?
 
359
                                        PyLong_AsLongLong(lenobj) :
 
360
                                        PyInt_AsLong(lenobj);
 
361
#endif
 
362
                        if (PyErr_Occurred())
 
363
                                return NULL;
 
364
                }
 
365
                l.l_whence = whence;
 
366
                Py_BEGIN_ALLOW_THREADS
 
367
                ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
 
368
                Py_END_ALLOW_THREADS
 
369
        }
 
370
        if (ret < 0) {
 
371
                PyErr_SetFromErrno(PyExc_IOError);
 
372
                return NULL;
 
373
        }
 
374
        Py_INCREF(Py_None);
 
375
        return Py_None;
 
376
#endif  /* defined(PYOS_OS2) && defined(PYCC_GCC) */
 
377
}
 
378
 
 
379
PyDoc_STRVAR(lockf_doc,
 
380
"lockf (fd, operation, length=0, start=0, whence=0)\n\
 
381
\n\
 
382
This is essentially a wrapper around the fcntl() locking calls.  fd is the\n\
 
383
file descriptor of the file to lock or unlock, and operation is one of the\n\
 
384
following values:\n\
 
385
\n\
 
386
    LOCK_UN - unlock\n\
 
387
    LOCK_SH - acquire a shared lock\n\
 
388
    LOCK_EX - acquire an exclusive lock\n\
 
389
\n\
 
390
When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\n\
 
391
LOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and the\n\
 
392
lock cannot be acquired, an IOError will be raised and the exception will\n\
 
393
have an errno attribute set to EACCES or EAGAIN (depending on the operating\n\
 
394
system -- for portability, check for either value).\n\
 
395
\n\
 
396
length is the number of bytes to lock, with the default meaning to lock to\n\
 
397
EOF.  start is the byte offset, relative to whence, to that the lock\n\
 
398
starts.  whence is as with fileobj.seek(), specifically:\n\
 
399
\n\
 
400
    0 - relative to the start of the file (SEEK_SET)\n\
 
401
    1 - relative to the current buffer position (SEEK_CUR)\n\
 
402
    2 - relative to the end of the file (SEEK_END)");
 
403
 
 
404
/* List of functions */
 
405
 
 
406
static PyMethodDef fcntl_methods[] = {
 
407
        {"fcntl",       fcntl_fcntl, METH_VARARGS, fcntl_doc},
 
408
        {"ioctl",       fcntl_ioctl, METH_VARARGS, ioctl_doc},
 
409
        {"flock",       fcntl_flock, METH_VARARGS, flock_doc},
 
410
        {"lockf",       fcntl_lockf, METH_VARARGS, lockf_doc},
 
411
        {NULL,          NULL}           /* sentinel */
 
412
};
 
413
 
 
414
 
 
415
PyDoc_STRVAR(module_doc,
 
416
"This module performs file control and I/O control on file \n\
 
417
descriptors.  It is an interface to the fcntl() and ioctl() Unix\n\
 
418
routines.  File descriptors can be obtained with the fileno() method of\n\
 
419
a file or socket object.");
 
420
 
 
421
/* Module initialisation */
 
422
 
 
423
static int
 
424
ins(PyObject* d, char* symbol, long value)
 
425
{
 
426
        PyObject* v = PyInt_FromLong(value);
 
427
        if (!v || PyDict_SetItemString(d, symbol, v) < 0)
 
428
                return -1;
 
429
 
 
430
        Py_DECREF(v);
 
431
        return 0;
 
432
}
 
433
 
 
434
#define INS(x) if (ins(d, #x, (long)x)) return -1
 
435
 
 
436
static int
 
437
all_ins(PyObject* d)
 
438
{
 
439
        if (ins(d, "LOCK_SH", (long)LOCK_SH)) return -1;
 
440
        if (ins(d, "LOCK_EX", (long)LOCK_EX)) return -1;
 
441
        if (ins(d, "LOCK_NB", (long)LOCK_NB)) return -1;
 
442
        if (ins(d, "LOCK_UN", (long)LOCK_UN)) return -1;
 
443
/* GNU extensions, as of glibc 2.2.4 */
 
444
#ifdef LOCK_MAND
 
445
        if (ins(d, "LOCK_MAND", (long)LOCK_MAND)) return -1;
 
446
#endif
 
447
#ifdef LOCK_READ
 
448
        if (ins(d, "LOCK_READ", (long)LOCK_READ)) return -1;
 
449
#endif
 
450
#ifdef LOCK_WRITE
 
451
        if (ins(d, "LOCK_WRITE", (long)LOCK_WRITE)) return -1;
 
452
#endif
 
453
#ifdef LOCK_RW
 
454
        if (ins(d, "LOCK_RW", (long)LOCK_RW)) return -1;
 
455
#endif
 
456
 
 
457
#ifdef F_DUPFD
 
458
        if (ins(d, "F_DUPFD", (long)F_DUPFD)) return -1;
 
459
#endif
 
460
#ifdef F_GETFD
 
461
        if (ins(d, "F_GETFD", (long)F_GETFD)) return -1;
 
462
#endif
 
463
#ifdef F_SETFD
 
464
        if (ins(d, "F_SETFD", (long)F_SETFD)) return -1;
 
465
#endif
 
466
#ifdef F_GETFL
 
467
        if (ins(d, "F_GETFL", (long)F_GETFL)) return -1;
 
468
#endif
 
469
#ifdef F_SETFL
 
470
        if (ins(d, "F_SETFL", (long)F_SETFL)) return -1;
 
471
#endif
 
472
#ifdef F_GETLK
 
473
        if (ins(d, "F_GETLK", (long)F_GETLK)) return -1;
 
474
#endif
 
475
#ifdef F_SETLK
 
476
        if (ins(d, "F_SETLK", (long)F_SETLK)) return -1;
 
477
#endif
 
478
#ifdef F_SETLKW
 
479
        if (ins(d, "F_SETLKW", (long)F_SETLKW)) return -1;
 
480
#endif
 
481
#ifdef F_GETOWN
 
482
        if (ins(d, "F_GETOWN", (long)F_GETOWN)) return -1;
 
483
#endif
 
484
#ifdef F_SETOWN
 
485
        if (ins(d, "F_SETOWN", (long)F_SETOWN)) return -1;
 
486
#endif
 
487
#ifdef F_GETSIG
 
488
        if (ins(d, "F_GETSIG", (long)F_GETSIG)) return -1;
 
489
#endif
 
490
#ifdef F_SETSIG
 
491
        if (ins(d, "F_SETSIG", (long)F_SETSIG)) return -1;
 
492
#endif
 
493
#ifdef F_RDLCK
 
494
        if (ins(d, "F_RDLCK", (long)F_RDLCK)) return -1;
 
495
#endif
 
496
#ifdef F_WRLCK
 
497
        if (ins(d, "F_WRLCK", (long)F_WRLCK)) return -1;
 
498
#endif
 
499
#ifdef F_UNLCK
 
500
        if (ins(d, "F_UNLCK", (long)F_UNLCK)) return -1;
 
501
#endif
 
502
/* LFS constants */
 
503
#ifdef F_GETLK64
 
504
        if (ins(d, "F_GETLK64", (long)F_GETLK64)) return -1;
 
505
#endif
 
506
#ifdef F_SETLK64
 
507
        if (ins(d, "F_SETLK64", (long)F_SETLK64)) return -1;
 
508
#endif
 
509
#ifdef F_SETLKW64
 
510
        if (ins(d, "F_SETLKW64", (long)F_SETLKW64)) return -1;
 
511
#endif
 
512
/* GNU extensions, as of glibc 2.2.4. */
 
513
#ifdef FASYNC
 
514
        if (ins(d, "FASYNC", (long)FASYNC)) return -1;
 
515
#endif
 
516
#ifdef F_SETLEASE
 
517
        if (ins(d, "F_SETLEASE", (long)F_SETLEASE)) return -1;
 
518
#endif
 
519
#ifdef F_GETLEASE
 
520
        if (ins(d, "F_GETLEASE", (long)F_GETLEASE)) return -1;
 
521
#endif
 
522
#ifdef F_NOTIFY
 
523
        if (ins(d, "F_NOTIFY", (long)F_NOTIFY)) return -1;
 
524
#endif
 
525
/* Old BSD flock(). */
 
526
#ifdef F_EXLCK
 
527
        if (ins(d, "F_EXLCK", (long)F_EXLCK)) return -1;
 
528
#endif
 
529
#ifdef F_SHLCK
 
530
        if (ins(d, "F_SHLCK", (long)F_SHLCK)) return -1;
 
531
#endif
 
532
 
 
533
/* OS X (and maybe others) let you tell the storage device to flush to physical media */
 
534
#ifdef F_FULLFSYNC
 
535
        if (ins(d, "F_FULLFSYNC", (long)F_FULLFSYNC)) return -1;
 
536
#endif
 
537
 
 
538
/* For F_{GET|SET}FL */
 
539
#ifdef FD_CLOEXEC
 
540
        if (ins(d, "FD_CLOEXEC", (long)FD_CLOEXEC)) return -1;
 
541
#endif
 
542
 
 
543
/* For F_NOTIFY */
 
544
#ifdef DN_ACCESS
 
545
        if (ins(d, "DN_ACCESS", (long)DN_ACCESS)) return -1;
 
546
#endif
 
547
#ifdef DN_MODIFY
 
548
        if (ins(d, "DN_MODIFY", (long)DN_MODIFY)) return -1;
 
549
#endif
 
550
#ifdef DN_CREATE
 
551
        if (ins(d, "DN_CREATE", (long)DN_CREATE)) return -1;
 
552
#endif
 
553
#ifdef DN_DELETE
 
554
        if (ins(d, "DN_DELETE", (long)DN_DELETE)) return -1;
 
555
#endif
 
556
#ifdef DN_RENAME
 
557
        if (ins(d, "DN_RENAME", (long)DN_RENAME)) return -1;
 
558
#endif
 
559
#ifdef DN_ATTRIB
 
560
        if (ins(d, "DN_ATTRIB", (long)DN_ATTRIB)) return -1;
 
561
#endif
 
562
#ifdef DN_MULTISHOT
 
563
        if (ins(d, "DN_MULTISHOT", (long)DN_MULTISHOT)) return -1;
 
564
#endif
 
565
 
 
566
#ifdef HAVE_STROPTS_H
 
567
        /* Unix 98 guarantees that these are in stropts.h. */
 
568
        INS(I_PUSH);
 
569
        INS(I_POP);
 
570
        INS(I_LOOK);
 
571
        INS(I_FLUSH);
 
572
        INS(I_FLUSHBAND);
 
573
        INS(I_SETSIG);
 
574
        INS(I_GETSIG);
 
575
        INS(I_FIND);
 
576
        INS(I_PEEK);
 
577
        INS(I_SRDOPT);
 
578
        INS(I_GRDOPT);
 
579
        INS(I_NREAD);
 
580
        INS(I_FDINSERT);
 
581
        INS(I_STR);
 
582
        INS(I_SWROPT);
 
583
#ifdef I_GWROPT
 
584
        /* despite the comment above, old-ish glibcs miss a couple... */
 
585
        INS(I_GWROPT);
 
586
#endif
 
587
        INS(I_SENDFD);
 
588
        INS(I_RECVFD);
 
589
        INS(I_LIST);
 
590
        INS(I_ATMARK);
 
591
        INS(I_CKBAND);
 
592
        INS(I_GETBAND);
 
593
        INS(I_CANPUT);
 
594
        INS(I_SETCLTIME);
 
595
#ifdef I_GETCLTIME
 
596
        INS(I_GETCLTIME);
 
597
#endif
 
598
        INS(I_LINK);
 
599
        INS(I_UNLINK);
 
600
        INS(I_PLINK);
 
601
        INS(I_PUNLINK);
 
602
#endif
 
603
        
 
604
        return 0;
 
605
}
 
606
 
 
607
PyMODINIT_FUNC
 
608
initfcntl(void)
 
609
{
 
610
        PyObject *m, *d;
 
611
 
 
612
        /* Create the module and add the functions and documentation */
 
613
        m = Py_InitModule3("fcntl", fcntl_methods, module_doc);
 
614
        if (m == NULL)
 
615
                return;
 
616
 
 
617
        /* Add some symbolic constants to the module */
 
618
        d = PyModule_GetDict(m);
 
619
        all_ins(d);
 
620
}