pgpdiskengineexports.cpp

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

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

        $Id: PGPdiskEngineExports.cpp,v 1.20 2002/08/06 20:09:36 dallen Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"
#include "pgpPflPriv.h"

#include "CString.h"
#include "UMath.h"
#include "UString.h"

#include "pgpClientErrors.h"
#include "pgpDiskEngine.h"

#include "CCipherContext.h"
#include "UCryptoFactory.h"

#include "CPGPKey.h"

#include "CDriverComm.h"
#include "CEngineSubsystems.h"
#include "CPGPdiskDisk.h"
#include "CPGPdiskDiskSet.h"
#include "CPGPdiskContext.h"
#include "CPGPdiskUser.h"
#include "CPGPdiskUserSet.h"

_USING_PGP

// Exported function definitions

/* PGPdiskContextRef functions */

PGPError 
PGPdiskEngineExport 
PGPdiskNewContext(PGPUInt32 clientAPIVersion, PGPdiskContextRef *pContext)
{
	PGPValidatePtr(pContext);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		if ((PGPdiskMajorVersion(clientAPIVersion) > 
			PGPdiskMajorVersion(kPGPdiskAPIVersion)) ||
			(PGPdiskMajorVersion(clientAPIVersion) == 0))
		{
			THROW_PGPERROR(kPGPClientError_DiskEngineIncompat);
		}

		*pContext = new CPGPdiskContext;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskFreeContext(PGPdiskContextRef context)
{
	pgpAssert(PGPdiskContextRefIsValid(context));

	try
	{
		delete context;
		context = NULL;
	}
	catch (CComboError&) { }
}

PGPError 
PGPdiskEngineExport 
PGPdiskOpenPeekContextPGPKeyDB(
	PGPdiskContextRef	context, 
	PGPKeyDBRef			*pPGPKeyDB)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));
	PGPValidatePtr(pPGPKeyDB);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pPGPKeyDB = context->PGPKeyDB();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskReloadContextPGPKeyDB(PGPdiskContextRef context)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		context->ReloadPGPKeyDB();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDirtyPGPKeyDB(PGPdiskContextRef context)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));

	context->mKeyDBModified=TRUE;
	return kPGPError_NoErr;
}

PGPContextRef 
PGPdiskEngineExport 
PGPdiskPeekContextPGPContext(PGPdiskContextRef context)
{
	pgpAssert(PGPdiskContextRefIsValid(context));

	PGPContextRef	pgpContext;

	try
	{
		pgpContext = context->PGPContext();
	}
	catch (CComboError&) { }

	return pgpContext;
}

PGPPrefRef 
PGPdiskEngineExport 
PGPdiskPeekContextPGPclPrefs(PGPdiskContextRef context)
{
	pgpAssert(PGPdiskContextRefIsValid(context));

	PGPPrefRef	pgpCLPrefs;

	try
	{
		pgpCLPrefs = context->PGPclPrefs();
	}
	catch (CComboError&) { }

	return pgpCLPrefs;
}

