/*

 * Launch a python module from an archive.   

 * Copyright (C) 2005, Giovanni Bajo

 * Based on previous work under copyright (c) 2002 McMillan Enterprises, Inc.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * In addition to the permissions in the GNU General Public License, the

 * authors give you unlimited permission to link or embed the compiled

 * version of this file into combinations with other programs, and to

 * distribute those combinations without any restriction coming from the

 * use of this file. (The General Public License restrictions do apply in

 * other respects; for example, they cover modification of the file, and

 * distribution when not linked into a combine executable.)

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA

 */

#include <stdio.h>

#ifdef WIN32

 #include <windows.h>

 #include <direct.h>

 #include <process.h>

 #include <io.h>

#else

 #include <unistd.h>

 #include <fcntl.h>

 #include <dirent.h>

#endif

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include "launch.h"

#ifndef NOZLIB

#include "zlib.h"

#endif

#ifdef WIN32

/*

 * Python Entry point declarations (see macros in launch.h).

 */

DECLVAR(Py_NoSiteFlag);

DECLVAR(Py_OptimizeFlag);

DECLVAR(Py_VerboseFlag);

DECLPROC(Py_Initialize);

DECLPROC(Py_Finalize);

DECLPROC(Py_CompileString);

DECLPROC(PyImport_ExecCodeModule);

DECLPROC(PyRun_SimpleString);

DECLPROC(PySys_SetArgv);

DECLPROC(Py_SetProgramName);

DECLPROC(PyImport_ImportModule);

DECLPROC(PyImport_AddModule);

DECLPROC(PyObject_SetAttrString);

DECLPROC(PyList_New);

DECLPROC(PyList_Append);

DECLPROC(Py_BuildValue);

DECLPROC(PyFile_FromString);

DECLPROC(PyString_FromStringAndSize);

DECLPROC(PyObject_CallFunction);

DECLPROC(PyModule_GetDict);

DECLPROC(PyDict_GetItemString);

DECLPROC(PyErr_Clear);

DECLPROC(PyErr_Occurred);

DECLPROC(PyErr_Print);

DECLPROC(PyObject_CallObject);

DECLPROC(PyObject_CallMethod);

DECLPROC(PySys_AddWarnOption);

DECLPROC(PyEval_InitThreads);

DECLPROC(PyEval_AcquireThread);

DECLPROC(PyEval_ReleaseThread);

DECLPROC(PyEval_AcquireLock);

DECLPROC(PyEval_ReleaseLock);

DECLPROC(PyThreadState_Swap);

DECLPROC(PyThreadState_New);

DECLPROC(PyThreadState_Clear);

DECLPROC(PyThreadState_Delete);

DECLPROC(PyInterpreterState_New);

DECLPROC(Py_NewInterpreter);

DECLPROC(Py_EndInterpreter);

DECLPROC(PyInt_AsLong);

DECLPROC(PySys_SetObject);

#endif

#ifdef WIN32

#define PATHSEP ";"

#define SEP "/"

#else

#define PATHSEP ":"

#define SEP "/"

#endif

/* File Local Variables (all start with f_) */

static char f_archivename[_MAX_PATH+1];

static char f_homepath[_MAX_PATH+1];

static char f_temppath[_MAX_PATH+1] = { '\0' };

#ifdef WIN32

static char f_temppathraw[MAX_PATH+1];

static char f_homepathraw[_MAX_PATH+1];

#endif

static char *f_workpath = NULL;

static FILE *f_fp;

static int f_pkgstart;

static TOC *f_tocbuff = NULL;

static TOC *f_tocend = NULL;

static COOKIE f_cookie;

unsigned char *extract(TOC *ptoc);

/*

 * The functions in this file defined in reverse order so that forward 

 * declarations are not necessary.

 */

int testTempPath(char *buff)

