pgprpckeyback.c

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

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

	PGPError
pgpPassphraseIsValid_backRPC(
	PGPContextRef	context,
	PGPUInt32		key_id,
	const char *	passphrase,
	PGPSize			passphraseLength,
	PGPBoolean		hashedPhrase,
	PGPUInt32		cacheTimeOut,
	PGPBoolean		cacheGlobal,
	PGPBoolean *	isValid)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_PassphraseIsValid_MSG, connect_ref);
	pack_uint32(&pkt, key_id);
	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)) {
		*isValid = unpack_bool(&rplypkt);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpSetKeyTrust_backRPC(
	PGPContextRef	context,
	PGPUInt32		key_id,
	PGPUInt32		trust)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_SetKeyTrust_MSG, connect_ref);
	pack_uint32(&pkt, key_id);
	pack_uint32(&pkt, trust);

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

	PGPError
pgpGetPasskeyBuffer_backRPC (
	PGPContextRef		context,
	PGPUInt32			key_id,
	char const *		passphrase,
	PGPSize				passphraseLength,
	PGPByte				**passkeyBuffer,
	PGPSize				*passkeyBufferLength
	)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_GetPasskeyBuffer_MSG, connect_ref);
	pack_uint32(&pkt, key_id);
	pack_opaque(&pkt, (void *)passphrase, passphraseLength);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		unpack_opaque_secure(&rplypkt, (void **)passkeyBuffer, passkeyBufferLength);
		PGPFreeData(rplypkt.base);
	}
	return status;
}


	PGPError
pgpAddKeyOptions_backRPC (PGPContextRef context, PGPUInt32 key_id,
	char const * passphrase, PGPSize passphraseLength, PGPBoolean hashedPhrase,
	PGPUInt32 cacheTimeOut, PGPBoolean cacheGlobal,
	PGPUInt32 *raklist, PGPSize raklistsize, PGPUInt32 rakclass,
	PGPUInt32 **newobjs, PGPSize *newobjslength)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_AddKeyOptions_MSG, connect_ref);
	pack_uint32(&pkt, key_id);
	pack_opaque(&pkt, passphrase, passphraseLength);
	pack_bool(&pkt, hashedPhrase);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);
	pack_opaque(&pkt, raklist, raklistsize);
	pack_uint32(&pkt, rakclass);

	if (raklist) PGPFreeData(raklist);

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


	PGPError
pgpUpdateKeyOptions_backRPC (
	PGPContextRef	   context,
	PGPUInt32		   key_id,
	char const *	   passphrase,
	PGPSize			   passphraseLength,
	PGPBoolean		   hashedPhrase,
	PGPUInt32			cacheTimeOut,
	PGPBoolean			cacheGlobal,
	PGPCipherAlgorithm const	*prefalg,
	PGPSize				prefalgLength,
	PGPByte const		*prefkeyserv,
	PGPSize				prefkeyservLength,
	PGPUInt32			keyflags,
	PGPBoolean			fkeyflags,
	PGPUInt32			keyservprefs,
	PGPBoolean			fkeyservprefs,
	PGPUInt32 **		newobjs,
	PGPSize *			newobjslength
	)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init_secure(&pkt, kPGP_UpdateKeyOptions_MSG, connect_ref);
	pack_uint32(&pkt, key_id);
	pack_opaque(&pkt, passphrase, passphraseLength);
	pack_bool(&pkt, hashedPhrase);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);
	pack_opaque(&pkt, prefalg, prefalgLength);
	pack_opaque(&pkt, prefkeyserv, prefkeyservLength);
	pack_uint32(&pkt, keyflags);
	pack_bool(&pkt, fkeyflags);
	pack_uint32(&pkt, keyservprefs);
	pack_bool(&pkt, fkeyservprefs);

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

	PGPError
pgpKeyDBAddObject_backRPC( PGPContextRef context, PGPUInt32 kdb_id,
	PGPUInt32 obj_id, PGPUInt32 **newobjs, PGPSize *newobjslength,
	PGPUInt32 *pnewobj )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_KeyDBAddObject_MSG, connect_ref);
	pack_uint32(&pkt, kdb_id);
	pack_uint32(&pkt, obj_id);

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


	PGPError
pgpKeyDBRemoveObject_backRPC( PGPContextRef context, PGPUInt32 kdb_id,
	PGPUInt32 obj_id )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_KeyDBRemoveObject_MSG, connect_ref);
	pack_uint32(&pkt, kdb_id);
	pack_uint32(&pkt, obj_id);
	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpCopyKeys_backRPC( PGPContextRef context, PGPUInt32 srcid,
	PGPUInt32 dstid, PGPUInt32 *keylist, PGPSize keylistsize,
	PGPBoolean neednewkeylist, PGPUInt32 **newkeylist, PGPSize *newkeylistsize)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_CopyKeys_MSG, connect_ref);
	pack_uint32(&pkt, srcid);
	pack_uint32(&pkt, dstid);
	pack_opaque(&pkt, keylist, keylistsize);
	pack_bool(&pkt, neednewkeylist);

	if (keylist) PGPFreeData(keylist);

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


	PGPError
