pgpkeyserverprefs.c

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

/*____________________________________________________________________________
	Copyright (C) 2002 PGP Corporation
	All rights reserved.

	$Id: pgpKeyServerPrefs.c,v 1.14 2002/09/03 20:59:44 dallen Exp $
____________________________________________________________________________*/
#include "pflPrefTypes.h"
#include "pgpBuild.h"
#include "pgpPFLErrors.h"
#include "pgpClientPrefs.h"
#include "pgpKeyServerPrefs.h"
#include "pgpDebug.h"
#include "pgpMem.h"

#include "pgpPFLPriv.h"

#include <string.h>
#include <stdio.h>
#include "pgpStrings.h"

	PGPError
PGPGetKeyServerPrefs(	PGPPrefRef				prefRef,
						PGPKeyServerEntry		**keyserverList,
						PGPUInt32				*keyserverCount)
{
	PGPError			err;
	PGPBoolean			badStruct = FALSE;
	PGPUInt32			index;
	PGPUInt16			structIndex;
	PGPPrefArray *		prefArray = NULL;
	PGPPrefStruct *		prefStruct = NULL;
	PGPMemoryMgrRef		memoryMgr = NULL;

	if (IsntNull(keyserverList))
		*keyserverList = NULL;
	if (IsntNull(keyserverCount))
		*keyserverCount = 0;

	PGPValidatePtr(keyserverList);
	PGPValidatePtr(keyserverCount);

	err = PGPGetPrefArray(	prefRef, 
							kPGPPrefKeyServerList, 
							&prefArray);

	if (IsntPGPError(err))
	{
		*keyserverCount = prefArray->numElements;

		if (prefArray->type != kPGPPrefType_Struct)
			badStruct = TRUE;

		else for (index=0; index<*keyserverCount; index++)
		{
			PGPGetPrefArrayStruct(prefRef, prefArray, index, &prefStruct);

			if (prefStruct->numMembers != LDAPKeyServer.numMembers)
				badStruct = TRUE;
			else 
			{
				for (structIndex=0; structIndex<prefStruct->numMembers;
				structIndex++)
				{
					if (prefStruct->members[structIndex].type !=
						LDAPKeyServer.members[structIndex].type)
					{
						badStruct = TRUE;
					}
				}
			}
		}
	}

	if (badStruct)
	{
		PGPFreePrefArray(prefArray);

		PGPClearPrefData(prefRef, kPGPPrefKeyServerList);

		err = PGPSetPrefArray(prefRef, kPGPPrefKeyServerList,
				&DefaultKeyServer);

		if (IsntPGPError(err))
			err = PGPGetPrefArray(	prefRef, 
									kPGPPrefKeyServerList, 
									&prefArray);
	}

	if (IsntPGPError(err))
	{
		PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

		*keyserverList = (PGPKeyServerEntry *) 
							PGPNewData(memoryMgr,
								sizeof(PGPKeyServerEntry) *
								prefArray->numElements,
								kPGPMemoryMgrFlags_Clear);

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

	if (IsntPGPError(err))
	{
		for (index=0; index<prefArray->numElements; index++)
		{
			err = PGPGetPrefArrayStruct(prefRef, prefArray, index,
					&prefStruct);

			if (IsPGPError(err))
				break;

			(*keyserverList)[index].protocol	= (PGPKeyServerProtocol)
													prefStruct->members[0].data;
			(*keyserverList)[index].type		= (PGPKeyServerClass)
													prefStruct->members[1].data;

			/* kPGPKeyServerClass_LDAPPGP is not used anymore */
			if ((*keyserverList)[index].type == kPGPKeyServerClass_LDAPPGP)
				(*keyserverList)[index].type = kPGPKeyServerClass_PGP;

			pgpCopyMemory(prefStruct->members[2].data,
				(*keyserverList)[index].domain, 
				prefStruct->members[2].size); 

			pgpCopyMemory(prefStruct->members[3].data,
				(*keyserverList)[index].serverDNS, 
				prefStruct->members[3].size); 

			(*keyserverList)[index].serverPort = (PGPUInt16)
												((PGPUInt32) prefStruct->members[4].data);

			pgpCopyMemory(prefStruct->members[5].data,
				(*keyserverList)[index].authKeyIDString, 
				prefStruct->members[5].size); 

			(*keyserverList)[index].authAlg = (PGPPublicKeyAlgorithm)
												prefStruct->members[6].data;

			(*keyserverList)[index].flags = (PGPUInt32)
											prefStruct->members[7].data;

			pgpCopyMemory(prefStruct->members[8].data,
				(*keyserverList)[index].keystoredn, 
				prefStruct->members[8].size); 
		}

		if (IsntPGPError(err))
			*keyserverCount = prefArray->numElements;
	}

	if (IsntNull(prefArray))
		PGPFreePrefArray(prefArray);

	return err;
}

	PGPError
PGPSetKeyServerPrefs(
	PGPPrefRef				prefRef,
	PGPKeyServerEntry		*keyserverList,
	PGPUInt32				keyserverCount )
{
	PGPError		err;
	PGPUInt32		index;
	PGPPrefArray *	prefArray = NULL;
	PGPPrefStruct *	prefStruct = NULL;
	PGPMemoryMgrRef	memoryMgr = NULL;

	PGPValidatePtr(keyserverList);

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	err = PGPCreatePrefArray(prefRef, kPGPPrefType_Struct, keyserverCount,
			&LDAPKeyServer, &prefArray);

	if (IsntPGPError(err))
	{
		for (index=0; index<keyserverCount; index++)
		{
			err = PGPCreatePrefStruct(prefRef, &LDAPKeyServer, &prefStruct);
			if (IsPGPError(err))
				break;

			PGPSetPrefStructNumber(prefRef, prefStruct, 0, 
				keyserverList[index].protocol);

			PGPSetPrefStructNumber(prefRef, prefStruct, 1, 
				keyserverList[index].type);

			PGPSetPrefStructString(prefRef, prefStruct, 2,
				keyserverList[index].domain);

			PGPSetPrefStructString(prefRef, prefStruct, 3,
				keyserverList[index].serverDNS);

			PGPSetPrefStructNumber(prefRef, prefStruct, 4, 
				keyserverList[index].serverPort);

			PGPSetPrefStructString(prefRef, prefStruct, 5,
				keyserverList[index].authKeyIDString);

			PGPSetPrefStructNumber(prefRef, prefStruct, 6, 
				keyserverList[index].authAlg);
			
			PGPSetPrefStructNumber(prefRef, prefStruct, 7, 
				keyserverList[index].flags);

			PGPSetPrefStructString(prefRef, prefStruct, 8, 
				keyserverList[index].keystoredn);
			
			err = PGPSetPrefArrayStruct(prefRef, prefArray, index,
					prefStruct);

			if (IsPGPError(err))
				break;
		}

		if (IsPGPError(err))
			PGPFreePrefStruct(prefStruct);
	}

	if (IsntPGPError(err))
		err = PGPSetPrefArray(prefRef, kPGPPrefKeyServerList, prefArray);

	if (IsntNull(prefArray))
		PGPFreePrefArray(prefArray);

	return err;
}

	PGPError
PGPGetKeyServerListFromPrefArray(
	PGPPrefRef			prefRef,
	PGPPrefArray		*prefArray,
	PGPKeyServerEntry	**keyserverList,
	PGPUInt32			*keyserverCount)
{
	PGPError			err = kPGPError_NoErr;
	PGPBoolean			badStruct = FALSE;
	PGPUInt32			index;
	PGPUInt16			structIndex;
	PGPPrefStruct*		prefStruct = NULL;
	PGPMemoryMgrRef		memoryMgr = NULL;

	if (IsntNull(keyserverList))
		*keyserverList = NULL;
	if (IsntNull(keyserverCount))
		*keyserverCount = 0;

	PGPValidatePtr(prefArray);
	PGPValidatePtr(keyserverList);
	PGPValidatePtr(keyserverCount);

	*keyserverCount = prefArray->numElements;

	if (prefArray->type != kPGPPrefType_Struct)
		badStruct = TRUE;

	else for (index=0; index<*keyserverCount; index++)
	{
		PGPGetPrefArrayStruct(prefRef, prefArray, index, &prefStruct);

		if (prefStruct->numMembers != LDAPKeyServer.numMembers)
			badStruct = TRUE;
		else 
		{
			for (structIndex=0; structIndex<prefStruct->numMembers;
			structIndex++)
			{
				if (prefStruct->members[structIndex].type !=
					LDAPKeyServer.members[structIndex].type)
				{
					badStruct = TRUE;
				}
			}
		}
	}

	if (badStruct)
		return kPGPError_BadParams;

	PGPPeekPrefMemoryMgr(prefRef, &memoryMgr);

	*keyserverList = (PGPKeyServerEntry *) 
						PGPNewData(memoryMgr,
							sizeof(PGPKeyServerEntry) *
							prefArray->numElements,
							kPGPMemoryMgrFlags_Clear);

	if (IsNull(*keyserverList))
		return kPGPError_OutOfMemory;

	for (index=0; index<prefArray->numElements; index++)
	{
		err = PGPGetPrefArrayStruct(prefRef, prefArray, index,
				&prefStruct);

		if (IsPGPError(err))
			break;

		(*keyserverList)[index].protocol	= (PGPKeyServerProtocol)
												prefStruct->members[0].data;
		(*keyserverList)[index].type		= (PGPKeyServerClass)
												prefStruct->members[1].data;

		/* kPGPKeyServerClass_LDAPPGP is not used anymore */
		if ((*keyserverList)[index].type == kPGPKeyServerClass_LDAPPGP)
			(*keyserverList)[index].type = kPGPKeyServerClass_PGP;

		pgpCopyMemory(prefStruct->members[2].data,
			(*keyserverList)[index].domain, 
			prefStruct->members[2].size); 

		pgpCopyMemory(prefStruct->members[3].data,
			(*keyserverList)[index].serverDNS, 
			prefStruct->members[3].size); 

		(*keyserverList)[index].serverPort = (PGPUInt16)
											((PGPUInt32) prefStruct->members[4].data);

		pgpCopyMemory(prefStruct->members[5].data,
			(*keyserverList)[index].authKeyIDString, 
			prefStruct->members[5].size); 

		(*keyserverList)[index].authAlg = (PGPPublicKeyAlgorithm)
											prefStruct->members[6].data;

		(*keyserverList)[index].flags = (PGPUInt32)
										prefStruct->members[7].data;

		pgpCopyMemory(prefStruct->members[8].data,
			(*keyserverList)[index].keystoredn, 
			prefStruct->members[8].size); 
	}

	if (IsntPGPError(err))
		*keyserverCount = prefArray->numElements;

	return err;
}

	PGPError
PGPFreeKeyServerList(	PGPKeyServerEntry		*keyserverList )
{
	PGPError	err = kPGPError_NoErr;

	PGPValidatePtr(keyserverList);

	PGPFreeData(keyserverList);
	return err;
}

	PGPError
PGPCreateKeyServerPath(	PGPPrefRef				prefRef,
						const char*				searchDomain,
						PGPKeyServerEntry		**keyserverPath,
						PGPUInt32				*keyserverCount)
{
	PGPError				err;
	PGPKeyServerEntry		*keyserverList;
	PGPUInt32				listCount;
	PGPUInt32				index;
	char					nullDomain[] = "";
	
	PGPValidatePtr(keyserverPath);
	PGPValidatePtr(keyserverCount);
	
	if( IsNull( searchDomain ) )
		searchDomain = nullDomain;
		
	err = PGPGetKeyServerPrefs(prefRef, &keyserverList, &listCount);
	if( IsPGPError(err) )
		return err;

	// init pointers
	*keyserverCount = 0;
	*keyserverPath = (PGPKeyServerEntry *)pgpAlloc(sizeof(PGPKeyServerEntry));

	for(index = 0; index < listCount; index++)
	{
		// check for a domain match
		if( !pgpCompareStringsIgnoreCase(keyserverList[index].domain,
				searchDomain) )
		{
			*keyserverCount = *keyserverCount + 1;
			
			pgpRealloc(	(void **) keyserverPath, 
						*keyserverCount * sizeof(PGPKeyServerEntry));

			(*keyserverPath)[*keyserverCount - 1] = keyserverList[index];
		}
	}

	if( searchDomain[0] ) // add servers that do all domains
	{
		for(index = 0; index < listCount; index++)
		{
			if( !keyserverList[index].domain[0] )
			{
				*keyserverCount = *keyserverCount + 1;
				
				pgpRealloc(	(void **) keyserverPath, 
							*keyserverCount * sizeof(PGPKeyServerEntry));

				(*keyserverPath)[*keyserverCount - 1] = keyserverList[index];
			}
		}
	}

	PGPFreeKeyServerList(keyserverList);
	
	return err;
}

	PGPError
PGPDisposeKeyServerPath(PGPKeyServerEntry *keyserverPath)
{
	PGPValidatePtr(keyserverPath);

	if( keyserverPath )
	{
		pgpFree(keyserverPath);
	}
	return kPGPError_NoErr;
}

	PGPError
PGPGetRootKeyServer(
	PGPPrefRef			prefRef,
	PGPKeyServerEntry	*rootServer )
{
	PGPError			err = kPGPError_NoErr;
	PGPKeyServerEntry	*keyserverList;
	PGPUInt32			count;
	PGPUInt32			index;
	PGPBoolean			found = FALSE;
	
	PGPValidatePtr( rootServer );

	err = PGPGetKeyServerPrefs(	prefRef,
								&keyserverList,
								&count);

	if (IsPGPError(err))
		return err;

	for(index = 0; index < count; index++)
	{
		if( IsKeyServerRoot( keyserverList[index].flags ) )
		{
			*rootServer = keyserverList[index];
			found = TRUE;
			break;
		}
	}
	if( !found )
		for(index = 0; index < count; index++)
		{
			if( keyserverList[index].domain[0] == '\0' )
			{
				*rootServer = keyserverList[index];
				found = TRUE;
				break;
			}
		}

	PGPFreeKeyServerList(keyserverList);
	
	if( !found )
		err = kPGPError_ItemNotFound;
	
	return err;
}

	void
PGPGetKeyServerURL(
	PGPKeyServerEntry	*keyserver,
	char				*url )
{
	switch( keyserver->protocol )
	{
		case kPGPKeyServerProtocol_LDAP:
			strcpy( url, "ldap://" );
			break;
		case kPGPKeyServerProtocol_HTTP:
			strcpy( url, "http://" );
			break;
		case kPGPKeyServerProtocol_LDAPS:
			strcpy( url, "ldaps://" );
			break;
		case kPGPKeyServerProtocol_HTTPS:
			strcpy( url, "https://" );
			break;
		default:
			break;
	}
	strncat( url, keyserver->serverDNS, 241 );
	if( keyserver->serverPort != 0 )
		sprintf( url, "%s:%d", url, keyserver->serverPort );
}

	void
PGPFindEmailDomain(const char *emailAddress, char *domain)
{
	char *p = (char *) emailAddress;
	
	if (IsNull(emailAddress))
	{
		strcpy(domain, "\0");
		return;
	}

	while(*p && *p != '@')
		p++;
	if(*p)
	{
		p++;
		strcpy(domain, p);
		p = domain;
		while(*p && *p != '>')
			p++;
		if(*p == '>')
			*p = '\0';
	}
}