pgpskep.c

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

			if (IsntPGPError(err))
				weConfirmed = TRUE;
			else
				weConfirmed = FALSE;

			err = kPGPError_NoErr;
		}

		if (IsntPGPError(err))
			err = sSocketReceive(skep, socketIn, &version, 1, FALSE, 
					&progressData);
		else
			remoteKey = NULL;

		if (IsntPGPError(err))
		{
			if (version != kPGPskepMajor)
				err = kPGPClientError_IncorrectSKEPVersion;
		}

		if (IsntPGPError(err))
			err = sSocketReceive(skep, socketIn, &version, 1, FALSE, 
					&progressData);

		if (IsntPGPError(err))
			err = sSocketReceive(skep, socketIn, &theyConfirmed, 1, FALSE, 
					&progressData);

		if (IsntPGPError(err))
		{
			err = sSocketSend(skep, socketIn, &weConfirmed, 1, FALSE, 
					&progressData);

			if (!theyConfirmed)
				err = kPGPClientError_RejectedSKEPAuthentication;

			if (!weConfirmed)
				err = kPGPError_UserAbort;
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &shareDataSize, 
					sizeof(shareDataSize), TRUE, &progressData);

			progressData.bytesTotal = sizeof(shareDataSize) + shareDataSize + 
										sizeof(dataSize) + sizeof(dataSize) +
										sizeof(PGPKeyID) + sizeof(PGPShareID) +
										sizeof(threshold) + sizeof(numShares) + 
										sizeof(totalShares) + 4;
		}

		if (IsntPGPError(err))
		{
			shareData = (PGPByte *) 
						PGPNewSecureData(PGPPeekContextMemoryMgr(skep->context),
							shareDataSize, kPGPMemoryMgrFlags_Clear);

			if (shareData == NULL)
			{
				err = kPGPError_OutOfMemory;;
				pgpAssertNoErr(err);
			}
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &dataSize, 
					sizeof(dataSize), TRUE, &progressData);
		}

		if (IsntPGPError(err) && (dataSize != sizeof(PGPKeyID)))
		{
			pgpAssert(dataSize == sizeof(PGPKeyID));
			err = kPGPError_CorruptData;
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &keyID, sizeof(PGPKeyID), 
					FALSE, &progressData);
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &dataSize, 
					sizeof(dataSize), TRUE, &progressData);
		}

		if (IsntPGPError(err) && (dataSize != sizeof(PGPShareID)))
		{
			pgpAssert(dataSize == sizeof(PGPShareID));
			err = kPGPError_CorruptData;
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &shareID, sizeof(PGPShareID), 
					FALSE, &progressData);
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &threshold, sizeof(threshold),
					TRUE, &progressData);
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &numShares, sizeof(numShares),
					TRUE, &progressData);
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, &totalShares, 
					sizeof(totalShares), TRUE, &progressData);
		}

		if (IsntPGPError(err))
		{
			err = sSocketReceive(skep, socketIn, shareData, 
					(PGPInt32) shareDataSize, FALSE, &progressData);
		}

		if (IsntPGPError(err))
		{
			skepEvent.type = kPGPskepEvent_CloseEvent;
			if (skep->eventHandler != NULL)
				err = skep->eventHandler(skep, &skepEvent, 
						skep->userValue);
		}

		if (IsntPGPError(err))
		{
			progressData.bytesTotal = 0;
			err = sSocketSend(skep, socketIn, &closing, sizeof(closing), TRUE,
					&progressData);
		}

		if (IsntNull(tlsSession))
		{
			if (IsntNull(remoteKey))
				PGPtlsClose(tlsSession, FALSE);
			else
				PGPtlsClose(tlsSession, TRUE);
			PGPFreeTLSSession(tlsSession);
		}

		if (IsntNull(socketIn))
		{
			PGPCloseSocket(socketIn);
			skep->socketIn = NULL;
		}

		if (IsntPGPError(err) && IsntNull(shareData))
		{
			err = pgpCreateShares(skep->context, keyID, shareID, threshold, 
					numShares, totalShares, shareDataSize, shareData, &shares);
			pgpAssertNoErr(err);
		}

		if (IsntNull(shareData))
			PGPFreeData(shareData);
			
		if (IsntPGPError(err))
		{
			skepEvent.type = kPGPskepEvent_ShareEvent;
			skepEvent.data.sd.shares = shares;

			if (skep->eventHandler != NULL)
				err = skep->eventHandler(skep, &skepEvent, 
						skep->userValue);
		}

		if (!weConfirmed)
			err = kPGPError_NoErr;
	}

	if (IsntNull(newPassphrase))
		PGPFreeData(newPassphrase);

	if (IsntNull(newPasskey))
		PGPFreeData(newPasskey);

	if (IsntNull(socket))
	{
		PGPCloseSocket(socket);
		skep->socketOut = NULL;
	}

	if (IsntNull(skep->eventHandler))
		PGPSetSocketsIdleEventHandler(oldCallback, oldUserValue);

	PGPSocketsDisposeThreadStorage(previousStorage);
	PGPSocketsCleanup();

	if (skep->cancel == TRUE)
		err = kPGPError_NoErr;

	return err;
}


