pkkeyops.c

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

	case IDX_ECPUBREVKEY :
	case IDX_ECPUBEXPKEY :
	case IDX_UNKNOWNKEY :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFKEY, pds);
		if (iConfirm == IDYES)
		{
			if (!pds->bItemNotDeleted)
			{
				pds->hPostDeleteFocusItem =
						sGetAdjacentItem (hwndTree, lptli);
			}

			PGPclKeyListUpdateTree (pds->ppks->hKL,
					kPGPclKeyListRemoveObject, obj, FALSE);
			PGPDeleteKeyDBObj (obj);
			PKDeletePropertiesWindowForObject (obj);
			pds->bItemModified = TRUE;
		}

		if (iConfirm == IDCANCEL)
			return FALSE;
		else
			return TRUE;

	case IDX_RSAUSERID :
	case IDX_DSAUSERID :
		if (PKIsThisTheOnlyUserID (obj))
		{
			PKMessageBox (hwndParent, IDS_CAPTIONINFO,
					IDS_DELONLYUSERID, MB_OK|MB_ICONINFORMATION);
			break;
		}
		// fall through

	case IDX_PHOTOUSERID :
	case IDX_INVALIDUSERID :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFUSERID, pds);
		if (iConfirm == IDYES)
		{
			BOOL			bPrimary;
			PGPKeyDBObjRef	key;

			bPrimary = PKIsThisThePrimaryUserID (obj);
			if (bPrimary)
				pds->bDeletedPrimaryUserID = TRUE;

			if (!pds->bItemNotDeleted)
			{
				pds->hPostDeleteFocusItem =
						sGetAdjacentItem (hwndTree, lptli);
			}

			key = PGPPeekKeyDBObjKey (obj);
			PGPclKeyListUpdateTree (pds->ppks->hKL,
					kPGPclKeyListRemoveObject, obj, FALSE);
			PGPDeleteKeyDBObj (obj);
			pds->bItemModified = TRUE;

			if (key != pds->keyPrev)
			{
				if (PGPKeyDBObjRefIsValid (pds->keyPrev))
				{
					PGPclKeyListUpdateTree (pds->ppks->hKL,
							kPGPclKeyListUpdateObject, 
							pds->keyPrev, FALSE);
				}
				pds->keyPrev = key;
			}

			if (bPrimary)
			{
				PGPclKeyListUpdateTree (pds->ppks->hKL,
						kPGPclKeyListUpdateObject, key, FALSE);
			}
		}

		if (iConfirm == IDCANCEL)
			return FALSE;
		else
			return TRUE;

	case IDX_CERT :
	case IDX_REVCERT :
	case IDX_BADCERT :
	case IDX_EXPCERT :
	case IDX_EXPORTCERT :
	case IDX_TRUSTEDCERT :
	case IDX_METACERT :
	case IDX_X509CERT :
	case IDX_X509EXPCERT :
	case IDX_X509REVCERT :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFCERT, pds);
		if (iConfirm == IDYES)
		{
			PGPKeyDBObjRef	key;

			if (!pds->bItemNotDeleted)
			{
				pds->hPostDeleteFocusItem =
						sGetAdjacentItem (hwndTree, lptli);
			}

			PGPclKeyListUpdateTree (pds->ppks->hKL,
					kPGPclKeyListRemoveObject, obj, FALSE);
			PGPDeleteKeyDBObj (obj);
			PKDeletePropertiesWindowForObject (obj);
			pds->bItemModified = TRUE;

			key = PGPPeekKeyDBObjKey (obj);
			if (key != pds->keyPrev)
			{
				if (PGPKeyDBObjRefIsValid (pds->keyPrev))
				{
					PGPclKeyListUpdateTree (pds->ppks->hKL,
							kPGPclKeyListUpdateObject, 
							pds->keyPrev, FALSE);
				}
				pds->keyPrev = key;
			}
		}

		if (iConfirm == IDCANCEL)
			return FALSE;
		else
			return TRUE;
	}

	return FALSE;
}


