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 long 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|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); 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 } 621
