pnoption.c

vc环境下的pgp源码

			PGPFreeFileSpec (fileRef);
		}
	}

	else
	{
		PGPsdkPrefGetFileSpec (
				g_context, kPGPsdkPref_PublicKeyring, &fileRefOrig);
		GetDlgItemText (hwnd, IDC_PUBRING, szFile, sizeof(szFile));
		err = PGPNewFileSpecFromFullPath (g_context, szFile, &fileRef);

		if (!PGPclErrorBox (hwnd, err)) 
		{
			err = PGPsdkPrefSetFileSpec (g_context, 
							kPGPsdkPref_PublicKeyring, fileRef);
			PGPclErrorBox (hwnd, err);
			PGPFreeFileSpec (fileRef);
		}
	}

	if (!PNLoadKeyRings (hwnd, &g_AOS.keysetMain)) 
	{
		if (bSecretRing)
		{
			PGPsdkPrefSetFileSpec (g_context, 
							kPGPsdkPref_PrivateKeyring, fileRefOrig);
		}
		else
		{
			PGPsdkPrefSetFileSpec (g_context, 
							kPGPsdkPref_PublicKeyring, fileRefOrig);
		}
	}

	if (PGPFileSpecRefIsValid (fileRefOrig))
		PGPFreeFileSpec (fileRefOrig);
}


//	____________________________________
//
//	get the current user's keyrings and set controls to them

static BOOL
sSetToCurrentUsersKeyrings (
		HWND			hwnd,
		POPTIONSSTRUCT	pos)
{
	PGPContextRef	context;
	PGPFileSpecRef	fileRef;
	PGPError		err;

	err = PGPNewContext (kPGPsdkAPIVersion, &context);
	if (IsntPGPError (err))
	{
		PGPsdkLoadDefaultPrefs (context);

		PGPsdkPrefGetFileSpec (
				context, kPGPsdkPref_PublicKeyring, &fileRef);
		PGPsdkPrefSetFileSpec (
				g_context, kPGPsdkPref_PublicKeyring, fileRef);
		PGPFreeFileSpec (fileRef);

		PGPsdkPrefGetFileSpec (
				context, kPGPsdkPref_PrivateKeyring, &fileRef);
		PGPsdkPrefSetFileSpec (
				g_context, kPGPsdkPref_PrivateKeyring, fileRef);
		PGPFreeFileSpec (fileRef);

		PNLoadKeyRings (hwnd, &g_AOS.keysetMain);

		pos->bKeyringsChanged = TRUE;
		PGPFreeContext (context);
	}

	if (IsntPGPError (err))
		return TRUE;
	else
		return FALSE;
}


//	____________________________________
//
//	authentication options dialog proc

