pgprecipientdialogcommon.cpp

vc环境下的pgp源码

					}
				}
				
				if( moveUser )
				{
					curUser->markValue 		= markValue;
					curUser->movedManually	= FALSE;

					*numMovedUsers += 1;
				}
			}
		}
		
		if( IsPGPError( err ) )
			break;
	}

	/* Second pass. Move all users with correct mark value */
	curKey = recipients->keys;
	while( IsntNull( curKey ) && IsntPGPError( err ) )
	{
		curUser = curKey->users;
		while( IsntNull( curUser ) )
		{
			if( curUser->markValue == markValue &&
				curUser->location != destinationList )
			{
				curUser->location = destinationList;
				
				err = SendUserEvent( recipients,
							kPGPRecipientEvent_MovedUserEvent, curUser );
				if( IsPGPError( err ) )
					break;
			}
		
			curUser = curUser->nextUser;
		}
		
		curKey = curKey->nextKey;
	}

	curUser = recipients->groups;
	while( IsntNull( curUser ) && IsntPGPError( err ))
	{
		if( curUser->markValue == markValue &&
			curUser->location != destinationList )
		{
			curUser->location = destinationList;
			
			err = SendUserEvent( recipients,
							kPGPRecipientEvent_MovedUserEvent, curUser );
			if( IsPGPError( err ) )
				break;
		}
	
		curUser = curUser->nextUser;
	}
	
	return( err );
}

	static PGPError
pgpAddKeyToSet(
	PGPKeyRef		theKey,
	PGPKeySetRef	keySet,
	PGPBoolean		commitKeySet)
{
	PGPError		err;
	PGPKeySetRef	singletonSet;
	
	err = PGPNewSingletonKeySet( theKey, &singletonSet );
	if( IsntPGPError( err ) )
	{
		err = PGPAddKeys( singletonSet, keySet );
		if( IsntPGPError( err ) && commitKeySet )
		{
			err = PGPCommitKeyRingChanges( keySet );
		}
		
		(void) PGPFreeKeySet( singletonSet );
	}
	
	return( err );
}

	PGPError
