pgpdialogs.cpp

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1997 Network Associates Inc. and affiliated companies.
	All rights reserved.
	
	$Id: pgpDialogs.cpp,v 1.51.6.1 1999/06/04 01:12:08 heller Exp $
____________________________________________________________________________*/

#include <string.h>

#include "pgpMem.h"
#include "pgpUserInterface.h"

#include "pgpContext.h"
#include "pgpDialogs.h"
#include "pgpErrors.h"
#include "pgpKeys.h"
#include "pgpKeyServer.h"
#include "pgpOptionListPriv.h"

#define elemsof(x) ((unsigned)(sizeof(x)/sizeof(*x)))

#define	kCommonAllowedOptions						\
			kPGPOptionType_ParentWindowHandle,      \
			kPGPOptionType_TextUI,      \
			kPGPOptionType_WindowTitle

#define	kCommonAllowedPassphraseOptions				\
			kCommonAllowedOptions,					\
			kPGPOptionType_DialogOptions,			\
			kPGPOptionType_DialogPrompt,			\
			kPGPOptionType_OutputPassphrase,		\
			kPGPOptionType_MinPassphraseLength,		\
			kPGPOptionType_MinPassphraseQuality

#define	kCommonAllowedKeyServerOptions				\
			kCommonAllowedOptions

			
CPGPDialogOptions::CPGPDialogOptions(void)
{
	mContext				= kInvalidPGPContextRef;
	mClientOptions 			= kInvalidPGPOptionListRef;
	mWindowTitle			= NULL;
	mServerList				= NULL;
	mServerCount			= 0;
	mSearchBeforeDisplay	= FALSE;
	mTextUI					= FALSE;
	mNewKeys				= NULL;
	mTLSContext				= kInvalidPGPtlsContextRef;
	mPrompt					= NULL;
	
#if PGP_WIN32
	 mHwndParent	= NULL;
#endif
}

CPGPDialogOptions::~CPGPDialogOptions(void)
{
}
	
	PGPError
CPGPDialogOptions::GatherOptions(
	PGPContextRef 		context,
	PGPOptionListRef	optionList)
{
	PGPError	err = kPGPError_NoErr;
	
	PGPValidateContext( context );
	PGPValidateParam( pgpOptionListIsValid( optionList ) );

	mContext		= context;
	mClientOptions	= optionList;

	err = pgpFindOptionArgs( optionList,
				kPGPOptionType_WindowTitle, FALSE, "%p",
				&mWindowTitle );

	if( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
					kPGPOptionType_DialogPrompt, FALSE, "%p",
					&mPrompt );
	}
	
	if( IsntPGPError( err ) )
	{
		PGPBoolean	haveOption;
		PGPUInt32	textUI;
		
		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_TextUI, FALSE,
						 "%b%d", &haveOption, &textUI );
		
		if( haveOption )
		{	 
			mTextUI = ( textUI != 0 );
		}
	}

#if PGP_WIN32
	if( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_ParentWindowHandle, FALSE,
						 "%p", &mHwndParent );
	}
#endif

	if( IsntPGPError( err ) &&
		IsntPGPError( pgpCheckNetworklibAvailability() ) )
	{
		PGPOUIKeyServerParamsDesc	*desc = NULL;
		
		// Key server params are stored at this level because this is the
		// class common to all users of key servers. The legal option
		// checking will filter out illegal calls.
	
		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_KeyServerUpdateParams, FALSE,
						 "%p", &desc );
		
		if( IsntNull( desc ) )
		{
			mServerList 			= desc->serverList;
			mServerCount 			= desc->serverCount;
			mTLSContext				= desc->tlsContext;
			mSearchBeforeDisplay 	= desc->searchBeforeDisplay;
			mNewKeys 				= desc->foundKeys;
		}
	}

	return( err );
}

CPGPRecipientDialogOptions::CPGPRecipientDialogOptions(void)
{
	mDialogOptions				= kInvalidPGPOptionListRef;
	mNumDefaultRecipients		= 0;
	mDefaultRecipients			= NULL;
	mDisplayMarginalValidity	= FALSE;
	mIgnoreMarginalValidity		= FALSE;
	mGroupSet					= kInvalidPGPGroupSetRef;
	mClientKeySet				= kInvalidPGPKeySetRef;
	mRecipientKeysPtr			= NULL;
	mEnforcement				= kPGPARREnforcement_None;
	mAlwaysDisplay				= FALSE;
	mAlwaysDisplayWithARRs		= FALSE;
	mRecipientCount				= NULL;
	mRecipientList				= NULL;
}

