clsdksrv.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 629 行 · 第 1/2 页

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

	CLsdksrv.c - wrapper functions for sdkui keyserver calls

	$Id: CLsdksrv.c,v 1.20 2002/10/29 18:30:41 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "pgpclx.h"
#include "pgpUnicodeWin32.h"

// external globals
extern HINSTANCE g_hInst;

//	___________________________________________________
//
//	all keyserver queries are funneled through here

static PGPError
sQueryServerInternal (
	HWND					hwndParent,
	PGPContextRef			context,
	PGPtlsContextRef		tlsContext,
	PGPOptionListRef		optionSearch,
	UINT					uServer,
	LPSTR					pszUserID,
	PGPKeyID*				pkeyid,
	PGPKeyDBRef				keydbMain,
	PGPKeyDBRef*			pkeydbResult)
{
	PGPError				err				= kPGPError_NoErr;
	PGPKeyServerEntry*		pentryList		= NULL;
	PGPKeyServerSpec*		pserverList		= NULL;
	PGPInt32				iNumEntries		= 0;
	PCLIENTSERVERSTRUCT		pcss			= NULL;

	err = CLInitKeyServerPrefs (uServer, NULL,
			hwndParent, context, keydbMain, pszUserID,
			&pcss, &pentryList, &pserverList, &iNumEntries);

	if (IsntPGPError (err))
	{
		if (hwndParent || (pkeyid == NULL))
		{
			err = PGPSearchKeyServerDialog (context, iNumEntries,
					pserverList, tlsContext,
					FALSE, pkeydbResult, optionSearch,
					PGPOUIParentWindowHandle (context, hwndParent),
					PGPOLastOption (context));
		}
		else
		{
			PGPFilterRef		filter	= kInvalidPGPFilterRef;
			INT					i;

			PGPKeyServerThreadStorageRef	previousStorage;

			if (IsntNull (optionSearch))
				PGPFreeOptionList (optionSearch);

			err = PGPNewKeyDBObjDataFilter (context, 
					kPGPKeyProperty_KeyID, pkeyid, sizeof(PGPKeyID), 
					kPGPMatchCriterion_Equal, &filter);

			PGPKeyServerInit ();
			PGPKeyServerCreateThreadStorage (&previousStorage);

			for (i=0; i<iNumEntries; i++)
			{
				err = PGPKeyServerOpen (pserverList[i].server, NULL);
				if (IsntPGPError (err))
				{
					err = PGPQueryKeyServer (
							pserverList[i].server, filter, pkeydbResult);
					PGPKeyServerClose (pserverList[i].server);

					if (IsntPGPError (err))
					{
						PGPUInt32	uNumKeys	= 0;
						PGPCountKeys (
								PGPPeekKeyDBRootKeySet (*pkeydbResult), &uNumKeys);
						if (uNumKeys > 0)
							break;
						else
						{
							PGPFreeKeyDB (*pkeydbResult);
							*pkeydbResult = kInvalidPGPKeyDBRef;
						}
					}
				}
			}

			PGPKeyServerDisposeThreadStorage (previousStorage);
			PGPKeyServerCleanup ();

			if (PGPFilterRefIsValid (filter))
				PGPFreeFilter (filter);
		}
	}

	CLUninitKeyServerPrefs (uServer,
			pcss, pentryList, pserverList, iNumEntries);

	return err;
}

//	___________________________________________________
//
//	all keyserver sends are funneled through here

static PGPError
sSendToServerInternal (
		HWND					hwndParent,
		PGPContextRef			context,
		PGPtlsContextRef		tlsContext,
		PGPclServerType			servertype,
		PGPKeyServerEntry*		pkeyserver,
		LPSTR					pszUserID,
		PGPKeyDBRef				keydbMain,
		PGPKeySetRef			keysetToSend)
{
	PGPError				err				= kPGPError_NoErr;
	PGPKeyServerEntry*		pentryList		= NULL;
	PGPKeyServerSpec*		pserverList		= NULL;
	PGPInt32				iNumEntries		= 0;
	PCLIENTSERVERSTRUCT		pcss			= NULL;
	PGPKeySetRef			keysetFailed	= kInvalidPGPKeySetRef;

	if(IsntPGPError(err))
	{
		err = CLInitKeyServerPrefs (servertype, pkeyserver,
				hwndParent, context, keydbMain, pszUserID,
				&pcss, &pentryList, &pserverList, &iNumEntries);
	}

	if (IsntPGPError (err))
	{
		err = PGPSendToKeyServerDialog (context, &(pserverList[0]),
				tlsContext, keysetToSend, &keysetFailed,
				PGPOUIParentWindowHandle (context, hwndParent),
				PGPOLastOption (context));

		if (PGPKeySetRefIsValid (keysetFailed))
			PGPFreeKeySet (keysetFailed);
	}

	CLUninitKeyServerPrefs (servertype,
			pcss, pentryList, pserverList, iNumEntries);

	return err;
}

//	___________________________________________________
//
//	send keyset to keyserver

