pgphashprefs.c

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

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

	$Id: pgpHashPrefs.c,v 1.9 2002/08/06 20:10:16 dallen Exp $
____________________________________________________________________________*/

#include <string.h>

#include "pgpHashPrefs.h"
#include "pgpHash.h"
#include "pgpEndianConversion.h"
#include "pflPrefTypes.h"
#include "pgpMem.h"
#include "pgpClientPrefs.h"
#include "pgpNetPrefs.h"
#include "pgpPFLPriv.h"
#include "pgpUtilities.h"


static PGPError sHashPrefs(PGPContextRef context, PGPPrefRef prefRef, 
					PGPSize *hashSize, void **hash);

static PGPError sHashPrefStruct(PGPPrefRef prefRef, 
					PGPHashContextRef hashRef, PGPPrefStruct *prefStruct);

PGPError PGPWritePrefsHash(PGPContextRef context, PGPPrefRef prefRef)
{
	PGPSize		hashSize;
	void *		hash = NULL;
	PGPError	err = kPGPError_NoErr;

	PGPValidateParam(PGPContextRefIsValid(context));
	PGPValidatePref(prefRef);
	
	err = sHashPrefs(context, prefRef, &hashSize, &hash);
	
	if (IsntPGPError(err))
		err = PGPSetPrefData(prefRef, kPGPPrefAdminHash, hashSize, hash);

	if (IsntNull(hash))
		PGPFreeData(hash);

	return err;
}


PGPError PGPCheckPrefsHash(PGPContextRef context, PGPPrefRef prefRef)
{
	PGPSize		hashSize;
	PGPSize		adminHashSize;
	void *		hash = NULL;
	void *		adminHash = NULL;
	PGPError	err = kPGPError_NoErr;

	PGPValidateParam(PGPContextRefIsValid(context));
	PGPValidatePref(prefRef);
	
	err = PGPGetPrefData(prefRef, kPGPPrefAdminHash, &adminHashSize, 
			&adminHash);

	if ((err == kPGPError_PrefNotFound) || IsNull(adminHash))
		return kPGPError_PrefNotFound;

	if (IsntPGPError(err))
		err = sHashPrefs(context, prefRef, &hashSize, &hash);
	
	if (IsntPGPError(err))
	{
		if (hashSize != adminHashSize)
			err = kPGPError_CorruptData;
		else if (!pgpMemoryEqual(adminHash, hash, hashSize))
			err = kPGPError_CorruptData;
	}

	if (IsntNull(hash))
		PGPFreeData(hash);

	if (IsntNull(adminHash))
		PGPFreeData(adminHash);

	return err;
}