CPGPRecipientDialogOptions::~CPGPRecipientDialogOptions(void)
{
	if( IsntNull( mDefaultRecipients ) )
	{
		PGPFreeData( (void *) mDefaultRecipients );
		mDefaultRecipients = NULL;
	}
}

	PGPError
CPGPRecipientDialogOptions::GatherOptions(
	PGPContextRef 		context,
	PGPOptionListRef	optionList)
{
	PGPError	err = kPGPError_NoErr;
	
	PGPValidateContext( context );
	PGPValidateParam( pgpOptionListIsValid( optionList ) );

	err = CPGPDialogOptions::GatherOptions( context, optionList );
	if( IsntPGPError( err ) )
	{
		PGPOption	optionData;

		err = pgpSearchOptionSingle( optionList,
					kPGPOptionType_DialogOptions, &optionData );
		if( IsntPGPError( err ) &&
			optionData.type == kPGPOptionType_DialogOptions &&
			PGPOptionListRefIsValid( optionData.subOptions ) )
		{
			mDialogOptions = optionData.subOptions;
		}
	}

	if( IsntPGPError( err ) )
	{
		PGPUInt32	optionIndex = 0;
		PGPOption	optionData;
		
		// Multiple default recipient options are allowed, so we
		// loop and look for all of them.
		
		while( IsntPGPError( pgpGetIndexedOptionType( optionList,
					kPGPOptionType_DefaultRecipients, optionIndex, TRUE,
					&optionData, NULL ) ) )
		{
			PGPUInt32			numNewRecipients;
			PGPUInt32			numTotalRecipients;
			PGPRecipientSpec	*newRecipientList;
			
			numNewRecipients = optionData.valueSize /
										sizeof( PGPRecipientSpec );
			numTotalRecipients	= numNewRecipients + mNumDefaultRecipients;
			
			newRecipientList = (PGPRecipientSpec *) PGPNewData(
										PGPGetContextMemoryMgr( context ),
										numTotalRecipients *
											sizeof( PGPRecipientSpec ), 0 );
			if( IsNull( newRecipientList ) )
			{
				err = kPGPError_OutOfMemory;
				break;
			}
			
			if( IsntNull( mDefaultRecipients ) )
			{
				pgpCopyMemory( mDefaultRecipients, newRecipientList,
						mNumDefaultRecipients * sizeof( PGPRecipientSpec ) );
				PGPFreeData( (void *) mDefaultRecipients );
				mDefaultRecipients = NULL;
			}
			
			pgpCopyMemory( 	optionData.value.asPtr,
							&newRecipientList[mNumDefaultRecipients],
							numNewRecipients * sizeof( PGPRecipientSpec ) );
			
			mNumDefaultRecipients 	= numTotalRecipients;
			mDefaultRecipients		= newRecipientList;
		
			++optionIndex;
		}
	}

	if( IsntPGPError( err ) )
	{
		PGPBoolean	haveOption;
		PGPUInt32	displayMarginalValidity;

		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_DisplayMarginalValidity, FALSE,
						 "%b%d", &haveOption, &displayMarginalValidity );
	
		if( haveOption )
		{	 
			mDisplayMarginalValidity = displayMarginalValidity;
		}
	}

	if( IsntPGPError( err ) )
	{
		PGPBoolean			haveOption;
		PGPOUIARRParamsDesc	arrOptions;

		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_ARREnforcement, FALSE,
						 "%b%d", &haveOption, &arrOptions );
	
		if( haveOption )
		{	 
			mEnforcement = (PGPAdditionalRecipientRequestEnforcement)
					arrOptions.enforcement;
			mAlwaysDisplayWithARRs = arrOptions.displayDialog;
		}
	}

	if( IsntPGPError( err ) )
	{
		PGPBoolean	haveOption;
		PGPUInt32	ignoreMarginalValidity;

		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_IgnoreMarginalValidity, FALSE,
						 "%b%d", &haveOption, &ignoreMarginalValidity );
	
		if( haveOption )
		{	 
			mIgnoreMarginalValidity = ignoreMarginalValidity;
		}
	}

	if( IsntPGPError( err ) )
	{
		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_RecipientGroups, FALSE,
						 "%p", &mGroupSet );
	}

	if( IsntPGPError( err ) )
	{
		PGPOUIRecipientListDesc	*desc = NULL;

		err = pgpFindOptionArgs( optionList,
						 kPGPOptionType_RecipientList, FALSE,
						 "%p", &desc );
	
		if( IsntNull( desc ) )
		{	
			mRecipientCount = desc->recipientCount;
			mRecipientList	= desc->recipientList;
		}
	}
	
	return( err );
}

