pgpsharefile.c

vc环境下的pgp源码

				&((*shareFileRef)->decryptedShareSize));

	if (IsntPGPError(err))
		err = sIORead(fileIO, sizeof(PGPSize), TRUE,
				&((*shareFileRef)->shareDataSize));

	if (IsntPGPError(err) && ((*shareFileRef)->shareDataSize > 0) &&
		((*shareFileRef)->numShares > 0))
	{
		(*shareFileRef)->shareData = (PGPByte *) PGPNewData(
										(*shareFileRef)->memoryMgr, 
										(*shareFileRef)->shareDataSize, 
										kPGPMemoryMgrFlags_Clear);
	
		if ((*shareFileRef)->shareData != NULL)
			err = sIORead(fileIO, (*shareFileRef)->shareDataSize, FALSE,
					(*shareFileRef)->shareData);
		else
			err = kPGPError_OutOfMemory;
	}

	if (IsntPGPError(err))
		err = sIORead(fileIO, sizeof(PGPSize), TRUE,
				&((*shareFileRef)->shareHashSize));

	if (IsntPGPError(err) && ((*shareFileRef)->shareHashSize > 0))
	{
		(*shareFileRef)->shareHash = (PGPByte *) PGPNewData(
										(*shareFileRef)->memoryMgr, 
										(*shareFileRef)->shareHashSize, 
										kPGPMemoryMgrFlags_Clear);
	
		if ((*shareFileRef)->shareHash != NULL)
			err = sIORead(fileIO, (*shareFileRef)->shareHashSize, FALSE,
					(*shareFileRef)->shareHash);
		else
			err = kPGPError_OutOfMemory;
	}

	PGPFreeIO(fileIO);
	if (IsPGPError(err))
	{
		PGPFreeShareFile(*shareFileRef);
		*shareFileRef = NULL;
		return err;
	}

	return err;
}


PGPError PGPSaveShareFile(PGPShareFileRef shareFileRef)
{
	PGPError	err = kPGPError_NoErr;
	PGPIORef	fileIO;
	PGPUInt32	fileSize;
	PGPSize		dataSize;
	PGPUInt32	magic;

	PGPValidateShareFile(shareFileRef);

	sCalcShareFileSize(shareFileRef, &fileSize);
	err = PGPSetFileSize(shareFileRef->shareFileSpec, fileSize);

	if (IsPGPError(err))
		return err;

	err = PGPOpenFileSpec(	shareFileRef->shareFileSpec, 
							kPFLFileOpenFlags_ReadWrite, 
							(PGPFileIORef *) &fileIO);
	if (IsPGPError(err))
		return err;

	magic = kPGPShareFileMagic;
	err = sIOWrite(fileIO, sizeof(PGPUInt32), TRUE, &magic);

	if (IsntNull(shareFileRef->userID))
		dataSize = strlen(shareFileRef->userID) + 1;
	else
		dataSize = 0;

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPSize), TRUE, &dataSize);

	if (IsntPGPError(err) && (dataSize > 0))
		err = sIOWrite(fileIO, dataSize, FALSE,
				shareFileRef->userID);
	
	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPSize), TRUE, 
				&(shareFileRef->fingerprintSize));

	if (IsntPGPError(err) && (shareFileRef->fingerprintSize > 0))
		err = sIOWrite(fileIO, shareFileRef->fingerprintSize, FALSE,
				shareFileRef->fingerprint);
	
	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPKeyID), FALSE,
				&(shareFileRef->keyID));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPKeyID), FALSE,
				&(shareFileRef->sharedKeyID));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPShareID), FALSE,
				&(shareFileRef->shareID));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPUInt32), TRUE,
				&(shareFileRef->threshold));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPUInt32), TRUE,
				&(shareFileRef->numShares));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPUInt32), TRUE,
				&(shareFileRef->totalShares));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPSize), TRUE,
				&(shareFileRef->decryptedShareSize));

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPSize), TRUE,
				&(shareFileRef->shareDataSize));

	if (IsntPGPError(err) && (shareFileRef->shareDataSize > 0))
		err = sIOWrite(fileIO, shareFileRef->shareDataSize, FALSE,
				shareFileRef->shareData);

	if (IsntPGPError(err))
		err = sIOWrite(fileIO, sizeof(PGPSize), TRUE,
				&(shareFileRef->shareHashSize));

	if (IsntPGPError(err) && (shareFileRef->shareHashSize > 0))
		err = sIOWrite(fileIO, shareFileRef->shareHashSize, FALSE,
				shareFileRef->shareHash);

	PGPFreeIO(fileIO);
	return err;
}


PGPError PGPGetShareFileSpec(PGPShareFileRef shareFileRef,
				PFLFileSpecRef *shareFileSpec)
{
	PGPError err = kPGPError_NoErr;

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

	PGPValidateShareFile(shareFileRef);
	PGPValidatePtr(shareFileSpec);

	err = PFLCopyFileSpec(shareFileRef->shareFileSpec, shareFileSpec);
	if (IsPGPError(err))
		*shareFileSpec = NULL;

	return err;
}


PGPError PGPGetShareFileShareID(PGPShareFileRef shareFileRef, 
				PGPShareID *id)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareFileRefIsValid(shareFileRef));
	PGPValidatePtr(id);

	pgpCopyMemory(&(shareFileRef->shareID), id, sizeof(PGPShareID));

	return err;
}