static BOOL CALLBACK
sAuthOptionsDlgProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam)
{
	POPTIONSSTRUCT	pos;

	switch (uMsg)
	{
	case WM_INITDIALOG :
		SetWindowLong (hwnd, GWL_USERDATA, ((PROPSHEETPAGE*)lParam)->lParam);
		pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		g_hwndOptions = hwnd;
		pos->hwndPGPKeyList = GetDlgItem (hwnd, IDC_PGPKEYLIST);

		sInitKeyLists (pos);
		g_AOS.hwndAuthDlg = hwnd;

#if !PGP_FREEWARE
		ShowWindow (GetDlgItem (hwnd, IDC_X509GROUPBOX), SW_SHOW);
		ShowWindow (GetDlgItem (hwnd, IDC_X509BORDER), SW_SHOW);
		ShowWindow (GetDlgItem (hwnd, IDC_X509ICON), SW_SHOW);
		ShowWindow (GetDlgItem (hwnd, IDC_X509KEYEDIT), SW_SHOW);
		ShowWindow (GetDlgItem (hwnd, IDC_SELECTX509KEY), SW_SHOW);
		ShowWindow (GetDlgItem (hwnd, IDC_CLEARX509KEY), SW_SHOW);
#endif //PGP_FREEWARE

		// enable key selection only if there are enough privileges
		if (g_bAuthAccess && !g_bReadOnly)
		{
			EnableWindow (GetDlgItem (hwnd, IDC_SELECTPGPKEY), TRUE);
#if !PGP_FREEWARE
			EnableWindow (GetDlgItem (hwnd, IDC_SELECTX509KEY), TRUE);
#endif //PGP_FREEWARE
			sGetKeyringPrefs (hwnd, pos);
		}

		PostMessage (hwnd, WM_APP, 0, 0);	
		return FALSE;

	case WM_APP :
		pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		if (g_bAuthAccess)
		{
			sSetKeyLists (hwnd, pos); 
		}
		break;

	case WM_PAINT :
		pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		break;

	case PGPNET_M_RELOADKEYRINGS :
		PostMessage (hwnd, WM_APP, 0, 0);
		break;

	case WM_NOTIFY :
	{
		pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		switch (((NMHDR FAR *) lParam)->code) {
		case PSN_HELP :
			WinHelp (hwnd, g_szHelpFile, HELP_CONTEXT, IDH_PNOPTAUTH_HELP); 
			break;

		case PSN_RESET :
			pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			pos->bUserCancel = TRUE;
			break;

		case PSN_APPLY :
			pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			if ((pos->bPGPKey != g_AOS.bPGPKey) ||
				(pos->bX509Key != g_AOS.bX509Key))
				g_AOS.bUpdateHostList = TRUE;

			g_AOS.bPGPKey = pos->bPGPKey;
			g_AOS.bX509Key = pos->bX509Key;

			g_AOS.pnconfig.uPGPAuthKeyAlg = pos->pnconfig.uPGPAuthKeyAlg;
			pgpCopyMemory (	pos->pnconfig.expkeyidPGPAuthKey,
							&g_AOS.pnconfig.expkeyidPGPAuthKey, 
							kPGPMaxExportedKeyIDSize);

			g_AOS.pnconfig.uX509AuthKeyAlg = pos->pnconfig.uX509AuthKeyAlg;
			pgpCopyMemory (	pos->pnconfig.expkeyidX509AuthKey,
							&g_AOS.pnconfig.expkeyidX509AuthKey, 
							kPGPMaxExportedKeyIDSize);

			if (g_AOS.pnconfig.pX509AuthCertIASN)
				PGPFreeData (g_AOS.pnconfig.pX509AuthCertIASN);
			g_AOS.pnconfig.pX509AuthCertIASN = 
							pos->pnconfig.pX509AuthCertIASN;
			g_AOS.pnconfig.uX509AuthCertIASNLength = 
							pos->pnconfig.uX509AuthCertIASNLength;

			pos->pnconfig.pX509AuthCertIASN = NULL;

			break;
		}
		break;
	}

	case WM_DESTROY :
		pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		ImageList_Destroy (pos->hil);
		break;

	case WM_HELP: 
		WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
			HELP_WM_HELP, (DWORD) (LPVOID) aAuthIds); 
		break; 
 
	case WM_CONTEXTMENU: 
		WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
			(DWORD) (LPVOID) aAuthIds); 
		break; 

	case WM_COMMAND :
	{
		PGPError	err;

		pos = (POPTIONSSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		switch (LOWORD (wParam)) {
		case IDC_PUBRINGBROWSE :
			if (sSelectKeyring (hwnd, FALSE, pos))
			{
				pos->bKeyringsChanged = TRUE;
				sSetKeyringPrefs (hwnd, FALSE, pos);
				sCompareToCurrent (hwnd);
				PostMessage (hwnd, WM_APP, 0, 0);
			}
			break;

		case IDC_SECRINGBROWSE :
			if (sSelectKeyring (hwnd, TRUE, pos))
			{
				pos->bKeyringsChanged = TRUE;
				sSetKeyringPrefs (hwnd, TRUE, pos);
				sCompareToCurrent (hwnd);
				PostMessage (hwnd, WM_APP, 0, 0);
			}
			break;

		case IDC_SETTOCURRENT :
			if (sSetToCurrentUsersKeyrings (hwnd, pos))
			{
				sGetKeyringPrefs (hwnd, pos);
				PostMessage (hwnd, WM_APP, 0, 0);
			}
			break;

		case IDC_SELECTPGPKEY :
			err = PNSelectPGPKey (g_context, g_AOS.keysetMain, hwnd,
						&pos->pnconfig.uPGPAuthKeyAlg, 
						pos->pnconfig.expkeyidPGPAuthKey);

			PostMessage (hwnd, WM_APP, 0, 0);
			break;

		case IDC_CLEARPGPKEY :
			if (sClearPGPAuthKey (hwnd, pos)) 
				PostMessage (hwnd, WM_APP, 0, 0);
			break;

		case IDC_SELECTX509KEY :
		{
			PGPKeyRef	key;
			PGPSigRef	sig;

			err = PGPclSelectX509Cert (g_context, hwnd, NULL,
						g_AOS.keysetMain, 
						PGPCL_CANSIGNKEYSONLY|PGPCL_NOSPLITKEYS,
						&key, &sig);
			if (IsntPGPError (err))
			{
				if (IsntNull (pos->pnconfig.pX509AuthCertIASN))
					PGPFreeData (pos->pnconfig.pX509AuthCertIASN);

				PGPX509CertToExport (g_context, key, sig,
						&(pos->pnconfig.uX509AuthKeyAlg), 
						pos->pnconfig.expkeyidX509AuthKey,
						&(pos->pnconfig.pX509AuthCertIASN),
						&(pos->pnconfig.uX509AuthCertIASNLength));
			}

			PostMessage (hwnd, WM_APP, 0, 0);
			break;
		}

		case IDC_CLEARX509KEY :
			if (sClearX509AuthKey (hwnd, pos)) 
				PostMessage (hwnd, WM_APP, 0, 0);
			break;
		}
		return 0;
	}
	}

	return FALSE;
}