CPGPRandomDataDialogOptions::CPGPRandomDataDialogOptions(void)
{
	mNeededEntropyBits 	= 0;
}

CPGPRandomDataDialogOptions::~CPGPRandomDataDialogOptions(void)
{
}

CPGPKeyServerDialogOptions::CPGPKeyServerDialogOptions(void)
{
}

CPGPKeyServerDialogOptions::~CPGPKeyServerDialogOptions(void)
{
}


CPGPSearchKeyServerDialogOptions::CPGPSearchKeyServerDialogOptions(void)
{
	mSearchAllServers 	= FALSE;
	mServerList			= NULL;
	mServerCount		= 0;
	mFilter				= kInvalidPGPFilterRef;
	mKeyDescription[0] 	= 0;
}

CPGPSearchKeyServerDialogOptions::~CPGPSearchKeyServerDialogOptions(void)
{
	if( PGPFilterRefIsValid( mFilter ) )
		PGPFreeFilter( mFilter );
}

	PGPError
CPGPSearchKeyServerDialogOptions::NewKeyIDListSearchFilter(
	PGPContextRef	context,
	const PGPKeyID	*keyIDList,
	PGPUInt32		keyIDCount,
	PGPFilterRef	*filter)
{
	PGPError		err 		= kPGPError_NoErr;
	PGPFilterRef	outFilter 	= kInvalidPGPFilterRef;
	PGPUInt32		keyIDIndex;
	
	for( keyIDIndex = 0; keyIDIndex < keyIDCount; keyIDIndex++ )
	{
		PGPFilterRef	curFilter;
		
		err = PGPNewKeyIDFilter( context, &keyIDList[keyIDIndex], &curFilter );
		if( IsntPGPError( err ) )
		{
			if( PGPFilterRefIsValid( outFilter ) )
			{
				PGPFilterRef	newFilter;
				
				err = PGPUnionFilters( curFilter, outFilter, &newFilter );
				if( IsntPGPError( err ) )
				{
					outFilter = newFilter;
				}
			}
			else
			{
				outFilter = curFilter;
			}
		}
	
		if( IsPGPError( err ) )
			break;
	}
	
	if( IsPGPError( err ) &&
		PGPFilterRefIsValid( outFilter ) )
	{
		PGPFreeFilter( outFilter );
		outFilter = kInvalidPGPFilterRef;
	}
	
	*filter = outFilter;
	
	return( err );
}

	PGPError
CPGPSearchKeyServerDialogOptions::NewKeySetSearchFilter(
	PGPContextRef	context,
	PGPKeySetRef	keySet,
	PGPFilterRef	*filter)
{
	PGPError		err 		= kPGPError_NoErr;
	PGPFilterRef	outFilter 	= kInvalidPGPFilterRef;
	PGPKeyListRef	keyList;
	
	err = PGPOrderKeySet( keySet, kPGPAnyOrdering, &keyList );
	if( IsntPGPError( err ) )
	{
		PGPKeyIterRef	iter;
		
		err = PGPNewKeyIter( keyList, &iter );
		if( IsntPGPError( err ) )
		{
			PGPKeyRef	theKey;
			
			err = PGPKeyIterNext( iter, &theKey );
			while( IsntPGPError( err ) )
			{
				PGPKeyID	keyID;
				
				err = PGPGetKeyIDFromKey( theKey, &keyID );
				if( IsntPGPError( err ) )
				{
					PGPFilterRef	keyIDFilter;
					
					err = PGPNewKeyIDFilter( context, &keyID, &keyIDFilter );
					if( IsntPGPError( err ) )
					{
						if( PGPFilterRefIsValid( outFilter ) )
						{
							PGPFilterRef	newFilter;
							
							err = PGPUnionFilters( outFilter, keyIDFilter,
										&newFilter );
							if( IsntPGPError( err ) )
							{
								outFilter = newFilter;
							}
						}
						else
						{
							outFilter = keyIDFilter;
						}
					}
				}
				
				if( IsntPGPError( err ) )
					err = PGPKeyIterNext( iter, &theKey );
			}
			
			if( err == kPGPError_EndOfIteration )
				err = kPGPError_NoErr;
				
			PGPFreeKeyIter( iter );
		}
		
		PGPFreeKeyList( keyList );
	}
	
	if( IsPGPError( err ) &&
		PGPFilterRefIsValid( outFilter ) )
	{
		PGPFreeFilter( outFilter );
		outFilter = kInvalidPGPFilterRef;
	}
	
	*filter = outFilter;
	
	return( err );
}

	PGPError
