pgpdiskenginedyn.c

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

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

        $Id: pgpDiskEngineDyn.c,v 1.11 2002/11/22 02:32:15 wjb Exp $
____________________________________________________________________________*/

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include "pgpMem.h"
#include "pgpPflErrors.h"

#ifndef PGPDISK_DYNLINK
#define PGPDISK_DYNLINK
#endif	// !PGPDISK_DYNLINK

#include "pgpDiskEngine.h"

/*
	Stubs for dynamic linking to the PGPdiskEngine.dll. Include this file 
	and #define PGPDISK_DYNLINK before you #include pgpDiskEngine.h.
*/

/* Types */

typedef int (_cdecl *DISKPROC)();


/* Static variables */

static HINSTANCE	PGPdiskEngineDll;

/* Function stubs */

PGPError 
PGPdiskEngineInitLibrary(PGPUInt32 Flags)
{
	PGPError	error	= kPGPError_NoErr;

	if (IsNull(PGPdiskEngineDll))
	{
		PGPdiskEngineDll = LoadLibrary("PGPdiskEngine.dll");

		if (IsNull(PGPdiskEngineDll))
			error = kPGPError_Win32DllOpFailed;
	}

	if (IsntPGPError(error))
	{
		DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(
			PGPdiskEngineDll, "PGPdiskEngineInitLibrary");

		if (IsNull(diskFunc))
			error = kPGPError_Win32DllOpFailed;

		if (IsntPGPError(error))
			error = diskFunc(Flags);
	}

	return error;
}

void 
PGPdiskEngineCleanupLibrary()
{
	if (IsntNull(PGPdiskEngineDll))
	{
		DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(
			PGPdiskEngineDll, "PGPdiskEngineCleanupLibrary");

		if (IsntNull(diskFunc))
			diskFunc();

		FreeLibrary(PGPdiskEngineDll);
		PGPdiskEngineDll = NULL;
	}
}

PGPError 
PGPdiskNewContext(PGPUInt32 clientAPIVersion, PGPdiskContextRef *pContext)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskNewContext");

	return diskFunc(clientAPIVersion, pContext);
}

void 
PGPdiskFreeContext(PGPdiskContextRef context)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskFreeContext");

	diskFunc(context);
}

PGPError 
PGPdiskEngineExport 
PGPdiskReloadContextPGPKeyDB(PGPdiskContextRef context)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskReloadContextPGPKeyDB");

	return (PGPError) diskFunc(context);
}

PGPError 
PGPdiskEngineExport 
PGPdiskDirtyPGPKeyDB(PGPdiskContextRef context)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskDirtyPGPKeyDB");

	return (PGPError) diskFunc(context);
}

PGPError 
PGPdiskOpenPeekContextPGPKeyDB(
	PGPdiskContextRef	context, 
	PGPKeyDBRef			*pPGPKeyDB)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskOpenPeekContextPGPKeyDB");

	return (PGPError) diskFunc(context, pPGPKeyDB);
}

PGPContextRef 
PGPdiskPeekContextPGPContext(PGPdiskContextRef context)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskPeekContextPGPContext");

	return (PGPContextRef) diskFunc(context);
}

PGPPrefRef 
PGPdiskPeekContextPGPclPrefs(PGPdiskContextRef context)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskPeekContextPGPclPrefs");

	return (PGPPrefRef) diskFunc(context);
}

PGPError 
PGPdiskContextIsThereADK(PGPdiskContextRef context, PGPBoolean *pIsThereADK)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskContextIsThereADK");

	return diskFunc(context, pIsThereADK);
}

PGPError 
PGPdiskContextGetADK(PGPdiskContextRef context, PGPKeyDBObjRef *pADKKey)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskContextGetADK");

	return diskFunc(context, pADKKey);
}

PGPError 
PGPdiskContextGetADKUserID(
	PGPdiskContextRef	context, 
	char				*userID, 
	PGPSize				availLength)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskContextGetADKUserID");

	return diskFunc(context, userID, availLength);
}

/* PGPdiskUserRef functions */

