pflprefs.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1997 Network Associates Inc. and affiliated companies.
	All rights reserved.

	$Id: pflPrefs.c,v 1.26.6.1 1999/06/04 01:23:40 heller Exp $
____________________________________________________________________________*/

#include <stdio.h>
#include <string.h>

#include "pgpMemoryMgr.h"
#include "pflPrefs.h"
#include "pgpMem.h"
#include "pgpDebug.h"
#include "pgpPFLErrors.h"
#include "pgpFileUtilities.h"
#include "pgpEndianConversion.h"

typedef struct PGPPrefData	PGPPrefData;
typedef struct PGPPref		PGPPref;

#define kPGPPrefsEndian		kPGPBigEndian
#define kPGPPrefsMagic		0x155A1326

struct PGPPrefData
{
	PGPPrefIndex	prefIndex;
	PGPSize			dataLength;
	void *			dataBuffer;

	PGPPrefData *	nextPrefData;
	PGPPrefData *	lastPrefData;
};

struct PGPPref 
{
	PGPMemoryMgrRef	memoryMgr;
	PFLFileSpecRef	prefFileSpec;

	PGPPrefData *	prefList;
	PGPPrefData *	prefListEnd;
};


#define PGPValidatePref(prefRef)		PGPValidateParam(prefRef != NULL)

static PGPError pgpFindPrefData(PGPPrefRef prefRef, 
								PGPPrefIndex prefIndex, 
								PGPPrefData **prefData);

static PGPError pgpCalcPrefFileSize(PGPPrefRef prefRef, PGPUInt32 *size);

static PGPError pgpFreePref(PGPPrefRef prefRef);

static PGPError pgpAddPrefData(PGPPrefRef prefRef, 
							   PGPPrefData *prefData);

static PGPError pgpRemovePrefData(PGPPrefRef prefRef, 
								  PGPPrefData *prefData);

static PGPError pgpGetNextPrefData(const PGPPrefData *currentPrefData, 
								   PGPPrefData **nextPrefData);

static PGPError sIORead(PGPIORef fileIO, PGPSize dataSize, 
					PGPBoolean crossPlatform, void *data);

static PGPError sIOWrite(PGPIORef fileIO, PGPSize dataSize, 
					PGPBoolean crossPlatform, const void *data);


