commands.cpp

vc环境下的pgp源码

	else
		if (_context == EECONTEXT_READNOTEMESSAGE)
		{
			char szCommand[256];
			char szMenu[256];
			MENUITEMINFO miiMenu;

			miiMenu.cbSize = sizeof(MENUITEMINFO);
			miiMenu.fMask = MIIM_TYPE;
			miiMenu.dwTypeData = szMenu;
			miiMenu.cch = 255;

			UIGetString(szCommand, sizeof(szCommand), IDS_DECRYPT_MENU);
			GetMenuItemInfo(_hmenuPGP, 0, TRUE, &miiMenu);
			if (strcmp(szCommand, szMenu))
			{
				strcpy(szMenu, szCommand);
				SetMenuItemInfo(_hmenuPGP, 0, TRUE, &miiMenu);
				DrawMenuBar(hwndMain);
			}

			SendMessage(hwndToolbar, TB_ENABLEBUTTON, 
				_cmdidDecrypt, MAKELONG(TRUE, 0));
		}


	if (!_fInitMenuOnce)
	{
		// Only set encrypt and sign flags once.
		
		_fInitMenuOnce = TRUE;
		
		_bEncrypt = ByDefaultEncrypt(_memoryMgr);
		_bSign = ByDefaultSign(_memoryMgr);
	}

	// Now to the real menu business

	if (_context == EECONTEXT_SENDNOTEMESSAGE)
	{
		HMENU hmenu;
		MENUITEMINFO miiEncrypt;
		MENUITEMINFO miiSign;
		
		hr = pmecb->GetMenu(&hmenu);
		if (FAILED(hr))
			return;

		miiEncrypt.cbSize = sizeof(MENUITEMINFO);
		miiEncrypt.fMask = MIIM_STATE | MIIM_CHECKMARKS;
		GetMenuItemInfo(hmenu, _cmdidEncrypt, FALSE, &miiEncrypt);
		if (_bEncrypt)
		{
			miiEncrypt.fState = MFS_CHECKED;
			miiEncrypt.hbmpChecked = NULL;
			SendMessage(hwndToolbar, TB_CHECKBUTTON, 
				_cmdidEncrypt, MAKELONG(TRUE, 0));
		}
		else
		{
			miiEncrypt.fState = MFS_UNCHECKED;
			miiEncrypt.hbmpUnchecked = NULL;
			SendMessage(hwndToolbar, TB_CHECKBUTTON, 
				_cmdidEncrypt, MAKELONG(FALSE, 0));
		}
		SetMenuItemInfo(hmenu, _cmdidEncrypt, FALSE, &miiEncrypt);

		miiSign.cbSize = sizeof(MENUITEMINFO);
		miiSign.fMask = MIIM_STATE | MIIM_CHECKMARKS;
		GetMenuItemInfo(hmenu, _cmdidSign, FALSE, &miiSign);
		if (_bSign)
		{
			miiSign.fState = MFS_CHECKED;
			miiSign.hbmpChecked = NULL;
			SendMessage(hwndToolbar, TB_CHECKBUTTON, 
				_cmdidSign, MAKELONG(TRUE, 0));
		}
		else
		{
			miiSign.fState = MFS_UNCHECKED;
			miiSign.hbmpUnchecked = NULL;
			SendMessage(hwndToolbar, TB_CHECKBUTTON, 
				_cmdidSign, MAKELONG(FALSE, 0));
		}
		SetMenuItemInfo(hmenu, _cmdidSign, FALSE, &miiSign);
	}
}


