pgpadminxctl.cpp

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: PGPadminXCtl.cpp,v 1.8 2002/08/06 20:09:15 dallen Exp $
____________________________________________________________________________*/
// PGPadminXCtl.cpp : Implementation of the CPGPadminXCtrl ActiveX Control class.

#include "stdafx.h"
#include <winable.h>
#include <string.h>
#include "PGPadminX.h"
#include "PGPadminXCtl.h"
#include "PGPadminXPpg.h"

#include "PGPadmin.h"
#include "Utils.h"
#include "resource.h"

#include "pgpFileSpec.h"
#include "pgpClientPrefs.h"
#include "pgpNetPrefs.h"
#include "pgpUtilities.h"
#include "pgpClientLib.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define PREFS_BLOCK_SIZE	2048
#define MAX_KEY_BLOCK		128

extern "C" {
extern HINSTANCE g_hInstance;
HWND g_hCurrentDlgWnd = NULL;
}

typedef enum _TabPage
{
	Tab_ADK=0,
	Tab_PassPhrase,
	Tab_KeyGen,
	Tab_DefaultKeys,
	Tab_CorpKey,
	Tab_Revoker,
	Tab_ServerUpdates,
	Tab_Access,
	Tab_Misc,
	NUM_TAB_PAGES
} TabPage;


BOOL CALLBACK DisableDlgCtrl(HWND hwnd, LPARAM lParam)
{
	EnableWindow(hwnd, FALSE);
	return TRUE;
}

static void sShowTabPage(HWND hwnd, pgpConfigInfo *pConfig, 
						 TabPageProps *pPage, BOOL bDisabled)
{
	char szName[1024]={0};
	HMODULE hModule=NULL;
	HRSRC hRes=NULL;
	HGLOBAL hDlg=NULL;
	DWORD dwSize=0;
	DLGTEMPLATE *pDlg=NULL, *pDlgCpy=NULL;
	int nIndex=0;
	RECT rc={0};
	RECT rcTab={0};
	int nTab=0;

	ASSERT(IsWindow(hwnd));
	ASSERT(!IsBadWritePtr(pConfig, sizeof(pgpConfigInfo)));
	ASSERT(!IsBadWritePtr(pPage, sizeof(TabPageProps)));

	nIndex=TabCtrl_GetCurSel(hwnd);
	ASSERT(-1 != nIndex);
	ASSERT(nIndex < NUM_TAB_PAGES);

	GetWindowModuleFileName(hwnd, szName, sizeof(szName));
	ASSERT(NULL != szName[0]);

	hModule=GetModuleHandle(szName);
	ASSERT(NULL != hModule);

	if(NULL != hModule)
	{
		TRACE2("Searching for dlg resource with id = %d for page = %d\n", 
				pPage[nIndex].nID, nIndex);

		hRes = FindResource(hModule, MAKEINTRESOURCE(pPage[nIndex].nID), RT_DIALOG);
		ASSERT(NULL != hRes);
	}

	if(NULL != hRes)
	{
		hDlg=LoadResource(hModule, hRes);
		ASSERT(NULL != hDlg);

		pDlg=(DLGTEMPLATE *)LockResource(hDlg);
		ASSERT(NULL != pDlg);

		dwSize=SizeofResource(hModule, hRes);
	    ASSERT(dwSize > 0);
	}

	if(dwSize > 0)
	{
		pDlgCpy=(LPDLGTEMPLATE) PGPNewData(pConfig->memoryMgr, dwSize, 0);
		ASSERT(NULL != pDlgCpy);
	}

	if(NULL != pDlgCpy)
	{
		ASSERT(!IsBadReadPtr(pDlg, dwSize));
		memcpy(pDlgCpy, pDlg, dwSize);

		pDlgCpy->style &= ~(WS_CAPTION|WS_DISABLED);
		pDlgCpy->style |= WS_VISIBLE;
		if (bDisabled)
			pDlgCpy->style |= WS_DISABLED;
		g_hCurrentDlgWnd=CreateDialogIndirectParam(g_hInstance, pDlgCpy, hwnd, 
							pPage[nIndex].dlgProc, (LPARAM) pConfig);
		ASSERT(NULL != g_hCurrentDlgWnd);
	}

	if(NULL != g_hCurrentDlgWnd)
	{
		rc.left = LONG_MAX;
		rc.top = LONG_MAX;
		for (nTab=0; nTab<NUM_TAB_PAGES; nTab++)
		{
			TabCtrl_GetItemRect(hwnd, nTab, &rcTab);
			if ((rcTab.left <= rc.left) && (rcTab.top <= rc.top))
				CopyRect(&rc, &rcTab);
		}
		TabCtrl_AdjustRect(hwnd, FALSE, &rc);
		SetWindowPos(g_hCurrentDlgWnd, HWND_TOP, rc.left, rc.top, 0, 0, SWP_NOSIZE);
		
		if (bDisabled)
			EnumChildWindows(g_hCurrentDlgWnd, DisableDlgCtrl, NULL);
	}

	if(NULL != pDlgCpy)
	{
		PGPFreeData(pDlgCpy);
		pDlgCpy=NULL;
	}
	return;
}