PGPError PGPOpenPrefFile(PFLFileSpecRef prefFileSpec, 
						 const PGPPrefDefault *defaults,
						 PGPUInt32 numDefaults,
						 PGPPrefRef *prefRef)
{
	PGPMemoryMgrRef	memoryMgr	= NULL;
	PGPIORef		prefIO;
	PGPPrefIndex	newIndex;
	PGPUInt32		listIndex;
	PGPSize			dataLength;
	void *			newData		= NULL;
	PGPPrefData *	newPrefData = NULL;
	PGPPrefData *	oldPrefData = NULL;
	PGPError		err;

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

	PGPValidatePtr(prefRef);
	PFLValidateFileSpec(prefFileSpec);

	memoryMgr = PFLGetFileSpecMemoryMgr( prefFileSpec );
	
	pgpAssert(PGPMemoryMgrIsValid(memoryMgr));
	if (!PGPMemoryMgrIsValid(memoryMgr))
		return kPGPError_BadParams;

	*prefRef = (PGPPrefRef) PGPNewData(memoryMgr, 
								sizeof(PGPPref), 
								kPGPMemoryMgrFlags_Clear);

	pgpAssert(IsntNull(*prefRef));
	if (IsNull(*prefRef))
		return kPGPError_OutOfMemory;

	(*prefRef)->memoryMgr		= memoryMgr;
	(*prefRef)->prefFileSpec	= NULL;
	(*prefRef)->prefList		= NULL;
	(*prefRef)->prefListEnd		= NULL;

	err = PFLCopyFileSpec(prefFileSpec, &((*prefRef)->prefFileSpec));
	if (IsPGPError(err))
	{
		pgpFreePref(*prefRef);
		*prefRef = NULL;
		return err;
	}

	err = PGPOpenFileSpec(	(*prefRef)->prefFileSpec, 
							kPFLFileOpenFlags_ReadOnly, 
							(PGPFileIORef *) &prefIO);
	
	if ((err != kPGPError_FileNotFound) && (err != kPGPError_FileOpFailed))
	{
		PGPUInt32 magic = 0;

		if (IsPGPError(err))
		{
			pgpFreePref(*prefRef);
			*prefRef = NULL;
			return err;
		}
		
		pgpAssert(PGPIOIsValid(prefIO));
		if (!PGPIOIsValid(prefIO))
		{
			pgpFreePref(*prefRef);
			*prefRef = NULL;
			return kPGPError_OutOfMemory;
		}
		
		if (!PGPIOIsAtEOF(prefIO))
			err = sIORead(prefIO, sizeof(PGPUInt32), TRUE, &magic);
		else
			err = kPGPError_CorruptData;

		if (IsPGPError(err) || (magic != kPGPPrefsMagic))
		{
			PGPFreeIO(prefIO);
			pgpFreePref(*prefRef);
			*prefRef = NULL;
			return kPGPError_CorruptData;
		}
		
		while (!PGPIOIsAtEOF(prefIO) && IsntPGPError(err))
		{
			newData = NULL;
			newPrefData = NULL;
			
			err = sIORead(prefIO, sizeof(PGPPrefIndex), TRUE, &newIndex);
			
			if (IsPGPError(err))
				break;
			
			err = sIORead(prefIO, sizeof(PGPSize), TRUE, &dataLength);
			
			if (IsPGPError(err))
				break;
			
			newData = PGPNewData(memoryMgr, 
				dataLength, 
				kPGPMemoryMgrFlags_Clear);
			
			if (IsNull(newData))
			{
				err = kPGPError_OutOfMemory;
				break;
			}
			
			err = sIORead(prefIO, dataLength, FALSE, newData);
			
			if (IsPGPError(err))
				break;
			
			newPrefData = (PGPPrefData *) PGPNewData(memoryMgr,
											sizeof(PGPPrefData),
											kPGPMemoryMgrFlags_Clear);
			if (IsNull(newPrefData))
			{
				err = kPGPError_OutOfMemory;
				break;
			}
			
			newPrefData->prefIndex	= newIndex;
			newPrefData->dataLength = dataLength;
			newPrefData->dataBuffer = newData;
			
			pgpAddPrefData(*prefRef, newPrefData);
		}
		
		if (err == kPGPError_EOF)
		{
			if (IsntNull(newData))
				PGPFreeData( newData);
			
			err = kPGPError_NoErr;
		}
		else if (IsPGPError(err))
		{
			pgpAssertNoErr(err);
			pgpFreePref(*prefRef);
			*prefRef = NULL;
		}
		
		PGPFreeIO(prefIO);
	}
	else
		err = kPGPError_NoErr;

	if ((numDefaults > 0) && IsntNull(defaults) && IsntPGPError(err))
	{
		for (listIndex=0; listIndex<numDefaults; listIndex++)
		{
			err = pgpFindPrefData(*prefRef, defaults[listIndex].index, 
					&oldPrefData);

			pgpAssertNoErr(err);
			if (IsPGPError(err))
				break;

			if (IsNull(oldPrefData))
			{
				newPrefData = (PGPPrefData *) PGPNewData(memoryMgr,
												sizeof(PGPPrefData),
												kPGPMemoryMgrFlags_Clear);
				
				if (IsNull(newPrefData))
				{
					err = kPGPError_OutOfMemory;
					break;
				}
				
				newPrefData->prefIndex = defaults[listIndex].index;
				
				switch (defaults[listIndex].type)
				{
				case kPGPPrefType_Boolean:
					{
					PGPBoolean	temp;
					
					newPrefData->dataLength = sizeof(PGPBoolean);
					newPrefData->dataBuffer = PGPNewData(memoryMgr,
												newPrefData->dataLength,
												kPGPMemoryMgrFlags_Clear);

					temp = (PGPBoolean) (size_t) defaults[listIndex].data;
					pgpCopyMemory( &temp,
						newPrefData->dataBuffer,
						newPrefData->dataLength);
					break;
					}
				case kPGPPrefType_Number:
					{
					PGPByte data32[sizeof(PGPUInt32)];

					newPrefData->dataLength = sizeof(PGPUInt32);
					newPrefData->dataBuffer = PGPNewData(memoryMgr,
												newPrefData->dataLength,
												kPGPMemoryMgrFlags_Clear);

					PGPUInt32ToEndian((PGPUInt32) defaults[listIndex].data, 
						kPGPPrefsEndian, data32);

					pgpCopyMemory(data32,
						newPrefData->dataBuffer,
						newPrefData->dataLength);
					break;
					}
					
				case kPGPPrefType_String:
					newPrefData->dataLength = 
						strlen((char *) defaults[listIndex].data) + 1;
					newPrefData->dataBuffer = PGPNewData(memoryMgr,
												newPrefData->dataLength,
												kPGPMemoryMgrFlags_Clear);

					pgpCopyMemory(defaults[listIndex].data,
						newPrefData->dataBuffer, 
						newPrefData->dataLength);
					break;
					
				case kPGPPrefType_Byte:
					newPrefData->dataLength = defaults[listIndex].size;
					newPrefData->dataBuffer = PGPNewData(memoryMgr,
												newPrefData->dataLength,
												kPGPMemoryMgrFlags_Clear);

					pgpCopyMemory(defaults[listIndex].data,
						newPrefData->dataBuffer,
						newPrefData->dataLength);
					break;
				}
				
				pgpAddPrefData(*prefRef, newPrefData);
			}
		}
	}

	return err;
}


PGPError PGPSavePrefFile(PGPPrefRef prefRef)
{
	PGPPrefData *	currentPrefData;
	PGPIORef		prefIO;
	PGPUInt32		prefFileSize;
	PGPUInt32		magic;
	PGPError		err;
	PGPBoolean		fileExists;
	
	PGPValidatePref(prefRef);

	pgpCalcPrefFileSize(prefRef, &prefFileSize);

	/* Create the file if it does not exist */
	err = PFLFileSpecExists( prefRef->prefFileSpec, &fileExists );
	if( IsntPGPError( err ) && ! fileExists )
	{
		err = PFLFileSpecCreate(prefRef->prefFileSpec);
	}
	
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	err = PGPSetFileSize(prefRef->prefFileSpec, prefFileSize);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	err = PGPOpenFileSpec(	prefRef->prefFileSpec, 
							kPFLFileOpenFlags_ReadWrite, 
							(PGPFileIORef *) &prefIO);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	magic = kPGPPrefsMagic;
	err = sIOWrite(prefIO, sizeof(PGPUInt32), TRUE, &magic);

	pgpAssertNoErr(err);
	if (IsPGPError(err))
	{
		PGPFreeIO(prefIO);
		return err;
	}

	currentPrefData = prefRef->prefList;

	while (IsntNull(currentPrefData))
	{
		err = sIOWrite(prefIO, sizeof(PGPPrefIndex), TRUE,
				&(currentPrefData->prefIndex));

		pgpAssertNoErr(err);
		if (IsPGPError(err))
			break;

		err = sIOWrite(prefIO, sizeof(PGPSize), TRUE,
				&(currentPrefData->dataLength));

		pgpAssertNoErr(err);
		if (IsPGPError(err))
			break;

		err = sIOWrite(prefIO, currentPrefData->dataLength, FALSE,
				currentPrefData->dataBuffer);

		pgpAssertNoErr(err);
		if (IsPGPError(err))
			break;

		pgpGetNextPrefData(currentPrefData, &currentPrefData);
	}

	PGPFreeIO(prefIO);
	return err;
}


PGPError PGPClosePrefFile(PGPPrefRef prefRef)
{
	PGPValidatePref(prefRef);

	pgpFreePref(prefRef);
	return kPGPError_NoErr;
}


PGPError PGPGetPrefFileSpec(PGPPrefRef prefRef,
								PFLFileSpecRef *prefFileSpec)
{
	PGPError err = kPGPError_NoErr;

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

	PGPValidatePref(prefRef);
	PGPValidatePtr(prefFileSpec);

	err = PFLCopyFileSpec(prefRef->prefFileSpec, prefFileSpec);
	if (IsPGPError(err))