pkserver.c

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

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.
	
	PKServer.c - handle communication with keyserver	

	$Id: PKServer.c,v 1.38 2002/10/29 18:30:59 pbj Exp $
____________________________________________________________________________*/
#include "pgpPFLConfig.h"

// project header files
#include "PGPkeysx.h"

// external globals
extern PGPContextRef	g_context;
extern PGPtlsContextRef	g_tlscontext;
extern HWND				g_hwndMain;

// typedefs
typedef struct {
	FARPROC			pfnCallback;
	PPGPKEYSSTRUCT	ppks;
	PGPKeySetRef	keyset;
	INT				icount;
	PGPKeyID*		pkeyidList;
} SERVERSTRUCT, *PSERVERSTRUCT;

static BOOL CALLBACK 
sAddKeyIDToList (
		TL_TREEITEM*	lptli, 
		LPARAM			lParam) 
{
	SERVERSTRUCT*	pss = (SERVERSTRUCT*)lParam;
	PGPKeyDBObjRef	sig;
	PGPError		err;
	PGPSize			size;

	sig = (PGPKeyDBObjRef)(lptli->lParam);
	err = PGPGetKeyDBObjDataProperty (sig, kPGPSigProperty_KeyID, 
			&pss->pkeyidList[pss->icount], sizeof(PGPKeyID), &size);

	if (IsntPGPError (err))
		++(pss->icount);

	return TRUE;
}

static BOOL CALLBACK 
sCountSelectedSigs (
		TL_TREEITEM*	lptli, 
		LPARAM			lParam) 
{
	SERVERSTRUCT*	pss = (SERVERSTRUCT*)lParam;

	++(pss->icount);

	return TRUE;
}

//	___________________________________________________
//
//	Send selected keys to keyserver

BOOL 
PKSendToServer (
		PPGPKEYSSTRUCT	ppks,
		UINT			uServerFlags) 
{
	PGPKeySetRef	keysetSend		= kInvalidPGPKeySetRef;
	PGPError		err				= kPGPError_BadParams;
	INT				iKeyCount		= 0;

	if ((uServerFlags == kPGPclSpecifiedServer) && 
		(ppks->klConfig.keyserver.protocol == kPGPKeyServerProtocol_Invalid))
	{
		uServerFlags = kPGPclUserIDBasedServer;
	}

	PGPclKeyListGetSelectedKeys (ppks->hKL, &keysetSend);
	if (PGPKeySetRefIsValid (keysetSend)) 
	{
		PGPCountKeys (keysetSend, &iKeyCount);
		err = PGPclSendKeysToServer (g_context, g_tlscontext, 
				ppks->hwndMain, uServerFlags, &ppks->klConfig.keyserver, 
				ppks->keydbMain, keysetSend);
		PGPFreeKeySet (keysetSend);
	}

	if (err == kPGPError_ServerKeyAlreadyExists) 
	{
		if (iKeyCount > 1) 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_KEYSALREADYONSERVER, MB_OK|MB_ICONINFORMATION);
		}
		else 
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
					IDS_KEYALREADYONSERVER, MB_OK|MB_ICONINFORMATION);
		}
	}
	else if (IsPGPError (err))
		PGPclErrorBox (NULL, err);
	else 
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
				IDS_UPLOADOK, MB_OK|MB_ICONINFORMATION);
	}

	return TRUE;
}

//	___________________________________________________
//
//	Disable selected keys on keyserver

BOOL 
PKDisableOnServer (
		PPGPKEYSSTRUCT	ppks)
{
	PGPKeySetRef			keysetDisable	= kInvalidPGPKeySetRef;
	PGPError				err				= kPGPError_BadParams;
	PGPKeyServerKeySpace	space;

	if (ppks->klConfig.uOptions & kPGPclKeyList_PendingBucket)
		space = kPGPKeyServerKeySpace_Normal;
	else
		space = kPGPKeyServerKeySpace_Default;

	PGPclKeyListGetSelectedKeys (ppks->hKL, &keysetDisable);

	if (PGPKeySetRefIsValid (keysetDisable)) 
	{
		err = PGPclDisableKeysOnServer (g_context, g_tlscontext,
				ppks->hwndMain, &ppks->klConfig.keyserver, 
				space, ppks->keydbMain, keysetDisable);
		PGPFreeKeySet (keysetDisable);
	}

	if (IsPGPError (err)) 
		PGPclErrorBox (NULL, err);
	else 
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
				IDS_DISABLEONSERVEROK, MB_OK|MB_ICONINFORMATION);
	}

	return TRUE;
}

