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 	Py_TYPE(self)->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, or to a specific path inside a zipfile. For example, it can be\n\

   559 '/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a\n\

   560 valid directory inside the archive.\n\

   561 \n\

   562 'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip\n\

   563 archive.\n\

   564 \n\

   565 The 'archive' attribute of zipimporter objects contains the name of the\n\

   566 zipfile targeted.");

   567 

   568 #define DEFERRED_ADDRESS(ADDR) 0

   569 

   570 static PyTypeObject ZipImporter_Type = {

   571 	PyVarObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type), 0)

   572 	"zipimport.zipimporter",

   573 	sizeof(ZipImporter),

   574 	0,					/* tp_itemsize */

   575 	(destructor)zipimporter_dealloc,	/* tp_dealloc */

   576 	0,					/* tp_print */

   577 	0,					/* tp_getattr */

   578 	0,					/* tp_setattr */

   579 	0,					/* tp_compare */

   580 	(reprfunc)zipimporter_repr,		/* tp_repr */

   581 	0,					/* tp_as_number */

   582 	0,					/* tp_as_sequence */

   583 	0,					/* tp_as_mapping */

   584 	0,					/* tp_hash */

   585 	0,					/* tp_call */

   586 	0,					/* tp_str */

   587 	PyObject_GenericGetAttr,		/* tp_getattro */

   588 	0,					/* tp_setattro */

   589 	0,					/* tp_as_buffer */

   590 	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |

   591 		Py_TPFLAGS_HAVE_GC,		/* tp_flags */

   592 	zipimporter_doc,			/* tp_doc */

   593 	zipimporter_traverse,			/* tp_traverse */

   594 	0,					/* tp_clear */

   595 	0,					/* tp_richcompare */

   596 	0,					/* tp_weaklistoffset */

   597 	0,					/* tp_iter */

   598 	0,					/* tp_iternext */

   599 	zipimporter_methods,			/* tp_methods */

   600 	zipimporter_members,			/* tp_members */

   601 	0,					/* tp_getset */

   602 	0,					/* tp_base */

   603 	0,					/* tp_dict */

   604 	0,					/* tp_descr_get */

   605 	0,					/* tp_descr_set */

   606 	0,					/* tp_dictoffset */

   607 	(initproc)zipimporter_init,		/* tp_init */

   608 	PyType_GenericAlloc,			/* tp_alloc */

   609 	PyType_GenericNew,			/* tp_new */

   610 	PyObject_GC_Del,			/* tp_free */

   611 };

   612 

   613 

   614 /* implementation */

   615 

   616 /* Given a buffer, return the long that is represented by the first

   617    4 bytes, encoded as little endian. This partially reimplements

   618    marshal.c:r_long() */

   619 static long

   620 get_long(unsigned char *buf) {

   621 	long x;

   622 	x =  buf[0];

   623 	x |= (long)buf[1] <<  8;

   624 	x |= (long)buf[2] << 16;

   625 	x |= (long)buf[3] << 24;

   626 #if SIZEOF_LONG > 4

   627 	/* Sign extension for 64-bit machines */

   628 	x |= -(x & 0x80000000L);

   629 #endif

   630 	return x;

   631 }

   632 

   633 /*

   634    read_directory(archive) -> files dict (new reference)

   635 

   636    Given a path to a Zip archive, build a dict, mapping file names

   637    (local to the archive, using SEP as a separator) to toc entries.

   638 

   639    A toc_entry is a tuple:

   640 

   641        (__file__,      # value to use for __file__, available for all files

   642         compress,      # compression kind; 0 for uncompressed

   643         data_size,     # size of compressed data on disk

   644         file_size,     # size of decompressed data

   645         file_offset,   # offset of file header from start of archive

   646         time,          # mod time of file (in dos format)

   647         date,          # mod data of file (in dos format)

   648         crc,           # crc checksum of the data

   649        )

   650 

   651    Directories can be recognized by the trailing SEP in the name,

   652    data_size and file_offset are 0.

   653 */

   654 static PyObject *

   655 read_directory(char *archive)

   656 {

   657 	PyObject *files = NULL;

   658 	FILE *fp;

   659 	long compress, crc, data_size, file_size, file_offset, date, time;

   660 	long header_offset, name_size, header_size, header_position;

   661 	long i, l, count;

   662 	size_t length;

   663 	char path[MAXPATHLEN + 5];

   664 	char name[MAXPATHLEN + 5];

   665 	char *p, endof_central_dir[22];

   666 	long arc_offset; /* offset from beginning of file to start of zip-archive */

   667 

   668 	if (strlen(archive) > MAXPATHLEN) {

   669 		PyErr_SetString(PyExc_OverflowError,

   670 				"Zip path name is too long");

   671 		return NULL;

   672 	}

   673 	strcpy(path, archive);

   674 

   675 	fp = fopen(archive, "rb");

   676 	if (fp == NULL) {

   677 		PyErr_Format(ZipImportError, "can't open Zip file: "

   678 			     "'%.200s'", archive);

   679 		return NULL;

   680 	}

   681 	fseek(fp, -22, SEEK_END);

   682 	header_position = ftell(fp);

   683 	if (fread(endof_central_dir, 1, 22, fp) != 22) {

   684 		fclose(fp);

   685 		PyErr_Format(ZipImportError, "can't read Zip file: "

   686 			     "'%.200s'", archive);

   687 		return NULL;

   688 	}

   689 	if (get_long((unsigned char *)endof_central_dir) != 0x06054B50) {

   690 		/* Bad: End of Central Dir signature */

   691 		fclose(fp);

   692 		PyErr_Format(ZipImportError, "not a Zip file: "

   693 			     "'%.200s'", archive);

   694 		return NULL;

   695 	}

   696 

   697 	header_size = get_long((unsigned char *)endof_central_dir + 12);

   698 	header_offset = get_long((unsigned char *)endof_central_dir + 16);

   699 	arc_offset = header_position - header_offset - header_size;

   700 	header_offset += arc_offset;

   701 

   702 	files = PyDict_New();

   703 	if (files == NULL)

   704 		goto error;

   705 

   706 	length = (long)strlen(path);

   707 	path[length] = SEP;

   708 

   709 	/* Start of Central Directory */

   710 	count = 0;

   711 	for (;;) {

   712 		PyObject *t;

   713 		int err;

   714 

   715 		fseek(fp, header_offset, 0);  /* Start of file header */

   716 		l = PyMarshal_ReadLongFromFile(fp);

   717 		if (l != 0x02014B50)

   718 			break;	/* Bad: Central Dir File Header */

   719 		fseek(fp, header_offset + 10, 0);

   720 		compress = PyMarshal_ReadShortFromFile(fp);

   721 		time = PyMarshal_ReadShortFromFile(fp);

   722 		date = PyMarshal_ReadShortFromFile(fp);

   723 		crc = PyMarshal_ReadLongFromFile(fp);

   724 		data_size = PyMarshal_ReadLongFromFile(fp);

   725 		file_size = PyMarshal_ReadLongFromFile(fp);

   726 		name_size = PyMarshal_ReadShortFromFile(fp);

   727 		header_size = 46 + name_size +

   728 		   PyMarshal_ReadShortFromFile(fp) +

   729 		   PyMarshal_ReadShortFromFile(fp);

   730 		fseek(fp, header_offset + 42, 0);

   731 		file_offset = PyMarshal_ReadLongFromFile(fp) + arc_offset;

   732 		if (name_size > MAXPATHLEN)

   733 			name_size = MAXPATHLEN;

   734 

   735 		p = name;

   736 		for (i = 0; i < name_size; i++) {

   737 			*p = (char)getc(fp);

   738 			if (*p == '/')

   739 				*p = SEP;

   740 			p++;

   741 		}

   742 		*p = 0;	/* Add terminating null byte */

   743 		header_offset += header_size;

   744 

   745 		strncpy(path + length + 1, name, MAXPATHLEN - length - 1);

   746 

   747 		t = Py_BuildValue("siiiiiii", path, compress, data_size,

   748 				  file_size, file_offset, time, date, crc);

   749 		if (t == NULL)

   750 			goto error;

   751 		err = PyDict_SetItemString(files, name, t);

   752 		Py_DECREF(t);

   753 		if (err != 0)

   754 			goto error;

   755 		count++;

   756 	}

   757 	fclose(fp);

   758 	if (Py_VerboseFlag)

   759 		PySys_WriteStderr("# zipimport: found %ld names in %s\n",

   760 			count, archive);

   761 	return files;

   762 error:

   763 	fclose(fp);

   764 	Py_XDECREF(files);

   765 	return NULL;

   766 }

   767 

   768 /* Return the zlib.decompress function object, or NULL if zlib couldn't

   769    be imported. The function is cached when found, so subsequent calls

   770    don't import zlib again. Returns a *borrowed* reference.

   771    XXX This makes zlib.decompress immortal. */

   772 static PyObject *

   773 get_decompress_func(void)

   774 {

   775 	static PyObject *decompress = NULL;

   776 

   777 	if (decompress == NULL) {

   778 		PyObject *zlib;

   779 		static int importing_zlib = 0;

   780 

   781 		if (importing_zlib != 0)

   782 			/* Someone has a zlib.py[co] in their Zip file;

   783 			   let's avoid a stack overflow. */

   784 			return NULL;

   785 		importing_zlib = 1;

   786 		zlib = PyImport_ImportModuleNoBlock("zlib");

   787 		importing_zlib = 0;

   788 		if (zlib != NULL) {

   789 			decompress = PyObject_GetAttrString(zlib,

   790 							    "decompress");

   791 			Py_DECREF(zlib);

   792 		}

   793 		else

   794 			PyErr_Clear();

   795 		if (Py_VerboseFlag)

   796 			PySys_WriteStderr("# zipimport: zlib %s\n",

   797 				zlib != NULL ? "available": "UNAVAILABLE");

   798 	}

   799 	return decompress;

   800 }

   801 

   802 /* Given a path to a Zip file and a toc_entry, return the (uncompressed)

   803    data as a new reference. */

   804 static PyObject *

   805 get_data(char *archive, PyObject *toc_entry)

   806 {

   807 	PyObject *raw_data, *data = NULL, *decompress;

   808 	char *buf;

   809 	FILE *fp;

   810 	int err;

   811 	Py_ssize_t bytes_read = 0;

   812 	long l;

   813 	char *datapath;

   814 	long compress, data_size, file_size, file_offset;

   815 	long time, date, crc;

   816 

   817 	if (!PyArg_ParseTuple(toc_entry, "slllllll", &datapath, &compress,

   818 			      &data_size, &file_size, &file_offset, &time,

   819 			      &date, &crc)) {

   820 		return NULL;

   821 	}

   822 

   823 	fp = fopen(archive, "rb");

   824 	if (!fp) {

   825 		PyErr_Format(PyExc_IOError,

   826 		   "zipimport: can not open file %s", archive);

   827 		return NULL;

   828 	}

   829 

   830 	/* Check to make sure the local file header is correct */

   831 	fseek(fp, file_offset, 0);

   832 	l = PyMarshal_ReadLongFromFile(fp);

   833 	if (l != 0x04034B50) {

   834 		/* Bad: Local File Header */

   835 		PyErr_Format(ZipImportError,

   836 			     "bad local file header in %s",

   837 			     archive);

   838 		fclose(fp);

   839 		return NULL;

   840 	}

   841 	fseek(fp, file_offset + 26, 0);

   842 	l = 30 + PyMarshal_ReadShortFromFile(fp) +

   843 	    PyMarshal_ReadShortFromFile(fp);	/* local header size */

   844 	file_offset += l;	/* Start of file data */

   845 

   846 	raw_data = PyString_FromStringAndSize((char *)NULL, compress == 0 ?

   847 					      data_size : data_size + 1);

   848 	if (raw_data == NULL) {

   849 		fclose(fp);

   850 		return NULL;

   851 	}

   852 	buf = PyString_AsString(raw_data);

   853 

   854 	err = fseek(fp, file_offset, 0);

   855 	if (err == 0)

   856 		bytes_read = fread(buf, 1, data_size, fp);

   857 	fclose(fp);

   858 	if (err || bytes_read != data_size) {

   859 		PyErr_SetString(PyExc_IOError,

   860 				"zipimport: can't read data");

   861 		Py_DECREF(raw_data);

   862 		return NULL;

   863 	}

   864 

   865 	if (compress != 0) {

   866 		buf[data_size] = 'Z';  /* saw this in zipfile.py */

   867 		data_size++;

   868 	}

   869 	buf[data_size] = '\0';

   870 

   871 	if (compress == 0)  /* data is not compressed */

   872 		return raw_data;

   873 

   874 	/* Decompress with zlib */

   875 	decompress = get_decompress_func();

   876 	if (decompress == NULL) {

   877 		PyErr_SetString(ZipImportError,

   878 				"can't decompress data; "

   879 				"zlib not available");

   880 		goto error;

   881 	}

   882 	data = PyObject_CallFunction(decompress, "Oi", raw_data, -15);

   883 error:

   884 	Py_DECREF(raw_data);

   885 	return data;

   886 }

   887 

   888 /* Lenient date/time comparison function. The precision of the mtime

   889    in the archive is lower than the mtime stored in a .pyc: we

   890    must allow a difference of at most one second. */

   891 static int

   892 eq_mtime(time_t t1, time_t t2)

   893 {

   894 	time_t d = t1 - t2;

   895 	if (d < 0)

   896 		d = -d;

   897 	/* dostime only stores even seconds, so be lenient */

   898 	return d <= 1;

   899 }

   900 

   901 /* Given the contents of a .py[co] file in a buffer, unmarshal the data

   902    and return the code object. Return None if it the magic word doesn't

   903    match (we do this instead of raising an exception as we fall back

   904    to .py if available and we don't want to mask other errors).

   905    Returns a new reference. */

   906 static PyObject *

   907 unmarshal_code(char *pathname, PyObject *data, time_t mtime)

   908 {

   909 	PyObject *code;

   910 	char *buf = PyString_AsString(data);

   911 	Py_ssize_t size = PyString_Size(data);

   912 

   913 	if (size <= 9) {

   914 		PyErr_SetString(ZipImportError,

   915 				"bad pyc data");

   916 		return NULL;

   917 	}

   918 

   919 	if (get_long((unsigned char *)buf) != PyImport_GetMagicNumber()) {

   920 		if (Py_VerboseFlag)

   921 			PySys_WriteStderr("# %s has bad magic\n",

   922 					  pathname);

   923 		Py_INCREF(Py_None);

   924 		return Py_None;  /* signal caller to try alternative */

   925 	}

   926 

   927 	if (mtime != 0 && !eq_mtime(get_long((unsigned char *)buf + 4),

   928 				    mtime)) {

   929 		if (Py_VerboseFlag)

   930 			PySys_WriteStderr("# %s has bad mtime\n",

   931 					  pathname);

   932 		Py_INCREF(Py_None);

   933 		return Py_None;  /* signal caller to try alternative */

   934 	}

   935 

   936 	code = PyMarshal_ReadObjectFromString(buf + 8, size - 8);

   937 	if (code == NULL)

   938 		return NULL;

   939 	if (!PyCode_Check(code)) {

   940 		Py_DECREF(code);

   941 		PyErr_Format(PyExc_TypeError,

   942 		     "compiled module %.200s is not a code object",

   943 		     pathname);

   944 		return NULL;

   945 	}

   946 	return code;

   947 }

   948 

   949 /* Replace any occurances of "\r\n?" in the input string with "\n".

   950    This converts DOS and Mac line endings to Unix line endings.

   951    Also append a trailing "\n" to be compatible with

   952    PyParser_SimpleParseFile(). Returns a new reference. */

   953 static PyObject *

   954 normalize_line_endings(PyObject *source)

   955 {

   956 	char *buf, *q, *p = PyString_AsString(source);

   957 	PyObject *fixed_source;

   958 

   959 	if (!p)

   960 		return NULL;

   961 

   962 	/* one char extra for trailing \n and one for terminating \0 */

   963 	buf = (char *)PyMem_Malloc(PyString_Size(source) + 2);

   964 	if (buf == NULL) {

   965 		PyErr_SetString(PyExc_MemoryError,

   966 				"zipimport: no memory to allocate "

   967 				"source buffer");

   968 		return NULL;

   969 	}

   970 	/* replace "\r\n?" by "\n" */

   971 	for (q = buf; *p != '\0'; p++) {

   972 		if (*p == '\r') {

   973 			*q++ = '\n';

   974 			if (*(p + 1) == '\n')

   975 				p++;

   976 		}

   977 		else

   978 			*q++ = *p;

   979 	}

   980 	*q++ = '\n';  /* add trailing \n */

   981 	*q = '\0';

   982 	fixed_source = PyString_FromString(buf);

   983 	PyMem_Free(buf);

   984 	return fixed_source;

   985 }

   986 

   987 /* Given a string buffer containing Python source code, compile it

   988    return and return a code object as a new reference. */

   989 static PyObject *

   990 compile_source(char *pathname, PyObject *source)

   991 {

   992 	PyObject *code, *fixed_source;

   993 

   994 	fixed_source = normalize_line_endings(source);

   995 	if (fixed_source == NULL)

   996 		return NULL;

   997 

   998 	code = Py_CompileString(PyString_AsString(fixed_source), pathname,

   999 				Py_file_input);

  1000 	Py_DECREF(fixed_source);

  1001 	return code;

  1002 }

  1003 

  1004 /* Convert the date/time values found in the Zip archive to a value

  1005    that's compatible with the time stamp stored in .pyc files. */

  1006 static time_t

  1007 parse_dostime(int dostime, int dosdate)

  1008 {

  1009 	struct tm stm;

  1010 

  1011 	memset((void *) &stm, '\0', sizeof(stm));

  1012 

  1013 	stm.tm_sec   =  (dostime        & 0x1f) * 2;

  1014 	stm.tm_min   =  (dostime >> 5)  & 0x3f;

  1015 	stm.tm_hour  =  (dostime >> 11) & 0x1f;

  1016 	stm.tm_mday  =   dosdate        & 0x1f;

  1017 	stm.tm_mon   = ((dosdate >> 5)  & 0x0f) - 1;

  1018 	stm.tm_year  = ((dosdate >> 9)  & 0x7f) + 80;

  1019 	stm.tm_isdst =   -1; /* wday/yday is ignored */

  1020 

  1021 	return mktime(&stm);

  1022 }

  1023 

  1024 /* Given a path to a .pyc or .pyo file in the archive, return the

  1025    modifictaion time of the matching .py file, or 0 if no source

  1026    is available. */

  1027 static time_t

  1028 get_mtime_of_source(ZipImporter *self, char *path)

  1029 {

  1030 	PyObject *toc_entry;

  1031 	time_t mtime = 0;

  1032 	Py_ssize_t lastchar = strlen(path) - 1;

  1033 	char savechar = path[lastchar];

  1034 	path[lastchar] = '\0';  /* strip 'c' or 'o' from *.py[co] */

  1035 	toc_entry = PyDict_GetItemString(self->files, path);

  1036 	if (toc_entry != NULL && PyTuple_Check(toc_entry) &&

  1037 	    PyTuple_Size(toc_entry) == 8) {

  1038 		/* fetch the time stamp of the .py file for comparison

  1039 		   with an embedded pyc time stamp */

  1040 		int time, date;

  1041 		time = PyInt_AsLong(PyTuple_GetItem(toc_entry, 5));

  1042 		date = PyInt_AsLong(PyTuple_GetItem(toc_entry, 6));

  1043 		mtime = parse_dostime(time, date);

  1044 	}

  1045 	path[lastchar] = savechar;

  1046 	return mtime;

  1047 }

  1048 

  1049 /* Return the code object for the module named by 'fullname' from the

  1050    Zip archive as a new reference. */

  1051 static PyObject *

  1052 get_code_from_data(ZipImporter *self, int ispackage, int isbytecode,

  1053 		   time_t mtime, PyObject *toc_entry)

  1054 {

  1055 	PyObject *data, *code;

  1056 	char *modpath;

  1057 	char *archive = PyString_AsString(self->archive);

  1058 

  1059 	if (archive == NULL)

  1060 		return NULL;

  1061 

  1062 	data = get_data(archive, toc_entry);

  1063 	if (data == NULL)

  1064 		return NULL;

  1065 

  1066 	modpath = PyString_AsString(PyTuple_GetItem(toc_entry, 0));

  1067 

  1068 	if (isbytecode) {

  1069 		code = unmarshal_code(modpath, data, mtime);

  1070 	}

  1071 	else {

  1072 		code = compile_source(modpath, data);

  1073 	}

  1074 	Py_DECREF(data);

  1075 	return code;

  1076 }

  1077 

  1078 /* Get the code object assoiciated with the module specified by

  1079    'fullname'. */

  1080 static PyObject *

  1081 get_module_code(ZipImporter *self, char *fullname,

  1082 		int *p_ispackage, char **p_modpath)

  1083 {

  1084 	PyObject *toc_entry;

  1085 	char *subname, path[MAXPATHLEN + 1];

  1086 	int len;

  1087 	struct st_zip_searchorder *zso;

  1088 

  1089 	subname = get_subname(fullname);

  1090 

  1091 	len = make_filename(PyString_AsString(self->prefix), subname, path);

  1092 	if (len < 0)

  1093 		return NULL;

  1094 

  1095 	for (zso = zip_searchorder; *zso->suffix; zso++) {

  1096 		PyObject *code = NULL;

  1097 

  1098 		strcpy(path + len, zso->suffix);

  1099 		if (Py_VerboseFlag > 1)

  1100 			PySys_WriteStderr("# trying %s%c%s\n",

  1101 					  PyString_AsString(self->archive),

  1102 					  SEP, path);

  1103 		toc_entry = PyDict_GetItemString(self->files, path);

  1104 		if (toc_entry != NULL) {

  1105 			time_t mtime = 0;

  1106 			int ispackage = zso->type & IS_PACKAGE;

  1107 			int isbytecode = zso->type & IS_BYTECODE;

  1108 

  1109 			if (isbytecode)

  1110 				mtime = get_mtime_of_source(self, path);

  1111 			if (p_ispackage != NULL)

  1112 				*p_ispackage = ispackage;

  1113 			code = get_code_from_data(self, ispackage,

  1114 						  isbytecode, mtime,

  1115 						  toc_entry);

  1116 			if (code == Py_None) {

  1117 				/* bad magic number or non-matching mtime

  1118 				   in byte code, try next */

  1119 				Py_DECREF(code);

  1120 				continue;

  1121 			}

  1122 			if (code != NULL && p_modpath != NULL)

  1123 				*p_modpath = PyString_AsString(

  1124 					PyTuple_GetItem(toc_entry, 0));

  1125 			return code;

  1126 		}

  1127 	}

  1128 	PyErr_Format(ZipImportError, "can't find module '%.200s'", fullname);

  1129 	return NULL;

  1130 }

  1131 

  1132 

  1133 /* Module init */

  1134 

  1135 PyDoc_STRVAR(zipimport_doc,