pgpkeyiter.c

vc环境下的pgp源码

PGPError 
PGPKeyIterKey (
	PGPKeyIterRef	iter,
	PGPKeyRef *		outRef)
{
	PGPError	err	= kPGPError_NoErr;
	
	pgpa(pgpaPGPKeyIterValid(iter));
	pgpAssertAddrValid( outRef, PGPKeyRef );
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	/* pgpFixBeforeShip( "what if key has been deleted" ) */
	if ( IsNull( iter->key ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= iter->key;
	return err;
}

PGPError 
PGPKeyIterSubKey (
	PGPKeyIterRef	iter,
	PGPSubKeyRef *	outRef)
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	if ( IsNull( iter->subKey ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= iter->subKey;
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}    

PGPError 
PGPKeyIterUserID (
	PGPKeyIterRef	iter,
	PGPUserIDRef *	outRef )
{
	PGPError	err	= kPGPError_NoErr;
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	if ( IsNull( iter->userID ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= iter->userID;
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}


PGPError 
PGPKeyIterSig (
	PGPKeyIterRef	iter,
	PGPSigRef *	outRef )
{
	PGPError	err	= kPGPError_NoErr;
	
	pgpa(pgpaPGPKeyIterValid(iter));
	pgpAssertAddrValid( outRef, PGPSigRef );
	 
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	if ( IsNull( iter->uidCert ) )
	{
		err	= kPGPError_EndOfIteration;
	}
	
	*outRef	= iter->uidCert;
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}

PGPError 
PGPKeyIterNextSubKey (
	PGPKeyIterRef	iter,
	PGPSubKeyRef *	outRef )
{
	PGPKey			*key;
	PGPSubKey       *next = NULL;
	PGPError		err	= kPGPError_EndOfIteration;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	*outRef	= NULL;
		
	key = iter->key;
	if (!iter->subKey)
		next = (PGPSubKeyRef ) key->subKeys.next;
	else
		next = iter->subKey->next;

	while (next != (PGPSubKeyRef ) &key->subKeys)
	{
		if (next->removed)
			next = next->next;
		else
		{
		    decIterSubKey (iter);
		    iter->subKey = next;
			incSubKeyRefCount (next);
			
			*outRef	= next;
			err	= kPGPError_NoErr;
			break;
		}
	}
    
    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(
	PGPKeyRef		key,
	PGPSubKeyRef *	outSubKey )
{
	PGPSubKeyRef	subKey	= NULL;
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr(outSubKey);
	*outSubKey = NULL;

	subKey = (PGPSubKeyRef)key->subKeys.next;
	while (	subKey != (PGPSubKeyRef)&key->subKeys &&
			subKey->removed)
	{
		subKey = subKey->next;
	}

	if (subKey != (PGPSubKeyRef)&key->subKeys)
	{
		*outSubKey = subKey;
	}
	
	if ( IsNull( *outSubKey ) )
   		err	= kPGPError_ItemNotFound;
   		
	return err;
}

PGPError 
PGPKeyIterPrevSubKey (
	PGPKeyIterRef	iter,
	PGPSubKeyRef *	outRef )
{
	PGPKey		*key;
	PGPSubKey   *prev;
	PGPError	err	= kPGPError_EndOfIteration;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
		
	key = iter->key;
	if (!iter->subKey)
		prev = (PGPSubKeyRef ) key->subKeys.prev;
	else
		prev = iter->subKey->prev;

	while (prev != (PGPSubKeyRef ) &key->subKeys)
	{
		if (prev->removed)
			prev = prev->prev;
		else
		{
		    decIterSubKey (iter);
			iter->subKey = prev;
			incSubKeyRefCount (prev);
			*outRef	= prev;
			err	= kPGPError_NoErr;
			break;
		}
	}

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


	PGPError 
PGPKeyIterRewindSubKey (PGPKeyIterRef iter)
{
	PGPValidateKeyIter( iter );
	
	decIterSubKey (iter);
	return( kPGPError_NoErr );
}


PGPError 
PGPKeyIterNextUserID (
	PGPKeyIterRef	iter,
	PGPUserIDRef *	outRef )
{
	PGPKey			*key;
	PGPUserID       *next = NULL;
	PGPError		err	= kPGPError_EndOfIteration;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
		
	key = iter->key;
	if (!iter->userID)
		next = (PGPUserIDRef ) key->userIDs.next;
	else
		next = iter->userID->next;

	while (next != (PGPUserIDRef ) &key->userIDs)
	{
		if (next->removed)
			next = next->next;
		else
		{
		    decIterUserID (iter);
		    iter->userID = next;
			incUserIDRefCount (next);
			*outRef	= next;
			err	= kPGPError_NoErr;
			break;
		}
	}

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


PGPError 
PGPKeyIterPrevUserID (
	PGPKeyIterRef 	iter,
	PGPUserIDRef *	outRef)
{
	PGPKey		*key;
	PGPUserID   *prev;
	PGPError		err	= kPGPError_EndOfIteration;

	pgpa(pgpaPGPKeyIterValid(iter));
	pgpAssertAddrValid( outRef, PGPUserIDRef );
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
		
	key = iter->key;
	if (!iter->userID)
		prev = (PGPUserIDRef ) key->userIDs.prev;
	else
		prev = iter->userID->prev;

	while (prev != (PGPUserIDRef ) &key->userIDs)
	{
		if (prev->removed)
			prev = prev->prev;
		else
		{
		    decIterUserID (iter);
			iter->userID = prev;
			incUserIDRefCount (prev);
			*outRef	= prev;
			err	= kPGPError_NoErr;
			break;
		}
	}
	
    pgpAssertErrWithPtr( err, *outRef );
	return( err );
}


PGPError 
PGPKeyIterRewindUserID (PGPKeyIterRef iter)
{
	PGPValidateKeyIter( iter );
	
	decIterUserID (iter);
	
	return( kPGPError_NoErr );
}


PGPError 
PGPKeyIterNextUIDSig (
	PGPKeyIterRef	iter,
	PGPSigRef *	outRef )
{
	PGPKey			*key;
	PGPUserID		*userid;
	PGPSig         *next;
	PGPError		err	= kPGPError_EndOfIteration;

	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	if ( IsNull( iter->userID ) ||
			iter->userID->removed)
	{
		return kPGPError_BadParams;
	}
		
	key = iter->key;
	userid = iter->userID;
	if (!iter->uidCert)
		next = (PGPSigRef ) userid->certs.next;
	else
		next = iter->uidCert->next;

	while (next != (PGPSigRef ) &userid->certs)
	{
		if (next->removed)
			next = next->next;
		else
		{
		    decIterUIDCert (iter);
			iter->uidCert = next;
			incCertRefCount (next);;
			*outRef	= next;
			err	= kPGPError_NoErr;
			break;
		}
	}
	
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}


PGPError 
PGPKeyIterPrevUIDSig (
	PGPKeyIterRef	iter,
	PGPSigRef *	outRef )
{
	PGPKey			*key;
	PGPUserID		*userid;
	PGPSig         *prev;
	PGPError		err	= kPGPError_EndOfIteration;

	pgpa(pgpaPGPKeyIterValid(iter));
	pgpAssertAddrValid( outRef, PGPSigRef );
	
	PGPValidatePtr( outRef );
	*outRef	= NULL;
	PGPValidateKeyIter( iter );
	
	if ( !iter->userID || iter->userID->removed)
		return kPGPError_BadParams;
		
	key = iter->key;
	userid = iter->userID;
	if (!iter->uidCert)
		prev = (PGPSigRef ) userid->certs.prev;
	else
		prev = iter->uidCert->prev;

	while (prev != (PGPSigRef ) &userid->certs)
	{
		if (prev->removed)
			prev = prev->prev;
		else
		{
		    decIterUIDCert (iter);
			iter->uidCert = prev;
			incCertRefCount (prev);
			err	= kPGPError_NoErr;
			*outRef	= prev;
			break;
		}
	}
	
	pgpAssertErrWithPtr( err, *outRef );
	return err;
}


PGPError 
PGPKeyIterRewindUIDSig (PGPKeyIterRef iter)
{
	PGPValidateKeyIter( iter );
	
	if ( iter->userID && !iter->userID->removed)
		decIterUIDCert (iter);
	return( kPGPError_NoErr );
}



/*  Internal functions */

/*  Adjust iterators when a key is added to or removed from a keylist */ 

void
pgpKeyIterAddKey (PGPKeyListRef keys, long idx)
{
	PGPKeyIterRef iter;

	pgpa(pgpaPGPKeyListValid(keys));
	for (iter = keys->firstIterInList; iter; iter = iter->nextIterInList)
	{
		if (iter->key == keys->keys[idx])
			iter->keyIndex = idx;
		else if (iter->keyIndex > idx)
			iter->keyIndex++;
		else if (iter->keyIndex == idx && keys->order != kPGPAnyOrdering
					&& iter->key != NULL
					&& PGPCompareKeys(iter->key, keys->keys[idx],
										keys->order) > 0)
			iter->keyIndex++;
	}
}

void
pgpKeyIterRemoveKey (PGPKeyListRef keys, long idx)
{
	PGPKeyIterRef iter;

	pgpa(pgpaPGPKeyListValid(keys));
	for (iter = keys->firstIterInList; iter; iter = iter->nextIterInList)
		if (iter->keyIndex > idx)
			iter->keyIndex--;
}



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