scutils.c

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

/*__________________________________________________________________________
 Copyright (C) 2002 PGP Corporation
 All rights reserved.
 
 $Id: SCutils.c,v 1.39 2002/11/20 00:15:37 wjb Exp $
__________________________________________________________________________*/
#include "precomp.h"

//DWORD g_uPurgePassphraseCacheMessage;
/*
#pragma data_seg(".SHARDAT")
static UINT g_KeyArray[4]={0,0,0,0};
static UINT * lpJournalKeys = 0;
static UINT g_KeyIndex = 0;
static UINT g_NumKeys = 0;
static HHOOK  g_hJournalHook=NULL ;
static BOOL g_fDelay=TRUE;
#pragma data_seg()
*/

typedef struct
{
	UINT g_KeyArray[4];
	UINT * lpJournalKeys;
	UINT g_KeyIndex;
	UINT g_NumKeys;
	HHOOK  g_hJournalHook;
	BOOL g_fDelay;
} SCSHARED;

SCSHARED *SCGetSharedMem(HANDLE *hMapObject)
{
	void *mem;

	*hMapObject=CreateFileMapping
		((HANDLE)0xFFFFFFFF,
		NULL,
		PAGE_READWRITE,
		0,
		sizeof(SCSHARED),
		"PGPscSharedMemory");

	if(*hMapObject==NULL)
		return NULL;

	mem=MapViewOfFile(*hMapObject,FILE_MAP_WRITE,0,0,0);

	return mem;
}

void SCReleaseSharedMem(SCSHARED *hkShared,HANDLE hMapObject)
{
	UnmapViewOfFile(hkShared);
	
	CloseHandle(hMapObject);
}

#define LAUNCHKEYS_TIMER		53
#define MILLISECONDS_PER_DAY	86400000

#define SK_KEYDOWN  0x8000
#define SK_SYSKEY   0x4000

BOOL WINAPI SendKeys( UINT *lpKeys, UINT nKeys );

BOOL PGPscSchedPGPdirwipe(HWND hwnd,void *PGPsc,char *Directory)
{
	PGPError err;
	PGPPrefRef prefRef;
	PGPUInt32 Passes;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if(IsntPGPError(err))
	{
		PGPGetPrefNumber (prefRef,
			kPGPPrefFileWipePasses, 
			(PGPUInt32*)&Passes);
	}

	SchedulePGPdirwipe(hwnd,PGPsc,Directory,Passes);

	return TRUE;
}

BOOL PGPscGetSecureViewerPref(void *PGPsc)
{
	PGPBoolean	bSecure		= FALSE;
	PGPPrefRef	prefRef;
	PGPError err;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if(IsntPGPError(err))
	{
		PGPGetPrefBoolean (prefRef, 
			kPGPPrefAlwaysUseSecureViewer, &bSecure);
	}

	return (BOOL) bSecure;
}

BOOL PGPscHookCBTWin(void *PGPsc)
{
	PGPBoolean	bCBT		= TRUE;
	PGPPrefRef	prefRef;
	PGPError err;

	err=PGPclPeekClientLibPrefRefs(&prefRef,NULL);

	if(IsntPGPError(err))
	{
		PGPGetPrefBoolean (prefRef, 
			kPGPPrefHookCBTWin, &bCBT);
	}

	return (BOOL) bCBT;
}

LRESULT 
PGPscMessageBox (
		 HWND	hWnd, 
		 INT	iCaption, 
		 INT	iMessage,
		 ULONG	ulFlags) 
{
	CHAR szCaption [128];
	CHAR szMessage [500];

	LoadString (g_hinst, iCaption, szCaption, sizeof(szCaption));
	LoadString (g_hinst, iMessage, szMessage, sizeof(szMessage));

	ulFlags |= MB_SETFOREGROUND;
	return (MessageBox (hWnd, szMessage, szCaption, ulFlags));
}

BOOL PGPscWindowExists (LPSTR lpszName, BOOL bShow) 
{
	HWND hWndMe;
    HANDLE			hSem;

	// Create or open a named semaphore. 
    hSem = CreateSemaphore (NULL, 0, 1, lpszName);

	// Close handle and return NULL if existing semaphore was opened.
    if ((hSem != NULL) && (GetLastError() == ERROR_ALREADY_EXISTS)) 
	{
        CloseHandle(hSem);

		if(bShow)
		{
			hWndMe = FindWindow (lpszName, lpszName);
			if (hWndMe) 
			{
				if (!IsZoomed (hWndMe)) 
					ShowWindow (hWndMe, SW_RESTORE);
				BringWindowToTop(hWndMe);
				SetForegroundWindow(hWndMe);
			}
		}

		return TRUE;
	}

    // If new semaphore was created, return FALSE.
    return FALSE;
}