IMPLEMENT_DYNCREATE(CPGPadminXCtrl, COleControl)


/////////////////////////////////////////////////////////////////////////////
// Message map

BEGIN_MESSAGE_MAP(CPGPadminXCtrl, COleControl)
	//{{AFX_MSG_MAP(CPGPadminXCtrl)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	//}}AFX_MSG_MAP
	ON_MESSAGE(OCM_COMMAND, OnOcmCommand)
	ON_MESSAGE(OCM_NOTIFY, OnOcmNotify)
	ON_OLEVERB(AFX_IDS_VERB_PROPERTIES, OnProperties)
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// Dispatch map

BEGIN_DISPATCH_MAP(CPGPadminXCtrl, COleControl)
	//{{AFX_DISPATCH_MAP(CPGPadminXCtrl)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "szPrefs", GetSzPrefs, SetSzPrefs, VT_BSTR)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "szNetPrefs", GetSzNetPrefs, SetSzNetPrefs, VT_BSTR)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "disabled", GetDisabled, SetDisabled, VT_BOOL)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "nPrefBlocks", GetNPrefBlocks, SetNPrefBlocks, VT_I4)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "nNetPrefBlocks", GetNNetPrefBlocks, SetNNetPrefBlocks, VT_I4)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "szDefaultKeys", GetSzDefaultKeys, SetSzDefaultKeys, VT_BSTR)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "nDefaultKeyBlocks", GetNDefaultKeyBlocks, SetNDefaultKeyBlocks, VT_I4)
	DISP_PROPERTY_EX(CPGPadminXCtrl, "szProductKey", GetSzProductKey, SetSzProductKey, VT_BSTR)
	//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()


/////////////////////////////////////////////////////////////////////////////
// Event map

BEGIN_EVENT_MAP(CPGPadminXCtrl, COleControl)
	//{{AFX_EVENT_MAP(CPGPadminXCtrl)
	//}}AFX_EVENT_MAP
END_EVENT_MAP()


/////////////////////////////////////////////////////////////////////////////
// Property pages

// TODO: Add more property pages as needed.  Remember to increase the count!
BEGIN_PROPPAGEIDS(CPGPadminXCtrl, 1)
	PROPPAGEID(CPGPadminXPropPage::guid)
END_PROPPAGEIDS(CPGPadminXCtrl)


/////////////////////////////////////////////////////////////////////////////
// Initialize class factory and guid

IMPLEMENT_OLECREATE_EX(CPGPadminXCtrl, "PGPADMINX.PGPadminXCtrl.1",
	0x6917c1f6, 0x755a, 0x11d5, 0xae, 0x28, 0, 0x1, 0x2, 0x34, 0x51, 0x8f)


