pktoken.c

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

	switch (uMsg) {

	case WM_INITDIALOG:
	{
		RECT		rc;
		HWND		hwndParent;

		SetWindowLong (hwnd, GWL_USERDATA, ((PROPSHEETPAGE*)lParam)->lParam);
		ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);

		s_hwndProperties = hwnd;

		if (ptds->bNeedsCentering) 
		{
			PGPclCenterWindowOnMonitor (GetParent (hwnd), kPGPclWindowMonitor);
			ptds->bNeedsCentering = FALSE;
		}

		// disable and hide cancel button; and move "OK" button over
		hwndParent = GetParent (hwnd);
		SendMessage (hwndParent, PSM_CANCELTOCLOSE, 0, 0);
		GetWindowRect (GetDlgItem (hwndParent, IDCANCEL), &rc);
		MapWindowPoints (NULL, hwndParent, (LPPOINT)&rc, 2);
		SetWindowPos (GetDlgItem (hwndParent, IDOK), NULL, rc.left,
				rc.top, rc.right-rc.left, rc.bottom-rc.top,
				SWP_NOZORDER);
		ShowWindow (GetDlgItem (hwndParent, IDCANCEL), SW_HIDE);

		// post message to load properties
		PostMessage (hwnd, WM_APP, TRUE, 0);

		return TRUE;
	}

	case WM_APP :
	{
		PGPTokenInfo	pti;
		CHAR			sz1[32], sz2[32], szFormat[32];

		ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);

		pti.size =  sizeof(pti);
		PGPGetTokenInfo (ptds->context, 0, &pti);

		SetDlgItemText (hwnd, IDC_MANUFACTURER, pti.manufacturerID);
		SetDlgItemText (hwnd, IDC_MODEL, pti.model);
		SetDlgItemText (hwnd, IDC_SERIAL, pti.serialNumber);

		// indicate supported keys
		sz1[0] = '\0';

///		if (pti.bDsa)
///		{
///		}

		if (pti.bRsa)
		{
			if (sz1[0])
				lstrcat (sz1, ", ");

			LoadString (g_hinst, IDS_RSA, sz2, sizeof(sz2));
			lstrcat (sz1, sz2);
			lstrcat (sz1, " (");

			if (pti.minRsaKeySize != pti.maxRsaKeySize)
			{
				LoadString (g_hinst, 
						IDS_SMARTCARDPREFIX, szFormat, sizeof(szFormat));
				wsprintf (sz2, szFormat, pti.minRsaKeySize);
				lstrcat (sz1, sz2);
			}
			LoadString (g_hinst, 
					IDS_SMARTCARDKEYSIZE, szFormat, sizeof(szFormat));
			wsprintf (sz2, szFormat, pti.maxRsaKeySize);
			lstrcat (sz1, sz2);

			lstrcat (sz1, ")");
		}

		if (!sz1[0])
			LoadString (g_hinst, IDS_NONE, sz1, sizeof(sz1));

		SetDlgItemText (hwnd, IDC_KEYSUPPORT, sz1);

		// indicate supported PIN length range
		sz1[0] = '\0';
		if (pti.minPinLen != pti.maxPinLen)
		{
			LoadString (g_hinst, 
					IDS_SMARTCARDPREFIX, szFormat, sizeof(szFormat));
			wsprintf (sz1, szFormat, pti.minPinLen);
		}
		LoadString (g_hinst, 
				IDS_SMARTCARDPINLENGTH, szFormat, sizeof(szFormat));
		wsprintf (sz2, szFormat, pti.maxPinLen);
		lstrcat (sz1, sz2);

		SetDlgItemText (hwnd, IDC_PINLENGTH, sz1);

		// report number of private keys on card
		SetDlgItemInt (hwnd, IDC_NUMPRIVKEYS, pti.numPrivKeys, FALSE);

		break;
	}

	case WM_HELP :
	case WM_CONTEXTMENU :
		return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
				(char*)kPGPclHelpFile, aTokenIds);

	case WM_NOTIFY :
		switch (((NMHDR FAR *) lParam)->code) {

		case PSN_HELP :
			PGPclHtmlHelp (hwnd, kPGPclHelpContext, 0, 0,
					(char*)kPGPclHelpFile, 
					(DWORD*)IDH_PGPPKTOKEN_CONTENTSDIALOG);
			break;
		}
		break;
	}

	return FALSE;
}


//	_____________________________________________________
//
//  Message processing function for Token property sheet

