pflpreftypes.c

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

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: pflPrefTypes.c,v 1.7 2002/08/06 20:10:33 dallen Exp $
____________________________________________________________________________*/
#include <string.h>

#include "pflPrefTypes.h"
#include "pgpPFLErrors.h"
#include "pgpDebug.h"
#include "pgpMem.h"
#include "pgpMemoryMgr.h"
#include "pgpEndianConversion.h"

#include "pgpPFLPriv.h"

PGPError PGPGetPrefBoolean(PGPPrefRef prefRef,
							   PGPPrefIndex prefIndex,
							   PGPBoolean *data)
{
	void *			tempData;
	PGPSize			dataLength;
	PGPError		err;

	if (IsntNull(data))
		*data = FALSE;
		
	PGPValidatePtr(data);

	err = PGPGetPrefData(prefRef, prefIndex, &dataLength, &tempData);
	if (IsPGPError(err))
		return err;

	pgpAssert(dataLength == sizeof(PGPBoolean));
	if (dataLength != sizeof(PGPBoolean))
	{
		PGPFreeData(tempData);
		return kPGPError_BadParams;
	}

	*data = *(PGPBoolean *)tempData;
	PGPFreeData(tempData);

	return err;
}


PGPError PGPSetPrefBoolean(PGPPrefRef prefRef,
							   PGPPrefIndex prefIndex,
							   PGPBoolean data)
{
	PGPError err;

	err = PGPSetPrefData(prefRef, prefIndex, sizeof(PGPBoolean), &data);

	return err;
}


PGPError PGPGetPrefNumber(PGPPrefRef prefRef,
							  PGPPrefIndex prefIndex,
							  PGPUInt32 *data)
{
	void *		tempData;
	PGPSize		dataLength;
	PGPError	err;

	if (IsntNull(data))
		*data = 0;

	PGPValidatePtr(data);

	err = PGPGetPrefData(prefRef, prefIndex, &dataLength, &tempData);
	if (IsPGPError(err))
		return err;

	pgpAssert(dataLength == sizeof(PGPUInt32));
	if (dataLength != sizeof(PGPUInt32))
	{
		PGPFreeData(tempData);
		return kPGPError_BadParams;
	}

	*data = *(PGPUInt32 *)tempData;
	PGPFreeData(tempData);

	return err;
}


PGPError PGPSetPrefNumber(PGPPrefRef prefRef,
							  PGPPrefIndex prefIndex,
							  PGPUInt32 data)
{
	PGPError	err;

	err = PGPSetPrefData(prefRef, prefIndex, sizeof(PGPUInt32),
			(void *) &data);

	return err;
}


PGPError PGPGetPrefStringAlloc(PGPPrefRef prefRef,
								   PGPPrefIndex prefIndex,
								  char **string)
{
	PGPError	err;
	void *		data			= NULL;
	PGPSize		stringLength	= 0;

	if (IsntNull(string))
		*string = NULL;

	PGPValidatePtr(string);

	err = PGPGetPrefData(prefRef, prefIndex, &stringLength, &data);
	if (IsntPGPError(err))
	{
		*string	= (char *)data;
	}
	
	return err;
}


PGPError PGPGetPrefStringBuffer(PGPPrefRef prefRef,
									PGPPrefIndex prefIndex,
									PGPSize maxSize,
									char *string)
{
	PGPError	err;
	void *		tempString;
	PGPSize		tempLength;

	if (IsntNull(string) && (maxSize > 0))
		string[0] = '\0';

	PGPValidatePtr(string);
	PGPValidateParam(maxSize > 0);

	err = PGPGetPrefData(prefRef, prefIndex, &tempLength, &tempString);
	if (IsPGPError(err))
		return err;

	if (tempLength > maxSize)
	{
		tempLength = maxSize;
		string[tempLength-1] = 0;
	}

	pgpCopyMemory(tempString, string, tempLength);
	PGPFreeData(tempString);
	
	return err;
}


PGPError PGPSetPrefString(PGPPrefRef prefRef,
							  PGPPrefIndex prefIndex,
							  const char *string)
{
	PGPError	err;
	PGPSize		stringLength;

	PGPValidatePtr(string);
	
	stringLength = strlen(string)+1;	/* Include null terminator */

	err = PGPSetPrefData(prefRef, prefIndex, stringLength, string);
	return err;
}


PGPError PGPGetPrefStruct(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPPrefStruct **structPtr)
{
	PGPError	err;
	void *		tempBuffer;
	PGPSize		tempLength;

	if (IsntNull(structPtr))
		*structPtr = NULL;

	PGPValidatePtr(structPtr);

	err = PGPGetPrefData(prefRef, prefIndex, &tempLength, &tempBuffer);
	
	if (IsntPGPError(err))
	{
		pgpAssert(tempLength == sizeof(PGPPrefStruct));
		if (tempLength != sizeof(PGPPrefStruct))
		{
			PGPFreeData(tempBuffer);
			err = kPGPError_BadParams;
		}
	}

	if (IsntPGPError(err))
	{
		*structPtr = (PGPPrefStruct *) tempBuffer;
		(*structPtr)->dirty = FALSE;
	}

	return err;
}