STDMETHODIMP CExtImpl::DoCommand(IExchExtCallback* pmecb, UINT cmdid)
{
	HWND hwndMain;
	FindStruct fs;
	BOOL FYEO;

	if ((EECONTEXT_READNOTEMESSAGE != _context) &&
		(EECONTEXT_SENDNOTEMESSAGE != _context) &&
		(EECONTEXT_VIEWER != _context))
		return S_FALSE;

	if ((cmdid == _cmdidEncrypt) && (_context == EECONTEXT_SENDNOTEMESSAGE))
	{
		_bEncrypt = !_bEncrypt;
		InitMenu(pmecb);
		return S_OK;
	}

	if ((cmdid == _cmdidSign) && (_context == EECONTEXT_SENDNOTEMESSAGE))
	{
		_bSign = !_bSign;
		InitMenu(pmecb);
		return S_OK;
	}

	pmecb->GetWindow(&hwndMain);

	if ((_context == EECONTEXT_SENDNOTEMESSAGE) || 
		(_context == EECONTEXT_READNOTEMESSAGE))
		_hwndMessage = FindMessageWindow(pmecb, &fs);

	if (((cmdid == _cmdidEncryptNow) || (cmdid == _cmdidSignNow) || 
		(cmdid == _cmdidEncryptSign)) && 
		(_context == EECONTEXT_SENDNOTEMESSAGE))
	{
		BOOL bEncrypt;
		BOOL bSign;
		
		bEncrypt =	(cmdid == _cmdidEncryptNow) || 
					(cmdid == _cmdidEncryptSign);

		bSign = (cmdid == _cmdidSignNow) || 
				(cmdid == _cmdidEncryptSign); 

		if (_bHaveAttachments)
			if (!UIWarnUser(hwndMain, IDS_Q_ATTACHMENT, "Attachment"))
				return S_OK;

		if (_hwndMessage)
		{
			RECIPIENTDIALOGSTRUCT *prds;
			PGPKeySetRef newKeySet = NULL;
			PGPError err;

			prds = (RECIPIENTDIALOGSTRUCT *) 
					calloc(sizeof(RECIPIENTDIALOGSTRUCT), 1);

			err = PGPsdkLoadDefaultPrefs(_pgpContext);
			if (IsPGPError(err))
			{
				UIDisplayErrorCode(__FILE__, __LINE__, NULL, err);
				return S_FALSE;
			}

			err = PGPOpenDefaultKeyRings(_pgpContext, (PGPKeyRingOpenFlags)0, 
					&(prds->OriginalKeySetRef));

			if (IsPGPError(err))
			{
				UIDisplayErrorCode(__FILE__, __LINE__, NULL, err);
				return S_FALSE;
			}

			PGPNewKeySet(_pgpContext, &newKeySet);
			PGPAddKeys(prds->OriginalKeySetRef, newKeySet);
			PGPFreeKeySet(prds->OriginalKeySetRef);

			prds->OriginalKeySetRef = newKeySet;

			if (EncryptSignMessageWindow(hwndMain, pmecb, bEncrypt, bSign, 
				prds))
			{
				_bEncrypt = _bEncrypt && !bEncrypt;
				_bSign = _bSign && !bSign;
				InitMenu(pmecb);
			}

			FreeRecipients(prds);
	
			if (IsntNull(prds->OriginalKeySetRef))
			{
				PGPFreeKeySet(prds->OriginalKeySetRef);
				prds->OriginalKeySetRef = NULL;
			}

			free(prds);
		}

		return S_OK;
	}

	if ((cmdid == _cmdidDecrypt) && (_context == EECONTEXT_READNOTEMESSAGE))
	{
		if (_hwndMessage)
		{
			char *szInput;
			char *szOutput = NULL;
			long lLength;
			UINT nOutLength;
			BOOL bSelectedText = FALSE;
			CHARRANGE chRange = {0,0};
			PGPError nError = kPGPError_NoErr;
			char szName[256];
			char szFile[256];

			UIGetString(szName, sizeof(szName), IDS_LOGNAME);
			UIGetString(szFile, sizeof(szFile), IDS_DLL);

			// Determine if the user selected a particular piece of text
			SendMessage(_hwndMessage, EM_EXGETSEL, 
				(WPARAM)0, (LPARAM) &chRange);
			bSelectedText = chRange.cpMax - chRange.cpMin;
			
			szInput = GetRichEditContents(_hwndMessage, &lLength, 
												FALSE, bSelectedText);
			if (!szInput)
				return S_OK;

			chRange.cpMin = 0;
			chRange.cpMax = lLength;

			while (!isgraph(szInput[chRange.cpMax-3]))
				chRange.cpMax--;

			if (_fOutlook)
			{
				char *szCR;
				int nNumCR=0;
					
				szCR = strchr(szInput, '\r');
				while (szCR && (szCR < (szInput+lLength)))
				{
					nNumCR++;
					szCR = strchr(szCR+1, '\r');
				}

				chRange.cpMax -= nNumCR;
			}

			SendMessage(_hwndMessage, EM_EXSETSEL, (WPARAM)0, 
				(LPARAM) &chRange);

			nError = DecryptVerifyBuffer(UIGetInstance(), hwndMain, 
						_pgpContext, _tlsContext,
						szName, szFile, szInput, lLength,
						FALSE, (void **) &szOutput, &nOutLength, &FYEO);

			if (IsntPGPError(nError))
			{
				if ((nOutLength > 0) && (szOutput != NULL))
				{
					if((FYEO)||(GetSecureViewerPref(_pgpContext)))
					{
						TempestViewer((void *)_pgpContext,hwndMain,
							szOutput,nOutLength,FYEO);
					}
					else
					{
						if ((nOutLength != (UINT) lLength) &&
							(nOutLength != (UINT) (lLength+1)))
						{
							SetRichEditContents(_hwndMessage, szOutput, 
								FALSE, TRUE);
						}
					}

					PGPFreeData(szOutput);
				}
				else
					UIDisplayStringID(_hwndMessage, IDS_E_NOPGP);
			}
			
			chRange.cpMin = 0;
			chRange.cpMax = 0;
			SendMessage(_hwndMessage, EM_EXSETSEL, 
				(WPARAM)0, (LPARAM) &chRange);
			HeapFree(GetProcessHeap (), 0, szInput);
		}

		return S_OK;
	}

	if (cmdid == _cmdidPgpKeys)
	{
		char szPath[MAX_PATH];
		char szPGPkeys[MAX_PATH];

		PGPclGetPGPPath(szPath, MAX_PATH-1);
		UIGetString(szPGPkeys, sizeof(szPGPkeys), IDS_PGPKEYSEXE);
		strcat(szPath, szPGPkeys);

		// run it...
		WinExec(szPath, SW_SHOW);
		return S_OK;
	}

	if (cmdid == _cmdidPrefs)
	{
		PGPclPreferences(_pgpContext, hwndMain, PGPCL_EMAILPREFS, NULL);
		return S_OK;
	}

	if (cmdid == _cmdidHelp)
	{
		CHAR szHelpFile[MAX_PATH] = {0x00};
		char szHelpName[256];

		PGPclGetPGPPath(szHelpFile, MAX_PATH-1);
		UIGetString(szHelpName, sizeof(szHelpName), IDS_PGPHELP);
		strcat(szHelpFile, szHelpName);
		
		WinHelp(hwndMain, szHelpFile, HELP_FINDER, 0);
		return S_OK;
	}

	if (cmdid == _cmdidAbout)
	{
		PGPclHelpAbout(_pgpContext, hwndMain, NULL, NULL, NULL);
		return S_OK;
	}

	return S_FALSE;
}