static LRESULT WINAPI
sTokenContentsDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	TOKENDLGSTRUCT*			ptds;

	switch (uMsg) {

	case WM_INITDIALOG:
	{
		RECT		rc;
		INT			iY;
		PGPPrefRef	prefref;

		SetWindowLong (hwnd, GWL_USERDATA, ((PROPSHEETPAGE*)lParam)->lParam);
		ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);

		s_hwndContents = hwnd;

		// create keymanager window
		GetWindowRect (GetDlgItem (hwnd, IDC_WIPETOKEN), &rc);
		ScreenToClient (hwnd, (LPPOINT)&rc);
		iY = rc.top;

		GetClientRect (hwnd, &rc);

		ptds->hKL = PGPclKeyListCreate (ptds->context, ptds->tlscontext,
				hwnd, IDC_TOKENKEYLIST, 
				rc.left, rc.top, rc.right-rc.left, iY-rc.top-YOFFSET,
				kPGPclKeyList_SingleSelection|kPGPclKeyList_ShowSelection,
				&ptds->hwndTree);

		// configure key manager window
		ptds->klConfig.keyserver.protocol = kPGPKeyServerProtocol_Invalid;
		ptds->klConfig.hwndStatusBar = NULL;
		ptds->klConfig.uOptions = 
				kPGPclKeyList_SelectKeysOnly | kPGPclKeyList_ReadOnly;

		// get those options which are based on prefs
		if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		{
			PGPBoolean	b;

			PGPGetPrefBoolean (prefref, kPGPPrefDisplayMarginalValidity, &b);
			if (!b) 
				ptds->klConfig.uOptions |= kPGPclKeyList_GreenDotMode;
			PGPGetPrefBoolean (prefref, kPGPPrefMarginalIsInvalid, &b);
			if (b) 
				ptds->klConfig.uOptions |= kPGPclKeyList_MarginalIsInvalid;
		}

		ptds->klConfig.uMask = kPGPclKeyList_ConfigureAll;
		PGPclKeyListConfigure (ptds->hKL, &ptds->klConfig);

		// post message to load keyset
		PostMessage (hwnd, WM_APP, TRUE, 0);

		return TRUE;
	}

	case WM_APP :
		ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);

		if (PGPKeySetRefIsValid (ptds->keysetToDisplay))
		{
			PGPclKeyListLoadKeys (ptds->hKL, NULL, NULL);
			PGPFreeKeySet (ptds->keysetToDisplay);
			ptds->keysetToDisplay = kInvalidPGPKeySetRef;
		}

		if ((BOOL)wParam)
		{
			sGetKeysOnToken (ptds->ppks->keydbMain, &(ptds->keysetToDisplay));

			PGPclKeyListLoadKeys (ptds->hKL, 
					ptds->ppks->keydbMain, ptds->keysetToDisplay);
		}

		InvalidateRect (hwnd, NULL, TRUE);
		UpdateWindow (hwnd);
		break;

	case WM_HELP :
	case WM_CONTEXTMENU :
		return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
				(char*)kPGPclHelpFile, aTokenIds);

	case WM_COMMAND :
		ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);
		switch (LOWORD (wParam)) {
		case IDM_KEYPROPERTIES :
		{
			PGPKeyDBObjRef	key;

			PGPclKeyListGetSelectionInfo (ptds->hKL, NULL, &key, NULL, NULL);
			PGPclKeyDBObjProperties (ptds->context, ptds->tlscontext, 
					hwnd, key, ptds->ppks->keydbMain, 
					kPGPclProperties_Key, NULL);
			PostMessage (hwnd, WM_APP, TRUE, 0);
			break;
		}

		case IDC_WIPETOKEN :
		{
			PGPError	err;

			err = sWipeToken (hwnd, ptds->ppks);
			if (IsPGPError (err))
			{
				if (err == kPGPError_BadPassphrase)
				{
					PKMessageBox (hwnd, IDS_CAPTIONALERT, 
							IDS_BADTOKENPHRASE, MB_OK|MB_ICONEXCLAMATION);
				}
				else
					PGPclErrorBox (hwnd, err);
			}
			
			if (IsntPGPError (err))
			{
				ptds->bModified = TRUE;
				PostMessage (s_hwndProperties, WM_APP, 0, 0);
				PostMessage (hwnd, WM_APP, 0, 0);
			}
			break;
		}
		}
		break;

	case WM_DESTROY :
		ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);

		// destropy keylist
		PGPclKeyListDestroy (ptds->hKL, FALSE);
		break;

	case WM_NOTIFY :
		if (wParam == IDC_TOKENKEYLIST) 
		{
			ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);
			// let keymanager have first whack at the notification
			PGPclKeyListDefaultNotificationProc (ptds->hKL, lParam);

			switch (((LPNM_TREELIST)lParam)->hdr.code) {
			// post the context menu
			case TLN_CONTEXTMENU :
				sTokenContextMenu (hwnd, ptds->hKL,
						((LPNM_TREELIST)lParam)->flags,
						((LPNM_TREELIST)lParam)->ptDrag.x,
						((LPNM_TREELIST)lParam)->ptDrag.y);
				break;
			}
			break;
		}

		switch (((NMHDR FAR *) lParam)->code) {

		case PSN_HELP :
			PGPclHtmlHelp (hwnd, kPGPclHelpContext, 0, 0,
					(char*)kPGPclHelpFile, 
					(DWORD*)IDH_PGPPKTOKEN_CONTENTSDIALOG);
			break;
		}
		break;

	case PGPCL_M_PROPERTYMESSAGE :
		if (wParam == kPGPclProperties_UpdateObject)
		{
			ptds = (TOKENDLGSTRUCT*)GetWindowLong (hwnd, GWL_USERDATA);
			ptds->bModified = TRUE;
		}
		break;
	}

	return FALSE;
}


