cldapkeyserver.cpp

可以实现对邮件的加密解密以及签名

					pgpError = PGPFindKeyByKeyID(
									PGPPeekKeySetKeyDB( inKeySetRef ),
									&keyID,
									&key);
					ThrowIfPGPError_(pgpError);

					if( *outKeysThatFailed == kInvalidPGPKeySetRef )
					{
						pgpError = PGPNewEmptyKeySet( PGPPeekKeySetKeyDB( inKeySetRef ),
										outKeysThatFailed );
						ThrowIfPGPError_( pgpError );
					}

					pgpError = PGPAddKey( key, *outKeysThatFailed );
					ThrowIfPGPError_( pgpError );

					currentItem = nextItem;
					while( ( *currentItem != '\0' ) && isspace( *currentItem ) )
						currentItem++;
				}
			}

			delete[] error;
			error = NULL;
		}
			
		pgpError = PGPldapGetErrno( mLDAP, NULL, &szError, &ldapResult );
		ThrowIfPGPError_( pgpError );

		switch( ldapResult )
		{
			case kPGPldapResult_Success:
				break;
			
			case kPGPldapResult_AlreadyExists:
				ThrowPGPError_( kPGPError_ServerKeyAlreadyExists );
				break;
			
			case kPGPldapResult_InsufficientAccess:
				ThrowPGPError_( kPGPError_ServerAuthorizationFailed );
				break;
			
			case kPGPldapResult_InvalidCredentials:
				ThrowPGPError_( kPGPError_ServerKeyFailedPolicy );
				break;
			
			default:
				ThrowPGPError_( kPGPError_ServerRequestFailed );
				break;
		}
	}
	
	catch( PGPError exception )
	{
		delete[] error;
		delete[] request;
		delete[] keySpace;

		if( IsntNull( signedRequest ) )
			PGPFreeData( signedRequest );

		if( PGPKeyIterRefIsValid( keyIter ) )
			PGPFreeKeyIter( keyIter );

		if( PGPKeyListRefIsValid( keyList ) )
			PGPFreeKeyList( keyList );

		result = exception;
	}
	
	return result;
}



	void
CLDAPKeyServer::SendGroups(
	PGPGroupSetRef	inGroupSetRef)
{
	StPreserveSocketsEventHandler	preserve(this);
	void *							groupsBuffer	= 0;
	PGPError						pgpError		= kPGPError_NoErr;
	PGPldapResult					ldapResult		= kPGPldapResult_Success;
	char *							szError			= NULL;
	
	SetErrorString( NULL );

	if( mUseLDAPPGP )
	{
		mLDAPPGPKeyServer->SendGroups( inGroupSetRef );
		return;
	}

	if( !mIsOpen )
		ThrowPGPError_( kPGPError_ServerNotOpen );

	try
	{
		PGPberValue			berVal = { 0, 0 };
		PGPberValue *		berVals[2] = { &berVal, NULL };
		const char *		strVals[2] = { kPGPSrvGroupFileClass, 0 };
		PGPldapMod			mod = { (PGPldapModOp) 
									(kPGPldapModOp_Add | kPGPldapModOpMask_UseBERValues),
								(char *) kPGPSrvGroupFileV2,
								(char **) NULL,
								(PGPberValue **) berVals };
		PGPldapMod *		attrs[2] = { &mod, NULL };
		PGPSize				groupsBufferSize;
		
		
		// Export the groups
		pgpError = PGPExportGroupSetToBuffer(	inGroupSetRef,
												&groupsBuffer,
												&groupsBufferSize );
		ThrowIfPGPError_( pgpError );
		pgpError = pgpEventKeyServer(	mContext,
										mEventHandler,
										mEventHandlerData,
										(PGPKeyServerRef) this,
										kPGPKeyServerState_Uploading );
		ThrowIfPGPErrorOrLDAPCanceled_( pgpError );
		
		// Send them to the server
		berVals[0]->length = groupsBufferSize;
		berVals[0]->value = (PGPByte *) groupsBuffer;

		pgpError = PGPldapAddSync( mLDAP, (char *) kDefaultPGPGroupspace, attrs );

		ThrowIfLDAPCanceled_();

		if( IsPGPError( pgpError ) )
		{
			switch( pgpError )
			{
				case kPGPError_LDAPAlreadyExists:
					ThrowPGPError_( kPGPError_ServerKeyAlreadyExists );
					break;
				
				case kPGPError_LDAPInsufficientAccess:
					ThrowPGPError_( kPGPError_ServerAuthorizationFailed );
					break;
				
				case kPGPError_LDAPInvalidCredentials:
					ThrowPGPError_( kPGPError_ServerKeyFailedPolicy );
					break;
				
				default:
					ThrowPGPError_( kPGPError_ServerRequestFailed );
					break;
			}
		}
		PGPFreeData( groupsBuffer );
		groupsBuffer = NULL;
		
		// Add the objectclass
		mod.op = kPGPldapModOp_Add;
		mod.type = (char *) kObjectClass;
		mod.value = (char **) strVals;

		pgpError = PGPldapAddSync( mLDAP, (char *) kDefaultPGPGroupspace, attrs );

		ThrowIfLDAPCanceled_();

		if( IsPGPError( pgpError ) )
		{
			switch( pgpError )
			{
				case kPGPError_LDAPAlreadyExists:
					ThrowPGPError_( kPGPError_ServerKeyAlreadyExists );
					break;
				
				case kPGPError_LDAPInsufficientAccess:
					ThrowPGPError_( kPGPError_ServerAuthorizationFailed );
					break;
				
				case kPGPError_LDAPInvalidCredentials:
					ThrowPGPError_( kPGPError_ServerKeyFailedPolicy );
					break;
				
				default:
					ThrowPGPError_( kPGPError_ServerRequestFailed );
					break;
			}
		}
	}
	
	catch (...)
	{
		if( IsntNull( groupsBuffer ) )
			PGPFreeData( groupsBuffer );

		if( mCanceled )
			ThrowPGPError_( kPGPError_UserAbort );
		else
		{
			(void) PGPldapGetErrno( mLDAP, NULL, &szError, &ldapResult );
			SetErrorString( szError );
			throw;
		}
	}
}



	void
