pflprefs.c

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

					
					case kPGPPrefType_Struct:
						data.strct = (PGPPrefStruct *) arrayData;
						break;

					default:
						break;
					}

					err = sExportPrefData(memIO, 
							currentPrefData->data.a->type, 
							currentPrefData->data.a->elements[index].size,
							data);
				}
				break;

			default:
				err = sExportPrefData(memIO, currentPrefData->prefType,
						currentPrefData->dataLength, currentPrefData->data);
			}

			if (IsPGPError(err))
				break;

			sGetNextPrefData(currentPrefData, &currentPrefData);
		}
	}

	if (IsntPGPError(err))
		err = PGPIOGetEOF(memIO, &fileOffset);

	if (IsntPGPError(err))
	{
		if (fileOffset > MAX_PGPSize)
			*bufferSize = MAX_PGPSize;
		else
			*bufferSize = (PGPSize) fileOffset;

		*buffer = PGPNewData(prefRef->memoryMgr, *bufferSize, 
					kPGPMemoryMgrFlags_Clear);

		if (IsNull(*buffer))
			err = kPGPError_OutOfMemory;
	}

	if (IsntPGPError(err))
		err = PGPIOSetPos(memIO, 0);

	if (IsntPGPError(err))
		err = PGPIORead(memIO, *bufferSize, *buffer, &bytesRead);

	if (IsPGPError(err))
	{
		*bufferSize = 0;

		if (IsntNull(*buffer))
		{
			PGPFreeData(*buffer);
			*buffer = NULL;
		}
	}

	if (IsntNull(memIO))
		PGPFreeIO(memIO);

	return err;
}


static PGPError sImportPrefData(PGPIORef memIO, PGPPrefType prefType,
									PGPPrefStruct *templateStruct,
									PGPSize *dataLength, void **data)
{
	PGPError		err = kPGPError_NoErr;
	PGPUInt32		index;
	PGPBoolean		crossPlatform = FALSE;
	PGPBoolean		newStruct;
	PGPByte			numMembers;
	void *			memberData;
	PGPPrefStruct *	prefStruct = NULL;
	PGPPrefType		memberType;
	PGPSize			memberSize;
	PGPMemoryMgrRef	memoryMgr;

	*dataLength = 0;
	*data = NULL;

	memoryMgr = PGPIOGetMemoryMgr(memIO);

	switch (prefType)
	{
	case kPGPPrefType_Boolean:
		*dataLength = sizeof(PGPBoolean);
		crossPlatform = FALSE;
		break;

	case kPGPPrefType_Number:
		*dataLength = sizeof(PGPUInt32);
		crossPlatform = TRUE;
		break;

	case kPGPPrefType_String:
	case kPGPPrefType_Byte:
		err = sIORead(memIO, sizeof(PGPSize), TRUE, dataLength);
		crossPlatform = FALSE;
		break;

	case kPGPPrefType_Struct:
		err = sIORead(memIO, sizeof(PGPByte), FALSE, &numMembers);
		if (IsPGPError(err))
			break;

		if (IsntNull(templateStruct))
		{
			newStruct = FALSE;
			err = sCreatePrefStruct(memoryMgr, templateStruct, &prefStruct);
			if (IsPGPError(err))
				break;
		}
		else
		{
			newStruct = TRUE;
			prefStruct = (PGPPrefStruct *) PGPNewData(memoryMgr,
											sizeof(PGPPrefStruct),
											kPGPMemoryMgrFlags_Clear);
			
			if (IsNull(prefStruct))
			{
				err = kPGPError_OutOfMemory;
				break;
			}
			
			prefStruct->members = (PGPPrefStructMember *) 
								PGPNewData(memoryMgr,
									sizeof(PGPPrefStructMember) * numMembers,
									kPGPMemoryMgrFlags_Clear);
			
			if (IsNull(prefStruct->members))
			{
				err = kPGPError_OutOfMemory;
				break;
			}
			
			prefStruct->numMembers = numMembers;
		}

		for (index=0; index<numMembers; index++)
		{
			err = sIORead(memIO, sizeof(PGPUInt32), TRUE, &memberType);

			if (IsPGPError(err))
				break;

			err = sImportPrefData(memIO, memberType, NULL, &memberSize, 
					&memberData);

			if (IsPGPError(err))
				break;

			if (newStruct)
				prefStruct->members[index].type = memberType;

			if (index >= prefStruct->numMembers)
			{
				if (prefStruct->members[index].type == kPGPPrefType_String)
				{
					prefStruct->members[index].data = PGPNewData(memoryMgr,
														1,
														kPGPMemoryMgrFlags_Clear);

					prefStruct->members[index].size = 1;
				}

				if (IsntNull(memberData))
					PGPFreeData(memberData);
				continue;
			}

			if (memberType != prefStruct->members[index].type)
			{
				if (prefStruct->members[index].type == kPGPPrefType_String)
				{
					prefStruct->members[index].data = PGPNewData(memoryMgr,
														1,
														kPGPMemoryMgrFlags_Clear);

					prefStruct->members[index].size = 1;
				}

				if (IsntNull(memberData))
					PGPFreeData(memberData);
				continue;
			}

			prefStruct->members[index].size = memberSize;

			switch (prefStruct->members[index].type)
			{
			case kPGPPrefType_Boolean:
				prefStruct->members[index].data = (void *)(size_t)
												*((PGPBoolean *) memberData);
				PGPFreeData(memberData);
				break;

			case kPGPPrefType_Number:
				prefStruct->members[index].data = (void *)
												*((PGPUInt32 *) memberData);
				PGPFreeData(memberData);
				break;

			default:
				prefStruct->members[index].data = memberData;
				break;
			}
		}

		for (index=numMembers; index<prefStruct->numMembers; index++)
		{
			if (prefStruct->members[index].type == kPGPPrefType_String)
			{
				prefStruct->members[index].data = PGPNewData(memoryMgr,
													1,
													kPGPMemoryMgrFlags_Clear);

				prefStruct->members[index].size = 1;
			}
		}

		if (IsntPGPError(err))
			*data = prefStruct;
		break;

	default:
		break;
	}

	if (IsntPGPError(err))
	{
		if (prefType == kPGPPrefType_Struct)
			*data = prefStruct;
		else if (*dataLength > 0)
		{
			*data = PGPNewData(memoryMgr, *dataLength, 
						kPGPMemoryMgrFlags_Clear);

			if (IsNull(*data))
				err = kPGPError_OutOfMemory;
			else
				err = sIORead(memIO, *dataLength, crossPlatform, *data);
		}
	}

	return err;
}


