pkmsgprc.c

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

				p++;
		}
	}
}


//	____________________________________
//
//  Import keys from WM_COPYDATA struct

static BOOL 
sImportData (
		PGPKEYSSTRUCT*	ppks, 
		PCOPYDATASTRUCT pcds) 
{
	PGPKeySetRef	keyset		= kInvalidPGPKeySetRef;
	BOOL			bPrompt;

	bPrompt = pcds->dwData & PGPPK_SELECTIVEIMPORT;

	switch (pcds->dwData & PGPPK_IMPORTKEYMASK) {
	case PGPPK_IMPORTKEYCOMMANDLINE :
		sProcessFileList (pcds->lpData, ppks, TRUE, bPrompt);
		return TRUE;
	}

	return FALSE;
}


//	____________________________________
//
//  Reload keyrings

static BOOL 
sReloadKeyrings (
		PGPKEYSSTRUCT*	ppks) 
{
	BOOL					bMutable	= TRUE;
	PGPOpenKeyDBFileOptions	flags		= kPGPOpenKeyDBFileOptions_Mutable;
	INT						iLockTries	= 0;

	PGPError				err;
	HCURSOR					hcursorOld;

	hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
	err = PGPclOpenDefaultKeyrings (g_context, 
			flags, &(ppks->keydbMain));
	SetCursor (hcursorOld);

	while (!PGPKeyDBRefIsValid (ppks->keydbMain) || 
			IsPGPError (PGPclKeyListLoadKeys (
					ppks->hKL, ppks->keydbMain, 
					PGPPeekKeyDBRootKeySet (ppks->keydbMain))))
	{
		switch (err) {

		case kPGPError_FilePermissions :
			bMutable = FALSE;
			break;

		case kPGPError_FileLocked :
			iLockTries++;
			if (iLockTries < WRITELOCKTRIES) 
				Sleep (WRITELOCKDELAY);
			else 
			{
				PKMessageBox (g_hwndMain, IDS_CAPTIONERROR,
						IDS_LOCKEDKEYRING, MB_OK|MB_ICONSTOP);

				if (!PKPGPPreferences (ppks, g_hwndMain, kPGPclKeyringPrefs)) 
				{
					SendMessage (g_hwndMain, WM_CLOSE, 0, 0);
					return FALSE;
				}
			}
			break;

		case kPGPError_CantOpenFile :
		case kPGPError_FileNotFound :
			if (!PKPGPPreferences (ppks, g_hwndMain, kPGPclKeyringPrefs)) 
			{
				SendMessage (g_hwndMain, WM_CLOSE, 0, 0);
				return FALSE;
			}
			break;

		default :
			PKMessageBox (g_hwndMain, IDS_CAPTIONERROR,
					IDS_CORRUPTKEYRING, MB_OK|MB_ICONSTOP);
			if (!PKPGPPreferences (ppks, g_hwndMain, kPGPclKeyringPrefs)) 
			{
				SendMessage (g_hwndMain, WM_CLOSE, 0, 0);
				return FALSE;
			}
			break;
		}
		hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));
		flags = 0;
		if (bMutable) 
			flags |= kPGPOpenKeyDBFileOptions_Mutable;
		err = PGPclOpenDefaultKeyrings (g_context, flags, &ppks->keydbMain);

		SetCursor (hcursorOld);
	}

	PGPCalculateTrust (
			PGPPeekKeyDBRootKeySet (ppks->keydbMain), kInvalidPGPKeyDBRef);
	ppks->bReadOnly = !bMutable;

	if (ppks->bReadOnly) 
	{
		ppks->klConfig.uOptions |= kPGPclKeyList_ReadOnly;
		PKReadOnlyWarning (ppks->hwndMain);
	}
	else 
		ppks->klConfig.uOptions &= ~kPGPclKeyList_ReadOnly;

	// pass readonly flag to keymanager
	ppks->klConfig.uMask = kPGPclKeyList_Options;
	PGPclKeyListConfigure (ppks->hKL, &(ppks->klConfig));

	// reload the groups file
	ppks->gmConfig.keydbMain = ppks->keydbMain;
	PGPgmConfigure (ppks->hGM, &(ppks->gmConfig));
	PGPgmLoadGroups (ppks->hGM);

	// initialize drag/drop
	PKEnableDropTarget (ppks->pDropTarget, 
			!ppks->bReadOnly && (ppks->uFlags & PK_KEYWINDOW));

	return TRUE;
}

