pgpclientlib.c

来自「PGP8.0源码 请认真阅读您的文件包然后写出其具体功能」· C语言 代码 · 共 803 行 · 第 1/2 页

	flags = PGPGetMemoryMgrDataInfo (pmem);
	if (!(flags & kPGPMemoryMgrBlockInfo_NonPageable))
	{
		// memory is pageable, thus the driver is not working
		err = PGPclPeekClientLibPrefRefs (&prefs, NULL); CKERR;
		PGPGetPrefBoolean (prefs, kPGPPrefWarnOnMemLockFailure, &bWarn);

		if (bWarn)
		{
			iret = DialogBox (g_hInst, MAKEINTRESOURCE(IDD_DRIVERWARNING),
							NULL, sDriverWarnDlgProc);
			switch (iret) {
			case 0 :
				err = kPGPError_UserAbort;
				break;

			case 2 :
				PGPSetPrefBoolean (prefs, kPGPPrefWarnOnMemLockFailure, FALSE);
				PGPclFlushClientLibPrefs (prefs, NULL);
			case 1 :
				err = kPGPError_NoErr;
				break;
			}
		}
	}

done :
	if (pmem)
		PGPFreeData (pmem);
	if (PGPContextRefIsValid (context))
		PGPFreeContext (context);

	return err;
}

//	____________________________________________________________
//
//	initialize common controls

static VOID
sInitControls (VOID)
{
	INITCOMMONCONTROLSEX	icex;
	HINSTANCE				hComCtl;


	// Ensure that the common control DLL is loaded.
	InitCommonControls ();

	// Ensure that the custom controls are initialized.
	InitTreeListControl ();
	InitPGPIPAddressControl ();
	InitPGPDurationControl ();

	hComCtl = LoadLibrary ("comctl32.dll");
	if (hComCtl)
	{
 		FARPROC	pInitCommonControlsEx;

		pInitCommonControlsEx =
			GetProcAddress (hComCtl, "InitCommonControlsEx");

		if (pInitCommonControlsEx) {

			// Ensure that the extended common controls are loaded
			icex.dwSize = sizeof(icex);
			icex.dwICC = ICC_BAR_CLASSES|ICC_DATE_CLASSES;
			(*pInitCommonControlsEx)(&icex);
		}

		FreeLibrary(hComCtl);
	}
}


#if PGP_DEBUG
//	____________________________________________________________
//
//	determine how if to run SDK backend or not

static BOOL
sUseLocalExecution (
		BOOL	bSDK)
{
	PGPBoolean	bLocal			= FALSE;
	HKEY		hkey;
	LONG		lResult;
	DWORD		dw, dwValueType, dwSize;
	CHAR		szKey[256];

	PGPclGetPath (kPGPclRegistryKey, szKey, sizeof(szKey));
	lResult = RegOpenKeyEx (
			HKEY_LOCAL_MACHINE, szKey, 0, KEY_READ, &hkey);

	if (lResult == ERROR_SUCCESS) 
	{
		dwSize = sizeof(DWORD);

		if (bSDK)
		{
			lResult = RegQueryValueEx (hkey, "PGPclForceLocalSDK", 
					0, &dwValueType, (LPBYTE)&dw, &dwSize);
		}
		else
		{
			lResult = RegQueryValueEx (hkey, "PGPclForceLocalPrefs", 
					0, &dwValueType, (LPBYTE)&dw, &dwSize);
		}

		if (lResult == ERROR_SUCCESS)
		{
			if (dw == 1)
				bLocal = TRUE;
		}

		RegCloseKey (hkey);
	}

	return bLocal;
}
#endif //PGP_DEBUG

//	____________________________________________________________
//
//	check if user account needs initialization and do it if enabled

static PGPError
sHandleNewUser (
		PGPUInt32		uFlags)
{
	PGPPrefRef		prefref			= kInvalidPGPPrefRef;
	PGPError		err				= kPGPError_NoErr;
	PGPBoolean		bKeyGenerated	= TRUE;

	PGPUInt32		uStatus;

	if (uFlags & kPGPclNoPrefsFileInit)
		return kPGPError_NoErr;

	if (!PGPclIsComponentInstalled (kPGPclPGPkeys))
		return kPGPError_NoErr;

	err = PGPclPeekClientLibPrefRefs (&prefref, NULL);
	if (IsPGPError (err))
		return err;

	err = PGPGetPrefNumber (prefref, 
			kPGPPrefUserAccountStatus, &uStatus);
	if (IsPGPError (err))
		return err;

	if (uStatus == kPGPPrefPGPInitialized)
	{
		if (uFlags & kPGPclEnableNewUserWizard)
		{
			err = PGPGetPrefBoolean (prefref, 
					kPGPPrefFirstKeyGenerated, &bKeyGenerated);

			if (!bKeyGenerated)
			{
				PGPclRebootKeyGeneration (NULL, TRUE);
			}
		}

		return kPGPError_NoErr;
	}

	if (!(uFlags & kPGPclEnableNewUserWizard))
		return kPGPError_Win32_UserNotInitialized;

	if (uStatus == kPGPPrefPGPDisabled)
	{
		if (!(uFlags & kPGPclForceNewUserWizard))
			return kPGPError_Win32_UserNotInitialized;
	}

	err = CLHandleNewUser (g_context, NULL);

	return err;
}


//	____________________________________________________________
//
//	initialize DLL

