cpgpexch.cpp

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

			}

			pmsg->Release();
			if (bError)
				return S_FALSE;
		}
	}

	// Determine if this is the Corporate version or Internet version

	_fCorporate = FALSE;
	peecb->GetSession(NULL, &pAddrBook);
	if (pAddrBook != NULL)
	{
		ULONG ulRow;
		ULONG ulIndex;
		LPSRowSet pSearch = NULL;

		pAddrBook->GetSearchPath(0, &pSearch);
		
		for (ulRow=0; ulRow<pSearch->cRows; ulRow++)
		{
			for(ulIndex=0; ulIndex<pSearch->aRow[ulRow].cValues; ulIndex++)
			{
				switch (pSearch->aRow[ulRow].lpProps[ulIndex].ulPropTag)
				{
				case PR_DISPLAY_TYPE:
					if (pSearch->aRow[ulRow].lpProps[ulIndex].Value.l == 
						DT_GLOBAL)
						_fCorporate = TRUE;
					break;
				}

				if (_fCorporate)
					break;
			}

			if (_fCorporate)
				break;
		}

		FreeProws(pSearch);
		pSearch = NULL;

		pAddrBook->Release();
	}

	if (!_fLoaded)
	{
		// Register the "copy done" and "paste done" messages

		_nCopyDoneMsg = RegisterWindowMessage("PGPexch Copy Done");
		_nPasteDoneMsg = RegisterWindowMessage("PGPexch Paste Done");

		// Create a hidden window to catch messages

		_hwndHidden = CreateHiddenWindow();

		_memoryMgr = PGPPeekContextMemoryMgr(_pgpContext);
		PGPNewTLSContext(_pgpContext, &_tlsContext);

		// Ensure that this is the right version on first load
		
		if ((CURRENT_PRODUCT_CODE != 
			(ulProductVer & EECBGV_VERSION_PRODUCT_MASK))   
			||
			(EECBGV_BUILDVERSION_MAJOR != 
			(ulBuildVer & EECBGV_BUILDVERSION_MAJOR_MASK)))
		{
			// The first time, explain why we aren't loading.
			// Subsequently, remain silent.
			
			if (!IsWarningOff(ulMajVer, ulMinVer, ulBuildMinVer))
			{
				TurnOffWarning(ulMajVer, ulMinVer, ulBuildMinVer);
				UIDisplayStringID(hWnd, IDS_E_INCOMPATIBLE_VERSION);
			}
			SetNoLoad();
			return S_FALSE;
		}

		if ((LAST_MAJVER_SUPPORTED < (ulMajVer)) ||
			(LAST_MINVER_SUPPORTED < (ulMinVer)) ||
			(LAST_BUILD_SUPPORTED  < (ulBuildMinVer)))
		{
			// Warn the user of a newer version of Exchange.
			// If the user loads the plug-in anyway, don't warn anymore,
			// otherwise, warn every time.
			if (!IsWarningOff(ulMajVer, ulMinVer, ulBuildMinVer))
			{
				fMinorBuildOk =	
					(UIAskYesNoStringID(hWnd, IDS_Q_LATER_BUILD) == IDYES);
				if (fMinorBuildOk)
					TurnOffWarning(ulMajVer, ulMinVer, ulBuildMinVer);
			}
			else
				fMinorBuildOk = IsNewerOK(ulMajVer, ulMinVer, ulBuildMinVer);
			
			if (!fMinorBuildOk)
			{
				SetNoLoad();
				return S_FALSE;
			}
			else
				SetNewerOK(ulMajVer, ulMinVer, ulBuildMinVer, TRUE);
		}

		// Is this an Exchange Server user? If so, check for, and if
		// necessary add, the Exchanger Server address as a User ID

		if (PGPclIsExchangeServerUser())
		{
			//check if the user has desktop license on the product
			//this plugin requires desktop license when mapi is used
			//with exchange on the server side
			if(FALSE == PGPlnDesktop())
			{
				//show the user that she would need the desktop license
				PGPclNoLicense(hWnd,kPGPclPGPDesktop);
				SetNoLoad();
				return S_FALSE;
			}

			CheckExchangeServerID(hWnd);
		}
	}

    switch (eecontext)
    {
		case EECONTEXT_SENDPOSTMESSAGE:
		case EECONTEXT_SENDNOTEMESSAGE:
		case EECONTEXT_READNOTEMESSAGE:
		case EECONTEXT_READPOSTMESSAGE:
			hrRet = S_OK;
			break;

		case EECONTEXT_VIEWER:
			hrRet = S_OK;
			break;

		case EECONTEXT_READREPORTMESSAGE:
		case EECONTEXT_SENDRESENDMESSAGE:
		default:
			hrRet = S_FALSE;
			break;
    }
    
	//if pgp is going to be running in this context
	if(S_OK == hrRet)
	{
		//register ourselves as an extension that will be throwing modeless
		//windows once in a while (during encryption and decryption we show
		//status windows)
		pgpAssert(NULL == m_pemOurMdlessCallBack);
		m_pemOurMdlessCallBack = new CPGPExtModeless;
		if(NULL != m_pemOurMdlessCallBack)
		{
			HRESULT hrResult = peecb->RegisterModeless(m_pemOurMdlessCallBack, 
						&m_pExtMdlessCallBack);
			pgpAssert(SUCCEEDED(hrResult) && (NULL != m_pExtMdlessCallBack));
		}
	}

	// Initialize encrypt and sign settings

	_bEncrypt = ByDefaultEncrypt(_memoryMgr);
	_bSign = ByDefaultSign(_memoryMgr);

    return hrRet;
}


