1 /*

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

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

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

     5 

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

     7   MUST BE CHECKED IN AS WELL!

     8 */

     9 

    10 /*

    11  * Written by Thomas Heller, May 2000

    12  *

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

    14  */

    15 

    16 /*

    17  * Windows Installer program for distutils.

    18  *

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

    20  *

    21  * At runtime, the exefile has appended:

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

    23  *	[metadata]

    24  *	author=Greg Ward

    25  *	author_email=gward@python.net

    26  *	description=Python Distribution Utilities

    27  *	licence=Python

    28  *	name=Distutils

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

    30  *	version=0.9pre

    31  *

    32  *	[Setup]

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

    34  *	title= to be displayed by this program

    35  *	target_version = if present, python version required

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

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

    38  *

    39  * - a struct meta_data_hdr, describing the above

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

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

    42  *

    43  * What does this program do?

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

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

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

    47  * - The registry is searched for installations of python

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

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

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

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

    52  *   in a list.

    53  */

    54 /*

    55  * Includes now an uninstaller.

    56  */

    57 

    58 /*

    59  * To Do:

    60  *

    61  * display some explanation when no python version is found

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

    63  *

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

    65  * additionaly to those found in the registry,

    66  * and then #define USE_OTHER_PYTHON_VERSIONS

    67  *

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

    69  *    to the poor user.

    70  *    text to the user

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

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

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

    74  *

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

    76  */

    77 

    78 #include <windows.h>

    79 #include <commctrl.h>

    80 #include <imagehlp.h>

    81 #include <objbase.h>

    82 #include <shlobj.h>

    83 #include <objidl.h>

    84 #include "resource.h"

    85 

    86 #include <stdio.h>

    87 #include <stdlib.h>

    88 #include <stdarg.h>

    89 #include <string.h>

    90 #include <time.h>

    91 #include <sys/types.h>

    92 #include <sys/stat.h>

    93 #include <malloc.h>

    94 #include <io.h>

    95 #include <fcntl.h>

    96 

    97 #include "archive.h"

    98 

    99 /* Only for debugging!

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

   101    {

   102    char Buffer[4096];

   103    va_list marker;

   104    int result;

   105 

   106    va_start(marker, fmt);

   107    result = wvsprintf(Buffer, fmt, marker);

   108    OutputDebugString(Buffer);

   109    return result;

   110    }

   111 */

   112 

   113 /* Bah: global variables */

   114 FILE *logfile;

   115 

   116 char modulename[MAX_PATH];

   117 

   118 HWND hwndMain;

   119 HWND hDialog;

   120 

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

   122 /* From ini-file */

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

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

   125 				   including version: "Distutils-1.0.1" */

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

   127 				   version or empty string */

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

   129 				   and build date */

   130 

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

   132 				   'Distutils' */

   133 char install_script[MAX_PATH];

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

   135 

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

   137 

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

   139 

   140 char *arc_data;			/* memory mapped archive */

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

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

   143 char python_dir[MAX_PATH];

   144 char pythondll[MAX_PATH];

   145 BOOL pyc_compile, pyo_compile;

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

   147    the permissions of the current user. */

   148 HKEY hkey_root = (HKEY)-1;

   149 

   150 BOOL success;			/* Installation successfull? */

   151 char *failure_reason = NULL;

   152 

   153 HANDLE hBitmap;

   154 char *bitmap_bytes;

   155 

   156 

   157 #define WM_NUMFILES WM_USER+1

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

   159 #define WM_NEXTFILE WM_USER+2

   160 /* wParam: number of this file */

   161 /* lParam: points to pathname */

   162 

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

   164 

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

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

   167 SCHEME old_scheme[] = {

   168 	{ "PURELIB", "" },

   169 	{ "PLATLIB", "" },

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

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

   172 	{ "DATA", "" },

   173 	{ NULL, NULL },

   174 };

   175 

   176 SCHEME new_scheme[] = {

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

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

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

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

   181 	{ "DATA", "" },

   182 	{ NULL, NULL },

   183 };

   184 

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

   186 {

   187 	char *eon;

   188 	char ch;

   189 

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

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

   192 			switch (*++src) {

   193 			case 'n':

   194 				++src;

   195 				*dst++ = '\r';

   196 				*dst++ = '\n';

   197 				size -= 2;

   198 				break;

   199 			case 'r':

   200 				++src;

   201 				*dst++ = '\r';

   202 				--size;

   203 				break;

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

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

   206 				if (ch == '\n') {

   207 					*dst++ = '\r';

   208 					--size;

   209 				}

   210 				*dst++ = ch;

   211 				--size;

   212 				src = eon;

   213 			}

   214 		} else {

   215 			*dst++ = *src++;

   216 			--size;

   217 		}

   218 	}

   219 	*dst = '\0';

   220 }

   221 

   222 static struct tagFile {

   223 	char *path;

   224 	struct tagFile *next;

   225 } *file_list = NULL;

   226 

   227 static void set_failure_reason(char *reason)

   228 {

   229     if (failure_reason)

   230 	free(failure_reason);

   231     failure_reason = strdup(reason);

   232     success = FALSE;

   233 }

   234 static char *get_failure_reason()

   235 {

   236     if (!failure_reason)

   237 	return "Installation failed.";

   238     return failure_reason;

   239 }

   240 

   241 static void add_to_filelist(char *path)

   242 {

   243 	struct tagFile *p;

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

   245 	p->path = strdup(path);

   246 	p->next = file_list;

   247 	file_list = p;

   248 }

   249 

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

   251 			     int optimize)

   252 {

   253 	struct tagFile *p;

   254 	int total, n;

   255 	char Buffer[MAX_PATH + 64];

   256 	int errors = 0;

   257 

   258 	total = 0;

   259 	p = file_list;

   260 	while (p) {

   261 		++total;

   262 		p = p->next;

   263 	}

   264 	SendDlgItemMessage(hDialog, IDC_PROGRESS, PBM_SETRANGE, 0,

   265 			    MAKELPARAM(0, total));

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

   267 

   268 	n = 0;

   269 	p = file_list;

   270 	while (p) {

   271 		++n;

   272 		wsprintf(Buffer,

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

   274 			  p->path);

   275 		if (PyRun_SimpleString(Buffer)) {

   276 			++errors;

   277 		}

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

   279 		 * be created so that the uninstaller will remove them

   280 		 * in case they are created later.

   281 		 */

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

   283 		notify(FILE_CREATED, Buffer);

   284 

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

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

   287 		p = p->next;

   288 	}

   289 	return errors;

   290 }

   291 

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

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

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

   295 

   296 

   297 #define DECLVAR(dll, type, name)\

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

   299 

   300 typedef void PyObject;

   301 

   302 

   303 /*

   304  * Returns number of files which failed to compile,

   305  * -1 if python could not be loaded at all

   306  */

   307 static int compile_filelist(HINSTANCE hPython, BOOL optimize_flag)

   308 {

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

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

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

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

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

   314 	DECLVAR(hPython, int, Py_OptimizeFlag);

   315 

   316 	int errors = 0;

   317 	struct tagFile *p = file_list;

   318 

   319 	if (!p)

   320 		return 0;

   321 

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

   323 		return -1;

   324 

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

   326 		return -1;

   327 

   328 	*Py_OptimizeFlag = optimize_flag ? 1 : 0;

   329 	Py_SetProgramName(modulename);

   330 	Py_Initialize();

   331 

   332 	errors += do_compile_files(PyRun_SimpleString, optimize_flag);

   333 	Py_Finalize();

   334 

   335 	return errors;

   336 }

   337 

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

   339 

   340 struct PyMethodDef {

   341 	char	*ml_name;

   342 	PyCFunction  ml_meth;

   343 	int		 ml_flags;

   344 	char	*ml_doc;

   345 };

   346 typedef struct PyMethodDef PyMethodDef;

   347 

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

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

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

   351 // Better might be to roll prepare_script_environment() into

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

   353 // clears the global pointers.

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

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

   356 PyObject * (*g_PyLong_FromVoidPtr)(void *);

   357 

   358 PyObject *g_PyExc_ValueError;

   359 PyObject *g_PyExc_OSError;

   360 

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

   362 

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

   364 

   365 struct {

   366 	int nFolder;

   367 	char *name;

   368 } csidl_names[] = {

   369 	/* Startup menu for all users.

   370 	   NT only */

   371 	DEF_CSIDL(CSIDL_COMMON_STARTMENU),

   372 	/* Startup menu. */

   373 	DEF_CSIDL(CSIDL_STARTMENU),

   374 

   375 /*    DEF_CSIDL(CSIDL_COMMON_APPDATA), */

   376 /*    DEF_CSIDL(CSIDL_LOCAL_APPDATA), */

   377 	/* Repository for application-specific data.

   378 	   Needs Internet Explorer 4.0 */

   379 	DEF_CSIDL(CSIDL_APPDATA),

   380 

   381 	/* The desktop for all users.

   382 	   NT only */

   383 	DEF_CSIDL(CSIDL_COMMON_DESKTOPDIRECTORY),

   384 	/* The desktop. */

   385 	DEF_CSIDL(CSIDL_DESKTOPDIRECTORY),

   386 

   387 	/* Startup folder for all users.

   388 	   NT only */

   389 	DEF_CSIDL(CSIDL_COMMON_STARTUP),

   390 	/* Startup folder. */

   391 	DEF_CSIDL(CSIDL_STARTUP),

   392 

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

   394 	   NT only */

   395 	DEF_CSIDL(CSIDL_COMMON_PROGRAMS),

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

   397 	DEF_CSIDL(CSIDL_PROGRAMS),

   398 

   399 /*    DEF_CSIDL(CSIDL_PROGRAM_FILES_COMMON), */

   400 /*    DEF_CSIDL(CSIDL_PROGRAM_FILES), */

   401 

   402 	/* Virtual folder containing fonts. */

   403 	DEF_CSIDL(CSIDL_FONTS),

   404 };

   405 

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

   407 

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

   409 {

   410 	char *path;

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

   412 		return NULL;

   413 	notify(FILE_CREATED, path);

   414 	return g_Py_BuildValue("");

   415 }

   416 

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

   418 {

   419 	char *path;

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

   421 		return NULL;

   422 	notify(DIR_CREATED, path);

   423 	return g_Py_BuildValue("");

   424 }

   425 

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

   427 {

   428 	char *name;

   429 	char lpszPath[MAX_PATH];

   430 	int i;

   431 	static HRESULT (WINAPI *My_SHGetSpecialFolderPath)(HWND hwnd,

   432 							   LPTSTR lpszPath,

   433 							   int nFolder,

   434 							   BOOL fCreate);

   435 

   436 	if (!My_SHGetSpecialFolderPath) {

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

   438 		if (!hLib) {

   439 			g_PyErr_Format(g_PyExc_OSError,

   440 				       "function not available");

   441 			return NULL;

   442 		}

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

   444 							     int, BOOL))

   445 			GetProcAddress(hLib,

   446 				       "SHGetSpecialFolderPathA");

   447 	}

   448 

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

   450 		return NULL;

   451     

   452 	if (!My_SHGetSpecialFolderPath) {

   453 		g_PyErr_Format(g_PyExc_OSError, "function not available");

   454 		return NULL;

   455 	}

   456 

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

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

   459 			int nFolder;

   460 			nFolder = csidl_names[i].nFolder;

   461 			if (My_SHGetSpecialFolderPath(NULL, lpszPath,

   462 						      nFolder, 0))

   463 				return g_Py_BuildValue("s", lpszPath);

   464 			else {

   465 				g_PyErr_Format(g_PyExc_OSError,

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

   467 				return NULL;

   468 			}

   469 		

   470 		}

   471 	};

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

   473 	return NULL;

   474 }

   475 

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

   477 {

   478 	char *path; /* path and filename */

   479 	char *description;

   480 	char *filename;

   481 

   482 	char *arguments = NULL;

   483 	char *iconpath = NULL;

   484 	int iconindex = 0;

   485 	char *workdir = NULL;

   486 

   487 	WCHAR wszFilename[MAX_PATH];

   488 

   489 	IShellLink *ps1 = NULL;

   490 	IPersistFile *pPf = NULL;

   491 

   492 	HRESULT hr;

   493 

   494 	hr = CoInitialize(NULL);

   495 	if (FAILED(hr)) {

   496 		g_PyErr_Format(g_PyExc_OSError,

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

   498 		goto error;

   499 	}

   500 

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

   502 				&path, &description, &filename,

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

   504 		return NULL;

   505 

   506 	hr = CoCreateInstance(&CLSID_ShellLink,

   507 			      NULL,

   508 			      CLSCTX_INPROC_SERVER,

   509 			      &IID_IShellLink,

   510 			      &ps1);

   511 	if (FAILED(hr)) {

   512 		g_PyErr_Format(g_PyExc_OSError,

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

   514 		goto error;

   515 	}

   516 

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

   518 					 (void **)&pPf);

   519 	if (FAILED(hr)) {

   520 		g_PyErr_Format(g_PyExc_OSError,

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

   522 		goto error;

   523 	}

   524 

   525 

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

   527 	if (FAILED(hr)) {

   528 		g_PyErr_Format(g_PyExc_OSError,

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

   530 		goto error;

   531 	}

   532 

   533 	hr = ps1->lpVtbl->SetDescription(ps1, description);

   534 	if (FAILED(hr)) {

   535 		g_PyErr_Format(g_PyExc_OSError,

   536 			       "SetDescription() failed, error 0x%x", hr);

   537 		goto error;

   538 	}

   539 

   540 	if (arguments) {

   541 		hr = ps1->lpVtbl->SetArguments(ps1, arguments);

   542 		if (FAILED(hr)) {

   543 			g_PyErr_Format(g_PyExc_OSError,

   544 				       "SetArguments() error 0x%x", hr);

   545 			goto error;

   546 		}

   547 	}

   548 

   549 	if (iconpath) {

   550 		hr = ps1->lpVtbl->SetIconLocation(ps1, iconpath, iconindex);

   551 		if (FAILED(hr)) {

   552 			g_PyErr_Format(g_PyExc_OSError,

   553 				       "SetIconLocation() error 0x%x", hr);

   554 			goto error;

   555 		}

   556 	}

   557 

   558 	if (workdir) {

   559 		hr = ps1->lpVtbl->SetWorkingDirectory(ps1, workdir);

   560 		if (FAILED(hr)) {

   561 			g_PyErr_Format(g_PyExc_OSError,

   562 				       "SetWorkingDirectory() error 0x%x", hr);

   563 			goto error;

   564 		}

   565 	}

   566 

   567 	MultiByteToWideChar(CP_ACP, 0,

   568 			    filename, -1,

   569 			    wszFilename, MAX_PATH);

   570 			

   571 	hr = pPf->lpVtbl->Save(pPf, wszFilename, TRUE);

   572 	if (FAILED(hr)) {

   573 		g_PyErr_Format(g_PyExc_OSError,

   574 			       "Failed to create shortcut '%s' - error 0x%x", filename, hr);

   575 		goto error;

   576 	}

   577     

   578 	pPf->lpVtbl->Release(pPf);

   579 	ps1->lpVtbl->Release(ps1);

   580 	CoUninitialize();

   581 	return g_Py_BuildValue("");

   582     

   583   error:

   584 	if (pPf)

   585 		pPf->lpVtbl->Release(pPf);

   586 

   587 	if (ps1)

   588 		ps1->lpVtbl->Release(ps1);

   589 

   590 	CoUninitialize();

   591 

   592 	return NULL;

   593 }

   594 

   595 static PyObject *PyMessageBox(PyObject *self, PyObject *args)

   596 {

   597 	int rc;

   598 	char *text, *caption;

   599 	int flags;

   600 	if (!g_PyArg_ParseTuple(args, "ssi", &text, &caption, &flags))

   601 		return NULL;

   602 	rc = MessageBox(GetFocus(), text, caption, flags);

   603 	return g_Py_BuildValue("i", rc);

   604 }

   605 

   606 static PyObject *GetRootHKey(PyObject *self)

   607 {

   608 	return g_PyLong_FromVoidPtr(hkey_root);

   609 }

   610 

   611 #define METH_VARARGS 0x0001

   612 #define METH_NOARGS   0x0004

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

   614 

   615 PyMethodDef meth[] = {

   616 	{"create_shortcut", CreateShortcut, METH_VARARGS, NULL},

   617 	{"get_special_folder_path", GetSpecialFolderPath, METH_VARARGS, NULL},

   618 	{"get_root_hkey", (PyCFunction)GetRootHKey, METH_NOARGS, NULL},

   619 	{"file_created", FileCreated, METH_VARARGS, NULL},

   620 	{"directory_created", DirectoryCreated, METH_VARARGS, NULL},

   621 	{"message_box", PyMessageBox, METH_VARARGS, NULL},

   622 };

   623 

   624 static HINSTANCE LoadPythonDll(char *fname)

   625 {

   626 	char fullpath[_MAX_PATH];

   627 	LONG size = sizeof(fullpath);

   628 	char subkey_name[80];

   629 	char buffer[260 + 12];

   630 	HINSTANCE h;

   631 

   632 	/* make sure PYTHONHOME is set, to that sys.path is initialized correctly */

   633 	wsprintf(buffer, "PYTHONHOME=%s", python_dir);

   634 	_putenv(buffer);

   635 	h = LoadLibrary(fname);

   636 	if (h)

   637 		return h;

   638 	wsprintf(subkey_name,

   639 		 "SOFTWARE\\Python\\PythonCore\\%d.%d\\InstallPath",

   640 		 py_major, py_minor);

   641 	if (ERROR_SUCCESS != RegQueryValue(HKEY_CURRENT_USER, subkey_name,

   642 	                                   fullpath, &size) &&

   643 	    ERROR_SUCCESS != RegQueryValue(HKEY_LOCAL_MACHINE, subkey_name,

   644 	                                   fullpath, &size))

   645 		return NULL;

   646 	strcat(fullpath, "\\");

   647 	strcat(fullpath, fname);

   648 	return LoadLibrary(fullpath);

   649 }

   650 

   651 static int prepare_script_environment(HINSTANCE hPython)

   652 {

   653 	PyObject *mod;

   654 	DECLPROC(hPython, PyObject *, PyImport_ImportModule, (char *));

   655 	DECLPROC(hPython, int, PyObject_SetAttrString, (PyObject *, char *, PyObject *));

   656 	DECLPROC(hPython, PyObject *, PyObject_GetAttrString, (PyObject *, char *));

   657 	DECLPROC(hPython, PyObject *, PyCFunction_New, (PyMethodDef *, PyObject *));

   658 	DECLPROC(hPython, PyObject *, Py_BuildValue, (char *, ...));

   659 	DECLPROC(hPython, int, PyArg_ParseTuple, (PyObject *, char *, ...));

   660 	DECLPROC(hPython, PyObject *, PyErr_Format, (PyObject *, char *));

   661 	DECLPROC(hPython, PyObject *, PyLong_FromVoidPtr, (void *));

   662 	if (!PyImport_ImportModule || !PyObject_GetAttrString || 

   663 	    !PyObject_SetAttrString || !PyCFunction_New)

   664 		return 1;

   665 	if (!Py_BuildValue || !PyArg_ParseTuple || !PyErr_Format)

   666 		return 1;

   667 

   668 	mod = PyImport_ImportModule("__builtin__");

   669 	if (mod) {

   670 		int i;

   671 		g_PyExc_ValueError = PyObject_GetAttrString(mod, "ValueError");

   672 		g_PyExc_OSError = PyObject_GetAttrString(mod, "OSError");

   673 		for (i = 0; i < DIM(meth); ++i) {

   674 			PyObject_SetAttrString(mod, meth[i].ml_name,

   675 					       PyCFunction_New(&meth[i], NULL));

   676 		}

   677 	}

   678 	g_Py_BuildValue = Py_BuildValue;

   679 	g_PyArg_ParseTuple = PyArg_ParseTuple;

   680 	g_PyErr_Format = PyErr_Format;

   681 	g_PyLong_FromVoidPtr = PyLong_FromVoidPtr;

   682 

   683 	return 0;

   684 }

   685 

   686 /*

   687  * This function returns one of the following error codes:

   688  * 1 if the Python-dll does not export the functions we need

   689  * 2 if no install-script is specified in pathname

   690  * 3 if the install-script file could not be opened

   691  * the return value of PyRun_SimpleString() otherwise,

   692  * which is 0 if everything is ok, -1 if an exception had occurred

   693  * in the install-script.

   694  */

   695 

   696 static int

   697 run_installscript(HINSTANCE hPython, char *pathname, int argc, char **argv)

   698 {

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

   700 	DECLPROC(hPython, int, PySys_SetArgv, (int, char **));

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

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

   703 	DECLPROC(hPython, PyObject *, Py_BuildValue, (char *, ...));

   704 	DECLPROC(hPython, PyObject *, PyCFunction_New,

   705 		 (PyMethodDef *, PyObject *));

   706 	DECLPROC(hPython, int, PyArg_ParseTuple, (PyObject *, char *, ...));

   707 	DECLPROC(hPython, PyObject *, PyErr_Format, (PyObject *, char *));

   708 

   709 	int result = 0;

   710 	int fh;

   711 

   712 	if (!Py_Initialize || !PySys_SetArgv

   713 	    || !PyRun_SimpleString || !Py_Finalize)

   714 		return 1;

   715 	

   716 	if (!Py_BuildValue || !PyArg_ParseTuple || !PyErr_Format)

   717 		return 1;

   718 

   719 	if (!PyCFunction_New || !PyArg_ParseTuple || !PyErr_Format)

   720 		return 1;

   721 

   722 	if (pathname == NULL || pathname[0] == '\0')

   723 		return 2;

   724 

   725 	fh = open(pathname, _O_RDONLY);

   726 	if (-1 == fh) {

   727 		fprintf(stderr, "Could not open postinstall-script %s\n",

   728 			pathname);

   729 		return 3;

   730 	}

   731 

   732 	SetDlgItemText(hDialog, IDC_INFO, "Running Script...");

   733 		

   734 	Py_Initialize();

   735 

   736 	prepare_script_environment(hPython);

   737 	PySys_SetArgv(argc, argv);

   738 	result = 3;

   739 	{

   740 		struct _stat statbuf;

   741 		if(0 == _fstat(fh, &statbuf)) {

   742 			char *script = alloca(statbuf.st_size + 5);

   743 			int n = read(fh, script, statbuf.st_size);

   744 			if (n > 0) {

   745 				script[n] = '\n';

   746 				script[n+1] = 0;

   747 				result = PyRun_SimpleString(script);

   748 			}

   749 		}

   750 	}

   751 	Py_Finalize();

   752 

   753 	close(fh);

   754 

   755 	return result;

   756 }

   757 

   758 static int do_run_simple_script(HINSTANCE hPython, char *script)

   759 {

   760 	int rc;

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

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

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

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

   765 	DECLPROC(hPython, void, PyErr_Print, (void));

   766 

   767 	if (!Py_Initialize || !Py_SetProgramName || !Py_Finalize || 

   768 	    !PyRun_SimpleString || !PyErr_Print)

   769 		return -1;

   770 

   771 	Py_SetProgramName(modulename);

   772 	Py_Initialize();

   773 	prepare_script_environment(hPython);

   774 	rc = PyRun_SimpleString(script);

   775 	if (rc)

   776 		PyErr_Print();

   777 	Py_Finalize();

   778 	return rc;

   779 }

   780 

   781 static int run_simple_script(char *script)

   782 {

   783 	int rc;

   784 	char *tempname;

   785 	HINSTANCE hPython;

   786 	tempname = tempnam(NULL, NULL);

   787 	freopen(tempname, "a", stderr);

   788 	freopen(tempname, "a", stdout);

   789 

   790 	hPython = LoadPythonDll(pythondll);

   791 	if (!hPython) {

   792 		char reason[128];

   793 		wsprintf(reason, "Can't load Python for pre-install script (%d)", GetLastError());

   794 		set_failure_reason(reason);

   795 		return -1;

   796 	}

   797 	rc = do_run_simple_script(hPython, script);

   798 	FreeLibrary(hPython);

   799 	fflush(stderr);

   800 	fclose(stderr);

   801 	fflush(stdout);

   802 	fclose(stdout);

   803 	/* We only care about the output when we fail.  If the script works

   804 	   OK, then we discard it

   805 	*/

   806 	if (rc) {

   807 		int err_buf_size;

   808 		char *err_buf;

   809 		const char *prefix = "Running the pre-installation script failed\r\n";

   810 		int prefix_len = strlen(prefix);

   811 		FILE *fp = fopen(tempname, "rb");

   812 		fseek(fp, 0, SEEK_END);

   813 		err_buf_size = ftell(fp);

   814 		fseek(fp, 0, SEEK_SET);

   815 		err_buf = malloc(prefix_len + err_buf_size + 1);

   816 		if (err_buf) {

   817 			int n;

   818 			strcpy(err_buf, prefix);

   819 			n = fread(err_buf+prefix_len, 1, err_buf_size, fp);

   820 			err_buf[prefix_len+n] = '\0';

   821 			fclose(fp);

   822 			set_failure_reason(err_buf);

   823 			free(err_buf);

   824 		} else {

   825 			set_failure_reason("Out of memory!");

   826 		}

   827 	}

   828 	remove(tempname);

   829 	return rc;

   830 }

   831 

   832 

   833 static BOOL SystemError(int error, char *msg)

   834 {

   835 	char Buffer[1024];

   836 	int n;

   837 

   838 	if (error) {

   839 		LPVOID lpMsgBuf;

   840 		FormatMessage( 

   841 			FORMAT_MESSAGE_ALLOCATE_BUFFER | 

   842 			FORMAT_MESSAGE_FROM_SYSTEM,

   843 			NULL,

   844 			error,

   845 			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

   846 			(LPSTR)&lpMsgBuf,

   847 			0,

   848 			NULL 

   849 			);

   850 		strncpy(Buffer, lpMsgBuf, sizeof(Buffer));

   851 		LocalFree(lpMsgBuf);

   852 	} else

   853 		Buffer[0] = '\0';

   854 	n = lstrlen(Buffer);

   855 	_snprintf(Buffer+n, sizeof(Buffer)-n, msg);

   856 	MessageBox(hwndMain, Buffer, "Runtime Error", MB_OK | MB_ICONSTOP);

   857 	return FALSE;

   858 }

   859 

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

   861 {

   862 	char Buffer[1024];

   863 	va_list marker;

   864 	BOOL result = TRUE;

   865 	int a, b;

   866 	char *cp;

   867 

   868 	va_start(marker, fmt);

   869 	_vsnprintf(Buffer, sizeof(Buffer), fmt, marker);

   870 

   871 	switch (code) {

   872 /* Questions */

   873 	case CAN_OVERWRITE:

   874 		break;

   875 

   876 /* Information notification */

   877 	case DIR_CREATED:

   878 		if (logfile)

   879 			fprintf(logfile, "100 Made Dir: %s\n", fmt);

   880 		break;

   881 

   882 	case FILE_CREATED:

   883 		if (logfile)

   884 			fprintf(logfile, "200 File Copy: %s\n", fmt);

   885 		goto add_to_filelist_label;

   886 		break;

   887 

   888 	case FILE_OVERWRITTEN:

   889 		if (logfile)

   890 			fprintf(logfile, "200 File Overwrite: %s\n", fmt);

   891 	  add_to_filelist_label:

   892 		if ((cp = strrchr(fmt, '.')) && (0 == strcmp (cp, ".py")))

   893 			add_to_filelist(fmt);

   894 		break;

   895 

   896 /* Error Messages */

   897 	case ZLIB_ERROR:

   898 		MessageBox(GetFocus(), Buffer, "Error",

   899 			    MB_OK | MB_ICONWARNING);

   900 		break;

   901 

   902 	case SYSTEM_ERROR:

   903 		SystemError(GetLastError(), Buffer);

   904 		break;

   905 

   906 	case NUM_FILES:

   907 		a = va_arg(marker, int);

   908 		b = va_arg(marker, int);

   909 		SendMessage(hDialog, WM_NUMFILES, 0, MAKELPARAM(0, a));

   910 		SendMessage(hDialog, WM_NEXTFILE, b,(LPARAM)fmt);

   911 	}

   912 	va_end(marker);

   913     

   914 	return result;

   915 }

   916 

   917 static char *MapExistingFile(char *pathname, DWORD *psize)

   918 {

   919 	HANDLE hFile, hFileMapping;

   920 	DWORD nSizeLow, nSizeHigh;

   921 	char *data;

   922 

   923 	hFile = CreateFile(pathname,

   924 			    GENERIC_READ, FILE_SHARE_READ, NULL,

   925 			    OPEN_EXISTING,

   926 			    FILE_ATTRIBUTE_NORMAL, NULL);

   927 	if (hFile == INVALID_HANDLE_VALUE)

   928 		return NULL;

   929 	nSizeLow = GetFileSize(hFile, &nSizeHigh);

   930 	hFileMapping = CreateFileMapping(hFile,

   931 					  NULL, PAGE_READONLY, 0, 0, NULL);

   932 	CloseHandle(hFile);

   933 

   934 	if (hFileMapping == INVALID_HANDLE_VALUE)

   935 		return NULL;

   936     

   937 	data = MapViewOfFile(hFileMapping,

   938 			      FILE_MAP_READ, 0, 0, 0);

   939 

   940 	CloseHandle(hFileMapping);

   941 	*psize = nSizeLow;

   942 	return data;

   943 }

   944 

   945 

   946 static void create_bitmap(HWND hwnd)

   947 {

   948 	BITMAPFILEHEADER *bfh;

   949 	BITMAPINFO *bi;

   950 	HDC hdc;

   951 

   952 	if (!bitmap_bytes)

   953 		return;

   954 

   955 	if (hBitmap)

   956 		return;

   957 

   958 	hdc = GetDC(hwnd);

   959 

   960 	bfh = (BITMAPFILEHEADER *)bitmap_bytes;

   961 	bi = (BITMAPINFO *)(bitmap_bytes + sizeof(BITMAPFILEHEADER));

   962 

   963 	hBitmap = CreateDIBitmap(hdc,

   964 				 &bi->bmiHeader,

   965 				 CBM_INIT,

   966 				 bitmap_bytes + bfh->bfOffBits,

   967 				 bi,

   968 				 DIB_RGB_COLORS);

   969 	ReleaseDC(hwnd, hdc);

   970 }

   971 

   972 /* Extract everything we need to begin the installation.  Currently this

   973    is the INI filename with install data, and the raw pre-install script

   974 */

   975 static BOOL ExtractInstallData(char *data, DWORD size, int *pexe_size,

   976 			       char **out_ini_file, char **out_preinstall_script)

   977 {

   978 	/* read the end of central directory record */

   979 	struct eof_cdir *pe = (struct eof_cdir *)&data[size - sizeof

   980 						       (struct eof_cdir)];

   981     

   982 	int arc_start = size - sizeof (struct eof_cdir) - pe->nBytesCDir -

   983 		pe->ofsCDir;

   984 

   985 	int ofs = arc_start - sizeof (struct meta_data_hdr);

   986 

   987 	/* read meta_data info */

   988 	struct meta_data_hdr *pmd = (struct meta_data_hdr *)&data[ofs];

   989 	char *src, *dst;

   990 	char *ini_file;

   991 	char tempdir[MAX_PATH];

   992 

   993 	/* ensure that if we fail, we don't have garbage out pointers */

   994 	*out_ini_file = *out_preinstall_script = NULL;

   995 

   996 	if (pe->tag != 0x06054b50) {

   997 		return FALSE;

   998 	}

   999 

  1000 	if (pmd->tag != 0x1234567B) {

  1001 		return SystemError(0,

  1002 			   "Invalid cfgdata magic number (see bdist_wininst.py)");

  1003 	}

  1004 	if (ofs < 0) {

  1005 		return FALSE;

  1006 	}

  1007 

  1008 	if (pmd->bitmap_size) {

  1009 		/* Store pointer to bitmap bytes */

  1010 		bitmap_bytes = (char *)pmd - pmd->uncomp_size - pmd->bitmap_size;

  1011 	}

  1012 

  1013 	*pexe_size = ofs - pmd->uncomp_size - pmd->bitmap_size;

  1014 

  1015 	src = ((char *)pmd) - pmd->uncomp_size;

  1016 	ini_file = malloc(MAX_PATH); /* will be returned, so do not free it */

  1017 	if (!ini_file)

  1018 		return FALSE;

  1019 	if (!GetTempPath(sizeof(tempdir), tempdir)

  1020 	    || !GetTempFileName(tempdir, "~du", 0, ini_file)) {

  1021 		SystemError(GetLastError(),

  1022 			     "Could not create temporary file");

  1023 		return FALSE;

  1024 	}

  1025     

  1026 	dst = map_new_file(CREATE_ALWAYS, ini_file, NULL, pmd->uncomp_size,

  1027 			    0, 0, NULL/*notify*/);

  1028 	if (!dst)

  1029 		return FALSE;

  1030 	/* Up to the first \0 is the INI file data. */

  1031 	strncpy(dst, src, pmd->uncomp_size);

  1032 	src += strlen(dst) + 1;

  1033 	/* Up to next \0 is the pre-install script */

  1034 	*out_preinstall_script = strdup(src);

  1035 	*out_ini_file = ini_file;

  1036 	UnmapViewOfFile(dst);

  1037 	return TRUE;

  1038 }

  1039 

  1040 static void PumpMessages(void)

  1041 {

  1042 	MSG msg;

  1043 	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {

  1044 		TranslateMessage(&msg);

  1045 		DispatchMessage(&msg);

  1046 	}

  1047 }

  1048 

  1049 LRESULT CALLBACK

  1050 WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

  1051 {

  1052 	HDC hdc;

  1053 	HFONT hFont;

  1054 	int h;

  1055 	PAINTSTRUCT ps;

  1056 	switch (msg) {

  1057 	case WM_PAINT:

  1058 		hdc = BeginPaint(hwnd, &ps);

  1059 		h = GetSystemMetrics(SM_CYSCREEN) / 10;

  1060 		hFont = CreateFont(h, 0, 0, 0, 700, TRUE,

  1061 				    0, 0, 0, 0, 0, 0, 0, "Times Roman");

  1062 		hFont = SelectObject(hdc, hFont);

  1063 		SetBkMode(hdc, TRANSPARENT);

  1064 		TextOut(hdc, 15, 15, title, strlen(title));

  1065 		SetTextColor(hdc, RGB(255, 255, 255));

  1066 		TextOut(hdc, 10, 10, title, strlen(title));

  1067 		DeleteObject(SelectObject(hdc, hFont));

  1068 		EndPaint(hwnd, &ps);

  1069 		return 0;

  1070 	}

  1071 	return DefWindowProc(hwnd, msg, wParam, lParam);

  1072 }

  1073 

  1074 static HWND CreateBackground(char *title)

  1075 {

  1076 	WNDCLASS wc;

  1077 	HWND hwnd;

  1078 	char buffer[4096];

  1079 

  1080 	wc.style = CS_VREDRAW | CS_HREDRAW;

  1081 	wc.lpfnWndProc = WindowProc;

  1082 	wc.cbWndExtra = 0;

  1083 	wc.cbClsExtra = 0;

  1084 	wc.hInstance = GetModuleHandle(NULL);

  1085 	wc.hIcon = NULL;

  1086 	wc.hCursor = LoadCursor(NULL, IDC_ARROW);

  1087 	wc.hbrBackground = CreateSolidBrush(RGB(0, 0, 128));

  1088 	wc.lpszMenuName = NULL;

  1089 	wc.lpszClassName = "SetupWindowClass";

  1090 

  1091 	if (!RegisterClass(&wc))

  1092 		MessageBox(hwndMain,

  1093 			    "Could not register window class",

  1094 			    "Setup.exe", MB_OK);

  1095 

  1096 	wsprintf(buffer, "Setup %s", title);

  1097 	hwnd = CreateWindow("SetupWindowClass",

  1098 			     buffer,

  1099 			     0,

  1100 			     0, 0,

  1101 			     GetSystemMetrics(SM_CXFULLSCREEN),

  1102 			     GetSystemMetrics(SM_CYFULLSCREEN),

  1103 			     NULL,

  1104 			     NULL,

  1105 			     GetModuleHandle(NULL),

  1106 			     NULL);

  1107 	ShowWindow(hwnd, SW_SHOWMAXIMIZED);

  1108 	UpdateWindow(hwnd);

  1109 	return hwnd;

  1110 }

  1111 

  1112 /*

  1113  * Center a window on the screen

  1114  */

  1115 static void CenterWindow(HWND hwnd)

  1116 {

  1117 	RECT rc;

  1118 	int w, h;

  1119 

  1120 	GetWindowRect(hwnd, &rc);

  1121 	w = GetSystemMetrics(SM_CXSCREEN);

  1122 	h = GetSystemMetrics(SM_CYSCREEN);

  1123 	MoveWindow(hwnd,

  1124 		   (w - (rc.right-rc.left))/2,

  1125 		   (h - (rc.bottom-rc.top))/2,

  1126 		    rc.right-rc.left, rc.bottom-rc.top, FALSE);

  1127 }

  1128 

  1129 #include <prsht.h>

  1130 

  1131 BOOL CALLBACK

  1132 IntroDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

  1133 {

  1134 	LPNMHDR lpnm;

  1135 	char Buffer[4096];