cldapkeyserver.cpp

vc环境下的pgp源码

						ThrowIfPGPError_(pgpError);
					}
					pgpError = PGPNewSingletonKeySet(key, &singleKeySet);
					ThrowIfPGPError_(pgpError);
					pgpError = PGPAddKeys(singleKeySet, *outKeysThatFailed);
					ThrowIfPGPError_(pgpError);
					PGPFreeKeySet(singleKeySet);
					singleKeySet = kInvalidPGPKeySetRef;
					currentItem = nextItem;
					while ((*currentItem != '\0') && isspace(*currentItem)) {
						currentItem++;
					}
				}
			}
			delete[] error;
			error = 0;
		}
			
		switch (ldapResult) {
			case LDAP_SUCCESS:
			{
			}
			break;
			
			
			case LDAP_ALREADY_EXISTS:
			{
				ThrowPGPError_(kPGPError_ServerKeyAlreadyExists);
			}
			break;
			
			
			case LDAP_INSUFFICIENT_ACCESS:
			{
				ThrowPGPError_(kPGPError_ServerAuthorizationFailed);
			}
			break;
			
			
			case LDAP_INVALID_CREDENTIALS:
			{
				ThrowPGPError_(kPGPError_ServerKeyFailedPolicy);
			}
			break;
			
			
			default:
			{
				ThrowPGPError_(kPGPError_ServerRequestFailed);
			}
			break;
		}
	}
	
	catch (PGPError exception) {
		delete[] error;
		delete[] request;
		delete[] keySpace;
		if (singleKeySet != kInvalidPGPKeySetRef) {
			PGPFreeKeySet(singleKeySet);
		}
		if (signedRequest != 0) {
			PGPFreeData(signedRequest);
		}
		if (keyIter != kInvalidPGPKeyIterRef) {
			PGPFreeKeyIter(keyIter);
		}
		if (keyList != kInvalidPGPKeyListRef) {
			PGPFreeKeyList(keyList);
		}
		result = exception;
	}
	
	return result;
}



	void
CLDAPKeyServer::SendGroups(
	PGPGroupSetRef	inGroupSetRef)
{
	StPreserveSocketsEventHandler	preserve(this);
	void *							groupsBuffer = 0;
	PGPError						pgpError = kPGPError_NoErr;
	int								ldapResult = 0;
	
	SetErrorString(0);
	if (! mIsOpen) {
		ThrowPGPError_(kPGPError_ServerNotOpen);
	}
	try {
		struct berval		berVal = { 0, 0 };
		struct berval *		berVals[2] = { &berVal, 0 };
		const char *		strVals[2] = { kPGPSrvGroupFileClass, 0 };
		LDAPMod				mod = { LDAP_MOD_BVALUES,
									(char *) kPGPSrvGroupFile,
									{ (char **) berVals }, 0 };
		LDAPMod *			attrs[2] = { &mod, 0 };
		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]->bv_len = groupsBufferSize;
		berVals[0]->bv_val = (char *) groupsBuffer;
		ldapResult = ldap_add_s(	mLDAP,
									(char *) kDefaultPGPGroupspace,
									attrs);
		ThrowIfLDAPCanceled_();
		if (ldapResult != LDAP_SUCCESS) {
			switch (ldapResult) {
				case LDAP_ALREADY_EXISTS:
				{
					ThrowPGPError_(kPGPError_ServerKeyAlreadyExists);
				}
				break;
				
				
				case LDAP_INSUFFICIENT_ACCESS:
				{
					ThrowPGPError_(kPGPError_ServerAuthorizationFailed);
				}
				break;
				
				
				case LDAP_INVALID_CREDENTIALS:
				{
					ThrowPGPError_(kPGPError_ServerKeyFailedPolicy);
				}
				break;
				
				
				default:
				{
					ThrowPGPError_(kPGPError_ServerRequestFailed);
				}
				break;
			}
		}
		PGPFreeData(groupsBuffer);
		groupsBuffer = 0;
		
		// Add the objectclass
		mod.mod_op = 0;
		mod.mod_type = (char *) kObjectClass;
		mod.mod_values = (char **) strVals;
		ldapResult = ldap_add_s(	mLDAP,
									(char *) kDefaultPGPGroupspace,
									attrs);
		ThrowIfLDAPCanceled_();
		switch (ldapResult) {
			case LDAP_SUCCESS:
			{
			}
			break;
			
			
			case LDAP_ALREADY_EXISTS:
			{
				ThrowPGPError_(kPGPError_ServerKeyAlreadyExists);
			}
			break;
			
			
			case LDAP_INSUFFICIENT_ACCESS:
			{
				ThrowPGPError_(kPGPError_ServerAuthorizationFailed);
			}
			break;
			
			
			case LDAP_INVALID_CREDENTIALS:
			{
				ThrowPGPError_(kPGPError_ServerKeyFailedPolicy);
			}
			break;
			
			
			default:
			{
				ThrowPGPError_(kPGPError_ServerRequestFailed);
			}
			break;
		}
	}
	
	catch (...) {
		if (groupsBuffer != 0) {
			PGPFreeData(groupsBuffer);
		}
		if (mCanceled) {
			ThrowPGPError_(kPGPError_UserAbort);
		} else {
			SetErrorString(mLDAP->ld_error);
			throw;
		}
	}
}



	void