//	____________________________________
//
//  Draw the owner-drawn part of the status bar

static VOID
sDrawStatus (
		LPDRAWITEMSTRUCT lpdis, 
		PGPKEYSSTRUCT* ppks) 
{
	HBRUSH	hBrushLit, hBrushOld;
	HPEN	hPen, hPenOld;
	INT		i;
	INT		itop, ibot, ileft, iright;

	if (lpdis->itemID == PROGRESS_PANE)
	{
		if (ppks->iStatusValue < -1) 
			return;
		
		itop = lpdis->rcItem.top+3;
		ibot = lpdis->rcItem.bottom-5;

		hPen = CreatePen (PS_SOLID, 0, RGB (128, 128, 128));
		hPenOld = SelectObject (lpdis->hDC, hPen);
		hBrushLit = CreateSolidBrush (RGB (0, 255, 0));

		ileft = lpdis->rcItem.left + 4;

		// draw "Knight Rider" LEDs
		if (ppks->iStatusDirection) 
		{
			hBrushOld = SelectObject (lpdis->hDC, hBrushLit);
			for (i=0; i<NUMLEDS; i++) 
			{
				iright = ileft + LEDWIDTH;
		
				if (i == ppks->iStatusValue) 
					Rectangle (lpdis->hDC, ileft, itop, iright, ibot);
				else
				{
					//repaint the existing lit LED if any with standard system color
					RECT rectOfLitLed={ileft, itop, iright, ibot};
					FillRect(lpdis->hDC, &rectOfLitLed, (HBRUSH)(COLOR_3DFACE+1));

					//now draw the unlit LED
					Rectangle (lpdis->hDC, ileft+1, itop+2, iright-1, ibot-2);
				}
		
				ileft += LEDWIDTH + LEDSPACING;
			}
		}

		// draw "progress bar" LEDs
		else 
		{ 
			if (ppks->iStatusValue >= 0) 
			{
				hBrushOld = SelectObject (lpdis->hDC, hBrushLit);

				for (i=0; i<NUMLEDS; i++) 
				{
					iright = ileft + LEDWIDTH;
			
					if (i <= ppks->iStatusValue) 
						Rectangle (lpdis->hDC, ileft, itop, iright, ibot);
				
					ileft += LEDWIDTH + LEDSPACING;
				}
			}
		}

		SelectObject (lpdis->hDC, hBrushOld);
		SelectObject (lpdis->hDC, hPenOld);
		DeleteObject (hPen);
		DeleteObject (hBrushLit);
	}
}


//	____________________________________
//
//  display downloaded key count in status bar

static INT
sDisplayKSKeyResult (
		PGPKeySetRef	keyset, 
		HWND			hwnd, 
		PGPError		err) 
{
	CHAR sz1[256];
	CHAR sz2[256];
	INT	 iCount;

	if (keyset)
		(void)PGPCountKeys (keyset, &iCount);
	else 
		iCount = 0;

	if (err == kPGPError_ServerPartialSearchResults)
		LoadString (g_hinst, IDS_KSTOOMANYKEYCOUNT, sz1, sizeof(sz1));
	else 
		LoadString (g_hinst, IDS_KSKEYCOUNT, sz1, sizeof(sz1));
	wsprintf (sz2, sz1, iCount);
	SendMessage (hwnd, SB_SETTEXT, STATUS_MSG_PANE, (LPARAM)sz2);
	
	return iCount;
}


//	____________________________________
//
//  get number of wheel scroll lines and pass to treelist controls

static VOID
sUpdateWheelScrollLines (PGPKEYSSTRUCT* ppks)
{
	UINT uLines;

	if (!SystemParametersInfo (SPI_GETWHEELSCROLLLINES, 0, &uLines, 0)) 
	{
		HWND hwnd = NULL;
		UINT umsg = 0;

		umsg = RegisterWindowMessage (MSH_SCROLL_LINES);
		hwnd = FindWindow (MSH_WHEELMODULE_CLASS, MSH_WHEELMODULE_TITLE);

		if (hwnd && umsg) 
			uLines = (UINT)SendMessage (hwnd, umsg, 0, 0);
	}

	if (ppks->hwndTreeList)
		TreeList_SetWheelScrollLines (ppks->hwndTreeList, uLines);
	if (ppks->hwndTreeListGroups)
		TreeList_SetWheelScrollLines (ppks->hwndTreeListGroups, uLines);
}