PGPError PGPclExport
PGPclInitLibrary (
		PGPContextRef*	pcontext,
		PGPUInt32		uFlags)
{
	PGPError		err				= kPGPError_NoErr;
	PFLFileSpecRef	filespec		= kInvalidPFLFileSpecRef;
	PGPUInt32		uLocalMode		= 0;
	BOOL			bUseLocalPrefs	= FALSE;

	CHAR			szPath[MAX_PATH];
	WSADATA			wsa;
	OSVERSIONINFO	oviOsVerInfo={sizeof(OSVERSIONINFO), 0};

	if (IsntNull (pcontext))
		*pcontext = kInvalidPGPContextRef;

	if (g_uRefCount++ == 0)
	{
		err = sCheckCurrentDate ();
		if (IsPGPError (err))
			return err;

		err = sCheckComctl32Version ();
		if (IsPGPError (err))
			return err;

		err = CLLoadSHFolderGetPath (NULL);
		if (IsPGPError (err))
			return err;

		// initialize Winsock 1.1, if present
		s_bWinsockInitialized = (WSAStartup (MAKEWORD (1,1), &wsa) == 0);

		// attempt to startup the utility driver, in case it is stopped
		sStartUtilDriver ();

		// load the richedit 2.0 control
		LoadLibrary ("RichEd20.dll");

		// Initialize the sdk library
		if (uFlags & kPGPclUseLocalSDKMode)
			uLocalMode = kPGPFlags_ForceLocalExecution;
#if PGP_DEBUG
		if (sUseLocalExecution (TRUE))
			uLocalMode |= kPGPFlags_ForceLocalExecution;
#endif
		s_bLocalSDK = uLocalMode & kPGPFlags_ForceLocalExecution;

		err = PGPsdkInit (uLocalMode);
		if (IsPGPError (err))
			return err;

		err = PGPsdkNetworkLibInit (0);
		if (IsPGPError (err))
		{
			PGPsdkCleanup ();
			return err;
		}

		err = PGPsdkUILibInit (0);
		if (IsPGPError (err))
		{
			PGPsdkNetworkLibCleanup ();
			PGPsdkCleanup ();
			return err;
		}

		// create a new sdk context
		err = PGPNewContext (kPGPsdkAPIVersion, &g_context);
		if (IsPGPError (err))
			return err;

#if PGP_DEBUG
		bUseLocalPrefs = sUseLocalExecution (TRUE);
#endif
		err = CLInitPrefs (bUseLocalPrefs, 
				!(uFlags & kPGPclNoPrefsFileInit));

		if(IsntPGPError(err))
		{
			PGPlnLicenseCheck(g_context);
		}
	
		if (IsPGPError (err))
			return err;

		err = sCheckMemoryLockingDriver ();
		if (IsPGPError (err))
			return err;

		// initialize the RNG seed file
		if (!(uFlags & kPGPclNoPrefsFileInit))
		{
			err = CLInitRNGSeedFilePref (
					kInvalidPGPPrefRef, szPath, sizeof(szPath));
			if (IsPGPError (err))
				return err;

			err = PFLNewFileSpecFromFullPath (
					PGPPeekContextMemoryMgr (g_context), szPath, &filespec);
			if (IsntPGPError (err))
				err = PGPSetRandSeedFile (filespec);
			if (PFLFileSpecRefIsValid (filespec))
				PFLFreeFileSpec (filespec);
			if (IsPGPError (err))
				return err;
		}

		//  initialize OLE for drag and drop functionality
		OleInitialize (NULL);

		// register the mouse wheel message
		g_uMouseWheelMessage = RegisterWindowMessage (MSH_MOUSEWHEEL);

		sInitControls ();
		sInitImageLists ();

		// see if user has initialized keyrings, etc.
		err = sHandleNewUser (uFlags);
		if (IsPGPError (err))
			return err;

		//check if the os supports unicode thru and thru (=NT onwards)
		GetVersionEx (&oviOsVerInfo);   
		g_bUnicodeOS = (VER_PLATFORM_WIN32_NT == oviOsVerInfo.dwPlatformId);
	}

	if (IsntNull (pcontext))
		*pcontext = g_context;

	return err;
}


//	____________________________________________________________
//
//	close down DLL

PGPError PGPclExport
PGPclCloseLibrary (void)
{
	if ((g_uRefCount > 0) && (--g_uRefCount == 0))
	{
		PGPlnLicenseFree (g_context);

		if (g_hilKeys)
		{
			ImageList_Destroy (g_hilKeys);
			g_hilKeys = NULL;
		}

		if (g_hilClientLib)
		{
			ImageList_Destroy (g_hilClientLib);
			g_hilClientLib = NULL;
		}

		CLClosePrefs ();
		OleUninitialize ();

		if (PGPContextRefIsValid (g_context))
		{
			if (s_bLocalSDK)
			{
				PGPPurgePassphraseCache (g_context);
				pgpPassphraseCacheRemoveClient (0);
				PGPPurgeKeyDBCache (g_context); 
			}

			PGPFreeContext (g_context);
			g_context = kInvalidPGPContextRef;
		}

		PGPsdkUILibCleanup ();
		PGPsdkNetworkLibCleanup ();
		PGPsdkCleanup ();

		if (s_bWinsockInitialized)
			WSACleanup ();
	}

	return kPGPError_NoErr;
}


//	____________________
//
//	DLL entry/exit point

BOOL WINAPI
DllMain (
		 HINSTANCE hInstDll,
		 DWORD dwReason,
		 LPVOID lpvReserved)
{
	switch (dwReason) {
	case DLL_PROCESS_ATTACH:
		g_uRefCount = 0;
		g_hInst = hInstDll;
		sRegisterSelectiveImportClass ();
		break;
    case DLL_THREAD_ATTACH:
        break;
    case DLL_THREAD_DETACH:
		break;
    case DLL_PROCESS_DETACH:
		break;
    }
    return TRUE;
}