pgprngpub.h

vc环境下的pgp源码

	RingIterator const *iter);
void  ringIterClearError(RingIterator *iter);
int  ringIterNextObject(RingIterator *iter, unsigned level);
int  ringIterPrevObject(RingIterator *iter, unsigned level);
unsigned  ringIterCurrentLevel(RingIterator const *iter);
union RingObject  *ringIterCurrentObject(
	RingIterator const *iter, unsigned level);

int  ringIterNextObjectAnywhere(RingIterator *iter);
int  ringIterRewind(RingIterator *iter, unsigned level);
int  ringIterFastForward(RingIterator *iter, unsigned level);
int  ringIterSeekTo(RingIterator *iter, union RingObject *obj);

/* RingFile access functions */

struct PGPFile  *ringFileFile(RingFile const *file);
RingSet const  *ringFileSet(RingFile const *file);
PgpVersion  ringFileVersion(RingFile const *file);

int  ringFileIsDirty(RingFile const *file);
int  ringFileIsTrustChanged(RingFile const *file);

PGPError  ringFileSwitchFile(RingFile *file, struct PGPFile *newPGPFile);

/* Alias for ringSetError(ringFileSet(file)) */
RingError const  *ringFileError(RingFile const *file);
void  ringFileClearError(RingFile *file);

int 
ringSetFilter(RingSet const *src, RingSet *dest,
              int (*predicate)(void *arg, RingIterator *iter,
                               union RingObject *object, unsigned level),
              void *arg);
int  ringSetFilterSpec(RingSet const *src,
	RingSet *dest, char const *string, int use);

union RingObject  *
ringLatestSecret(RingSet const *set, char const *string, PGPUInt32 tstamp,
	int use);


/* Object access functions */

PgpTrustModel  pgpTrustModel(RingPool const *pool);
int  ringKeyError(RingSet const *set, union RingObject *key);
unsigned  ringKeyBits(RingSet const *set,
	union RingObject *key);
PGPUInt32  ringKeyCreation(RingSet const *set,
	union RingObject *key);
PGPUInt32  ringKeyExpiration(RingSet const *set,
	union RingObject *key);
void  ringKeyID4(RingSet const *set,
	union RingObject const *key, PGPByte *pkalg, PGPKeyID *keyID);
void  ringKeyID8(RingSet const *set,
	union RingObject const *key, PGPByte *pkalg, PGPKeyID *keyID);
PGPBoolean ringKeyV3(RingSet const *set, union RingObject const *key);
int  ringKeyUseInternal(RingSet const *set, union RingObject *key,
	PGPBoolean unExpired);
#define ringKeyUse(s,k)					ringKeyUseInternal(s,k,FALSE)
#define ringKeyUnexpiredUse(s,k)		ringKeyUseInternal(s,k,TRUE)
PGPByte  ringKeyTrust(RingSet const *set, union RingObject *key);
void  ringKeySetTrust(RingSet const *set,
	union RingObject *key, PGPByte trust);
int  ringKeyDisabled(RingSet const *set,
	union RingObject *key);
void  ringKeyDisable(RingSet const *set,
	union RingObject *key);
void  ringKeyEnable(RingSet const *set,
	union RingObject *key);
int  ringKeyRevoked(RingSet const *set,
	union RingObject *key);
void  ringKeySetAxiomatic(RingSet const *set,
	union RingObject *key);
void  ringKeyResetAxiomatic(RingSet const *set,
	union RingObject *key);
int  ringKeyAxiomatic(RingSet const *set,
	union RingObject *key);
int  ringKeyIsSubkey(RingSet const *set,
	union RingObject const *key);

int  ringKeyFingerprint16(RingSet const *set,
	union RingObject *key, PGPByte *buf);
int  ringKeyFingerprint20(RingSet const *set,
	union RingObject *key, PGPByte *buf);
int  ringKeyFingerprint20n(RingSet const *set,
	union RingObject *key, PGPByte *buf);
int  ringKeyAddSigsby(RingSet const *set,
	union RingObject *key, RingSet *dest);

/* Given a Ring Object, obtain a PGPPubKey or a PGPSecKey */
int  ringKeyIsSec(RingSet const *set, union RingObject *key);
int  ringKeyIsSecOnly(RingSet const *set,
				union RingObject *key);
union RingObject  *ringKeySubkey(RingSet const *set,
				union RingObject const *key);
union RingObject  *ringKeyMasterkey(RingSet const *set,
				union RingObject const *subkey);
PGPPubKey  *ringKeyPubKey(RingSet const *set,
				union RingObject *key, int use);
PGPSecKey  *ringSecSecKey(RingSet const *set,
				union RingObject *sec, int use);
union RingObject *ringBestSec(RingSet const *set,
	union RingObject const *key);
PgpVersion  ringSecVersion (RingSet const *set,
				union RingObject *sec);

RingObject *ringLatestSigByKey (RingObject const *obj, RingSet const *set,
	RingObject const *key);

char const  *ringNameName(RingSet const *set,
	union RingObject *name, PGPSize *lenp);
PGPBoolean ringNameIsAttribute(RingSet const *set, union RingObject *name);
PGPUInt32 ringNameCountAttributes(RingSet const *set, union RingObject *name);
PGPByte const *ringNameAttributeSubpacket(RingObject *name, RingSet const *set,
	PGPUInt32 nth, PGPUInt32 *subpacktype, PGPSize *plen, PGPError *error);
