pgprpckeyback.c

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

	pack_opaque(&pkt, buffer, length);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		*kdbid = unpack_uint32(&rplypkt);
		*numKeys = unpack_uint32(&rplypkt);
		unpack_opaque_alloc(&rplypkt, (void **)keyArray, keyArraySize);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpKeyDBFlush_backRPC( PGPContextRef context, PGPUInt32 id,
	PGPUInt32 **changedkeylist, PGPSize *changedkeylistsize )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_KeyDBFlush_MSG, connect_ref);
	pack_int32(&pkt, id);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_alloc(&rplypkt, (void **)changedkeylist, changedkeylistsize);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	void
pgpFreeKeyDB_backRPC( PGPContextRef context, PGPUInt32 id )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_FreeKeyDB_MSG, connect_ref);
	pack_int32(&pkt, id);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status))
		PGPFreeData(rplypkt.base);
	return;
}

	PGPError
pgpCacheKeyDB_backRPC( PGPContextRef context, PGPUInt32 id,
	PGPUInt32 timeoutSeconds )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_CacheKeyDB_MSG, connect_ref);
	pack_int32(&pkt, id);
	pack_int32(&pkt, timeoutSeconds);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status))
		PGPFreeData(rplypkt.base);
	return status;
}

	PGPError
pgpPurgeKeyDBCache_backRPC( PGPContextRef context )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_PurgeKeyDBCache_MSG, connect_ref);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status))
		PGPFreeData(rplypkt.base);
	return status;
}


	PGPError
pgpSetKeyEnabled_backRPC( PGPContextRef context, PGPUInt32 id, PGPBoolean enable  )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_SetKeyEnabled_MSG, connect_ref);
	pack_int32(&pkt, id);
	pack_bool(&pkt, enable);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status))
		PGPFreeData(rplypkt.base);
	return status;
}

	PGPError
pgpSetKeyAxiomatic_backRPC(
	PGPContextRef	context,
	PGPUInt32		id,
	PGPBoolean		setAxiomatic,
	PGPBoolean		checkPassphrase,
	char const *	passphrase,
	PGPSize			passphraseLength,
	PGPBoolean		hashedPhrase,
	PGPUInt32		cacheTimeOut,
	PGPBoolean		cacheGlobal)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_SetKeyAxiomatic_MSG, connect_ref);
	pack_int32(&pkt, id);
	pack_bool(&pkt, setAxiomatic);
	pack_bool(&pkt, checkPassphrase);
	pack_opaque(&pkt, (void *)passphrase, passphraseLength);
	pack_bool(&pkt, hashedPhrase);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status))
		PGPFreeData(rplypkt.base);
	return status;
}

	PGPError
pgpPropagateTrust_backRPC( PGPContextRef context, PGPUInt32 setid,
	PGPUInt32 *keylist, PGPSize keylistsize, PGPUInt32 altid,
	PGPUInt32 const timenow, PGPUInt32 **changedkeylist,
	PGPSize *changedkeylistsize )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_PropagateTrust_MSG, connect_ref);
	pack_uint32(&pkt, setid);
	pack_opaque(&pkt, keylist, keylistsize);
	pack_uint32(&pkt, altid);
	pack_uint32(&pkt, timenow);

	if (keylist) PGPFreeData(keylist);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_alloc(&rplypkt, (void **)changedkeylist, changedkeylistsize);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpCheckKeyRingSigs_backRPC( PGPContextRef context, PGPUInt32 setid,
	PGPUInt32 *keylist, PGPSize keylistsize, PGPUInt32 altid,
	PGPBoolean checkAll, PGPUInt32 **changedkeylist,
	PGPSize *changedkeylistsize )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_CheckKeyRingSigs_MSG, connect_ref);
	pack_uint32(&pkt, setid);
	pack_opaque(&pkt, keylist, keylistsize);
	pack_uint32(&pkt, altid);
	pack_bool(&pkt, checkAll);

	if (keylist) PGPFreeData(keylist);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_alloc(&rplypkt, (void **)changedkeylist, changedkeylistsize);
		PGPFreeData(rplypkt.base);
	}
	return status;
}


	PGPError
