pgpkeyiter.c

可以实现对邮件的加密解密以及签名

	static PGPError 
pgpKeyIterSubKey (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef)
{
	PGPKeyDBObj *subkey;
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	subkey = sKeyIterCurrentObject( iter, 1 );

	if( IsntNull( subkey ) && !OBJISSUBKEY( subkey ) )
		subkey = NULL;

	if ( IsNull( subkey ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= subkey;
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}    

	static PGPError 
pgpKeyIterUserID (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPKeyDBObj *userid;
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	userid = sKeyIterCurrentObject( iter, 1 );
	if( IsntNull( userid ) && !OBJISUSERID( userid ) )
		userid = NULL;

	if ( IsNull( userid ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= userid;
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}


	static PGPError 
pgpKeyIterSig (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPKeyDBObj	*sig;
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	sig = sKeyIterCurrentObject( iter, 2 );
	if( IsntNull( sig ) && !OBJISSIG( sig ) )
		sig = NULL;

	if ( IsNull( sig ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= sig;
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}

static PGPError
sKeyIterNextSubObject (
	PGPKeyIterRef	iter,
	PGPInt32		level,
	PGPUInt32		objtype,
	PGPKeyDBObjRef	*outRef )
{
	PGPKeyDBObj		*obj;
	PGPError		err = kPGPError_NoErr;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	if( iter->level < 0 )
	{
		if( IsPGPError( err = PGPKeyIterMove( iter, 1, outRef ) ) )
			return err;
	}

	if( level >= iter->level && iter->atEndOfLevel )
		return kPGPError_EndOfIteration;

	if( level <= iter->level )
	{
		if( level < iter->level )
		{
			obj = sKeyIterCurrentObject( iter, level );
			iter->level = level;
			iter->currentObject = obj;
			iter->atEndOfLevel = FALSE;
			pgpAssert( obj != NULL );
		}
		if( IsPGPError( err = sKeyIterMoveAtLevel( iter, 1 ) ) )
			return err;
	} else if (level > iter->level) {
		obj = iter->currentObject;
		while( level > iter->level  && IsntNull( obj ) )
		{
			obj = obj->down;
			if( obj == NULL )
				return kPGPError_EndOfIteration;
			++iter->level;
			iter->currentObject = obj;
			if( IsPGPError( err = sKeyIterMoveAtLevel( iter, 0 ) ) )
				return err;
		}
	}

	for( ; ; )
	{
		obj = iter->currentObject;
		if( pgpObjectType( obj ) == objtype )
			break;
		if( IsPGPError( err = sKeyIterMoveAtLevel( iter, 1 ) ) )
			return err;
	}

	obj = iter->currentObject;
	
	*outRef	= obj;
	if( obj != NULL )
		err = kPGPError_NoErr;
    
    pgpAssertErrWithPtr( err, *outRef );
    return( err );
}

static PGPError
sKeyIterPrevSubObject (
	PGPKeyIterRef	iter,
	PGPInt32		level,
	PGPUInt32		objtype,
	PGPKeyDBObjRef	*outRef )
{
	PGPKeyDBObj     *obj = NULL;
	PGPError		err;

	*outRef	= NULL;
	
	pgpAssert( level > 0 );

	/* Can't go prev unless we are at that level or lower already */
	if( level > iter->level )
		return kPGPError_EndOfIteration;

	if( level < iter->level )
	{
		obj = sKeyIterCurrentObject( iter, level );
		iter->level = level;
		iter->currentObject = obj;
		iter->atEndOfLevel = FALSE;
		pgpAssert( obj != NULL );
	}
	if( IsPGPError( err = sKeyIterMoveAtLevel( iter, -1 ) ) )
		return err;

	for( ; ; )
	{
		obj = iter->currentObject;
		if( pgpObjectType( obj ) == objtype )
			break;
		if( IsPGPError( err = sKeyIterMoveAtLevel( iter, -1 ) ) )
			return err;
	}

	obj = iter->currentObject;
	
	*outRef	= obj;
	if( obj != NULL )
		err = kPGPError_NoErr;
    
    pgpAssertErrWithPtr( err, *outRef );
    return( err );
}


static PGPError 
pgpKeyIterNextSubKey (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPError		err;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	*outRef	= NULL;

	err = sKeyIterNextSubObject( iter, 1, RINGTYPE_SUBKEY, outRef );
	if( IsPGPError( err ) )
	{
		/* Point back at first in list so we can then ask about subkeys */
		iter->currentObject = sKeyIterCurrentObject( iter, 0 );
		iter->level = 0;
		iter->atEndOfLevel = FALSE;
	}
    
    pgpAssertErrWithPtr( err, *outRef );
    return( err );
}


/*____________________________________________________________________________
	Get the first subkey on a key.
	
	If the key doesn't have a subkey, then return kPGPError_ItemNotFound.
____________________________________________________________________________*/
	PGPError
pgpGetFirstSubKey(
	PGPKeyDBObjRef		key,
	PGPKeyDBObjRef *	outRef )
{
	PGPKeyDBObjRef	subkey	= NULL;
	PGPError		err	= kPGPError_ItemNotFound;

	PGPValidatePtr(outRef);
	*outRef = NULL;

	if( IsNull( key ) )
		return err;

	subkey = key->down;
	while( IsntNull( subkey ) ) {
		subkey = subkey->next;
		if( !pgpKeyDBObjIsReal( subkey ) )
			continue;
		if( OBJISSUBKEY( subkey ) )
			break;
	}

	*outRef	= subkey;
	
	if ( IsntNull( *outRef ) )
   		err	= kPGPError_NoErr;
   		
	return err;
}

	static PGPError 
pgpKeyIterPrevSubKey (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPError	err;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
		
	err = sKeyIterPrevSubObject( iter, 1, RINGTYPE_SUBKEY, outRef );

    pgpAssertErrWithPtr( err, *outRef );
    return( err );
}


	static PGPError 
pgpKeyIterRewindSubKey (PGPKeyIterRef iter)
{
	PGPValidateKeyIter( iter );
	
	if( iter->level > 0 ) {
		iter->currentObject = sKeyIterCurrentObject( iter, 0 );
		iter->level = 0;
		iter->atEndOfLevel = FALSE;
	}
	return( kPGPError_NoErr );
}


static PGPError 
pgpKeyIterNextUserID (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPError		err;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
		
	err = sKeyIterNextSubObject( iter, 1, RINGTYPE_USERID, outRef );
	if( IsPGPError( err ) )
	{
		/* Point back at first in list so we can then ask about subkeys */
		iter->currentObject = sKeyIterCurrentObject( iter, 0 );
		iter->level = 0;
		iter->atEndOfLevel = FALSE;
	}

    pgpAssertErrWithPtr( err, *outRef );
	return( err );
}


	static PGPError 
pgpKeyIterPrevUserID (
	PGPKeyIterRef 		iter,
	PGPKeyDBObjRef *	outRef)
{
	PGPError		err;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
		
	err = sKeyIterNextSubObject( iter, 1, RINGTYPE_USERID, outRef );
	
    pgpAssertErrWithPtr( err, *outRef );
	return( err );
}


	static PGPError 
pgpKeyIterRewindUserID (PGPKeyIterRef iter)
{
	PGPValidateKeyIter( iter );
	
	if( iter->level > 0 ) {
		iter->currentObject = sKeyIterCurrentObject( iter, 0 );
		iter->level = 0;
		iter->atEndOfLevel = FALSE;
	}
	
	return( kPGPError_NoErr );
}


static PGPError 
pgpKeyIterNextUIDSig (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPError		err	= kPGPError_EndOfIteration;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	/* Don't show revocation sigs */
	for ( ; ; )
	{
		err = sKeyIterNextSubObject( iter, 2, RINGTYPE_SIG, outRef );
		if( IsPGPError( err ) )
			break;
		/* Probably should always be a sig here, but allow others... */
		if( !OBJISSIG(iter->currentObject) )
			break;
		if( pgpSigType( iter->currentObject) != PGP_SIGTYPE_KEY_UID_REVOKE )
			break;
		/* Else try again */
		*outRef = NULL;
	}
	
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}


	static PGPError 
pgpKeyIterPrevUIDSig (
	PGPKeyIterRef		iter,
	PGPKeyDBObjRef *	outRef )
{
	PGPError		err	= kPGPError_EndOfIteration;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	err = sKeyIterPrevSubObject( iter, 2, RINGTYPE_SIG, outRef );
	
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}


	static PGPError 
pgpKeyIterRewindUIDSig (PGPKeyIterRef iter)
{
	PGPValidateKeyIter( iter );
	
	if( iter->level > 1 ) {
		iter->currentObject = sKeyIterCurrentObject( iter, 1 );
		iter->level = 1;
		iter->atEndOfLevel = FALSE;
	}
	return( kPGPError_NoErr );
}

	PGPBoolean
pgpKeyIterIsValid( PGPKeyIter const *	keyIter)
{
	return( IsntNull( keyIter ) &&
		keyIter->magic == kPGPKeyIterMagic );
}

	PGPError
PGPKeyIterNextKeyDBObj(
	PGPKeyIterRef 	iter,
	PGPKeyDBObjType	objectType,
	PGPKeyDBObjRef 	*outRef)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	pgpEnterPGPErrorFunction();

	switch( objectType )
	{
		case kPGPKeyDBObjType_Key:
			err = pgpKeyIterNext( iter, outRef );
			break;
			
		case kPGPKeyDBObjType_SubKey:
			err = pgpKeyIterNextSubKey( iter, outRef );
			break;
			
		case kPGPKeyDBObjType_UserID:
			err = pgpKeyIterNextUserID( iter, outRef );
			break;
		
		case kPGPKeyDBObjType_Signature:
			err = pgpKeyIterNextUIDSig( iter, outRef );
			break;
		
		case kPGPKeyDBObjType_Any:
			err = pgpKeyIterNextObject( iter, outRef );
			break;
			
		default:
			err = kPGPError_BadParams;
			break;
	}
	
	if( IsPGPError( err ) )
		*outRef = kInvalidPGPKeyDBObjRef;
		
	pgpAssertErrWithPtr( err, *outRef );
	return( err );
}

	PGPError
PGPKeyIterPrevKeyDBObj(
	PGPKeyIterRef 	iter,
	PGPKeyDBObjType	objectType,
	PGPKeyDBObjRef 	*outRef)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	pgpEnterPGPErrorFunction();

	switch( objectType )
	{
		case kPGPKeyDBObjType_Key:
			err = pgpKeyIterPrev( iter, outRef );
			break;
			
		case kPGPKeyDBObjType_SubKey:
			err = pgpKeyIterPrevSubKey( iter, outRef );
			break;
			
		case kPGPKeyDBObjType_UserID:
			err = pgpKeyIterPrevUserID( iter, outRef );
			break;
		
		case kPGPKeyDBObjType_Signature:
			err = pgpKeyIterPrevUIDSig( iter, outRef );
			break;
		
		default:
			err = kPGPError_BadParams;
			break;
	}
	
	if( IsPGPError( err ) )
		*outRef = kInvalidPGPKeyDBObjRef;
		
	pgpAssertErrWithPtr( err, *outRef );
	return( err );
}

	PGPError
PGPKeyIterGetKeyDBObj(
	PGPKeyIterRef 	iter,
	PGPKeyDBObjType	objectType,
	PGPKeyDBObjRef 	*outRef)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	pgpEnterPGPErrorFunction();

	switch( objectType )
	{
		case kPGPKeyDBObjType_Key:
			err = pgpKeyIterKey( iter, outRef );
			break;
			
		case kPGPKeyDBObjType_SubKey:
			err = pgpKeyIterSubKey( iter, outRef );
			break;
			
		case kPGPKeyDBObjType_UserID:
			err = pgpKeyIterUserID( iter, outRef );
			break;
		
		case kPGPKeyDBObjType_Signature:
			err = pgpKeyIterSig( iter, outRef );
			break;
		
		default:
			err = kPGPError_BadParams;
			break;
	}
	
	if( IsPGPError( err ) )
		*outRef = kInvalidPGPKeyDBObjRef;
		
	pgpAssertErrWithPtr( err, *outRef );
	return( err );
}

	PGPError
PGPKeyIterRewind(
	PGPKeyIterRef 	iter,
	PGPKeyDBObjType	objectType)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidateKeyIter( iter );
	
	pgpEnterPGPErrorFunction();

	switch( objectType )
	{
		case kPGPKeyDBObjType_Key:
			err = pgpKeyIterRewind( iter );
			break;
			
		case kPGPKeyDBObjType_SubKey:
			err = pgpKeyIterRewindSubKey( iter );
			break;
			
		case kPGPKeyDBObjType_UserID:
			err = pgpKeyIterRewindUserID( iter );
			break;
		
		case kPGPKeyDBObjType_Signature:
			err = pgpKeyIterRewindUIDSig( iter );
			break;
		
		default:
			err = kPGPError_BadParams;
			break;
	}
	
	return( err );
}

#if PGP_DEBUG	/* [ */
	PGPBoolean
pgpaInternalPGPKeyIterValid(
	pgpaCallPrefixDef,
	PGPKeyIter const *	keyIter,
	char const *		varName)
{
	pgpaAddrValid(keyIter, PGPKeyIter);
	pgpaFmtMsg((pgpaFmtPrefix,
			"pgpaPGPKeyIterValid failed on %s (%p)", varName, keyIter));

	return pgpaFailed;
}
#endif /* ] PGP_DEBUG */


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