BOOL PGPscInit(HWND hwnd,void **PGPsc,void **PGPtls,int Flags)
{
	PGPError err;
	PGPContextRef context;
	PGPtlsContextRef tls;
	DWORD OLERetVal;

	err=PGPclInitLibrary(&context, Flags);

	if( IsPGPError(err) )
	{
		if(err == kPGPError_IncompatibleAPI)
		{
			PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_WRONGSDK,
					MB_OK|MB_ICONSTOP);
		}
		else
		if(err == kPGPError_FeatureNotAvailable)
		{
			PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_EVALEXPIRED,
					MB_OK|MB_ICONSTOP);
		}
		else
			PGPclErrorBox(hwnd,err);

		return FALSE;
	}

	PGPlnLicenseCheck (context);
///	if(IsPGPError(PGPlnIsExpired(hwnd,kPGPlnGraceExpiration)))
///	{
///		PGPclCloseLibrary();
///		return FALSE;
///	}

	if(err==kPGPError_UserAbort)
		return FALSE;

	err=PGPNewTLSContext (context, &tls);

	if( IsPGPError(err) )
	{
		PGPclErrorBox(hwnd,err);
		return FALSE;
	}

	OLERetVal=OleInitialize (NULL);

	switch(OLERetVal)
	{
		case S_OK:
			// The COM library and additional functionality were 
			// initialized successfully on this apartment. 
			break;

		case S_FALSE:
		{
			// The COM library is already initialized on this 
			// apartment.
			break;
		}

		case OLE_E_WRONGCOMPOBJ:
		{
			MessageBox(hwnd,
				"The versions of COMPOBJ.DLL and OLE2.DLL on\n"
				"your machine are incompatible with each other.",
				"OLE Error",MB_OK);
			return FALSE;
		}

		default:
		{
			MessageBox(hwnd,
				"Error initializing OLE.",
				"OLE Error",MB_OK);
			return FALSE;
		}
	}

	*PGPsc=(void *)context;
	*PGPtls=(void *)tls;

//	g_uPurgePassphraseCacheMessage = 
//		RegisterWindowMessage (kPGPclPurgePassphraseCacheMsg);

	// register the reload messages
	g_uAddedKeysMessage = 
		RegisterWindowMessage (kPGPscAddedKeysMsg);

	return TRUE;
}

BOOL PGPscDestroy(HWND hwnd,void *PGPsc,void *PGPtls)
{
	PGPError err;
	PGPContextRef context;
	PGPtlsContextRef tls;

	context=(PGPContextRef)PGPsc;
	tls=(PGPtlsContextRef)PGPtls;

	err=PGPFreeTLSContext(tls);

	PGPclCloseLibrary ();

	OleUninitialize();

	if(IsntPGPError(err))
		return TRUE;

	return FALSE;
}

BOOL PGPscInitDirectory(void)
{
	PGPError err;
	char szInitDir[MAX_PATH];

	err=PGPclGetPath (kPGPclDefaultOpenFolder, 
		szInitDir, sizeof(szInitDir));

	if(IsntPGPError(err))
	{
		SetCurrentDirectory(szInitDir);

		return TRUE;
	}

	return FALSE;
}

BOOL PGPscCheckForPurge(UINT uMsg,WPARAM wParam)
{
// There is no longer a local cache

//	if (uMsg == g_uPurgePassphraseCacheMessage)
//	{
//		PGPclPurgeCachedPassphrase (wParam);
//			return TRUE;
//	}

//	return FALSE;
	return TRUE;
}

OUTBUFFLIST *PGPscMakeOutBuffItem(OUTBUFFLIST **obl)
{
	OUTBUFFLIST *nobl,*lastobl,*indexobl;

	nobl=(OUTBUFFLIST *)malloc(sizeof(OUTBUFFLIST));
	memset(nobl,0x00,sizeof(OUTBUFFLIST));

	lastobl=indexobl=*obl;

	while(indexobl!=0)
	{
		lastobl=indexobl;
		indexobl=indexobl->next;
	}

	if(lastobl==0)
		*obl=nobl;
	else
		lastobl->next=nobl;

	return nobl;
}

BOOL PGPscConcatOutBuffList(void *PGPsc,
					   OUTBUFFLIST *obl,
					   char **pBuff,
					   DWORD *dwBuffSize,
					   BOOL *FYEO)
{
	OUTBUFFLIST *indexobl,*prevobl;
	DWORD memindex;
	PGPMemoryMgrRef	memmgr;
	PGPContextRef context;

	context=(PGPContextRef)PGPsc;

	*pBuff=0;
	*dwBuffSize=0;
	*FYEO=FALSE;

	if(obl==NULL)
		return TRUE;

	memmgr = PGPPeekContextMemoryMgr (context);

	// Find size and whether complete block is FYEO or not
	indexobl=obl;
	*dwBuffSize=0;
	*FYEO=FALSE;

	while(indexobl!=0)
	{
		if(indexobl->FYEO)
		{
			*FYEO=TRUE;
		}
		*dwBuffSize=*dwBuffSize+indexobl->dwBuffSize;
		indexobl=indexobl->next;
	}

	// Allocate new memory buffer
	if(*FYEO)
	{
		*pBuff=PGPNewSecureData (memmgr, *dwBuffSize+1, 0);
	}
	else
	{
		*pBuff=PGPNewData (memmgr, *dwBuffSize+1, 0);
	}

	if(*pBuff==NULL)
	{
		return FALSE;
	}

	// +1 for terminating null
	memset(*pBuff,0x00,*dwBuffSize+1);

	// Concatenate memory blocks and free originals/linked list
	indexobl=obl;
	memindex=0;

	while(indexobl!=0)
	{
		if(indexobl->pBuff!=0)
		{
			memcpy(&((*pBuff)[memindex]),indexobl->pBuff,indexobl->dwBuffSize);
			memset(indexobl->pBuff,0x00,indexobl->dwBuffSize);
			PGPFreeData(indexobl->pBuff);
			memindex=memindex+indexobl->dwBuffSize;
		}

		prevobl=indexobl;
		indexobl=indexobl->next;
		free(prevobl);
	}

	return TRUE;
}