//	_______________________________________________
//
//  Delete selected key or keys

BOOL
PKDeleteObject (
		PGPKEYSSTRUCT*	ppks)
{
	TL_TREEITEM		tli;
	DELETESTRUCT	ds;

	ds.pfnCallback = sDeleteSingleObject;
	ds.ppks = ppks;
	ds.bItemModified = FALSE;
	ds.bDeleteAll = FALSE;
	ds.bItemNotDeleted = FALSE;
	ds.bDeletedPrimaryUserID = FALSE;
	ds.hPostDeleteFocusItem = NULL;
	ds.keyPrev = kInvalidPGPKeyDBObjRef;
	PGPclGetDefaultPrivateKey (ppks->keydbMain, &ds.keyDefault);

	// call callback function for all selected objects
	TreeList_IterateSelected (ppks->hwndTreeList, &ds);

	if (ds.bItemModified)
	{
		if (PGPKeyDBObjRefIsValid (ds.keyPrev))
		{
			PGPclKeyListUpdateTree (ppks->hKL,
					kPGPclKeyListUpdateObject, 
					ds.keyPrev, FALSE);
		}

		if (ds.bDeletedPrimaryUserID)
		{
			PGPclKeyListSetTree (ppks->hKL, kPGPclResort, NULL);
		}
		else
		{
			if (ds.bItemNotDeleted)
			{
				if (ds.hPostDeleteFocusItem)
				{
					tli.hItem = ds.hPostDeleteFocusItem;
					TreeList_Select (ppks->hwndTreeList, &tli, FALSE);
				}
				else
					PGPclKeyListSetTree (ppks->hKL, kPGPclDeselectAll, NULL);
			}
			else
			{
				PKKeyDBModified (ppks, PK_MOD_INDEX_0);
				PGPclKeyListSetTree (ppks->hKL, kPGPclDeselectAll, NULL);
				if (ds.hPostDeleteFocusItem)
				{
					tli.hItem = ds.hPostDeleteFocusItem;
					TreeList_Select (ppks->hwndTreeList, &tli, TRUE);
					tli.stateMask = TLIS_SELECTED;
					tli.state = 0;
					tli.mask = TLIF_STATE;
					TreeList_SetItem (ppks->hwndTreeList, &tli);
				}
			}
		}
		InvalidateRect (ppks->hwndTreeList, NULL, TRUE);
		PKUpdateAllObjectPropertiesWindows (ppks);

		PGPclKeyListUpdateTree (ppks->hKL, 
				kPGPclKeyListUpdateValidities, NULL, TRUE); 
	}
	return (ds.bItemModified);
}


//	_______________________________________________
//
//	Set focused key to be default signing key