CLDAPKeyServer::RetrieveGroups(
	PGPGroupSetRef *	outGroupSetRef)
{
	StPreserveSocketsEventHandler	preserve(this);
	PGPldapMessageRef				message		= kInvalidPGPldapMessageRef;
	PGPberValue **					value		= NULL;
	PGPGroupSetRef					groupSetRef = kInvalidPGPGroupSetRef;
	PGPError						pgpError	= kPGPError_NoErr;
	PGPldapResult					ldapResult	= kPGPldapResult_Success;
	char *							szError		= NULL;

	SetErrorString( NULL );

	if( mUseLDAPPGP )
	{
		mLDAPPGPKeyServer->RetrieveGroups( outGroupSetRef );
		return;
	}

	if( !mIsOpen )
		ThrowPGPError_( kPGPError_ServerNotOpen );

	try
	{
		PGPldapMessageRef	nextMessage		= kInvalidPGPldapMessageRef;
		char *				attribute		= NULL;
		PGPberElementRef	iterAttribute	= kInvalidPGPberElementRef;
		static const char *	attr[2] = { kPGPSrvGroupFileV2, 0 };
		
		pgpError = pgpEventKeyServer(	mContext,
										mEventHandler,
										mEventHandlerData,
										(PGPKeyServerRef) this,
										kPGPKeyServerState_Querying );
		ThrowIfPGPErrorOrLDAPCanceled_( pgpError );
		
		pgpError = PGPNewLDAPMessage( mLDAP, &message );
		ThrowIfPGPError_( pgpError );

		pgpError = PGPldapSearchSync(  mLDAP,
							(char *) kDefaultPGPGroupspace,
							kPGPldapScope_Base,
							(char *) kObjectClassAny,
							(char **) attr,
							FALSE,
							message );
		if( IsPGPError( pgpError ) )
			ThrowPGPError_( kPGPError_ServerSearchFailed );

		pgpError = PGPldapFirstEntry( mLDAP, message, &nextMessage );
		if( IsPGPError( pgpError ) )
			ThrowPGPError_( kPGPError_ServerSearchFailed );

		if( PGPldapMessageRefIsValid( nextMessage ) )
		{
			pgpError = PGPldapFirstAttribute( mLDAP, nextMessage, &iterAttribute, 
				&attribute );
			if( IsPGPError( pgpError ) )
				ThrowPGPError_( kPGPError_ServerSearchFailed );

			if( IsntNull( attribute ) )
			{
				pgpError = PGPldapGetValuesLen( mLDAP, 
					nextMessage, 
					attribute,
					&value );
				if( IsPGPError( pgpError ) )
					ThrowPGPError_( kPGPError_ServerSearchFailed );

				if( ( value != 0 ) && ( *value != 0 ) )
				{
					pgpError = PGPImportGroupSetFromBuffer(	mContext,
															(*value)->value,
															(*value)->length,
															&groupSetRef );
					if( IsPGPError( pgpError ) )
						ThrowPGPError_( kPGPError_ServerSearchFailed );

					PGPFreeLDAPValuesLen( value );
					value = NULL;
				}
			}
		}
		if( groupSetRef == kInvalidPGPGroupSetRef )
			ThrowPGPError_( kPGPError_ServerSearchFailed );

		PGPFreeLDAPMessage( message );
		message = kInvalidPGPldapMessageRef;

		*outGroupSetRef = groupSetRef;
	}
	
	catch(...)
	{
		if( groupSetRef != kInvalidPGPGroupSetRef )
			PGPFreeGroupSet( groupSetRef );

		if( IsntNull( value ) )
			PGPFreeLDAPValuesLen( value );

		if( PGPldapMessageRefIsValid( message ) )
			PGPFreeLDAPMessage( message );

		if( mCanceled )
			ThrowPGPError_( kPGPError_UserAbort );
		else
		{
			(void) PGPldapGetErrno( mLDAP, NULL, &szError, &ldapResult );
			SetErrorString( szError );
			throw;
		}
	}
}



	void