void PGPscEnsureWindowIsOnMonitor(HWND hwnd)
{
	PGPclEnsureWindowIsOnMonitor(hwnd,NULL);
}

void FreePhrases(MYSTATE *ms)
{
	if(ms->PassPhrase)
	{
		PGPclFreeCachedPhrase(ms->PassPhrase);
		ms->PassPhrase=NULL;
	}

	if(ms->PassKey)
	{
		memset(ms->PassKey,0x00,ms->PassKeyLen);
		PGPFreeData(ms->PassKey);
		ms->PassKey=NULL;
	}

	if(ms->ConvPassPhrase)
	{
		PGPclFreePhrase(ms->ConvPassPhrase);
		ms->ConvPassPhrase=NULL;
	}
}

void AddKeys(HWND hwnd,PGPKeyDBRef AddKeyDB,MYSTATE *ms)
{
	PGPUInt32		numKeys;
	PGPError		err;

	if(PGPKeyDBRefIsValid(AddKeyDB))
	{
		PGPCountKeysInKeyDB( AddKeyDB, &numKeys );

		if ( numKeys > 0) 
		{	
			if(ms->bMutable==FALSE)
			{
				PGPscReadOnlyWarning(hwnd);
			}
			else
			{
				PGPKeySetRef keysetToAdd;

				PGPNewKeySet (AddKeyDB, &keysetToAdd);
		
				err=PGPclImportKeys (ms->context, ms->tlsContext, ms->hwndWorking,
					keysetToAdd, ms->KeyDB, kPGPclDefaultImportFlags);

				if(IsntPGPError(err))
				{
					PostMessage (HWND_BROADCAST, g_uAddedKeysMessage,0,0);
				}

				PGPFreeKeySet (keysetToAdd);
			}
		}
		PGPFreeKeyDB (AddKeyDB);
	}
}

static BOOL CALLBACK 
sReadOnlyDlgProc (
		HWND	hWndDlg, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam) 
{
	switch (uMsg) {
	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDOK:
			if (IsDlgButtonChecked (hWndDlg, IDC_WARNNOMORE) == BST_CHECKED)
				EndDialog (hWndDlg, 1);
			else 
				EndDialog (hWndDlg, 0);
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	____________________________________
//
// Warn user that keyrings are read-only

VOID 
PGPscReadOnlyWarning(HWND hWnd) 
{
	PGPBoolean		bWarn		= TRUE;
	PGPPrefRef		prefref		= kInvalidPGPPrefRef;
	PGPError		err;

	err = PGPclPeekClientLibPrefRefs (&prefref, NULL);

	if (IsntPGPError (err)) 
	{
		PGPGetPrefBoolean (prefref, kPGPPrefWarnOnReadOnlyKeyRings, &bWarn);

		if (bWarn) 
		{
			if (DialogBox (g_hinst, MAKEINTRESOURCE (IDD_READONLY), 
						hWnd, sReadOnlyDlgProc)) 
			{
				bWarn = FALSE;
				PGPSetPrefBoolean (
						prefref, kPGPPrefWarnOnReadOnlyKeyRings, bWarn);
				PGPclFlushClientLibPrefs (prefref, NULL);
			}
		}
	}
}

BOOL OpenRings(HWND hwnd,PGPContextRef context,PGPKeyDBRef *pkeydb,PGPBoolean *bMutable)
{
	PGPError err;

	*bMutable=TRUE;

	err=PGPclOpenDefaultKeyrings(context,
		kPGPOpenKeyDBFileOptions_Mutable,pkeydb);

	if(IsPGPError(err))
	{
		err=PGPclOpenDefaultKeyrings(context,
			kPGPOpenKeyDBFileOptions_None,pkeydb);

		if(IsntPGPError(err))
		{
			*bMutable=FALSE;
		}
		else
		{
			PGPscMessageBox (hwnd,IDS_PGPERROR,IDS_CANTOPENRINGS,
				MB_OK|MB_ICONSTOP);
			return FALSE;
		}
	}
	
	return TRUE;
}

void PGPscPGPpath(char *szPath)
{