PGPError PGPGetShareFileOwnerKeyID(PGPShareFileRef shareFileRef, 
				PGPKeyID *id)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareFileRefIsValid(shareFileRef));
	PGPValidatePtr(id);

	pgpCopyMemory(&(shareFileRef->keyID), id, sizeof(PGPKeyID));

	return err;
}


PGPError PGPSetShareFileOwnerKeyID(PGPShareFileRef shareFileRef, 
				const PGPKeyID id)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareFileRefIsValid(shareFileRef));

	pgpCopyMemory(&id, &(shareFileRef->keyID), sizeof(PGPKeyID));

	return err;
}


PGPError PGPGetShareFileOwnerFingerprint(PGPShareFileRef shareFileRef, 
				PGPSize bufferSize, void *fingerprint, PGPSize *fullSize)
{
	PGPError	err = kPGPError_NoErr;
	PGPSize		fingerprintSize;

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

	PGPValidateShareFile(shareFileRef);
	PGPValidateParam(bufferSize > 0);
	PGPValidatePtr(fingerprint);

	if (IsNull(shareFileRef->fingerprint))
		return kPGPError_NoErr;

	if (bufferSize < shareFileRef->fingerprintSize)
		fingerprintSize = bufferSize;
	else
		fingerprintSize = shareFileRef->fingerprintSize;

	pgpCopyMemory(shareFileRef->fingerprint, fingerprint, fingerprintSize);

	if (fullSize != NULL)
		*fullSize = shareFileRef->fingerprintSize;

	if (bufferSize < shareFileRef->fingerprintSize)
		err = kPGPError_BufferTooSmall;

	return err;
}


PGPError PGPSetShareFileOwnerFingerprint(PGPShareFileRef shareFileRef,
				PGPSize bufferSize, const void *fingerprint)
{
	PGPError	err = kPGPError_NoErr;

	PGPValidateShareFile(shareFileRef);
	PGPValidateParam(bufferSize > 0);
	PGPValidatePtr(fingerprint);

	if (shareFileRef->fingerprint != NULL)
		PGPFreeData(shareFileRef->fingerprint);

	shareFileRef->fingerprint = (char *) PGPNewData(shareFileRef->memoryMgr,
											bufferSize,
											kPGPMemoryMgrFlags_Clear);

	if (shareFileRef->fingerprint == NULL)
		return kPGPError_OutOfMemory;

	pgpCopyMemory(fingerprint, shareFileRef->fingerprint, bufferSize);
	shareFileRef->fingerprintSize = bufferSize;
	return err;
}


PGPError PGPGetShareFileSharedKeyID(PGPShareFileRef shareFileRef, 
				PGPKeyID *id)
{
	PGPError err = kPGPError_NoErr;

	PGPValidateParam(PGPShareFileRefIsValid(shareFileRef));
	PGPValidatePtr(id);

	pgpCopyMemory(&(shareFileRef->sharedKeyID), id, sizeof(PGPKeyID));

	return err;
}


PGPUInt32 PGPGetShareThresholdInFile(PGPShareFileRef shareFileRef)
{
	pgpAssert(PGPShareFileRefIsValid(shareFileRef));

	if (PGPShareFileRefIsValid(shareFileRef))
		return shareFileRef->threshold;
	else
		return 0;
}


PGPUInt32 PGPGetNumSharesInFile(PGPShareFileRef shareFileRef)
{
	pgpAssert(PGPShareFileRefIsValid(shareFileRef));
	
	if (PGPShareFileRefIsValid(shareFileRef))
		return shareFileRef->numShares;
	else
		return 0;
}


PGPBoolean IsSamePGPSharesInFiles(PGPShareFileRef firstFile, 
				PGPShareFileRef secondFile)
{
	PGPBoolean result = FALSE;

	if (!PGPShareFileRefIsValid(firstFile))
		return FALSE;
	if (!PGPShareFileRefIsValid(secondFile))
		return FALSE;

	if (firstFile->shareHashSize == secondFile->shareHashSize)
	{
		if (pgpMemoryEqual(firstFile->shareHash, secondFile->shareHash,
				firstFile->shareHashSize))
		{
			result = TRUE;
		}
	}

	return result;
}


static void sCalcShareFileSize(PGPShareFileRef shareFileRef, 
				PGPUInt32 *fileSize)
{
	pgpAssert(shareFileRef != NULL);
	pgpAssert(fileSize != NULL);

	*fileSize = sizeof(PGPUInt32)*4 + sizeof(PGPSize)*4 + 
					sizeof(PGPKeyID)*2 + shareFileRef->shareDataSize +
					sizeof(PGPShareID) + shareFileRef->shareHashSize;

	if (shareFileRef->userID != NULL)
		*fileSize += strlen(shareFileRef->userID) + 1;

	if (shareFileRef->fingerprint != NULL)
		*fileSize += shareFileRef->fingerprintSize;

	return;
}


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(kPGPShareFileEndian, tempData16);
				pgpCopyMemory(&data16, data, sizeof(PGPUInt16));
			}
			else
			{
				data32 = PGPEndianToUInt32(kPGPShareFileEndian, 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, kPGPShareFileEndian, tempData16);
			err = PGPIOWrite(fileIO, dataSize, tempData16);
		}
		else
		{
			pgpCopyMemory(data, &data32, sizeof(PGPUInt32));
			PGPUInt32ToEndian(data32, kPGPShareFileEndian, 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
_____________________*/