BOOL CExtImpl::EncryptSignMessageWindow(HWND hwndMain,
										IExchExtCallback *pmecb,
										BOOL bEncrypt,
										BOOL bSign,
										RECIPIENTDIALOGSTRUCT *prds)
{
	char *szInput;
	char *szOutput = NULL;
	long lLength;
	UINT nOutLength;
	BOOL bSelectedText = FALSE;
	BOOL bReturn = FALSE;
	CHARRANGE chRange = {0,0};
	PGPOptionListRef signOptions = NULL;
	char szName[256];
	char szFile[256];
	PGPError nError = kPGPError_NoErr;

//	prds = (RECIPIENTDIALOGSTRUCT *) 
//			calloc(sizeof(RECIPIENTDIALOGSTRUCT), 1);

	if ((prds == NULL) && bEncrypt)
		return FALSE;

	UIGetString(szName, sizeof(szName), IDS_LOGNAME);
	UIGetString(szFile, sizeof(szFile), IDS_DLL);

	if (bEncrypt)
		nError = GetRecipients(pmecb, _pgpContext, _tlsContext, prds);
			
	if (IsPGPError(nError))
	{
		if (nError != kPGPError_UserAbort)
			UIDisplayErrorCode(__FILE__, __LINE__, NULL, nError);
		return FALSE;
	}

	// Determine if the user selected a particular piece of text
	SendMessage(_hwndMessage, EM_EXGETSEL, 
		(WPARAM)0, (LPARAM) &chRange);

	bSelectedText = chRange.cpMax - chRange.cpMin;
			
	szInput = GetRichEditContents(_hwndMessage, &lLength, 
									FALSE, bSelectedText);
	if (!szInput)
		return FALSE;

	lLength = strlen(szInput);
	nError = EncryptSignBuffer(UIGetInstance(), hwndMain, _pgpContext, 
				_tlsContext, szName, szFile, szInput, 
				lLength, prds, NULL, &signOptions, (void **) &szOutput, 
				&nOutLength, bEncrypt, bSign, FALSE);

	if (IsntPGPError(nError))
	{
		SetRichEditContents(_hwndMessage, szOutput, FALSE, 
			bSelectedText);
		PGPFreeData(szOutput);
		bReturn = TRUE;
	}

	if (signOptions != NULL)
	{
		PGPFreeOptionList(signOptions);
		signOptions = NULL;
	}

	memset(szInput, 0, lLength);
	HeapFree(GetProcessHeap (), 0, szInput);

	return bReturn;
}


