Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

zipimport.c

Last change on this file was 391, checked in by dmik, 11 years ago
python: Merge vendor 2.7.6 to trunk.
Property svn:eol-style set to `native`
File size: 37.3 KB

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

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

Context Navigation

source: python/trunk/Modules/zipimport.c

Download in other formats: