/*

  IMPORTANT NOTE: IF THIS FILE IS CHANGED, WININST-6.EXE MUST BE RECOMPILED

  WITH THE MSVC6 WININST.DSW WORKSPACE FILE MANUALLY, AND WININST-7.1.EXE MUST

  BE RECOMPILED WITH THE MSVC 2003.NET WININST-7.1.VCPROJ FILE MANUALLY.

  IF CHANGES TO THIS FILE ARE CHECKED INTO PYTHON CVS, THE RECOMPILED BINARIES

  MUST BE CHECKED IN AS WELL!

*/

/*

 * Written by Thomas Heller, May 2000

 *

 * $Id: install.c 63828 2008-05-31 05:11:07Z mark.hammond $

 */

/*

 * Windows Installer program for distutils.

 *

 * (a kind of self-extracting zip-file)

 *

 * At runtime, the exefile has appended:

 * - compressed setup-data in ini-format, containing the following sections:

 *	[metadata]

 *	author=Greg Ward

 *	author_email=gward@python.net

 *	description=Python Distribution Utilities

 *	licence=Python

 *	name=Distutils

 *	url=http://www.python.org/sigs/distutils-sig/

 *	version=0.9pre

 *

 *	[Setup]

 *	info= text to be displayed in the edit-box

 *	title= to be displayed by this program

 *	target_version = if present, python version required

 *	pyc_compile = if 0, do not compile py to pyc

 *	pyo_compile = if 0, do not compile py to pyo

 *

 * - a struct meta_data_hdr, describing the above

 * - a zip-file, containing the modules to be installed.

 *   for the format see http://www.pkware.com/appnote.html

 *

 * What does this program do?

 * - the setup-data is uncompressed and written to a temporary file.

 * - setup-data is queried with GetPrivateProfile... calls

 * - [metadata] - info is displayed in the dialog box

 * - The registry is searched for installations of python

 * - The user can select the python version to use.

 * - The python-installation directory (sys.prefix) is displayed

 * - When the start-button is pressed, files from the zip-archive

 *   are extracted to the file system. All .py filenames are stored

 *   in a list.

 */

/*

 * Includes now an uninstaller.

 */

/*

 * To Do:

 *

 * display some explanation when no python version is found

 * instead showing the user an empty listbox to select something from.

 *

 * Finish the code so that we can use other python installations

 * additionaly to those found in the registry,

 * and then #define USE_OTHER_PYTHON_VERSIONS

 *

 *  - install a help-button, which will display something meaningful

 *    to the poor user.

 *    text to the user

 *  - should there be a possibility to display a README file

 *    before starting the installation (if one is present in the archive)

 *  - more comments about what the code does(?)

 *

 *  - evolve this into a full blown installer (???)

 */

#include <windows.h>

#include <commctrl.h>

#include <imagehlp.h>

#include <objbase.h>

#include <shlobj.h>

#include <objidl.h>

#include "resource.h"

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <time.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <malloc.h>

#include <io.h>

#include <fcntl.h>

#include "archive.h"

/* Only for debugging!

   static int dprintf(char *fmt, ...)

   {

   char Buffer[4096];

   va_list marker;

   int result;

   va_start(marker, fmt);

   result = wvsprintf(Buffer, fmt, marker);

   OutputDebugString(Buffer);

   return result;

   }

*/

/* Bah: global variables */

FILE *logfile;

char modulename[MAX_PATH];

HWND hwndMain;

HWND hDialog;

char *ini_file;			/* Full pathname of ini-file */

/* From ini-file */

char info[4096];		/* [Setup] info= */

char title[80];			/* [Setup] title=, contains package name

				   including version: "Distutils-1.0.1" */

char target_version[10];	/* [Setup] target_version=, required python

				   version or empty string */

char build_info[80];		/* [Setup] build_info=, distutils version

				   and build date */

char meta_name[80];		/* package name without version like

				   'Distutils' */

char install_script[MAX_PATH];

char *pre_install_script; /* run before we install a single file */

char user_access_control[10]; // one of 'auto', 'force', otherwise none.

int py_major, py_minor;		/* Python version selected for installation */

char *arc_data;			/* memory mapped archive */

DWORD arc_size;			/* number of bytes in archive */

int exe_size;			/* number of bytes for exe-file portion */

char python_dir[MAX_PATH];

char pythondll[MAX_PATH];

BOOL pyc_compile, pyo_compile;

/* Either HKLM or HKCU, depending on where Python itself is registered, and

   the permissions of the current user. */

HKEY hkey_root = (HKEY)-1;

BOOL success;			/* Installation successfull? */

char *failure_reason = NULL;

HANDLE hBitmap;

char *bitmap_bytes;

#define WM_NUMFILES WM_USER+1

/* wParam: 0, lParam: total number of files */

#define WM_NEXTFILE WM_USER+2

/* wParam: number of this file */

/* lParam: points to pathname */

static BOOL notify(int code, char *fmt, ...);

/* Note: If scheme.prefix is nonempty, it must end with a '\'! */

/* Note: purelib must be the FIRST entry! */

SCHEME old_scheme[] = {

	{ "PURELIB", "" },

	{ "PLATLIB", "" },

	{ "HEADERS", "" }, /* 'Include/dist_name' part already in archive */

	{ "SCRIPTS", "Scripts\\" },

	{ "DATA", "" },

	{ NULL, NULL },

};

SCHEME new_scheme[] = {

	{ "PURELIB", "Lib\\site-packages\\" },

	{ "PLATLIB", "Lib\\site-packages\\" },

	{ "HEADERS", "" }, /* 'Include/dist_name' part already in archive */

	{ "SCRIPTS", "Scripts\\" },

	{ "DATA", "" },

	{ NULL, NULL },

};

static void unescape(char *dst, char *src, unsigned size)

{

	char *eon;

	char ch;

	while (src && *src && (size > 2)) {

		if (*src == '\\') {

			switch (*++src) {

			case 'n':

				++src;

				*dst++ = '\r';

				*dst++ = '\n';

				size -= 2;

				break;

			case 'r':

				++src;

				*dst++ = '\r';

				--size;

				break;

			case '0': case '1': case '2': case '3':

				ch = (char)strtol(src, &eon, 8);

				if (ch == '\n') {

					*dst++ = '\r';

					--size;

				}

				*dst++ = ch;

				--size;

				src = eon;

			}

		} else {

			*dst++ = *src++;

			--size;

		}

	}

	*dst = '\0';

}

static struct tagFile {

	char *path;

	struct tagFile *next;

} *file_list = NULL;

static void set_failure_reason(char *reason)

{

    if (failure_reason)

	free(failure_reason);

    failure_reason = strdup(reason);

    success = FALSE;

}

static char *get_failure_reason()

{

    if (!failure_reason)

	return "Installation failed.";

    return failure_reason;

}

static void add_to_filelist(char *path)

{

	struct tagFile *p;

	p = (struct tagFile *)malloc(sizeof(struct tagFile));

	p->path = strdup(path);

	p->next = file_list;

	file_list = p;

}

static int do_compile_files(int (__cdecl * PyRun_SimpleString)(char *),

			     int optimize)

{

	struct tagFile *p;

	int total, n;

	char Buffer[MAX_PATH + 64];

	int errors = 0;

	total = 0;

	p = file_list;

	while (p) {

		++total;

		p = p->next;

	}

	SendDlgItemMessage(hDialog, IDC_PROGRESS, PBM_SETRANGE, 0,

			    MAKELPARAM(0, total));

	SendDlgItemMessage(hDialog, IDC_PROGRESS, PBM_SETPOS, 0, 0);

	n = 0;

	p = file_list;

	while (p) {

		++n;

		wsprintf(Buffer,

			  "import py_compile; py_compile.compile (r'%s')",

			  p->path);

		if (PyRun_SimpleString(Buffer)) {

			++errors;

		}

		/* We send the notification even if the files could not

		 * be created so that the uninstaller will remove them

		 * in case they are created later.

		 */

		wsprintf(Buffer, "%s%c", p->path, optimize ? 'o' : 'c');

		notify(FILE_CREATED, Buffer);

		SendDlgItemMessage(hDialog, IDC_PROGRESS, PBM_SETPOS, n, 0);

		SetDlgItemText(hDialog, IDC_INFO, p->path);

		p = p->next;

	}

	return errors;

}

#define DECLPROC(dll, result, name, args)\

    typedef result (*__PROC__##name) args;\

    result (*name)args = (__PROC__##name)GetProcAddress(dll, #name)

#define DECLVAR(dll, type, name)\

    type *name = (type*)GetProcAddress(dll, #name)

typedef void PyObject;

/*

 * Returns number of files which failed to compile,

 * -1 if python could not be loaded at all

 */

static int compile_filelist(HINSTANCE hPython, BOOL optimize_flag)

{

	DECLPROC(hPython, void, Py_Initialize, (void));

	DECLPROC(hPython, void, Py_SetProgramName, (char *));

	DECLPROC(hPython, void, Py_Finalize, (void));

	DECLPROC(hPython, int, PyRun_SimpleString, (char *));

	DECLPROC(hPython, PyObject *, PySys_GetObject, (char *));

	DECLVAR(hPython, int, Py_OptimizeFlag);

	int errors = 0;

	struct tagFile *p = file_list;

	if (!p)

		return 0;

	if (!Py_Initialize || !Py_SetProgramName || !Py_Finalize)

		return -1;

	if (!PyRun_SimpleString || !PySys_GetObject || !Py_OptimizeFlag)

		return -1;

	*Py_OptimizeFlag = optimize_flag ? 1 : 0;

	Py_SetProgramName(modulename);

	Py_Initialize();

	errors += do_compile_files(PyRun_SimpleString, optimize_flag);

	Py_Finalize();

	return errors;

}

typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);

struct PyMethodDef {

	char	*ml_name;

	PyCFunction  ml_meth;

	int		 ml_flags;

	char	*ml_doc;

};

typedef struct PyMethodDef PyMethodDef;

// XXX - all of these are potentially fragile!  We load and unload

// the Python DLL multiple times - so storing functions pointers 

// is dangerous (although things *look* OK at present)

// Better might be to roll prepare_script_environment() into

// LoadPythonDll(), and create a new UnloadPythonDLL() which also

// clears the global pointers.

void *(*g_Py_BuildValue)(char *, ...);

int (*g_PyArg_ParseTuple)(PyObject *, char *, ...);

PyObject * (*g_PyLong_FromVoidPtr)(void *);

PyObject *g_PyExc_ValueError;

PyObject *g_PyExc_OSError;

PyObject *(*g_PyErr_Format)(PyObject *, char *, ...);

#define DEF_CSIDL(name) { name, #name }

struct {

	int nFolder;

	char *name;

} csidl_names[] = {

	/* Startup menu for all users.

	   NT only */

	DEF_CSIDL(CSIDL_COMMON_STARTMENU),

	/* Startup menu. */

	DEF_CSIDL(CSIDL_STARTMENU),

/*    DEF_CSIDL(CSIDL_COMMON_APPDATA), */

/*    DEF_CSIDL(CSIDL_LOCAL_APPDATA), */

	/* Repository for application-specific data.

	   Needs Internet Explorer 4.0 */

	DEF_CSIDL(CSIDL_APPDATA),

	/* The desktop for all users.

	   NT only */

	DEF_CSIDL(CSIDL_COMMON_DESKTOPDIRECTORY),

	/* The desktop. */

	DEF_CSIDL(CSIDL_DESKTOPDIRECTORY),

	/* Startup folder for all users.

	   NT only */

	DEF_CSIDL(CSIDL_COMMON_STARTUP),

	/* Startup folder. */

	DEF_CSIDL(CSIDL_STARTUP),

	/* Programs item in the start menu for all users.

	   NT only */

	DEF_CSIDL(CSIDL_COMMON_PROGRAMS),

	/* Program item in the user's start menu. */

	DEF_CSIDL(CSIDL_PROGRAMS),

/*    DEF_CSIDL(CSIDL_PROGRAM_FILES_COMMON), */

/*    DEF_CSIDL(CSIDL_PROGRAM_FILES), */

	/* Virtual folder containing fonts. */

	DEF_CSIDL(CSIDL_FONTS),

};

#define DIM(a) (sizeof(a) / sizeof((a)[0]))

static PyObject *FileCreated(PyObject *self, PyObject *args)

{

	char *path;

	if (!g_PyArg_ParseTuple(args, "s", &path))

		return NULL;

	notify(FILE_CREATED, path);

	return g_Py_BuildValue("");

}

static PyObject *DirectoryCreated(PyObject *self, PyObject *args)

{

	char *path;

	if (!g_PyArg_ParseTuple(args, "s", &path))

		return NULL;

	notify(DIR_CREATED, path);

	return g_Py_BuildValue("");

}

static PyObject *GetSpecialFolderPath(PyObject *self, PyObject *args)

{

	char *name;

	char lpszPath[MAX_PATH];

	int i;

	static HRESULT (WINAPI *My_SHGetSpecialFolderPath)(HWND hwnd,

							   LPTSTR lpszPath,

							   int nFolder,

							   BOOL fCreate);

	if (!My_SHGetSpecialFolderPath) {

		HINSTANCE hLib = LoadLibrary("shell32.dll");

		if (!hLib) {

			g_PyErr_Format(g_PyExc_OSError,

				       "function not available");

			return NULL;

		}

		My_SHGetSpecialFolderPath = (BOOL (WINAPI *)(HWND, LPTSTR,

							     int, BOOL))

			GetProcAddress(hLib,

				       "SHGetSpecialFolderPathA");

	}

	if (!g_PyArg_ParseTuple(args, "s", &name))

		return NULL;

	if (!My_SHGetSpecialFolderPath) {

		g_PyErr_Format(g_PyExc_OSError, "function not available");

		return NULL;

	}

	for (i = 0; i < DIM(csidl_names); ++i) {

		if (0 == strcmpi(csidl_names[i].name, name)) {

			int nFolder;

			nFolder = csidl_names[i].nFolder;

			if (My_SHGetSpecialFolderPath(NULL, lpszPath,

						      nFolder, 0))

				return g_Py_BuildValue("s", lpszPath);

			else {

				g_PyErr_Format(g_PyExc_OSError,

					       "no such folder (%s)", name);

				return NULL;

			}

		}

	};

	g_PyErr_Format(g_PyExc_ValueError, "unknown CSIDL (%s)", name);

	return NULL;

}

static PyObject *CreateShortcut(PyObject *self, PyObject *args)

{

	char *path; /* path and filename */

	char *description;

	char *filename;

	char *arguments = NULL;

	char *iconpath = NULL;

	int iconindex = 0;

	char *workdir = NULL;

	WCHAR wszFilename[MAX_PATH];

	IShellLink *ps1 = NULL;

	IPersistFile *pPf = NULL;

	HRESULT hr;

	hr = CoInitialize(NULL);

	if (FAILED(hr)) {

		g_PyErr_Format(g_PyExc_OSError,

			       "CoInitialize failed, error 0x%x", hr);

		goto error;

	}

	if (!g_PyArg_ParseTuple(args, "sss|sssi",

				&path, &description, &filename,

				&arguments, &workdir, &iconpath, &iconindex))

		return NULL;

	hr = CoCreateInstance(&CLSID_ShellLink,

			      NULL,

			      CLSCTX_INPROC_SERVER,

			      &IID_IShellLink,

			      &ps1);

	if (FAILED(hr)) {

		g_PyErr_Format(g_PyExc_OSError,

			       "CoCreateInstance failed, error 0x%x", hr);

		goto error;

	}

	hr = ps1->lpVtbl->QueryInterface(ps1, &IID_IPersistFile,

					 (void **)&pPf);

	if (FAILED(hr)) {

		g_PyErr_Format(g_PyExc_OSError,

			       "QueryInterface(IPersistFile) error 0x%x", hr);

		goto error;

	}

	hr = ps1->lpVtbl->SetPath(ps1, path);

	if (FAILED(hr)) {

		g_PyErr_Format(g_PyExc_OSError,

			       "SetPath() failed, error 0x%x", hr);