PGPGetRecipientKeys(
	PGPRecipientsList	*recipients,
	PGPKeySetRef		*keySetPtr,
	PGPKeySetRef		*newKeysPtr,
	PGPUInt32			*keyListCountPtr,
	PGPRecipientSpec	**keyListPtr)
{
	PGPError			err				= kPGPError_NoErr;
	PGPKeySetRef		keySet			= kInvalidPGPKeySetRef;
	PGPBoolean			haveNewKeys		= FALSE;
	PGPUInt32			keyListCount	= 0;
	PGPRecipientSpec	*keyList		= NULL;
	
	PGPValidatePtr( keySetPtr );
	*keySetPtr	= NULL;
	
	err = PGPNewKeySet( recipients->context, &keySet );
	if( IsntPGPError( err ) )
	{
		PGPRecipientKey		*curKey;
		PGPRecipientUser	*curUser;
		PGPUInt32			markValue;
		
		markValue = GetNextMarkValue();
		
		/* Mark keys in recipient list */
		curKey = recipients->keys;
		while( IsntNull( curKey ) )
		{
			if( curKey->isNewKey )
				haveNewKeys = TRUE;
				
			curUser = curKey->users;
			while( IsntNull( curUser ) )
			{
				if( curUser->location ==
							kPGPRecipientUserLocation_RecipientList )
				{
					curKey->markValue = markValue;
					break;
				}
				
				curUser = curUser->nextUser;
			}
		
			curKey = curKey->nextKey;
		}
		
		/* Mark group keys in recipient list */
		curUser = recipients->groups;
		while( IsntNull( curUser ) && IsntPGPError( err ) )
		{
			if( curUser->location == kPGPRecipientUserLocation_RecipientList )
			{
				PGPUInt32		itemIndex;
				
				for( itemIndex = 0; itemIndex < curUser->groupInfo.numKeys;
						++itemIndex )
				{
					PGPGroupItem	item;
					
					err = PGPGetIndGroupItem( recipients->groupSet,
								curUser->groupInfo.groupID, itemIndex, &item );
					if( IsntPGPError( err ) )
					{	
						if( item.userValue != 0 )
						{
							curKey = (PGPRecipientKey *) item.userValue;
							if( curKey->isVisible )
							{
								curKey->markValue = markValue;
							}
						}
					}
					else
					{
						break;
					}
				}
			}
			
			curUser = curUser->nextUser;
		}

		/* If creating a key list, count the marked keys and allocate the
			list */
		if( IsntNull( keyListPtr ) )
		{
			curKey = recipients->keys;
			while( IsntNull( curKey ) )
			{
				if( curKey->markValue == markValue )
				{
					++keyListCount;
				}
			
				curKey = curKey->nextKey;
			}
			
			/* Count missing items as well */
			
			curUser = recipients->missingRecipients;
			while( IsntNull( curUser ) )
			{
				if( curUser->location ==
							kPGPRecipientUserLocation_RecipientList )
				{
					++keyListCount;
				}
				
				curUser = curUser->nextUser;
			}
			
			keyList = (PGPRecipientSpec *) PGPNewData( recipients->memoryMgr, 
								keyListCount * sizeof( PGPRecipientSpec ),
								kPGPMemoryMgrFlags_Clear );
			if( IsNull( keyList ) )
				err = kPGPError_OutOfMemory;
		}
		
		if( IsntPGPError( err ) ) 
		{
			PGPRecipientSpec	*curKeySpec = keyList;
			
			/* Final pass. Add marked keys to result set */
			curKey = recipients->keys;
			while( IsntNull( curKey ) && IsntPGPError( err ) )
			{
				if( curKey->markValue == markValue )
				{
					err = pgpAddKeyToSet( curKey->keyRef, keySet, FALSE );
					if( IsntPGPError( err ) && IsntNull( curKeySpec ) )
					{
						PGPKeyID	keyID;
						
						/*
						** If we're creating a recipient list, we need to get
						** the value of curKey->keyRef as it appears in keySet,
						** _not_ our working set, so we have to search by key ID
						*/
						
						err = PGPGetKeyIDFromKey( curKey->keyRef, &keyID );
						if( IsntPGPError( err ) &&
							IsntPGPError( PGPGetKeyByKeyID( keySet, &keyID,
								curKey->algorithm, &curKeySpec->u.key ) ) )
						{
							curKeySpec->type = kPGPRecipientSpecType_Key;
						
							++curKeySpec;
						}
					}
				}
			
				curKey = curKey->nextKey;
			}

			if( IsntPGPError( err ) && IsntNull( curKeySpec ) )
			{
				curUser = recipients->missingRecipients;
				while( IsntNull( curUser ) )
				{
					if( curUser->location ==
								kPGPRecipientUserLocation_RecipientList )
					{
						curKeySpec->type = curUser->missingUser.type;
						
						if( curUser->missingUser.type ==
									kPGPRecipientSpecType_UserID )
						{
							strcpy( curKeySpec->u.userIDStr,
									PGPGetRecipientUserNamePtr( curUser ) );
						}
						else if( curUser->missingUser.type ==
										kPGPRecipientSpecType_KeyID )
						{
							curKeySpec->u.id.keyID =
									*curUser->missingUser.keyID;
							curKeySpec->u.id.algorithm =
									curUser->missingUser.algorithm;
						}
						else
						{
							pgpDebugMsg( "PGPGetRecipientKeys(): Unknown "
									"missing recipient type" );
						}
						
						++curKeySpec;
					}
					
					curUser = curUser->nextUser;
				}
			}
		}
		
		if( IsntPGPError( err ) )
			err = PGPCommitKeyRingChanges( keySet );
			
		if( IsPGPError( err ) )
		{
			PGPFreeKeySet( keySet );
			keySet = kInvalidPGPKeySetRef;
		}
	}
	
	*keySetPtr 			= keySet;
	
	if( IsntNull( keyListPtr ) )
		*keyListPtr			= keyList;

	if( IsntNull( keyListCountPtr ) )
		*keyListCountPtr	= keyListCount;
	
	if( IsntPGPError( err ) &&
		IsntNull( newKeysPtr ) )
	{
		*newKeysPtr = kInvalidPGPKeySetRef;
		
		if( haveNewKeys )
		{
			err = PGPNewKeySet( recipients->context, &keySet );
			if( IsntPGPError( err ) )
			{
				PGPRecipientKey		*curKey;

				curKey = recipients->keys;
				while( IsntNull( curKey ) && IsntPGPError( err ) )
				{
					if( curKey->isNewKey )
					{
						err = pgpAddKeyToSet( curKey->keyRef, keySet, FALSE );
					}
				
					curKey = curKey->nextKey;
				}
				
				if( IsntPGPError( err ) )
					err = PGPCommitKeyRingChanges( keySet );
					
				if( IsPGPError( err ) )
				{
					PGPFreeKeySet( keySet );
					keySet = kInvalidPGPKeySetRef;
				}
			}
			
			*newKeysPtr = keySet;
		}
	}
	
	return( err );
}

	static PGPError