CLDAPKeyServer::NewMonitor(
	PGPKeyServerMonitor **	outMonitor)
{
	StPreserveSocketsEventHandler	preserve(this);
	PGPldapMessageRef				message				= kInvalidPGPldapMessageRef;
	char **							value				= NULL;
	PGPKeyServerMonitor *			monitor				= 0;
	PGPError						pgpError			= kPGPError_NoErr;
	PGPldapResult					ldapResult			= kPGPldapResult_Success;
	PGPKeyServerMonitorValues *		currentMonitorValue	= 0;
	PGPldapMessageRef				nextMessage			= kInvalidPGPldapMessageRef;
	char *							attribute			= NULL;
	int								numValues			= 0;
	int 							i					= 0;
	char *							szError				= NULL;

	SetErrorString( NULL );

	if( mUseLDAPPGP )
	{
		mLDAPPGPKeyServer->NewMonitor( outMonitor );
		return;
	}

	if( !mIsOpen )
		ThrowPGPError_( kPGPError_ServerNotOpen );

	try
	{
		PGPberElementRef			iterAttribute;
		static const char *			attr[1] = { 0 };

		if( mAccessType != kPGPKeyServerAccessType_Administrator )
			ThrowPGPError_( kPGPError_ServerAuthorizationRequired );

		pgpError = pgpEventKeyServer(	mContext,
										mEventHandler,
										mEventHandlerData,
										(PGPKeyServerRef) this,
										kPGPKeyServerState_Querying );
		ThrowIfPGPErrorOrLDAPCanceled_( pgpError );

		PGPNewLDAPMessage( mLDAP, &message );

		pgpError = PGPldapSearchSync(	mLDAP,
							(char *) kMonitorCN,
							kPGPldapScope_Base,
							(char *) kObjectClassAny,
							(char **) attr,
							FALSE,
							message );
		if( IsPGPError( pgpError ) )
			ThrowPGPError_( kPGPError_ServerSearchFailed );

		pgpError = pgpEventKeyServer(	mContext,
										mEventHandler,
										mEventHandlerData,
										(PGPKeyServerRef) this,
										kPGPKeyServerState_ProcessingResults );
		ThrowIfPGPErrorOrLDAPCanceled_( pgpError );

		monitor = new PGPKeyServerMonitor;
		if( IsNull( monitor ) )
			ThrowPGPError_( kPGPError_OutOfMemory );

		monitor->keyServerRef = (PGPKeyServerRef) this;
		monitor->valuesHead = 0;

		pgpError = PGPldapFirstEntry( mLDAP, message, &nextMessage );
		if( IsPGPError( pgpError ) )
			ThrowPGPError_( kPGPError_ServerSearchFailed );

		while( PGPldapMessageRefIsValid( nextMessage ) )
		{
			pgpError = PGPldapFirstAttribute(  mLDAP,
									nextMessage,
									&iterAttribute,
									&attribute );
			if( IsPGPError( pgpError ) )
				ThrowPGPError_( kPGPError_ServerSearchFailed );

			while( IsntNull( attribute ) )
			{
				if( IsNull( currentMonitorValue ) )
				{
					monitor->valuesHead = currentMonitorValue = 
											new PGPKeyServerMonitorValues;
				}
				else
				{
					currentMonitorValue->next =
											new PGPKeyServerMonitorValues;
					currentMonitorValue = currentMonitorValue->next;
				}
				if( IsNull( currentMonitorValue ) )
					ThrowPGPError_( kPGPError_OutOfMemory );

				currentMonitorValue->values = 0;
				currentMonitorValue->next = 0;
				currentMonitorValue->name = new char[strlen(attribute) + 1];

				if( IsNull( currentMonitorValue->name ) )
					ThrowPGPError_( kPGPError_OutOfMemory );

				/* copy the attribute */
				strncpy( currentMonitorValue->name, attribute,
						strlen(attribute) + 1);
				
				pgpError = PGPldapGetValues( mLDAP, 
					nextMessage, 
					attribute, 
					&value );
				if( IsPGPError( pgpError ) )
					ThrowPGPError_( kPGPError_ServerSearchFailed );

				if( IsntNull( value ) )
				{
					pgpError = PGPldapCountValues( mLDAP, 
						value, 
						(PGPSize *) &numValues );
					if( IsPGPError( pgpError ) )
						ThrowPGPError_( kPGPError_ServerSearchFailed );

					currentMonitorValue->values = new char*[numValues + 1];
					if( IsNull( currentMonitorValue->values ) )
						ThrowPGPError_(kPGPError_OutOfMemory);

					for( i = 0; i < numValues; i++ )
					{
						currentMonitorValue->values[i] =
											new char[strlen(value[i]) + 1];
						if( IsNull( currentMonitorValue->values[i] ) )
							ThrowPGPError_(kPGPError_OutOfMemory);

						strcpy(currentMonitorValue->values[i], value[i]);
					}
					currentMonitorValue->values[numValues] = 0;
					PGPFreeLDAPValues( value );
					value = NULL;
				}
				PGPFreeData( attribute );
				attribute = NULL;

				pgpError = PGPldapNextAttribute( mLDAP, nextMessage, iterAttribute, 
					&attribute );
				if( IsPGPError( pgpError ) )
					ThrowPGPError_( kPGPError_ServerSearchFailed );
			}

			
			if( ldapResult != kPGPldapResult_Success )
				ThrowPGPError_( kPGPError_ServerOpenFailed );

			pgpError = PGPldapNextEntry( mLDAP, nextMessage, &nextMessage );
			if( IsPGPError( pgpError ) )
				ThrowPGPError_( kPGPError_ServerSearchFailed );
		}
		PGPFreeLDAPMessage( message );
		message = kInvalidPGPldapMessageRef;

		*outMonitor = monitor;
	}
	
	catch (...)
	{
		if( IsntNull( monitor ) )
			FreeMonitor( monitor );

		if( IsntNull( value ) )
			PGPFreeLDAPValues( value );

		if( PGPldapMessageRefIsValid( message ) )
			PGPFreeLDAPMessage( message );

		if( mCanceled )
			ThrowPGPError_( kPGPError_UserAbort );
		else
		{
			(void) PGPldapGetErrno( mLDAP, NULL, &szError, &ldapResult );
			SetErrorString( szError );
			throw;
		}
	}
}



	void
CLDAPKeyServer::FreeMonitor(
	PGPKeyServerMonitor *	inMonitor)
{
	PGPKeyServerMonitorValues *	currentMonitorValue = inMonitor->valuesHead;
	PGPKeyServerMonitorValues * tempMonitorValue;
	char **						tempValue;

	if( mUseLDAPPGP )
	{
		mLDAPPGPKeyServer->FreeMonitor( inMonitor );
		return;
	}

	while( currentMonitorValue != 0 ) 
	{
		delete[] currentMonitorValue->name;

		if( currentMonitorValue->values != 0 )
		{
			tempValue = currentMonitorValue->values;
			while( *tempValue != 0 )
			{
				delete[] *tempValue;
				tempValue++;
			}
			delete[] currentMonitorValue->values;
		}

		tempMonitorValue = currentMonitorValue;
		currentMonitorValue = currentMonitorValue->next;

		delete tempMonitorValue;
	}

	delete[] inMonitor;
}