Modules/zipimport.c

   1 #include "Python.h"
   2 #include "structmember.h"
   3 #include "osdefs.h"
   4 #include "marshal.h"
   5 #include <time.h>
   6
   7
   8 #define IS_SOURCE   0x0
   9 #define IS_BYTECODE 0x1
  10 #define IS_PACKAGE  0x2
  11
  12 struct st_zip_searchorder {
  13     char suffix[14];
  14     int type;
  15 };
  16
  17 /* zip_searchorder defines how we search for a module in the Zip
  18    archive: we first search for a package __init__, then for
  19    non-package .pyc, .pyo and .py entries. The .pyc and .pyo entries
  20    are swapped by initzipimport() if we run in optimized mode. Also,
  21    '/' is replaced by SEP there. */
  22 static struct st_zip_searchorder zip_searchorder[] = {
  23     {"/__init__.pyc", IS_PACKAGE | IS_BYTECODE},
  24     {"/__init__.pyo", IS_PACKAGE | IS_BYTECODE},
  25     {"/__init__.py", IS_PACKAGE | IS_SOURCE},
  26     {".pyc", IS_BYTECODE},
  27     {".pyo", IS_BYTECODE},
  28     {".py", IS_SOURCE},
  29     {"", 0}
  30 };
  31
  32 /* zipimporter object definition and support */
  33
  34 typedef struct _zipimporter ZipImporter;
  35
  36 struct _zipimporter {
  37     PyObject_HEAD
  38     PyObject *archive;  /* pathname of the Zip archive */
  39     PyObject *prefix;   /* file prefix: "a/sub/directory/" */
  40     PyObject *files;    /* dict with file info {path: toc_entry} */
  41 };
  42
  43 static PyObject *ZipImportError;
  44 static PyObject *zip_directory_cache = NULL;
  45
  46 /* forward decls */
  47 static PyObject *read_directory(char *archive);
  48 static PyObject *get_data(char *archive, PyObject *toc_entry);
  49 static PyObject *get_module_code(ZipImporter *self, char *fullname,
  50                                  int *p_ispackage, char **p_modpath);
  51
  52
  53 #define ZipImporter_Check(op) PyObject_TypeCheck(op, &ZipImporter_Type)
  54
  55
  56 /* zipimporter.__init__
  57    Split the "subdirectory" from the Zip archive path, lookup a matching
  58    entry in sys.path_importer_cache, fetch the file directory from there
  59    if found, or else read it from the archive. */
  60 static int
  61 zipimporter_init(ZipImporter *self, PyObject *args, PyObject *kwds)
  62 {
  63     char *path, *p, *prefix, buf[MAXPATHLEN+2];
  64     size_t len;
  65
  66     if (!_PyArg_NoKeywords("zipimporter()", kwds))
  67         return -1;
  68
  69     if (!PyArg_ParseTuple(args, "s:zipimporter", &path))
  70         return -1;
  71
  72     len = strlen(path);
  73     if (len == 0) {
  74         PyErr_SetString(ZipImportError, "archive path is empty");
  75         return -1;
  76     }
  77     if (len >= MAXPATHLEN) {
  78         PyErr_SetString(ZipImportError,
  79                         "archive path too long");
  80         return -1;
  81     }
  82     strcpy(buf, path);
  83
  84 #ifdef ALTSEP
  85     for (p = buf; *p; p++) {
  86         if (*p == ALTSEP)
  87             *p = SEP;
  88     }
  89 #endif
  90
  91     path = NULL;
  92     prefix = NULL;
  93     for (;;) {
  94         struct stat statbuf;
  95         int rv;
  96
  97         rv = stat(buf, &statbuf);
  98         if (rv == 0) {
  99             /* it exists */
 100             if (S_ISREG(statbuf.st_mode))
 101                 /* it's a file */
 102                 path = buf;
 103             break;
 104         }
 105         /* back up one path element */
 106         p = strrchr(buf, SEP);
 107         if (prefix != NULL)
 108             *prefix = SEP;
 109         if (p == NULL)
 110             break;
 111         *p = '\0';
 112         prefix = p;
 113     }
 114     if (path != NULL) {
 115         PyObject *files;
 116         files = PyDict_GetItemString(zip_directory_cache, path);
 117         if (files == NULL) {
 118             files = read_directory(buf);
 119             if (files == NULL)
 120                 return -1;
 121             if (PyDict_SetItemString(zip_directory_cache, path,
 122                                      files) != 0)
 123                 return -1;
 124         }
 125         else
 126             Py_INCREF(files);
 127         self->files = files;
 128     }
 129     else {
 130         PyErr_SetString(ZipImportError, "not a Zip file");
 131         return -1;
 132     }
 133
 134     if (prefix == NULL)
 135         prefix = "";
 136     else {
 137         prefix++;
 138         len = strlen(prefix);
 139         if (prefix[len-1] != SEP) {
 140             /* add trailing SEP */
 141             prefix[len] = SEP;
 142             prefix[len + 1] = '\0';
 143         }
 144     }
 145
 146     self->archive = PyUnicode_FromString(buf);
 147     if (self->archive == NULL)
 148         return -1;
 149
 150     self->prefix = PyUnicode_FromString(prefix);
 151     if (self->prefix == NULL)
 152         return -1;
 153
 154     return 0;
 155 }
 156
 157 /* GC support. */
 158 static int
 159 zipimporter_traverse(PyObject *obj, visitproc visit, void *arg)
 160 {
 161     ZipImporter *self = (ZipImporter *)obj;
 162     Py_VISIT(self->files);
 163     return 0;
 164 }
 165
 166 static void
 167 zipimporter_dealloc(ZipImporter *self)
 168 {
 169     PyObject_GC_UnTrack(self);
 170     Py_XDECREF(self->archive);
 171     Py_XDECREF(self->prefix);
 172     Py_XDECREF(self->files);
 173     Py_TYPE(self)->tp_free((PyObject *)self);
 174 }
 175
 176 static PyObject *
 177 zipimporter_repr(ZipImporter *self)
 178 {
 179     char *archive = "???";
 180     char *prefix = "";
 181
 182     if (self->archive != NULL && PyUnicode_Check(self->archive))
 183         archive = _PyUnicode_AsString(self->archive);
 184     if (self->prefix != NULL && PyUnicode_Check(self->prefix))
 185         prefix = _PyUnicode_AsString(self->prefix);
 186     if (prefix != NULL && *prefix)
 187         return PyUnicode_FromFormat("<zipimporter object \"%.300s%c%.150s\">",
 188                                     archive, SEP, prefix);
 189     else
 190         return PyUnicode_FromFormat("<zipimporter object \"%.300s\">",
 191                                     archive);
 192 }
 193
 194 /* return fullname.split(".")[-1] */
 195 static char *
 196 get_subname(char *fullname)
 197 {
 198     char *subname = strrchr(fullname, '.');
 199     if (subname == NULL)
 200         subname = fullname;
 201     else
 202         subname++;
 203     return subname;
 204 }
 205
 206 /* Given a (sub)modulename, write the potential file path in the
 207    archive (without extension) to the path buffer. Return the
 208    length of the resulting string. */
 209 static int
 210 make_filename(char *prefix, char *name, char *path)
 211 {
 212     size_t len;
 213     char *p;
 214
 215     len = strlen(prefix);
 216
 217     /* self.prefix + name [+ SEP + "__init__"] + ".py[co]" */
 218     if (len + strlen(name) + 13 >= MAXPATHLEN) {
 219         PyErr_SetString(ZipImportError, "path too long");
 220         return -1;
 221     }
 222
 223     strcpy(path, prefix);
 224     strcpy(path + len, name);
 225     for (p = path + len; *p; p++) {
 226         if (*p == '.')
 227             *p = SEP;
 228     }
 229     len += strlen(name);
 230     assert(len < INT_MAX);
 231     return (int)len;
 232 }
 233
 234 enum zi_module_info {
 235     MI_ERROR,
 236     MI_NOT_FOUND,
 237     MI_MODULE,
 238     MI_PACKAGE
 239 };
 240
 241 /* Return some information about a module. */
 242 static enum zi_module_info
 243 get_module_info(ZipImporter *self, char *fullname)
 244 {
 245     char *subname, path[MAXPATHLEN + 1];
 246     int len;
 247     struct st_zip_searchorder *zso;
 248
 249     subname = get_subname(fullname);
 250
 251     len = make_filename(_PyUnicode_AsString(self->prefix), subname, path);
 252     if (len < 0)
 253         return MI_ERROR;
 254
 255     for (zso = zip_searchorder; *zso->suffix; zso++) {
 256         strcpy(path + len, zso->suffix);
 257         if (PyDict_GetItemString(self->files, path) != NULL) {
 258             if (zso->type & IS_PACKAGE)
 259                 return MI_PACKAGE;
 260             else
 261                 return MI_MODULE;
 262         }
 263     }
 264     return MI_NOT_FOUND;
 265 }
 266
 267 /* Check whether we can satisfy the import of the module named by
 268    'fullname'. Return self if we can, None if we can't. */
 269 static PyObject *
 270 zipimporter_find_module(PyObject *obj, PyObject *args)
 271 {
 272     ZipImporter *self = (ZipImporter *)obj;
 273     PyObject *path = NULL;
 274     char *fullname;
 275     enum zi_module_info mi;
 276
 277     if (!PyArg_ParseTuple(args, "s|O:zipimporter.find_module",
 278                           &fullname, &path))
 279         return NULL;
 280
 281     mi = get_module_info(self, fullname);
 282     if (mi == MI_ERROR)
 283         return NULL;
 284     if (mi == MI_NOT_FOUND) {
 285         Py_INCREF(Py_None);
 286         return Py_None;
 287     }
 288     Py_INCREF(self);
 289     return (PyObject *)self;
 290 }
 291
 292 /* Load and return the module named by 'fullname'. */
 293 static PyObject *
 294 zipimporter_load_module(PyObject *obj, PyObject *args)
 295 {
 296     ZipImporter *self = (ZipImporter *)obj;
 297     PyObject *code, *mod, *dict;
 298     char *fullname, *modpath;
 299     int ispackage;
 300
 301     if (!PyArg_ParseTuple(args, "s:zipimporter.load_module",
 302                           &fullname))
 303         return NULL;
 304
 305     code = get_module_code(self, fullname, &ispackage, &modpath);
 306     if (code == NULL)
 307         return NULL;
 308
 309     mod = PyImport_AddModule(fullname);
 310     if (mod == NULL) {
 311         Py_DECREF(code);
 312         return NULL;
 313     }
 314     dict = PyModule_GetDict(mod);
 315
 316     /* mod.__loader__ = self */
 317     if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0)
 318         goto error;
 319
 320     if (ispackage) {
 321         /* add __path__ to the module *before* the code gets
 322            executed */
 323         PyObject *pkgpath, *fullpath;
 324         char *subname = get_subname(fullname);
 325         int err;
 326
 327         fullpath = PyUnicode_FromFormat("%U%c%U%s",
 328                                 self->archive, SEP,
 329                                 self->prefix, subname);
 330         if (fullpath == NULL)
 331             goto error;
 332
 333         pkgpath = Py_BuildValue("[O]", fullpath);
 334         Py_DECREF(fullpath);
 335         if (pkgpath == NULL)
 336             goto error;
 337         err = PyDict_SetItemString(dict, "__path__", pkgpath);
 338         Py_DECREF(pkgpath);
 339         if (err != 0)
 340             goto error;
 341     }
 342     mod = PyImport_ExecCodeModuleEx(fullname, code, modpath);
 343     Py_DECREF(code);
 344     if (Py_VerboseFlag)
 345         PySys_WriteStderr("import %s # loaded from Zip %s\n",
 346                           fullname, modpath);
 347     return mod;
 348 error:
 349     Py_DECREF(code);
 350     Py_DECREF(mod);
 351     return NULL;
 352 }
 353
 354 /* Return a string matching __file__ for the named module */
 355 static PyObject *
 356 zipimporter_get_filename(PyObject *obj, PyObject *args)
 357 {
 358     ZipImporter *self = (ZipImporter *)obj;
 359     PyObject *code;
 360     char *fullname, *modpath;
 361     int ispackage;
 362
 363     if (!PyArg_ParseTuple(args, "s:zipimporter.get_filename",
 364                          &fullname))
 365     return NULL;
 366
 367     /* Deciding the filename requires working out where the code
 368        would come from if the module was actually loaded */
 369     code = get_module_code(self, fullname, &ispackage, &modpath);
 370     if (code == NULL)
 371     return NULL;
 372     Py_DECREF(code); /* Only need the path info */
 373
 374     return PyUnicode_FromString(modpath);
 375 }
 376
 377 /* Return a bool signifying whether the module is a package or not. */
 378 static PyObject *
 379 zipimporter_is_package(PyObject *obj, PyObject *args)
 380 {
 381     ZipImporter *self = (ZipImporter *)obj;
 382     char *fullname;
 383     enum zi_module_info mi;
 384
 385     if (!PyArg_ParseTuple(args, "s:zipimporter.is_package",
 386                           &fullname))
 387         return NULL;
 388
 389     mi = get_module_info(self, fullname);
 390     if (mi == MI_ERROR)
 391         return NULL;
 392     if (mi == MI_NOT_FOUND) {
 393         PyErr_Format(ZipImportError, "can't find module '%.200s'",
 394                      fullname);
 395         return NULL;
 396     }
 397     return PyBool_FromLong(mi == MI_PACKAGE);
 398 }
 399
 400 static PyObject *
 401 zipimporter_get_data(PyObject *obj, PyObject *args)
 402 {
 403     ZipImporter *self = (ZipImporter *)obj;
 404     char *path;
 405 #ifdef ALTSEP
 406     char *p, buf[MAXPATHLEN + 1];
 407 #endif
 408     PyObject *toc_entry;
 409     Py_ssize_t len;
 410     char *archive_str;
 411
 412     if (!PyArg_ParseTuple(args, "s:zipimporter.get_data", &path))
 413         return NULL;
 414
 415 #ifdef ALTSEP
 416     if (strlen(path) >= MAXPATHLEN) {
 417         PyErr_SetString(ZipImportError, "path too long");
 418         return NULL;
 419     }
 420     strcpy(buf, path);
 421     for (p = buf; *p; p++) {
 422         if (*p == ALTSEP)
 423             *p = SEP;
 424     }
 425     path = buf;
 426 #endif
 427     archive_str = _PyUnicode_AsStringAndSize(self->archive, &len);
 428     if ((size_t)len < strlen(path) &&
 429         strncmp(path, archive_str, len) == 0 &&
 430         path[len] == SEP) {
 431         path = path + len + 1;
 432     }
 433
 434     toc_entry = PyDict_GetItemString(self->files, path);
 435     if (toc_entry == NULL) {
 436         PyErr_SetFromErrnoWithFilename(PyExc_IOError, path);
 437         return NULL;
 438     }
 439     return get_data(archive_str, toc_entry);
 440 }
 441
 442 static PyObject *
 443 zipimporter_get_code(PyObject *obj, PyObject *args)
 444 {
 445     ZipImporter *self = (ZipImporter *)obj;
 446     char *fullname;
 447
 448     if (!PyArg_ParseTuple(args, "s:zipimporter.get_code", &fullname))
 449         return NULL;
 450
 451     return get_module_code(self, fullname, NULL, NULL);
 452 }
 453
 454 static PyObject *
 455 zipimporter_get_source(PyObject *obj, PyObject *args)
 456 {
 457     ZipImporter *self = (ZipImporter *)obj;
 458     PyObject *toc_entry;
 459     char *fullname, *subname, path[MAXPATHLEN+1];
 460     int len;
 461     enum zi_module_info mi;
 462
 463     if (!PyArg_ParseTuple(args, "s:zipimporter.get_source", &fullname))
 464         return NULL;
 465
 466     mi = get_module_info(self, fullname);
 467     if (mi == MI_ERROR)
 468         return NULL;
 469     if (mi == MI_NOT_FOUND) {
 470         PyErr_Format(ZipImportError, "can't find module '%.200s'",
 471                      fullname);
 472         return NULL;
 473     }
 474     subname = get_subname(fullname);
 475
 476     len = make_filename(_PyUnicode_AsString(self->prefix), subname, path);
 477     if (len < 0)
 478         return NULL;
 479
 480     if (mi == MI_PACKAGE) {
 481         path[len] = SEP;
 482         strcpy(path + len + 1, "__init__.py");
 483     }
 484     else
 485         strcpy(path + len, ".py");
 486
 487     toc_entry = PyDict_GetItemString(self->files, path);
 488     if (toc_entry != NULL) {
 489         PyObject *bytes = get_data(_PyUnicode_AsString(self->archive), toc_entry);
 490         PyObject *res = PyUnicode_FromString(PyBytes_AsString(bytes));
 491         Py_XDECREF(bytes);
 492         return res;
 493     }
 494
 495     /* we have the module, but no source */
 496     Py_INCREF(Py_None);
 497     return Py_None;
 498 }
 499
 500 PyDoc_STRVAR(doc_find_module,
 501 "find_module(fullname, path=None) -> self or None.\n\
 502 \n\
 503 Search for a module specified by 'fullname'. 'fullname' must be the\n\
 504 fully qualified (dotted) module name. It returns the zipimporter\n\
 505 instance itself if the module was found, or None if it wasn't.\n\
 506 The optional 'path' argument is ignored -- it's there for compatibility\n\
 507 with the importer protocol.");
 508
 509 PyDoc_STRVAR(doc_load_module,
 510 "load_module(fullname) -> module.\n\
 511 \n\
 512 Load the module specified by 'fullname'. 'fullname' must be the\n\
 513 fully qualified (dotted) module name. It returns the imported\n\
 514 module, or raises ZipImportError if it wasn't found.");
 515
 516 PyDoc_STRVAR(doc_get_data,
 517 "get_data(pathname) -> string with file data.\n\
 518 \n\
 519 Return the data associated with 'pathname'. Raise IOError if\n\
 520 the file wasn't found.");
 521
 522 PyDoc_STRVAR(doc_is_package,
 523 "is_package(fullname) -> bool.\n\
 524 \n\
 525 Return True if the module specified by fullname is a package.\n\
 526 Raise ZipImportError is the module couldn't be found.");
 527
 528 PyDoc_STRVAR(doc_get_code,
 529 "get_code(fullname) -> code object.\n\
 530 \n\
 531 Return the code object for the specified module. Raise ZipImportError\n\
 532 is the module couldn't be found.");
 533
 534 PyDoc_STRVAR(doc_get_source,
 535 "get_source(fullname) -> source string.\n\
 536 \n\
 537 Return the source code for the specified module. Raise ZipImportError\n\
 538 is the module couldn't be found, return None if the archive does\n\
 539 contain the module, but has no source for it.");
 540
 541
 542 PyDoc_STRVAR(doc_get_filename,
 543 "get_filename(fullname) -> filename string.\n\
 544 \n\
 545 Return the filename for the specified module.");
 546
 547 static PyMethodDef zipimporter_methods[] = {
 548     {"find_module", zipimporter_find_module, METH_VARARGS,
 549      doc_find_module},
 550     {"load_module", zipimporter_load_module, METH_VARARGS,
 551      doc_load_module},
 552     {"get_data", zipimporter_get_data, METH_VARARGS,
 553      doc_get_data},
 554     {"get_code", zipimporter_get_code, METH_VARARGS,
 555      doc_get_code},
 556     {"get_source", zipimporter_get_source, METH_VARARGS,
 557      doc_get_source},
 558     {"get_filename", zipimporter_get_filename, METH_VARARGS,
 559      doc_get_filename},
 560     {"is_package", zipimporter_is_package, METH_VARARGS,
 561      doc_is_package},
 562     {NULL,              NULL}   /* sentinel */
 563 };
 564
 565 static PyMemberDef zipimporter_members[] = {
 566     {"archive",  T_OBJECT, offsetof(ZipImporter, archive),  READONLY},
 567     {"prefix",   T_OBJECT, offsetof(ZipImporter, prefix),   READONLY},
 568     {"_files",   T_OBJECT, offsetof(ZipImporter, files),    READONLY},
 569     {NULL}
 570 };
 571
 572 PyDoc_STRVAR(zipimporter_doc,
 573 "zipimporter(archivepath) -> zipimporter object\n\
 574 \n\
 575 Create a new zipimporter instance. 'archivepath' must be a path to\n\
 576 a zipfile, or to a specific path inside a zipfile. For example, it can be\n\
 577 '/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a\n\
 578 valid directory inside the archive.\n\
 579 \n\
 580 'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip\n\
 581 archive.\n\
 582 \n\
 583 The 'archive' attribute of zipimporter objects contains the name of the\n\
 584 zipfile targeted.");
 585
 586 #define DEFERRED_ADDRESS(ADDR) 0
 587
 588 static PyTypeObject ZipImporter_Type = {
 589     PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0)
 590     "zipimport.zipimporter",
 591     sizeof(ZipImporter),
 592     0,                                          /* tp_itemsize */
 593     (destructor)zipimporter_dealloc,            /* tp_dealloc */
 594     0,                                          /* tp_print */
 595     0,                                          /* tp_getattr */
 596     0,                                          /* tp_setattr */
 597     0,                                          /* tp_reserved */
 598     (reprfunc)zipimporter_repr,                 /* tp_repr */
 599     0,                                          /* tp_as_number */
 600     0,                                          /* tp_as_sequence */
 601     0,                                          /* tp_as_mapping */
 602     0,                                          /* tp_hash */
 603     0,                                          /* tp_call */
 604     0,                                          /* tp_str */
 605     PyObject_GenericGetAttr,                    /* tp_getattro */
 606     0,                                          /* tp_setattro */
 607     0,                                          /* tp_as_buffer */
 608     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
 609         Py_TPFLAGS_HAVE_GC,                     /* tp_flags */
 610     zipimporter_doc,                            /* tp_doc */
 611     zipimporter_traverse,                       /* tp_traverse */
 612     0,                                          /* tp_clear */
 613     0,                                          /* tp_richcompare */
 614     0,                                          /* tp_weaklistoffset */
 615     0,                                          /* tp_iter */
 616     0,                                          /* tp_iternext */
 617     zipimporter_methods,                        /* tp_methods */
 618     zipimporter_members,                        /* tp_members */
 619     0,                                          /* tp_getset */
 620     0,                                          /* tp_base */
 621     0,                                          /* tp_dict */
 622     0,                                          /* tp_descr_get */
 623     0,                                          /* tp_descr_set */
 624     0,                                          /* tp_dictoffset */
 625     (initproc)zipimporter_init,                 /* tp_init */
 626     PyType_GenericAlloc,                        /* tp_alloc */
 627     PyType_GenericNew,                          /* tp_new */
 628     PyObject_GC_Del,                            /* tp_free */
 629 };
 630
 631
 632 /* implementation */
 633
 634 /* Given a buffer, return the long that is represented by the first
 635    4 bytes, encoded as little endian. This partially reimplements
 636    marshal.c:r_long() */
 637 static long
 638 get_long(unsigned char *buf) {
 639     long x;
 640     x =  buf[0];
 641     x |= (long)buf[1] <<  8;
 642     x |= (long)buf[2] << 16;
 643     x |= (long)buf[3] << 24;
 644 #if SIZEOF_LONG > 4
 645     /* Sign extension for 64-bit machines */
 646     x |= -(x & 0x80000000L);
 647 #endif
 648     return x;
 649 }
 650
 651 /*
 652    read_directory(archive) -> files dict (new reference)
 653
 654    Given a path to a Zip archive, build a dict, mapping file names
 655    (local to the archive, using SEP as a separator) to toc entries.
 656
 657    A toc_entry is a tuple:
 658
 659        (__file__,      # value to use for __file__, available for all files
 660     compress,      # compression kind; 0 for uncompressed
 661     data_size,     # size of compressed data on disk
 662     file_size,     # size of decompressed data
 663     file_offset,   # offset of file header from start of archive
 664     time,          # mod time of file (in dos format)
 665     date,          # mod data of file (in dos format)
 666     crc,           # crc checksum of the data
 667        )
 668
 669    Directories can be recognized by the trailing SEP in the name,
 670    data_size and file_offset are 0.
 671 */
 672 static PyObject *
 673 read_directory(char *archive)
 674 {
 675     PyObject *files = NULL;
 676     FILE *fp;
 677     long compress, crc, data_size, file_size, file_offset, date, time;
 678     long header_offset, name_size, header_size, header_position;
 679     long i, l, count;
 680     size_t length;
 681     char path[MAXPATHLEN + 5];
 682     char name[MAXPATHLEN + 5];
 683     char *p, endof_central_dir[22];
 684     long arc_offset; /* offset from beginning of file to start of zip-archive */
 685
 686     if (strlen(archive) > MAXPATHLEN) {
 687         PyErr_SetString(PyExc_OverflowError,
 688                         "Zip path name is too long");
 689         return NULL;
 690     }
 691     strcpy(path, archive);
 692
 693     fp = fopen(archive, "rb");
 694     if (fp == NULL) {
 695         PyErr_Format(ZipImportError, "can't open Zip file: "
 696                      "'%.200s'", archive);
 697         return NULL;
 698     }
 699     fseek(fp, -22, SEEK_END);
 700     header_position = ftell(fp);
 701     if (fread(endof_central_dir, 1, 22, fp) != 22) {
 702         fclose(fp);
 703         PyErr_Format(ZipImportError, "can't read Zip file: "
 704                      "'%.200s'", archive);
 705         return NULL;
 706     }
 707     if (get_long((unsigned char *)endof_central_dir) != 0x06054B50) {
 708         /* Bad: End of Central Dir signature */
 709         fclose(fp);
 710         PyErr_Format(ZipImportError, "not a Zip file: "
 711                      "'%.200s'", archive);
 712         return NULL;
 713     }
 714
 715     header_size = get_long((unsigned char *)endof_central_dir + 12);
 716     header_offset = get_long((unsigned char *)endof_central_dir + 16);
 717     arc_offset = header_position - header_offset - header_size;
 718     header_offset += arc_offset;
 719
 720     files = PyDict_New();
 721     if (files == NULL)
 722         goto error;
 723
 724     length = (long)strlen(path);
 725     path[length] = SEP;
 726
 727     /* Start of Central Directory */
 728     count = 0;
 729     for (;;) {
 730         PyObject *t;
 731         int err;
 732
 733         fseek(fp, header_offset, 0);  /* Start of file header */
 734         l = PyMarshal_ReadLongFromFile(fp);
 735         if (l != 0x02014B50)
 736             break;              /* Bad: Central Dir File Header */
 737         fseek(fp, header_offset + 10, 0);
 738         compress = PyMarshal_ReadShortFromFile(fp);
 739         time = PyMarshal_ReadShortFromFile(fp);
 740         date = PyMarshal_ReadShortFromFile(fp);
 741         crc = PyMarshal_ReadLongFromFile(fp);
 742         data_size = PyMarshal_ReadLongFromFile(fp);
 743         file_size = PyMarshal_ReadLongFromFile(fp);
 744         name_size = PyMarshal_ReadShortFromFile(fp);
 745         header_size = 46 + name_size +
 746            PyMarshal_ReadShortFromFile(fp) +
 747            PyMarshal_ReadShortFromFile(fp);
 748         fseek(fp, header_offset + 42, 0);
 749         file_offset = PyMarshal_ReadLongFromFile(fp) + arc_offset;
 750         if (name_size > MAXPATHLEN)
 751             name_size = MAXPATHLEN;
 752
 753         p = name;
 754         for (i = 0; i < name_size; i++) {
 755             *p = (char)getc(fp);
 756             if (*p == '/')
 757                 *p = SEP;
 758             p++;
 759         }
 760         *p = 0;         /* Add terminating null byte */
 761         header_offset += header_size;
 762
 763         strncpy(path + length + 1, name, MAXPATHLEN - length - 1);
 764
 765         t = Py_BuildValue("siiiiiii", path, compress, data_size,
 766                           file_size, file_offset, time, date, crc);
 767         if (t == NULL)
 768             goto error;
 769         err = PyDict_SetItemString(files, name, t);
 770         Py_DECREF(t);
 771         if (err != 0)
 772             goto error;
 773         count++;
 774     }
 775     fclose(fp);
 776     if (Py_VerboseFlag)
 777         PySys_WriteStderr("# zipimport: found %ld names in %s\n",
 778             count, archive);
 779     return files;
 780 error:
 781     fclose(fp);
 782     Py_XDECREF(files);
 783     return NULL;
 784 }
 785
 786 /* Return the zlib.decompress function object, or NULL if zlib couldn't
 787    be imported. The function is cached when found, so subsequent calls
 788    don't import zlib again. Returns a *borrowed* reference.
 789    XXX This makes zlib.decompress immortal. */
 790 static PyObject *
 791 get_decompress_func(void)
 792 {
 793     static PyObject *decompress = NULL;
 794
 795     if (decompress == NULL) {
 796         PyObject *zlib;
 797         static int importing_zlib = 0;
 798
 799         if (importing_zlib != 0)
 800             /* Someone has a zlib.py[co] in their Zip file;
 801                let's avoid a stack overflow. */
 802             return NULL;
 803         importing_zlib = 1;
 804         zlib = PyImport_ImportModuleNoBlock("zlib");
 805         importing_zlib = 0;
 806         if (zlib != NULL) {
 807             decompress = PyObject_GetAttrString(zlib,
 808                                                 "decompress");
 809             Py_DECREF(zlib);
 810         }
 811         else
 812             PyErr_Clear();
 813         if (Py_VerboseFlag)
 814             PySys_WriteStderr("# zipimport: zlib %s\n",
 815                 zlib != NULL ? "available": "UNAVAILABLE");
 816     }
 817     return decompress;
 818 }
 819
 820 /* Given a path to a Zip file and a toc_entry, return the (uncompressed)
 821    data as a new reference. */
 822 static PyObject *
 823 get_data(char *archive, PyObject *toc_entry)
 824 {
 825     PyObject *raw_data, *data = NULL, *decompress;
 826     char *buf;
 827     FILE *fp;
 828     int err;
 829     Py_ssize_t bytes_read = 0;
 830     long l;
 831     char *datapath;
 832     long compress, data_size, file_size, file_offset, bytes_size;
 833     long time, date, crc;
 834
 835     if (!PyArg_ParseTuple(toc_entry, "slllllll", &datapath, &compress,
 836                           &data_size, &file_size, &file_offset, &time,
 837                           &date, &crc)) {
 838         return NULL;
 839     }
 840
 841     fp = fopen(archive, "rb");
 842     if (!fp) {
 843         PyErr_Format(PyExc_IOError,
 844            "zipimport: can not open file %s", archive);
 845         return NULL;
 846     }
 847
 848     /* Check to make sure the local file header is correct */
 849     fseek(fp, file_offset, 0);
 850     l = PyMarshal_ReadLongFromFile(fp);
 851     if (l != 0x04034B50) {
 852         /* Bad: Local File Header */
 853         PyErr_Format(ZipImportError,
 854                      "bad local file header in %s",
 855                      archive);
 856         fclose(fp);
 857         return NULL;
 858     }
 859     fseek(fp, file_offset + 26, 0);
 860     l = 30 + PyMarshal_ReadShortFromFile(fp) +
 861         PyMarshal_ReadShortFromFile(fp);        /* local header size */
 862     file_offset += l;           /* Start of file data */
 863
 864     bytes_size = compress == 0 ? data_size : data_size + 1;
 865     if (bytes_size == 0)
 866         bytes_size++;
 867     raw_data = PyBytes_FromStringAndSize((char *)NULL, bytes_size);
 868
 869     if (raw_data == NULL) {
 870         fclose(fp);
 871         return NULL;
 872     }
 873     buf = PyBytes_AsString(raw_data);
 874
 875     err = fseek(fp, file_offset, 0);
 876     if (err == 0)
 877         bytes_read = fread(buf, 1, data_size, fp);
 878     fclose(fp);
 879     if (err || bytes_read != data_size) {
 880         PyErr_SetString(PyExc_IOError,
 881                         "zipimport: can't read data");
 882         Py_DECREF(raw_data);
 883         return NULL;
 884     }
 885
 886     if (compress != 0) {
 887         buf[data_size] = 'Z';  /* saw this in zipfile.py */
 888         data_size++;
 889     }
 890     buf[data_size] = '\0';
 891
 892     if (compress == 0) {  /* data is not compressed */
 893         data = PyBytes_FromStringAndSize(buf, data_size);
 894         Py_DECREF(raw_data);
 895         return data;
 896     }
 897
 898     /* Decompress with zlib */
 899     decompress = get_decompress_func();
 900     if (decompress == NULL) {
 901         PyErr_SetString(ZipImportError,
 902                         "can't decompress data; "
 903                         "zlib not available");
 904         goto error;
 905     }
 906     data = PyObject_CallFunction(decompress, "Oi", raw_data, -15);
 907 error:
 908     Py_DECREF(raw_data);
 909     return data;
 910 }
 911
 912 /* Lenient date/time comparison function. The precision of the mtime
 913    in the archive is lower than the mtime stored in a .pyc: we
 914    must allow a difference of at most one second. */
 915 static int
 916 eq_mtime(time_t t1, time_t t2)
 917 {
 918     time_t d = t1 - t2;
 919     if (d < 0)
 920         d = -d;
 921     /* dostime only stores even seconds, so be lenient */
 922     return d <= 1;
 923 }
 924
 925 /* Given the contents of a .py[co] file in a buffer, unmarshal the data
 926    and return the code object. Return None if it the magic word doesn't
 927    match (we do this instead of raising an exception as we fall back
 928    to .py if available and we don't want to mask other errors).
 929    Returns a new reference. */
 930 static PyObject *
 931 unmarshal_code(char *pathname, PyObject *data, time_t mtime)
 932 {
 933     PyObject *code;
 934     char *buf = PyBytes_AsString(data);
 935     Py_ssize_t size = PyBytes_Size(data);
 936
 937     if (size <= 9) {
 938         PyErr_SetString(ZipImportError,
 939                         "bad pyc data");
 940         return NULL;
 941     }
 942
 943     if (get_long((unsigned char *)buf) != PyImport_GetMagicNumber()) {
 944         if (Py_VerboseFlag)
 945             PySys_WriteStderr("# %s has bad magic\n",
 946                               pathname);
 947         Py_INCREF(Py_None);
 948         return Py_None;  /* signal caller to try alternative */
 949     }
 950
 951     if (mtime != 0 && !eq_mtime(get_long((unsigned char *)buf + 4),
 952                                 mtime)) {
 953         if (Py_VerboseFlag)
 954             PySys_WriteStderr("# %s has bad mtime\n",
 955                               pathname);
 956         Py_INCREF(Py_None);
 957         return Py_None;  /* signal caller to try alternative */
 958     }
 959
 960     code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);
 961     if (code == NULL)
 962         return NULL;
 963     if (!PyCode_Check(code)) {
 964         Py_DECREF(code);
 965         PyErr_Format(PyExc_TypeError,
 966              "compiled module %.200s is not a code object",
 967              pathname);
 968         return NULL;
 969     }
 970     return code;
 971 }
 972
 973 /* Replace any occurances of "\r\n?" in the input string with "\n".
 974    This converts DOS and Mac line endings to Unix line endings.
 975    Also append a trailing "\n" to be compatible with
 976    PyParser_SimpleParseFile(). Returns a new reference. */
 977 static PyObject *
 978 normalize_line_endings(PyObject *source)
 979 {
 980     char *buf, *q, *p = PyBytes_AsString(source);
 981     PyObject *fixed_source;
 982     int len = 0;
 983
 984     if (!p) {
 985         return PyBytes_FromStringAndSize("\n\0", 2);
 986     }
 987
 988     /* one char extra for trailing \n and one for terminating \0 */
 989     buf = (char *)PyMem_Malloc(PyBytes_Size(source) + 2);
 990     if (buf == NULL) {
 991         PyErr_SetString(PyExc_MemoryError,
 992                         "zipimport: no memory to allocate "
 993                         "source buffer");
 994         return NULL;
 995     }
 996     /* replace "\r\n?" by "\n" */
 997     for (q = buf; *p != '\0'; p++) {
 998         if (*p == '\r') {
 999             *q++ = '\n';
1000             if (*(p + 1) == '\n')
1001                 p++;
1002         }
1003         else
1004             *q++ = *p;
1005         len++;
1006     }
1007     *q++ = '\n';  /* add trailing \n */
1008     *q = '\0';
1009     fixed_source = PyBytes_FromStringAndSize(buf, len + 2);
1010     PyMem_Free(buf);
1011     return fixed_source;
1012 }
1013
1014 /* Given a string buffer containing Python source code, compile it
1015    return and return a code object as a new reference. */
1016 static PyObject *
1017 compile_source(char *pathname, PyObject *source)
1018 {
1019     PyObject *code, *fixed_source;
1020
1021     fixed_source = normalize_line_endings(source);
1022     if (fixed_source == NULL)
1023         return NULL;
1024
1025     code = Py_CompileString(PyBytes_AsString(fixed_source), pathname,
1026                             Py_file_input);
1027     Py_DECREF(fixed_source);
1028     return code;
1029 }
1030
1031 /* Convert the date/time values found in the Zip archive to a value
1032    that's compatible with the time stamp stored in .pyc files. */
1033 static time_t
1034 parse_dostime(int dostime, int dosdate)
1035 {
1036     struct tm stm;
1037
1038     memset((void *) &stm, '\0', sizeof(stm));
1039
1040     stm.tm_sec   =  (dostime        & 0x1f) * 2;
1041     stm.tm_min   =  (dostime >> 5)  & 0x3f;
1042     stm.tm_hour  =  (dostime >> 11) & 0x1f;
1043     stm.tm_mday  =   dosdate        & 0x1f;
1044     stm.tm_mon   = ((dosdate >> 5)  & 0x0f) - 1;
1045     stm.tm_year  = ((dosdate >> 9)  & 0x7f) + 80;
1046     stm.tm_isdst =   -1; /* wday/yday is ignored */
1047
1048     return mktime(&stm);
1049 }
1050
1051 /* Given a path to a .pyc or .pyo file in the archive, return the
1052    modifictaion time of the matching .py file, or 0 if no source
1053    is available. */
1054 static time_t
1055 get_mtime_of_source(ZipImporter *self, char *path)
1056 {
1057     PyObject *toc_entry;
1058     time_t mtime = 0;
1059     Py_ssize_t lastchar = strlen(path) - 1;
1060     char savechar = path[lastchar];
1061     path[lastchar] = '\0';  /* strip 'c' or 'o' from *.py[co] */
1062     toc_entry = PyDict_GetItemString(self->files, path);
1063     if (toc_entry != NULL && PyTuple_Check(toc_entry) &&
1064         PyTuple_Size(toc_entry) == 8) {
1065         /* fetch the time stamp of the .py file for comparison
1066            with an embedded pyc time stamp */
1067         int time, date;
1068         time = PyLong_AsLong(PyTuple_GetItem(toc_entry, 5));
1069         date = PyLong_AsLong(PyTuple_GetItem(toc_entry, 6));
1070         mtime = parse_dostime(time, date);
1071     }
1072     path[lastchar] = savechar;
1073     return mtime;
1074 }
1075
1076 /* Return the code object for the module named by 'fullname' from the
1077    Zip archive as a new reference. */
1078 static PyObject *
1079 get_code_from_data(ZipImporter *self, int ispackage, int isbytecode,
1080                    time_t mtime, PyObject *toc_entry)
1081 {
1082     PyObject *data, *code;
1083     char *modpath;
1084     char *archive = _PyUnicode_AsString(self->archive);
1085
1086     if (archive == NULL)
1087         return NULL;
1088
1089     data = get_data(archive, toc_entry);
1090     if (data == NULL)
1091         return NULL;
1092
1093     modpath = _PyUnicode_AsString(PyTuple_GetItem(toc_entry, 0));
1094
1095     if (isbytecode) {
1096         code = unmarshal_code(modpath, data, mtime);
1097     }
1098     else {
1099         code = compile_source(modpath, data);
1100     }
1101     Py_DECREF(data);
1102     return code;
1103 }
1104
1105 /* Get the code object assoiciated with the module specified by
1106    'fullname'. */
1107 static PyObject *
1108 get_module_code(ZipImporter *self, char *fullname,
1109                 int *p_ispackage, char **p_modpath)
1110 {
1111     PyObject *toc_entry;
1112     char *subname, path[MAXPATHLEN + 1];
1113     int len;
1114     struct st_zip_searchorder *zso;
1115
1116     subname = get_subname(fullname);
1117
1118     len = make_filename(_PyUnicode_AsString(self->prefix), subname, path);
1119     if (len < 0)
1120         return NULL;
1121
1122     for (zso = zip_searchorder; *zso->suffix; zso++) {
1123         PyObject *code = NULL;
1124
1125         strcpy(path + len, zso->suffix);
1126         if (Py_VerboseFlag > 1)
1127             PySys_WriteStderr("# trying %s%c%s\n",
1128                               _PyUnicode_AsString(self->archive),
1129                               (int)SEP, path);
1130         toc_entry = PyDict_GetItemString(self->files, path);
1131         if (toc_entry != NULL) {
1132             time_t mtime = 0;
1133             int ispackage = zso->type & IS_PACKAGE;
1134             int isbytecode = zso->type & IS_BYTECODE;
1135
1136             if (isbytecode)
1137                 mtime = get_mtime_of_source(self, path);
1138             if (p_ispackage != NULL)
1139                 *p_ispackage = ispackage;
1140             code = get_code_from_data(self, ispackage,
1141                                       isbytecode, mtime,
1142                                       toc_entry);
1143             if (code == Py_None) {
1144                 /* bad magic number or non-matching mtime
1145                    in byte code, try next */
1146                 Py_DECREF(code);
1147                 continue;
1148             }
1149             if (code != NULL && p_modpath != NULL)
1150                 *p_modpath = _PyUnicode_AsString(
1151                     PyTuple_GetItem(toc_entry, 0));
1152             return code;
1153         }
1154     }
1155     PyErr_Format(ZipImportError, "can't find module '%.200s'", fullname);
1156     return NULL;
1157 }
1158
1159
1160 /* Module init */
1161
1162 PyDoc_STRVAR(zipimport_doc,
1163 "zipimport provides support for importing Python modules from Zip archives.\n\
1164 \n\
1165 This module exports three objects:\n\
1166 - zipimporter: a class; its constructor takes a path to a Zip archive.\n\
1167 - ZipImportError: exception raised by zipimporter objects. It's a\n\
1168   subclass of ImportError, so it can be caught as ImportError, too.\n\
1169 - _zip_directory_cache: a dict, mapping archive paths to zip directory\n\
1170   info dicts, as used in zipimporter._files.\n\
1171 \n\
1172 It is usually not needed to use the zipimport module explicitly; it is\n\
1173 used by the builtin import mechanism for sys.path items that are paths\n\
1174 to Zip archives.");
1175
1176 static struct PyModuleDef zipimportmodule = {
1177     PyModuleDef_HEAD_INIT,
1178     "zipimport",
1179     zipimport_doc,
1180     -1,
1181     NULL,
1182     NULL,
1183     NULL,
1184     NULL,
1185     NULL
1186 };
1187
1188 PyMODINIT_FUNC
1189 PyInit_zipimport(void)
1190 {
1191     PyObject *mod;
1192
1193     if (PyType_Ready(&ZipImporter_Type) < 0)
1194         return NULL;
1195
1196     /* Correct directory separator */
1197     zip_searchorder[0].suffix[0] = SEP;
1198     zip_searchorder[1].suffix[0] = SEP;
1199     zip_searchorder[2].suffix[0] = SEP;
1200     if (Py_OptimizeFlag) {
1201         /* Reverse *.pyc and *.pyo */
1202         struct st_zip_searchorder tmp;
1203         tmp = zip_searchorder[0];
1204         zip_searchorder[0] = zip_searchorder[1];
1205         zip_searchorder[1] = tmp;
1206         tmp = zip_searchorder[3];
1207         zip_searchorder[3] = zip_searchorder[4];
1208         zip_searchorder[4] = tmp;
1209     }
1210
1211     mod = PyModule_Create(&zipimportmodule);
1212     if (mod == NULL)
1213         return NULL;
1214
1215     ZipImportError = PyErr_NewException("zipimport.ZipImportError",
1216                                         PyExc_ImportError, NULL);
1217     if (ZipImportError == NULL)
1218         return NULL;
1219
1220     Py_INCREF(ZipImportError);
1221     if (PyModule_AddObject(mod, "ZipImportError",
1222                            ZipImportError) < 0)
1223         return NULL;
1224
1225     Py_INCREF(&ZipImporter_Type);
1226     if (PyModule_AddObject(mod, "zipimporter",
1227                            (PyObject *)&ZipImporter_Type) < 0)
1228         return NULL;
1229
1230     zip_directory_cache = PyDict_New();
1231     if (zip_directory_cache == NULL)
1232         return NULL;
1233     Py_INCREF(zip_directory_cache);
1234     if (PyModule_AddObject(mod, "_zip_directory_cache",
1235                            zip_directory_cache) < 0)
1236         return NULL;
1237     return mod;
1238 }