sclogin.c

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

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: SClogin.c,v 1.20 2002/11/22 02:32:15 wjb Exp $
__________________________________________________________________________*/

#include "precomp.h"
#include "UserEnv.h"

#define PGPDISK_DYNLINK

#include "PGPdiskEngine.h"
#include "PGPdiskUI.h"

	PGPError
PGPsdkReconnect();

void DebugOutput(char *szDebug)
{
#ifdef _DEBUG
	FILE *fbug;

	fbug=fopen("c:\\pgplogin.txt","a");

	if(fbug!=NULL)
	{
		time_t x;
		
		x = time(0);

		fprintf(fbug,"%s %s\n",ctime(&x),szDebug);
		fclose(fbug);
	}
#endif
}

PGPError	PGPscsdkInit( PGPFlags options )
{
	DebugOutput("PGPSC: PGPscsdkInit");
	return(PGPsdkInit( options ));
}

	void *
PGPscNewSecureData(
	PGPMemoryMgrRef 	mgr,
	PGPSize 			requestSize,
	PGPMemoryMgrFlags	flags )
{
	DebugOutput("PGPSC: PGPscNewSecureData");
	return(PGPNewSecureData(mgr,requestSize,flags ));
}

	PGPError
PGPscFreeData( void * allocation )
{
	DebugOutput("PGPSC: PGPscFreeData");
	return(PGPFreeData(allocation));
}

	PGPError
PGPscNewMemoryMgr(
	PGPFlags			reserved,
	PGPMemoryMgrRef *	newMgr )
{
	DebugOutput("PGPSC: PGPscNewMemoryMgr");
	return(PGPNewMemoryMgr(reserved,newMgr));
}

void WaitOnSC(PGPContextRef *PGPsc)
{
	int tries;

	DebugOutput("PGPSC: WaitOnSC");

	tries=0;

	// Wait here till our context is created
	while((*PGPsc)==NULL)
	{
		Sleep(1000);
		tries++;

		if(tries%15==0)
		{
			DebugOutput("DEBUG INFO: The PGP service hasn't started yet");
		}
	}
}

	PGPError	
PGPscPurgePassphraseCache( PGPContextRef context )
{
	DebugOutput("PGPSC: PGPscPurgePassphraseCache");

	if(context==NULL)
		return kPGPError_NoErr;

	DebugOutput("Reconnect!");

	if(IsPGPError(PGPsdkReconnect()))
	{
		DebugOutput("Reconnect failed.");

		return kPGPError_NoErr;
	}

	PGPPurgeKeyDBCache(context);
	return(PGPPurgePassphraseCache(context));
}

#define PROFILEREGPATH "Network\\Logon"

BOOL UserProfilesAreEnabled(void)
{
	DWORD dwProfile;
	HKEY hKey;
	BOOL bEnabled;
	BOOL IsNT=FALSE;
	OSVERSIONINFO osid;

	memset(&osid,0x00,sizeof(OSVERSIONINFO));

	osid.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
	GetVersionEx (&osid);   
	IsNT=(osid.dwPlatformId == VER_PLATFORM_WIN32_NT);

	if(IsNT)
	{
		return TRUE;
	}
	else
	{
		bEnabled=FALSE;

		dwProfile=0;

		if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
						PROFILEREGPATH, 
						0, 
						KEY_ALL_ACCESS, 
						&hKey) == ERROR_SUCCESS) 
		{
			DWORD  size = sizeof(dwProfile);
			DWORD  type = 0;

			if(RegQueryValueEx(hKey, 
					"UserProfiles", 
					0, 
					&type, 
					(LPBYTE)&dwProfile, 
					&size)==ERROR_SUCCESS)
			{
				// Regkey exists, so we must be using profiles
				bEnabled=TRUE;
			}

			RegCloseKey (hKey);
		}
	}

	return bEnabled;
}

typedef BOOL (WINAPI *GETPROFDIR)(char *, DWORD *);

BOOL FindProfileDir(char *lpProfilesDir,DWORD *lpcchSize)
{
	HINSTANCE hUserEnvDLL=NULL;
	BOOL RetVal;
	GETPROFDIR GetProfDir;

	RetVal=FALSE;

    hUserEnvDLL = LoadLibrary("USERENV.DLL");

    if (hUserEnvDLL != 0) 
	{
		GetProfDir  = (GETPROFDIR)GetProcAddress(hUserEnvDLL,
			"GetProfilesDirectoryA");
		
		if(GetProfDir!=NULL)
		{
			RetVal=(GetProfDir)(lpProfilesDir,lpcchSize);
		}
		FreeLibrary(hUserEnvDLL);
	}

	if(RetVal==FALSE)
	{
		GetWindowsDirectory(lpProfilesDir,*lpcchSize);

		// Make sure it ends in a backslash
		if(lpProfilesDir[strlen(lpProfilesDir)-1]!='\\')
			strcat(lpProfilesDir,"\\");
		strcat(lpProfilesDir,"Profiles");
	}

	return RetVal;
}