HWND FindMessageWindow(IExchExtCallback* pmecb, FindStruct *fs)
{
	HWND hwndMain;
	HWND hwndSearch = NULL;
	HWND hwndFound = NULL;
	HWND hwndLast = NULL;

	fs->hwndFound = NULL;
	fs->yMax = 0;
	fs->bInternetExplorer = FALSE;
	fs->bMicrosoftWord = FALSE;

	pmecb->GetWindow(&hwndMain);
	EnumChildWindows(hwndMain, (WNDENUMPROC) ReportChildren, 
					(LPARAM) fs);

	hwndFound = fs->hwndFound;
	return hwndFound;
}


BOOL CALLBACK ReportChildren(HWND hwnd, LPARAM lParam)
{
	char szClassName[200];
	char szOldEditClass[256];
	char szNewEditClass[256];
	char szIEClass[256];
	char szWordClass[256];
	FindStruct *pfsRichEdit;
	RECT rc;

	UIGetString(szOldEditClass, sizeof(szOldEditClass), IDS_OLDEDITCTRLCLASS);
	UIGetString(szNewEditClass, sizeof(szNewEditClass), IDS_NEWEDITCTRLCLASS);
	UIGetString(szIEClass, sizeof(szIEClass), IDS_IE40CLASS);
	UIGetString(szWordClass, sizeof(szWordClass), IDS_WORDCLASS);

	pfsRichEdit = (FindStruct *) lParam;
	GetClassName(hwnd, szClassName, 199);

	if (!strcmp(szClassName, szOldEditClass) || 
		!strcmp(szClassName, szNewEditClass))
	{
		GetWindowRect(hwnd, &rc);
		if (rc.bottom > pfsRichEdit->yMax)
		{
			pfsRichEdit->yMax = rc.bottom;
			pfsRichEdit->hwndFound = hwnd;
		}
	}

	if (!strcmp(szClassName, szIEClass))
		pfsRichEdit->bInternetExplorer = TRUE;

	if (!strcmp(szClassName, szWordClass))
		pfsRichEdit->bMicrosoftWord = TRUE;

	return TRUE;
}


/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/