BOOL IsExchExtWithinOutlook(IExchExtCallback* peecb)
{
	IOutlookGetObjectForExchExtCallback* po = NULL;

	HRESULT hr = peecb->
					QueryInterface(IID_IOutlookGetObjectForExchExtCallback, 
						(void**)&po);
	if (po)
		po->Release();

	return (SUCCEEDED(hr));
}


void TurnOffWarning(ULONG ulMajVer, ULONG ulMinVer, ULONG ulBuildMinVer)
{
	HKEY hkey;
	char szRegKey[255];
	char szVersion[255];
	DWORD dwDummy;
	DWORD dwValue;

	UIGetString(szRegKey, 254, IDS_WARNING_REGKEY);
	wsprintf(szVersion, "Maj %ld Min %ld Build %ld", ulMajVer, ulMinVer, 
		ulBuildMinVer);
	strcat(szRegKey, szVersion);

	RegCreateKeyEx(HKEY_CURRENT_USER, szRegKey, 0, NULL, 
		REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDummy);

	dwValue = 1;
	RegSetValueEx(hkey, "WarningOff", 0, REG_DWORD, (BYTE *) &dwValue, 
		sizeof(DWORD));
	RegCloseKey(hkey);
	return;
}


void SetNewerOK(ULONG ulMajVer, 
				ULONG ulMinVer, 
				ULONG ulBuildMinVer, 
				BOOL bOK)
{
	HKEY hkey;
	char szRegKey[255];
	char szVersion[255];
	DWORD dwDummy;
	DWORD dwValue;

	UIGetString(szRegKey, 254, IDS_WARNING_REGKEY);
	wsprintf(szVersion, "Maj %ld Min %ld Build %ld", ulMajVer, ulMinVer, 
		ulBuildMinVer);
	strcat(szRegKey, szVersion);

	RegCreateKeyEx(HKEY_CURRENT_USER, szRegKey, 0, NULL, 
		REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDummy);

	dwValue = bOK;
	RegSetValueEx(hkey, "NewerOK", 0, REG_DWORD, (BYTE *) &dwValue, 
		sizeof(DWORD));
	RegCloseKey(hkey);
	return;
}