PGPError PGPskepCancel(PGPskepRef skep)
{
	PGPValidateSKEP(skep);
	pgpAssertMsg(skep->magic == kPGPskepMagic, "Invalid SKEP object");

	if (IsntNull(skep->socketIn))
	{
		PGPCloseSocket(skep->socketIn);
		skep->socketIn = NULL;
	}

	if (IsntNull(skep->socketOut))
	{
		PGPCloseSocket(skep->socketOut);
		skep->socketOut = NULL;
	}
#if PGP_WIN32
	if (PGPAsyncHostEntryRefIsValid(skep->asyncHostEntryRef)) {
		PGPCancelAsyncHostEntryRef(skep->asyncHostEntryRef);
		skep->asyncHostEntryRef = kPGPInvalidAsyncHostEntryRef;
	}
#endif

	skep->cancel = TRUE;

	return kPGPError_NoErr;
}


PGPError PGPFreeSKEP(PGPskepRef skep)
{
	PGPValidateSKEP(skep);
	pgpAssertMsg(skep->magic == kPGPskepMagic, "Invalid SKEP object");

	if (IsntNull(skep->socketIn) || IsntNull(skep->socketOut))
		PGPskepCancel(skep);	

	if (skep->freeTLSContext)
		PGPFreeTLSContext(skep->tlsContext);

	PGPFreeData(skep);
	return kPGPError_NoErr;
}

PGPContextRef PGPGetSKEPContext(PGPskepRef skep)
{
	PGPContextRef	context;
	
	if( PGPskepRefIsValid( skep ) )
	{
		if (skep->magic == kPGPskepMagic)
			context = skep->context;
		else
			context = kInvalidPGPContextRef;
	}
	else
	{
		context = kInvalidPGPContextRef;
	}
	
	return context;
}

static PGPError sSocketSend(PGPskepRef skep, PGPSocketRef socket, 
					void *data, PGPInt32 dataSize, PGPBoolean crossPlatform,
					PGPskepEventProgressData *progressData)
{
	PGPByte		tempData16[sizeof(PGPUInt16)];
	PGPByte		tempData32[sizeof(PGPUInt32)];
	PGPUInt16	data16;
	PGPUInt32	data32;
	PGPInt32	result = 0;

	if (crossPlatform)
	{
		if (dataSize == sizeof(PGPUInt16))
		{
			pgpCopyMemory(data, &data16, sizeof(PGPUInt16));
			PGPUInt16ToEndian(data16, kPGPskepEndian, tempData16);
			result = PGPSend(socket, tempData16, dataSize, kPGPSendFlagNone);
		}
		else
		{
			pgpCopyMemory(data, &data32, sizeof(PGPUInt32));
			PGPUInt32ToEndian(data32, kPGPskepEndian, tempData32);
			result = PGPSend(socket, tempData32, dataSize, kPGPSendFlagNone);
		}
	}
	else
		result = PGPSend(socket, data, dataSize, kPGPSendFlagNone);

	return sProcessResult(skep, result, progressData);
}