pgpKeyDBArray_backRPC(
	PGPContextRef cdkContext,
	PGPUInt32 kdbid,
	PGPUInt32 * numKeys,
	PGPUInt32 ** keyArray,
	PGPSize * keyArraySize )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	pack_init(&pkt, kPGP_KeyDBArray_MSG, connect_ref);
	pack_uint32(&pkt, kdbid);

	(void) cdkContext;

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

	PGPError
pgpUpdateKeyDB_backRPC(
	PGPContextRef cdkContext,
	PGPUInt32 kdbid,
	PGPUInt32 * numNewKeys,
	PGPUInt32 ** newKeyArray,
	PGPSize * newKeyArraySize,
	PGPUInt32 **changedkeylist,
	PGPSize *changedkeylistsize )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	pack_init(&pkt, kPGP_UpdateKeyDB_MSG, connect_ref);
	pack_uint32(&pkt, kdbid);

	(void) cdkContext;

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

	PGPError
pgpNewKeyDB_backRPC( PGPContextRef context, PGPUInt32 *keydbid )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_NewKeyDB_MSG, connect_ref);
	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		*keydbid = unpack_uint32(&rplypkt);
		PGPFreeData(rplypkt.base);
	}
	return status;
}

	PGPError
pgpCertifyPrimaryUserID_backRPC (PGPContextRef ctxt,
		PGPUInt32 useridid, char const *passphrase,
		PGPSize passphraseLength, PGPBoolean hashedPhrase,
		PGPUInt32	cacheTimeOut,
		PGPBoolean	cacheGlobal,
		PGPUInt32 **newobjs, PGPSize *newobjsLength)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)ctxt;
	pack_init_secure(&pkt, kPGP_CertifyPrimaryUserID_MSG, connect_ref);
	pack_uint32(&pkt, useridid);
	pack_opaque(&pkt, passphrase, passphraseLength);
	pack_bool(&pkt, hashedPhrase);
	pack_uint32(&pkt, cacheTimeOut);
	pack_bool(&pkt, cacheGlobal);

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

	PGPError
pgpGlobalRandomPoolAddState_backRPC( PGPBoolean addKeyState,
		PGPInt32 keyEvent, PGPBoolean addMouseState, PGPBoolean addSystemState )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	pack_init(&pkt, kPGP_GlobalRandomPoolAddState_MSG, connect_ref);
	pack_bool(&pkt, addKeyState);
	pack_int32(&pkt, keyEvent);
	pack_bool(&pkt, addMouseState);
	pack_bool(&pkt, addSystemState);

	status = pgpRPCSendPacket(&pkt, &rplypkt, FALSE);  /* okayToBlock == FALSE */
	if (IsntPGPError(status)) {
		PGPFreeData(rplypkt.base);
	}
	return status;
}

PGPError
pgpGlobalRandomPoolGetInfo_backRPC( PGPUInt32 *entropy, PGPUInt32 *size,
		PGPUInt32 *minEntropy, PGPBoolean *hasMinEntropy,
		PGPBoolean *hasIntelRNG )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	pack_init(&pkt, kPGP_GlobalRandomPoolGetInfo_MSG, connect_ref);

	status = pgpRPCSendPacket(&pkt, &rplypkt, TRUE);
	if (IsntPGPError(status)) {
		PGPUInt32 ui; PGPBoolean b;
		ui = unpack_uint32(&rplypkt);
		if (entropy) *entropy = ui;

		ui = unpack_uint32(&rplypkt);
		if (size) *size = ui;

		ui = unpack_uint32(&rplypkt);
		if (minEntropy) *minEntropy = ui;

		b = unpack_bool(&rplypkt);
		if (hasMinEntropy) *hasMinEntropy = b;

		b = unpack_bool(&rplypkt);
		if (hasIntelRNG) *hasIntelRNG = b;

		PGPFreeData(rplypkt.base);
	}
	return status;
}

PGPError
pgpRandomGetBytesEntropy_backRPC( PGPContextRef context,
		PGPUInt32 requestBytes, PGPUInt32 entropyBits,
		PGPByte **randBuf, PGPSize *randBufLen )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_RandomGetBytesEntropy_MSG, connect_ref);
	pack_uint32(&pkt, requestBytes);
	pack_uint32(&pkt, entropyBits);

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

PGPError
pgpRandomAddBytes_backRPC( PGPContextRef context,
		PGPByte const *buf, PGPSize buflen )
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	(void)context;
	pack_init(&pkt, kPGP_RandomAddBytes_MSG, connect_ref);
	pack_opaque(&pkt, buf, buflen);

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

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

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

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

	PGPError
pgpSetRandSeedFile_backRPC(
	PFLFileSpecRef randFile)
{
	PGPInt32 status;
	PGPPackMsg pkt, rplypkt;

	pack_init(&pkt, kPGP_SetRandSeedFile_MSG, connect_ref);
	pack_filespec(&pkt, randFile);

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


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