//	___________________________________________________
//
//	Delete selected keys from keyserver

BOOL 
PKDeleteFromServer (
		PPGPKEYSSTRUCT	ppks)
{
	PGPKeySetRef			keysetDelete	= kInvalidPGPKeySetRef;
	PGPError				err				= kPGPError_BadParams;
	PGPKeyServerKeySpace	space;

	if (ppks->klConfig.uOptions & kPGPclKeyList_PendingBucket)
		space = kPGPKeyServerKeySpace_Pending;
	else
		space = kPGPKeyServerKeySpace_Default;

	PGPclKeyListGetSelectedKeys (ppks->hKL, &keysetDelete);

	if (PGPKeySetRefIsValid (keysetDelete)) 
	{
		err = PGPclDeleteKeysFromServer (g_context, g_tlscontext,
				ppks->hwndMain, &ppks->klConfig.keyserver, 
				space, ppks->keydbMain, keysetDelete);
		PGPFreeKeySet (keysetDelete);
	}

	if (IsPGPError (err)) 
		PGPclErrorBox (NULL, err);
	else 
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
				IDS_DELETEFROMSERVEROK, MB_OK|MB_ICONINFORMATION);
	}

	return TRUE;
}

//	_______________________________________________
//
//  Update selected keys from server

BOOL 
PKGetFromServerInternal (
		PPGPKEYSSTRUCT	ppks,
		BOOL			bQueryAdd, 
		BOOL			bWarn,
		BOOL			bGetSigners) 
{
	SERVERSTRUCT	ss;
	PGPKeySetRef	keysetGet		= kInvalidPGPKeySetRef;
	PGPKeyDBRef		keydbFound		= kInvalidPGPKeyDBRef;
	PGPError		err				= kPGPError_NoErr;
	PGPUInt32		uSel;

	// get selected keys
	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, NULL, NULL, &uSel);
	if ((uSel == kPGPclKeyList_Key) ||
		(uSel == kPGPclKeyList_UserID) ||
		(!bGetSigners)) 
	{
		PGPclKeyListGetSelectedKeys (ppks->hKL, &keysetGet);
		if (PGPKeySetRefIsValid (keysetGet)) 
		{
			err = PGPclUpdateKeySetFromServer (g_context, g_tlscontext,
					ppks->hwndMain, keysetGet, kPGPclUserIDBasedServer,
					ppks->keydbMain, &keydbFound);
			PGPFreeKeySet (keysetGet);
		}
	}

	// get signing keys
	else 
	{
		ss.ppks = ppks;
		ss.icount = 0;
		ss.pfnCallback = sCountSelectedSigs;
		TreeList_IterateSelected (ppks->hwndTreeList, &ss);

		if (ss.icount > 0) 
		{
			ss.pkeyidList = 
				(PGPKeyID*)malloc ((ss.icount) * sizeof(PGPKeyID));

			ss.icount = 0;
			ss.pfnCallback = sAddKeyIDToList;
			TreeList_IterateSelected (ppks->hwndTreeList, &ss);

			err = PGPclSearchServerForKeyIDs (g_context, g_tlscontext,
					ppks->hwndMain, ss.pkeyidList, ss.icount, 
					kPGPclDefaultServer, ppks->keydbMain, &keydbFound);
			free (ss.pkeyidList);
		}
	}

	if (err == kPGPError_UserAbort) 
		return FALSE;

	if (IsPGPError (err)) 
	{
		if (bWarn) 
			PGPclErrorBox (NULL, err);
	}
	else 
	{
		if (PGPKeyDBRefIsValid (keydbFound)) 
		{
			PGPUInt32 u;
			PGPCountKeys (PGPPeekKeyDBRootKeySet (keydbFound), &u);
			if (u > 0) 
			{
				if (bQueryAdd) 
				{
					PGPclImportKeys (g_context, g_tlscontext,
							ppks->hwndMain, PGPPeekKeyDBRootKeySet (keydbFound), 
							ppks->keydbMain, kPGPclDefaultImportFlags);
					PostMessage (g_hwndMain, PK_M_REFRESHKEYRINGS, 0, FALSE);
				}
				else 
				{
					PGPCopyKeys (PGPPeekKeyDBRootKeySet (keydbFound), 
							ppks->keydbMain, NULL);
				}
				PKKeyDBModified (ppks, PK_MOD_INDEX_0);
			}
			else 
			{
				if (bWarn)
				{
					PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT,
							IDS_SERVERSEARCHFAIL, MB_OK|MB_ICONEXCLAMATION);
				}
			}
			PGPFreeKeyDB (keydbFound);
		}
	}

	return TRUE;
}


