pgpevent.c

vc环境下的pgp源码

				*cur = '_';
		#endif
		
			while( *cur != 0 )
			{
			#if PGP_MACINTOSH
				if( *cur < ' ' || *cur == ':' )
			#elif PGP_WIN32 || PGP_UNIX
				if ((*cur < ' ')  || (*cur == ':') || (*cur == '/') || 
					(*cur == '?') || (*cur == '*') || (*cur == '"') || 
					(*cur == '>') || (*cur == '\\') || (*cur == '|') || 
					(*cur == 0x5C) )	/* \ */
			#else
				#error Unknown platform
			#endif
				{
					*cur = '_';
				}
				
				++cur;
			}
		}
	}
	
	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_OutputEvent;
	event.data.outputData.messageType			= messageType;
	event.data.outputData.suggestedName			= canonicalName;
	event.data.outputData.forYourEyesOnly		= FYEO;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	
	if( IsntNull( canonicalName ) )
		PGPFreeData( canonicalName );
		
	return err;
}

	PGPError
pgpEventSignature(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPKeyID const *	signingKeyID,
	PGPKeyRef			signingKey,
	PGPBoolean			checked,
	PGPBoolean			verified,
	PGPBoolean			keyDisabled,
	PGPBoolean			keyRevoked,
	PGPBoolean			keyExpired,
	PGPBoolean			keyValidityThreshold,
	PGPValidity			keyValidity,
	PGPTime				creationTime
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_SignatureEvent;
	event.data.signatureData.signingKeyID		= *signingKeyID;
	event.data.signatureData.signingKey			= signingKey;
	event.data.signatureData.checked			= checked;
	event.data.signatureData.verified			= verified;
	event.data.signatureData.keyDisabled		= keyDisabled;
	event.data.signatureData.keyRevoked			= keyRevoked;
	event.data.signatureData.keyExpired			= keyExpired;
	event.data.signatureData.keyMeetsValidityThreshold = keyValidityThreshold;
	event.data.signatureData.keyValidity		= keyValidity;
	event.data.signatureData.creationTime		= creationTime;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}


	PGPError
pgpEventDecryption(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPCipherAlgorithm	cipheralg,
	PGPByte				*key,
	PGPSize				keylen
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_DecryptionEvent;
	event.data.decryptionData.cipherAlgorithm	= cipheralg;
	event.data.decryptionData.sessionKey		= key;
	event.data.decryptionData.sessionKeyLength	= keylen;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}


	PGPError
pgpEventEncryption(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPCipherAlgorithm	cipheralg,
	PGPByte				*key,
	PGPSize				keylen
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_EncryptionEvent;
	event.data.encryptionData.cipherAlgorithm	= cipheralg;
	event.data.encryptionData.sessionKey		= key;
	event.data.encryptionData.sessionKeyLength	= keylen;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}


	PGPError
pgpEventBeginLex(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPUInt32			sectionNumber,
	PGPSize				sectionOffset
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job								= &job;
	event.type								= kPGPEvent_BeginLexEvent;
	event.data.beginLexData.sectionNumber	= sectionNumber;
	event.data.beginLexData.sectionOffset	= sectionOffset;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}

	PGPError
pgpEventEndLex(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPUInt32			sectionNumber
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job								= &job;
	event.type								= kPGPEvent_EndLexEvent;
	event.data.endLexData.sectionNumber		= sectionNumber;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}

	PGPError
pgpEventDetachedSignature(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job							= &job;
	event.type							= kPGPEvent_DetachedSignatureEvent;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}

	PGPError
pgpEventKeyGen(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPUInt32			state
	)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_KeyGenEvent;
	event.data.keyGenData.state					= state;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}

	PGPError
pgpEventKeyServer(
	PGPContextRef		context,
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPKeyServerRef		keyServerRef,
	PGPUInt32			state)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_KeyServerEvent;
	event.data.keyServerData.state				= state;
	event.data.keyServerData.keyServerRef		= keyServerRef;

	err = func( context, &event, userValue );

	return err;
}

	PGPError
pgpEventKeyServerSign(
	PGPContextRef		context,
	PGPOptionListRef   *newOptionList,	/* Output parameter */
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPKeyServerRef		keyServerRef)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	*newOptionList = NULL;
	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_KeyServerSignEvent;
	event.data.keyServerSignData.keyServerRef	= keyServerRef;

	err = func( context, &event, userValue );

	*newOptionList = job.newOptionList;
	return err;
}



	PGPError
pgpEventKeyServerTLS(
	PGPContextRef		context,
	PGPEventHandlerProcPtr func,
	PGPUserValue		userValue,
	PGPKeyServerRef		keyServerRef,
	PGPUInt32			state,
	PGPtlsSessionRef	tlsSession)
{
	PGPJob				job;
	PGPEvent			event;
	PGPError			err;

	if( IsNull( func ) )
		return kPGPError_NoErr;

	job.context			= context;
	job.newOptionList	= NULL;

	pgpClearMemory( &event, sizeof( event ) );
	event.job									= &job;
	event.type									= kPGPEvent_KeyServerTLSEvent;
	event.data.keyServerTLSData.state			= state;
	event.data.keyServerTLSData.keyServerRef	= keyServerRef;
	event.data.keyServerTLSData.tlsSession		= tlsSession;

	err = func( context, &event, userValue );

	return err;
}

/*__Editor_settings____

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