source: python/trunk/Modules/fcntlmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 17.5 KB
RevLine 
[2]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
18static int
19conv_descriptor(PyObject *object, int *target)
20{
21 int fd = PyObject_AsFileDescriptor(object);
22
23 if (fd < 0)
[391]24 return 0;
[2]25 *target = fd;
26 return 1;
27}
28
29
30/* fcntl(fd, opt, [arg]) */
31
32static PyObject *
33fcntl_fcntl(PyObject *self, PyObject *args)
34{
[391]35 int fd;
36 int code;
37 long arg;
38 int ret;
39 char *str;
40 Py_ssize_t len;
41 char buf[1024];
[2]42
[391]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 }
[2]60
[391]61 PyErr_Clear();
62 arg = 0;
63 if (!PyArg_ParseTuple(args,
64 "O&i|l;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);
[2]77}
78
79PyDoc_STRVAR(fcntl_doc,
80"fcntl(fd, opt, [arg])\n\
81\n\
82Perform the requested operation on file descriptor fd. The operation\n\
83is defined by op and is operating system dependent. These constants are\n\
84available from the fcntl module. The argument arg is optional, and\n\
[391]85defaults to 0; it may be an int or a string. If arg is given as a string,\n\
[2]86the return value of fcntl is a string of that length, containing the\n\
[391]87resulting value put in the arg buffer by the operating system. The length\n\
88of the arg string is not allowed to exceed 1024 bytes. If the arg given\n\
[2]89is an integer or if none is specified, the result value is an integer\n\
90corresponding to the return value of the fcntl call in the C code.");
91
92
93/* ioctl(fd, opt, [arg]) */
94
95static PyObject *
96fcntl_ioctl(PyObject *self, PyObject *args)
97{
98#define IOCTL_BUFSZ 1024
[391]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.
[2]108
[391]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 */
[2]120
[391]121 if (PyArg_ParseTuple(args, "O&Iw#|i:ioctl",
122 conv_descriptor, &fd, &code,
123 &str, &len, &mutate_arg)) {
124 char *arg;
[2]125
[391]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 }
[2]170
[391]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 }
[2]190
[391]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
[2]200#ifdef __VMS
[391]201 ret = ioctl(fd, code, (void *)arg);
[2]202#else
[391]203 ret = ioctl(fd, code, arg);
[2]204#endif
[391]205 Py_END_ALLOW_THREADS
206 if (ret < 0) {
207 PyErr_SetFromErrno(PyExc_IOError);
208 return NULL;
209 }
210 return PyInt_FromLong((long)ret);
[2]211#undef IOCTL_BUFSZ
212}
213
214PyDoc_STRVAR(ioctl_doc,
215"ioctl(fd, opt[, arg[, mutate_flag]])\n\
216\n\
217Perform the requested operation on file descriptor fd. The operation is\n\
218defined by opt and is operating system dependent. Typically these codes are\n\
219retrieved from the fcntl or termios library modules.\n\
220\n\
221The argument arg is optional, and defaults to 0; it may be an int or a\n\
222buffer containing character data (most likely a string or an array). \n\
223\n\
224If the argument is a mutable buffer (such as an array) and if the\n\
225mutate_flag argument (which is only allowed in this case) is true then the\n\
226buffer is (in effect) passed to the operating system and changes made by\n\
227the OS will be reflected in the contents of the buffer after the call has\n\
228returned. The return value is the integer returned by the ioctl system\n\
229call.\n\
230\n\
231If the argument is a mutable buffer and the mutable_flag argument is not\n\
232passed or is false, the behavior is as if a string had been passed. This\n\
233behavior will change in future releases of Python.\n\
234\n\
235If the argument is an immutable buffer (most likely a string) then a copy\n\
236of the buffer is passed to the operating system and the return value is a\n\
237string of the same length containing whatever the operating system put in\n\
238the buffer. The length of the arg buffer in this case is not allowed to\n\
239exceed 1024 bytes.\n\
240\n\
241If the arg given is an integer or if none is specified, the result value is\n\
242an integer corresponding to the return value of the ioctl call in the C\n\
243code.");
244
245
246/* flock(fd, operation) */
247
248static PyObject *
249fcntl_flock(PyObject *self, PyObject *args)
250{
[391]251 int fd;
252 int code;
253 int ret;
[2]254
[391]255 if (!PyArg_ParseTuple(args, "O&i:flock",
256 conv_descriptor, &fd, &code))
257 return NULL;
[2]258
259#ifdef HAVE_FLOCK
[391]260 Py_BEGIN_ALLOW_THREADS
261 ret = flock(fd, code);
262 Py_END_ALLOW_THREADS
[2]263#else
264
265#ifndef LOCK_SH
[391]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 */
[2]270#endif
[391]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 }
[2]289#endif /* HAVE_FLOCK */
[391]290 if (ret < 0) {
291 PyErr_SetFromErrno(PyExc_IOError);
292 return NULL;
293 }
294 Py_INCREF(Py_None);
295 return Py_None;
[2]296}
297
298PyDoc_STRVAR(flock_doc,
299"flock(fd, operation)\n\
300\n\
301Perform the lock operation op on file descriptor fd. See the Unix \n\
[391]302manual page for flock(2) for details. (On some systems, this function is\n\
[2]303emulated using fcntl().)");
304
305
306/* lockf(fd, operation) */
307static PyObject *
308fcntl_lockf(PyObject *self, PyObject *args)
309{
[391]310 int fd, code, ret, whence = 0;
311 PyObject *lenobj = NULL, *startobj = NULL;
[2]312
[391]313 if (!PyArg_ParseTuple(args, "O&i|OOi:lockf",
314 conv_descriptor, &fd, &code,
315 &lenobj, &startobj, &whence))
316 return NULL;
[2]317
[10]318#if defined(PYOS_OS2) && defined(PYCC_GCC) && !defined(__KLIBC__)
[391]319 PyErr_SetString(PyExc_NotImplementedError,
320 "lockf not supported on OS/2 (EMX)");
321 return NULL;
[2]322#else
323#ifndef LOCK_SH
[391]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 */
[2]328#endif /* LOCK_SH */
[391]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) {
[2]344#if !defined(HAVE_LARGEFILE_SUPPORT)
[391]345 l.l_start = PyInt_AsLong(startobj);
[2]346#else
[391]347 l.l_start = PyLong_Check(startobj) ?
348 PyLong_AsLongLong(startobj) :
349 PyInt_AsLong(startobj);
[2]350#endif
[391]351 if (PyErr_Occurred())
352 return NULL;
353 }
354 if (lenobj != NULL) {
[2]355#if !defined(HAVE_LARGEFILE_SUPPORT)
[391]356 l.l_len = PyInt_AsLong(lenobj);
[2]357#else
[391]358 l.l_len = PyLong_Check(lenobj) ?
359 PyLong_AsLongLong(lenobj) :
360 PyInt_AsLong(lenobj);
[2]361#endif
[391]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;
[10]376#endif /* defined(PYOS_OS2) && defined(PYCC_GCC) && !defined(__KLIBC__)*/
[2]377}
378
379PyDoc_STRVAR(lockf_doc,
380"lockf (fd, operation, length=0, start=0, whence=0)\n\
381\n\
382This is essentially a wrapper around the fcntl() locking calls. fd is the\n\
383file descriptor of the file to lock or unlock, and operation is one of the\n\
384following 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\
390When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\n\
391LOCK_NB to avoid blocking on lock acquisition. If LOCK_NB is used and the\n\
392lock cannot be acquired, an IOError will be raised and the exception will\n\
393have an errno attribute set to EACCES or EAGAIN (depending on the operating\n\
394system -- for portability, check for either value).\n\
395\n\
396length is the number of bytes to lock, with the default meaning to lock to\n\
397EOF. start is the byte offset, relative to whence, to that the lock\n\
398starts. 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
406static PyMethodDef fcntl_methods[] = {
[391]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 */
[2]412};
413
414
415PyDoc_STRVAR(module_doc,
416"This module performs file control and I/O control on file \n\
417descriptors. It is an interface to the fcntl() and ioctl() Unix\n\
418routines. File descriptors can be obtained with the fileno() method of\n\
419a file or socket object.");
420
421/* Module initialisation */
422
423static int
424ins(PyObject* d, char* symbol, long value)
425{
[391]426 PyObject* v = PyInt_FromLong(value);
427 if (!v || PyDict_SetItemString(d, symbol, v) < 0)
428 return -1;
[2]429
[391]430 Py_DECREF(v);
431 return 0;
[2]432}
433
434#define INS(x) if (ins(d, #x, (long)x)) return -1
435
436static int
437all_ins(PyObject* d)
438{
[391]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;
[2]443/* GNU extensions, as of glibc 2.2.4 */
444#ifdef LOCK_MAND
[391]445 if (ins(d, "LOCK_MAND", (long)LOCK_MAND)) return -1;
[2]446#endif
447#ifdef LOCK_READ
[391]448 if (ins(d, "LOCK_READ", (long)LOCK_READ)) return -1;
[2]449#endif
450#ifdef LOCK_WRITE
[391]451 if (ins(d, "LOCK_WRITE", (long)LOCK_WRITE)) return -1;
[2]452#endif
453#ifdef LOCK_RW
[391]454 if (ins(d, "LOCK_RW", (long)LOCK_RW)) return -1;
[2]455#endif
456
457#ifdef F_DUPFD
[391]458 if (ins(d, "F_DUPFD", (long)F_DUPFD)) return -1;
[2]459#endif
460#ifdef F_GETFD
[391]461 if (ins(d, "F_GETFD", (long)F_GETFD)) return -1;
[2]462#endif
463#ifdef F_SETFD
[391]464 if (ins(d, "F_SETFD", (long)F_SETFD)) return -1;
[2]465#endif
466#ifdef F_GETFL
[391]467 if (ins(d, "F_GETFL", (long)F_GETFL)) return -1;
[2]468#endif
469#ifdef F_SETFL
[391]470 if (ins(d, "F_SETFL", (long)F_SETFL)) return -1;
[2]471#endif
472#ifdef F_GETLK
[391]473 if (ins(d, "F_GETLK", (long)F_GETLK)) return -1;
[2]474#endif
475#ifdef F_SETLK
[391]476 if (ins(d, "F_SETLK", (long)F_SETLK)) return -1;
[2]477#endif
478#ifdef F_SETLKW
[391]479 if (ins(d, "F_SETLKW", (long)F_SETLKW)) return -1;
[2]480#endif
481#ifdef F_GETOWN
[391]482 if (ins(d, "F_GETOWN", (long)F_GETOWN)) return -1;
[2]483#endif
484#ifdef F_SETOWN
[391]485 if (ins(d, "F_SETOWN", (long)F_SETOWN)) return -1;
[2]486#endif
487#ifdef F_GETSIG
[391]488 if (ins(d, "F_GETSIG", (long)F_GETSIG)) return -1;
[2]489#endif
490#ifdef F_SETSIG
[391]491 if (ins(d, "F_SETSIG", (long)F_SETSIG)) return -1;
[2]492#endif
493#ifdef F_RDLCK
[391]494 if (ins(d, "F_RDLCK", (long)F_RDLCK)) return -1;
[2]495#endif
496#ifdef F_WRLCK
[391]497 if (ins(d, "F_WRLCK", (long)F_WRLCK)) return -1;
[2]498#endif
499#ifdef F_UNLCK
[391]500 if (ins(d, "F_UNLCK", (long)F_UNLCK)) return -1;
[2]501#endif
502/* LFS constants */
503#ifdef F_GETLK64
[391]504 if (ins(d, "F_GETLK64", (long)F_GETLK64)) return -1;
[2]505#endif
506#ifdef F_SETLK64
[391]507 if (ins(d, "F_SETLK64", (long)F_SETLK64)) return -1;
[2]508#endif
509#ifdef F_SETLKW64
[391]510 if (ins(d, "F_SETLKW64", (long)F_SETLKW64)) return -1;
[2]511#endif
512/* GNU extensions, as of glibc 2.2.4. */
513#ifdef FASYNC
[391]514 if (ins(d, "FASYNC", (long)FASYNC)) return -1;
[2]515#endif
516#ifdef F_SETLEASE
[391]517 if (ins(d, "F_SETLEASE", (long)F_SETLEASE)) return -1;
[2]518#endif
519#ifdef F_GETLEASE
[391]520 if (ins(d, "F_GETLEASE", (long)F_GETLEASE)) return -1;
[2]521#endif
522#ifdef F_NOTIFY
[391]523 if (ins(d, "F_NOTIFY", (long)F_NOTIFY)) return -1;
[2]524#endif
525/* Old BSD flock(). */
526#ifdef F_EXLCK
[391]527 if (ins(d, "F_EXLCK", (long)F_EXLCK)) return -1;
[2]528#endif
529#ifdef F_SHLCK
[391]530 if (ins(d, "F_SHLCK", (long)F_SHLCK)) return -1;
[2]531#endif
532
533/* OS X (and maybe others) let you tell the storage device to flush to physical media */
534#ifdef F_FULLFSYNC
[391]535 if (ins(d, "F_FULLFSYNC", (long)F_FULLFSYNC)) return -1;
[2]536#endif
537
538/* For F_{GET|SET}FL */
539#ifdef FD_CLOEXEC
[391]540 if (ins(d, "FD_CLOEXEC", (long)FD_CLOEXEC)) return -1;
[2]541#endif
542
543/* For F_NOTIFY */
544#ifdef DN_ACCESS
[391]545 if (ins(d, "DN_ACCESS", (long)DN_ACCESS)) return -1;
[2]546#endif
547#ifdef DN_MODIFY
[391]548 if (ins(d, "DN_MODIFY", (long)DN_MODIFY)) return -1;
[2]549#endif
550#ifdef DN_CREATE
[391]551 if (ins(d, "DN_CREATE", (long)DN_CREATE)) return -1;
[2]552#endif
553#ifdef DN_DELETE
[391]554 if (ins(d, "DN_DELETE", (long)DN_DELETE)) return -1;
[2]555#endif
556#ifdef DN_RENAME
[391]557 if (ins(d, "DN_RENAME", (long)DN_RENAME)) return -1;
[2]558#endif
559#ifdef DN_ATTRIB
[391]560 if (ins(d, "DN_ATTRIB", (long)DN_ATTRIB)) return -1;
[2]561#endif
562#ifdef DN_MULTISHOT
[391]563 if (ins(d, "DN_MULTISHOT", (long)DN_MULTISHOT)) return -1;
[2]564#endif
565
566#ifdef HAVE_STROPTS_H
[391]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);
[2]583#ifdef I_GWROPT
[391]584 /* despite the comment above, old-ish glibcs miss a couple... */
585 INS(I_GWROPT);
[2]586#endif
[391]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);
[2]595#ifdef I_GETCLTIME
[391]596 INS(I_GETCLTIME);
[2]597#endif
[391]598 INS(I_LINK);
599 INS(I_UNLINK);
600 INS(I_PLINK);
601 INS(I_PUNLINK);
[2]602#endif
[391]603
604 return 0;
[2]605}
606
607PyMODINIT_FUNC
608initfcntl(void)
609{
[391]610 PyObject *m, *d;
[2]611
[391]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;
[2]616
[391]617 /* Add some symbolic constants to the module */
618 d = PyModule_GetDict(m);
619 all_ins(d);
[2]620}
Note: See TracBrowser for help on using the repository browser.