pkkeyops.c

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

	if (IsPGPError (PGPclPeekClientLibPrefRefs (&prefref, NULL)))
		return FALSE;

	PGPGetPrefBoolean (prefref, 
			kPGPPrefKeyServerSyncOnKeySign, &(ccs.bSyncWithServer));

	if (DialogBoxParam (g_hinst, MAKEINTRESOURCE(IDD_SIGNCONFIRM),
		ppks->hwndMain, sSignKeyDlgProc, (LPARAM)&ccs))
	{
		return FALSE;
	}

	// convert user-entered signature type to flags to pass
	// and setup domain regular expression
	switch (ccs.iSigType) {
	case SIG_NONEXPORTABLE :
		cs.bExportable = FALSE;
		cs.uTrustLevel = 0;
		cs.szRegExpression[0] = '\0';
		break;

	case SIG_EXPORTABLE :
		cs.bExportable = TRUE;
		cs.uTrustLevel = 0;
		cs.szRegExpression[0] = '\0';
		break;

	case SIG_TRUST :
		cs.bExportable = TRUE;
		cs.uTrustLevel = ccs.uTrustLevel;
		if (ccs.szDomain[0])
			sDomainToRegExpression (ccs.szDomain, cs.szRegExpression);
		else
			cs.szRegExpression[0] = '\0';
		break;

	case SIG_META :
		cs.bExportable = FALSE;
		cs.uTrustLevel = ccs.uTrustLevel;
		cs.szRegExpression[0] = '\0';
		break;
	}

	// convert expiration info to expire days
	if ((ccs.bExpires) && (ccs.iExpireDays > 0))
		cs.uExpireDays = (UINT)ccs.iExpireDays;
	else
		cs.uExpireDays = 0;

	// get valid passphrase
	LoadString (g_hinst, IDS_SIGNKEYPASSPHRASE, sz256, 256);
	err = PGPclGetSigningKeyPhrase (g_context, g_tlscontext,
			ppks->hwndMain, sz256,
			ppks->keydbMain, FALSE, &cs.keySigning,
			NULL, &cs.pPasskey, &cs.sizePasskey);

	if (IsntPGPError (err))
	{
		// update from server
		if (ccs.bSyncWithServer)
		{
			if (!PKGetFromServerInternal (ppks, FALSE, FALSE, FALSE))
			{
				if (PKMessageBox (ppks->hwndMain, IDS_CAPTIONALERT,
						IDS_QUERYCONTINUESIGNING,
						MB_YESNO|MB_ICONQUESTION) == IDNO)
				{
					if (cs.pPasskey)
					{
						PGPclFreePasskey (cs.pPasskey, cs.sizePasskey);
						cs.pPasskey = NULL;
					}
					return FALSE;
				}
			}
		}

		// call callback for all selected items
		TreeList_IterateSelected (ppks->hwndTreeList, &cs);

		// changes have been made; save them and update all validities
		if (cs.bItemModified)
		{
			PKKeyDBModified (ppks, PK_MOD_INDEX_0);
			PGPclKeyListReloadKeys (ppks->hKL, FALSE);
			PGPclKeyListUpdateTree (ppks->hKL, 
					kPGPclKeyListUpdateValidities, NULL, TRUE); 

			// send key to server, if selected
			if (ccs.bSyncWithServer && cs.bExportable)
				PKSendToServer (ppks, kPGPclDefaultServer);
		}
	}

	if (cs.pPasskey)
	{
		PGPclFreePasskey (cs.pPasskey, cs.sizePasskey);
		cs.pPasskey = NULL;
	}

	PKUpdateAllObjectPropertiesWindows (ppks);

	return (cs.bItemModified);
}


//	_______________________________________________
//
//  Enable selected key

BOOL
PKEnableKey (
		PGPKEYSSTRUCT*	ppks)
{
	PGPKeyDBObjRef	key;

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, NULL, NULL);
	if (IsntPGPError (PGPclErrorBox (
				ppks->hwndMain, PGPSetKeyEnabled (key, TRUE))))
	{
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PGPclKeyListUpdateTree (ppks->hKL,
				kPGPclKeyListUpdateObject, key, TRUE);
		PGPclKeyListSetTree (ppks->hKL,
				kPGPclSelectSpecifiedOnly, key);
		PKUpdateAllObjectPropertiesWindows (ppks);
		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//  Disable selected key

BOOL
PKDisableKey (
		PGPKEYSSTRUCT*	ppks)
{
	PGPKeyDBObjRef	key;

	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, NULL, NULL);
	if (IsntPGPError (PGPclErrorBox (
				ppks->hwndMain, PGPSetKeyEnabled (key, FALSE))))
	{
		PKKeyDBModified (ppks, PK_MOD_INDEX_0);
		PGPclKeyListUpdateTree (ppks->hKL,
				kPGPclKeyListUpdateObject, key, TRUE);
		PGPclKeyListSetTree (ppks->hKL,
				kPGPclSelectSpecifiedOnly, key);
		PKUpdateAllObjectPropertiesWindows (ppks);
		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//	Delete All dialog message procedure

static BOOL CALLBACK
sDeleteAllDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	PDELETESTRUCT pds;

	switch (uMsg) {

	case WM_INITDIALOG :
		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		pds = (PDELETESTRUCT)lParam;

		UTF8EditInit (GetDlgItem (hwnd, IDC_NAME));
		UTF8EditSetText (GetDlgItem (hwnd, IDC_NAME), pds->pszUserID);
		SetDlgItemText (hwnd, IDC_PROMPT, pds->pszPrompt);

		if (!pds->bMultiple)
		{
			RECT rc;

			GetWindowRect (GetDlgItem (hwnd, IDC_YESTOALL), &rc);
			MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
			SetWindowPos (GetDlgItem (hwnd, IDOK), NULL, 
					rc.left, rc.top, 0, 0, SWP_NOSIZE|SWP_NOZORDER); 

			ShowWindow (GetDlgItem (hwnd, IDC_YESTOALL), SW_HIDE);
			EnableWindow (GetDlgItem (hwnd, IDC_YESTOALL), FALSE);

			ShowWindow (GetDlgItem (hwnd, IDCANCEL), SW_HIDE);
			EnableWindow (GetDlgItem (hwnd, IDCANCEL), FALSE);
		}

		SetFocus (GetDlgItem (hwnd, IDNO));
		return FALSE;

	case WM_DESTROY :
		UTF8EditDestroy (GetDlgItem (hwnd, IDC_NAME));
		return FALSE;

	case WM_HELP :
	case WM_CONTEXTMENU :
		return PGPclHtmlHelp (hwnd, uMsg, wParam, lParam, 
				(char*)kPGPclHelpFile, aDeleteAllIds);

	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDCANCEL:
			pds = (PDELETESTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			pds->bItemNotDeleted = TRUE;
			EndDialog (hwnd, IDCANCEL);
			break;

		case IDOK:
		case IDYES:
			EndDialog (hwnd, IDYES);
			break;

		case IDNO:
			EndDialog (hwnd, IDNO);
			break;

		case IDC_YESTOALL :
			pds = (PDELETESTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			pds->bDeleteAll = TRUE;
			EndDialog (hwnd, IDYES);
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//  Ask user for delete confirmation

static INT
sDeleteConfirm (
		TL_TREEITEM*	lptli,
		INT				iPromptID,
		PDELETESTRUCT	pds)
{
	CHAR		szPrompt[256];
	INT			iRetVal;

	if (pds->bDeleteAll)
		return IDYES;

	LoadString (g_hinst, iPromptID, szPrompt, sizeof(szPrompt));
	pds->pszPrompt = szPrompt;
	pds->pszUserID = lptli->pszText;

	PGPclKeyListGetSelectionInfo (
			pds->ppks->hKL, NULL, NULL, &(pds->bMultiple), NULL);

	iRetVal = DialogBoxParam (g_hinst, MAKEINTRESOURCE (IDD_DELETEALL),
			pds->ppks->hwndMain, sDeleteAllDlgProc, (LPARAM)pds);

	if (pds->bMultiple)
	{
		if (!pds->bItemNotDeleted && (iRetVal == IDNO))
		{
			pds->bItemNotDeleted = TRUE;
			pds->hPostDeleteFocusItem = lptli->hItem;
		}
	}

	return iRetVal;
}


//	_______________________________________________
//
//  inform user about deleting keys on tokens

static INT
sDeleteTokenKeyMessage (
		TL_TREEITEM*	lptli,
		PDELETESTRUCT	pds)
{
	CHAR		sz1[512];
	CHAR		sz2[768];
	INT			iRetVal;
	PGPBoolean	bMultiple;
	PGPInt32	iFlags;

	LoadString (g_hinst, IDS_DELETETOKENKEY, sz1, sizeof(sz1));
	wsprintf (sz2, sz1, lptli->pszText);

	LoadString (g_hinst, IDS_CAPTIONINFO, sz1, sizeof(sz1));

	PGPclKeyListGetSelectionInfo (
			pds->ppks->hKL, NULL, NULL, &bMultiple, NULL);

	if (bMultiple)
		iFlags = MB_YESNOCANCEL|MB_TASKMODAL|MB_ICONEXCLAMATION;
	else
		iFlags = MB_YESNO|MB_TASKMODAL|MB_ICONEXCLAMATION;

	iRetVal = PGPclMessageBoxUTF8 (pds->ppks->hwndMain, sz2, sz1, iFlags);

	return iRetVal;
}


//	_______________________________________________
//
//  Get handle of nearby item
//
//	lptli	= pointer to TreeList item

static HTLITEM
sGetAdjacentItem (
		HWND			hwndTree,
		TL_TREEITEM*	lptli)
{
	TL_TREEITEM tli;

	tli.hItem = lptli->hItem;
	tli.mask = TLIF_NEXTHANDLE;
	TreeList_GetItem (hwndTree, &tli);
	if (!tli.hItem)
	{
		tli.hItem = lptli->hItem;
		tli.mask = TLIF_PREVHANDLE;
		TreeList_GetItem (hwndTree, &tli);
		if (!tli.hItem)
		{
			tli.hItem = lptli->hItem;
			tli.mask = TLIF_PARENTHANDLE;
			TreeList_GetItem (hwndTree, &tli);
		}
	}

	return tli.hItem;
}


//	_______________________________________________
//
//  Delete a single object
//	routine called either from KMDeleteObject or as a
//	callback function from the TreeList control to
//	delete a single item.
//
//	lptli	= pointer to TreeList item to delete

static BOOL CALLBACK
sDeleteSingleObject (
		TL_TREEITEM*	lptli,
		LPARAM			lParam)
{
	PDELETESTRUCT	pds			= (PDELETESTRUCT)lParam;
	PGPKeyDBObjRef	obj;
	INT				iConfirm;
	HWND			hwndParent;
	HWND			hwndTree;


	hwndParent = pds->ppks->hwndMain;
	hwndTree = pds->ppks->hwndTreeList;
	obj = (PGPKeyDBObjRef)(lptli->lParam);

	switch (lptli->iImage) {
	case IDX_RSASECKEY :
	case IDX_RSASECDISKEY :
	case IDX_RSASECSHRKEY :
	case IDX_DSASECKEY :
	case IDX_DSASECDISKEY :
	case IDX_DSASECSHRKEY :
	case IDX_RSAV4SECKEY :
	case IDX_RSAV4SECDISKEY :
	case IDX_RSAV4SECSHRKEY :
	case IDX_ECSECKEY :
	case IDX_ECSECDISKEY :
	case IDX_ECSECSHRKEY :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFPRIVKEY, pds);
		if (iConfirm == IDYES)
		{
			if (obj == pds->keyDefault)
			{
				if (PKMessageBox (hwndParent, IDS_CAPTIONWARNING, 
						IDS_DELCONFDEFKEY,
						MB_YESNO|MB_TASKMODAL|MB_DEFBUTTON2|MB_ICONWARNING)
							==IDNO)
				{
					return TRUE;
				}
			}

			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_RSASECREVKEY :
	case IDX_RSASECEXPKEY :
	case IDX_DSASECREVKEY :
	case IDX_DSASECEXPKEY :
	case IDX_RSAV4SECREVKEY :
	case IDX_RSAV4SECEXPKEY :
	case IDX_ECSECREVKEY :
	case IDX_ECSECEXPKEY :
		iConfirm = sDeleteConfirm (lptli, IDS_DELCONFPRIVKEY, 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_RSATOKKEY :
	case IDX_RSATOKDISKEY :
	case IDX_RSAV4TOKKEY :
	case IDX_RSAV4TOKDISKEY :
	case IDX_RSATOKREVKEY :
	case IDX_RSATOKEXPKEY :
	case IDX_RSAV4TOKREVKEY :
	case IDX_RSAV4TOKEXPKEY :
		iConfirm = sDeleteTokenKeyMessage (lptli, pds);
		if (iConfirm == IDYES)
		{
			LPSTR		pszPIN			= NULL;

			CHAR		sz[128];
			PGPError	err;

			LoadString (g_hinst, IDS_TOKENPHRASEPROMPT, sz, sizeof(sz));
			err = PGPclGetConventionalPhrase (
					g_context, hwndParent, sz, &pszPIN);

			if (IsntPGPError (err))
			{
				HCURSOR		hcursorOld	= SetCursor (LoadCursor (NULL, IDC_WAIT));
				err = PGPDeleteKeyOnToken (obj, -1, pszPIN, lstrlen(pszPIN));
				SetCursor (hcursorOld);

				if (IsntPGPError (err))
				{
					PGPclKeyListUpdateTree (pds->ppks->hKL,
							kPGPclKeyListUpdateObject, obj, FALSE);
					pds->bItemModified = TRUE;
				}
				else if (err == kPGPError_BadPassphrase)
				{
					PKMessageBox (hwndParent, IDS_CAPTIONALERT, 
							IDS_BADTOKENPHRASE, MB_OK|MB_ICONEXCLAMATION);
				}
				else
					PGPclErrorBox (hwndParent, err);
			}

			if (IsntNull (pszPIN))
				PGPclFreePhrase (pszPIN);
		}

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

	case IDX_RSAPUBKEY :
	case IDX_RSAPUBDISKEY :
	case IDX_RSAPUBREVKEY :
	case IDX_RSAPUBEXPKEY :
	case IDX_DSAPUBKEY :
	case IDX_DSAPUBDISKEY :
	case IDX_DSAPUBREVKEY :
	case IDX_DSAPUBEXPKEY :
	case IDX_RSAV4PUBKEY :
	case IDX_RSAV4PUBDISKEY :
	case IDX_RSAV4PUBREVKEY :
	case IDX_RSAV4PUBEXPKEY :
	case IDX_ECPUBKEY :
	case IDX_ECPUBDISKEY :