| #include "Python.h" |
| #include "structmember.h" |
| #include "osdefs.h" |
| #include "marshal.h" |
| #include <time.h> |
| |
| |
| #define IS_SOURCE 0x0 |
| #define IS_BYTECODE 0x1 |
| #define IS_PACKAGE 0x2 |
| |
| struct st_zip_searchorder { |
| char suffix[14]; |
| int type; |
| }; |
| |
| /* zip_searchorder defines how we search for a module in the Zip |
| archive: we first search for a package __init__, then for |
| non-package .pyc, .pyo and .py entries. The .pyc and .pyo entries |
| are swapped by initzipimport() if we run in optimized mode. Also, |
| '/' is replaced by SEP there. */ |
| static struct st_zip_searchorder zip_searchorder[] = { |
| {"/__init__.pyc", IS_PACKAGE | IS_BYTECODE}, |
| {"/__init__.pyo", IS_PACKAGE | IS_BYTECODE}, |
| {"/__init__.py", IS_PACKAGE | IS_SOURCE}, |
| {".pyc", IS_BYTECODE}, |
| {".pyo", IS_BYTECODE}, |
| {".py", IS_SOURCE}, |
| {"", 0} |
| }; |
| |
| /* zipimporter object definition and support */ |
| |
| typedef struct _zipimporter ZipImporter; |
| |
| struct _zipimporter { |
| PyObject_HEAD |
| PyObject *archive; /* pathname of the Zip archive */ |
| PyObject *prefix; /* file prefix: "a/sub/directory/" */ |
| PyObject *files; /* dict with file info {path: toc_entry} */ |
| }; |
| |
| static PyObject *ZipImportError; |
| static PyObject *zip_directory_cache = NULL; |
| |
| /* forward decls */ |
| static PyObject *read_directory(char *archive); |
| static PyObject *get_data(char *archive, PyObject *toc_entry); |
| static PyObject *get_module_code(ZipImporter *self, char *fullname, |
| int *p_ispackage, char **p_modpath); |
| |
| |
| #define ZipImporter_Check(op) PyObject_TypeCheck(op, &ZipImporter_Type) |
| |
| |
| /* zipimporter.__init__ |
| Split the "subdirectory" from the Zip archive path, lookup a matching |
| entry in sys.path_importer_cache, fetch the file directory from there |
| if found, or else read it from the archive. */ |
| static int |
| zipimporter_init(ZipImporter *self, PyObject *args, PyObject *kwds) |
| { |
| char *path, *p, *prefix, buf[MAXPATHLEN+2]; |
| size_t len; |
| |
| if (!_PyArg_NoKeywords("zipimporter()", kwds)) |
| return -1; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter", |
| &path)) |
| return -1; |
| |
| len = strlen(path); |
| if (len == 0) { |
| PyErr_SetString(ZipImportError, "archive path is empty"); |
| return -1; |
| } |
| if (len >= MAXPATHLEN) { |
| PyErr_SetString(ZipImportError, |
| "archive path too long"); |
| return -1; |
| } |
| strcpy(buf, path); |
| |
| #ifdef ALTSEP |
| for (p = buf; *p; p++) { |
| if (*p == ALTSEP) |
| *p = SEP; |
| } |
| #endif |
| |
| path = NULL; |
| prefix = NULL; |
| for (;;) { |
| #ifndef RISCOS |
| struct stat statbuf; |
| int rv; |
| |
| rv = stat(buf, &statbuf); |
| if (rv == 0) { |
| /* it exists */ |
| if (S_ISREG(statbuf.st_mode)) |
| /* it's a file */ |
| path = buf; |
| break; |
| } |
| #else |
| if (object_exists(buf)) { |
| /* it exists */ |
| if (isfile(buf)) |
| /* it's a file */ |
| path = buf; |
| break; |
| } |
| #endif |
| /* back up one path element */ |
| p = strrchr(buf, SEP); |
| if (prefix != NULL) |
| *prefix = SEP; |
| if (p == NULL) |
| break; |
| *p = '\0'; |
| prefix = p; |
| } |
| if (path != NULL) { |
| PyObject *files; |
| files = PyDict_GetItemString(zip_directory_cache, path); |
| if (files == NULL) { |
| files = read_directory(buf); |
| if (files == NULL) |
| return -1; |
| if (PyDict_SetItemString(zip_directory_cache, path, |
| files) != 0) |
| return -1; |
| } |
| else |
| Py_INCREF(files); |
| self->files = files; |
| } |
| else { |
| PyErr_SetString(ZipImportError, "not a Zip file"); |
| return -1; |
| } |
| |
| if (prefix == NULL) |
| prefix = ""; |
| else { |
| prefix++; |
| len = strlen(prefix); |
| if (prefix[len-1] != SEP) { |
| /* add trailing SEP */ |
| prefix[len] = SEP; |
| prefix[len + 1] = '\0'; |
| } |
| } |
| |
| self->archive = PyString_FromString(buf); |
| if (self->archive == NULL) |
| return -1; |
| |
| self->prefix = PyString_FromString(prefix); |
| if (self->prefix == NULL) |
| return -1; |
| |
| return 0; |
| } |
| |
| /* GC support. */ |
| static int |
| zipimporter_traverse(PyObject *obj, visitproc visit, void *arg) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| Py_VISIT(self->files); |
| return 0; |
| } |
| |
| static void |
| zipimporter_dealloc(ZipImporter *self) |
| { |
| PyObject_GC_UnTrack(self); |
| Py_XDECREF(self->archive); |
| Py_XDECREF(self->prefix); |
| Py_XDECREF(self->files); |
| Py_TYPE(self)->tp_free((PyObject *)self); |
| } |
| |
| static PyObject * |
| zipimporter_repr(ZipImporter *self) |
| { |
| char buf[500]; |
| char *archive = "???"; |
| char *prefix = ""; |
| |
| if (self->archive != NULL && PyString_Check(self->archive)) |
| archive = PyString_AsString(self->archive); |
| if (self->prefix != NULL && PyString_Check(self->prefix)) |
| prefix = PyString_AsString(self->prefix); |
| if (prefix != NULL && *prefix) |
| PyOS_snprintf(buf, sizeof(buf), |
| "<zipimporter object \"%.300s%c%.150s\">", |
| archive, SEP, prefix); |
| else |
| PyOS_snprintf(buf, sizeof(buf), |
| "<zipimporter object \"%.300s\">", |
| archive); |
| return PyString_FromString(buf); |
| } |
| |
| /* return fullname.split(".")[-1] */ |
| static char * |
| get_subname(char *fullname) |
| { |
| char *subname = strrchr(fullname, '.'); |
| if (subname == NULL) |
| subname = fullname; |
| else |
| subname++; |
| return subname; |
| } |
| |
| /* Given a (sub)modulename, write the potential file path in the |
| archive (without extension) to the path buffer. Return the |
| length of the resulting string. */ |
| static int |
| make_filename(char *prefix, char *name, char *path) |
| { |
| size_t len; |
| char *p; |
| |
| len = strlen(prefix); |
| |
| /* self.prefix + name [+ SEP + "__init__"] + ".py[co]" */ |
| if (len + strlen(name) + 13 >= MAXPATHLEN) { |
| PyErr_SetString(ZipImportError, "path too long"); |
| return -1; |
| } |
| |
| strcpy(path, prefix); |
| strcpy(path + len, name); |
| for (p = path + len; *p; p++) { |
| if (*p == '.') |
| *p = SEP; |
| } |
| len += strlen(name); |
| assert(len < INT_MAX); |
| return (int)len; |
| } |
| |
| enum zi_module_info { |
| MI_ERROR, |
| MI_NOT_FOUND, |
| MI_MODULE, |
| MI_PACKAGE |
| }; |
| |
| /* Return some information about a module. */ |
| static enum zi_module_info |
| get_module_info(ZipImporter *self, char *fullname) |
| { |
| char *subname, path[MAXPATHLEN + 1]; |
| int len; |
| struct st_zip_searchorder *zso; |
| |
| subname = get_subname(fullname); |
| |
| len = make_filename(PyString_AsString(self->prefix), subname, path); |
| if (len < 0) |
| return MI_ERROR; |
| |
| for (zso = zip_searchorder; *zso->suffix; zso++) { |
| strcpy(path + len, zso->suffix); |
| if (PyDict_GetItemString(self->files, path) != NULL) { |
| if (zso->type & IS_PACKAGE) |
| return MI_PACKAGE; |
| else |
| return MI_MODULE; |
| } |
| } |
| return MI_NOT_FOUND; |
| } |
| |
| /* Check whether we can satisfy the import of the module named by |
| 'fullname'. Return self if we can, None if we can't. */ |
| static PyObject * |
| zipimporter_find_module(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| PyObject *path = NULL; |
| char *fullname; |
| enum zi_module_info mi; |
| |
| if (!PyArg_ParseTuple(args, "s|O:zipimporter.find_module", |
| &fullname, &path)) |
| return NULL; |
| |
| mi = get_module_info(self, fullname); |
| if (mi == MI_ERROR) |
| return NULL; |
| if (mi == MI_NOT_FOUND) { |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| Py_INCREF(self); |
| return (PyObject *)self; |
| } |
| |
| /* Load and return the module named by 'fullname'. */ |
| static PyObject * |
| zipimporter_load_module(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| PyObject *code, *mod, *dict; |
| char *fullname, *modpath; |
| int ispackage; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter.load_module", |
| &fullname)) |
| return NULL; |
| |
| code = get_module_code(self, fullname, &ispackage, &modpath); |
| if (code == NULL) |
| return NULL; |
| |
| mod = PyImport_AddModule(fullname); |
| if (mod == NULL) { |
| Py_DECREF(code); |
| return NULL; |
| } |
| dict = PyModule_GetDict(mod); |
| |
| /* mod.__loader__ = self */ |
| if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0) |
| goto error; |
| |
| if (ispackage) { |
| /* add __path__ to the module *before* the code gets |
| executed */ |
| PyObject *pkgpath, *fullpath; |
| char *prefix = PyString_AsString(self->prefix); |
| char *subname = get_subname(fullname); |
| int err; |
| |
| fullpath = PyString_FromFormat("%s%c%s%s", |
| PyString_AsString(self->archive), |
| SEP, |
| *prefix ? prefix : "", |
| subname); |
| if (fullpath == NULL) |
| goto error; |
| |
| pkgpath = Py_BuildValue("[O]", fullpath); |
| Py_DECREF(fullpath); |
| if (pkgpath == NULL) |
| goto error; |
| err = PyDict_SetItemString(dict, "__path__", pkgpath); |
| Py_DECREF(pkgpath); |
| if (err != 0) |
| goto error; |
| } |
| mod = PyImport_ExecCodeModuleEx(fullname, code, modpath); |
| Py_DECREF(code); |
| if (Py_VerboseFlag) |
| PySys_WriteStderr("import %s # loaded from Zip %s\n", |
| fullname, modpath); |
| return mod; |
| error: |
| Py_DECREF(code); |
| Py_DECREF(mod); |
| return NULL; |
| } |
| |
| /* Return a string matching __file__ for the named module */ |
| static PyObject * |
| zipimporter_get_filename(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| PyObject *code; |
| char *fullname, *modpath; |
| int ispackage; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter.get_filename", |
| &fullname)) |
| return NULL; |
| |
| /* Deciding the filename requires working out where the code |
| would come from if the module was actually loaded */ |
| code = get_module_code(self, fullname, &ispackage, &modpath); |
| if (code == NULL) |
| return NULL; |
| Py_DECREF(code); /* Only need the path info */ |
| |
| return PyString_FromString(modpath); |
| } |
| |
| /* Return a bool signifying whether the module is a package or not. */ |
| static PyObject * |
| zipimporter_is_package(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| char *fullname; |
| enum zi_module_info mi; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter.is_package", |
| &fullname)) |
| return NULL; |
| |
| mi = get_module_info(self, fullname); |
| if (mi == MI_ERROR) |
| return NULL; |
| if (mi == MI_NOT_FOUND) { |
| PyErr_Format(ZipImportError, "can't find module '%.200s'", |
| fullname); |
| return NULL; |
| } |
| return PyBool_FromLong(mi == MI_PACKAGE); |
| } |
| |
| static PyObject * |
| zipimporter_get_data(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| char *path; |
| #ifdef ALTSEP |
| char *p, buf[MAXPATHLEN + 1]; |
| #endif |
| PyObject *toc_entry; |
| Py_ssize_t len; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter.get_data", &path)) |
| return NULL; |
| |
| #ifdef ALTSEP |
| if (strlen(path) >= MAXPATHLEN) { |
| PyErr_SetString(ZipImportError, "path too long"); |
| return NULL; |
| } |
| strcpy(buf, path); |
| for (p = buf; *p; p++) { |
| if (*p == ALTSEP) |
| *p = SEP; |
| } |
| path = buf; |
| #endif |
| len = PyString_Size(self->archive); |
| if ((size_t)len < strlen(path) && |
| strncmp(path, PyString_AsString(self->archive), len) == 0 && |
| path[len] == SEP) { |
| path = path + len + 1; |
| } |
| |
| toc_entry = PyDict_GetItemString(self->files, path); |
| if (toc_entry == NULL) { |
| PyErr_SetFromErrnoWithFilename(PyExc_IOError, path); |
| return NULL; |
| } |
| return get_data(PyString_AsString(self->archive), toc_entry); |
| } |
| |
| static PyObject * |
| zipimporter_get_code(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| char *fullname; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter.get_code", &fullname)) |
| return NULL; |
| |
| return get_module_code(self, fullname, NULL, NULL); |
| } |
| |
| static PyObject * |
| zipimporter_get_source(PyObject *obj, PyObject *args) |
| { |
| ZipImporter *self = (ZipImporter *)obj; |
| PyObject *toc_entry; |
| char *fullname, *subname, path[MAXPATHLEN+1]; |
| int len; |
| enum zi_module_info mi; |
| |
| if (!PyArg_ParseTuple(args, "s:zipimporter.get_source", &fullname)) |
| return NULL; |
| |
| mi = get_module_info(self, fullname); |
| if (mi == MI_ERROR) |
| return NULL; |
| if (mi == MI_NOT_FOUND) { |
| PyErr_Format(ZipImportError, "can't find module '%.200s'", |
| fullname); |
| return NULL; |
| } |
| subname = get_subname(fullname); |
| |
| len = make_filename(PyString_AsString(self->prefix), subname, path); |
| if (len < 0) |
| return NULL; |
| |
| if (mi == MI_PACKAGE) { |
| path[len] = SEP; |
| strcpy(path + len + 1, "__init__.py"); |
| } |
| else |
| strcpy(path + len, ".py"); |
| |
| toc_entry = PyDict_GetItemString(self->files, path); |
| if (toc_entry != NULL) |
| return get_data(PyString_AsString(self->archive), toc_entry); |
| |
| /* we have the module, but no source */ |
| Py_INCREF(Py_None); |
| return Py_None; |
| } |
| |
| PyDoc_STRVAR(doc_find_module, |
| "find_module(fullname, path=None) -> self or None.\n\ |
| \n\ |
| Search for a module specified by 'fullname'. 'fullname' must be the\n\ |
| fully qualified (dotted) module name. It returns the zipimporter\n\ |
| instance itself if the module was found, or None if it wasn't.\n\ |
| The optional 'path' argument is ignored -- it's there for compatibility\n\ |
| with the importer protocol."); |
| |
| PyDoc_STRVAR(doc_load_module, |
| "load_module(fullname) -> module.\n\ |
| \n\ |
| Load the module specified by 'fullname'. 'fullname' must be the\n\ |
| fully qualified (dotted) module name. It returns the imported\n\ |
| module, or raises ZipImportError if it wasn't found."); |
| |
| PyDoc_STRVAR(doc_get_data, |
| "get_data(pathname) -> string with file data.\n\ |
| \n\ |
| Return the data associated with 'pathname'. Raise IOError if\n\ |
| the file wasn't found."); |
| |
| PyDoc_STRVAR(doc_is_package, |
| "is_package(fullname) -> bool.\n\ |
| \n\ |
| Return True if the module specified by fullname is a package.\n\ |
| Raise ZipImportError if the module couldn't be found."); |
| |
| PyDoc_STRVAR(doc_get_code, |
| "get_code(fullname) -> code object.\n\ |
| \n\ |
| Return the code object for the specified module. Raise ZipImportError\n\ |
| if the module couldn't be found."); |
| |
| PyDoc_STRVAR(doc_get_source, |
| "get_source(fullname) -> source string.\n\ |
| \n\ |
| Return the source code for the specified module. Raise ZipImportError\n\ |
| if the module couldn't be found, return None if the archive does\n\ |
| contain the module, but has no source for it."); |
| |
| |
| PyDoc_STRVAR(doc_get_filename, |
| "get_filename(fullname) -> filename string.\n\ |
| \n\ |
| Return the filename for the specified module."); |
| |
| static PyMethodDef zipimporter_methods[] = { |
| {"find_module", zipimporter_find_module, METH_VARARGS, |
| doc_find_module}, |
| {"load_module", zipimporter_load_module, METH_VARARGS, |
| doc_load_module}, |
| {"get_data", zipimporter_get_data, METH_VARARGS, |
| doc_get_data}, |
| {"get_code", zipimporter_get_code, METH_VARARGS, |
| doc_get_code}, |
| {"get_source", zipimporter_get_source, METH_VARARGS, |
| doc_get_source}, |
| {"get_filename", zipimporter_get_filename, METH_VARARGS, |
| doc_get_filename}, |
| {"is_package", zipimporter_is_package, METH_VARARGS, |
| doc_is_package}, |
| {NULL, NULL} /* sentinel */ |
| }; |
| |
| static PyMemberDef zipimporter_members[] = { |
| {"archive", T_OBJECT, offsetof(ZipImporter, archive), READONLY}, |
| {"prefix", T_OBJECT, offsetof(ZipImporter, prefix), READONLY}, |
| {"_files", T_OBJECT, offsetof(ZipImporter, files), READONLY}, |
| {NULL} |
| }; |
| |
| PyDoc_STRVAR(zipimporter_doc, |
| "zipimporter(archivepath) -> zipimporter object\n\ |
| \n\ |
| Create a new zipimporter instance. 'archivepath' must be a path to\n\ |
| a zipfile, or to a specific path inside a zipfile. For example, it can be\n\ |
| '/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a\n\ |
| valid directory inside the archive.\n\ |
| \n\ |
| 'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip\n\ |
| archive.\n\ |
| \n\ |
| The 'archive' attribute of zipimporter objects contains the name of the\n\ |
| zipfile targeted."); |
| |
| #define DEFERRED_ADDRESS(ADDR) 0 |
| |
| static PyTypeObject ZipImporter_Type = { |
| PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0) |
| "zipimport.zipimporter", |
| sizeof(ZipImporter), |
| 0, /* tp_itemsize */ |
| (destructor)zipimporter_dealloc, /* tp_dealloc */ |
| 0, /* tp_print */ |
| 0, /* tp_getattr */ |
| 0, /* tp_setattr */ |
| 0, /* tp_compare */ |
| (reprfunc)zipimporter_repr, /* tp_repr */ |
| 0, /* tp_as_number */ |
| 0, /* tp_as_sequence */ |
| 0, /* tp_as_mapping */ |
| 0, /* tp_hash */ |
| 0, /* tp_call */ |
| 0, /* tp_str */ |
| PyObject_GenericGetAttr, /* tp_getattro */ |
| 0, /* tp_setattro */ |
| 0, /* tp_as_buffer */ |
| Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | |
| Py_TPFLAGS_HAVE_GC, /* tp_flags */ |
| zipimporter_doc, /* tp_doc */ |
| zipimporter_traverse, /* tp_traverse */ |
| 0, /* tp_clear */ |
| 0, /* tp_richcompare */ |
| 0, /* tp_weaklistoffset */ |
| 0, /* tp_iter */ |
| 0, /* tp_iternext */ |
| zipimporter_methods, /* tp_methods */ |
| zipimporter_members, /* tp_members */ |
| 0, /* tp_getset */ |
| 0, /* tp_base */ |
| 0, /* tp_dict */ |
| 0, /* tp_descr_get */ |
| 0, /* tp_descr_set */ |
| 0, /* tp_dictoffset */ |
| (initproc)zipimporter_init, /* tp_init */ |
| PyType_GenericAlloc, /* tp_alloc */ |
| PyType_GenericNew, /* tp_new */ |
| PyObject_GC_Del, /* tp_free */ |
| }; |
| |
| |
| /* implementation */ |
| |
| /* Given a buffer, return the long that is represented by the first |
| 4 bytes, encoded as little endian. This partially reimplements |
| marshal.c:r_long() */ |
| static long |
| get_long(unsigned char *buf) { |
| long x; |
| x = buf[0]; |
| x |= (long)buf[1] << 8; |
| x |= (long)buf[2] << 16; |
| x |= (long)buf[3] << 24; |
| #if SIZEOF_LONG > 4 |
| /* Sign extension for 64-bit machines */ |
| x |= -(x & 0x80000000L); |
| #endif |
| return x; |
| } |
| |
| /* |
| read_directory(archive) -> files dict (new reference) |
| |
| Given a path to a Zip archive, build a dict, mapping file names |
| (local to the archive, using SEP as a separator) to toc entries. |
| |
| A toc_entry is a tuple: |
| |
| (__file__, # value to use for __file__, available for all files |
| compress, # compression kind; 0 for uncompressed |
| data_size, # size of compressed data on disk |
| file_size, # size of decompressed data |
| file_offset, # offset of file header from start of archive |
| time, # mod time of file (in dos format) |
| date, # mod data of file (in dos format) |
| crc, # crc checksum of the data |
| ) |
| |
| Directories can be recognized by the trailing SEP in the name, |
| data_size and file_offset are 0. |
| */ |
| static PyObject * |
| read_directory(char *archive) |
| { |
| PyObject *files = NULL; |
| FILE *fp; |
| long compress, crc, data_size, file_size, file_offset, date, time; |
| long header_offset, name_size, header_size, header_position; |
| long i, l, count; |
| size_t length; |
| char path[MAXPATHLEN + 5]; |
| char name[MAXPATHLEN + 5]; |
| char *p, endof_central_dir[22]; |
| long arc_offset; /* offset from beginning of file to start of zip-archive */ |
| |
| if (strlen(archive) > MAXPATHLEN) { |
| PyErr_SetString(PyExc_OverflowError, |
| "Zip path name is too long"); |
| return NULL; |
| } |
| strcpy(path, archive); |
| |
| fp = fopen(archive, "rb"); |
| if (fp == NULL) { |
| PyErr_Format(ZipImportError, "can't open Zip file: " |
| "'%.200s'", archive); |
| return NULL; |
| } |
| fseek(fp, -22, SEEK_END); |
| header_position = ftell(fp); |
| if (fread(endof_central_dir, 1, 22, fp) != 22) { |
| fclose(fp); |
| PyErr_Format(ZipImportError, "can't read Zip file: " |
| "'%.200s'", archive); |
| return NULL; |
| } |
| if (get_long((unsigned char *)endof_central_dir) != 0x06054B50) { |
| /* Bad: End of Central Dir signature */ |
| fclose(fp); |
| PyErr_Format(ZipImportError, "not a Zip file: " |
| "'%.200s'", archive); |
| return NULL; |
| } |
| |
| header_size = get_long((unsigned char *)endof_central_dir + 12); |
| header_offset = get_long((unsigned char *)endof_central_dir + 16); |
| arc_offset = header_position - header_offset - header_size; |
| header_offset += arc_offset; |
| |
| files = PyDict_New(); |
| if (files == NULL) |
| goto error; |
| |
| length = (long)strlen(path); |
| path[length] = SEP; |
| |
| /* Start of Central Directory */ |
| count = 0; |
| for (;;) { |
| PyObject *t; |
| int err; |
| |
| fseek(fp, header_offset, 0); /* Start of file header */ |
| l = PyMarshal_ReadLongFromFile(fp); |
| if (l != 0x02014B50) |
| break; /* Bad: Central Dir File Header */ |
| fseek(fp, header_offset + 10, 0); |
| compress = PyMarshal_ReadShortFromFile(fp); |
| time = PyMarshal_ReadShortFromFile(fp); |
| date = PyMarshal_ReadShortFromFile(fp); |
| crc = PyMarshal_ReadLongFromFile(fp); |
| data_size = PyMarshal_ReadLongFromFile(fp); |
| file_size = PyMarshal_ReadLongFromFile(fp); |
| name_size = PyMarshal_ReadShortFromFile(fp); |
| header_size = 46 + name_size + |
| PyMarshal_ReadShortFromFile(fp) + |
| PyMarshal_ReadShortFromFile(fp); |
| fseek(fp, header_offset + 42, 0); |
| file_offset = PyMarshal_ReadLongFromFile(fp) + arc_offset; |
| if (name_size > MAXPATHLEN) |
| name_size = MAXPATHLEN; |
| |
| p = name; |
| for (i = 0; i < name_size; i++) { |
| *p = (char)getc(fp); |
| if (*p == '/') |
| *p = SEP; |
| p++; |
| } |
| *p = 0; /* Add terminating null byte */ |
| header_offset += header_size; |
| |
| strncpy(path + length + 1, name, MAXPATHLEN - length - 1); |
| |
| t = Py_BuildValue("siiiiiii", path, compress, data_size, |
| file_size, file_offset, time, date, crc); |
| if (t == NULL) |
| goto error; |
| err = PyDict_SetItemString(files, name, t); |
| Py_DECREF(t); |
| if (err != 0) |
| goto error; |
| count++; |
| } |
| fclose(fp); |
| if (Py_VerboseFlag) |
| PySys_WriteStderr("# zipimport: found %ld names in %s\n", |
| count, archive); |
| return files; |
| error: |
| fclose(fp); |
| Py_XDECREF(files); |
| return NULL; |
| } |
| |
| /* Return the zlib.decompress function object, or NULL if zlib couldn't |
| be imported. The function is cached when found, so subsequent calls |
| don't import zlib again. */ |
| static PyObject * |
| get_decompress_func(void) |
| { |
| static int importing_zlib = 0; |
| PyObject *zlib; |
| PyObject *decompress; |
| |
| if (importing_zlib != 0) |
| /* Someone has a zlib.py[co] in their Zip file; |
| let's avoid a stack overflow. */ |
| return NULL; |
| importing_zlib = 1; |
| zlib = PyImport_ImportModuleNoBlock("zlib"); |
| importing_zlib = 0; |
| if (zlib != NULL) { |
| decompress = PyObject_GetAttrString(zlib, |
| "decompress"); |
| Py_DECREF(zlib); |
| } |
| else { |
| PyErr_Clear(); |
| decompress = NULL; |
| } |
| if (Py_VerboseFlag) |
| PySys_WriteStderr("# zipimport: zlib %s\n", |
| zlib != NULL ? "available": "UNAVAILABLE"); |
| return decompress; |
| } |
| |
| /* Given a path to a Zip file and a toc_entry, return the (uncompressed) |
| data as a new reference. */ |
| static PyObject * |
| get_data(char *archive, PyObject *toc_entry) |
| { |
| PyObject *raw_data, *data = NULL, *decompress; |
| char *buf; |
| FILE *fp; |
| int err; |
| Py_ssize_t bytes_read = 0; |
| long l; |
| char *datapath; |
| long compress, data_size, file_size, file_offset; |
| long time, date, crc; |
| |
| if (!PyArg_ParseTuple(toc_entry, "slllllll", &datapath, &compress, |
| &data_size, &file_size, &file_offset, &time, |
| &date, &crc)) { |
| return NULL; |
| } |
| |
| fp = fopen(archive, "rb"); |
| if (!fp) { |
| PyErr_Format(PyExc_IOError, |
| "zipimport: can not open file %s", archive); |
| return NULL; |
| } |
| |
| /* Check to make sure the local file header is correct */ |
| fseek(fp, file_offset, 0); |
| l = PyMarshal_ReadLongFromFile(fp); |
| if (l != 0x04034B50) { |
| /* Bad: Local File Header */ |
| PyErr_Format(ZipImportError, |
| "bad local file header in %s", |
| archive); |
| fclose(fp); |
| return NULL; |
| } |
| fseek(fp, file_offset + 26, 0); |
| l = 30 + PyMarshal_ReadShortFromFile(fp) + |
| PyMarshal_ReadShortFromFile(fp); /* local header size */ |
| file_offset += l; /* Start of file data */ |
| |
| raw_data = PyString_FromStringAndSize((char *)NULL, compress == 0 ? |
| data_size : data_size + 1); |
| if (raw_data == NULL) { |
| fclose(fp); |
| return NULL; |
| } |
| buf = PyString_AsString(raw_data); |
| |
| err = fseek(fp, file_offset, 0); |
| if (err == 0) |
| bytes_read = fread(buf, 1, data_size, fp); |
| fclose(fp); |
| if (err || bytes_read != data_size) { |
| PyErr_SetString(PyExc_IOError, |
| "zipimport: can't read data"); |
| Py_DECREF(raw_data); |
| return NULL; |
| } |
| |
| if (compress != 0) { |
| buf[data_size] = 'Z'; /* saw this in zipfile.py */ |
| data_size++; |
| } |
| buf[data_size] = '\0'; |
| |
| if (compress == 0) /* data is not compressed */ |
| return raw_data; |
| |
| /* Decompress with zlib */ |
| decompress = get_decompress_func(); |
| if (decompress == NULL) { |
| PyErr_SetString(ZipImportError, |
| "can't decompress data; " |
| "zlib not available"); |
| goto error; |
| } |
| data = PyObject_CallFunction(decompress, "Oi", raw_data, -15); |
| Py_DECREF(decompress); |
| error: |
| Py_DECREF(raw_data); |
| return data; |
| } |
| |
| /* Lenient date/time comparison function. The precision of the mtime |
| in the archive is lower than the mtime stored in a .pyc: we |
| must allow a difference of at most one second. */ |
| static int |
| eq_mtime(time_t t1, time_t t2) |
| { |
| time_t d = t1 - t2; |
| if (d < 0) |
| d = -d; |
| /* dostime only stores even seconds, so be lenient */ |
| return d <= 1; |
| } |
| |
| /* Given the contents of a .py[co] file in a buffer, unmarshal the data |
| and return the code object. Return None if it the magic word doesn't |
| match (we do this instead of raising an exception as we fall back |
| to .py if available and we don't want to mask other errors). |
| Returns a new reference. */ |
| static PyObject * |
| unmarshal_code(char *pathname, PyObject *data, time_t mtime) |
| { |
| PyObject *code; |
| char *buf = PyString_AsString(data); |
| Py_ssize_t size = PyString_Size(data); |
| |
| if (size <= 9) { |
| PyErr_SetString(ZipImportError, |
| "bad pyc data"); |
| return NULL; |
| } |
| |
| if (get_long((unsigned char *)buf) != PyImport_GetMagicNumber()) { |
| if (Py_VerboseFlag) |
| PySys_WriteStderr("# %s has bad magic\n", |
| pathname); |
| Py_INCREF(Py_None); |
| return Py_None; /* signal caller to try alternative */ |
| } |
| |
| if (mtime != 0 && !eq_mtime(get_long((unsigned char *)buf + 4), |
| mtime)) { |
| if (Py_VerboseFlag) |
| PySys_WriteStderr("# %s has bad mtime\n", |
| pathname); |
| Py_INCREF(Py_None); |
| return Py_None; /* signal caller to try alternative */ |
| } |
| |
| code = PyMarshal_ReadObjectFromString(buf + 8, size - 8); |
| if (code == NULL) |
| return NULL; |
| if (!PyCode_Check(code)) { |
| Py_DECREF(code); |
| PyErr_Format(PyExc_TypeError, |
| "compiled module %.200s is not a code object", |
| pathname); |
| return NULL; |
| } |
| return code; |
| } |
| |
| /* Replace any occurances of "\r\n?" in the input string with "\n". |
| This converts DOS and Mac line endings to Unix line endings. |
| Also append a trailing "\n" to be compatible with |
| PyParser_SimpleParseFile(). Returns a new reference. */ |
| static PyObject * |
| normalize_line_endings(PyObject *source) |
| { |
| char *buf, *q, *p = PyString_AsString(source); |
| PyObject *fixed_source; |
| |
| if (!p) |
| return NULL; |
| |
| /* one char extra for trailing \n and one for terminating \0 */ |
| buf = (char *)PyMem_Malloc(PyString_Size(source) + 2); |
| if (buf == NULL) { |
| PyErr_SetString(PyExc_MemoryError, |
| "zipimport: no memory to allocate " |
| "source buffer"); |
| return NULL; |
| } |
| /* replace "\r\n?" by "\n" */ |
| for (q = buf; *p != '\0'; p++) { |
| if (*p == '\r') { |
| *q++ = '\n'; |
| if (*(p + 1) == '\n') |
| p++; |
| } |
| else |
| *q++ = *p; |
| } |
| *q++ = '\n'; /* add trailing \n */ |
| *q = '\0'; |
| fixed_source = PyString_FromString(buf); |
| PyMem_Free(buf); |
| return fixed_source; |
| } |
| |
| /* Given a string buffer containing Python source code, compile it |
| return and return a code object as a new reference. */ |
| static PyObject * |
| compile_source(char *pathname, PyObject *source) |
| { |
| PyObject *code, *fixed_source; |
| |
| fixed_source = normalize_line_endings(source); |
| if (fixed_source == NULL) |
| return NULL; |
| |
| code = Py_CompileString(PyString_AsString(fixed_source), pathname, |
| Py_file_input); |
| Py_DECREF(fixed_source); |
| return code; |
| } |
| |
| /* Convert the date/time values found in the Zip archive to a value |
| that's compatible with the time stamp stored in .pyc files. */ |
| static time_t |
| parse_dostime(int dostime, int dosdate) |
| { |
| struct tm stm; |
| |
| memset((void *) &stm, '\0', sizeof(stm)); |
| |
| stm.tm_sec = (dostime & 0x1f) * 2; |
| stm.tm_min = (dostime >> 5) & 0x3f; |
| stm.tm_hour = (dostime >> 11) & 0x1f; |
| stm.tm_mday = dosdate & 0x1f; |
| stm.tm_mon = ((dosdate >> 5) & 0x0f) - 1; |
| stm.tm_year = ((dosdate >> 9) & 0x7f) + 80; |
| stm.tm_isdst = -1; /* wday/yday is ignored */ |
| |
| return mktime(&stm); |
| } |
| |
| /* Given a path to a .pyc or .pyo file in the archive, return the |
| modification time of the matching .py file, or 0 if no source |
| is available. */ |
| static time_t |
| get_mtime_of_source(ZipImporter *self, char *path) |
| { |
| PyObject *toc_entry; |
| time_t mtime = 0; |
| Py_ssize_t lastchar = strlen(path) - 1; |
| char savechar = path[lastchar]; |
| path[lastchar] = '\0'; /* strip 'c' or 'o' from *.py[co] */ |
| toc_entry = PyDict_GetItemString(self->files, path); |
| if (toc_entry != NULL && PyTuple_Check(toc_entry) && |
| PyTuple_Size(toc_entry) == 8) { |
| /* fetch the time stamp of the .py file for comparison |
| with an embedded pyc time stamp */ |
| int time, date; |
| time = PyInt_AsLong(PyTuple_GetItem(toc_entry, 5)); |
| date = PyInt_AsLong(PyTuple_GetItem(toc_entry, 6)); |
| mtime = parse_dostime(time, date); |
| } |
| path[lastchar] = savechar; |
| return mtime; |
| } |
| |
| /* Return the code object for the module named by 'fullname' from the |
| Zip archive as a new reference. */ |
| static PyObject * |
| get_code_from_data(ZipImporter *self, int ispackage, int isbytecode, |
| time_t mtime, PyObject *toc_entry) |
| { |
| PyObject *data, *code; |
| char *modpath; |
| char *archive = PyString_AsString(self->archive); |
| |
| if (archive == NULL) |
| return NULL; |
| |
| data = get_data(archive, toc_entry); |
| if (data == NULL) |
| return NULL; |
| |
| modpath = PyString_AsString(PyTuple_GetItem(toc_entry, 0)); |
| |
| if (isbytecode) { |
| code = unmarshal_code(modpath, data, mtime); |
| } |
| else { |
| code = compile_source(modpath, data); |
| } |
| Py_DECREF(data); |
| return code; |
| } |
| |
| /* Get the code object associated with the module specified by |
| 'fullname'. */ |
| static PyObject * |
| get_module_code(ZipImporter *self, char *fullname, |
| int *p_ispackage, char **p_modpath) |
| { |
| PyObject *toc_entry; |
| char *subname, path[MAXPATHLEN + 1]; |
| int len; |
| struct st_zip_searchorder *zso; |
| |
| subname = get_subname(fullname); |
| |
| len = make_filename(PyString_AsString(self->prefix), subname, path); |
| if (len < 0) |
| return NULL; |
| |
| for (zso = zip_searchorder; *zso->suffix; zso++) { |
| PyObject *code = NULL; |
| |
| strcpy(path + len, zso->suffix); |
| if (Py_VerboseFlag > 1) |
| PySys_WriteStderr("# trying %s%c%s\n", |
| PyString_AsString(self->archive), |
| SEP, path); |
| toc_entry = PyDict_GetItemString(self->files, path); |
| if (toc_entry != NULL) { |
| time_t mtime = 0; |
| int ispackage = zso->type & IS_PACKAGE; |
| int isbytecode = zso->type & IS_BYTECODE; |
| |
| if (isbytecode) |
| mtime = get_mtime_of_source(self, path); |
| if (p_ispackage != NULL) |
| *p_ispackage = ispackage; |
| code = get_code_from_data(self, ispackage, |
| isbytecode, mtime, |
| toc_entry); |
| if (code == Py_None) { |
| /* bad magic number or non-matching mtime |
| in byte code, try next */ |
| Py_DECREF(code); |
| continue; |
| } |
| if (code != NULL && p_modpath != NULL) |
| *p_modpath = PyString_AsString( |
| PyTuple_GetItem(toc_entry, 0)); |
| return code; |
| } |
| } |
| PyErr_Format(ZipImportError, "can't find module '%.200s'", fullname); |
| return NULL; |
| } |
| |
| |
| /* Module init */ |
| |
| PyDoc_STRVAR(zipimport_doc, |
| "zipimport provides support for importing Python modules from Zip archives.\n\ |
| \n\ |
| This module exports three objects:\n\ |
| - zipimporter: a class; its constructor takes a path to a Zip archive.\n\ |
| - ZipImportError: exception raised by zipimporter objects. It's a\n\ |
| subclass of ImportError, so it can be caught as ImportError, too.\n\ |
| - _zip_directory_cache: a dict, mapping archive paths to zip directory\n\ |
| info dicts, as used in zipimporter._files.\n\ |
| \n\ |
| It is usually not needed to use the zipimport module explicitly; it is\n\ |
| used by the builtin import mechanism for sys.path items that are paths\n\ |
| to Zip archives."); |
| |
| PyMODINIT_FUNC |
| initzipimport(void) |
| { |
| PyObject *mod; |
| |
| if (PyType_Ready(&ZipImporter_Type) < 0) |
| return; |
| |
| /* Correct directory separator */ |
| zip_searchorder[0].suffix[0] = SEP; |
| zip_searchorder[1].suffix[0] = SEP; |
| zip_searchorder[2].suffix[0] = SEP; |
| if (Py_OptimizeFlag) { |
| /* Reverse *.pyc and *.pyo */ |
| struct st_zip_searchorder tmp; |
| tmp = zip_searchorder[0]; |
| zip_searchorder[0] = zip_searchorder[1]; |
| zip_searchorder[1] = tmp; |
| tmp = zip_searchorder[3]; |
| zip_searchorder[3] = zip_searchorder[4]; |
| zip_searchorder[4] = tmp; |
| } |
| |
| mod = Py_InitModule4("zipimport", NULL, zipimport_doc, |
| NULL, PYTHON_API_VERSION); |
| if (mod == NULL) |
| return; |
| |
| ZipImportError = PyErr_NewException("zipimport.ZipImportError", |
| PyExc_ImportError, NULL); |
| if (ZipImportError == NULL) |
| return; |
| |
| Py_INCREF(ZipImportError); |
| if (PyModule_AddObject(mod, "ZipImportError", |
| ZipImportError) < 0) |
| return; |
| |
| Py_INCREF(&ZipImporter_Type); |
| if (PyModule_AddObject(mod, "zipimporter", |
| (PyObject *)&ZipImporter_Type) < 0) |
| return; |
| |
| zip_directory_cache = PyDict_New(); |
| if (zip_directory_cache == NULL) |
| return; |
| Py_INCREF(zip_directory_cache); |
| if (PyModule_AddObject(mod, "_zip_directory_cache", |
| zip_directory_cache) < 0) |
| return; |
| } |