/////////////////////////////////////////////////////////////////////////////
// Type library ID and version

IMPLEMENT_OLETYPELIB(CPGPadminXCtrl, _tlid, _wVerMajor, _wVerMinor)


/////////////////////////////////////////////////////////////////////////////
// Interface IDs

const IID BASED_CODE IID_DPGPadminX =
		{ 0x6917c1f4, 0x755a, 0x11d5, { 0xae, 0x28, 0, 0x1, 0x2, 0x34, 0x51, 0x8f } };
const IID BASED_CODE IID_DPGPadminXEvents =
		{ 0x6917c1f5, 0x755a, 0x11d5, { 0xae, 0x28, 0, 0x1, 0x2, 0x34, 0x51, 0x8f } };


/////////////////////////////////////////////////////////////////////////////
// Control type information

static const DWORD BASED_CODE _dwPGPadminXOleMisc =
	OLEMISC_ACTIVATEWHENVISIBLE |
	OLEMISC_SETCLIENTSITEFIRST |
	OLEMISC_INSIDEOUT |
	OLEMISC_CANTLINKINSIDE |
	OLEMISC_RECOMPOSEONRESIZE;

IMPLEMENT_OLECTLTYPE(CPGPadminXCtrl, IDS_PGPADMINX, _dwPGPadminXOleMisc)


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::CPGPadminXCtrlFactory::UpdateRegistry -
// Adds or removes system registry entries for CPGPadminXCtrl