PGPError 
PGPdiskEngineExport 
PGPdiskContextIsThereADK(PGPdiskContextRef context, PGPBoolean *pIsThereADK)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));
	PGPValidatePtr(pIsThereADK);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pIsThereADK = context->IsTherePGPdiskADK();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskContextGetADK(PGPdiskContextRef context, PGPKeyDBObjRef *pADKKey)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));
	PGPValidatePtr(pADKKey);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CPGPKey	adkKey;

		context->GetPGPdiskADKPubKey(adkKey);
		*pADKKey = adkKey;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskContextGetADKUserID(
	PGPdiskContextRef	context, 
	char				*userID, 
	PGPSize				availLength)
{
	PGPValidateParam(PGPdiskContextRefIsValid(context));
	PGPValidatePtr(userID);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CString	cUserID;
		context->GetPGPdiskADKUserID(cUserID);

		UString::SmartStringCopy(userID, cUserID.Get(), availLength);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

/* PGPdiskUserRef functions */

PGPError 
PGPdiskEngineExport 
PGPdiskNewUserWithSymmetricKey(
	PGPdiskUserRef	cipheringUser, 
	const char		*userName, 
	const char		*passphrase, 
	PGPBoolean		isReadOnly, 
	PGPdiskUserRef	*pNewUser)
{
	PGPValidateParam(PGPdiskUserRefIsValid(cipheringUser));
	PGPValidatePtr(userName);
	PGPValidatePtr(passphrase);
	PGPValidatePtr(pNewUser);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		auto_ptr<CPGPdiskUser>	pTheNewUser(
			new CPGPdiskUser(cipheringUser->Context()));

		CCipherContext	cipher;
		cipheringUser->GetCipherContext(cipher);

		pTheNewUser->Create(cipher, userName, passphrase, isReadOnly);
		*pNewUser = pTheNewUser.release();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskNewUserWithPublicKey(
	PGPdiskUserRef	cipheringUser, 
	PGPKeyDBObjRef	pubKey, 
	PGPBoolean		isReadOnly, 
	PGPBoolean		isLocked, 
	PGPdiskUserRef	*pNewUser)
{
	PGPValidateParam(PGPdiskUserRefIsValid(cipheringUser));
	PGPValidateParam(PGPKeyDBObjRefIsValid(pubKey));
	PGPValidatePtr(pNewUser);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		auto_ptr<CPGPdiskUser>	pTheNewUser(
			new CPGPdiskUser(cipheringUser->Context()));

		CCipherContext	cipher;
		cipheringUser->GetCipherContext(cipher);

		pTheNewUser->Create(cipher, pubKey, isReadOnly, isLocked);
		*pNewUser = pTheNewUser.release();
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskDuplicateUser(PGPdiskUserRef user, PGPdiskUserRef *pNewUser)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pNewUser);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pNewUser = new CPGPdiskUser(*user);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskFreeUser(PGPdiskUserRef user)
{
	pgpAssert(PGPdiskUserRefIsValid(user));

	try
	{
		delete user;
	}
	catch (CComboError&) { }
}

PGPdiskContextRef 
PGPdiskEngineExport
PGPdiskPeekUserContext(PGPdiskUserRef user)
{
	pgpAssert(PGPdiskUserRefIsValid(user));

	PGPdiskContextRef	result	= kInvalidPGPdiskContextRef;

	try
	{
		result = const_cast<CPGPdiskContext *>(user->Context());
	}
	catch (CComboError&) { }

	return result;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserEnableCiphering(
	PGPdiskUserRef	user, 
	PGPdiskDiskRef	disk, 
	const char		*passphrase,
	int				passkeylen)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidateParam(PGPdiskDiskRefIsValid(disk));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		disk->EnableCipheringOnUser(*user, passphrase, passkeylen);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskUserDisableCiphering(PGPdiskUserRef user)
{
	pgpAssert(PGPdiskUserRefIsValid(user));

	try
	{
		user->DisableCiphering();
	}
	catch (CComboError&) { }
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserGetPGPKeyID(PGPdiskUserRef user, PGPKeyID *pKeyID)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pKeyID);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CPGPKeyID	keyID;
		user->GetPGPKeyID(keyID);

		*pKeyID = keyID;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserChangePassphrase(
	PGPdiskUserRef	symUserForCiphering, 
	const char		*newPassphrase)
{
	PGPValidateParam(PGPdiskUserRefIsValid(symUserForCiphering));
	PGPValidatePtr(newPassphrase);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		symUserForCiphering->ChangePassphrase(newPassphrase);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPBoolean 
PGPdiskEngineExport 
PGPdiskUserAreUsersEqual(PGPdiskUserRef user1, PGPdiskUserRef user2)
{
	pgpAssert(PGPdiskUserRefIsValid(user1));
	pgpAssert(PGPdiskUserRefIsValid(user2));

	PGPBoolean	result	= FALSE;

	try
	{
		result = (*user1 == *user2);
	}
	catch (CComboError&) { }

	return result;
}

PGPError 
PGPdiskEngineExport 
PGPdiskGetUserBooleanProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPBoolean			*pBool)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pBool);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskUserProp_HasPublicKey:
			*pBool = user->HasPublicKey();
			break;

		case kPGPdiskUserProp_HasSymmetricKey:
			*pBool = user->HasSymmetricKey();
			break;

		case kPGPdiskUserProp_IsReadOnly:
			*pBool = user->IsReadOnly();
			break;

		case kPGPdiskUserProp_IsLocked:
			*pBool = user->IsLocked();
			break;

		case kPGPdiskUserProp_IsAdminUser:
			*pBool = user->IsAdminUser();
			break;

		case kPGPdiskUserProp_IsDisabled:
			*pBool = user->IsDisabled();
			break;

		case kPGPdiskUserProp_IsCipheringEnabled:
			*pBool = user->IsCipheringEnabled();
			break;

		case kPGPdiskUserProp_CanSetReadOnly:
			*pBool = user->CanSetReadOnly();
			break;

		case kPGPdiskUserProp_CanSetUserName:
			*pBool = user->CanSetUserName();
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskGetUserNumericProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPInt32			*pNumber)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pNumber);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case 0:
		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskGetUserDataProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	void				*pData, 
	PGPSize				availLength, 
	PGPSize				*pUsedLength)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pData);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		CString	temp;
		PGPSize	usedLength;

		switch (prop)
		{
		case kPGPdiskUserProp_UserName:
			user->GetUserName(temp);

			if (availLength < temp.Length() + 1)
				THROW_PGPERROR(kPGPError_BufferTooSmall);

			strcpy(static_cast<char *>(pData), temp);
			usedLength = temp.Length() + 1;
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}

		if (IsntNull(pUsedLength))
			*pUsedLength = usedLength;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskSetUserBooleanProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPBoolean			boolVal)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskUserProp_IsReadOnly:
			user->SetIsReadOnly(boolVal);
			break;

		case kPGPdiskUserProp_IsLocked:
			user->SetIsLocked(boolVal);
			break;

		case kPGPdiskUserProp_IsDisabled:
			user->SetIsDisabled(boolVal);
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskSetUserNumericProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPInt32			number)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case 0:
		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskSetUserDataProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	const void			*pData, 
	PGPSize				dataLength)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pData);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		switch (prop)
		{
		case kPGPdiskUserProp_UserName:
			user->SetUserName(static_cast<const char *>(pData));
			break;

		default:
			THROW_PGPERROR(kPGPError_BadParams);
			break;
		}
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