pgpUpdateMissingRecipients(
	void				*hwndParent,
	PGPRecipientsList	*recipients,
	PGPBoolean			*haveNewKeys)
{
	PGPError			err 	= kPGPError_NoErr;
	PGPRecipientUser	*curUser;
	PGPKeySetRef		searchResults;
	PGPContextRef		context;
	
	(void) hwndParent;
	
	context 		= recipients->context;
	*haveNewKeys 	= FALSE;
	
	err = PGPNewKeySet( context, &searchResults );
	if( IsntPGPError( err ) )
	{
		/* Search for missing recipients */
		curUser = recipients->missingRecipients;
		while( IsntNull( curUser ) && IsntPGPError( err ) )
		{
			if( curUser->location == kPGPRecipientUserLocation_RecipientList )
			{
				PGPFilterRef	filter = kInvalidPGPFilterRef;
				
				if( curUser->missingUser.type == kPGPRecipientSpecType_UserID )
				{
					err = PGPNewUserIDStringFilter( context,
								PGPGetRecipientUserNamePtr( curUser ),
								kPGPMatchSubString,
								&filter );
				}
				else if( curUser->missingUser.type ==
								kPGPRecipientSpecType_KeyID )
				{
					err = PGPNewKeyIDFilter( context,
								curUser->missingUser.keyID, &filter );
				}
				else
				{
					pgpDebugMsg( "pgpUpdateMissingRecipients(): Unknown "
							"missing recipient type" );
				}
				
				if( IsntPGPError( err ) &&
					PGPFilterRefIsValid( filter ) )
				{
					PGPKeySetRef	tempSet;
					
					err = PGPSearchKeyServerDialog( context,
							recipients->serverCount, recipients->serverList,
							recipients->tlsContext, FALSE, &tempSet,
							PGPOUIKeyServerSearchFilter( context, filter ),
#if PGP_WIN32
							PGPOUIParentWindowHandle(context, (HWND) hwndParent),
#endif
							PGPOLastOption( context ) );
					if( IsntPGPError( err ) && PGPKeySetRefIsValid( tempSet ) )
					{
						PGPUInt32	numKeys;
						
						err = PGPCountKeys( tempSet, &numKeys );
						if( IsntPGPError( err ) && numKeys > 0 )
						{
							*haveNewKeys = TRUE;
							
							err = PGPAddKeys( tempSet, searchResults );
							if( IsntPGPError( err ) )
							{
								err = PGPCommitKeyRingChanges( searchResults );
							}
						}
						
						PGPFreeKeySet( tempSet );
					}
					
					PGPFreeFilter( filter );
				}
			}
			
			curUser = curUser->nextUser;
		}
		
		/* Search for incomplete groups */
		curUser = recipients->groups;
		while( IsntNull( curUser ) && IsntPGPError( err ) )
		{
			if( curUser->location == kPGPRecipientUserLocation_RecipientList &&
				curUser->groupInfo.numMissingKeys > 0 )
			{
				PGPUInt32		itemIndex;
				
				for( itemIndex = 0; itemIndex < curUser->groupInfo.numKeys;
						++itemIndex )
				{
					PGPGroupItem	item;
					
					err = PGPGetIndGroupItem( recipients->groupSet,
								curUser->groupInfo.groupID, itemIndex, &item );
					if( IsntPGPError( err ) && item.userValue == 0 )
					{
						PGPKeySetRef	tempSet;
							
						err = PGPSearchKeyServerDialog( context,
									recipients->serverCount, 
									recipients->serverList,
									recipients->tlsContext, FALSE, &tempSet,
									PGPOUIKeyServerSearchKeyIDList( context,
										1, &item.u.key.keyID ),
#if PGP_WIN32
									PGPOUIParentWindowHandle(context,
										(HWND) hwndParent),
#endif
									PGPOLastOption( context ) );
						if( IsntPGPError( err ) &&
							PGPKeySetRefIsValid( tempSet ) )
						{
							PGPUInt32	numKeys;
							
							err = PGPCountKeys( tempSet, &numKeys );
							if( IsntPGPError( err ) && numKeys > 0 )
							{
								*haveNewKeys = TRUE;
									
								err = PGPAddKeys( tempSet, searchResults );
								if( IsntPGPError( err ) )
								{
									err = PGPCommitKeyRingChanges(
												searchResults );
								}
							}
							
							PGPFreeKeySet( tempSet );
						}
					}
					
					if( IsPGPError( err ) )
						break;
				}
			}
			
			curUser = curUser->nextUser;
		}
		
		if( IsntPGPError( err ) && *haveNewKeys )
		{
			err = AddNewKeys( recipients, searchResults );
		
			curUser = recipients->missingRecipients;
			while( IsntNull( curUser ) && IsntPGPError( err ) )
			{
				if( UserIsVisible( curUser ) )
				{
					if( curUser->missingUser.type == 
								kPGPRecipientSpecType_UserID )
					{
						PGPUInt32			numMatchedUsers;
						PGPRecipientUser	**matchedUserList;
						
						err = FindUsersFromUserID( recipients,
									PGPGetRecipientUserNamePtr( curUser ),
											FALSE, &numMatchedUsers,
											&matchedUserList );
						if( IsntPGPError( err ) )
						{
							if( numMatchedUsers != 0 )
							{
								PGPBoolean	movedARRs;
								PGPUInt32	numMovedUsers = 0;
								
								err = PGPMoveRecipients( recipients,
										kPGPRecipientUserLocation_RecipientList,
										numMatchedUsers, matchedUserList, 
										&numMovedUsers, &movedARRs );
								if( IsntPGPError( err ) )
								{
									if( numMatchedUsers != 1 )
									{
										PGPUInt32	userIndex;
										
										for( userIndex = 0;
												userIndex < numMatchedUsers;
													++userIndex )
										{
											matchedUserList[userIndex]->
													multipleMatch = TRUE;
										}
									}
									
									curUser->location =
											kPGPRecipientUserLocation_Hidden;
								}
							}
							
							PGPFreeData( matchedUserList );
						}
					}
					else if( curUser->missingUser.type == 
								kPGPRecipientSpecType_KeyID )
					{
						PGPRecipientUser	*matchedUser;
						
						err = FindUserFromKeyID( recipients,
									curUser->missingUser.keyID,
									curUser->missingUser.algorithm,
									&matchedUser );
						if( IsntPGPError( err ) && IsntNull( matchedUser ) )
						{
							PGPBoolean	movedARRs;
							PGPUInt32	numMovedUsers = 0;
							
							err = PGPMoveRecipients( recipients,
									kPGPRecipientUserLocation_RecipientList,
									1, &matchedUser, &numMovedUsers,
									&movedARRs );
							if( IsntPGPError( err ) )
							{
								curUser->location =
										kPGPRecipientUserLocation_Hidden;
							}
						}
					}
					else
					{
						pgpDebugMsg( "Unknown missing recipient type" );
					}
				}
				
				curUser = curUser->nextUser;
			}
		}
		
		PGPFreeKeySet( searchResults );
	}
	
	return( err );
}

	PGPError
PGPUpdateMissingRecipients(
	void				*hwndParent,
	PGPRecipientsList	*recipients,
	PGPBoolean			*haveNewKeys)
{
	PGPError	err = kPGPError_NoErr;
	
	PGPValidatePtr( recipients );
	PGPValidatePtr( haveNewKeys );

	*haveNewKeys = FALSE;
	
	if( IsntNull( recipients->serverList ) &&
		recipients->serverCount != 0 )
	{
		err = pgpUpdateMissingRecipients( hwndParent, recipients, haveNewKeys );
	}
	
	return( err );
}