pgpPrepareToCheckKeyRingSigs_backRPC( PGPContextRef context, PGPUInt32 setid,
	PGPUInt32 *keylist, PGPSize keylistsize, PGPUInt32 altid,
	PGPBoolean checkAll, PGPUInt32 *nsigs, PGPUInt32 **changedkeylist,
	PGPSize *changedkeylistsize )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_PrepareToCheckKeyRingSigs_MSG, connect_ref);
	pack_uint32(&pkt, setid);
	pack_opaque(&pkt, keylist, keylistsize);
	pack_uint32(&pkt, altid);
	pack_bool(&pkt, checkAll);

	if (keylist) PGPFreeData(keylist);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		*nsigs = unpack_uint32(&rplypkt);
		unpack_opaque_alloc(&rplypkt, (void **)changedkeylist, changedkeylistsize);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpCheckSig_backRPC( PGPContextRef context, PGPUInt32 setid, PGPUInt32 objid,
	PGPUInt32 altid, PGPBoolean checkAll, PGPBoolean revocationonly,
	PGPBoolean *handled, PGPBoolean *changed, PGPBoolean *verified )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_CheckSig_MSG, connect_ref);
	pack_uint32(&pkt, setid);
	pack_uint32(&pkt, objid);
	pack_uint32(&pkt, altid);
	pack_bool(&pkt, checkAll);
	pack_bool(&pkt, revocationonly);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		*handled = unpack_bool(&rplypkt);
		*changed = unpack_bool(&rplypkt);
		*verified = unpack_bool(&rplypkt);
		PGPFreeData(rplypkt.base);
	}
	return status;
}


	PGPError
