pgphashprefs.c

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

							arrayIndex, &prefBoolean);
					
					if (IsntPGPError(err))
						PGPContinueHash(hashRef, &prefBoolean, 
							sizeof(PGPBoolean));
					break;
					
				case kPGPPrefType_Number:
					err = PGPGetPrefArrayNumber(prefRef, prefArray,
							arrayIndex, &prefNumber);
					
					if (IsntPGPError(err))
					{
						PGPUInt32ToEndian(prefNumber, kPGPBigEndian, 
							rawData);
						
						PGPContinueHash(hashRef, rawData, 
							sizeof(PGPUInt32));
					}
					break;
					
				case kPGPPrefType_String:
					err = PGPGetPrefArrayString(prefRef, prefArray,
							arrayIndex, &prefString);
					
					if (IsntPGPError(err) && IsntNull(prefString))
					{
						PGPContinueHash(hashRef, prefString, 
							strlen(prefString));
						
						PGPFreeData(prefString);
					}
					break;
					
				case kPGPPrefType_Byte:
					err = PGPGetPrefArrayByte(prefRef, prefArray,
							arrayIndex, &dataSize, &prefData);

					if (IsntPGPError(err) && IsntNull(prefData))
					{
						PGPContinueHash(hashRef, prefData, dataSize);
						PGPFreeData(prefData);
					}
					break;
					
				case kPGPPrefType_Struct:
					err = PGPGetPrefArrayStruct(prefRef, prefArray,
							arrayIndex, &prefStruct);
					
					if (IsntPGPError(err))
						sHashPrefStruct(prefRef, hashRef, prefStruct);
					break;

				default:
					break;
				}
			}
		}
			
		if (IsntNull(prefArray))
			PGPFreePrefArray(prefArray);
	}

	for (index=kPGPPrefArrayFirst; index<kPGPPrefArrayLast;
	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,
							arrayIndex, &prefBoolean);
					
					if (IsntPGPError(err))
						PGPContinueHash(hashRef, &prefBoolean, 
							sizeof(PGPBoolean));
					break;
					
				case kPGPPrefType_Number:
					err = PGPGetPrefArrayNumber(prefRef, prefArray,
							arrayIndex, &prefNumber);
					
					if (IsntPGPError(err))
					{
						PGPUInt32ToEndian(prefNumber, kPGPBigEndian, 
							rawData);
						
						PGPContinueHash(hashRef, rawData, 
							sizeof(PGPUInt32));
					}
					break;
					
				case kPGPPrefType_String:
					err = PGPGetPrefArrayString(prefRef, prefArray,
							arrayIndex, &prefString);
					
					if (IsntPGPError(err) && IsntNull(prefString))
					{
						PGPContinueHash(hashRef, prefString, 
							strlen(prefString));
						
						PGPFreeData(prefString);
					}
					break;
					
				case kPGPPrefType_Byte:
					err = PGPGetPrefArrayByte(prefRef, prefArray,
							arrayIndex, &dataSize, &prefData);

					if (IsntPGPError(err) && IsntNull(prefData))
					{
						PGPContinueHash(hashRef, prefData, dataSize);
						PGPFreeData(prefData);
					}
					break;
					
				case kPGPPrefType_Struct:
					err = PGPGetPrefArrayStruct(prefRef, prefArray,
							arrayIndex, &prefStruct);
					
					if (IsntPGPError(err))
						sHashPrefStruct(prefRef, hashRef, prefStruct);
					break;

				default:
					break;
				}
			}
		}
			
		if (IsntNull(prefArray))
			PGPFreePrefArray(prefArray);
	}

	for (index=kPGPNetPrefArrayFirst; index<kPGPNetPrefArrayLast;
	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,
							arrayIndex, &prefBoolean);
					
					if (IsntPGPError(err))
						PGPContinueHash(hashRef, &prefBoolean, 
							sizeof(PGPBoolean));
					break;
					
				case kPGPPrefType_Number:
					err = PGPGetPrefArrayNumber(prefRef, prefArray,
							arrayIndex, &prefNumber);
					
					if (IsntPGPError(err))
					{
						PGPUInt32ToEndian(prefNumber, kPGPBigEndian, 
							rawData);
						
						PGPContinueHash(hashRef, rawData, 
							sizeof(PGPUInt32));
					}
					break;
					
				case kPGPPrefType_String:
					err = PGPGetPrefArrayString(prefRef, prefArray,
							arrayIndex, &prefString);
					
					if (IsntPGPError(err) && IsntNull(prefString))
					{
						PGPContinueHash(hashRef, prefString, 
							strlen(prefString));
						
						PGPFreeData(prefString);
					}
					break;
					
				case kPGPPrefType_Byte:
					err = PGPGetPrefArrayByte(prefRef, prefArray,
							arrayIndex, &dataSize, &prefData);

					if (IsntPGPError(err) && IsntNull(prefData))
					{
						PGPContinueHash(hashRef, prefData, dataSize);
						PGPFreeData(prefData);
					}
					break;
					
				case kPGPPrefType_Struct:
					err = PGPGetPrefArrayStruct(prefRef, prefArray,
							arrayIndex, &prefStruct);
					
					if (IsntPGPError(err))
						sHashPrefStruct(prefRef, hashRef, prefStruct);
					break;

				default:
					break;
				}
			}
		}
			
		if (IsntNull(prefArray))
			PGPFreePrefArray(prefArray);
	}

	if (err == kPGPError_PrefNotFound)
		err = kPGPError_NoErr;

	if (IsntPGPError(err))
	{
		PGPGetHashSize(hashRef, hashSize);

		*hash = PGPNewData(memoryMgr, *hashSize, kPGPMemoryMgrFlags_Clear);
		if (IsNull(*hash))
		{
			*hashSize = 0;
			err = kPGPError_OutOfMemory;
		}
		else
			PGPFinalizeHash(hashRef, *hash);
	}

	if (IsntNull(hashRef))
		PGPFreeHashContext(hashRef);

	return err;
}