//	_______________________________________________
//
//  Update selected keys from server

BOOL 
PKGetFromServer (
		PPGPKEYSSTRUCT	ppks)
{
	return PKGetFromServerInternal (ppks, TRUE, TRUE, TRUE);
}


//	_______________________________________________
//
//  Update configuration (prefs) from server

BOOL 
PKUpdateConfigurationFromServer (
		HWND			hwnd,
		PGPKeyDBRef		keydb)
{
	PGPError		err;

	err = PGPclGetPrefsFromServer (g_context, g_tlscontext, 
			hwnd, kInvalidPGPPrefRef, kInvalidPGPPrefRef);

	if (IsntPGPError (err))
	{
		PGPclGetDefaultKeysFromServer (g_context, g_tlscontext, 
				hwnd, keydb);

		PKMessageBox (hwnd, IDS_CAPTIONINFO,
				IDS_PREFSUPDATED, MB_OK|MB_ICONINFORMATION);

		return TRUE;
	}
	else if (err == kPGPError_ItemNotFound)
	{
		PKMessageBox (hwnd, IDS_CAPTIONALERT, 
				IDS_NOPREFSONSERVER, MB_OK|MB_ICONEXCLAMATION);
	}

	PGPclErrorBox (hwnd, err);

	return FALSE;
}


//	_______________________________________________
//
//  Request CA for certificate for key

BOOL 
PKAddCertificate (
		PPGPKEYSSTRUCT	ppks)
{
	PGPKeySetRef	keysetKey		= kInvalidPGPKeySetRef;
	PGPKeyDBObjRef	key				= kInvalidPGPKeyDBObjRef;
	PGPKeyDBObjRef	userid			= kInvalidPGPKeyDBObjRef;
	PGPKeyDBObjRef	obj				= kInvalidPGPKeyDBObjRef;
	PGPUInt32		uSel;
	PGPError		err;

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &obj, NULL, &uSel);
	if (uSel == kPGPclKeyList_UserID)
	{
		userid = obj;
		key = PGPPeekKeyDBObjKey (userid);
	}
	else
	{
		key = obj;
		PGPGetPrimaryUserID (key, &userid);
	}

	PGPNewOneKeySet (key, &keysetKey);
	if (PGPKeySetRefIsValid (keysetKey)) 
	{
		err = PGPclSendCertificateRequestToServer (g_context, g_tlscontext,
				ppks->hwndMain, ppks->keydbMain, userid, keysetKey);
		PGPFreeKeySet (keysetKey);
	}

	if (err == kPGPError_InvalidProperty)
	{
		if (PKIsThisTheOnlyUserID (userid))
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
					IDS_CANTDERIVEATTRIBUTESONLY, MB_OK|MB_ICONEXCLAMATION);
		}
		else
		{
			PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT, 
					IDS_CANTDERIVEATTRIBUTES, MB_OK|MB_ICONEXCLAMATION);
		}
	}
	else if (IsPGPError (err))
	{
		PGPclErrorBox (ppks->hwndMain, err);
	}
	else
	{
		PKMessageBox (ppks->hwndMain, IDS_CAPTIONINFO, 
				IDS_CERTIFICATEREQUESTED, MB_OK|MB_ICONINFORMATION);
	}

	return TRUE;
}

