prefs.c

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

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

	$Id: Prefs.c,v 1.9 2002/11/15 23:13:20 wjb Exp $
____________________________________________________________________________*/
// System Headers
#include <windows.h> 

// PGPsdk Headers
#include "pgpSymmetricCipher.h"
#include "pflPrefs.h"
#include "pflPrefTypes.h"
#include "pgpDebug.h"

// Shared Headers
#include "pgpClientPrefs.h"
#include "pgpBuild.h"
#include "pgpClientLib.h"
#include "Prefs.h"


BOOL UsePGPMimeForEncryption(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bUseMime	= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefMailEncryptPGPMIME, &bUseMime);

	return (BOOL) bUseMime;
}


BOOL UsePGPMimeForSigning(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bUseMime	= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefMailSignPGPMIME, &bUseMime);

	return (BOOL) bUseMime;
}

BOOL ByDefaultEncrypt(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bEncrypt	= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefMailEncryptDefault, &bEncrypt);

	return (BOOL) bEncrypt;
}


BOOL ByDefaultSign(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bSign		= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefMailSignDefault, &bSign);

	return (BOOL) bSign;
}


BOOL ByDefaultWordWrap(PGPMemoryMgrRef memoryMgr, long* pThreshold)
{
	PGPBoolean	bWrap		= FALSE;
	PGPUInt32	width		= 0;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		*pThreshold = 0;
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefWordWrapEnable, &bWrap);
	PGPGetPrefNumber(prefRef, kPGPPrefWordWrapWidth, &width);

	*pThreshold = width;
	return (BOOL) bWrap;
}


BOOL GetCommentString(PGPMemoryMgrRef memoryMgr, 
					  char *szComment, 
					  int nLength)
{
	PGPBoolean	bGotString	= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		*szComment = 0;
		return FALSE;
	}

	PGPGetPrefStringBuffer(prefRef, kPGPPrefComment, nLength, szComment);
	if (strlen(szComment) > 0)
		bGotString = TRUE;

	return (BOOL) bGotString;
}


BOOL GetPreferredAlgorithm(PGPMemoryMgrRef memoryMgr, 
						   PGPCipherAlgorithm *prefAlg)
{
	BOOL		bGotAlgorithm	= FALSE;
	PGPUInt32	alg				= 0;
	PGPPrefRef	prefRef			= NULL;
	PGPError	err				= kPGPError_NoErr;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		*prefAlg = kPGPCipherAlgorithm_None;
		return FALSE;
	}

	err = PGPGetPrefNumber(prefRef, kPGPPrefPreferredAlgorithm, &alg);

	if (IsntPGPError(err))
	{
		*prefAlg = (PGPCipherAlgorithm) alg;
		bGotAlgorithm = TRUE;
	}
	else
	{
		*prefAlg = kPGPCipherAlgorithm_None;
		PGPclErrorBox(NULL, err);
	}

	return bGotAlgorithm;
}


BOOL GetAllowedAlgorithms(PGPMemoryMgrRef memoryMgr, 
						  PGPCipherAlgorithm *pAllowedAlgs, 
						  int *pNumAlgs)
{
	BOOL				bGotAlgorithms	= FALSE;
	PGPPrefRef			prefRef			= NULL;
	PGPCipherAlgorithm *pData			= NULL;
	PGPPrefArray *		prefArray		= NULL;
	PGPSize				dataLength		= 0;
	PGPError			err				= kPGPError_NoErr;
	int					i				= 0;

	pgpAssert(pAllowedAlgs != NULL);
	pgpAssert(pNumAlgs != NULL);

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		*pNumAlgs = 0;
		return FALSE;
	}

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

	if (IsntPGPError(err))
	{
		int i;
		PGPBoolean aes256=FALSE;
		PGPInt32 num = prefArray->numElements;

		for (i=0; i<num; i++)  
		{
			pAllowedAlgs[i] = (PGPCipherAlgorithm) 
								prefArray->elements[i].data;
			if( pAllowedAlgs[i]==kPGPCipherAlgorithm_AES256 )
				aes256=TRUE;
		}
		
		if( aes256 )  
		{	
				pAllowedAlgs[i++] = kPGPCipherAlgorithm_AES128;
				pAllowedAlgs[i++] = kPGPCipherAlgorithm_AES192;
		}

		*pNumAlgs = i;

		PGPFreePrefArray(prefArray);

		bGotAlgorithms = TRUE;
	}
	else
		*pNumAlgs = 0;

	return bGotAlgorithms;
}


BOOL AutoDecrypt(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bAuto		= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefAutoDecrypt, &bAuto);

	return (BOOL) bAuto;
}


BOOL SyncOnVerify(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bSync		= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefKeyServerSyncOnVerify, &bSync);

	return (BOOL) bSync;
}


BOOL MarginalIsInvalid(PGPMemoryMgrRef memoryMgr)
{
	PGPBoolean	bInvalid	= FALSE;
	PGPPrefRef	prefRef		= NULL;
	PGPError	err;

	err = PGPclPeekClientLibPrefRefs(&prefRef, NULL);
	if (IsPGPError(err))
	{
		PGPclErrorBox(NULL, err);
		return FALSE;
	}

	PGPGetPrefBoolean(prefRef, kPGPPrefMarginalIsInvalid, &bInvalid);

	return (BOOL) bInvalid;
}



/*__Editor_settings____

	Local Variables:
	tab-width: 4
	End:
	vi: ts=4 sw=4
	vim: si
_____________________*/