BOOL CPGPadminXCtrl::CPGPadminXCtrlFactory::UpdateRegistry(BOOL bRegister)
{
	// TODO: Verify that your control follows apartment-model threading rules.
	// Refer to MFC TechNote 64 for more information.
	// If your control does not conform to the apartment-model rules, then
	// you must modify the code below, changing the 6th parameter from
	// afxRegApartmentThreading to 0.

	if (bRegister)
		return AfxOleRegisterControlClass(
			AfxGetInstanceHandle(),
			m_clsid,
			m_lpszProgID,
			IDS_PGPADMINX,
			IDB_PGPADMINX,
			afxRegApartmentThreading,
			_dwPGPadminXOleMisc,
			_tlid,
			_wVerMajor,
			_wVerMinor);
	else
		return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::CPGPadminXCtrl - Constructor

CPGPadminXCtrl::CPGPadminXCtrl()
{
	InitializeIIDs(&IID_DPGPadminX, &IID_DPGPadminXEvents);

	// TODO: Initialize your control's instance data here.

	PGPError err;

	m_pgpContext = NULL;
	m_pgpMemMgr = NULL;
	m_prefRef = NULL;
	m_prefRefNet = NULL;
	m_bDisabled = FALSE;
	m_szPrefBuffer = NULL;
	m_szNetPrefBuffer = NULL;
	m_szKeyBuffer = NULL;
	m_szProductKey = NULL;
	g_hCurrentDlgWnd = NULL;

	err = PGPclInitLibrary(&m_pgpContext, 0);
	if (IsPGPError(err))
	{
		PGPclCloseLibrary();
		return;
	}

	// Check for beta/demo expiration

	if (PGPclIsExpired(NULL, kPGPclDefaultExpired) != kPGPError_NoErr)
	{
		PGPclCloseLibrary();
		m_pgpContext = NULL;
		return;
	}

	m_pgpMemMgr = PGPPeekContextMemoryMgr(m_pgpContext);
	m_pPage = (TabPageProps *) PGPNewData(m_pgpMemMgr, 
								sizeof(TabPageProps) * NUM_TAB_PAGES,
								kPGPMemoryMgrFlags_Clear);

	SetNPrefBlocks(0);
	SetNNetPrefBlocks(0);
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::~CPGPadminXCtrl - Destructor

CPGPadminXCtrl::~CPGPadminXCtrl()
{
	// TODO: Cleanup your control's instance data here.
	if (m_szPrefBuffer != NULL)
		PGPFreeData(m_szPrefBuffer);

	if (m_szNetPrefBuffer != NULL)
		PGPFreeData(m_szNetPrefBuffer);

	if (m_szKeyBuffer != NULL)
		PGPFreeData(m_szKeyBuffer);

	if (m_szProductKey != NULL)
		PGPFreeData(m_szProductKey);

	if (m_prefRef != NULL)
	{
		PGPFreePrefs(m_prefRef);
		DeleteFile(m_szPrefFile);
	}

	if (m_prefRefNet != NULL)
	{
		PGPFreePrefs(m_prefRefNet);
		DeleteFile(m_szNetPrefFile);
	}

	if (m_pgpContext != NULL)
	{
		PGPFreeData(m_pPage);
		PGPclCloseLibrary();
	}
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::OnDraw - Drawing function

void CPGPadminXCtrl::OnDraw(
			CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)
{
	DoSuperclassPaint(pdc, rcBounds);
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::DoPropExchange - Persistence support

void CPGPadminXCtrl::DoPropExchange(CPropExchange* pPX)
{
	ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor));
	COleControl::DoPropExchange(pPX);

	// TODO: Call PX_ functions for each persistent custom property.

}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::OnResetState - Reset control to default state

void CPGPadminXCtrl::OnResetState()
{
	COleControl::OnResetState();  // Resets defaults found in DoPropExchange

	// TODO: Reset any other control state here.
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::PreCreateWindow - Modify parameters for CreateWindowEx

BOOL CPGPadminXCtrl::PreCreateWindow(CREATESTRUCT& cs)
{
	cs.lpszClass = _T("SysTabControl32");
	cs.style |= TCS_MULTILINE;
	return COleControl::PreCreateWindow(cs);
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::IsSubclassedControl - This is a subclassed control

BOOL CPGPadminXCtrl::IsSubclassedControl()
{
	return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::OnOcmCommand - Handle command messages

LRESULT CPGPadminXCtrl::OnOcmCommand(WPARAM wParam, LPARAM lParam)
{
	WORD wNotifyCode = HIWORD(wParam);

	// TODO: Switch on wNotifyCode here.

	return 0;
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl::OnOcmNotify - Handle notify messages

LRESULT CPGPadminXCtrl::OnOcmNotify(WPARAM wParam, LPARAM lParam)
{
	LPNMHDR pHdr = (LPNMHDR) lParam;
	pgpConfigInfo *pConfig;

	// TODO: Switch on wNotifyCode here.
	switch (pHdr->code)
	{
	case TCN_SELCHANGING:
		NMHDR hdrNotify;

		hdrNotify.hwndFrom = GetSafeHwnd();
		hdrNotify.idFrom = 0;
		hdrNotify.code = PSN_KILLACTIVE;
		return ::SendMessage(g_hCurrentDlgWnd, WM_NOTIFY, 0, (LPARAM) &hdrNotify);

	case TCN_SELCHANGE:
		pConfig = (pgpConfigInfo *) GetWindowLong(g_hCurrentDlgWnd, GWL_USERDATA);
		::DestroyWindow(g_hCurrentDlgWnd);
		sShowTabPage(GetSafeHwnd(), pConfig, m_pPage, m_bDisabled);
		break;
	}

	return 0;
}


/////////////////////////////////////////////////////////////////////////////
// CPGPadminXCtrl message handlers

int CPGPadminXCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (COleControl::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	if (m_pgpContext == NULL)
		return -1;

	// TODO: Add your specialized creation code here

	HWND hwnd = GetSafeHwnd();
	TCITEM tci;
	pgpConfigInfo *pConfig;
	char szTabText[256];
	InstallerProduct nProduct;
	UINT nNumTabs = 0;

	SendMessage(WM_SETFONT, (WPARAM) GetStockObject(ANSI_VAR_FONT), 0);
	
	pConfig = (pgpConfigInfo *) PGPNewData(m_pgpMemMgr, sizeof(pgpConfigInfo), 0);
	InitAdminOptions(m_pgpContext, pConfig, TRUE);
	pConfig->prefRef = m_prefRef;
	pConfig->prefRefNet = m_prefRefNet;
	pConfig->szProductKey = m_szProductKey;
	LoadAdminOptions(pConfig);
	nProduct = GetInstalledProduct(pConfig->szProductKey);

	tci.mask = TCIF_TEXT | TCIF_IMAGE;
	tci.iImage = -1;
	tci.pszText = szTabText;

	if (!(nProduct & Installer_PGPfire))
	{
		LoadString(g_hInstance, IDS_TAB_ADK, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_ADK;
		m_pPage[nNumTabs].dlgProc = ADKDlgProc;
		nNumTabs++;
		
		LoadString(g_hInstance, IDS_TAB_PASSPHRASE, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_PASSPHRASE;
		m_pPage[nNumTabs].dlgProc = PassPhraseDlgProc;
		nNumTabs++;
		
		LoadString(g_hInstance, IDS_TAB_KEYGEN, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_KEYGEN;
		m_pPage[nNumTabs].dlgProc = KeyGenDlgProc;
		nNumTabs++;
		
		LoadString(g_hInstance, IDS_TAB_KEYS, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_DEFKEYSEL;
		m_pPage[nNumTabs].dlgProc = DefaultKeysDlgProc;
		nNumTabs++;
		
		LoadString(g_hInstance, IDS_TAB_CORPKEY, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_CORPKEY;
		m_pPage[nNumTabs].dlgProc = CorpKeyDlgProc;
		nNumTabs++;
		
		LoadString(g_hInstance, IDS_TAB_REVOKER, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_REVOKER;
		m_pPage[nNumTabs].dlgProc = RevokerDlgProc;
		nNumTabs++;

		LoadString(g_hInstance, IDS_TAB_UPDATES, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_SERVERUPDATES;
		m_pPage[nNumTabs].dlgProc = ServerUpdatesDlgProc;
		nNumTabs++;
	}
	
	LoadString(g_hInstance, IDS_TAB_ACCESS, szTabText, sizeof(szTabText));
	TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
	m_pPage[nNumTabs].nID = IDD_ACCESS;
	m_pPage[nNumTabs].dlgProc = AccessDlgProc;
	nNumTabs++;
	
	if (!(nProduct & Installer_PGPfire))
	{
		LoadString(g_hInstance, IDS_TAB_MISC, szTabText, sizeof(szTabText));
		TabCtrl_InsertItem(hwnd, nNumTabs, &tci);
		m_pPage[nNumTabs].nID = IDD_MISC;
		m_pPage[nNumTabs].dlgProc = MiscDlgProc;
		nNumTabs++;
	}
	
	sShowTabPage(hwnd, pConfig, m_pPage, m_bDisabled);
	return 0;
}

void CPGPadminXCtrl::OnDestroy() 
{
	COleControl::OnDestroy();
	
	// TODO: Add your message handler code here
	pgpConfigInfo *pConfig;
	
	pConfig = (pgpConfigInfo *) ::GetWindowLong(g_hCurrentDlgWnd, GWL_USERDATA);
	FreeAdminOptions(pConfig);
	PGPFreeData(pConfig);
	g_hCurrentDlgWnd = NULL;
}

BOOL CALLBACK CommonDlgProc(HWND hwndDlg, 
							UINT uMsg, 
							WPARAM wParam, 
							LPARAM lParam)
{
	BOOL			bReturnCode = FALSE;
	pgpConfigInfo *	pConfig		= NULL;

	g_hCurrentDlgWnd = hwndDlg;
	pConfig = (pgpConfigInfo *) GetWindowLong(hwndDlg, GWL_USERDATA);

	switch(uMsg)
	{
	case WM_INITDIALOG:
		pConfig = (pgpConfigInfo *) lParam;
		SetWindowLong(hwndDlg, GWL_USERDATA, (LPARAM) pConfig);
		break;
	}

	return bReturnCode;
}