pgpsigspec.c

vc环境下的pgp源码

pgpSigSpecExportable (PGPSigSpec const *spec, PGPBoolean *exportable)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_EXPORTABLE, 0 );
	if( IsNull( pkt ) ) {
		*exportable = 0;
		return 0;
	}
	pgpAssert (pkt->len == sizeof (*exportable));
	*exportable = *(PGPBoolean *)pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetExportable (PGPSigSpec *spec, PGPUInt32 flags,
						 PGPBoolean exportable)
{
	PktList *pkt;

	sFreePkts( spec, SIGSUB_EXPORTABLE );
	flags |= SIGSUB_EXPORTABLE;
	pkt = pgpPktListNew( spec->cdkContext, flags, (PGPByte *)&exportable,
						 sizeof(exportable) );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecRevocable (PGPSigSpec const *spec, PGPBoolean *revocable)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_REVOCABLE, 0 );
	if( IsNull( pkt ) ) {
		*revocable = 0;
		return 0;
	}
	pgpAssert (pkt->len == sizeof (*revocable));
	*revocable = *(PGPBoolean *)pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetRevocable (PGPSigSpec *spec, PGPUInt32 flags,
						PGPBoolean revocable)
{
	PktList *pkt;

	sFreePkts( spec, SIGSUB_REVOCABLE );
	flags |= SIGSUB_REVOCABLE;
	pkt = pgpPktListNew( spec->cdkContext, flags, (PGPByte *)&revocable,
						 sizeof(revocable) );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecPrimaryUserID (PGPSigSpec const *spec, PGPBoolean *primaryUserID)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_PRIMARY_USERID, 0 );
	if( IsNull( pkt ) ) {
		*primaryUserID = 0;
		return 0;
	}
	pgpAssert (pkt->len == sizeof (*primaryUserID));
	*primaryUserID = *(PGPBoolean *)pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetPrimaryUserID (PGPSigSpec *spec, PGPUInt32 flags,
						 PGPBoolean primaryUserID)
{
	PktList *pkt;

	sFreePkts( spec, SIGSUB_PRIMARY_USERID );
	flags |= SIGSUB_PRIMARY_USERID;
	pkt = pgpPktListNew( spec->cdkContext, flags, (PGPByte *)&primaryUserID,
						 sizeof(primaryUserID) );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecTrustLevel (PGPSigSpec const *spec, PGPByte *trustLevel,
					  PGPByte *trustValue)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_TRUST, 0 );
	if( IsNull( pkt ) ) {
		*trustLevel = 0;
		*trustValue = 0;
		return 0;
	}
	pgpAssert (pkt->len == sizeof (*trustLevel) + sizeof (*trustValue));
	*trustLevel = pkt->buf[0];
	*trustValue = pkt->buf[1];
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetTrustLevel (PGPSigSpec *spec, PGPUInt32 flags,
						 PGPByte trustLevel, PGPByte trustValue)
{
	PktList *pkt;
	PGPByte trustArray[2];

	sFreePkts( spec, SIGSUB_TRUST );
	flags |= SIGSUB_TRUST;
	trustArray[0] = trustLevel;
	trustArray[1] = trustValue;
	pkt = pgpPktListNew( spec->cdkContext, flags, trustArray,
						 sizeof(trustArray) );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecRegExp (PGPSigSpec const *spec, char **regExp)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_REGEXP, 0 );
	if( IsNull( pkt ) ) {
		*regExp = 0;
		return 0;
	}
	*regExp = (char *)pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetRegExp (PGPSigSpec *spec, PGPUInt32 flags, char const *regExp)
{
	PktList *pkt;
	PGPSize len;

	sFreePkts( spec, SIGSUB_REGEXP );
	flags |= SIGSUB_REGEXP;
	len = strlen( regExp ) + 1;	/* include null */
	pkt = pgpPktListNew( spec->cdkContext, flags,
				(const PGPByte *) regExp, len );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

/* Access functions for self-sig related signature subpackets */

PGPUInt32
pgpSigSpecKeyExpiration (PGPSigSpec const *spec, PGPUInt32 *keyExpire)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_KEY_EXPIRATION, 0 );
	if( IsNull( pkt ) ) {
		*keyExpire = 0;
		return 0;
	}
	pgpAssert (pkt->len == sizeof (*keyExpire));
	*keyExpire = *(PGPUInt32 *)pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetKeyExpiration (PGPSigSpec *spec, PGPUInt32 flags,
							PGPUInt32 keyExpire)
{
	PktList *pkt;

	sFreePkts( spec, SIGSUB_KEY_EXPIRATION );
	flags |= SIGSUB_KEY_EXPIRATION;
	pkt = pgpPktListNew( spec->cdkContext, flags, (PGPByte *)&keyExpire,
						 sizeof(keyExpire) );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecPrefAlgs (PGPSigSpec const *spec, PGPByte **prefalgs,
					PGPSize *preflen)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_PREFERRED_ENCRYPTION_ALGS, 0 );
	if( IsNull( pkt ) ) {
		*prefalgs = 0;
		*preflen = 0;
		return 0;
	}
	*preflen = pkt->len;
	*prefalgs = pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetPrefAlgs (PGPSigSpec *spec, PGPUInt32 flags,
					   PGPByte const *algs, size_t len)
{
	PktList *pkt;

	sFreePkts( spec, SIGSUB_PREFERRED_ENCRYPTION_ALGS );
	flags |= SIGSUB_PREFERRED_ENCRYPTION_ALGS;
	pkt = pgpPktListNew( spec->cdkContext, flags, algs, len );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecAdditionalRecipientRequest (PGPSigSpec const *spec,
									  PGPByte **arr, size_t *arrlen,
									  int nth)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_KEY_ADDITIONAL_RECIPIENT_REQUEST, nth );
	if( IsNull( pkt ) ) {
		*arr = 0;
		*arrlen = 0;
		return 0;
	}
	*arrlen = pkt->len;
	*arr = pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetAdditionalRecipientRequest  (PGPSigSpec *spec, PGPUInt32 flags,
										  PGPByte const *krinfo, PGPSize len)
{
	PktList *pkt;

	flags |= SIGSUB_KEY_ADDITIONAL_RECIPIENT_REQUEST;
	pkt = pgpPktListNew( spec->cdkContext, flags, krinfo, len );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

PGPUInt32
pgpSigSpecRevocationKey (PGPSigSpec const *spec, PGPByte **rev,
						 PGPSize *revlen, int nth)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_KEY_REVOCATION_KEY, nth );
	if( IsNull( pkt ) ) {
		*rev = 0;
		*revlen = 0;
		return 0;
	}
	*revlen = pkt->len;
	*rev = pkt->buf;
	return sSigFlags( pkt->type );
}