//	____________________________________
//
//  create new search or file window

static HWND
sNewPGPkeysWindow (
		HWND			hwndParent,
		PGPKEYSSTRUCT*	ppks,
		BOOL			bSearch,
		BOOL			bPda,
		BOOL			bReadOnly,
		LPSTR			pszPath,
		PGPKeyDBRef		keydb)
{
	HWND			hwnd		= NULL;

	RECT			rc;
	RECT			rcMonitor;
	INT				iHeight, iWidth;
	CHAR			sz[64];
	LPSTR			pszTitle;
	PKWINDOWSTRUCT	pkws;
	HMENU			hmenu;

	// save column info of main window
	PGPclKeyListGetSelectedColumns (ppks->hKL, &s_ulColumns);
	PGPclKeyListSelectColumns (ppks->hKL, s_ulColumns, FALSE);

	// create new search window
	if (bSearch)
	{
		LoadString (g_hinst, IDS_SEARCHTITLE, sz, sizeof(sz));
		pszTitle = sz;
		hmenu = NULL;
	}
	else
	{
		pszTitle = pszPath;
		hmenu = LoadMenu (g_hinst, MAKEINTRESOURCE (IDR_MENUKEYMAN));
	}

	GetWindowRect (hwndParent, &rc);

	iWidth = rc.right - rc.left;
	if (iWidth < MINSEARCHWINDOWWIDTH)
		iWidth = MINSEARCHWINDOWWIDTH;

	iHeight = ((rc.bottom-rc.top)*3)>>2;
	if (iHeight < MINSEARCHWINDOWHEIGHT) 
		iHeight = MINSEARCHWINDOWHEIGHT;

	PGPclGetMonitorRect (hwndParent, kPGPclWindowMonitor, &rcMonitor);
	if (rc.left+60+iWidth > rcMonitor.right)
		rc.left = rcMonitor.right - iWidth - 60;

	pkws.bSearch = bSearch;
	pkws.bPda = bPda;
	pkws.bReadOnly = bReadOnly;
	pkws.keydbMain = keydb;

	hwnd = CreateWindow (PGPKEYS_WINCLASSNAME, pszTitle, 
			WS_OVERLAPPEDWINDOW|WS_VISIBLE, rc.left+60, 
			rc.top+60, iWidth,
			iHeight, NULL, hmenu, g_hinst, 
			(LPVOID)(&pkws));

	if (hwnd)
	{
		SendMessage (hwnd, PK_M_COPYFILENAMES, 0, (LPARAM)ppks);
		ppks->szFilePub[0] = '\0';
		ppks->szFileSec[0] = '\0';
	}

	return hwnd;
}


//	____________________________________
//
//  based on provided file, guess the other file name

static BOOL
sGuessMatchingKeyringFile (
	PKOPENFILESTRUCT*	ppofs,
	BOOL				bGuessSecring,
	BOOL				bNew)
{
	BOOL	bExists		= FALSE;
	CHAR*	p;
	CHAR	szGuess[MAX_PATH];
	CHAR	szExt[6];


	if (bGuessSecring && !ppofs->bHavePub)
		return FALSE;

	if (!bGuessSecring && !ppofs->bHaveSec)
		return FALSE;

	if (bGuessSecring)
	{
		lstrcpy (szGuess, ppofs->szPub);
		p = strrchr (szGuess, '.');

		if (lstrcmpi (p, ".pgp") == 0)
			lstrcpy (szExt, p);
		else
			lstrcpy (szExt, ".skr");

		if (p)
		{
			if (lstrlen (p) <= 4)
				*p = '\0';
		}

		p = strrchr (szGuess, '\\');

		if (lstrcmpi (p, "\\pubring") == 0)
		{
			*p = '\0';
			lstrcat (szGuess, "\\secring");
		}
	}
	else
	{
		lstrcpy (szGuess, ppofs->szSec);
		p = strrchr (szGuess, '.');

		if (lstrcmpi (p, ".pgp") == 0)
			lstrcpy (szExt, p);
		else
			lstrcpy (szExt, ".pkr");

		if (p)
		{
			if (lstrlen (p) <= 4)
				*p = '\0';
		}

		p = strrchr (szGuess, '\\');

		if (lstrcmpi (p, "\\secring") == 0)
		{
			*p = '\0';
			lstrcat (szGuess, "\\pubring");
		}
	}

	lstrcat (szGuess, szExt);

	if (PGPclTestPathNameStatus (szGuess) & kPGPclIsFile)
		bExists = TRUE;
	else if (!bNew)
	{
		WIN32_FIND_DATA		wfd;
		HANDLE				hfind;
		CHAR				szMatch[MAX_PATH];

		lstrcpy (szMatch, szGuess);

		p = strrchr (szMatch, '\\');
		if (!p)
		{
			p = strrchr (szMatch, ':');
			if (!p)
				p = &szMatch[0];
		}

		lstrcpy (p, "\\*");
		lstrcat (p, szExt);

		hfind = FindFirstFile (szMatch, &wfd);
		if (hfind != INVALID_HANDLE_VALUE)
		{
			bExists = TRUE;

			while (strstr (wfd.cFileName, "-bak"))
			{
				if (!FindNextFile (hfind, &wfd))
					break;
			}

			*p = '\0';
			lstrcpy (szGuess, szMatch);
			lstrcat (szGuess, "\\");
			lstrcat (szGuess, wfd.cFileName);
			FindClose (hfind);
		}
	}

	if (!bNew || !bExists)
	{
		if (bGuessSecring)
			lstrcpy (ppofs->szSec, szGuess);
		else
			lstrcpy (ppofs->szPub, szGuess);
	}

	return bExists;
}


//	____________________________________
//
//  prompt user for keyring file to open

static BOOL
sGetKeyringFileName (
		HWND			hwnd, 
		LPSTR			pszFile,
		BOOL			bSecring,
		BOOL			bNew)
{
	static CHAR		szInitDir[MAX_PATH] = {""};

	BOOL			bReturn				= FALSE;
	OPENFILENAME	ofn;
	LPSTR			p;
	CHAR			szPath[MAX_PATH];
	CHAR			szFilter[128];
	CHAR			szTitle[64];

	szPath[0] = '\0';

	if (bSecring)
		LoadString (g_hinst, IDS_SECRINGFILEFILTER, szFilter, sizeof(szFilter));
	else
		LoadString (g_hinst, IDS_PUBRINGFILEFILTER, szFilter, sizeof(szFilter));
	while (p = strrchr (szFilter, '@')) *p = '\0';

	if (szInitDir[0] == '\0')
	{
		if (pszFile[0] == '\0')
		{
			PGPclGetPath (kPGPclDefaultOpenFolder, 
					szInitDir, sizeof(szInitDir));
		}
		else
		{
			lstrcpy (szInitDir, pszFile);
			p = strrchr (szInitDir, '\\');
			if (p)
				*p = '\0';
		}
	}

	ofn.lStructSize			= sizeof (OPENFILENAME);
	ofn.hwndOwner			= hwnd;
	ofn.hInstance			= (HANDLE)g_hinst;
	ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter	= (LPTSTR)NULL;
	ofn.nMaxCustFilter		= 0L;
	ofn.nFilterIndex		= 1L;
	ofn.lpstrFile			= szPath;
	ofn.nMaxFile			= sizeof(szPath);
	ofn.lpstrFileTitle		= NULL;
	ofn.nMaxFileTitle		= 0;
	ofn.lpstrInitialDir		= szInitDir;
	ofn.lpstrTitle			= szTitle;
	ofn.nFileOffset			= 0;
	ofn.nFileExtension		= 0;
	ofn.lpstrDefExt			= "";
	ofn.lCustData			= 0;
	ofn.Flags				= OFN_HIDEREADONLY|OFN_NOCHANGEDIR;

	// create new file
	if (bNew)
	{
		LoadString (g_hinst, 
				IDS_NEWKEYRINGFILECAPTION, szTitle, sizeof(szTitle));
		ofn.Flags |= OFN_OVERWRITEPROMPT;
		if (GetSaveFileName (&ofn)) 
			bReturn = TRUE;
	}

	// open existing file
	else
	{
		LoadString (g_hinst,