BOOL IsWarningOff(ULONG ulMajVer, ULONG ulMinVer, ULONG ulBuildMinVer)
{
	HKEY hkey;
	char szRegKey[255];
	char szVersion[255];
	DWORD dwDummy;
	DWORD dwValue;
	DWORD dwType;
	DWORD dwSize=4;

	UIGetString(szRegKey, 254, IDS_WARNING_REGKEY);
	wsprintf(szVersion, "Maj %ld Min %ld Build %ld", ulMajVer, ulMinVer, 
		ulBuildMinVer);
	strcat(szRegKey, szVersion);

	RegCreateKeyEx(HKEY_CURRENT_USER, szRegKey, 0, NULL, 
		REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDummy);

	if (RegQueryValueEx(hkey, "WarningOff", 0, &dwType, (BYTE *) &dwValue, 
		&dwSize) != ERROR_SUCCESS)
	{
		dwValue = 0;
		RegSetValueEx(hkey, "WarningOff", 0, REG_DWORD, (BYTE *) &dwValue, 
			sizeof(DWORD));
	}

	RegCloseKey(hkey);
	return dwValue;
}


BOOL IsNewerOK(ULONG ulMajVer, ULONG ulMinVer, ULONG ulBuildMinVer)
{
	HKEY hkey;
	char szRegKey[255];
	char szVersion[255];
	DWORD dwDummy;
	DWORD dwValue;
	DWORD dwType;
	DWORD dwSize=4;

	UIGetString(szRegKey, 254, IDS_WARNING_REGKEY);
	wsprintf(szVersion, "Maj %ld Min %ld Build %ld", ulMajVer, ulMinVer, 
		ulBuildMinVer);
	strcat(szRegKey, szVersion);

	RegCreateKeyEx(HKEY_CURRENT_USER, szRegKey, 0, NULL, 
		REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDummy);

	if (RegQueryValueEx(hkey, "NewerOK", 0, &dwType, (BYTE *) &dwValue, 
		&dwSize) != ERROR_SUCCESS)
	{
		dwValue = 0;
		RegSetValueEx(hkey, "NewerOK", 0, REG_DWORD, (BYTE *) &dwValue, 
			sizeof(DWORD));
	}

	RegCloseKey(hkey);
	return dwValue;
}


BOOL DoIExist(BOOL bOutlook, HANDLE *phSem)
{
    HANDLE hSem;

    // Create or open a named semaphore

	if (bOutlook)
	    hSem = CreateSemaphore (NULL, 0, 1, "pgpOutlookInstSem");
	else
		hSem = CreateSemaphore (NULL, 0, 1, "pgpExchangeInstSem");

    // Close handle and return TRUE if existing semaphore was opened.
    if ((hSem != NULL) && (GetLastError() == ERROR_ALREADY_EXISTS)) 
	{
        CloseHandle(hSem);
        return TRUE;
	}
	else if (phSem != NULL)
		*phSem = hSem;

	return FALSE;
}


void SetNoLoad(void)
{
    HANDLE hSem;

    // Create or open a named semaphore. 
    hSem = CreateSemaphore (NULL, 0, 1, "pgpExchLoadSem");

    if ((hSem != NULL) && (GetLastError() == ERROR_ALREADY_EXISTS)) 
        CloseHandle(hSem);

	return;
}


BOOL ShouldILoad(void)
{
    HANDLE hSem;
	BOOL bShouldLoad = TRUE;

    // Create or open a named semaphore. 
    hSem = CreateSemaphore (NULL, 0, 1, "pgpExchLoadSem");

    if (hSem != NULL)
	{
		if (GetLastError() == ERROR_ALREADY_EXISTS) 
			bShouldLoad = FALSE;
		else
			bShouldLoad = TRUE;

		CloseHandle(hSem);
	}

	return bShouldLoad;
}