PGPError 
PGPdiskNewUserWithSymmetricKey(
	PGPdiskUserRef	cipheringUser, 
	const char		*userName, 
	const char		*passphrase, 
	PGPBoolean		isReadOnly, 
	PGPdiskUserRef	*pNewUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskNewUserWithSymmetricKey");

	return diskFunc(cipheringUser, userName, passphrase, isReadOnly, 
		pNewUser);
}

PGPError 
PGPdiskNewUserWithPublicKey(
	PGPdiskUserRef	cipheringUser, 
	PGPKeyDBObjRef	pubKey, 
	PGPBoolean		isReadOnly, 
	PGPBoolean		isLocked, 
	PGPdiskUserRef	*pNewUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskNewUserWithPublicKey");

	return diskFunc(cipheringUser, pubKey, isReadOnly, isLocked, pNewUser);
}

PGPError 
PGPdiskDuplicateUser(PGPdiskUserRef user, PGPdiskUserRef *pNewUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskDuplicateUser");

	return diskFunc(user, pNewUser);
}

void 
PGPdiskFreeUser(PGPdiskUserRef user)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskFreeUser");

	diskFunc(user);
}

PGPdiskContextRef 
PGPdiskPeekUserContext(PGPdiskUserRef user)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskPeekUserContext");

	return (PGPdiskContextRef) diskFunc(user);
}

PGPError 
PGPdiskUserEnableCiphering(
	PGPdiskUserRef	user, 
	PGPdiskDiskRef	disk, 
	const char		*passphrase,
	int				passkeylen)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserEnableCiphering");

	return diskFunc(user, disk, passphrase,passkeylen);
}

void 
PGPdiskUserDisableCiphering(PGPdiskUserRef user)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserDisableCiphering");

	diskFunc(user);
}

PGPError 
PGPdiskUserGetPGPKeyID(PGPdiskUserRef user, PGPKeyID *pKeyID)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserGetPGPKeyID");

	return diskFunc(user, pKeyID);
}

PGPError 
PGPdiskUserChangePassphrase(
	PGPdiskUserRef	symUserForCiphering, 
	const char		*newPassphrase)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserChangePassphrase");

	return diskFunc(symUserForCiphering, newPassphrase);
}

PGPBoolean 
PGPdiskUserAreUsersEqual(PGPdiskUserRef user1, PGPdiskUserRef user2)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserAreUsersEqual");

	return diskFunc(user1, user2);
}

PGPError 
PGPdiskGetUserBooleanProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPBoolean			*pBool)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskGetUserBooleanProp");

	return diskFunc(user, prop, pBool);
}

PGPError 
PGPdiskGetUserNumericProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPInt32			*pNumber)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskGetUserNumericProp");

	return diskFunc(user, prop, pNumber);
}

PGPError 
PGPdiskGetUserDataProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	void				*pData, 
	PGPSize				availLength, 
	PGPSize				*pUsedLength)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskGetUserDataProp");

	return diskFunc(user, prop, pData, availLength, pUsedLength);
}

PGPError 
PGPdiskSetUserBooleanProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPBoolean			boolVal)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskSetUserBooleanProp");

	return diskFunc(user, prop, boolVal);
}

PGPError 
PGPdiskSetUserNumericProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	PGPInt32			number)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskSetUserNumericProp");

	return diskFunc(user, prop, number);
}

PGPError 
PGPdiskSetUserDataProp(
	PGPdiskUserRef		user, 
	PGPdiskUserPropName	prop, 
	const void			*pData, 
	PGPSize				dataLength)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskSetUserDataProp");

	return diskFunc(user, prop, pData, dataLength);
}

/* PGPdiskUserSetRef functions */

PGPError 
PGPdiskNewUserSet(PGPdiskUserSetRef *pUserSet)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskNewUserSet");

	return diskFunc(pUserSet);
}

PGPError 
PGPdiskNewSingletonUserSet(PGPdiskUserRef user, PGPdiskUserSetRef *pUserSet)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskNewSingletonUserSet");

	return diskFunc(user, pUserSet);
}

void 
PGPdiskFreeUserSet(PGPdiskUserSetRef userSet)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskFreeUserSet");

	diskFunc(userSet);
}

