pgpoptionlist.c

vc环境下的pgp源码

					break;
				case 'p':
					ptrPtr = va_arg( args, void ** );
					*ptrPtr = *( ( void ** ) ptr );
					ptr += sizeof( void * );
					break;
				case 't':
					ptrTimeInterval = va_arg( args, PGPTimeInterval * );
					*ptrTimeInterval = *( ( PGPTimeInterval * ) ptr );
					ptr += sizeof( PGPTimeInterval );
					break;
				case 'T':
					ptrTime = va_arg( args, PGPTime * );
					*ptrTime = *( ( PGPTime * ) ptr );
					ptr += sizeof( PGPTime );
					break;
				case 'f':
					ptrFileSpec = va_arg( args, PFLFileSpecRef * );
					*ptrFileSpec = *( ( PFLFileSpecRef * ) ptr );
					ptr += sizeof( PFLFileSpecRef );
					break;
				default:
					err = kPGPError_BadParams;
					goto error;
				}
			}
			va_end( args );
		}
	} else {
		/* Missing op, fill in parameters */
		ptr = ( PGPByte * ) op.value.asPtr;
		while( *str++ == '%' ) {
			switch( *str++ ) {
			case 'd':
				ptrInt32 = va_arg( args, PGPInt32 * );
				*ptrInt32 = (PGPInt32) 0;
				break;
			case 'l':
				ptrSize = va_arg( args, PGPSize * );
				*ptrSize = (PGPSize) 0;
				break;
			case 'p':
				ptrPtr = va_arg( args, void ** );
				*ptrPtr = NULL;
				break;
			case 't':
				ptrTimeInterval = va_arg( args, PGPTimeInterval * );
				*ptrTimeInterval = (PGPTimeInterval) 0;
				break;
			case 'T':
				ptrTime = va_arg( args, PGPTime * );
				*ptrTime = (PGPTime) 0;
				break;
			case 'f':
				ptrFileSpec = va_arg( args, PFLFileSpecRef * );
				*ptrFileSpec = kInvalidPFLFileSpecRef;
				break;
			default:
				err = kPGPError_BadParams;
				goto error;
			}
		}
		if( fMandatory ) {
		
			pgpDebugFmtMsg(( pgpaFmtPrefix,
				"Error: Missing required PGPO option #%ld",
				(long)optionType ));

			err = kPGPError_OptionNotFound;
			goto error;
		}
	}
	return kPGPError_NoErr;
error:
	return err;
}


/* Delete option list and null out the pointer to it */

	void
pgpCleanupOptionList(PGPOptionListRef *optionList)
{
	/* XXX check to make sure we have no critical unused options */
	if( IsntNull( *optionList ) ) {
		pgpFreeOptionList( *optionList );
		*optionList = NULL;
	}
}

/********************* Access functions for option data *********************/


	PGPError
pgpOptionInt(
	PGPOption			*op,
	PGPInt32			*pInt
	)			 
{
	*pInt = op->value.asInt;
	return kPGPError_NoErr;
}

	PGPError
pgpOptionUInt(
	PGPOption			*op,
	PGPUInt32			*pUInt
	)			 
{
	*pUInt = op->value.asInt;
	return kPGPError_NoErr;
}

	PGPError
pgpOptionPtr(
	PGPOption			 *op,
	void				**pPtr
	)			 
{
	*pPtr = op->value.asPtr;
	return kPGPError_NoErr;
}

	PGPError
pgpOptionInterval(
	PGPOption			*op,
	PGPTimeInterval		*pInterval
	)			 
{
	*pInterval = op->value.asInterval;
	return kPGPError_NoErr;
}

/* Access option data consisting of a pointer and a length */
/* This is a special case; the length is in the option itself */
	PGPError
pgpOptionPtrLength(
	PGPOption			 *op,
	void				**pPtr,
	PGPSize				 *pLength
	)			 
{
	*pPtr = op->value.asPtr;
	*pLength = op->valueSize;
	return kPGPError_NoErr;
}

/* Access option data consisting of a pointer then a pointer */
	PGPError
pgpOptionPtrPtr(
	PGPOption			 *op,
	void				**pPtr,
	void				**pPtr2
	)			 
{
	PGPByte *ptr = ( PGPByte * ) op->value.asPtr;
	*pPtr = *( ( void ** ) ptr );
	ptr += sizeof( void * );
	*pPtr2 = *( ( void ** ) ptr );
	return kPGPError_NoErr;
}

/* Access option data consisting of a pointer, length, then pointer */
	PGPError