{

	char base[16];

	int n;

	n = strlen(buff);

	if ( buff[n-1] == '/' || buff[n-1] == '\\' )

		sprintf(base, "_MEI%d", getpid());

	else

		sprintf(base, "%s_MEI%d", SEP, getpid());

	strcat(buff, base);

#ifdef WIN32

	if (mkdir(buff) == 0) {

#else

	if (mkdir(buff, 0700) == 0) {

#endif

		strcat(buff, SEP);

		return 1;

	}

	return 0;

}

void getTempPath(char *buff)

{

#ifdef WIN32

	GetTempPath(MAX_PATH, buff);

	testTempPath(buff);

#else

	static const char *envname[] = {

		"TMPDIR", "TEMP", "TMP", 0

	};

	static const char *dirname[] = {

		"/tmp", "/var/tmp", "/usr/tmp", 0

	};

	int i;

	char *p;

	for ( i=0; envname[i]; i++ ) {

		p = getenv(envname[i]);

		if (p) {

			strcpy(buff, p);

			if (testTempPath(buff))

				return;

		}

	}

	for ( i=0; dirname[i]; i++ ) {

		strcpy(buff, dirname[i]);

		if (testTempPath(buff))

			return;

	}

	buff[0] = '\0';

#endif

}

/*

 * Set up paths required by rest of this module

 * Sets f_archivename, f_homepath

 */

int setPaths(char const * archivePath, char const * archiveName)

{

#ifdef WIN32

	char *p;

#endif

	/* Get the archive Path */

	strcpy(f_archivename, archivePath);

	strcat(f_archivename, archiveName);

	/* Set homepath to where the archive is */

	strcpy(f_homepath, archivePath);

#ifdef WIN32

	strcpy(f_homepathraw, archivePath);

	for ( p = f_homepath; *p; p++ )

		if (*p == '\\')

			*p = '/';

#endif

	return 0;

}

/* 

 * Open the archive

 * Sets f_archiveFile, f_pkgstart, f_tocbuff and f_cookie.

 */

int openArchive()

{

	int filelen;

	/* Physically open the file */

	f_fp = fopen(f_archivename, "rb");

	if (f_fp == NULL) {

		VS("Cannot open archive: ");

		VS(f_archivename);

		VS("\n");

		return -1;

	}

	/* Seek to the Cookie at the end of the file. */

	fseek(f_fp, 0, SEEK_END);

	filelen = ftell(f_fp);

	if (fseek(f_fp, -(int)sizeof(COOKIE), SEEK_END)) 

	{

		VS(f_archivename);

		VS(" appears to be an invalid archive\n");

		return -1;

	}

	/* Read the Cookie, and check its MAGIC bytes */

	fread(&f_cookie, sizeof(COOKIE), 1, f_fp);

	if (strncmp(f_cookie.magic, MAGIC, strlen(MAGIC))) 

	{

		VS(f_archivename);

		VS(" has bad magic!\n");

		return -1;

	}

	/* From the cookie, calculate the archive start */

	f_pkgstart = filelen - ntohl(f_cookie.len);

	/* Read in in the table of contents */

	fseek(f_fp, f_pkgstart + ntohl(f_cookie.TOC), SEEK_SET);

	f_tocbuff = (TOC *) malloc(ntohl(f_cookie.TOClen));

	if (f_tocbuff == NULL) 

	{

		FATALERROR("Could not allocate buffer for TOC.");

		return -1;

	}

	fread(f_tocbuff, ntohl(f_cookie.TOClen), 1, f_fp);

	f_tocend = (TOC *) (((char *)f_tocbuff) + ntohl(f_cookie.TOClen));

	/* Check input file is still ok (should be). */

	if (ferror(f_fp))

	{

		FATALERROR("Error on file");

		return -1;

	}

	return 0;

}

#ifdef WIN32

int mapNames(HMODULE dll)

{

    /* Get all of the entry points that we are interested in */

	GETVAR(dll, Py_NoSiteFlag);

	GETVAR(dll, Py_OptimizeFlag);

	GETVAR(dll, Py_VerboseFlag);

	GETPROC(dll, Py_Initialize);

	GETPROC(dll, Py_Finalize);

	GETPROC(dll, Py_CompileString);

	GETPROC(dll, PyImport_ExecCodeModule);

	GETPROC(dll, PyRun_SimpleString);

	GETPROC(dll, PySys_SetArgv);

	GETPROC(dll, Py_SetProgramName);

	GETPROC(dll, PyImport_ImportModule);

	GETPROC(dll, PyImport_AddModule);

	GETPROC(dll, PyObject_SetAttrString);

	GETPROC(dll, PyList_New);

	GETPROC(dll, PyList_Append);

	GETPROC(dll, Py_BuildValue);

	GETPROC(dll, PyFile_FromString);

	GETPROC(dll, PyString_FromStringAndSize);

	GETPROC(dll, PyObject_CallFunction);

	GETPROC(dll, PyModule_GetDict);

	GETPROC(dll, PyDict_GetItemString);

	GETPROC(dll, PyErr_Clear);

	GETPROC(dll, PyErr_Occurred);

	GETPROC(dll, PyErr_Print);

	GETPROC(dll, PyObject_CallObject);

	GETPROC(dll, PyObject_CallMethod);

	if (ntohl(f_cookie.pyvers) >= 21) {

		GETPROC(dll, PySys_AddWarnOption);

	}

	GETPROC(dll, PyEval_InitThreads);

	GETPROC(dll, PyEval_AcquireThread);

	GETPROC(dll, PyEval_ReleaseThread);

	GETPROC(dll, PyEval_AcquireLock);

	GETPROC(dll, PyEval_ReleaseLock);

	GETPROC(dll, PyThreadState_Swap);

	GETPROC(dll, PyThreadState_New);

	GETPROC(dll, PyThreadState_Clear);

	GETPROC(dll, PyThreadState_Delete);

	GETPROC(dll, PyInterpreterState_New);

	GETPROC(dll, Py_NewInterpreter);

	GETPROC(dll, Py_EndInterpreter);

	GETPROC(dll, PyErr_Print);

	GETPROC(dll, PyInt_AsLong);

	GETPROC(dll, PySys_SetObject);

	return 0;

}

#endif

/*

 * Load the Python DLL, and get all of the necessary entry points

 * Windows only (dynamic load)

 */

int loadPython()

{

#ifdef WIN32

	HINSTANCE dll;

	char dllpath[_MAX_PATH + 1];

	/* Determine the path */

	sprintf(dllpath, "%spython%02d.dll", f_homepathraw, ntohl(f_cookie.pyvers));

	/* Load the DLL */

	dll = LoadLibraryEx(dllpath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);  

	if (dll) {

		VS(dllpath);

		VS("\n");

	}

	else {

		sprintf(dllpath, "%spython%02d.dll", f_temppathraw, ntohl(f_cookie.pyvers));

		dll = LoadLibraryEx(dllpath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH );

		if (dll) {

			VS(dllpath); 

			VS("\n");

		}

	}

	if (dll == 0) {

		FATALERROR("Error loading Python DLL: ");

		FATALERROR(dllpath);

		FATALERROR("\n");

		return -1;

	}

	mapNames(dll);

#endif

	return 0;

}

#ifdef WIN32

/*

 * use this from a dll instead of loadPython()

 * it will attach to an existing pythonXX.dll,

 * or load one if needed.

 */

int attachPython(int *loadedNew)

{

	HMODULE dll;

	char nm[_MAX_PATH + 1];

	/* Get python's name */

	sprintf(nm, "python%02d.dll", ntohl(f_cookie.pyvers));

	/* See if it's loaded */

	dll = GetModuleHandle(nm);  

	if (dll == 0) {

		*loadedNew = 1;

		return loadPython();

	}

	mapNames(dll);

	*loadedNew = 0;

	return 0;

}

#endif

/*

 * Return pointer to next toc entry.

 */

TOC *incrementTocPtr(TOC* ptoc)

{

	TOC *result = (TOC*)((char *)ptoc + ntohl(ptoc->structlen));

	if (result < f_tocbuff) {

		FATALERROR("Cannot read Table of Contents.\n");

		return f_tocend;

	}

	return result;

}

/*

 * external API for iterating TOCs

 */

TOC *getFirstTocEntry(void)

{

	return f_tocbuff;

}

TOC *getNextTocEntry(TOC *entry)

{

	TOC *rslt = (TOC*)((char *)entry + ntohl(entry->structlen));

	if (rslt >= f_tocend)

		return NULL;

	return rslt;

}

/*

 * A toc entry of type 'o' holds runtime options

 * toc->name is the arg

 * this is so you can freeze in command line args to Python

 */

int setRuntimeOptions(void)

{

	int unbuffered = 0;

	TOC *ptoc = f_tocbuff;

	while (ptoc < f_tocend) {

		if (ptoc->typcd == 'o') {

			VS(ptoc->name);

			VS("\n");

			switch (ptoc->name[0]) {

			case 'v':

#if defined  WIN32 

				*Py_VerboseFlag = 1;

#else

				Py_VerboseFlag = 1;

#endif

			break;

			case 'u':

				unbuffered = 1;

			break;

#ifdef HAVE_WARNINGS

			case 'W':

				if (ntohl(f_cookie.pyvers) >= 21) {

					PySys_AddWarnOption(&ptoc->name[2]);

				}

			break;

#endif

			case 's':

#if defined  WIN32 

				*Py_NoSiteFlag = 0;

#else

				Py_NoSiteFlag = 0;

#endif

			break;

			case 'O':

#if defined  WIN32 

				*Py_OptimizeFlag = 1;

#else

				Py_OptimizeFlag = 1;

#endif

			break;

			}

		}

		ptoc = incrementTocPtr(ptoc);

	}

	if (unbuffered) {

#ifdef WIN32

		_setmode(fileno(stdin), O_BINARY);

		_setmode(fileno(stdout), O_BINARY);

#else

		fflush(stdout);

		fflush(stderr);

#ifdef HAVE_SETVBUF

		setvbuf(stdin, (char *)NULL, _IONBF, 0);

		setvbuf(stdout, (char *)NULL, _IONBF, 0);

		setvbuf(stderr, (char *)NULL, _IONBF, 0);

#else

		setbuf(stdin, (char *)NULL);

		setbuf(stdout, (char *)NULL);

		setbuf(stderr, (char *)NULL);

#endif

#endif

	}

	return 0;

}

/*

 * Start python - return 0 on success

 */

int startPython(int argc, char *argv[])

{

    /* Set PYTHONPATH so dynamic libs will load */

	static char pypath[2*_MAX_PATH + 14];

	int pathlen = 1;

	int i;

	char cmd[_MAX_PATH+1+80];

	char tmp[_MAX_PATH+1];

	PyObject *py_argv;

	PyObject *val;

	PyObject *sys;

	VS("Manipulating evironment\n");

	if (f_workpath && (strcmp(f_workpath, f_homepath) != 0)) {

		strcpy(pypath, "PYTHONPATH=");

		strcat(pypath, f_workpath);

		pypath[strlen(pypath)-1] = '\0';

		strcat(pypath, PATHSEP);

		strcat(pypath, f_homepath);

		pathlen = 2;

	}

	else {

		/* never extracted anything, or extracted to homepath - homepath will do */

		strcpy(pypath, "PYTHONPATH=");

		strcat(pypath, f_homepath);

	}

	/* don't chop off SEP if root directory */

#ifdef WIN32

	if (strlen(pypath) > 14)

#else

	if (strlen(pypath) > 12)

#endif

		pypath[strlen(pypath)-1] = '\0';

	putenv(pypath);

	VS(pypath); 

	VS("\n");

	/* Clear out PYTHONHOME to avoid clashing with any installation */

#ifdef WIN32

	putenv("PYTHONHOME=");

#endif

	/* Start python. */

	/* VS("Loading python\n"); */

#if defined  WIN32 

	*Py_NoSiteFlag = 1;	/* maybe changed to 0 by setRuntimeOptions() */

#else

	Py_NoSiteFlag = 1;

#endif

	setRuntimeOptions();

#ifdef WIN32

	Py_SetProgramName(f_archivename); /*XXX*/

#endif

	Py_Initialize();

	/* Set sys.path */

	/* VS("Manipulating Python's sys.path\n"); */