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