//	____________________________________
//
//	dialog proc of hosts dialog

VOID
PNOptionsPropSheet (
		HWND	hwnd,
		UINT	uStartPage)
{
	PROPSHEETHEADER		psh;
	PROPSHEETPAGE		psp[PGPNET_NUMOPTIONS];
	CHAR				szCaption[64];
	OPTIONSSTRUCT		os;
	PGPUInt32			uNumProposals;
	PGPSize				size;

	pgpClearMemory (&os, sizeof(os));

	// initialize option structure 
	os.iSelectedCertItem	= -1;
	os.iSelectedCertParam	= -1;
	os.bUserCancel			= FALSE;
	os.bKeyringsChanged		= FALSE;

	// copy entire PNCONFIG structure
	pgpCopyMemory (&g_AOS.pnconfig, &os.pnconfig, sizeof(PNCONFIG));

	// copy authentication info for local use
	if (g_AOS.pnconfig.pX509AuthCertIASN)
	{
		os.pnconfig.pX509AuthCertIASN = 
				PGPNewData (PGPGetContextMemoryMgr (g_context),
							g_AOS.pnconfig.uX509AuthCertIASNLength, 
							kPGPMemoryMgrFlags_Clear);

		pgpCopyMemory (	g_AOS.pnconfig.pX509AuthCertIASN, 
						os.pnconfig.pX509AuthCertIASN,
						g_AOS.pnconfig.uX509AuthCertIASNLength);
	}

	// copy IKE proposal list for local use
	uNumProposals = 
		g_AOS.pnconfig.IkeIkeProposalPrefs.u.ikeProposals.numTransforms;
												;
	size = uNumProposals * sizeof(PGPikeTransform);

	os.pnconfig.IkeIkeProposalPrefs.u.ikeProposals.t =
			PGPNewData (PGPGetContextMemoryMgr (g_context),
					size, kPGPMemoryMgrFlags_Clear);
	pgpCopyMemory (	g_AOS.pnconfig.IkeIkeProposalPrefs.u.ikeProposals.t,
					os.pnconfig.IkeIkeProposalPrefs.u.ikeProposals.t,
					size);

	// copy IPSEC proposal list for local use
	uNumProposals = 
		g_AOS.pnconfig.IkeIpsecProposalPrefs.u.ipsecProposals.numTransforms;
												;
	size = uNumProposals * sizeof(PGPipsecTransform);

	os.pnconfig.IkeIpsecProposalPrefs.u.ipsecProposals.t = 
			PGPNewData (PGPGetContextMemoryMgr (g_context),
					size, kPGPMemoryMgrFlags_Clear);
	pgpCopyMemory (	g_AOS.pnconfig.IkeIpsecProposalPrefs.u.ipsecProposals.t, 
					os.pnconfig.IkeIpsecProposalPrefs.u.ipsecProposals.t,
					size);

	psp[PGPNET_GENOPTIONS].dwSize		= sizeof(PROPSHEETPAGE);
	psp[PGPNET_GENOPTIONS].dwFlags		= PSP_HASHELP;
	psp[PGPNET_GENOPTIONS].hInstance	= g_hinst;
	psp[PGPNET_GENOPTIONS].pszTemplate	= MAKEINTRESOURCE (IDD_GENOPTIONS);
	psp[PGPNET_GENOPTIONS].hIcon		= NULL;
	psp[PGPNET_GENOPTIONS].pszTitle		= NULL;
	psp[PGPNET_GENOPTIONS].pfnDlgProc	= sGenOptionsDlgProc;
	psp[PGPNET_GENOPTIONS].lParam		= (LPARAM)&os;
	psp[PGPNET_GENOPTIONS].pfnCallback	= NULL;
	psp[PGPNET_GENOPTIONS].pcRefParent	= NULL;

	psp[PGPNET_AUTHOPTIONS].dwSize		= sizeof(PROPSHEETPAGE);
	psp[PGPNET_AUTHOPTIONS].dwFlags		= PSP_HASHELP;
	psp[PGPNET_AUTHOPTIONS].hInstance	= g_hinst;
	psp[PGPNET_AUTHOPTIONS].pszTemplate	= MAKEINTRESOURCE (IDD_AUTHOPTIONS);
	psp[PGPNET_AUTHOPTIONS].hIcon		= NULL;
	psp[PGPNET_AUTHOPTIONS].pszTitle	= NULL;
	psp[PGPNET_AUTHOPTIONS].pfnDlgProc	= sAuthOptionsDlgProc;
	psp[PGPNET_AUTHOPTIONS].lParam		= (LPARAM)&os;
	psp[PGPNET_AUTHOPTIONS].pfnCallback	= NULL;
	psp[PGPNET_AUTHOPTIONS].pcRefParent	= NULL;

	psp[PGPNET_ADVOPTIONS].dwSize		= sizeof(PROPSHEETPAGE);
	psp[PGPNET_ADVOPTIONS].dwFlags		= PSP_HASHELP;
	psp[PGPNET_ADVOPTIONS].hInstance	= g_hinst;
	psp[PGPNET_ADVOPTIONS].pszTemplate	= MAKEINTRESOURCE (IDD_ADVANCEDOPTIONS);
	psp[PGPNET_ADVOPTIONS].hIcon		= NULL;
	psp[PGPNET_ADVOPTIONS].pszTitle		= NULL;
	psp[PGPNET_ADVOPTIONS].pfnDlgProc	= PNAdvancedOptionsDlgProc;
	psp[PGPNET_ADVOPTIONS].lParam		= (LPARAM)&os;
	psp[PGPNET_ADVOPTIONS].pfnCallback	= NULL;
	psp[PGPNET_ADVOPTIONS].pcRefParent	= NULL;

	LoadString (g_hinst, IDS_OPTIONSCAPTION, szCaption, sizeof(szCaption));
	psh.dwSize		= sizeof(PROPSHEETHEADER);
	psh.dwFlags		= PSH_NOAPPLYNOW|PSH_PROPSHEETPAGE|PSH_HASHELP;
	psh.hwndParent	= hwnd;
	psh.hInstance	= g_hinst;
	psh.hIcon		= NULL;
	psh.pszCaption	= szCaption;
	psh.nPages		= PGPNET_NUMOPTIONS;
	psh.nStartPage	= uStartPage;
	psh.ppsp		= &psp[0];
	psh.pfnCallback	= NULL;

	PropertySheet (&psh);

	g_AOS.hwndAuthDlg = NULL;

	if (os.bUserCancel)
	{
		PGPnetLoadSDKPrefs (g_context);
		if (os.bKeyringsChanged)
		{
			PNLoadKeyRings (hwnd, &g_AOS.keysetMain);
		}
	}
	else
	{
		PGPsdkSavePrefs (g_context);
		PNSaveConfiguration (hwnd, &g_AOS.pnconfig, os.bKeyringsChanged);
	}

	if (IsntNull (os.pnconfig.pX509AuthCertIASN))
		PGPFreeData (os.pnconfig.pX509AuthCertIASN);
	if (IsntNull (os.pnconfig.IkeIkeProposalPrefs.u.ikeProposals.t))
		PGPFreeData (os.pnconfig.IkeIkeProposalPrefs.u.ikeProposals.t);
	if (IsntNull (os.pnconfig.IkeIpsecProposalPrefs.u.ipsecProposals.t))
		PGPFreeData (os.pnconfig.IkeIpsecProposalPrefs.u.ipsecProposals.t);

	g_hwndOptions = NULL;
}