static PGPError sHashPrefs(PGPContextRef context, PGPPrefRef prefRef, 
					PGPSize *hashSize, void **hash)
{
	PGPMemoryMgrRef		memoryMgr;
	PGPHashContextRef	hashRef = NULL;
	PGPBoolean			prefBoolean;
	PGPUInt32			prefNumber;
	char *				prefString;
	PGPSize				dataSize;
	void *				prefData;
	PGPPrefStruct *		prefStruct;
	PGPPrefArray *		prefArray;
	PGPByte				rawData[sizeof(PGPUInt32)];
	PGPPrefIndex		index;
	PGPUInt32			arrayIndex;
	PGPUInt32			flags;
	PGPError			err = kPGPError_NoErr;

	if (IsntNull(hashSize))
		*hashSize = 0;
	if (IsntNull(hash))
		*hash = NULL;

	memoryMgr = PGPPeekContextMemoryMgr(context);

	err = PGPNewHashContext(context, kPGPHashAlgorithm_SHA, &hashRef);
	if (IsPGPError(err))
		return err;

	for (index=kPGPAdminPrefBoolFirst; index<kPGPAdminPrefBoolLast; index++)
	{
		err = PGPGetPrefBoolean(prefRef, index, &prefBoolean);
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
			PGPContinueHash(hashRef, &prefBoolean, sizeof(PGPBoolean));
	}
	
	for (index=kPGPPrefBoolFirst; index<kPGPPrefBoolLast; index++)
	{
		err = PGPGetPrefBoolean(prefRef, index, &prefBoolean);
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
			PGPContinueHash(hashRef, &prefBoolean, sizeof(PGPBoolean));
	}
	
	for (index=kPGPNetPrefBoolFirst; index<kPGPNetPrefBoolLast; index++)
	{
		err = PGPGetPrefBoolean(prefRef, index, &prefBoolean);
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
			PGPContinueHash(hashRef, &prefBoolean, sizeof(PGPBoolean));
	}
	
	for (index=kPGPAdminPrefNumberFirst; index<kPGPAdminPrefNumberLast; 
	index++)
	{
		err = PGPGetPrefNumber(prefRef, index, &prefNumber); 
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
		{
			PGPUInt32ToEndian(prefNumber, kPGPBigEndian, rawData);
			PGPContinueHash(hashRef, rawData, sizeof(PGPUInt32));
		}
	}
	
	for (index=kPGPPrefNumberFirst; index<kPGPPrefNumberLast; 
	index++)
	{
		err = PGPGetPrefNumber(prefRef, index, &prefNumber); 
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
		{
			PGPUInt32ToEndian(prefNumber, kPGPBigEndian, rawData);
			PGPContinueHash(hashRef, rawData, sizeof(PGPUInt32));
		}
	}
	
	for (index=kPGPNetPrefNumberFirst; index<kPGPNetPrefNumberLast; 
	index++)
	{
		err = PGPGetPrefNumber(prefRef, index, &prefNumber); 
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
		{
			PGPUInt32ToEndian(prefNumber, kPGPBigEndian, rawData);
			PGPContinueHash(hashRef, rawData, sizeof(PGPUInt32));
		}
	}
	
	for (index=kPGPAdminPrefStringFirst; index<kPGPAdminPrefStringLast; 
	index++)
	{
		err = PGPGetPrefStringAlloc(prefRef, index, &prefString); 
		if (IsntPGPError(err) && IsntNull(prefString))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				PGPContinueHash(hashRef, prefString, strlen(prefString));

			PGPFreeData(prefString);
		}
	}
	
	for (index=kPGPPrefStringFirst; index<kPGPPrefStringLast; 
	index++)
	{
		err = PGPGetPrefStringAlloc(prefRef, index, &prefString); 
		if (IsntPGPError(err) && IsntNull(prefString))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				PGPContinueHash(hashRef, prefString, strlen(prefString));

			PGPFreeData(prefString);
		}
	}
	
	for (index=kPGPNetPrefStringFirst; index<kPGPNetPrefStringLast; 
	index++)
	{
		err = PGPGetPrefStringAlloc(prefRef, index, &prefString); 
		if (IsntPGPError(err) && IsntNull(prefString))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				PGPContinueHash(hashRef, prefString, strlen(prefString));

			PGPFreeData(prefString);
		}
	}
	
	for (index=kPGPAdminPrefByteFirst; index<kPGPAdminPrefByteLast; index++)
	{
		err = PGPGetPrefData(prefRef, index, &dataSize, &prefData); 
		if (IsntPGPError(err) && IsntNull(prefData))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				PGPContinueHash(hashRef, prefData, dataSize);

			PGPFreeData(prefData);
		}
	}
	
	for (index=kPGPPrefByteFirst; index<kPGPPrefByteLast; index++)
	{
		err = PGPGetPrefData(prefRef, index, &dataSize, &prefData); 
		if (IsntPGPError(err) && IsntNull(prefData))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				PGPContinueHash(hashRef, prefData, dataSize);

			PGPFreeData(prefData);
		}
	}
	
	for (index=kPGPNetPrefByteFirst; index<kPGPNetPrefByteLast; index++)
	{
		err = PGPGetPrefData(prefRef, index, &dataSize, &prefData); 
		if (IsntPGPError(err) && IsntNull(prefData))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				PGPContinueHash(hashRef, prefData, dataSize);

			PGPFreeData(prefData);
		}
	}
	
	for (index=kPGPAdminPrefStructFirst; index<kPGPAdminPrefStructLast;
	index++)
	{
		err = PGPGetPrefStruct(prefRef, index, &prefStruct); 
		if (IsntPGPError(err))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				sHashPrefStruct(prefRef, hashRef, prefStruct);

			PGPFreePrefStruct(prefStruct);
		}
	}
	
	for (index=kPGPPrefStructFirst; index<kPGPPrefStructLast;
	index++)
	{
		err = PGPGetPrefStruct(prefRef, index, &prefStruct); 
		if (IsntPGPError(err))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				sHashPrefStruct(prefRef, hashRef, prefStruct);

			PGPFreePrefStruct(prefStruct);
		}
	}
	
	for (index=kPGPNetPrefStructFirst; index<kPGPNetPrefStructLast;
	index++)
	{
		err = PGPGetPrefStruct(prefRef, index, &prefStruct); 
		if (IsntPGPError(err))
		{
			err = PGPGetPrefFlags(prefRef, index, &flags);
			if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
				sHashPrefStruct(prefRef, hashRef, prefStruct);

			PGPFreePrefStruct(prefStruct);
		}
	}
	
	for (index=kPGPAdminPrefArrayFirst; index<kPGPAdminPrefArrayLast;
	index++)
	{
		err = PGPGetPrefArray(prefRef, index, &prefArray); 
		if (IsntPGPError(err))
			err = PGPGetPrefFlags(prefRef, index, &flags);
		if (IsntPGPError(err) && (flags & kPGPPrefFlags_Hash))
		{
			for (arrayIndex=0; arrayIndex<prefArray->numElements;
			arrayIndex++)
			{
				switch (prefArray->type)
				{
				case kPGPPrefType_Boolean:
					err = PGPGetPrefArrayBoolean(prefRef, prefArray,