Context Navigation

zipimport.c

Visit:

Last change on this file was 3225, checked in by bird, 18 years ago
Python 2.5
File size: 30.1 KB

Line
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	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: vendor/python/2.5/Modules/zipimport.c

Download in other formats: