ckeyserver.cpp

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

				
				
				case kPGPKeyServerClass_NetToolsCA:
				{
					result = new CHTTPXcertServer(	inContext,
													inHostName,
													0,
													inHostPort,
													inPath,
													inType,
													inClass);
				}
				break;

				default:
					ThrowPGPError_( kPGPError_FeatureNotAvailable );
					break;
			
			}
		}
		if (result == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
	}
	
	catch (...) {
		delete result;
		throw;
	}
	
	return result;
}



	PGPBoolean
CKeyServer::Free()
{
	PGPBoolean	freedServer = FALSE;
	
	mRefCount--;
	
	if (mRefCount == 0) {
		if (mIsOpen) {
			ThrowPGPError_(kPGPError_ServerOpen);
		}

		delete this;
		freedServer = TRUE;
	}
	
	return( freedServer );
}


CKeyServer::CKeyServer(
	PGPContextRef			inContext,
	const char *			inHostName,
	PGPUInt32				inHostAddress,
	PGPUInt16				inHostPort,
	const char *			inPath,
	PGPKeyServerProtocol	inType,
	PGPKeyServerClass		inClass)
	: mContext(inContext), mHostName(0), mHostPort(inHostPort),
	  mHostAddress(inHostAddress), mPath(0), mClass(inClass), mType(inType), 
	  mEventHandler(0), mEventHandlerData(0),
	  mTLSSession(kInvalidPGPtlsSessionRef),
	  mErrorString(0), mSecured(false), mIsBusy(false), mIsOpen(false),
	  mCanceled(false), mRefCount(1)
#if PGP_WIN32
	  , mAsyncHostEntryRef(kPGPInvalidAsyncHostEntryRef)
#endif
{
	if (inHostName != 0) {
		mHostName = new char[strlen(inHostName) + 1];
		if (mHostName == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
		strcpy(mHostName, inHostName);
	}
	if (inPath != 0) {
		mPath = new char[strlen(inPath) + 2];
		if (mPath == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
		*mPath = '/';
		strcpy(mPath + 1, inPath);
	}
}



CKeyServer::~CKeyServer()
{
	delete[] mHostName;
	delete[] mErrorString;
	delete[] mPath;
}



	void
CKeyServer::SetIdleEventHandler(
	PGPEventHandlerProcPtr	inCallback,
	PGPUserValue			inUserData)
{
	SetThreadIdleEventHandler(inCallback, inUserData);
}



	void
CKeyServer::GetIdleEventHandler(
	PGPEventHandlerProcPtr *	outCallback,
	PGPUserValue *				outUserData)
{
	GetThreadIdleEventHandler(outCallback, outUserData);
}



	PGPError
CKeyServer::KeyServerIdleEventHandler(
	PGPContextRef	inContext,
	PGPEvent *		inEvent,
	PGPUserValue	callBackArg)
{
	PGPEventHandlerProcPtr	eventHandler;
	PGPUserValue			eventHandlerData;
	PGPError				result;
	
	(void) inContext;
	(void) inEvent;
	
	GetThreadIdleEventHandler(&eventHandler, &eventHandlerData);
	
	if (eventHandler != 0) {
		PGPContextRef	context = kInvalidPGPContextRef;
		PGPEvent		theEvent;
		
		pgpClearMemory(&theEvent, sizeof(theEvent));
		theEvent.type = kPGPEvent_KeyServerIdleEvent;
		theEvent.job = 0;
		theEvent.data.keyServerIdleData.keyServerRef =
									(PGPKeyServerRef) callBackArg;
		if (callBackArg != 0) {
			context = ((CKeyServer *) callBackArg)->mContext;
		}
		result = eventHandler(context, &theEvent, eventHandlerData);
		if (callBackArg != 0) {
			if (result != kPGPError_NoErr) {
				((CKeyServer *) callBackArg)->mCanceled = true;
			} else if (((CKeyServer *) callBackArg)->mCanceled) {
				result = kPGPError_UserAbort;
			}
		}
	} else {
		result = kPGPError_NoErr;
	}
	
	return result;
}



	void
CKeyServer::Open(
	PGPtlsSessionRef	inTLSSession)
{
	if (mIsOpen) {
		ThrowPGPError_(kPGPError_ServerOpen);
	}
	mTLSSession = inTLSSession;
	InitializeHostNameAndAddress(&mHostName, &mHostAddress);
	mIsOpen = true;
}



	void
CKeyServer::Close()
{
	mTLSSession = kInvalidPGPtlsSessionRef;
	mIsOpen = false;
	mSecured = false;
	mCanceled = false;
}



	void
CKeyServer::Cancel()
{
	StPreserveSocketsEventHandler	preserve(this);

	mCanceled = true;
#if PGP_WIN32
	if (PGPAsyncHostEntryRefIsValid(mAsyncHostEntryRef)) {
		PGPCancelAsyncHostEntryRef(mAsyncHostEntryRef);
		mAsyncHostEntryRef = kPGPInvalidAsyncHostEntryRef;
	}
#endif
}



	void
CKeyServer::GetHostName(
	char **	outHostName)
{
	InitializeHostNameAndAddress(&mHostName, &mHostAddress);
	*outHostName = (char *) PGPNewData(	PGPPeekContextMemoryMgr(mContext),
										strlen(mHostName) + 1,
										kPGPMemoryMgrFlags_None);
	if (*outHostName == 0) {
		ThrowPGPError_(kPGPError_OutOfMemory);
	}
	strcpy(*outHostName, mHostName);
}



	void
CKeyServer::GetAddress(
	PGPUInt32 &	outAddress)
{
	InitializeHostNameAndAddress(&mHostName, &mHostAddress);
	outAddress = mHostAddress;
}



	void
CKeyServer::GetPath(
	char **	outPath)
{
	*outPath = (char *) PGPNewData(	PGPPeekContextMemoryMgr(mContext),
									strlen(mPath) + 1,
									kPGPMemoryMgrFlags_None);
	if (*outPath == 0) {
		ThrowPGPError_(kPGPError_OutOfMemory);
	}
	strcpy(*outPath, mPath);
}



	void
CKeyServer::GetErrorString(
	char **	outErrorString)
{
	if (mErrorString != 0) {
		*outErrorString = (char *) PGPNewData(
										PGPPeekContextMemoryMgr(mContext),
										strlen(mErrorString) + 1,
										kPGPMemoryMgrFlags_None);
		if (*outErrorString == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
		strcpy(*outErrorString, mErrorString);
	}
}



	void
CKeyServer::SetErrorString(
	const char *	inErrorString)
{
	delete[] mErrorString;
	
	if (inErrorString == 0) {
		mErrorString = 0;
	} else {
		mErrorString = new char[strlen(inErrorString) + 1];
		if (mErrorString != 0) {
			strcpy(mErrorString, inErrorString);
		}
	}
}



	void
CKeyServer::InitOperation()
{
	SetErrorString(0);
	if (! mIsOpen) {
		ThrowPGPError_(kPGPError_ServerNotOpen);
	}
}



	void
CKeyServer::InitializeHostNameAndAddress(
	char **		inHostName,
	PGPUInt32 *	inHostAddress)
{
	StPreserveSocketsEventHandler	preserve(this);
	PGPHostEntry *					hostEntry = 0;

	if (*inHostName != 0) {
		PGPUInt32	tempAddress = PGPDottedToInternetAddress(*inHostName);
		
		if (((PGPError) tempAddress) != kPGPSockets_Error) {
			*inHostAddress = PGPNetToHostLong(tempAddress);
		} else {
			hostEntry = PGPGetHostByName(*inHostName);
			if (hostEntry == 0) {
 				ThrowPGPError_(PGPGetLastSocketsError());
			}
			*inHostAddress = PGPNetToHostLong(
 								*((PGPUInt32 *)hostEntry->h_addr));
		}
	} else if (*inHostAddress != 0) {
		char *theHostName;
		PGPInternetAddress	address;

		if( *inHostName != 0 ) {
			delete *inHostName;
		}
		
		address.s_addr = PGPHostToNetLong(*inHostAddress);
		theHostName = PGPInternetAddressToDottedString(address);
		if (theHostName == 0) {
			ThrowPGPError_(kPGPError_UnknownError);
		}

		*inHostName = new char[strlen(theHostName) + 1];
		if (*inHostName == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
		strcpy(*inHostName, theHostName);

	}

}



#if PGP_MACINTOSH
	void
CKeyServer::CreateThreadStorage(
	SKeyServerThreadContext **	outContext)
{
	OSStatus											err;
	ThreadID											theThreadID;
	map<ThreadID, SKeyServerThreadContext>::iterator	theIterator;
	SKeyServerThreadContext *							theResult = nil;

	try {
		err = ::GetCurrentThread(&theThreadID);
		if (err != noErr) {
			ThrowPGPError_(err);
		}
		theIterator = sThreadContextMap.find(theThreadID);
		if (theIterator != sThreadContextMap.end()) {
			theResult = new SKeyServerThreadContext;
			if (theResult == 0) {
				ThrowPGPError_(kPGPError_OutOfMemory);
			}
			*theResult = (*theIterator).second;
		} else {
			SKeyServerThreadContext	tempContext;

			pgpClearMemory( &tempContext, sizeof(SKeyServerThreadContext) );
			pgpLeaksSuspend();
			sThreadContextMap[theThreadID] = tempContext;
			pgpLeaksResume();
			
			theIterator = sThreadContextMap.find(theThreadID);
			if (theIterator == sThreadContextMap.end()) {
				ThrowPGPError_(kPGPError_OutOfMemory);
			}
		}
		(*theIterator).second.idleEventHandler = 0;
		(*theIterator).second.idleEventHandlerData = 0;
	}
	
	catch (...) {
		delete theResult;
		throw;
	}
	
	*outContext = theResult;
}



	void
CKeyServer::DisposeThreadStorage(
	SKeyServerThreadContext *	inContext)
{
	ThreadID	theThreadID;
	OSStatus	err;									
	
	err = ::GetCurrentThread(&theThreadID);
	if (err != noErr) {
		ThrowPGPError_(err);
	}
	if (inContext != 0) {
		sThreadContextMap[theThreadID] = *inContext;
		delete inContext;
	} else {
		map<ThreadID, SKeyServerThreadContext>::iterator	theIterator;

		theIterator = sThreadContextMap.find(theThreadID);
		if (theIterator != sThreadContextMap.end()) {
			sThreadContextMap.erase(theThreadID);
		}
	}
		
}
	static SKeyServerThreadContext *
GetThreadContext()
{
	OSStatus											err;
	ThreadID											theThreadID;
	map<ThreadID, SKeyServerThreadContext>::iterator	theIterator;
	SKeyServerThreadContext *							theResult = nil;
	
	try {
		err = ::GetCurrentThread(&theThreadID);
		if (err != noErr) {
			ThrowPGPError_(err);
		}
		theIterator = sThreadContextMap.find(theThreadID);
		if (theIterator == sThreadContextMap.end()) {
			ThrowPGPError_(kPGPError_SocketsNoStaticStorage);
		}

		theResult = &(*theIterator).second;
	}
	
	catch (...) {
	}
	
	return theResult;
}



	void
CKeyServer::GetThreadIdleEventHandler(
	PGPEventHandlerProcPtr *	outCallback,
	PGPUserValue *				outUserData)
{
	SKeyServerThreadContext *	theContext = GetThreadContext();
	
	if (theContext != 0) {
		*outCallback = theContext->idleEventHandler;
		*outUserData = theContext->idleEventHandlerData;
	} else {
		*outCallback = 0;
		*outUserData = 0;
	}
}



	void
CKeyServer::SetThreadIdleEventHandler(
	PGPEventHandlerProcPtr	inCallback,
	PGPUserValue			inUserData)
{
	SKeyServerThreadContext *	theContext = GetThreadContext();
	
	if (theContext != 0) {
		theContext->idleEventHandler = inCallback;
		theContext->idleEventHandlerData = inUserData;
	}
}



#elif PGP_OSX
	void
CKeyServer::CreateThreadStorage(
	SKeyServerThreadContext **	outContext)
{
	*outContext = new SKeyServerThreadContext;
	if (*outContext == 0) {
		ThrowPGPError_(kPGPError_OutOfMemory);
	}
	GetThreadIdleEventHandler(	&(*outContext)->idleEventHandler,
								&(*outContext)->idleEventHandlerData);
}



	void
CKeyServer::GetThreadIdleEventHandler(
	PGPEventHandlerProcPtr *	outCallback,
	PGPUserValue *				outUserData)
{
	if (sIdleEventHandler != NULL) {
		*outCallback = sIdleEventHandler;
		*outUserData = sIdleEventHandlerData;
	} else {
		*outCallback = 0;
		*outUserData = 0;
	}
}



	void
CKeyServer::SetThreadIdleEventHandler(
	PGPEventHandlerProcPtr	inCallback,
	PGPUserValue			inUserData)
{
	sIdleEventHandler = inCallback;
	sIdleEventHandlerData = inUserData;
}



	void
CKeyServer::DisposeThreadStorage(
	SKeyServerThreadContext *	inContext)
{
	if (inContext != 0) {
		SetThreadIdleEventHandler(	inContext->idleEventHandler,
									inContext->idleEventHandlerData);
		delete inContext;
	}
}



#elif PGP_WIN32
	void
CKeyServer::GetThreadIdleEventHandler(
	PGPEventHandlerProcPtr *	outCallback,
	PGPUserValue *				outUserData)
{
	PGPRMWOLockStartReading(&sThreadLock);
	*outCallback = (PGPEventHandlerProcPtr)
					TlsGetValue(sIdleEventHandlerIndex);
	*outUserData = (PGPUserValue) TlsGetValue(sIdleEventHandlerDataIndex);
	PGPRMWOLockStopReading(&sThreadLock);
}



	void
CKeyServer::SetThreadIdleEventHandler(
	PGPEventHandlerProcPtr	inCallback,
	PGPUserValue			inUserData)
{
	PGPRMWOLockStartWriting(&sThreadLock);
	if (TlsSetValue(sIdleEventHandlerIndex, inCallback)) {
		if (! TlsSetValue(sIdleEventHandlerDataIndex, inUserData)) {
			TlsSetValue(sIdleEventHandlerIndex, 0);
		}
	}
	PGPRMWOLockStopWriting(&sThreadLock);
}


	void
CKeyServer::CreateThreadStorage(
	SKeyServerThreadContext **	outContext)
{
	*outContext = new SKeyServerThreadContext;
	if (*outContext == 0) {
		ThrowPGPError_(kPGPError_OutOfMemory);
	}
	GetThreadIdleEventHandler(	&(*outContext)->idleEventHandler,
								&(*outContext)->idleEventHandlerData);
}



	void
CKeyServer::DisposeThreadStorage(
	SKeyServerThreadContext *	inContext)
{
	if (inContext != 0) {
		SetThreadIdleEventHandler(	inContext->idleEventHandler,
									inContext->idleEventHandlerData);
		delete inContext;
	}
}

#elif PGP_UNIX

	void
CKeyServer::GetThreadIdleEventHandler(
	PGPEventHandlerProcPtr *	outCallback,
	PGPUserValue *				outUserData)
{
	(void) outCallback;
	(void) outUserData;
	
	ThrowPGPError_(kPGPError_ServerOperationNotSupported);
}



	void
CKeyServer::SetThreadIdleEventHandler(
	PGPEventHandlerProcPtr	inCallback,
	PGPUserValue			inUserData)
{
	(void) inCallback;
	(void) inUserData;
	
	ThrowPGPError_(kPGPError_ServerOperationNotSupported);
}


		void
CKeyServer::CreateThreadStorage(
	SKeyServerThreadContext **	outContext)
{
	*outContext = 0;
}



	void
CKeyServer::DisposeThreadStorage(
	SKeyServerThreadContext *	inContext)
{
}

#endif