pgpDoGenerateKey_backRPC (
	PGPContextRef	context,
	PGPUInt32		keydbID,
	PGPUInt32		masterkeyID,
	PGPByte			pkalg,
	PGPUInt32		bits,
	PGPTime			creationDate,
	PGPUInt16		expirationDays,
	char const *	name,
	PGPSize			name_len, 
	char const *	passphrase,
	PGPSize			passphraseLength,
	PGPBoolean		passphraseIsKey,
	char const *	masterpass, 
	PGPSize			masterpassLength,
	PGPUInt32		cacheTimeOut,
	PGPBoolean		cacheGlobal,
	PGPEventHandlerProcPtr progress,
	PGPUserValue	userValue,
	PGPBoolean		fastgen,
	PGPBoolean		checkentropy,
	PGPBoolean		usetoken,
	PGPUInt32		tokenid,
	PGPUInt32 *		adkkeylist,
	PGPSize			adkkeylistsize,
	PGPByte			adkclass,
	PGPUInt32 *		rakkeylist,
	PGPSize			rakkeylistsize,
	PGPByte			rakclass,
	PGPCipherAlgorithm const * prefalg,
	PGPSize			prefalgLength,
	PGPByte const * prefkeyserv,
	PGPSize prefkeyservLength,
	PGPUInt32 keyflags,
	PGPBoolean fkeyflags,
	PGPUInt32 keyservprefs,
	PGPBoolean fkeyservprefs,
	PGPUInt32 **	newobjs,
	PGPSize *		newobjslength,
	PGPUInt32 *		newKey)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_DoGenerateKey_MSG, connect_ref);
	pack_uint32(&pkt, keydbID);
	pack_uint32(&pkt, masterkeyID);
	pack_int32(&pkt, pkalg);
	pack_uint32(&pkt, bits);
	pack_uint32(&pkt, creationDate);
	pack_uint32(&pkt, expirationDays);
	pack_opaque(&pkt, (void *)name, name_len);
	pack_opaque(&pkt, (void *)passphrase, passphraseLength);
	pack_bool(&pkt, passphraseIsKey);
	pack_opaque(&pkt, (void *)masterpass, masterpassLength);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);
	pack_uint32(&pkt, (PGPUInt32)progress);
	pack_uint32(&pkt, (PGPUInt32)userValue);
	pack_bool(&pkt, fastgen);
	pack_bool(&pkt, checkentropy);
	pack_bool(&pkt, usetoken);
	pack_uint32(&pkt, tokenid);
	pack_opaque(&pkt, adkkeylist, adkkeylistsize);
	pack_byte(&pkt, adkclass);
	pack_opaque(&pkt, rakkeylist, rakkeylistsize);
	pack_byte(&pkt, rakclass);
	pack_opaque(&pkt, (void *)prefalg, prefalgLength);
	pack_opaque(&pkt, prefkeyserv, prefkeyservLength);
	pack_uint32(&pkt, keyflags);
	pack_bool(&pkt, fkeyflags);
	pack_uint32(&pkt, keyservprefs);
	pack_bool(&pkt, fkeyservprefs);

	if (adkkeylist) PGPFreeData(adkkeylist);
	if (rakkeylist) PGPFreeData(rakkeylist);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_alloc(&rplypkt, (void *)newobjs, newobjslength);
		*newKey = unpack_uint32(&rplypkt);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpCreateKeypair_backRPC (
	PGPContextRef	context,
	PGPUInt32		keydbID,
	PGPByte *		seckeyBuf,
	PGPSize			seckeySize,
	PGPByte *		keyspecBuf,
	PGPSize			keyspecSize,
	char const *	name,
	PGPSize			name_len, 
	PGPUInt32 *		adklist,
	PGPSize			adklistsize,
	PGPByte			adkclass,
	PGPUInt32 *		raklist,
	PGPSize			raklistsize,
	PGPByte			rakclass,
	char const *	passphrase,
	PGPSize			passphraseLength,
	PGPBoolean		passphraseIsKey,
	PGPUInt32		cacheTimeOut,
	PGPBoolean		cacheGlobal,
	PGPUInt32 **	newobjs,
	PGPSize *		newobjslength,
	PGPUInt32 *		newkeyid )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_CreateKeypair_MSG, connect_ref);
	pack_uint32(&pkt, keydbID);
	pack_opaque(&pkt, (void *)seckeyBuf, seckeySize);
	pack_opaque(&pkt, (void *)keyspecBuf, keyspecSize);
	pack_opaque(&pkt, (void *)name, name_len);
	pack_opaque(&pkt, adklist, adklistsize);
	pack_byte(&pkt, adkclass);
	pack_opaque(&pkt, raklist, raklistsize);
	pack_byte(&pkt, rakclass);
	pack_opaque(&pkt, (void *)passphrase, passphraseLength);
	pack_bool(&pkt, passphraseIsKey);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);

	if (adklist) PGPFreeData(adklist);
	if (raklist) PGPFreeData(raklist);
	if (keyspecBuf) PGPFreeData(keyspecBuf);
	if (seckeyBuf) PGPFreeData(seckeyBuf);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_alloc(&rplypkt, (void *)newobjs, newobjslength);
		*newkeyid = unpack_uint32(&rplypkt);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpCreateSubkeypair_backRPC (
	PGPContextRef	context,
	PGPUInt32		masterkeyID,
	PGPByte *		seckeyBuf,
	PGPSize			seckeySize,
	PGPByte *		keyspecBuf,
	PGPSize			keyspecSize,
	char const *	passphrase,
	PGPSize			passphraseLength,
	PGPBoolean		passphraseIsKey,
	PGPUInt32		cacheTimeOut,
	PGPBoolean		cacheGlobal,
	PGPUInt32 **	newobjs,
	PGPSize *		newobjslength,
	PGPUInt32 *		newkeyid )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_CreateSubkeypair_MSG, connect_ref);
	pack_uint32(&pkt, masterkeyID);
	pack_opaque(&pkt, (void *)seckeyBuf, seckeySize);
	pack_opaque(&pkt, (void *)keyspecBuf, keyspecSize);
	pack_opaque(&pkt, (void *)passphrase, passphraseLength);
	pack_bool(&pkt, passphraseIsKey);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);

	if (keyspecBuf) PGPFreeData(keyspecBuf);
	if (seckeyBuf) PGPFreeData(seckeyBuf);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_alloc(&rplypkt, (void *)newobjs, newobjslength);
		*newkeyid = unpack_uint32(&rplypkt);
		PGPFreeData(rplypkt.base);
	}
	return status;
}


PGPBoolean enable_checking = FALSE;

	PGPError
pgpCountTokens_backRPC (
	PGPContextRef	context,
	PGPUInt32 *		numTokens
	)

{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;


	pack_init_secure(&pkt, kPGP_CountTokens_MSG, connect_ref);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		*numTokens = unpack_uint32(&rplypkt);
		PGPFreeData(rplypkt.base);
	}


	return status;
}


   	PGPError
pgpGetTokenInfo_backRPC (
	PGPContextRef	context,
    PGPUInt32  tokNumber, PGPTokenInfo *info )

{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;
    PGPUInt32 client_size = info->size;   /* sizeof(PGPTokenInfo) for client */

	(void)context;