RingObject * ringKeyPrimaryName (RingObject *key, RingSet const *set,
	PGPUInt32 type);
PGPByte  ringNameTrust(RingSet const *set,
	union RingObject *name);
int  ringNameWarnonly(RingSet const *set,
	union RingObject *name);
void  ringNameSetWarnonly(RingSet const *set,
	union RingObject *name);

int  ringSigError(RingSet const *set, union RingObject *sig);
union RingObject  *ringSigMaker(RingSet const *sset,
	union RingObject *sig, RingSet const *kset);
void  ringSigID8(RingSet const *set,
	union RingObject const *sig, PGPByte *pkalg, PGPKeyID *buf);
PGPByte  ringSigTrust(RingSet const *set, union RingObject *sig);
PGPByte  ringSigTrustLevel(RingSet const *set, union RingObject const *sig);
PGPByte  ringSigTrustValue(RingSet const *set, union RingObject const *sig);
int  ringSigChecked(RingSet const *set, union RingObject const *sig);
int  ringSigTried(RingSet const *set, union RingObject const *sig);
int  ringSigType(RingSet const *Set, union RingObject const *sig);
PGPUInt32  ringSigTimestamp(RingSet const *Set, union RingObject const *sig);
PGPUInt32  ringSigExpiration(RingSet const *set, union RingObject const *sig);
int  ringSigRevoked (RingSet const *set, union RingObject *sig);
int	ringSigExportable (RingSet const *set, union RingObject const *sig);
PGPBoolean ringSigIsSelfSig(RingSet const *set, RingObject const *sig);
PGPBoolean ringSigIsX509(RingSet const *set, RingObject const *sig);
PGPByte *ringSigX509Certificate(RingSet const *set, RingObject *sig,
   PGPSize *len);

int ringCRLChecked(RingSet const *set, union RingObject const *crl);
int ringCRLTried(RingSet const *set, union RingObject const *crl);
PGPUInt32 ringCRLCreation(RingSet const *set, union RingObject const *crl);
PGPUInt32 ringCRLExpiration(RingSet const *set, union RingObject const *crl);
PGPBoolean ringCRLIsCurrent (RingSet const *set, RingObject *crl,
	PGPUInt32 tstamp);
RingObject * ringKeyEarliestCRL(RingSet const *set, RingObject *key,
	PGPBoolean expiration);
RingObject * ringKeyNthCRL(RingSet const *set, RingObject *key, PGPUInt32 n,
	PGPUInt32 *crlcount);
PGPBoolean ringKeyHasCRL(RingSet const *set, RingObject *key);
PGPByte const * ringCRLDistributionPoint( RingSet const *set, RingObject *crl,
	PGPSize *len );
PGPError ringListCRLDistributionPoints(PGPMemoryMgrRef mgr, RingObject *key,
	RingSet const *set, PGPUInt32 *pnDistPoints, PGPByte **pbuf,
	PGPSize **pbufsizes);


/* Only valid if PgpTrustModel > PGPTRUST0 */
PGPUInt16  ringKeyConfidence(RingSet const *set,
	union RingObject *key);
PGPUInt16  ringNameValidity(RingSet const *set,
	union RingObject *name);
PGPUInt16  ringNameConfidence(RingSet const *set,
	union RingObject *name);
int  ringNameConfidenceUndefined(RingSet const *set, 
				union RingObject *name);
void  ringNameSetConfidence(RingSet const *set, 
			     union RingObject *name, PGPUInt16 confidence);
PGPUInt16  ringSigConfidence(RingSet const *set,
	union RingObject *sig);

PGPByte const  *
ringKeyFindSubpacket (RingObject *obj, RingSet const *set,
	int subpacktype, unsigned nth,
	PGPSize *plen, int *pcritical, int *phashed, PGPUInt32 *pcreation,
	unsigned *pmatches, PGPError *error);
union RingObject  *
ringKeyAdditionalRecipientRequestKey (RingObject *obj, RingSet const *set,
					unsigned nth, PGPByte *pkalg, PGPKeyID *keyid,
					PGPByte *pclass, unsigned *pkeys, PGPError *error);
union RingObject  *
ringKeyRevocationKey (union RingObject *obj, RingSet const *set, unsigned nth,
					PGPByte *pkalg, PGPKeyID *keyid,
					PGPByte *pclass, unsigned *pkeys, PGPError *error);
PGPBoolean
ringKeyIsRevocationKey (RingObject *key, RingSet const *set,
					RingObject *rkey);
PGPBoolean
ringKeyHasThirdPartyRevocation (RingObject *obj, RingSet const *set,
					RingObject **revkey, PGPByte *pkalg, PGPKeyID *keyid,
					PGPError *error);
PGPSigSpec *
ringSigSigSpec (RingObject *sig, RingSet const *set,
					PGPError *error);

PGPBoolean
ringSetHasExpiringObjects( RingSet const *set, PGPTime time1, PGPTime time2 );

void ringPoolConsistent (RingPool *pool, int *pnsets,
	int *pnfiles);


PGP_END_C_DECLARATIONS

#endif /* Included_pgpRngPub_h */