PGPError PGPImportBufferToMemoryPrefs(PGPMemoryMgrRef memoryMgr,
										const void *buffer, 
										PGPSize bufferSize,
										const PGPPrefDefinition *prefs,
										PGPUInt32 numPrefs,
										PGPPrefRef *prefRef)
{
	PGPIORef		memIO = NULL;
	PGPPrefIndex	prefIndex;
	PGPPrefType		prefType;
	PGPUInt32		prefFlags;
	PGPUInt32		arraySize;
	PGPUInt32		index;
	PGPPrefType		arrayType;
	PGPPrefStruct *	tempStruct = NULL;
	PGPPrefStruct *	templateStruct = NULL;
	PGPPrefArray *	prefArray = NULL;
	PGPPrefData *	currentPrefData;
	PGPSize			dataLength;
	void *			data;
	PGPError		err = kPGPError_NoErr;

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

	PGPValidateParam(bufferSize > 0);
	PGPValidatePtr(buffer);

	err = PGPNewMemoryPrefs(memoryMgr, prefs, numPrefs, prefRef);
	if (IsPGPError(err))
	{
		if (IsntNull(*prefRef))
		{
			sFreePref(*prefRef);
			*prefRef = NULL;
		}
		
		return err;
	}

	err = PGPNewMemoryIO(memoryMgr, (PGPMemoryIORef *) &memIO);
	
	if (IsntPGPError(err))
		err = PGPIOWrite(memIO, bufferSize, buffer);

	if (IsntPGPError(err))
		err = PGPIOSetPos(memIO, 0);

	while (IsntPGPError(err) && !PGPIOIsAtEOF(memIO))
	{
		err = sIORead(memIO, sizeof(PGPUInt32), TRUE, &prefIndex);
		if (IsPGPError(err))
			break;

		err = sIORead(memIO, sizeof(PGPUInt32), TRUE, &prefType);
		if (IsPGPError(err))
			break;

		err = sIORead(memIO, sizeof(PGPUInt32), TRUE, &prefFlags);
		if (IsPGPError(err))
			break;

		switch (prefType)
		{
		case kPGPPrefType_Array:
			prefArray = NULL;
			tempStruct = NULL;
			templateStruct = NULL;

			err = sIORead(memIO, sizeof(PGPUInt32), TRUE, &arraySize);
			if (IsPGPError(err))
				break;

			err = sIORead(memIO, sizeof(PGPUInt32), TRUE, &arrayType);
			if (IsPGPError(err))
				break;

			if (arrayType == kPGPPrefType_Struct)
			{
				err = sImportPrefData(memIO, arrayType, NULL, &dataLength, 
						(void **) &tempStruct);

				if (IsntPGPError(err))
					err = sFindPrefDataByIndex(*prefRef, prefIndex, 
							&currentPrefData);

				if (IsntPGPError(err) && IsntNull(currentPrefData))
					templateStruct = currentPrefData->data.a->templateStruct;
				else
					templateStruct = tempStruct;

				if (IsntPGPError(err))
					err = PGPCreatePrefArray(*prefRef, arrayType, arraySize,
							templateStruct, &prefArray);
			}
			else
				err = PGPCreatePrefArray(*prefRef, arrayType, arraySize, NULL,
						&prefArray);

			if (IsPGPError(err))
				break;

			prefArray->type = arrayType;
			prefArray->numElements = arraySize;

			for (index=0; index<arraySize; index++)
			{
				err = sImportPrefData(memIO, arrayType, templateStruct, 
						&(prefArray->elements[index].size), &data);

				switch (arrayType)
				{
				case kPGPPrefType_Boolean:
					prefArray->elements[index].data = (void *)(size_t) 
														*((PGPBoolean *) data);
					PGPFreeData(data);
					break;

				case kPGPPrefType_Number:
					prefArray->elements[index].data = (void *)
														*((PGPUInt32 *) data);
					PGPFreeData(data);
					break;

				default:
					prefArray->elements[index].data = data;
					break;
				}

				if (IsPGPError(err))
					break;
			}

			if (IsntPGPError(err))
				err = PGPSetPrefData(*prefRef, prefIndex, sizeof(PGPPrefArray),
						prefArray);

			if (IsntNull(prefArray))
				PGPFreePrefArray(prefArray);
			if (IsntNull(tempStruct))
				PGPFreePrefStruct(tempStruct);
			break;

		case kPGPPrefType_Struct:
			err = sFindPrefDataByIndex(*prefRef, prefIndex, &currentPrefData);
			
			if (IsntPGPError(err) && IsntNull(currentPrefData))
				templateStruct = currentPrefData->data.a->templateStruct;
			else
				templateStruct = NULL;

			err = sImportPrefData(memIO, prefType, templateStruct, 
					&dataLength, &data);

			if (IsntPGPError(err))
				err = PGPSetPrefData(*prefRef, prefIndex, dataLength, data);

			if (IsntNull(data))
				PGPFreePrefStruct(data);
			break;

		default:
			err = sImportPrefData(memIO, prefType, NULL, &dataLength, &data);
			if (IsntPGPError(err))
				err = PGPSetPrefData(*prefRef, prefIndex, dataLength, data);

			if (IsntNull(data))
					PGPFreeData(data);
			break;
		}

		if (IsntPGPError(err))
			err = sCopyPrefFlags(*prefRef, prefIndex, prefFlags);

		if (err == kPGPError_PrefNotFound)
			err = kPGPError_NoErr;
	}

	if (IsntNull(memIO))
		PGPFreeIO(memIO);

	if (IsPGPError(err))
	{
		if (IsntNull(*prefRef))
		{
			sFreePref(*prefRef);
			*prefRef = NULL;
		}
	}

	return err;
}