PGPError PGPSetPrefStruct(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPPrefStruct *structPtr)
{
	PGPError err;

	PGPValidatePtr(structPtr);

	err = PGPSetPrefData(prefRef, prefIndex, sizeof(PGPPrefStruct), 
			structPtr);
	
	if (IsntPGPError(err))
		structPtr->dirty = FALSE;

	return err;
}


PGPError PGPGetPrefArray(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPPrefArray **arrayPtr)
{
	PGPError				err;
	void *					tempBuffer;
	PGPSize					tempLength;

	if (IsntNull(arrayPtr))
		*arrayPtr = NULL;

	PGPValidatePtr(arrayPtr);

	err = PGPGetPrefData(prefRef, prefIndex, &tempLength, &tempBuffer);
	
	if (IsntPGPError(err))
	{
		pgpAssert(tempLength == sizeof(PGPPrefArray));
		if (tempLength != sizeof(PGPPrefArray))
		{
			PGPFreeData(tempBuffer);
			err = kPGPError_BadParams;
		}
	}

	if (IsntPGPError(err))
	{
		*arrayPtr = (PGPPrefArray *) tempBuffer;
		(*arrayPtr)->dirty = FALSE;
	}

	return err;
}


PGPError PGPSetPrefArray(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPPrefArray *arrayPtr)
{
	PGPError err;

	PGPValidatePtr(arrayPtr);

	err = PGPSetPrefData(prefRef, prefIndex, sizeof(PGPPrefArray), 
			arrayPtr);
	
	if (IsntPGPError(err))
		arrayPtr->dirty = FALSE;

	return err;
}


PGPError PGPGetPrefArrayBoolean(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPBoolean *data)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(data);

	if (prefArray->type != kPGPPrefType_Boolean)
		return kPGPError_BadParams;

	if (arrayIndex >= prefArray->numElements)
		return kPGPError_BadParams;

	*data = (PGPBoolean)(size_t) prefArray->elements[arrayIndex].data;
	return kPGPError_NoErr;
}


PGPError PGPSetPrefArrayBoolean(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPBoolean data)
{
	PGPMemoryMgrRef memoryMgr;
	PGPError err = kPGPError_NoErr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);

	if (prefArray->type != kPGPPrefType_Boolean)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (arrayIndex >= prefArray->numElements)
	{
		err = PGPReallocData(memoryMgr,
				(void **) &(prefArray->elements),
				sizeof(PGPPrefArrayElement) * (arrayIndex+1),
				0);

		if (IsPGPError(err))
			return err;
		prefArray->numElements = arrayIndex + 1;
	}

	prefArray->elements[arrayIndex].data = (void *)(size_t) data;
	prefArray->elements[arrayIndex].size = sizeof(PGPBoolean);
	prefArray->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefArrayNumber(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPUInt32 *data)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(data);

	if (prefArray->type != kPGPPrefType_Number)
		return kPGPError_BadParams;

	if (arrayIndex >= prefArray->numElements)
		return kPGPError_BadParams;

	*data = (PGPUInt32) prefArray->elements[arrayIndex].data;
	return kPGPError_NoErr;
}


PGPError PGPSetPrefArrayNumber(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									PGPUInt32 data)
{
	PGPMemoryMgrRef memoryMgr;
	PGPError err = kPGPError_NoErr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);

	if (prefArray->type != kPGPPrefType_Number)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (arrayIndex >= prefArray->numElements)
	{
		err = PGPReallocData(memoryMgr,
				(void **) &(prefArray->elements),
				sizeof(PGPPrefArrayElement) * (arrayIndex+1),
				0);

		if (IsPGPError(err))
			return err;
		prefArray->numElements = arrayIndex + 1;
	}

	prefArray->elements[arrayIndex].data = (void *) data;
	prefArray->elements[arrayIndex].size = sizeof(PGPUInt32);
	prefArray->dirty = TRUE;
	return kPGPError_NoErr;
}


PGPError PGPGetPrefArrayString(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									char **string)
{
	PGPMemoryMgrRef memoryMgr;

	if (IsntNull(string))
		*string = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(string);

	if (prefArray->type != kPGPPrefType_String)
		return kPGPError_BadParams;

	if (arrayIndex >= prefArray->numElements)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (IsntNull(prefArray->elements[arrayIndex].data))
	{
		*string = (char *) PGPNewData(memoryMgr,
							strlen(prefArray->elements[arrayIndex].data)+1,
							kPGPMemoryMgrFlags_Clear);

		if (IsNull(*string))
			return kPGPError_OutOfMemory;

		pgpCopyMemory(prefArray->elements[arrayIndex].data, *string,
			strlen(prefArray->elements[arrayIndex].data) + 1);
	}

	return kPGPError_NoErr;
}


PGPError PGPSetPrefArrayString(PGPPrefRef prefRef,
									PGPPrefArray *prefArray,
									PGPUInt32 arrayIndex,
									char *string)
{
	PGPMemoryMgrRef memoryMgr;
	PGPError err = kPGPError_NoErr;

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefArray);
	PGPValidatePtr(string);

	if (prefArray->type != kPGPPrefType_String)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	if (arrayIndex >= prefArray->numElements)
	{
		err = PGPReallocData(memoryMgr,