PGPError
pgpSigSpecSetRevocationKey  (PGPSigSpec *spec, PGPUInt32 flags,
							 PGPByte const *krinfo, size_t len)
{
	PktList *pkt;

	flags |= SIGSUB_KEY_REVOCATION_KEY;
	pkt = pgpPktListNew( spec->cdkContext, flags, krinfo, len );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}

/* Unrecognized subpacket type which we will copy over blindly */
PGPUInt32
pgpSigSpecPacket (PGPSigSpec const *spec, PGPByte **extradata,
				  PGPSize *len, int nth)
{
	PktList *pkt;

	pkt = sSearchPkt( spec, SIGSUB_UNRECOGNIZED, nth );
	if( IsNull( pkt ) ) {
		*extradata = 0;
		*len = 0;
		return 0;
	}
	*len = pkt->len;
	*extradata = pkt->buf;
	return sSigFlags( pkt->type );
}	

/* Unrecognized subpacket type which we will copy over blindly */
PGPError
pgpSigSpecSetPacket (PGPSigSpec *spec, PGPUInt32 flags,
							 PGPByte const *extradata, size_t len)
{
	PktList *pkt;

	flags |= SIGSUB_UNRECOGNIZED;
	pkt = pgpPktListNew( spec->cdkContext, flags, extradata, len );
	if( IsNull( pkt ) )
		return kPGPError_OutOfMemory;
	pkt->next = spec->pkl;
	spec->pkl = pkt;
	sSubPacketVersion(spec);
	return kPGPError_NoErr;
}


/*
 * Search for and remove any packets of specified type.
 * Returns kPGPSigFlags_Present if at least one existed, else 0.
 */
PGPUInt32
pgpSigSpecRemove (PGPSigSpec *spec, PGPUInt32 type)
{
	PGPUInt32 rtrn = 0;

	if( sSearchPkt( spec, type, 0 ) )
		rtrn = kPGPSigFlags_Present;
	sFreePkts( spec, type );
	return rtrn;
}