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 /* For F_{GET|SET}FL */
 534 #ifdef FD_CLOEXEC
 535         if (ins(d, "FD_CLOEXEC", (long)FD_CLOEXEC)) return -1;
 536 #endif
 537
 538 /* For F_NOTIFY */
 539 #ifdef DN_ACCESS
 540         if (ins(d, "DN_ACCESS", (long)DN_ACCESS)) return -1;
 541 #endif
 542 #ifdef DN_MODIFY
 543         if (ins(d, "DN_MODIFY", (long)DN_MODIFY)) return -1;
 544 #endif
 545 #ifdef DN_CREATE
 546         if (ins(d, "DN_CREATE", (long)DN_CREATE)) return -1;
 547 #endif
 548 #ifdef DN_DELETE
 549         if (ins(d, "DN_DELETE", (long)DN_DELETE)) return -1;
 550 #endif
 551 #ifdef DN_RENAME
 552         if (ins(d, "DN_RENAME", (long)DN_RENAME)) return -1;
 553 #endif
 554 #ifdef DN_ATTRIB
 555         if (ins(d, "DN_ATTRIB", (long)DN_ATTRIB)) return -1;
 556 #endif
 557 #ifdef DN_MULTISHOT
 558         if (ins(d, "DN_MULTISHOT", (long)DN_MULTISHOT)) return -1;
 559 #endif
 560
 561 #ifdef HAVE_STROPTS_H
 562         /* Unix 98 guarantees that these are in stropts.h. */
 563         INS(I_PUSH);
 564         INS(I_POP);
 565         INS(I_LOOK);
 566         INS(I_FLUSH);
 567         INS(I_FLUSHBAND);
 568         INS(I_SETSIG);
 569         INS(I_GETSIG);
 570         INS(I_FIND);
 571         INS(I_PEEK);
 572         INS(I_SRDOPT);
 573         INS(I_GRDOPT);
 574         INS(I_NREAD);
 575         INS(I_FDINSERT);
 576         INS(I_STR);
 577         INS(I_SWROPT);
 578 #ifdef I_GWROPT
 579         /* despite the comment above, old-ish glibcs miss a couple... */
 580         INS(I_GWROPT);
 581 #endif
 582         INS(I_SENDFD);
 583         INS(I_RECVFD);
 584         INS(I_LIST);
 585         INS(I_ATMARK);
 586         INS(I_CKBAND);
 587         INS(I_GETBAND);
 588         INS(I_CANPUT);
 589         INS(I_SETCLTIME);
 590 #ifdef I_GETCLTIME
 591         INS(I_GETCLTIME);
 592 #endif
 593         INS(I_LINK);
 594         INS(I_UNLINK);
 595         INS(I_PLINK);
 596         INS(I_PUNLINK);
 597 #endif
 598
 599         return 0;
 600 }
 601
 602 PyMODINIT_FUNC
 603 initfcntl(void)
 604 {
 605         PyObject *m, *d;
 606
 607         /* Create the module and add the functions and documentation */
 608         m = Py_InitModule3("fcntl", fcntl_methods, module_doc);
 609         if (m == NULL)
 610                 return;
 611
 612         /* Add some symbolic constants to the module */
 613         d = PyModule_GetDict(m);
 614         all_ins(d);
 615 }