pgpexchangeserver.c

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

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: pgpExchangeServer.c,v 1.13 2002/11/22 03:17:19 pbj Exp $
____________________________________________________________________________*/
#include <mapix.h>
#include <mapiutil.h>

#define USES_IID_IMailUser

#include <objbase.h>
#include <initguid.h>
#include <mapiguid.h>

#include "pgpMem.h"
#include "pgpClientLib.h"

typedef HRESULT (STDAPICALLTYPE * HrQueryAllRowsProc)(LPMAPITABLE, LPSPropTagArray,
												LPSRestriction, 
												LPSSortOrderSet,
												LONG, LPSRowSet *);
typedef void (STDAPICALLTYPE * FreeProwsProc)(LPSRowSet);

static LPMAPIINITIALIZE pMAPIInitialize;
static LPMAPIADMINPROFILES pMAPIAdminProfiles;
static LPMAPIUNINITIALIZE pMAPIUninitialize;
static LPMAPIFREEBUFFER pMAPIFreeBuffer;
static LPMAPILOGONEX pMAPILogonEx;
static HrQueryAllRowsProc pHrQueryAllRows;
static FreeProwsProc pFreeProws;
static HANDLE hMAPI32 = NULL;

static BOOL sIsDefaultMailClient(void);
static BOOL sLoadMAPI32(void);
static void sUnloadMAPI32(void);

#if 0
#define SHOW_HR_CODE(func)	\
{	\
	char szDebug[256];	\
\
	wsprintf(szDebug, "%s failed with code %X", func, hr);	\
	MessageBox(NULL, szDebug, "DEBUG", MB_OK);	\
}
#else
#define SHOW_HR_CODE(func)
#endif

PGPBoolean PGPclExport
PGPclIsExchangeServerUser (void)
{
	LPPROFADMIN pProfAdmin = NULL;
	LPMAPITABLE pTable = NULL;
	LPSERVICEADMIN pMsgService = NULL;
	LPSRowSet pRowSet = NULL;
	SRestriction sRes;
	SPropValue sPropVal;
	char *szProfile = NULL;
	PGPBoolean bIsUser = FALSE;
	HRESULT hr;
	MAPIINIT_0 mapiInit;

	if (!sIsDefaultMailClient())
		return FALSE;

	if (!sLoadMAPI32())
		return FALSE;

	mapiInit.ulVersion = MAPI_INIT_VERSION;
	mapiInit.ulFlags = 0;
	hr = pMAPIInitialize(&mapiInit);
	if (hr != S_OK)
	{
		SHOW_HR_CODE("MAPIInitialize");
		sUnloadMAPI32();
		return FALSE;
	}

	hr = pMAPIAdminProfiles(0, &pProfAdmin);

	if (hr == S_OK)
		pProfAdmin->lpVtbl->GetProfileTable(pProfAdmin, 0, &pTable);
	else
		SHOW_HR_CODE("pMAPIAdminProfiles");
	
	sPropVal.ulPropTag = PR_DEFAULT_PROFILE;
	sPropVal.Value.b = TRUE;
	sRes.rt = RES_PROPERTY;
	sRes.res.resProperty.relop = RELOP_EQ;
	sRes.res.resProperty.ulPropTag = PR_DEFAULT_PROFILE;
	sRes.res.resProperty.lpProp = &sPropVal;

	if (hr == S_OK)
		hr = pTable->lpVtbl->Restrict(pTable, &sRes, TBL_BATCH);
	else
		SHOW_HR_CODE("GetProfileTable (1)");

	if (hr == S_OK)
		hr = pTable->lpVtbl->FindRow(pTable, &sRes, BOOKMARK_BEGINNING, 0);
	else
		SHOW_HR_CODE("Restrict (1)");

	if (hr == S_OK)
		hr = pTable->lpVtbl->QueryRows(pTable, 1, 0, &pRowSet);
	else
		SHOW_HR_CODE("FindRow (1)");

	if (hr == S_OK)
	{
		szProfile = pRowSet->aRow[0].lpProps[0].Value.lpszA;

		hr = pProfAdmin->lpVtbl->AdminServices(pProfAdmin, szProfile, NULL, 0, 
				0, &pMsgService);
	}
	else
		SHOW_HR_CODE("QueryRows");

	if (IsntNull(pTable))
	{
		if (IsntNull(pRowSet))
			pFreeProws(pRowSet);

		pTable->lpVtbl->Release(pTable);
		pTable = NULL;
	}
	
	if (hr == S_OK)
		hr = pMsgService->lpVtbl->GetMsgServiceTable(pMsgService, 0, &pTable);
	else
		SHOW_HR_CODE("AdminServices");

	sPropVal.ulPropTag = PR_SERVICE_NAME;
	sPropVal.Value.lpszA = "MSEMS";
	sRes.rt = RES_PROPERTY;
	sRes.res.resProperty.relop = RELOP_EQ;
	sRes.res.resProperty.ulPropTag = PR_SERVICE_NAME;
	sRes.res.resProperty.lpProp = &sPropVal;

	if (hr == S_OK)
		hr = pTable->lpVtbl->Restrict(pTable, &sRes, TBL_BATCH);
	else
		SHOW_HR_CODE("GetMsgServiceTable");

	if (hr == S_OK)
		hr = pTable->lpVtbl->FindRow(pTable, &sRes, BOOKMARK_BEGINNING, 0);
	else
		SHOW_HR_CODE("Restrict (2)");

	if (hr == S_OK)
		bIsUser = TRUE;
	else
		SHOW_HR_CODE("FindRow (2)");

	if (IsntNull(pTable))
		pTable->lpVtbl->Release(pTable);

	if (IsntNull(pMsgService))
		pMsgService->lpVtbl->Release(pMsgService);

	if (IsntNull(pProfAdmin))
		pProfAdmin->lpVtbl->Release(pProfAdmin);

	pMAPIUninitialize();
	sUnloadMAPI32();
	return bIsUser;
}