void CheckExchangeServerID(HWND hWnd)
{
	PGPKeyDBRef		keyDB = NULL;
	PGPKeyDBObjRef	defaultKey = NULL;
	PGPKeyDBObjRef	userID = NULL;
	PGPKeyIterRef	keyIter = NULL;
	char			szExName[kPGPMaxUserIDSize];
	char			szExAddress[kPGPMaxUserIDSize];
	char			szUserID[kPGPMaxUserIDSize];
	PGPSize			idSize;
	PGPError		err;
	
	// Check the user's default key to see if it contains
	// the Exchange Server address as a user ID. If not,
	// prompt the user to add it
	
	err = PGPclGetExchangeServerAddress(hWnd, TRUE, szExName, sizeof(szExName), 
			szExAddress, sizeof(szExAddress));
	
	if (IsntPGPError(err))
		err = PGPclOpenDefaultKeyrings(_pgpContext, 
				kPGPOpenKeyDBFileOptions_None, &keyDB);
	
	if (IsntPGPError(err))
		err = PGPclGetDefaultPrivateKey(keyDB, &defaultKey);
	
	if (IsntPGPError(err))
		err = PGPNewKeyIterFromKeyDB(keyDB, &keyIter);
	
	if (IsntPGPError(err))
	{
		PGPKeyIterSeek(keyIter, defaultKey);
		err = PGPKeyIterRewind(keyIter, kPGPKeyDBObjType_UserID);
	}
	
	while (IsntPGPError(err))
	{
		err = PGPKeyIterNextKeyDBObj(keyIter, kPGPKeyDBObjType_UserID, 
				&userID);
		
		if (IsntPGPError(err))
			err = PGPclGetUserIDName (userID, 
					szUserID, sizeof(szUserID), &idSize);
		
		if (IsntPGPError(err))
		{
			szUserID[idSize] = 0;
			if (strstr(szUserID, szExAddress))
				break;
		}
	}
	
	if (err == kPGPError_EndOfIteration)
	{
		err = kPGPError_NoErr;
		if (UIWarnYesNo(hWnd, IDS_Q_ADDEXCHID, kPGPPrefWin32OutlookExchangeID, FALSE))
			AddUserID(hWnd, keyDB, defaultKey, szExName, szExAddress);
	}
	
	if (keyIter != NULL)
		PGPFreeKeyIter(keyIter);
	
	if (keyDB != NULL)
		PGPFreeKeyDB(keyDB);

	return;
}


void AddUserID(HWND hWnd, PGPKeyDBRef keyDB, PGPKeyDBObjRef key,
			   char *szName, char *szAddress)
{
	PGPPrefRef		prefref	= kInvalidPGPPrefRef;
	PGPBoolean		bSync = FALSE;
	PGPByte *		passkey = NULL;
	PGPSize			passkeySize = 0;
	PGPKeySetRef	keyset = NULL;
	char			szMsg[256];
	char			szUserID[kPGPMaxUserIDSize];
	PGPError		err;

	UIGetString(szMsg, sizeof(szMsg), IDS_ENTER_PHRASE);
	wsprintf(szUserID, "%s <%s>", szName, szAddress);

	err = PGPclGetKeyPhrase(_pgpContext, _tlsContext, hWnd, szMsg, keyDB, key,
			NULL, &passkey, (INT *) &passkeySize);

	if (IsntPGPError(PGPclErrorBox(hWnd, err)))
	{
		if (passkey != NULL)
			err = PGPAddUserID(key, szUserID,
					PGPOPasskeyBuffer(_pgpContext, passkey, passkeySize),
					PGPOLastOption(_pgpContext));
		else
			err = PGPAddUserID(key, szUserID,
					PGPOLastOption(_pgpContext));
	}

	if (IsntPGPError(PGPclErrorBox(hWnd, err)))
		err = PGPclPeekClientLibPrefRefs(&prefref, NULL);

	if (IsntPGPError(err))
		err = PGPGetPrefBoolean(prefref, kPGPPrefKeyServerSyncOnAdd, &bSync);

	if (IsntPGPError(err) && bSync)
	{
		err = PGPNewKeySet(keyDB, &keyset);
		
		if (IsntPGPError(err))
			PGPAddKey(key, keyset);

		if (IsntPGPError(err))
			err = PGPclSendKeysToServer(_pgpContext, _tlsContext, hWnd,
					kPGPclDefaultServer, NULL, keyDB, keyset);

		if (err != kPGPError_ServerKeyAlreadyExists)
			PGPclErrorBox(hWnd, err);
	}

	if (keyset != NULL)
		PGPFreeKeySet(keyset);

	if (passkey != NULL)
		PGPclFreePasskey(passkey, passkeySize);

	return;
}


/*__Editor_settings____

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