BOOL
PKSetDefaultKey (
		PGPKEYSSTRUCT*	ppks)
{
	PGPKeyDBObjRef	keyNewDef;
	PGPKeyDBObjRef	keyOldDef;
	PGPError		err;
	PGPKeyID		keyid;

	PGPclGetDefaultPrivateKey (ppks->keydbMain, &keyOldDef);
	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &keyNewDef, NULL, NULL);

	err = PGPGetKeyID (keyNewDef, &keyid);
	if (IsntPGPError (err))
	{
		PGPPrefRef		prefref;

		if (IsntPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		{
			err = PGPSetPrefData (prefref,
					kPGPPrefDefaultKeyID, sizeof(PGPKeyID), &keyid);

			if (IsntPGPError (err))
			{
				err = PGPSetPrefBoolean (prefref,
						kPGPPrefWin32OutlookExchangeID, TRUE);
			}

			if (IsntPGPError (err))
				err = PGPclFlushClientLibPrefs (prefref, NULL);
		}
	}

	if (IsntPGPError (PGPclErrorBox (ppks->hwndMain, err)))
	{
		if (PGPKeyDBObjRefIsValid (keyOldDef))
		{
			PGPclKeyListUpdateTree (ppks->hKL,
					kPGPclKeyListUpdateObject, keyOldDef, FALSE);
		}

		PGPclKeyListUpdateTree (ppks->hKL,
				kPGPclKeyListUpdateObject, keyNewDef, TRUE);
		PGPclKeyListSetTree (ppks->hKL, 
				kPGPclSelectSpecifiedOnly, keyNewDef);

		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//	Set focused UID to be primary UID

BOOL
PKSetPrimaryUserID (
		PGPKEYSSTRUCT*	ppks)
{
	PGPByte*		pPasskey			= NULL;
	LPSTR			pszPhrase			= NULL;

	PGPKeyDBObjRef	key;
	PGPKeyDBObjRef	userid;
	CHAR			sz[128];
	PGPError		err;
	PGPSize			sizePasskey;
	PGPBoolean		bSecret;

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &userid, NULL, NULL);
	key = PGPPeekKeyDBObjKey (userid);

	err = PGPGetKeyDBObjBooleanProperty (key, 
			kPGPKeyProperty_IsSecret, &bSecret);
	if (IsPGPError (PGPclErrorBox (ppks->hwndMain, err)))
		return FALSE;

	if (bSecret)
	{
		// get valid passphrase
		LoadString (g_hinst, IDS_SELKEYPASSPHRASE, sz, sizeof(sz));
		err = PGPclGetKeyPhrase (g_context, g_tlscontext,
				ppks->hwndMain, sz, ppks->keydbMain, key,
				&pszPhrase, &pPasskey, &sizePasskey);
		PGPclErrorBox (ppks->hwndMain, err);

		// now we have a valid passphrase
		if (IsntPGPError (err))
		{
			err = PGPSetPrimaryUserID (userid,
				pPasskey ?
					PGPOPasskeyBuffer (g_context, pPasskey, sizePasskey) :
					PGPOPassphrase (g_context, pszPhrase),
				PGPOLastOption (g_context));
		}
	}
	else
	{
		err = PGPSetPrimaryUserID (userid,
			PGPOLastOption (g_context));
	}

	if (pszPhrase)
		PGPclFreePhrase (pszPhrase);
	if (pPasskey)
		PGPclFreePasskey (pPasskey, sizePasskey);

	if (IsntPGPError (PGPclErrorBox (ppks->hwndMain, err)))
	{
		PGPclKeyListUpdateTree (ppks->hKL,
				kPGPclKeyListReplaceObject, key, TRUE);
		PKUpdateAllObjectPropertiesWindows (ppks);
		return TRUE;
	}
	else
		return FALSE;
}


//	_______________________________________________
//
//	add selected keys to main keyset

BOOL
PKAddSelectedToMain (
		PGPKEYSSTRUCT*	ppks)
{
	PGPKeySetRef		keysetToAdd	= kInvalidPGPKeySetRef;
	PGPError			err			= kPGPError_NoErr;
	BOOL				bRet		= FALSE;

	err = PGPclKeyListGetSelectedKeys (ppks->hKL, &keysetToAdd);
	if (IsntPGPError (err) &&
		PGPKeySetRefIsValid (keysetToAdd))
	{
		err = PGPCopyKeys (keysetToAdd, ppks->keydbMain, NULL);
		if (IsntPGPError (err))
			bRet = TRUE;
		PGPFreeKeySet (keysetToAdd);
	}

	if (bRet)
	{
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PostMessage (g_hwndMain, PK_M_REFRESHKEYRINGS, 0, FALSE);
	}

	return bRet;
}


//	_______________________________________________
//
//	routine called as a callback function from the
//  PGPCheckKeyRingSigs function

static PGPError
sKeyCheckEventHandler(
		PGPContextRef	context,
		PGPEvent		*event,
		PGPUserValue	userValue)
{
	PREVERIFYSTRUCT prvs;
	CHAR			sz[64];
	INT				iTotal;

	prvs = (PREVERIFYSTRUCT)userValue;

	iTotal = LOWORD (event->data.nullData.bytesTotal);
	if (iTotal != prvs->iNumSigsTotal)
	{
		prvs->iNumSigsTotal = iTotal;

		EnableWindow (GetDlgItem (prvs->hwndProgress, IDCANCEL), TRUE);

		LoadString (g_hinst, IDS_VERIFYING, sz, sizeof(sz));
		SetDlgItemText (prvs->hwndProgress, IDC_TEXT, sz);

		SendDlgItemMessage (prvs->hwndProgress, IDC_PROGRESSBAR,
					PBM_SETRANGE, 0, MAKELPARAM (0, prvs->iNumSigsTotal));
	}

	SendDlgItemMessage (prvs->hwndProgress, IDC_PROGRESSBAR,
			PBM_SETPOS, LOWORD (event->data.nullData.bytesWritten), 0);

	if (prvs->bCancel)
		return kPGPError_UserAbort;
	else
		return kPGPError_NoErr;
}

//	_______________________________________________
//
//	reverify signature progress dialog message procedure

static BOOL CALLBACK
sReverifyProgressDlgProc (
		HWND	hDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	PREVERIFYSTRUCT prvs;
	CHAR			sz[64];

	switch (uMsg) {
	case WM_INITDIALOG :
		SetWindowLong (hDlg, GWL_USERDATA, lParam);
		prvs = (PREVERIFYSTRUCT)lParam;
		LoadString (g_hinst, IDS_PREPARINGTOVERIFY, sz, sizeof(sz));
		SetDlgItemText (hDlg, IDC_TEXT, sz);
		prvs->hwndProgress = hDlg;
		return TRUE;

	case WM_APP :
		prvs = (PREVERIFYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
		SetForegroundWindow (prvs->hwndParent);
		EndDialog (hDlg, 0);
		break;

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDCANCEL :
			prvs = (PREVERIFYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			prvs->bCancel = TRUE;
			break;
		}
		return TRUE;
	}
	return FALSE;
}

//	_______________________________________________
//
//	reverify signatures thread routine

static DWORD
sReverifyProgressThreadRoutine (LPVOID lpvoid)
{
	PREVERIFYSTRUCT		prvs	= (PREVERIFYSTRUCT)lpvoid;

	DialogBoxParam (g_hinst,
					MAKEINTRESOURCE(IDD_REVERIFYING), NULL,
					sReverifyProgressDlgProc, (LPARAM)prvs);

	return 0;
}

//	_______________________________________________
//
//	reverify signatures of selected keys

BOOL
PKReverifySigs (
		PGPKEYSSTRUCT*	ppks)
{
	PGPKeySetRef		keysetReverify	= kInvalidPGPKeySetRef;
	PGPError			err				= kPGPError_NoErr;
	REVERIFYSTRUCT		rvs;

	rvs.hwndParent = ppks->hwndMain;
	rvs.hwndProgress = NULL;
	rvs.iNumSigsTotal = -1;
	rvs.bCancel = FALSE;
	_beginthread (sReverifyProgressThreadRoutine, 0, &rvs);

	// wait for dialog box
	EnableWindow (ppks->hwndMain, FALSE);
	while (rvs.hwndProgress == NULL) Sleep (100);

	err = PGPclKeyListGetSelectedKeys (ppks->hKL, &keysetReverify);

	if (PGPKeySetRefIsValid (keysetReverify))
	{
		err = PGPCheckKeyRingSigs (keysetReverify,
				ppks->keydbMain, TRUE, sKeyCheckEventHandler, &rvs);
	}

	// send message to close down dialog
	SendMessage (rvs.hwndProgress, WM_APP, 0, 0);
	EnableWindow (ppks->hwndMain, TRUE);

	if (IsntPGPError (PGPclErrorBox (NULL, err)))
	{
		PGPclKeyListReloadKeys (ppks->hKL, FALSE);
	}

	if (PGPKeySetRefIsValid (keysetReverify))
		PGPFreeKeySet (keysetReverify);

	PKUpdateAllObjectPropertiesWindows (ppks);

	return (IsntPGPError (err));
}