/* PGPdiskUserSetRef functions */

PGPError 
PGPdiskEngineExport 
PGPdiskNewUserSet(PGPdiskUserSetRef *pUserSet)
{
	PGPValidatePtr(pUserSet);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pUserSet = new CPGPdiskUserSet;
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskNewSingletonUserSet(PGPdiskUserRef user, PGPdiskUserSetRef *pUserSet)
{
	PGPValidateParam(PGPdiskUserRefIsValid(user));
	PGPValidatePtr(pUserSet);

	PGPError	error	= kPGPError_NoErr;

	try
	{
		*pUserSet = new CPGPdiskUserSet(*user);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

void 
PGPdiskEngineExport 
PGPdiskFreeUserSet(PGPdiskUserSetRef userSet)
{
	pgpAssert(PGPdiskUserSetRefIsValid(userSet));

	try
	{
		delete userSet;
	}
	catch (CComboError&) { }
}

PGPUInt32 
PGPdiskEngineExport 
PGPdiskUserSetCount(PGPdiskUserSetRef userSet)
{
	pgpAssert(PGPdiskUserSetRefIsValid(userSet));

	PGPUInt32	count	= 0;

	try
	{
		count = userSet->Count();
	}
	catch (CComboError&) { }

	return count;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserSetAddUsers(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserSetRef	usersToAdd)
{
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));
	PGPValidateParam(PGPdiskUserSetRefIsValid(usersToAdd));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		userSet->Add(*usersToAdd);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport 
PGPdiskUserSetAddUser(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserRef		userToAdd)
{
	PGPValidateParam(PGPdiskUserSetRefIsValid(userSet));
	PGPValidateParam(PGPdiskUserRefIsValid(userToAdd));

	PGPError	error	= kPGPError_NoErr;

	try
	{
		userSet->Add(*userToAdd);
	}
	catch (CComboError& caughtErr)
	{
		error = caughtErr.pgpErr;
	}

	return error;
}

PGPError 
PGPdiskEngineExport