PGPError PGPGetPrefFlags(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPUInt32 *flags)
{
	PGPPrefData *	currentPrefData;
	PGPError		err = kPGPError_NoErr;

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

	PGPValidatePref(prefRef);
	PGPValidatePtr(flags);

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

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	*flags = currentPrefData->flags;
	return err;
}


PGPError PGPSetPrefFlags(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPUInt32 bitmask)
{
	PGPPrefData *	currentPrefData;
	PGPUInt32		oldFlags;
	PGPError		err = kPGPError_NoErr;

	PGPValidatePref(prefRef);

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

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	oldFlags = currentPrefData->flags;
	currentPrefData->flags |= bitmask;
	if (currentPrefData->flags != oldFlags)
		prefRef->dirty = TRUE;

	return err;
}


PGPError PGPClearPrefFlags(PGPPrefRef prefRef,
							PGPPrefIndex prefIndex,
							PGPUInt32 bitmask)
{
	PGPPrefData *	currentPrefData;
	PGPUInt32		oldFlags;
	PGPError		err = kPGPError_NoErr;

	PGPValidatePref(prefRef);

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

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	oldFlags = currentPrefData->flags;
	currentPrefData->flags &= ~bitmask;
	if (currentPrefData->flags != oldFlags)
		prefRef->dirty = TRUE;

	return err;
}


void PGPSetPrefUserValue(PGPPrefRef prefRef,
						PGPUserValue userValue,
						PGPFreePrefsUserValueProc proc)
{
	prefRef->userValue = userValue;
	prefRef->userValueFreeProc = proc;
}


PGPUserValue PGPGetPrefUserValue(PGPPrefRef prefRef)
{
	return prefRef->userValue;
}


PGPError PGPSetPrefWrap(PGPPrefRef prefRef,
							PGPUInt32 wrap)
{
	PGPValidatePref(prefRef);

	prefRef->wrap = wrap;
	return kPGPError_NoErr;
}


static PGPError sCopyPrefFlags(PGPPrefRef prefRef,
					PGPPrefIndex prefIndex,
					PGPUInt32 flags)
{
	PGPPrefData *	currentPrefData;
	PGPError		err = kPGPError_NoErr;

	PGPValidatePref(prefRef);

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

	if (IsNull(currentPrefData))
		return kPGPError_PrefNotFound;

	if (currentPrefData->flags != flags)
	{
		prefRef->dirty = TRUE;