PGPError PGPclExport
PGPclGetExchangeServerAddress(HWND hwnd, PGPBoolean defaultLogon,
			char *nameString, PGPSize nameStringLength, char *addressString, 
			PGPSize addressStringLength)
{
	PGPError err = kPGPError_NoErr;
	HRESULT hr;
	MAPIINIT_0 mapiInit;
	LPMAPISESSION pSession = NULL;
	ULONG ulEntryBytes = 0;
	LPENTRYID pEntryID = NULL;
	ULONG ulType;
	FLAGS fFlags;
	LPMAILUSER pUser = NULL;
	LPMAPITABLE pStatus = NULL;
	SizedSPropTagArray(3, propTags) = 
	{
		3, {PR_ADDRTYPE, PR_DISPLAY_NAME, PR_EMAIL_ADDRESS}
	};
	enum {ulAddrType, ulDisplayName, ulEmailAddress, ulNumValIDs};
	SizedSPropTagArray(2, statusTags) = 
	{
		2, {PR_RESOURCE_TYPE, PR_ENTRYID}
	};
	enum {ulResourceType, ulEntryID};
	SPropValue *pVal = NULL;
	SRowSet *pRowSet = NULL;
	ULONG ulNumVals;

	if (IsntNull(nameString) && !nameStringLength)
		return kPGPError_BadParams;

	if (IsntNull(addressString) && !addressStringLength)
		return kPGPError_BadParams;

	if (IsNull(nameString) && IsNull(addressString))
		return kPGPError_NoErr;

	if (IsntNull(nameString))
		pgpClearMemory(nameString, nameStringLength);
	if (IsntNull(addressString))
		pgpClearMemory(addressString, addressStringLength);

	if (!sLoadMAPI32())
		return kPGPError_FeatureNotAvailable;

	mapiInit.ulVersion = MAPI_INIT_VERSION;
	mapiInit.ulFlags = 0;
	hr = pMAPIInitialize(&mapiInit);
	if (hr != S_OK)
	{
		sUnloadMAPI32();
		return kPGPError_FeatureNotAvailable;
	}

	fFlags = MAPI_EXTENDED /* | MAPI_ALLOW_OTHERS */;

	if (defaultLogon)
		fFlags |= MAPI_USE_DEFAULT;
	else
		fFlags |= MAPI_LOGON_UI | MAPI_EXPLICIT_PROFILE;

	if (hr == S_OK)
		hr = pMAPILogonEx((ULONG) hwnd, NULL, NULL, fFlags, &pSession);

	if (hr == S_OK)
		hr = pSession->lpVtbl->GetStatusTable(pSession, 0, &pStatus);
	else
		SHOW_HR_CODE("MAPILogonEx");

	if (hr == S_OK)
		hr = pHrQueryAllRows(pStatus, (SPropTagArray *) &statusTags, NULL, 
				NULL, 0, &pRowSet);
	else
		SHOW_HR_CODE("GetStatusTable");

	if (hr == S_OK)
	{
		UINT nIndex;
		BOOL bOffline = FALSE;
		LPMAPISTATUS pStatusObj = NULL;
		SizedSPropTagArray(1, statTags) = 
		{
			1, {PR_STATUS_CODE}
		};

		for (nIndex=0; nIndex<pRowSet->cRows; nIndex++)
		{
			if (pRowSet->aRow[nIndex].lpProps[ulResourceType].Value.l == 
				MAPI_STORE_PROVIDER)
			{
				ulEntryBytes = pRowSet->aRow[nIndex].lpProps[ulEntryID].Value.bin.cb;
				pEntryID = (LPENTRYID) 
							pRowSet->aRow[nIndex].lpProps[ulEntryID].Value.bin.lpb;

				hr = pSession->lpVtbl->OpenEntry(pSession, ulEntryBytes, 
						pEntryID, &IID_IUnknown, 0, &ulType, 
						(IUnknown **) &pStatusObj);

				if (hr == S_OK)
					hr = pStatusObj->lpVtbl->GetProps(pStatusObj, 
							(SPropTagArray *) &statTags, 0, &ulNumVals, &pVal);

				if (hr == S_OK)
				{
					if (pVal[0].Value.l == STATUS_OFFLINE)
						bOffline = TRUE;

					pMAPIFreeBuffer(pVal);
					pVal = NULL;
				}

				if (pStatusObj != NULL)
				{
					pStatusObj->lpVtbl->Release(pStatusObj);
					pStatusObj = NULL;
				}
			}

			if (bOffline)
				break;
		}

		pEntryID = NULL;
		ulEntryBytes = 0;
		if (bOffline)
			hr = MAPI_E_USER_CANCEL;
	}
	else
		SHOW_HR_CODE("HrQueryAllRows");

	if (hr == S_OK)
		hr = pSession->lpVtbl->QueryIdentity(pSession, &ulEntryBytes, 
				&pEntryID);
	else
		SHOW_HR_CODE("OpenEntry");

	if (hr == S_OK)
	{
		hr = pSession->lpVtbl->OpenEntry(pSession, ulEntryBytes, pEntryID, 
				&IID_IMailUser, 0, &ulType, (IUnknown **) &pUser);

///>>> pbj & wjb 11sep01
		if ((hr != S_OK) || (pUser == NULL))
			hr = pSession->lpVtbl->OpenEntry(pSession, ulEntryBytes, pEntryID, 
					&IID_IUnknown, 0, &ulType, (IUnknown **) &pUser);
///<<<
	}
	else
		SHOW_HR_CODE("QueryIdentity");

///	if ((hr != S_OK) || (pUser == NULL))
///		hr = pSession->lpVtbl->OpenEntry(pSession, ulEntryBytes, pEntryID, 
///				&IID_IUnknown, 0, &ulType, (IUnknown **) &pUser);

	if (hr == S_OK)
		hr = pUser->lpVtbl->GetProps(pUser, (SPropTagArray *) &propTags, 0, 
				&ulNumVals, &pVal);
	else
		SHOW_HR_CODE("OpenEntry (2)");

	if (hr == S_OK)
	{
		if (ulNumVals < ulNumValIDs)
			hr = MAPI_E_INVALID_OBJECT;
	}
	else
		SHOW_HR_CODE("GetProps");

	if (hr == S_OK)
	{
		if (pVal[ulAddrType].Value.lpszA == NULL)
			hr = MAPI_E_INVALID_OBJECT;
		else if ((pVal[ulAddrType].ulPropTag & 0xFF) == PT_ERROR)
			hr = MAPI_E_INVALID_OBJECT;
		else if ((*(pVal[ulAddrType].Value.lpszA) < 32) ||
			(*(pVal[ulAddrType].Value.lpszA) > 127))
			hr = MAPI_E_INVALID_OBJECT;
	}
	else
		SHOW_HR_CODE("ulNumVals < ulNumValIDs");

	if (hr == S_OK)
	{
		if (pVal[ulDisplayName].Value.lpszA == NULL)
			hr = MAPI_E_INVALID_OBJECT;
		else if ((pVal[ulDisplayName].ulPropTag & 0xFF) == PT_ERROR)
			hr = MAPI_E_INVALID_OBJECT;
		else if ((*(pVal[ulDisplayName].Value.lpszA) < 32) ||
			(*(pVal[ulDisplayName].Value.lpszA) > 127))
			hr = MAPI_E_INVALID_OBJECT;
	}
	else
		SHOW_HR_CODE("ulAddrType");

	if (hr == S_OK)
	{
		if (pVal[ulEmailAddress].Value.lpszA == NULL)
			hr = MAPI_E_INVALID_OBJECT;
		else if ((pVal[ulEmailAddress].ulPropTag & 0xFF) == PT_ERROR)
			hr = MAPI_E_INVALID_OBJECT;
		else if ((*(pVal[ulEmailAddress].Value.lpszA) < 32) ||
			(*(pVal[ulEmailAddress].Value.lpszA) > 127))
			hr = MAPI_E_INVALID_OBJECT;
	}
	else
		SHOW_HR_CODE("ulDisplayName");

	if (hr == S_OK)
	{
		if (!strcmp(pVal[ulAddrType].Value.lpszA, "EX"))
		{
			if (IsntNull(nameString))
			{
				if (nameStringLength > strlen(pVal[ulDisplayName].Value.lpszA))
					nameStringLength = strlen(pVal[ulDisplayName].Value.lpszA) + 1;
				strncpy(nameString, pVal[ulDisplayName].Value.lpszA,
					nameStringLength - 1);
				nameString[nameStringLength - 1] = 0;
			}
			
			if (IsntNull(addressString))
			{
				if (addressStringLength > strlen(pVal[ulEmailAddress].Value.lpszA))
					addressStringLength = strlen(pVal[ulEmailAddress].Value.lpszA) + 1;
				strncpy(addressString, pVal[ulEmailAddress].Value.lpszA,
					addressStringLength - 1);
				addressString[addressStringLength - 1] = 0;
			}
		}
		else
			err = kPGPError_FeatureNotAvailable;
	}
	else
		SHOW_HR_CODE("ulEmailAddress");

	if (IsntNull(pVal))
		pMAPIFreeBuffer(pVal);

	if (IsntNull(pUser))
		pUser->lpVtbl->Release(pUser);

	if (IsntNull(pEntryID))
		pMAPIFreeBuffer(pEntryID);

	if (IsntNull(pRowSet))
		pFreeProws(pRowSet);

	if (IsntNull(pStatus))
		pStatus->lpVtbl->Release(pStatus);

	if (IsntNull(pSession))
	{
		pSession->lpVtbl->Logoff(pSession, 0, 0, 0);
		pSession->lpVtbl->Release(pSession);
	}

	pMAPIUninitialize();
	sUnloadMAPI32();

	switch (hr)
	{
	case S_OK:
		break;

	case MAPI_E_USER_CANCEL:
		err = kPGPError_UserAbort;
		break;

	default:
		err = kPGPError_FeatureNotAvailable;
	}

	return err;
}