// This entire function is in ASCII because of the PGP SDK
BOOL SwitchToCorrectPrefs(char *szUser,char *szNT)
{
	char szPrefsPath[MAX_PATH];
	DWORD dwSize;
	FILE *ftest;
	OSVERSIONINFO osid;
	BOOL bIsNT;

	osid.dwOSVersionInfoSize = sizeof (osid);
	GetVersionEx (&osid);   
	bIsNT=(osid.dwPlatformId == VER_PLATFORM_WIN32_NT);

	if(bIsNT)
	{
		if(szNT==NULL)
			return FALSE;

		strcpy(szPrefsPath,szNT);
	}
	else
	{
		// No user name, so don't change em
		if(szUser==NULL)
			return FALSE;

		// ASCII version
		dwSize=MAX_PATH;
		FindProfileDir(szPrefsPath,&dwSize);

		// Make sure it ends in a backslash
		if(szPrefsPath[strlen(szPrefsPath)-1]!='\\')
			strcat(szPrefsPath,"\\");

		strcat(szPrefsPath,szUser);
	}

	// Make sure it ends in a backslash
	if(szPrefsPath[strlen(szPrefsPath)-1]!='\\')
		strcat(szPrefsPath,"\\");

	strcat(szPrefsPath,
		"Application Data\\PGP Corporation\\PGP\\PGPprefs.txt");

	if(UserProfilesAreEnabled())
	{
		DebugOutput(szPrefsPath);

		ftest=fopen(szPrefsPath,"rb");

		// If this fails, we just use the default prefs location
		if(ftest==0)
		{
//			Fail here. PGP isn't for this user
//			PGPclChangeDefaultPrefsFile(NULL);
			return FALSE;
		}
		else
		{
///>>> pbj
			PGPError	err;
			CHAR		szErr[64];
///<<< pbj
			fclose(ftest);
///>>> pbj
///			PGPclChangeDefaultPrefsFile(szPrefsPath);
			err = PGPclChangeDefaultPrefsFile(szPrefsPath);
			wsprintf (szErr, "PGPclChangeDefaultPrefsFile returned %li", err);
			DebugOutput (szErr);
///<<< pbj
			return TRUE;
		}
	}

	// No user profiles
	PGPclChangeDefaultPrefsFile(NULL);

	return TRUE;
}

//
//	Perform PGPdisk initialization

PGPError PGPscUnmountPGPdisks(char *szErr)
{
	PGPError	err;

	PGPdiskContextRef PGPdiskContext;

	DebugOutput("PGPSC: PGPscUnmountPGPdisks");

	err = PGPdiskEngineInitLibrary(0);

	if (IsntPGPError(err))
	{
		err = PGPdiskUIInitLibrary();

		if(IsntPGPError(err))
		{
			err = PGPdiskNewContext(kPGPdiskAPIVersion, &PGPdiskContext);

			if(IsntPGPError(err))
			{
				DebugOutput("PGPSC: UNMOUNTING DISKS*********");

				err=PGPdiskAskUnmountAllDisks(PGPdiskContext, NULL, kPGPdiskNoUnmountFlags);

				PGPdiskFreeContext(PGPdiskContext);
			}

			PGPdiskUICleanupLibrary();
		}

		PGPdiskEngineCleanupLibrary();
	}

	if ((err != kPGPError_NoErr) && (err != kPGPError_UserAbort))
	{
		PGPGetClientErrorString(err, 512, szErr);
	}

	return (DWORD)err;
}

void PGPscCleanupGINA(void *vMemMgr,
					 void **vPGPsc,
					 void **vPGPtls)
{
	PGPMemoryMgrRef MemMgr;
	PGPContextRef *PGPsc;
	PGPtlsContextRef *PGPtls;

	PGPsc=(PGPContextRef *)vPGPsc;
	PGPtls=(PGPtlsContextRef *)vPGPtls;
	MemMgr=(PGPMemoryMgrRef)vMemMgr;

	DebugOutput("PGPSC: PGPscCleanupGINA");

	// Wait here till our context is created
	WaitOnSC(PGPsc);

	if(*PGPsc!=(PGPContextRef)(-1))
	{
		if((*PGPsc!=NULL)&&(*PGPtls!=NULL))
		{
			PGPscDestroy(NULL,*PGPsc,*PGPtls);
			*PGPsc=NULL;
			*PGPtls=NULL;
		}
	}

	if(MemMgr!=NULL)
		PGPFreeMemoryMgr(MemMgr);
}

#define CP_NONE 0
#define CP_OK 1

DWORD PGPscCachePassphrase(HWND hwnd,
					void **vPGPsc,
					void **vPGPtls,
					void *memmgr,
					char *pszUserASCII,
					char *pszPassASCII,
					char *szNT)
{
	PGPError err;
	PGPKeyDBRef	keydb;
	PGPKeyDBObjRef key;
	PGPPrefRef prefRef;
	DWORD dwRet;
	PGPUInt32	cacheType;
	PGPUInt32	cacheSeconds;
	PGPBoolean	globalCache;
	PGPContextRef *PGPsc;
	PGPtlsContextRef *PGPtls;

	PGPsc=(PGPContextRef *)vPGPsc;
	PGPtls=(PGPtlsContextRef *)vPGPtls;

	DebugOutput("PGPSC: PGPscCachePassphrase");

	// Oops. Something happened here
	if((pszUserASCII==NULL)||(pszPassASCII==NULL))
	{
		DebugOutput("Hmmm. Nothing to cache?");

		return CP_NONE;
	}

	// Wait here till our context is created
	WaitOnSC(PGPsc);

	if(*PGPsc==(PGPContextRef)(-1))
	{
		DebugOutput("There is no context. Retreat! CP_NONE");
		return CP_NONE;
	}