pkmsgprc.c

vc环境下的pgp源码

						break;
					}
				}
				break;

			default :
				break;
			}
		}

		// did it come from the group treelist ?
		else if (wParam == IDC_TREELISTGROUP) {
			if (pnmh->code == TLN_SELCHANGED) {
				PGPkmPerformAction (ppks->hKM, KM_UNSELECTALL);
			}

			PGPgmDefaultNotificationProc (ppks->hGM, lParam);

			switch (pnmh->code) {
			case TLN_CONTEXTMENU :
				ppks->bGroupsFocused = TRUE;
				ppks->uGroupSelectionFlags = ((LPNM_TREELIST)lParam)->flags;
				PKContextMenu (ppks, hWnd, 
					((LPNM_TREELIST)lParam)->ptDrag.x,
					((LPNM_TREELIST)lParam)->ptDrag.y);
				break;

			case TLN_SELCHANGED :
				ppks->bGroupsFocused = TRUE;
				ppks->uGroupSelectionFlags = ((LPNM_TREELIST)lParam)->flags;
				PKSetToolbarButtonStates (ppks);
				break;

			case TLN_KEYDOWN :
				switch (((TL_KEYDOWN*)lParam)->wVKey) {
				case VK_TAB :
					SendMessage (ppks->kmConfig.hWndStatusBar, SB_SETTEXT, 
									STATUS_MSG_PANE, (LPARAM)"");
					ppks->bGroupsFocused = !ppks->bGroupsFocused;
					if (ppks->bGroupsFocused) 
						SetFocus (ppks->hWndTreeListGroups);
					else 
						SetFocus (ppks->hWndTreeList);
					PKSetToolbarButtonStates (ppks);
					break;
				}
				break;

			default :
				break;
			}
		}

		// did it come from the search window keyserver code ?
		else if ((ppks->hWndSearchControl) &&
				 (pnmh->hwndFrom == ppks->hWndSearchControl)) {
			switch (pnmh->code)
			{
				case SEARCH_REQUEST_SIZING: 
				{
					PSIZEREQUEST pRequest = (PSIZEREQUEST)lParam;
					RECT rc;
					GetClientRect (ppks->hWndTreeList, &rc);
					if ((rc.bottom - rc.top) > (pRequest->delta + 50))
						return TRUE;
					else
						return FALSE;
				}

				case SEARCH_SIZING: 
				{
					PSIZEREQUEST pRequest = (PSIZEREQUEST)lParam;
					RECT rcTool, rcMain;
					GetWindowRect (pnmh->hwndFrom, &rcTool);
					ppks->iToolHeight = rcTool.bottom-rcTool.top;

					GetClientRect (hWnd, &rcMain);

					SetWindowPos (ppks->hWndTreeList, NULL, 
						0, ppks->iToolHeight, 
						rcMain.right-rcMain.left, 
						rcMain.bottom-rcMain.top
							-ppks->iToolHeight
							-STATUSBARHEIGHT, 
						SWP_NOZORDER);
					InvalidateRect (hWnd, NULL, FALSE);
					break;
				}

				case SEARCH_DISPLAY_KEYSET: 
				{
					PSEARCHRESULT	pResult = (PSEARCHRESULT)lParam;
					PGPKeySetRef	KeySetPrevious;
					HCURSOR			hCursorOld;
					CHAR			sz[64];

					// stop LEDs, if going
					if (ppks->bSearchInProgress) {
						KillTimer (hWnd, LEDTIMER);
						ppks->bSearchInProgress = FALSE;
						ppks->iStatusValue = -1;
						InvalidateRect (ppks->kmConfig.hWndStatusBar, 
											NULL, FALSE);
						UpdateWindow (ppks->kmConfig.hWndStatusBar);
					}

					// if error, post message and drop out
					if (IsPGPError (pResult->error) && 
						(pResult->error != 
								kPGPError_ServerPartialSearchResults)) 
					{
						KillTimer (hWnd, LEDTIMER);
						ppks->bSearchInProgress = FALSE;
						ppks->iStatusValue = -1;
						SendMessage (ppks->kmConfig.hWndStatusBar, 
								SB_SETTEXT, STATUS_MSG_PANE, (LPARAM)"");
						InvalidateRect (ppks->kmConfig.hWndStatusBar, 
										NULL, FALSE);
						PGPclErrorBox (NULL, pResult->error);
						break;
					}

					// load new keyset into window
					LoadString (g_hInst, IDS_SYNCINGKEYSETS, sz, sizeof(sz));
					SendMessage (ppks->kmConfig.hWndStatusBar, SB_SETTEXT, 
									STATUS_MSG_PANE, (LPARAM)sz);
					UpdateWindow (ppks->kmConfig.hWndStatusBar);

					hCursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));

					KeySetPrevious = ppks->KeySetDisp;
					ppks->KeySetDisp = (PGPKeySetRef)(pResult->pData);

					if (pResult->flags & FLAG_SEARCH_LOCAL_KEYSET) {
						ppks->bLocalKeySet = TRUE;
						ppks->kmConfig.keyserver.structSize = 0;
						ppks->kmConfig.ulOptionFlags = 
							KMF_ENABLERELOADS |
							KMF_ENABLECOMMITS |
							KMF_ENABLEDRAGOUT;
						if (!g_bExpertMode)
							ppks->kmConfig.ulOptionFlags |= KMF_NOVICEMODE;
						if (g_bMarginalAsInvalid) 
							ppks->kmConfig.ulOptionFlags |= KMF_MARGASINVALID;
						if (g_bReadOnly)
							ppks->kmConfig.ulOptionFlags |= KMF_READONLY;
						ppks->kmConfig.ulDisableActions = 
							KM_ADDTOMAIN|KM_IMPORT|KM_PASTE|
							KM_SETASPRIMARY|KM_SETASDEFAULT;
					}
					else {
						ppks->bLocalKeySet = FALSE;
						memcpy (&ppks->kmConfig.keyserver, 
								&pResult->keyserver, 
								sizeof(PGPKeyServerEntry));
						ppks->kmConfig.ulOptionFlags = 
							KMF_ENABLEDRAGOUT;
						if (!g_bExpertMode)
							ppks->kmConfig.ulOptionFlags |= KMF_NOVICEMODE;
						if (g_bMarginalAsInvalid) 
							ppks->kmConfig.ulOptionFlags |= KMF_MARGASINVALID;
						if (pResult->flags & FLAG_AREA_PENDING) 
							ppks->kmConfig.ulOptionFlags |= KMF_PENDINGBUCKET;
						ppks->kmConfig.ulDisableActions = 
							KM_IMPORT|KM_PASTE|
							KM_SETASPRIMARY|KM_SETASDEFAULT;
					}
					ppks->kmConfig.ulMask = PGPKM_OPTIONS |
											PGPKM_KEYSERVER |
											PGPKM_DISABLEFLAGS;
					PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));

					// display keyset
					PGPkmLoadKeySet (ppks->hKM, ppks->KeySetDisp, 
												ppks->KeySetMain);
					SetFocus (ppks->hWndTreeList);

					// sync downloaded keyset with main and redisplay
					PGPclSyncKeySets (g_Context, ppks->KeySetMain, 
											ppks->KeySetDisp);
					PGPkmLoadKeySet (ppks->hKM, ppks->KeySetDisp, 
												ppks->KeySetMain);

					sDisplayKSKeyResult (ppks->KeySetDisp, 
										ppks->kmConfig.hWndStatusBar,
										pResult->error);

					// stop LEDs, if going
					if (ppks->bSearchInProgress) {
						KillTimer (hWnd, LEDTIMER);
						ppks->bSearchInProgress = FALSE;
						ppks->iStatusValue = -1;
						InvalidateRect (ppks->kmConfig.hWndStatusBar, 
											NULL, FALSE);
					}

					if (KeySetPrevious) PGPFreeKeySet (KeySetPrevious);
					SetCursor (hCursorOld);

					SendMessage (ppks->hWndSearchControl, 
											SEARCH_SET_FOCUS, 0, 0);
					break;
				}

				case SEARCH_PROGRESS :
				{
					PSEARCHPROGRESS pProgress = (PSEARCHPROGRESS)lParam;

					if (pProgress->total) {
						// we're starting a query
						if (!ppks->bSearchInProgress) {
							ppks->bSearchInProgress = TRUE;
							ppks->kmConfig.ulOptionFlags |= 
													KMF_DISABLESTATUSBAR;
							ppks->kmConfig.ulMask = PGPKM_OPTIONS;
							PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));

							ppks->iStatusValue = 0;
							if (pProgress->step == SEARCH_PROGRESS_INFINITE) 
							{
								ppks->iStatusDirection = 1;
								SetTimer (hWnd, LEDTIMER, 
													LEDTIMERPERIOD, NULL);
							}
							else 
							{
								ppks->iStatusDirection = 0;
								ppks->iStatusValue = 0;
							}
							// reset icon to "unlocked"
							SendMessage (ppks->kmConfig.hWndStatusBar, 
									SB_SETTEXT, 
									LOCK_PANE|SBT_OWNERDRAW|SBT_POPOUT, 
									0);
							// signal that we're not authenticated yet
							ppks->iTLSstatus = TLS_NOTAUTHENTICATED;
						}
						else {
							if (pProgress->step != SEARCH_PROGRESS_INFINITE) 
							{
								ppks->iStatusDirection = 0;
								ppks->iStatusValue = 
									(pProgress->step * 9) / pProgress->total;
								InvalidateRect (ppks->kmConfig.hWndStatusBar, 
													NULL, FALSE);
							}
						}
					}
					else {
						if (ppks->bSearchInProgress) {
							KillTimer (hWnd, LEDTIMER);
							ppks->bSearchInProgress = FALSE;
							ppks->iStatusValue = -1;
							InvalidateRect (ppks->kmConfig.hWndStatusBar, 
											NULL, FALSE);
						}
					}

					SendMessage (ppks->kmConfig.hWndStatusBar, SB_SETTEXT, 
							STATUS_MSG_PANE, (LPARAM)(pProgress->message));
					break;
				}

				case SEARCH_SECURE_STATUS :
				{
					PSEARCHSECURE	pSecure = (PSEARCHSECURE)lParam;
					PGPKeySetRef	keyset;
					PGPKeyListRef	keylist;
					PGPKeyIterRef	keyiter;
					
					SendMessage (ppks->kmConfig.hWndStatusBar, SB_SETTEXT,
									LOCK_PANE|SBT_OWNERDRAW|SBT_POPOUT, 
									(LPARAM)(pSecure->secure));

					if (pSecure->secure) {
						ppks->iTLSstatus = TLS_AUTHENTICATED;

						lstrcpy (ppks->szTLSserver, pSecure->szServerName);
						ppks->tlsCipher = pSecure->tlsCipher;

						if (PGPKeySetRefIsValid (ppks->keysetAuth))
							PGPFreeKeySet (ppks->keysetAuth);
						PGPNewSingletonKeySet (pSecure->keyAuth, &keyset);
						PGPNewKeySet (g_Context, &ppks->keysetAuth);
						PGPAddKeys (keyset, ppks->keysetAuth);
						PGPCommitKeyRingChanges (ppks->keysetAuth);
						PGPFreeKeySet (keyset);
	
						PGPOrderKeySet (ppks->keysetAuth, 
										kPGPAnyOrdering, &keylist);
						PGPNewKeyIter (keylist, &keyiter);
						PGPKeyIterNext (keyiter, &ppks->keyAuth);
						PGPFreeKeyIter (keyiter);
						PGPFreeKeyList (keylist);
					}
					else 
						ppks->iTLSstatus = TLS_NOTAUTHENTICATED;
	
					break;
				}

				case SEARCH_ABORT :
				{
					PSEARCHABORT pAbort = (PSEARCHABORT)lParam;
					CHAR sz[256];
					if (ppks->bSearchInProgress) {
						KillTimer (hWnd, LEDTIMER);
						ppks->bSearchInProgress = FALSE;
						ppks->iStatusValue = -1;
						InvalidateRect (ppks->kmConfig.hWndStatusBar, 
											NULL, FALSE);
					}
					LoadString (g_hInst, IDS_SEARCHABORTED, 
									sz, sizeof(sz));
					SendMessage (ppks->kmConfig.hWndStatusBar, SB_SETTEXT,
									STATUS_MSG_PANE, (LPARAM)sz);
					SendMessage (ppks->hWndSearchControl, 
											SEARCH_SET_FOCUS, 0, 0);
					break;
				}

				default :
					break;
			}

			if (!ppks->bSearchInProgress) {
				ppks->kmConfig.ulOptionFlags &= ~KMF_DISABLESTATUSBAR;
				ppks->kmConfig.ulMask = PGPKM_OPTIONS;
				PGPkmConfigure (ppks->hKM, &(ppks->kmConfig));
			}
		}

		// did it come from the status bar?
		else if ((ppks->kmConfig.hWndStatusBar) &&
				 (pnmh->hwndFrom == ppks->kmConfig.hWndStatusBar)) {
			if (pnmh->code == NM_CLICK) {
				if (!ppks->bMainWindow) {
					POINT pt;
					GetCursorPos (&pt);
					ScreenToClient (ppks->kmConfig.hWndStatusBar, &pt);
					if (pt.x <= LOCKWIDTH) {
						switch (ppks->iTLSstatus) {
						case TLS_NOSEARCHYET :
							PKMessageBox (hWnd, IDS_CAPTION, 
								IDS_NOCONNECTIONYET, 
								MB_OK|MB_ICONEXCLAMATION);
							break;

						case TLS_NOTAUTHENTICATED :
							PKMessageBox (hWnd, IDS_CAPTION, 
								IDS_CONNECTIONNOTAUTHENTICATED, 
								MB_OK|MB_ICONEXCLAMATION);
							break;

						case TLS_AUTHENTICATED :
							PGPclConfirmRemoteAuthentication (
									g_Context, hWnd, ppks->szTLSserver,
									ppks->keyAuth, ppks->tlsCipher,
									ppks->KeySetMain, 
									PGPCL_SHOWAUTHENTICATION);
							break;

						}
					}
				}
			}
		}

		// else assume it's from the tooltip control of the toolbar
		else if (pnmh->code == TTN_NEEDTEXT) {
			PKGetToolbarTooltipText ((LPTOOLTIPTEXT)lParam);
		}
		}

		break;

	case WM_PAINT :
		{
			HDC			hdc;
			PAINTSTRUCT ps;
			RECT		rc;
			HPEN		hpenOld;
			INT			iWidth;

			ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);

			hdc = BeginPaint (hWnd, &ps);

			if (ppks->hWndToolBar && (ppks->iToolHeight > 0)) {
				GetWindowRect (hWnd, &rc);
				iWidth = rc.right-rc.left;

				hpenOld = SelectObject (hdc, CreatePen (PS_SOLID, 0, 
								GetSysColor (COLOR_3DSHADOW)));
				MoveToEx (hdc, 0, 0, NULL);
				LineTo (hdc, iWidth, 0);

				SelectObject (hdc, CreatePen (PS_SOLID, 0, 
								GetSysColor (COLOR_3DHILIGHT)));
				MoveToEx (hdc, 0, 1, NULL);
				LineTo (hdc, iWidth, 1);

				SelectObject (hdc, hpenOld);
			}

			EndPaint (hWnd, &ps);
		}
		return 0;

	case WM_TIMER :
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);

		// it's time to load the keyring from disk
		if (wParam == RELOADTIMERID) {

			KillTimer (hWnd, wParam);

			// do the actual loading
			bIgnoreReloads = TRUE;
			if (sReloadKeyrings (ppks))
			{
				// repaint window
				InvalidateRect (hWnd, NULL, FALSE);

				// do some first-time post-processing
				if (bFirstKeyringLoad) {
					PGPBoolean bUpdateAllKeys;
					PGPBoolean bUpdateTrustedIntroducers;
					PGPBoolean bUpdateCRLs;

					bFirstKeyringLoad = FALSE;

					// import key files if passed from the command line
					sProcessFileList (GetCommandLine (), TRUE, TRUE,
										ppks->KeySetMain);

					// import keys from prefs file if available
					if (IsntPGPError (sImportPrefsKeys (ppks->KeySetMain)))
						PGPkmReLoadKeySet (ppks->hKM, FALSE);

					// display groups if groups were displayed last session
					if (g_bShowGroups) 
						PostMessage (hWnd, WM_COMMAND,
										MAKEWPARAM (IDM_VIEWGROUPS, 0), 0);

					// check if we are to run the keygen wizard
					if (g_bKeyGenEnabled) {
						PGPBoolean	bKeyGenerated;
						PGPPrefRef	prefref;

						PGPclOpenClientPrefs (
									PGPGetContextMemoryMgr (g_Context), 
									&prefref);
						PGPGetPrefBoolean (prefref, 
									kPGPPrefFirstKeyGenerated, &bKeyGenerated);
						PGPclCloseClientPrefs (prefref, FALSE);
						if (!bKeyGenerated) {
							if (!sPKCheckForSecretKeys (ppks->KeySetMain)) {
								ShowWindow (g_hWndMain, SW_HIDE);
								PKCreateKey (g_hWndMain, ppks->KeySetMain);
							}
						}
					}

					// compute when we should next update CRLs
					PKScheduleNextCRLUpdate (g_Context, ppks->KeySetMain);

					// see if it's time to auto-update anything
					PGPclCheckAutoUpdate (PGPGetContextMemoryMgr (g_Context),
						TRUE, &bUpdateAllKeys, &bUpdateTrustedIntroducers,
						&bUpdateCRLs);

					if (bUpdateAllKeys) {
						if (PKAutoUpdateAllKeys (hWnd, 
											ppks->KeySetMain, FALSE))
							PGPkmReLoadKeySet (ppks->hKM, FALSE);
					}

					if (bUpdateTrustedIntroducers) {
						if (PKAutoUpdateIntroducers (hWnd, 
											ppks->KeySetMain, FALSE))
							PGPkmReLoadKeySet (ppks->hKM, TRUE);
					}

					if (bUpdateCRLs) {
						if (PKUpdateCARevocations (
									hWnd, ppks->hKM, ppks->KeySetMain))
							PGPkmReLoadKeySet (ppks->hKM, TRUE);
					}
				}

				// if there is an open search window, notify it of change
				if (ppks->bMainWindow && hwndOpenSearch)
				{
					PostMessage (hwndOpenSearch, KM_M_RELOADKEYRINGS,
									0, (LPARAM)(ppks->KeySetMain));
				}
			}
		}
		else {
			ppks->iStatusValue += ppks->iStatusDirection;
			if (ppks->iStatusValue <= 0) {
				ppks->iStatusValue = 0;
				ppks->iStatusDirection = 1;
			}
			else if (ppks->iStatusValue >= NUMLEDS-1) {
				ppks->iStatusValue = NUMLEDS-1;
				ppks->iStatusDirection = -1;
			}
			InvalidateRect (ppks->kmConfig.hWndStatusBar, NULL, FALSE);
		}
		bIgnoreReloads = FALSE;
		break;

	case KM_M_RELOADKEYRINGS : 
		ppks = (PGPKEYSSTRUCT*)GetWindowLong (hWnd, GWL_USERDATA);

		PGPkmLoadKeySet (ppks->hKM, NULL, NULL);
		if (ppks->bMainWindow) {
			if (hwndOpenSearch)
				SendMessage (hwndOpenSearch, KM_M_RELOADKEYRINGS, 0, 0);
			if (ppks->KeySetMain) {
				PGPFreeKeySet (ppks->KeySetMain);
				ppks->KeySetMain = NULL;
			}
			SetTimer (hWnd, RELOADTIMERID, RELOADDELAY, NULL);
		}
		else {