CLDAPKeyServer::RetrieveGroups(
	PGPGroupSetRef *	outGroupSetRef)
{
	StPreserveSocketsEventHandler	preserve(this);
	LDAPMessage *					message = 0;
	struct berval **				value = 0;
	PGPGroupSetRef					groupSetRef = kInvalidPGPGroupSetRef;
	PGPError						pgpError = kPGPError_NoErr;
	int								ldapResult = 0;

	SetErrorString(0);
	if (! mIsOpen) {
		ThrowPGPError_(kPGPError_ServerNotOpen);
	}
	try {
		LDAPMessage *		nextMessage;
		char *				attribute;
		BerElement *		iterAttribute;
		static const char *	attr[2] = { kPGPSrvGroupFile, 0 };
		
		pgpError = pgpEventKeyServer(	mContext,
										mEventHandler,
										mEventHandlerData,
										(PGPKeyServerRef) this,
										kPGPKeyServerState_Querying);
		ThrowIfPGPErrorOrLDAPCanceled_(pgpError);
		
		ldapResult = ldap_search_s(	mLDAP,
									(char *) kDefaultPGPGroupspace,
									LDAP_SCOPE_BASE,
									(char *) kObjectClassAny,
									(char **) attr,
									0,
									&message);
		ThrowIfLDAPCanceled_();
		if (ldapResult != LDAP_SUCCESS) {
			ThrowPGPError_(kPGPError_ServerSearchFailed);
		}
		nextMessage = ldap_first_entry(mLDAP, message);
		if (nextMessage != 0) {
			attribute = ldap_first_attribute(	mLDAP,
												nextMessage,
												&iterAttribute);
			if (attribute != 0) {
				value = ldap_get_values_len(	mLDAP,
												nextMessage,
												attribute);
				if ((value != 0) && (*value != 0)) {
					pgpError = PGPImportGroupSetFromBuffer(	mContext,
															(*value)->bv_val,
															(*value)->bv_len,
															&groupSetRef);
					ldap_value_free_len(value);
					value = 0;
				}
			}
pgpFixBeforeShip(am getting errors here)
/*
			if (mLDAP->ld_errno != LDAP_SUCCESS) {
				ThrowPGPError_(kPGPError_ServerOpenFailed);
			}
*/		}
		if (groupSetRef == kInvalidPGPGroupSetRef) {
			ThrowPGPError_(kPGPError_ServerSearchFailed);
		}
		ldap_msgfree(message);
		*outGroupSetRef = groupSetRef;
	}
	
	catch (...) {
		if (groupSetRef != kInvalidPGPGroupSetRef) {
			PGPFreeGroupSet(groupSetRef);
		}
		if (value != 0) {
			ldap_value_free_len(value);
		}
		if (message != 0) {
			ldap_msgfree(message);
		}
		if (mCanceled) {
			ThrowPGPError_(kPGPError_UserAbort);
		} else {
			SetErrorString(mLDAP->ld_error);
			throw;
		}
	}
}



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

	SetErrorString(0);
	if (! mIsOpen) {
		ThrowPGPError_(kPGPError_ServerNotOpen);
	}
	try {
		BerElement *				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);
		ldapResult = ldap_search_s(	mLDAP,
									(char *) kMonitorCN,
									LDAP_SCOPE_BASE,
									(char *) kObjectClassAny,
									(char **) attr,
									0,
									&message);
		ThrowIfLDAPCanceled_();
		if (ldapResult != LDAP_SUCCESS) {
			ThrowPGPError_(kPGPError_ServerSearchFailed);
		}
		
		pgpError = pgpEventKeyServer(	mContext,
										mEventHandler,
										mEventHandlerData,
										(PGPKeyServerRef) this,
										kPGPKeyServerState_ProcessingResults);
		ThrowIfPGPErrorOrLDAPCanceled_(pgpError);
		monitor = new PGPKeyServerMonitor;
		if (monitor == 0) {
			ThrowPGPError_(kPGPError_OutOfMemory);
		}
		monitor->keyServerRef = (PGPKeyServerRef) this;
		monitor->valuesHead = 0;
		nextMessage = ldap_first_entry(mLDAP, message);
		while (nextMessage != 0) {
			attribute = ldap_first_attribute(	mLDAP,
												nextMessage,
												&iterAttribute);
			while (attribute != 0) {
				if (currentMonitorValue == 0) {
					monitor->valuesHead = currentMonitorValue = 
											new PGPKeyServerMonitorValues;
				} else {
					currentMonitorValue->next =
											new PGPKeyServerMonitorValues;
					currentMonitorValue = currentMonitorValue->next;
				}
				if (currentMonitorValue == 0) {
					ThrowPGPError_(kPGPError_OutOfMemory);
				}
				currentMonitorValue->values = 0;
				currentMonitorValue->next = 0;
				currentMonitorValue->name = new char[strlen(attribute) + 1];
				if (currentMonitorValue->name == 0) {
					ThrowPGPError_(kPGPError_OutOfMemory);
				}
				/* copy the attribute */
				strncpy( currentMonitorValue->name, attribute,
						strlen(attribute) + 1);
				
				value = ldap_get_values(	mLDAP,
											nextMessage,
											attribute);
				if (value != 0) {
					numValues = ldap_count_values(value);
					currentMonitorValue->values = new char*[numValues + 1];
					if (currentMonitorValue->values == 0) {
						ThrowPGPError_(kPGPError_OutOfMemory);
					}
					for (i = 0; i < numValues; i++) {
						currentMonitorValue->values[i] =
											new char[strlen(value[i]) + 1];
						if (currentMonitorValue->values[i] == 0) {
							ThrowPGPError_(kPGPError_OutOfMemory);
						}
						strcpy(currentMonitorValue->values[i], value[i]);
					}
					currentMonitorValue->values[numValues] = 0;
					ldap_value_free(value);
					value = 0;
				}
				attribute = ldap_next_attribute(	mLDAP,	
													nextMessage,
													iterAttribute);
			}
pgpFixBeforeShip(am getting errors here)
/*
			if (mLDAP->ld_errno != LDAP_SUCCESS) {
				ThrowPGPError_(kPGPError_ServerOpenFailed);
			}
*/			nextMessage = ldap_next_entry(	mLDAP,
											nextMessage);
		}
		ldap_msgfree(message);
		*outMonitor = monitor;
	}
	
	catch (...) {
		if (monitor != 0) {
			FreeMonitor(monitor);
		}
		if (value != 0) {
			ldap_value_free(value);
		}
		if (message != 0) {
			ldap_msgfree(message);
		}
		if (mCanceled) {
			ThrowPGPError_(kPGPError_UserAbort);
		} else {
			SetErrorString(mLDAP->ld_error);
			throw;
		}
	}
}



	void
CLDAPKeyServer::FreeMonitor(
	PGPKeyServerMonitor *	inMonitor)
{
	PGPKeyServerMonitorValues *	currentMonitorValue = inMonitor->valuesHead;
	PGPKeyServerMonitorValues * tempMonitorValue;
	char **						tempValue;
	
	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;
}