pgpOptionPtrLengthPtr(
	PGPOption			 *op,
	void				**pPtr,
	PGPSize				 *pLength,
	void				**pPtr2
	)			 
{
	PGPByte *ptr = ( PGPByte * ) op->value.asPtr;
	*pPtr = *( ( void ** ) ptr );
	ptr += sizeof( void * );
	*pLength = *( ( PGPSize * ) ptr );
	ptr += sizeof( PGPSize );
	*pPtr2 = *( ( void ** ) ptr );
	return kPGPError_NoErr;
}


/* Allocate and make a copy of a C String */

	char *
pgpAllocCString(
	PGPContextRef	 	 context,
	char const			*string
	)
{
	char				*ptr;
	PGPSize				 length;

	length = strlen( string );
	ptr = (char *)pgpContextMemAlloc( context, length+1, 0 );
	if( IsntNull( ptr ) ) {
		strcpy( ptr, string );
	}
	return ptr;
}


/*
**	This is the handler proc for sensitive options like passphrase
*/

	PGPError
pgpSensitiveOptionHandlerProc(
	PGPContextRef				context,
	PGPOptionHandlerOperation 	operation,
	PGPOptionType				type,
	PGPOptionValue				inputValue,
	PGPSize 					inputValueSize,
	PGPOptionValue 				*outputValue,
	PGPSize						*outputValueSize)
{
	PGPError	err = kPGPError_NoErr;
	
	(void) context;
	(void) type;
	
	switch( operation )
	{
		case kPGPOptionHandler_FreeDataOperation:
		{
			/* This wipes as it frees since it is a secure buffer */
			PGPFreeData( inputValue.asPtr );
			break;
		}
			
		case kPGPOptionHandler_CopyDataOperation:
		{
			pgpAssertAddrValid( outputValue, PGPOptionValue );
			pgpAssertAddrValid( outputValueSize, PGPSize );

			outputValue->asPtr = PGPNewSecureData(
					PGPGetContextMemoryMgr( context ), inputValueSize, 0);
			if( IsNull( outputValue->asPtr ) ) {
				err = kPGPError_OutOfMemory;
				break;
			}

			pgpCopyMemory( inputValue.asPtr, outputValue->asPtr,
						   inputValueSize );
			*outputValueSize = inputValueSize;
			
			break;
		}
		
		default:
		{
			err = kPGPError_UnknownRequest;
			break;
		}
	}

	return( err );
}

/*
**	This is the handler proc for options which take buffers but aren't
**	sensitive.
*/

	PGPError
pgpBufferOptionHandlerProc(
	PGPContextRef				context,
	PGPOptionHandlerOperation 	operation,
	PGPOptionType				type,
	PGPOptionValue				inputValue,
	PGPSize 					inputValueSize,
	PGPOptionValue 				*outputValue,
	PGPSize						*outputValueSize)
{
	PGPError	err = kPGPError_NoErr;
	
	(void) context;
	(void) type;
	
	switch( operation )
	{
		case kPGPOptionHandler_FreeDataOperation:
		{
			pgpContextMemFree( context, inputValue.asPtr );
			break;
		}
			
		case kPGPOptionHandler_CopyDataOperation:
		{
			pgpAssertAddrValid( outputValue, PGPOptionValue );
			pgpAssertAddrValid( outputValueSize, PGPSize );

			outputValue->asPtr = pgpContextMemAlloc( context,
													 inputValueSize, 0 );
			if( IsNull( outputValue->asPtr ) ) {
				err = kPGPError_OutOfMemory;
				break;
			}

			pgpCopyMemory( inputValue.asPtr, outputValue->asPtr,
						   inputValueSize );
			*outputValueSize = inputValueSize;
			
			break;
		}
		
		default:
		{
			err = kPGPError_UnknownRequest;
			break;
		}
	}

	return( err );
}

/*
**	This is the handler proc for options containing PGPFileRefs.
*/

	PGPError
pgpFileRefOptionHandlerProc(
	PGPContextRef				context,
	PGPOptionHandlerOperation 	operation,
	PGPOptionType				type,
	PGPOptionValue				inputValue,
	PGPSize 					inputValueSize,
	PGPOptionValue 				*outputValue,
	PGPSize						*outputValueSize)
{
	PGPError	err = kPGPError_NoErr;
	
	(void) context;
	(void) type;
	
	switch( operation )
	{
		case kPGPOptionHandler_FreeDataOperation:
		{
			err = PFLFreeFileSpec( (PFLFileSpecRef) inputValue.asFileRef );
			break;
		}
			
		case kPGPOptionHandler_CopyDataOperation:
		{
			pgpAssertAddrValid( outputValue, PGPOptionValue );
			pgpAssertAddrValid( outputValueSize, PGPSize );

			err = PFLCopyFileSpec( (PFLFileSpecRef) inputValue.asFileRef,
						(PFLFileSpecRef *) &outputValue->asFileRef );
			if( IsntPGPError( err ) )
			{
				*outputValueSize = inputValueSize;
			}
			
			break;
		}
		
		default:
		{
			err = kPGPError_UnknownRequest;
			break;
		}
	}

	return( err );
}

	PGPOptionListRef
