createwiz.cpp

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1997 Network Associates Inc. and affiliated companies.
	All rights reserved.

	$Id: CreateWiz.cpp,v 1.85.4.1 1999/06/16 23:12:13 wjb Exp $
____________________________________________________________________________*/

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include "PGPadmin.h"
#include "resource.h"
#include "CreateWiz.h"
#include "Utils.h"
#include "pflPrefs.h"
#include "pflPrefTypes.h"
#include "pgpMem.h"
#include "pgpFileSpec.h"
#include "pgpKeys.h"
#include "pgpAdminPrefs.h"
#include "pgpUtilities.h"
#include "pgpVersion.h"
#include "PGPcl.h"
#include "pgpVersion.h"
#include "PGPsea.h"
#include "pgpClientLib.h"

extern "C" {
#include "pgpNetPaths.h"
#include "pgpVersionHeader.h"
};

static pgpConfigInfo Config;

static HPALETTE 
CreateDIBPalette (LPBITMAPINFO lpbmi, 
				  LPINT lpiNumColors);

static HBITMAP 
LoadResourceBitmap (HINSTANCE hInstance, 
					LPSTR lpString,
					HPALETTE FAR* lphPalette);

BOOL CALLBACK WaitProc(HWND hwndDlg, 
					   UINT uMsg, 
					   WPARAM wParam, 
					   LPARAM lParam);

#define DEFAULT_USERINSTALLDIR "C:\\Program Files\\Network Associates\\PGP"

// AddPrefsToSEA
//
// Given the filename of the SEA, add the
// buffers containing the preference files
// to the SEA. 
//
// Note, each call of AddPrefsToSEA erases any
// previous prefs written to the SEA. Also, a 
// NULL pointer for a buffer means that no prefs
// file should be included in the SEA for that 
// module. 
//
// Return value of TRUE means success. FALSE 
// means there was an error manipulating the SEA.
BOOL AddPrefsToSEA(char *filename,
				   char *AdminBuffer,
				   DWORD AdminSize,
				   char *ClientBuffer,
				   DWORD ClientSize,
				   char *NetBuffer,
				   DWORD NetSize,
				   char *SetupBuffer,
				   DWORD SetupSize)
{
	SDAHEADER SDAHeader;
	FILE *fsea;
	DWORD offset;

	fsea=fopen(filename,"r+b");

	if(fsea==0)
		return FALSE; // Couldn't open file

	fseek(fsea, -(int)(sizeof(SDAHEADER)), SEEK_END);
	fread(&SDAHeader,1,sizeof(SDAHEADER),fsea);

	if(memcmp(SDAHeader.szPGPSDA,"PGPSEA",6)!=0)
	{
		// Not an SEA file
		fclose(fsea);
		return FALSE;
	}

	// Erase old pref entries in header
	memset(&SDAHeader.AdminOffset,0x00,8*sizeof(DWORD));

	// Prefs go after the compressed data
	offset=SDAHeader.offset+SDAHeader.CompLength;

	// Truncate whatever cruft was already there
	fflush(fsea);
	_chsize(_fileno(fsea),offset);
	fflush(fsea);

	// Start at the end of the file
	fseek(fsea,offset,SEEK_SET);

	if(AdminBuffer)
	{
		SDAHeader.AdminOffset=offset;
		SDAHeader.AdminSize=AdminSize;

		fwrite(AdminBuffer,1,SDAHeader.AdminSize,fsea);

		offset=offset+SDAHeader.AdminSize;
	}

	if(ClientBuffer)
	{
		SDAHeader.ClientOffset=offset;
		SDAHeader.ClientSize=ClientSize;

		fwrite(ClientBuffer,1,SDAHeader.ClientSize,fsea);

		offset=offset+SDAHeader.ClientSize;
	}

	if(NetBuffer)
	{
		SDAHeader.NetOffset=offset;
		SDAHeader.NetSize=NetSize;

		fwrite(NetBuffer,1,SDAHeader.NetSize,fsea);

		offset=offset+SDAHeader.NetSize;
	}

	if(SetupBuffer)
	{
		SDAHeader.SetupOffset=offset;
		SDAHeader.SetupSize=SetupSize;

		fwrite(SetupBuffer,1,SDAHeader.SetupSize,fsea);

		offset=offset+SDAHeader.SetupSize;
	}

	// Finally, finish up by writing out new header
	fwrite(&SDAHeader,1,sizeof(SDAHEADER),fsea);

	fclose(fsea);
	return TRUE;
}

