📄 pgpkeyfilter.c

📁 vc环境下的pgp源码
💻 C
📖 第 1 页 / 共 5 页
字号:

	PGPError
PGPNewKeyRevokedFilter(
	PGPContextRef		context, 
	PGPBoolean			revoked, 
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyRevoked, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.keyRevoked = revoked;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewKeyDisabledFilter(
	PGPContextRef		context, 
	PGPBoolean			disabled, 
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyDisabled, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.keyDisabled = disabled;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


	PGPError
PGPNewKeySigAlgorithmFilter(
	PGPContextRef			context,
	PGPPublicKeyAlgorithm	sigAlgorithm, 
	PGPFilterRef *			outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	PGPValidateParam( sigAlgorithm >= kPGPPublicKeyAlgorithm_First &&
		sigAlgorithm <= kPGPPublicKeyAlgorithm_Last	);
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeySigAlgorithm, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.keySigAlgorithm = sigAlgorithm;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


	PGPError
PGPNewKeyEncryptKeySizeFilter(
	PGPContextRef		context,
	PGPUInt32			keySize, 
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	PGPValidateMatchCriterion( match );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyEncryptKeySize, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.keyEncryptKeySize = keySize;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


	PGPError
PGPNewKeySigKeySizeFilter(
	PGPContextRef		context,
	PGPUInt32			keySize, 
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter = NULL;
	PGPValidateContext( context );
	PGPValidateMatchCriterion( match );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeySigKeySize, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.keySigKeySize = keySize;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


	PGPError
PGPNewUserIDStringFilter(
	PGPContextRef		context,
	char const *		userIDString, 
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPFilterRef	newFilter;
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter = NULL;
	PGPValidateContext( context );
	PGPValidateMatchCriterion( match );
	
	err = sAllocateFilter( context,  kPGPFilterClassDefault,
			/*	kPGPFilterClassKey | kPGPFilterClassDefault, */
			kPGPFilterTypeUserIDString, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		char *			value;
		
		value = (char *)pgpContextMemAlloc( context,
						strlen( userIDString ) + 1,  0);
		if( IsntNull( value )) 
		{
			newFilter->value.userIDString = value;
			strcpy( value, userIDString);
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewUserIDEmailFilter(
	PGPContextRef		context,
	char const *		eMail, 
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPFilterRef	newFilter;
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter = NULL;
	PGPValidateContext( context );
	PGPValidateMatchCriterion( match );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeUserIDEmail, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		char *			value;

		value = (char *)pgpContextMemAlloc( context, strlen( eMail ) + 1, 0);
		if( IsntNull( value ) )
		{
			strcpy( value, eMail);
			newFilter->value.userIDEmail = value;
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


	PGPError
PGPNewUserIDNameFilter(
	PGPContextRef		context,
	char const *		name, 
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPFilterRef	newFilter;
	PGPError		err	= kPGPError_NoErr;
	char *			value;

	PGPValidatePtr( outFilter );
	*outFilter = NULL;
	PGPValidateContext( context );
	PGPValidateMatchCriterion( match );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeUserIDName, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		value = (char *)pgpContextMemAlloc( context, strlen( name) + 1, 0);
		if( IsntNull( value ) ) 
		{
			strcpy( value, name);
			newFilter->value.userIDName	= value;
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter	= newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


	PGPError
PGPNewSigKeyIDFilter(
	PGPContextRef		context,
	PGPKeyID const *	keyID,  
	PGPFilterRef *		outFilter)
{
	PGPFilterRef	newFilter;
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter = NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSigKeyID, kPGPMatchDefault, &newFilter);
	if ( IsntPGPError( err ) )
	{
		newFilter->value.sigKeyID	= *keyID;
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}


/********************** Generic property filters ************************/

	PGPError
PGPNewKeyBooleanFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	PGPBoolean			match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyBoolean, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propbool.prop = prop;
		(*outFilter)->value.propbool.val = match;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewKeyNumberFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	PGPUInt32			val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyNumber, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propnum.prop = prop;
		(*outFilter)->value.propnum.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewKeyTimeFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	PGPTime				val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyTime, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.proptime.prop = prop;
		(*outFilter)->value.proptime.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewKeyPropertyBufferFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	void			   *val,
	PGPSize				len,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;
	PGPFilterRef	newFilter;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeKeyBuffer, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		PGPByte *		value;

		value = (PGPByte *)pgpContextMemAlloc( context, len, 0);
		if( IsntNull( value ) )
		{
			pgpCopyMemory (val, value, len);
			newFilter->value.propbuffer.prop = prop;
			newFilter->value.propbuffer.val = value;
			newFilter->value.propbuffer.len = len;
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSubKeyBooleanFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	PGPBoolean			match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSubKeyBoolean, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propbool.prop = prop;
		(*outFilter)->value.propbool.val = match;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSubKeyNumberFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	PGPUInt32			val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSubKeyNumber, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propnum.prop = prop;
		(*outFilter)->value.propnum.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSubKeyTimeFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	PGPTime				val,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSubKeyTime, match, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.proptime.prop = prop;
		(*outFilter)->value.proptime.val = val;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewSubKeyPropertyBufferFilter(
	PGPContextRef		context,
	PGPKeyPropName		prop,
	void			   *val,
	PGPSize				len,
	PGPMatchCriterion	match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;
	PGPFilterRef	newFilter;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeSubKeyBuffer, match, &newFilter);
	if( IsntPGPError( err ) )
	{
		PGPByte *		value;

		value = (PGPByte *)pgpContextMemAlloc( context, len, 0);
		if( IsntNull( value ) )
		{
			pgpCopyMemory (val, value, len);
			newFilter->value.propbuffer.prop = prop;
			newFilter->value.propbuffer.val = value;
			newFilter->value.propbuffer.len = len;
		}
		else
		{
			PGPFreeFilter( newFilter );
			newFilter	= NULL;
			err	= kPGPError_OutOfMemory;
		}
	}
	
	*outFilter = newFilter;
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewUserIDBooleanFilter(
	PGPContextRef		context,
	PGPUserIDPropName	prop,
	PGPBoolean			match,
	PGPFilterRef *		outFilter)
{
	PGPError		err	= kPGPError_NoErr;

	PGPValidatePtr( outFilter );
	*outFilter	= NULL;
	PGPValidateContext( context );
	
	err = sAllocateFilter( context, kPGPFilterClassDefault,
			kPGPFilterTypeUserIDBoolean, kPGPMatchDefault, outFilter);
	if( IsntPGPError( err ) )
	{
		(*outFilter)->value.propbool.prop = prop;
		(*outFilter)->value.propbool.val = match;
	}
	
	pgpAssertErrWithPtr( err, *outFilter );
	return err;
}

	PGPError
PGPNewUserIDNumberFilter(
	PGPContextRef		context,
	PGPUserIDPropName	prop,
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -