pflprefs.c

vc环境下的pgp源码

		*prefFileSpec = NULL;

	return err;
}


PGPError PGPGetPrefData(PGPPrefRef prefRef, 
						PGPPrefIndex prefIndex, 
						PGPSize *dataLength, 
						void **inBuffer)
{
	PGPPrefData *	currentPrefData;
	PGPError		err;

	if (IsntNull(dataLength))
		*dataLength = 0;
	if (IsntNull(inBuffer))
		*inBuffer = NULL;

	PGPValidatePtr(inBuffer);
	PGPValidatePtr(dataLength);
	PGPValidatePref(prefRef);

	err = pgpFindPrefData(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
	{
		return kPGPError_PrefNotFound;
	}

	*inBuffer	= PGPNewData(prefRef->memoryMgr,
					currentPrefData->dataLength,
					kPGPMemoryMgrFlags_Clear);

	if (IsNull(*inBuffer))
	{
		return kPGPError_OutOfMemory;
	}

	*dataLength	= currentPrefData->dataLength;
	pgpCopyMemory(currentPrefData->dataBuffer, 
		*inBuffer, 
		currentPrefData->dataLength);

	return kPGPError_NoErr;
}


PGPError PGPSetPrefData(PGPPrefRef prefRef, 
						PGPPrefIndex prefIndex, 
						PGPSize dataLength, 
						const void *outBuffer)
{
	PGPPrefData *	currentPrefData;
	PGPError		err;
	
	PGPValidatePref(prefRef);
	PGPValidatePtr(outBuffer);

	err = pgpFindPrefData(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
	{
		currentPrefData = 
			(PGPPrefData *) PGPNewData(prefRef->memoryMgr,
								sizeof(PGPPrefData),
								kPGPMemoryMgrFlags_Clear);

		if (IsNull(currentPrefData))
			return kPGPError_OutOfMemory;

		currentPrefData->prefIndex	= prefIndex;
		currentPrefData->dataBuffer = NULL;

		pgpAddPrefData(prefRef, currentPrefData);
	}

	currentPrefData->dataLength = dataLength;
	
	if (IsntNull(currentPrefData->dataBuffer))
		PGPFreeData( currentPrefData->dataBuffer);

	currentPrefData->dataBuffer = PGPNewData(prefRef->memoryMgr,
									dataLength,
									kPGPMemoryMgrFlags_Clear);

	if (IsNull(currentPrefData->dataBuffer))
	{
		pgpRemovePrefData(prefRef, currentPrefData);
		return kPGPError_OutOfMemory;
	}

	pgpCopyMemory(outBuffer, currentPrefData->dataBuffer, dataLength);

	return kPGPError_NoErr;
}


PGPError PGPRemovePref(PGPPrefRef prefRef, 
					   PGPPrefIndex prefIndex)
{
	PGPPrefData *	currentPrefData;
	PGPError		err;
	
	PGPValidatePref(prefRef);

	err = pgpFindPrefData(prefRef, prefIndex, &currentPrefData);
	pgpAssertNoErr(err);
	if (IsPGPError(err))
		return err;

	if (IsNull(currentPrefData))
		return kPGPError_BadParams;

	pgpRemovePrefData(prefRef, currentPrefData);
	return kPGPError_NoErr;
}


PGPError PGPDisposePrefData(PGPPrefRef prefRef, 
							void *dataBuffer)
{
	PGPValidatePref(prefRef);
	PGPValidatePtr(dataBuffer);

	PGPFreeData( dataBuffer);
	return kPGPError_NoErr;
}


PGPError PGPExportPrefFileToBuffer(PGPPrefRef prefRef, PGPSize *bufferSize,
										void **buffer)
{
	PGPIORef prefIO;
	PGPFileOffset fileLength;
	PGPSize bytesRead;
	PGPError err = kPGPError_NoErr;

	if (IsntNull(bufferSize))
		*bufferSize = 0;
	if (IsntNull(buffer))
		*buffer = NULL;

	PGPValidatePref(prefRef);
	PGPValidatePtr(bufferSize);
	PGPValidatePtr(buffer);

	err = PGPSavePrefFile(prefRef);

	if (IsntPGPError(err))
		err = PGPOpenFileSpec(	prefRef->prefFileSpec, 
								kPFLFileOpenFlags_ReadOnly, 
								(PGPFileIORef *) &prefIO);

	if (IsntPGPError(err))
	{
		err = PGPIOGetEOF(prefIO, &fileLength);
		
		if (IsntPGPError(err))
		{
			*buffer = PGPNewData(prefRef->memoryMgr, (PGPSize) fileLength, 0);
			
			if (IsNull(*buffer))
				err = kPGPError_OutOfMemory;
		}
		
		if (IsntPGPError(err))
			err = PGPIORead(prefIO, (PGPSize)fileLength, *buffer, &bytesRead);
		
		if (IsntPGPError(err))
			*bufferSize = bytesRead;
		else if (IsntNull(*buffer))
		{
			PGPFreeData(*buffer);
			*buffer = NULL;
		}

		PGPFreeIO(prefIO);		
	}

	return err;
}


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

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

	PGPValidatePtr(prefData);
	PGPValidatePref(prefRef);

	searchPrefData = prefRef->prefList;
	while (IsntNull(searchPrefData))
	{
		if (searchPrefData->prefIndex == prefIndex)
			break;

		pgpGetNextPrefData(searchPrefData, &searchPrefData);
	}

	*prefData = searchPrefData;
	return kPGPError_NoErr;
}


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

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

	PGPValidatePtr(size);
	PGPValidatePref(prefRef);

	*size = sizeof(PGPUInt32);

	currentPrefData = prefRef->prefList;
	while (IsntNull(currentPrefData))
	{
		*size += sizeof(PGPPrefIndex) + sizeof(PGPSize) +
					currentPrefData->dataLength;
		pgpGetNextPrefData(currentPrefData, &currentPrefData);
	}

	return kPGPError_NoErr;
}


static PGPError pgpFreePref(PGPPrefRef prefRef)
{
	PGPPrefData *currentPrefData;
	PGPPrefData *tempPrefData;
	PGPMemoryMgrRef memoryMgr;

	PGPValidatePref(prefRef);

	currentPrefData = prefRef->prefList;
	while (IsntNull(currentPrefData))
	{
		pgpGetNextPrefData(currentPrefData, &tempPrefData);
		pgpRemovePrefData(prefRef, currentPrefData);
		currentPrefData = tempPrefData;
	}

	if (pflFileSpecIsValid(prefRef->prefFileSpec))
		PFLFreeFileSpec(prefRef->prefFileSpec);

	memoryMgr = prefRef->memoryMgr;
	PGPFreeData( prefRef);
	return kPGPError_NoErr;
}


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

	if (IsNull(prefRef->prefList))
		prefRef->prefList = prefData;

	if (IsntNull(prefRef->prefListEnd))
		prefRef->prefListEnd->nextPrefData = prefData;

	prefData->lastPrefData	= prefRef->prefListEnd;
	prefData->nextPrefData	= NULL;
	prefRef->prefListEnd	= prefData;
	return kPGPError_NoErr;
}


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

	if (IsntNull(prefData->dataBuffer))
		PGPFreeData( prefData->dataBuffer);

	if (IsntNull(prefData->nextPrefData))
		prefData->nextPrefData->lastPrefData = prefData->lastPrefData;

	if (IsntNull(prefData->lastPrefData))
		prefData->lastPrefData->nextPrefData = prefData->nextPrefData;

	if (prefRef->prefList == prefData)
		prefRef->prefList = prefData->nextPrefData;
	
	if (prefRef->prefListEnd == prefData)
		prefRef->prefListEnd = prefData->lastPrefData;

	PGPFreeData( prefData);
	return kPGPError_NoErr;
}


static PGPError pgpGetNextPrefData(const PGPPrefData *currentPrefData, 
								   PGPPrefData **nextPrefData)
{
	if (IsntNull(nextPrefData))
		*nextPrefData = NULL;

	PGPValidatePtr(nextPrefData);
	PGPValidatePtr(currentPrefData);

	*nextPrefData = currentPrefData->nextPrefData;
	return kPGPError_NoErr;
}


static PGPError sIORead(PGPIORef fileIO, PGPSize dataSize, 
					PGPBoolean crossPlatform, void *data)
{
	PGPByte		tempData16[sizeof(PGPUInt16)];
	PGPByte		tempData32[sizeof(PGPUInt32)];
	PGPUInt32	data32;
	PGPUInt16	data16;
	PGPSize		bytesRead;
	PGPError	err = kPGPError_NoErr;

	PGPValidateIO(fileIO);
	PGPValidateParam(dataSize > 0);
	PGPValidatePtr(data);

	if (crossPlatform)
	{
		if (dataSize == sizeof(PGPUInt16))
			err = PGPIORead(fileIO, dataSize, tempData16, &bytesRead);
		else
			err = PGPIORead(fileIO, dataSize, tempData32, &bytesRead);

		if (IsntPGPError(err))
		{
			if (dataSize == sizeof(PGPUInt16))
			{
				data16 = PGPEndianToUInt16(kPGPPrefsEndian, tempData16);
				pgpCopyMemory(&data16, data, sizeof(PGPUInt16));
			}
			else
			{
				data32 = PGPEndianToUInt32(kPGPPrefsEndian, tempData32);
				pgpCopyMemory(&data32, data, sizeof(PGPUInt32));
			}
		}
	}
	else
		err = PGPIORead(fileIO, dataSize, data, &bytesRead);

	return err;
}


static PGPError sIOWrite(PGPIORef fileIO, PGPSize dataSize, 
					PGPBoolean crossPlatform, const void *data)
{
	PGPByte		tempData16[sizeof(PGPUInt16)];
	PGPByte		tempData32[sizeof(PGPUInt32)];
	PGPUInt32	data32;
	PGPUInt16	data16;
	PGPError	err = kPGPError_NoErr;

	PGPValidateIO(fileIO);
	PGPValidateParam(dataSize > 0);
	PGPValidatePtr(data);

	if (crossPlatform)
	{
		if (dataSize == sizeof(PGPUInt16))
		{
			pgpCopyMemory(data, &data16, sizeof(PGPUInt16));
			PGPUInt16ToEndian(data16, kPGPPrefsEndian, tempData16);
			err = PGPIOWrite(fileIO, dataSize, tempData16);
		}
		else
		{
			pgpCopyMemory(data, &data32, sizeof(PGPUInt32));
			PGPUInt32ToEndian(data32, kPGPPrefsEndian, tempData32);
			err = PGPIOWrite(fileIO, dataSize, tempData32);
		}
	}
	else
		err = PGPIOWrite(fileIO, dataSize, data);

	return err;
}


/*__Editor_settings____

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