CPGPSearchKeyServerDialogOptions::GatherOptions(
	PGPContextRef 		context,
	PGPOptionListRef	optionList)
{
	PGPError	err = kPGPError_NoErr;
	
	PGPValidateContext( context );
	PGPValidateParam( pgpOptionListIsValid( optionList ) );

	err = CPGPKeyServerDialogOptions::GatherOptions( context, optionList );
	if( IsntPGPError( err ) )
	{
		PGPFilterRef	filter = kInvalidPGPFilterRef;
		PGPUInt32		optionIndex = 0;
		PGPOption		optionData;
		char			keyDescription[256];
		PGPUInt32		numSearchOptions = 0;
		
		// Multiple search source options are allowed, so we
		// loop and look for all of them. If there is a single
		// search key or a key list with one item, we grab a string
		// description of the item for display in the dialog.

		keyDescription[0] = 0;
		
		while( IsntPGPError( pgpGetIndexedOption( optionList, optionIndex,
					TRUE, &optionData ) ) && IsntPGPError( err ) )
		{
			PGPFilterRef	curFilter = kInvalidPGPFilterRef;

			switch( optionData.type )
			{
				case kPGPOptionType_KeyServerSearchFilter:
				{
					curFilter = optionData.value.asFilterRef;
					(void) PGPIncFilterRefCount( curFilter );

					++numSearchOptions;
					break;
				}
				
				case kPGPOptionType_KeyServerSearchKey:
				{
					PGPKeyRef	keyRef = optionData.value.asKeyRef;
					
					if( numSearchOptions == 0 )
					{
						PGPSize	len;
						
						err = PGPGetPrimaryUserIDNameBuffer( keyRef, 
									sizeof( keyDescription ),
									keyDescription, &len );
						keyDescription[len] = 0;
					}
					
					if( IsntPGPError( err ) )
					{
						PGPKeyID	keyID;
						
						err = PGPGetKeyIDFromKey( keyRef, &keyID );
						if( IsntPGPError( err ) )
						{
							err = PGPNewKeyIDFilter( context, &keyID,
										&curFilter );
						}
					}
					
					++numSearchOptions;
					break;
				}
				
				case kPGPOptionType_KeyServerSearchKeyIDList:
				{
					PGPKeyID	*keyIDList;
					PGPUInt32	keyIDCount;
					
					keyIDList 	= (PGPKeyID *) optionData.value.asPtr;
					keyIDCount 	= optionData.valueSize / sizeof( *keyIDList );
					
					if( numSearchOptions == 0 && keyIDCount == 1 )
					{
						err = PGPGetKeyIDString( keyIDList,
									kPGPKeyIDString_Abbreviated,
									keyDescription );
					}

					if( IsntPGPError( err ) )
					{
						err = NewKeyIDListSearchFilter( context, keyIDList,
										keyIDCount, &curFilter );
					}
					
					++numSearchOptions;
					break;
				}

				case kPGPOptionType_KeyServerSearchKeySet:
				{
					err = NewKeySetSearchFilter( context,
								optionData.value.asKeySetRef, &curFilter );
					
					++numSearchOptions;
					break;
				}
				
				default:
					break;
			}
			
			if( PGPFilterRefIsValid( curFilter ) &&
				IsntPGPError( err ) )
			{
				if( PGPFilterRefIsValid( filter ) )
				{
					PGPFilterRef	newFilter;
					
					err = PGPUnionFilters( filter, curFilter, &newFilter );
					if( IsntPGPError( err ) )
					{
						filter = newFilter;
					}
				}
				else
				{
					filter = curFilter;
				}
			}
			
			++optionIndex;
		}