//	___________________________________________________
//
//  update the tokens properties dialog

VOID 
PKReloadTokenProperties (
		BOOL	bLoadKeys)
{
	if (s_hwndContents)
	{
		SendMessage (s_hwndContents, WM_APP, (WPARAM)bLoadKeys, 0);
	}
}


//	___________________________________________________
//
//  display the token properties dialog

BOOL 
PKTokenProperties (
		PGPKEYSSTRUCT*	ppks)
{
	TOKENDLGSTRUCT		tds;
    PROPSHEETPAGE		psp[2];
    PROPSHEETHEADER		psh;
	CHAR				szTitle[128];

	LoadString (g_hinst, IDS_TOKENPROPCAPTION, szTitle, sizeof(szTitle));

	// zero out PREFSDLGSTRUCT
	memset (&tds, 0, sizeof(tds));

	tds.ppks = ppks;
	tds.context = g_context;
	tds.tlscontext = g_tlscontext;
	tds.hwndParent = ppks->hwndMain;
	tds.bNeedsCentering = TRUE;

	psp[0].dwSize = sizeof(PROPSHEETPAGE);
	psp[0].dwFlags = PSP_USETITLE|PSP_HASHELP;
	psp[0].hInstance = g_hinst;
	psp[0].pszTemplate = MAKEINTRESOURCE(IDD_TOKENPROPS);
	psp[0].pszIcon = NULL;
	psp[0].pfnDlgProc = sTokenPropsDlgProc;
	psp[0].pszTitle = (LPSTR)IDS_TOKEN_PROPERTIES;
	psp[0].lParam = (LPARAM)&tds;
	psp[0].pfnCallback = NULL;

	psp[1].dwSize = sizeof(PROPSHEETPAGE);
	psp[1].dwFlags = PSP_USETITLE|PSP_HASHELP;
	psp[1].hInstance = g_hinst;
	psp[1].pszTemplate = MAKEINTRESOURCE(IDD_TOKENCONTENTS);
	psp[1].pszIcon = NULL;
	psp[1].pfnDlgProc = sTokenContentsDlgProc;
	psp[1].pszTitle = (LPSTR)IDS_TOKEN_CONTENTS;
	psp[1].lParam = (LPARAM)&tds;
	psp[1].pfnCallback = NULL;

	psh.dwSize = sizeof(PROPSHEETHEADER);
	psh.dwFlags = PSH_PROPSHEETPAGE | PSH_NOAPPLYNOW;
	psh.hwndParent = tds.hwndParent;
	psh.hInstance = g_hinst;
	psh.pszIcon = NULL;
	psh.pszCaption = (LPSTR) szTitle;
	psh.nPages = 2;
	psh.nStartPage = 0;
	psh.ppsp = (LPCPROPSHEETPAGE) &psp;
	psh.pfnCallback = NULL;

	// actually display and handle the property sheet
	PropertySheet (&psh);

	s_hwndProperties = NULL;
	s_hwndContents = NULL;

	if (PGPKeySetRefIsValid (tds.keysetToDisplay))
		PGPFreeKeySet (tds.keysetToDisplay);

	return tds.bModified;
}