PGPError PGPclExport
PGPclSendKeysToServer (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwndParent,
		PGPclServerType		servertype,
		PGPKeyServerEntry*	pkeyserver,
		PGPKeyDBRef			keydbMain,
		PGPKeySetRef		keysetToSend)
{
	PGPError				err				= kPGPError_NoErr;
	PGPKeySetRef			keyset			= kInvalidPGPKeySetRef;
	PGPKeyIterRef			keyiter			= kInvalidPGPKeyIterRef;

	// derive server from userid
	if (servertype == kPGPclUserIDBasedServer)
	{
		PGPKeyDBObjRef	key		= kInvalidPGPKeyDBObjRef;

		CHAR			szUserID[kPGPMaxUserIDSize+1];
		PGPSize			size;

		err = PGPNewKeyIterFromKeySet (keysetToSend, &keyiter); CKERR;
		err = PGPKeyIterNextKeyDBObj (keyiter,
				kPGPKeyDBObjType_Key, &key); CKERR;

		while (PGPKeyDBObjRefIsValid (key))
		{
			err = PGPNewOneKeySet (key, &keyset); CKERR;

			err = PGPclGetPrimaryUserIDNameUTF8 (key,
					szUserID, sizeof(szUserID), &size); CKERR;

			err = sSendToServerInternal (hwndParent, context,
					tlsContext, servertype, pkeyserver,
					szUserID, keydbMain, keyset); CKERR;

			PGPKeyIterNextKeyDBObj (keyiter,
					kPGPKeyDBObjType_Key, &key); CKERR;
		}
	}

	// use indicated or caller-supplied server
	else
	{
		err = sSendToServerInternal (hwndParent, context,
				tlsContext, servertype, pkeyserver, "",
				keydbMain, keysetToSend);
	}

done :
	if (PGPKeyIterRefIsValid (keyiter))
		PGPFreeKeyIter (keyiter);
	if (PGPKeySetRefIsValid (keyset))
		PGPFreeKeySet (keyset);

	return err;
}

//	___________________________________________________
//
//	search keyserver(s) for userid

PGPError PGPclExport
PGPclSearchServerForUserID (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwndParent,
		LPSTR				szUserID,
		PGPclServerType		servertype,
		PGPKeyDBRef			keydbMain,
		PGPKeyDBRef*		pkeydbResult)
{
	PGPError				err				= kPGPError_NoErr;
	PGPKeyDBRef				keydb			= kInvalidPGPKeyDBRef;
	PGPOptionListRef		optionSearch	= kInvalidPGPOptionListRef;
	PGPFilterRef			filter			= kInvalidPGPFilterRef;
	PGPUInt32				ulen			= 0;

	char					szUTF8[kPGPMaxUserIDSize];

	// initialize return keyset
	*pkeydbResult = kInvalidPGPKeyDBRef;

	// convert userid to UTF-8
	pgpLocalStringToUTF8 (0, 0, szUserID, 
			lstrlen(szUserID), szUTF8, sizeof(szUTF8), &ulen);

	err = PGPNewKeyDBObjDataFilter (context, kPGPUserIDProperty_Name,
			szUTF8, ulen, kPGPMatchCriterion_SubString, &filter);

	if (IsntPGPError (err) &&
		PGPFilterRefIsValid (filter))
	{
		optionSearch = PGPOUIKeyServerSearchFilter (context, filter);

		if (PGPOptionListRefIsValid (optionSearch))
		{
			err = sQueryServerInternal (hwndParent, context,
					tlsContext, optionSearch, servertype,
					szUserID, NULL, keydbMain, &keydb);

			if (IsntPGPError (err))
			{
				*pkeydbResult = keydb;
				keydb = kInvalidPGPKeyDBRef;
			}
		}
	}

	if (PGPKeyDBRefIsValid (keydb))
		PGPFreeKeyDB (keydb);
	if (PGPFilterRefIsValid (filter))
		PGPFreeFilter (filter);

	return err;
}

//	___________________________________________________
//
//	Update keyset from specified keyserver

PGPError PGPclExport
PGPclUpdateKeySetFromServer (
		PGPContextRef		context,
		PGPtlsContextRef	tlsContext,
		HWND				hwndParent,
		PGPKeySetRef		keysetToUpdate,
		PGPclServerType		servertype,
		PGPKeyDBRef			keydbMain,
		PGPKeyDBRef*		pkeydbResult)
{
	PGPError				err				= kPGPError_NoErr;
	PGPKeyDBRef				keydb			= kInvalidPGPKeyDBRef;
	PGPKeyDBRef				keydbCollect	= kInvalidPGPKeyDBRef;
	PGPOptionListRef		optionSearch	= kInvalidPGPOptionListRef;
	PGPKeyIterRef			keyiter			= kInvalidPGPKeyIterRef;
	PGPKeySetRef			keyset			= kInvalidPGPKeySetRef;

	PGPKeyID				keyid;

	// initialize return keyset
	*pkeydbResult = kInvalidPGPKeyDBRef;

	if (servertype == kPGPclUserIDBasedServer)
	{
		PGPKeyDBObjRef	key			= kInvalidPGPKeyDBObjRef;

		CHAR			szUserID[kPGPMaxUserIDSize+1];
		PGPSize			size;

		err = PGPNewKeyDB (context, &keydbCollect); CKERR;
		err = PGPNewKeyIterFromKeySet (keysetToUpdate, &keyiter); CKERR;
		err = PGPKeyIterNextKeyDBObj (keyiter,
				kPGPKeyDBObjType_Key, &key); CKERR;