static PGPInt32 sReceive(PGPskepRef skep, PGPSocketRef sock, void *outBuffer,
				PGPInt32 inBufferSize, PGPInt32 inFlags)
{
	PGPInt32			result;
	PGPSocketSet		readSet;
	PGPSocketsTimeValue	tv;
	PGPError			err;
	PGPEvent			event;

	tv.tv_sec = kPGPskepReceiveTimeout;
	tv.tv_usec = 0;

	do
	{
		PGPSOCKETSET_ZERO (&readSet);
		PGPSOCKETSET_SET ((PGPInt32) sock, &readSet);
		result = PGPSelect ((PGPInt32) sock + 1, &readSet, NULL, NULL, &tv);
		
		err = sSocketCallback (skep->context, &event, (PGPUserValue) skep);
	} while ((result <= 0) && (!PGPSOCKETSET_ISSET(sock, &readSet)) && (IsntPGPError (err)));
	
	if (IsPGPError (err))
		return kPGPSockets_Error;
		
	result = PGPReceive (sock, outBuffer, inBufferSize, inFlags);
	
	return result;
}


static PGPError sSocketReceive(PGPskepRef skep, PGPSocketRef socket, 
					void *data, PGPInt32 dataSize, PGPBoolean crossPlatform,
					PGPskepEventProgressData *progressData)
{
	PGPByte		tempData16[sizeof(PGPUInt16)];
	PGPByte		tempData32[sizeof(PGPUInt32)];
	PGPUInt16	data16;
	PGPUInt32	data32;
	PGPInt32	result = 0;

	if (crossPlatform)
	{
		if (dataSize == sizeof(PGPUInt16))
			result = sReceive(skep, socket, tempData16, dataSize, 
						kPGPReceiveFlagNone);
		else
			result = sReceive(skep, socket, tempData32, dataSize, 
						kPGPReceiveFlagNone);

		if (result > 0)
		{
			if (dataSize == sizeof(PGPUInt16))
			{
				data16 = PGPEndianToUInt16(kPGPskepEndian, tempData16);
				pgpCopyMemory(&data16, data, sizeof(PGPUInt16));
			}
			else
			{
				data32 = PGPEndianToUInt32(kPGPskepEndian, tempData32);
				pgpCopyMemory(&data32, data, sizeof(PGPUInt32));
			}
		}
	}
	else
		result = sReceive(skep, socket, data, dataSize, kPGPReceiveFlagNone);

	return sProcessResult(skep, result, progressData);
}


static PGPError sProcessResult(PGPskepRef skep, PGPInt32 result,
					PGPskepEventProgressData *progressData)
{
	PGPskepEvent	skepEvent;
	PGPError		err = kPGPError_NoErr;

	if (result == 0)
		err = kPGPError_UserAbort;
	else if (result == kPGPSockets_Error)
	{
		err = PGPGetLastSocketsError();

		if (skep->cancel == TRUE)
			err = kPGPError_UserAbort;

		pgpAssertNoErr(err);
	}
	else
	{
		progressData->bytesSoFar += result;
		skepEvent.type = kPGPskepEvent_ProgressEvent;
		skepEvent.data.pd.bytesSoFar = progressData->bytesSoFar;
		skepEvent.data.pd.bytesTotal = progressData->bytesTotal;

		if ((skep->eventHandler != NULL) && (progressData->bytesTotal > 0))
			err = skep->eventHandler(skep, &skepEvent, 
					skep->userValue);
	}

	return err;
}


static PGPError sSocketCallback(PGPContextRef context, 
					struct PGPEvent *event, PGPUserValue userValue)
{
	PGPError		err	= kPGPError_NoErr;
	PGPskepRef		skep;
	PGPskepEvent	skepEvent;

	pgpAssert(event != NULL);
	(void) context;
	(void) event;
	skep = (PGPskepRef) userValue;
	
	if (skep->eventHandler != NULL)
	{
		skepEvent.type = kPGPskepEvent_NullEvent;
		err = skep->eventHandler(skep, &skepEvent, skep->userValue);
	}

	return err;
}


/*__Editor_settings____

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