static BOOL sIsDefaultMailClient()
{
	HKEY hKey = NULL;
	LONG lResult;
	BOOL bIsDefault = FALSE;
	char szData[256];
	DWORD dwSize = sizeof(szData);
	DWORD dwType;

	lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Clients\\Mail", 0,
				KEY_READ, &hKey);

	if (lResult == ERROR_SUCCESS)
		lResult = RegQueryValueEx(hKey, NULL, NULL, &dwType, szData, &dwSize);

	if (lResult == ERROR_SUCCESS)
	{
		if (szData == NULL)
			MessageBox(NULL, "szData == NULL", NULL, MB_OK);
		else if (!stricmp(szData, "Microsoft Outlook"))
			bIsDefault = TRUE;
	}

	if (hKey != NULL)
		RegCloseKey(hKey);

	return bIsDefault;
}


static BOOL sLoadMAPI32()
{
	if (hMAPI32 != NULL)
		return TRUE;

	hMAPI32 = LoadLibrary("mapi32.dll");
	if (hMAPI32 == NULL)
		return FALSE;

	pMAPIInitialize = (LPMAPIINITIALIZE) GetProcAddress(hMAPI32, 
												"MAPIInitialize");

	pMAPIUninitialize = (LPMAPIUNINITIALIZE) GetProcAddress(hMAPI32, 
												"MAPIUninitialize");

	pMAPIAdminProfiles = (LPMAPIADMINPROFILES) GetProcAddress(hMAPI32, 
												"MAPIAdminProfiles");

	pMAPIFreeBuffer = (LPMAPIFREEBUFFER) GetProcAddress(hMAPI32, 
												"MAPIFreeBuffer");

	pMAPILogonEx = (LPMAPILOGONEX) GetProcAddress(hMAPI32, 
												"MAPILogonEx");

	pHrQueryAllRows = (HrQueryAllRowsProc) GetProcAddress(hMAPI32, 
												"HrQueryAllRows@24");

	if (!pHrQueryAllRows)
		pHrQueryAllRows = (HrQueryAllRowsProc) GetProcAddress(hMAPI32, 
												(char *) MAKEWORD(75,0));

	pFreeProws = (FreeProwsProc) GetProcAddress(hMAPI32, 
												"FreeProws@4");
	
	if (!pFreeProws)
		pFreeProws = (FreeProwsProc) GetProcAddress(hMAPI32, 
												(char *) MAKEWORD(140,0));

	pgpAssert(pMAPIInitialize != NULL);
	pgpAssert(pMAPIUninitialize != NULL);
	pgpAssert(pMAPIAdminProfiles != NULL);
	pgpAssert(pMAPIFreeBuffer != NULL);
	pgpAssert(pMAPILogonEx != NULL);
	pgpAssert(pHrQueryAllRows != NULL);
	pgpAssert(pFreeProws != NULL);

	if (!pMAPIInitialize || !pMAPIUninitialize || !pMAPIAdminProfiles ||
		!pMAPIFreeBuffer || !pMAPILogonEx || !pHrQueryAllRows ||
		!pFreeProws)
	{
		FreeLibrary(hMAPI32);
		hMAPI32 = NULL;
		return FALSE;
	}

	return TRUE;
}


static void sUnloadMAPI32()
{
	if (hMAPI32 != NULL)
		FreeLibrary(hMAPI32);

	hMAPI32 = NULL;
	return;
}


/*__Editor_settings____

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