void CreateWiz(HWND hwndMain)
{
	PROPSHEETPAGE	pspWiz[NUM_WIZ_PAGES];
	PROPSHEETHEADER pshWiz;
	int				nIndex;
	int iNumBits,	iBitmap;
	HDC				hDC;
	char			szTitle[255];
	char			szMsg[255];
	PGPPrefRef		adminPrefs;
	PGPError		err;

	// Make sure SDK isn't expired 

	err = PGPNewContext(kPGPsdkAPIVersion, &(Config.pgpContext));
	if (IsPGPError(err))
	{
		if (err == kPGPError_FeatureNotAvailable)
		{
			LoadString(g_hInstance, IDS_E_EXPIRED, szMsg, 254);
			LoadString(g_hInstance, IDS_TITLE, szTitle, 254);
			MessageBox(hwndMain, szMsg, szTitle, MB_ICONWARNING);
		}
		else
			PGPclErrorBox(hwndMain, err);

		g_bGotReloadMsg = FALSE;
		return;
	}

	err = PGPclInitLibrary(Config.pgpContext);
	if (IsPGPError(err))
	{
		PGPclErrorBox (hwndMain, err);
		g_bGotReloadMsg = FALSE;
		PGPFreeContext(Config.pgpContext);
		return;
	}

	Config.memoryMgr = PGPGetContextMemoryMgr(Config.pgpContext);

	// Check for beta/demo expiration

	if (PGPclIsExpired(hwndMain) != kPGPError_NoErr)
	{
		PGPclCloseLibrary();
		PGPFreeContext(Config.pgpContext);
		g_bGotReloadMsg = FALSE;
		return;
	}

	// Make sure we can actually save the prefs, i.e. user is running
	// with Administrator privileges

	err = PGPclOpenAdminPrefs(Config.memoryMgr, &adminPrefs, TRUE);
	if (IsntPGPError(err))
		err = PGPclCloseAdminPrefs(adminPrefs, TRUE);
	else
	{
		PGPclCloseLibrary();
		PGPFreeContext(Config.pgpContext);
		g_bGotReloadMsg = FALSE;
		return;
	}
	
	if (IsPGPError(err))
	{
		LoadString(g_hInstance, IDS_E_CANTSAVE, szMsg, 254);
		LoadString(g_hInstance, IDS_TITLE, szTitle, 254);
		MessageBox(hwndMain, szMsg, szTitle, MB_ICONWARNING);

		PGPclCloseLibrary();
		PGPFreeContext(Config.pgpContext);
		g_bGotReloadMsg = FALSE;
		return;
	}

	// Set defaults here:

	Config.hBitmap = NULL;
	Config.hPalette = NULL;
	Config.szLicenseNum = NULL;
	Config.bUseOutgoingADK = FALSE;
	Config.bUseIncomingADK = FALSE;
	Config.bUseDiskADK = FALSE;
	Config.szOutgoingADKID = NULL;
	Config.szOutgoingADK = NULL;
	Config.szIncomingADKID = NULL;
	Config.szIncomingADK = NULL;
	Config.szDiskADKID = NULL;
	Config.szDiskADK = NULL;
	Config.bEnforceIncomingADK = FALSE;
	Config.bEnforceOutgoingADK = FALSE;
	Config.bEnforceRemoteADK = TRUE;
	Config.bEnforceMinChars = FALSE;
	Config.nMinChars = 8;
	Config.bEnforceMinQuality = FALSE;
	Config.nMinQuality = 20;
	Config.szCorpKeyID = NULL;
	Config.szCorpKey = NULL;
	Config.corpKeyType = (PGPPublicKeyAlgorithm) 0;
	Config.outgoingADKKeyType = (PGPPublicKeyAlgorithm) 0;
	Config.diskADKKeyType = (PGPPublicKeyAlgorithm) 0;
	Config.bWarnNotCertByCorp = FALSE;
	Config.bAutoSignTrustCorp = FALSE;
	Config.bMetaIntroducerCorp = FALSE;
	Config.bAutoAddRevoker = FALSE;
	Config.szRevokerKeyID = NULL;
	Config.szRevokerKey = NULL;
	Config.revokerKeyType = (PGPPublicKeyAlgorithm) 0;
	Config.bKeyGenCertRequest = FALSE;
	Config.bAllowManualCertRequest = TRUE;
	Config.bAutoUpdateCRL = FALSE;
	Config.nCAType = kPGPKeyServerClass_Invalid;
	Config.pAVList = NULL;
	Config.nNumAVs = 0;
	Config.bAllowKeyGen = TRUE;
	Config.bAllowRSAKeyGen = FALSE;
	Config.nMinKeySize = 1024;
	Config.bUpdateAllKeys = FALSE;
	Config.bUpdateTrustedIntroducers = FALSE;
	Config.nDaysUpdateAllKeys = 1;
	Config.nDaysUpdateTrustedIntroducers = 1;
	Config.bAllowConventionalEncryption = TRUE;
	Config.szComments = NULL;
	Config.nCommentLength = 0;
	Config.defaultKeySet = NULL;
	Config.szAdminInstaller = NULL;
	Config.szClientInstaller = NULL;
	Config.bCopyClientPrefs = FALSE;
	Config.bPreselectInstall = FALSE;
	Config.szUserInstallDir = (char *) PGPNewData(Config.memoryMgr,
										strlen(DEFAULT_USERINSTALLDIR)+1, 
										kPGPMemoryMgrFlags_Clear);
	strcpy(Config.szUserInstallDir, DEFAULT_USERINSTALLDIR);
	Config.bInstallPrograms = TRUE;
	Config.bInstallCmdLine = TRUE;
	Config.bInstallNet = TRUE;
	Config.bInstallDisk = TRUE;
	Config.bInstallEudora = TRUE;
	Config.bInstallOutlook = TRUE;
	Config.bInstallOutExpress = TRUE;
	Config.bInstallManual = TRUE;
	Config.bUninstallOld = TRUE;
	Config.bSave = FALSE;

	// Determine which bitmap will be displayed in the wizard

	hDC = GetDC (NULL);		// DC for desktop
	iNumBits = GetDeviceCaps (hDC, BITSPIXEL) * GetDeviceCaps (hDC, PLANES);
	ReleaseDC (NULL, hDC);

	if (iNumBits <= 1)
		iBitmap = IDB_ADMINWIZ1;
	else if (iNumBits <= 4) 
		iBitmap = IDB_ADMINWIZ4;
	else if (iNumBits <= 8) 
		iBitmap = IDB_ADMINWIZ8;
	else 
		iBitmap = IDB_ADMINWIZ24;

	Config.hBitmap = LoadResourceBitmap(g_hInstance, MAKEINTRESOURCE(iBitmap),
						&(Config.hPalette));

	// Set the values common to all pages

	for (nIndex=0; nIndex<NUM_WIZ_PAGES; nIndex++)
	{
		pspWiz[nIndex].dwSize		= sizeof(PROPSHEETPAGE);
		pspWiz[nIndex].dwFlags		= PSP_DEFAULT;
		pspWiz[nIndex].hInstance	= g_hInstance;
		pspWiz[nIndex].pszTemplate	= NULL;
		pspWiz[nIndex].hIcon		= NULL;
		pspWiz[nIndex].pszTitle		= NULL;
		pspWiz[nIndex].pfnDlgProc	= NULL;
		pspWiz[nIndex].lParam		= (LPARAM) &Config;
		pspWiz[nIndex].pfnCallback	= NULL;
		pspWiz[nIndex].pcRefParent	= NULL;
	}

	// Set up the license number page

	pspWiz[Wiz_License].pszTemplate	= MAKEINTRESOURCE(IDD_LICENSE);
	pspWiz[Wiz_License].pfnDlgProc	= (DLGPROC) LicenseDlgProc;
	
	// Set up the intro page

	pspWiz[Wiz_Intro].pszTemplate	= MAKEINTRESOURCE(IDD_INTRO);
	pspWiz[Wiz_Intro].pfnDlgProc	= (DLGPROC) IntroDlgProc;
	
	// Set up the additional decryption key intro page

	pspWiz[Wiz_ADKIntro].pszTemplate = MAKEINTRESOURCE(IDD_ADK);
	pspWiz[Wiz_ADKIntro].pfnDlgProc	= (DLGPROC) ADKIntroDlgProc;
	
	// Set up the incoming additional decryption key page

	pspWiz[Wiz_ADKIncoming].pszTemplate	= MAKEINTRESOURCE(IDD_ADK_INCOMING);
	pspWiz[Wiz_ADKIncoming].pfnDlgProc	= (DLGPROC) ADKIncomingDlgProc;
	
	// Set up the incoming additional decryption key selection page

	pspWiz[Wiz_ADKInSelect].pszTemplate =MAKEINTRESOURCE(IDD_ADK_INSEL);
	pspWiz[Wiz_ADKInSelect].pfnDlgProc  =(DLGPROC) ADKInSelectDlgProc;
	
	// Set up the outgoing additional decryption key page

	pspWiz[Wiz_ADKOutgoing].pszTemplate = 
										MAKEINTRESOURCE(IDD_ADK_OUTGOING);
	pspWiz[Wiz_ADKOutgoing].pfnDlgProc  = (DLGPROC) ADKOutgoingDlgProc;
	
	// Set up the outgoing additional decryption key selection page

	pspWiz[Wiz_ADKOutSelect].pszTemplate = 
										MAKEINTRESOURCE(IDD_ADK_OUTSEL);