static PGPError sHashPrefStruct(PGPPrefRef prefRef, 
					PGPHashContextRef hashRef, PGPPrefStruct *prefStruct)
{
	PGPUInt16	index;
	PGPBoolean	prefBoolean;
	PGPUInt32	prefNumber;
	char *		prefString;
	PGPSize		dataSize;
	void *		prefData;
	PGPByte		rawData[sizeof(PGPUInt32)];
	PGPError	err = kPGPError_NoErr;

	for (index=0; index<prefStruct->numMembers; index++)
	{
		switch (prefStruct->members[index].type)
		{
		case kPGPPrefType_Boolean:
			err = PGPGetPrefStructBoolean(prefRef, prefStruct, index,
					&prefBoolean);
			
			if (IsntPGPError(err))
				PGPContinueHash(hashRef, &prefBoolean, sizeof(PGPBoolean));
			break;

		case kPGPPrefType_Number:
			err = PGPGetPrefStructNumber(prefRef, prefStruct, index,
					&prefNumber);
			
			if (IsntPGPError(err))
			{
				PGPUInt32ToEndian(prefNumber, kPGPBigEndian, rawData);
				PGPContinueHash(hashRef, rawData, sizeof(PGPUInt32));
			}
			break;
			
			err = PGPGetPrefStructString(prefRef, prefStruct,
					index, &prefString);
			
			if (IsntPGPError(err) && IsntNull(prefString))
			{
				PGPContinueHash(hashRef, prefString, strlen(prefString));
				PGPFreeData(prefString);
			}
			break;
			
		case kPGPPrefType_Byte:
			err = PGPGetPrefStructByte(prefRef, prefStruct,
					index, &dataSize, &prefData);
			
			if (IsntPGPError(err) && IsntNull(prefData))
			{
				PGPContinueHash(hashRef, prefData, dataSize);
				PGPFreeData(prefData);
			}
			break;

		default:
			break;
		}
	}

	return err;
}


/*__Editor_settings____

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