PGPUInt32 
PGPdiskUserSetCount(PGPdiskUserSetRef userSet)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserSetCount");

	return diskFunc(userSet);
}

PGPError 
PGPdiskUserSetAddUsers(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserSetRef	usersToAdd)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserSetAddUsers");

	return diskFunc(userSet, usersToAdd);
}

PGPError 
PGPdiskUserSetAddUser(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserRef		userToAdd)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserSetAddUser");

	return diskFunc(userSet, userToAdd);
}

PGPError 
PGPdiskUserSetRemoveUsers(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserSetRef	usersToRemove)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserSetRemoveUsers");

	return diskFunc(userSet, usersToRemove);
}

PGPError 
PGPdiskUserSetRemoveUser(
	PGPdiskUserSetRef	userSet, 
	PGPdiskUserRef		userToRemove)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserSetRemoveUser");

	return diskFunc(userSet, userToRemove);
}

PGPError 
PGPdiskUserSetEmptyUserSet(PGPdiskUserSetRef userSet)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserSetEmptyUserSet");

	return diskFunc(userSet);
}

/* PGPdiskUserIterRef functions */

PGPError 
PGPdiskNewUserIter(PGPdiskUserSetRef userSet, PGPdiskUserIterRef *pUserIter)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskNewUserIter");

	return diskFunc(userSet, pUserIter);
}

void 
PGPdiskFreeUserIter(PGPdiskUserIterRef userIter)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskFreeUserIter");

	diskFunc(userIter);
}

PGPdiskUserSetRef 
PGPdiskPeekUserSet(PGPdiskUserIterRef userIter)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskPeekUserSet");

	return (PGPdiskUserSetRef) diskFunc(userIter);
}

PGPUInt32 
PGPdiskUserIterCount(PGPdiskUserIterRef userIter)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterCount");

	return diskFunc(userIter);
}

PGPInt32 
PGPdiskUserIterIndex(PGPdiskUserIterRef userIter)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterIndex");

	return diskFunc(userIter);
}

PGPBoolean 
PGPdiskUserIterUser(PGPdiskUserIterRef userIter, PGPdiskUserRef *pUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterUser");

	return diskFunc(userIter, pUser);
}

PGPBoolean 
PGPdiskUserIterMove(
	PGPdiskUserIterRef	userIter, 
	PGPInt32			relOffset, 
	PGPBoolean			fromStart, 
	PGPdiskUserRef		*pUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterMove");

	return diskFunc(userIter, relOffset, fromStart, pUser);
}

PGPInt32 
PGPdiskUserIterSeek(PGPdiskUserIterRef userIter, PGPdiskUserRef user)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterSeek");

	return diskFunc(userIter, user);
}

PGPBoolean 
PGPdiskUserIterNext(PGPdiskUserIterRef userIter, PGPdiskUserRef *pUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterNext");

	return diskFunc(userIter, pUser);
}

PGPBoolean 
PGPdiskUserIterPrev(PGPdiskUserIterRef userIter, PGPdiskUserRef *pUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterPrev");

	return diskFunc(userIter, pUser);
}

void 
PGPdiskUserIterRewind(PGPdiskUserIterRef userIter)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterRewind");

	diskFunc(userIter);
}

PGPBoolean 
PGPdiskUserIterSearchOnUserName(
	PGPdiskUserIterRef	userIter, 
	const char			*userName, 
	PGPdiskUserRef		*pUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterSearchOnUserName");

	return diskFunc(userIter, userName, pUser);
}

PGPBoolean 
PGPdiskUserIterFindEqualUser(
	PGPdiskUserIterRef	userIter, 
	PGPdiskUserRef		user, 
	PGPdiskUserRef		*pEqualUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterFindEqualUser");

	return diskFunc(userIter, user, pEqualUser);
}

PGPBoolean 
PGPdiskUserIterFindAdminUser(
	PGPdiskUserIterRef	userIter, 
	PGPdiskUserRef		*pAdminUser)
{
	DISKPROC	diskFunc	= (DISKPROC) GetProcAddress(PGPdiskEngineDll, 
		"PGPdiskUserIterFindAdminUser");

	return diskFunc(userIter, pAdminUser);
}