pgpCreateCustomValueOptionList(
	PGPContextRef			context,
	PGPOptionType			type,
	PGPOptionFlags			flags,
	const PGPOptionValue	*value,
	PGPSize					valueSize,
	PGPOptionListRef		subOptions,
	PGPOptionHandlerProcPtr	handlerProc)
{
	PGPOptionListRef	optionList;
	PGPOption			option;
	
	pgpValidateOptionContext( context );
	
	option.type			= type;
	option.flags		= flags;
	option.valueSize	= valueSize;
	option.subOptions	= subOptions;
	option.handlerProc	= handlerProc;
	
	if( IsNull( value ) )
	{
		pgpAssert( option.valueSize == 0 );
		
		option.value.asPtr = NULL;
	}
	else
	{
		option.value = *value;
	}
	
	optionList = pgpNewOneOptionList( context, &option );
	
	if( pgpOptionListIsValid( subOptions ) )
	{
		/* Fetch the err from the subOptions list, if any */
		pgpSetOptionListError( optionList,
					pgpGetOptionListError( subOptions ) );
	}
	
	return( optionList );
}

	PGPOptionListRef
pgpCreateStandardValueOptionList( 
	PGPContextRef			context,
	PGPOptionType			type,
	const PGPOptionValue	*value,
	PGPSize					valueSize,
	PGPOptionHandlerProcPtr	handlerProc)
{
	return( pgpCreateCustomValueOptionList( context,
				type, kPGPOptionFlag_Default,
				value, valueSize, NULL, handlerProc ) );
}

	PGPOptionListRef
pgpCreateFileRefOptionList( 
	PGPContextRef	context,
	PGPOptionType	type,
	PGPFileSpecRef	fileRef)
{
	PGPOptionListRef	optionList;
	PGPOptionValue		value;
	
	pgpValidateOptionContext( context );
	pgpValidateOptionParam( pflFileSpecIsValid( (PFLFileSpecRef)fileRef ) );
	
	if( IsntPGPError( PFLCopyFileSpec(
			(PFLConstFileSpecRef) fileRef, (PFLFileSpecRef *) &value.asFileRef ) ) )
	{
		optionList = pgpCreateStandardValueOptionList( context,  
							type,
							&value, sizeof( fileRef ),
							pgpFileRefOptionHandlerProc );
	}
	else
	{
		/* Inability to copy a ref means we're out of memory */
		optionList = kPGPOutOfMemoryOptionListRef;
	}
	
	return( optionList );
}

	PGPOptionListRef
pgpCreateSensitiveOptionList( 
	PGPContextRef		context,
	PGPOptionType		type,
	void const			*sensitiveData,
	PGPSize				sensitiveDataSize)
{
	PGPOptionListRef	optionList;
	PGPOptionValue		value;
	
	pgpValidateOptionContext( context );
	pgpValidateOptionParam( IsntNull( sensitiveData ) );
	
	value.asPtr = PGPNewSecureData( PGPGetContextMemoryMgr( context ),
					sensitiveDataSize, 0 );
	if( IsntNull( value.asPtr ) )
	{
		pgpCopyMemory( sensitiveData, value.asPtr, sensitiveDataSize );
		optionList = pgpCreateStandardValueOptionList( context,  
							type,
							&value, sensitiveDataSize,
							pgpSensitiveOptionHandlerProc );
	}
	else
	{
		/* Inability to copy a ref means we're out of memory */
		optionList = kPGPOutOfMemoryOptionListRef;
	}
	
	return( optionList );
}

/* This is like pgpCreateSensitiveOptionList, but for non-sensitive data */
	PGPOptionListRef
pgpCreateBufferOptionList( 
	PGPContextRef		context,
	PGPOptionType		type,
	void const			*bufferData,
	PGPSize				bufferDataSize)
{
	PGPOptionListRef	optionList;
	PGPOptionValue		value;
	
	pgpValidateOptionContext( context );
	pgpValidateOptionParam( IsntNull( bufferData ) );
		
	value.asPtr = pgpContextMemAlloc( context, bufferDataSize, 0 );
	if( IsntNull( value.asPtr ) )
	{
		pgpCopyMemory( bufferData, value.asPtr, bufferDataSize );
		optionList = pgpCreateStandardValueOptionList( context,  
							type,
							&value, bufferDataSize,
							pgpBufferOptionHandlerProc );
	}
	else
	{
		/* Inability to copy a ref means we're out of memory */
		optionList = kPGPOutOfMemoryOptionListRef;
	}

	return( optionList );
}


/*__Editor_settings____

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