ckeyserver.cpp

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1997 Network Associates Inc. and affiliated companies.
	All rights reserved.
	
	
	
	$Id: CKeyServer.cpp,v 1.46.6.2 1999/06/04 01:12:05 heller Exp $
____________________________________________________________________________*/

#if PGP_MACINTOSH
#include <Threads.h>
#include <map>

#elif PGP_WIN32
#include <windows.h>
#endif

#if PGP_WIN32 || PGP_UNIX
#include "pgpRMWOLock.h"
#endif

#include <string.h>

#include "pgpStrings.h"
#include "pgpMemoryMgr.h"
#include "pgpEncode.h"
#include "pgpContext.h"
#include "pgpMem.h"

#include "pgpSockets.h"

#include "CLDAPKeyServer.h"
#include "CCRSEntrustServer.h"
#include "CCRSVerisignServer.h"
#include "CHTTPPGPKeyServer.h"
#include "CHTTPXcertServer.h"
#include "CKeyServer.h"


PGPBoolean				CKeyServer::sIsInitialized = FALSE;

struct SThreadContext {
	PGPEventHandlerProcPtr	idleEventHandler;
	PGPUserValue			idleEventHandlerData;
};


#if PGP_WIN32
PGPRMWOLock				CKeyServer::sThreadLock;
PGPInt32				CKeyServer::sIdleEventHandlerIndex = 0;
PGPInt32				CKeyServer::sIdleEventHandlerDataIndex = 0;
#endif

#if PGP_MACINTOSH
static map<ThreadID, SThreadContext>	sThreadContextMap;
extern ThreadID							gMainThreadID;
#endif

static const PGPUInt16			kPGPKeyServerPortLDAP = 389;
static const PGPUInt16			kPGPKeyServerPortLDAPS = 636;
static const PGPUInt16			kPGPKeyServerPortHTTPPGP = 11371;
static const PGPUInt16			kPGPKeyServerPortHTTP = 80;
static const PGPUInt16			kPGPKeyServerPortHTTPS = 443;
static const char *				kProtocolSeparator = "://";
static const char *				kProtocolTag[] = {	"LDAPS:", "HTTPS:",
													"LDAP:", "HTTP:",
													0};
static const PGPKeyServerProtocol	kProtocolType[] = {	kPGPKeyServerProtocol_LDAPS,
													kPGPKeyServerProtocol_HTTPS,
													kPGPKeyServerProtocol_LDAP,
													kPGPKeyServerProtocol_HTTP};


#if PGP_UNIX	// No need to save the idle event handler
StPreserveSocketsEventHandler::StPreserveSocketsEventHandler(
	CKeyServer * inKeyServer)
{
	(void) inKeyServer;
}



StPreserveSocketsEventHandler::~StPreserveSocketsEventHandler()
{
}

#else
StPreserveSocketsEventHandler::StPreserveSocketsEventHandler(
	CKeyServer * inKeyServer)
{
	PGPError				pgpError = kPGPError_NoErr;
	PGPEventHandlerProcPtr	eventHandler;
	PGPUserValue			eventHandlerData;
	
	CKeyServer::GetThreadIdleEventHandler(&eventHandler, &eventHandlerData);
	
	if (eventHandler != 0) {
		pgpError = PGPSetSocketsIdleEventHandler(
										CKeyServer::KeyServerIdleEventHandler,
										inKeyServer);
	}
	
}



StPreserveSocketsEventHandler::~StPreserveSocketsEventHandler()
{
}
#endif	// idle event handler restoration

	void
CKeyServer::CheckInitialization()
{
	if (! sIsInitialized) {
		ThrowPGPError_(kPGPError_ServerNotInitialized);
	}
}

	void
CKeyServer::Initialize()
{
	PGPError	pgpError;
	
#if PGP_WIN32
	InitializePGPRMWOLock(&sThreadLock);
	sIdleEventHandlerIndex = TlsAlloc();
	if (! TlsSetValue(sIdleEventHandlerIndex, 0)) {
		ThrowPGPError_(kPGPError_UnknownError);
	}
	sIdleEventHandlerDataIndex = TlsAlloc();
	if (! TlsSetValue(sIdleEventHandlerDataIndex, 0)) {
		ThrowPGPError_(kPGPError_UnknownError);
	}
#endif

	pgpError = PGPSocketsInit();
	ThrowIfPGPError_(pgpError);
	
	sIsInitialized = TRUE;
}



	void
CKeyServer::Cleanup()
{
#if PGP_WIN32
	TlsFree(sIdleEventHandlerIndex);
	sIdleEventHandlerIndex = 0;
	TlsFree(sIdleEventHandlerDataIndex);
	sIdleEventHandlerDataIndex = 0;
	DeletePGPRMWOLock(&sThreadLock);
#endif

#if PGP_MACINTOSH
	sThreadContextMap.erase(	sThreadContextMap.begin(),
								sThreadContextMap.end());
#endif

	PGPSocketsCleanup();
	sIsInitialized = FALSE;
}
	


	CKeyServer *
CKeyServer::NewKeyServerFromURL(
	PGPContextRef			inContext,
	const char *			inURL,
	PGPKeyServerAccessType	inAccessType,
	PGPKeyServerKeySpace	inKeySpace,
	PGPKeyServerClass		inClass)
{
	CKeyServer *					result = 0;
	char *							url = 0;
	
	CheckInitialization();
	
	try {
		PGPKeyServerProtocol	keyServerType = (PGPKeyServerProtocol) 0;
		char *				host;
		PGPUInt16			port;
		char *				currentItem = 0;
		char *				nextItem = 0;
		
		url = new char[strlen(inURL) + 1];
		if (url == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
		strcpy(url, inURL);
		
		// Parse the URL
		currentItem = url;
		nextItem = strchr(currentItem, ':');
		
		// Determine the protocol
		if (nextItem != 0) {
			// Determine if we are at the port separator or protocol
			// separator
			if (pgpCompareStringsIgnoreCaseN(nextItem, kProtocolSeparator,
			strlen(kProtocolSeparator)) == 0) {
				// Determine protocol
				for (PGPUInt16 i = 0; kProtocolTag[i] != 0; i++) {
					if (pgpCompareStringsIgnoreCaseN(currentItem,
					kProtocolTag[i], strlen(kProtocolTag[i])) == 0) {
						keyServerType = kProtocolType[i];
						break;
					}
				}
				if (keyServerType == 0) {
					ThrowPGPError_(kPGPError_ServerInvalidProtocol);
				} else {
					nextItem += strlen(kProtocolSeparator);
				}
			} else {
				// Default to HTTP, colon must be for port
				keyServerType = kPGPKeyServerProtocol_HTTP;
				nextItem = url;
			}
		} else {
			// Default to HTTP
			keyServerType = kPGPKeyServerProtocol_HTTP;
			nextItem = url;
		}
		
		// Determine the host name and port
		host = currentItem = nextItem;
		nextItem = strchr(currentItem, ':');
		if (nextItem != 0) {
			// Found port
			currentItem = nextItem + 1;
			port = atoi(currentItem);
			*nextItem = '\0';
		} else {
			switch (keyServerType) {
				case kPGPKeyServerProtocol_LDAP:
				{
					port = kPGPKeyServerPortLDAP;
				}
				break;
				
				
				case kPGPKeyServerProtocol_LDAPS:
				{
					port = kPGPKeyServerPortLDAPS;
				}
				break;
				
				
				case kPGPKeyServerProtocol_HTTP:
				{
					if (inClass == kPGPKeyServerClass_PGP) {
						port = kPGPKeyServerPortHTTPPGP;
					} else {
						port = kPGPKeyServerPortHTTP;
					}
				}
				break;
				
				
				case kPGPKeyServerProtocol_HTTPS:
				{
					port = kPGPKeyServerPortHTTPS;
				}
				break;
				
				default:
				{
					pgpDebugMsg("NewKeyServerFromURL() Unknown server type");
					port = 0;
				}
				break;
			}
		}
		
		// Find path
		nextItem = strchr(currentItem, '/');
		if (nextItem != 0) {
			currentItem = nextItem + 1;
			*nextItem = '\0';
		} else {
			currentItem = 0;
		}

		result = NewKeyServerFromHostName(	inContext,
											host,
											port,
											currentItem,
											keyServerType,
											inAccessType,
											inKeySpace,
											inClass);
	}
	
	catch (...) {
		delete[] url;
		throw;
	}
	
	delete[] url;
	
	return result;
}



	CKeyServer *
CKeyServer::NewKeyServerFromHostAddress(
	PGPContextRef			inContext,
	PGPUInt32				inHostAddress,
	PGPUInt16				inHostPort,
	PGPKeyServerProtocol	inType,
	PGPKeyServerAccessType	inAccessType,
	PGPKeyServerKeySpace	inKeySpace,
	PGPKeyServerClass		inClass)
{
	CKeyServer *	result = 0;

	CheckInitialization();
	
	try {
		if (inHostPort == 0) {
			switch (inType) {
				case kPGPKeyServerProtocol_LDAP:
				{
					inHostPort = kPGPKeyServerPortLDAP;
				}
				break;
				
				
				case kPGPKeyServerProtocol_LDAPS:
				{
					inHostPort = kPGPKeyServerPortLDAPS;
				}
				break;
				
				
				case kPGPKeyServerProtocol_HTTP:
				{
					if (inClass == kPGPKeyServerClass_PGP) {
						inHostPort = kPGPKeyServerPortHTTPPGP;
					} else {
						inHostPort = kPGPKeyServerPortHTTP;
					}
				}
				break;
				
				
				case kPGPKeyServerProtocol_HTTPS:
				{
					inHostPort = kPGPKeyServerPortHTTPS;
				}
				break;
				
				default:
				{
					pgpDebugMsg(
					"NewKeyServerFromHostAddress(): Unknown server type" );
					inHostPort = 0;
				}
				break;
			}
		}
		if ((inType == kPGPKeyServerProtocol_LDAP)
		|| (inType == kPGPKeyServerProtocol_LDAPS)) {
			if (inClass != kPGPKeyServerClass_PGP) {
				ThrowPGPError_(kPGPError_FeatureNotAvailable);
			}
			result = new CLDAPKeyServer(	inContext,
											0,
											inHostAddress,
											inHostPort,
											inType,
											inAccessType,
											inKeySpace);
		} else {
			switch (inClass) {
				case kPGPKeyServerClass_PGP:
				{
					result = new CHTTPPGPKeyServer(	inContext,
													0,
													inHostAddress,
													inHostPort,
													inType);
				}
				break;
				
				
				case kPGPKeyServerClass_Verisign:
				{
					result = new CCRSVerisignServer(	inContext,
														0,
														inHostAddress,
														inHostPort,
														0,
														inType);
				}
				break;
				
				
				case kPGPKeyServerClass_Entrust:
				{
					result = new CCRSEntrustServer(	inContext,
													0,
													inHostAddress,
													inHostPort,
													0,
													inType);
				}
				break;
				
				
				case kPGPKeyServerClass_NetToolsCA:
				{
					result = new CHTTPXcertServer(	inContext,
													0,
													inHostAddress,
													inHostPort,
													0,
													inType);
				}
				break;
				
				default:
					break;
			}
		}
		if (result == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
	}
	
	catch (...) {
		delete result;
		throw;
	}
	
	return result;
}



	CKeyServer *
CKeyServer::NewKeyServerFromHostName(
	PGPContextRef			inContext,
	const char *			inHostName,
	PGPUInt16				inHostPort,
	const char *			inPath,
	PGPKeyServerProtocol	inType,
	PGPKeyServerAccessType	inAccessType,
	PGPKeyServerKeySpace	inKeySpace,
	PGPKeyServerClass		inClass)
{
	CKeyServer *	result = 0;

	CheckInitialization();
	
	try {
		if (inHostPort == 0) {
			switch (inType) {
				case kPGPKeyServerProtocol_LDAP:
				{
					inHostPort = kPGPKeyServerPortLDAP;
				}
				break;
				
				
				case kPGPKeyServerProtocol_LDAPS:
				{
					inHostPort = kPGPKeyServerPortLDAPS;
				}
				break;
				
				
				case kPGPKeyServerProtocol_HTTP:
				{
					if (inClass == kPGPKeyServerClass_PGP) {
						inHostPort = kPGPKeyServerPortHTTPPGP;
					} else {
						inHostPort = kPGPKeyServerPortHTTP;
					}
				}
				break;
				
				
				case kPGPKeyServerProtocol_HTTPS:
				{
					inHostPort = kPGPKeyServerPortHTTPS;
				}
				break;
				
				default:
				{
					pgpDebugMsg(
					"NewKeyServerFromHostName(): Unknown server type" );
					inHostPort = 0;
				}
				break;
			}
		}
		if ((inType == kPGPKeyServerProtocol_LDAP)
		|| (inType == kPGPKeyServerProtocol_LDAPS)) {
			if (inClass != kPGPKeyServerClass_PGP) {
				ThrowPGPError_(kPGPError_FeatureNotAvailable);
			}
			result = new CLDAPKeyServer(	inContext,
											inHostName,
											0,
											inHostPort,
											inType,
											inAccessType,
											inKeySpace);
		} else {
			switch (inClass) {
				case kPGPKeyServerClass_PGP:
				{
					result = new CHTTPPGPKeyServer(	inContext,
													inHostName,
													0,
													inHostPort,
													inType);
				}
				break;
				
				
				case kPGPKeyServerClass_Verisign:
				{
					result = new CCRSVerisignServer(	inContext,
														inHostName,
														0,
														inHostPort,
														inPath,
														inType);
				}
				break;
				
				
				case kPGPKeyServerClass_Entrust:
				{
					result = new CCRSEntrustServer(	inContext,
													inHostName,
													0,
													inHostPort,
													inPath,
													inType);
				}
				break;
				
				
				case kPGPKeyServerClass_NetToolsCA:
				{
					result = new CHTTPXcertServer(	inContext,
													inHostName,
													0,
													inHostPort,
													inPath,
													inType);
				}
				break;
				
				default:
					break;
			}
		}
		if (result == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
	}
	
	catch (...) {
		delete result;
		throw;
	}
	
	return result;
}