//	_______________________________________________
//
//  Retrieve a previously-requested certificate

BOOL 
PKRetrieveCertificate (
		PPGPKEYSSTRUCT	ppks)
{
	PGPKeySetRef	keysetKey		= kInvalidPGPKeySetRef;
	PGPKeyDBRef		keydbReturned	= kInvalidPGPKeyDBRef;
	PGPKeyDBObjRef	key				= kInvalidPGPKeyDBObjRef;
	PGPKeyDBObjRef	userid			= kInvalidPGPKeyDBObjRef;
	PGPKeyDBObjRef	obj				= kInvalidPGPKeyDBObjRef;
	PGPUInt32		uSel;
	LPSTR			pszPhrase = NULL; 
	PGPByte *		pPasskey = NULL;
	PGPSize			sizePasskey = 0;
	PGPError		err;
	PGPBoolean		bOnToken;


	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &obj, NULL, &uSel);
	if (uSel == kPGPclKeyList_UserID)
	{
		userid = obj;
		key = PGPPeekKeyDBObjKey (userid);
	}
	else
	{
		key = obj;
		PGPGetPrimaryUserID (key, &userid);
	}

	PGPGetKeyDBObjBooleanProperty (obj, 
		kPGPKeyProperty_IsOnToken, &bOnToken);

	if( bOnToken )  {
		err = PGPclGetKeyPhrase (g_context, g_tlscontext, ppks->hwndMain,
			NULL, ppks->keydbMain, obj, 
			&pszPhrase, &pPasskey, &sizePasskey);
		if( IsPGPError(err) )  {
			if (pPasskey)
				PGPFreeData (pPasskey);
			if( pPasskey )
				PGPFreeData (pszPhrase);
			return FALSE;
		}
	}

	PGPNewOneKeySet (key, &keysetKey);
	if (PGPKeySetRefIsValid (keysetKey)) 
	{
		err = PGPclRetrieveCertificateFromServer (g_context, g_tlscontext,
			ppks->hwndMain, ppks->keydbMain, keysetKey,
			userid, pPasskey, sizePasskey, &keydbReturned);
		PGPFreeKeySet (keysetKey);
	}
	
	if (err == kPGPError_UserAbort)  {
		if (pPasskey)
			PGPFreeData (pPasskey);
		if( pPasskey )
			PGPFreeData (pszPhrase);
		return FALSE;
	}

	if (IsPGPError (err)) 
	{
		PGPclErrorBox (ppks->hwndMain, err);
	}
	else 
	{
		if (PGPKeyDBRefIsValid (keydbReturned)) 
		{
			PGPUInt32	u;

			PGPCountKeys (PGPPeekKeyDBRootKeySet (keydbReturned), &u);
			if (u > 0) 
			{
				CHAR	szUserID[kPGPMaxUserIDSize];

				PGPCopyKeys (PGPPeekKeyDBRootKeySet (keydbReturned), 
						ppks->keydbMain, NULL);
				PGPCheckKeyRingSigs (PGPPeekKeyDBRootKeySet (ppks->keydbMain),
						NULL, FALSE, NULL, NULL );
				PGPclKeyListReloadKeys (ppks->hKL, TRUE);

				PKKeyDBModified (ppks, PK_MOD_INDEX_0);

				PGPclGetUserIDNameUTF8 (userid,
						szUserID, sizeof(szUserID), &u);

				if (bOnToken)
				{
					err = PGPclCopyX509CertToToken (
						g_context, g_tlscontext, ppks->hwndMain, 
						pszPhrase, 
						ppks->keydbMain, obj, 
						PGPPeekKeyDBRootKeySet (keydbReturned));
					PGPclErrorBox (ppks->hwndMain, err);
				}

				PGPclCertCongrats (ppks->hwndMain, 
						kPGPclManualRetrieval, szUserID);
			}
			else 
			{
				PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT,
						IDS_CERTRETRIEVALFAIL, MB_OK|MB_ICONEXCLAMATION);
			}
			PGPFreeKeyDB (keydbReturned);
		}
	}

	return TRUE;
}