pksplit.c

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

		bRetVal = FALSE;
		goto SplitKeyCleanup;
	}

	// post progress dialog
	iNumItems = ListView_GetItemCount (psks->hwndList);
	skps.iNumSteps = iNumItems +2;
	hwndProgress = CreateDialogParam (g_hinst,
			MAKEINTRESOURCE(IDD_SPLITKEYPROGRESS),
			psks->hwndDlg, sSplitKeyProgressDlgProc,
			(LPARAM)&skps);
	LoadString (g_hinst, IDS_CREATINGSHARES, sz, sizeof(sz));
	SendMessage (hwndProgress, WM_APP, 1, (LPARAM)sz);

	// create the shares
	err = PGPCreateShares (g_context, keyToSplit,
			psks->uThreshold, psks->uTotalShares, &shares);

	if (IsPGPError (PGPclErrorBox (NULL, err)))
	{
		bRetVal = FALSE;
		goto SplitKeyCleanup;
	}

	// get the passkey from the shares
	err = PGPGetPasskeyFromShares (shares, &pPasskey, &sizePasskey);
	if (IsntPGPError (PGPclErrorBox (NULL, err)))
	{
		hcursorOld = SetCursor (LoadCursor (NULL, IDC_WAIT));

		// save share file for each item in listview
		for (iItem=0; iItem<iNumItems; iItem++)
		{
			lvI.mask = LVIF_PARAM;
			lvI.iItem = iItem;
			lvI.iSubItem = 0;
			ListView_GetItem(psks->hwndList, &lvI);

			// update progress dialog
			pshs = (PSHAREHOLDERSTRUCT)lvI.lParam;
			LoadString (g_hinst, IDS_SAVINGSHARES, sz, sizeof(sz));
			lstrcat (sz, pshs->szUserID);
			SendMessage (hwndProgress, WM_APP, iItem+2, (LPARAM)sz);

			err = sSaveSharesToFile (pshs, iItem+1,
					shares, psks->ppks->keydbMain, szFolder);
			if (IsPGPError (err))
				break;
		}

		// update progress dialog
		LoadString (g_hinst, IDS_SPLITTINGKEY, sz, sizeof(sz));
		SendMessage (hwndProgress, WM_APP, iNumItems+2, (LPARAM)sz);

		SetCursor (hcursorOld);
		PGPclErrorBox (NULL, err);

		if (IsPGPError (err))
		{
///			delete files;
		}
		else
		{
			err = sChangeKeyPhrase (keyToSplit, pszPhraseKeyToSplit, 
					pPasskeyToSplit, sizePasskeyToSplit, 
					pPasskey, sizePasskey);
			PGPclErrorBox (NULL, err);
			PGPclKeyListUpdateTree (psks->ppks->hKL, 
					kPGPclKeyListUpdateObject, keyToSplit, FALSE);
			PGPclKeyListSetTree (psks->ppks->hKL,
					kPGPclSelectSpecifiedOnly, keyToSplit);
		}
	}

	// cleanup
SplitKeyCleanup :
	if (hwndProgress)
		DestroyWindow (hwndProgress);
	if (pszPhraseKeyToSplit)
		PGPclFreePhrase (pszPhraseKeyToSplit);
	if (pPasskeyToSplit)
		PGPclFreePasskey (pPasskeyToSplit, sizePasskeyToSplit);
	if (pPasskey)
		PGPFreeData (pPasskey);
	if (shares != NULL)
		PGPFreeShares (shares);

	return (bRetVal);
}


//	_______________________________________________
//
//	Split key dialog message procedure

static BOOL CALLBACK
sSplitKeyDlgProc (
		HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam)
{
	PSPLITKEYSTRUCT		psks;
	CHAR				sz[8];
	NMHDR*				pnmh;
	UINT				u;

	switch (uMsg) {

	case WM_INITDIALOG :
	{
		CHAR	szTitle[kPGPMaxUserIDSize + 32];

		// save address of struct
		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		psks = (PSPLITKEYSTRUCT)lParam;
		psks->hwndDlg = hwnd;

		// if we have a function to call to add hwnd to list, then call it
		PKAddRemoveWindowList (hwnd, TRUE, TRUE, FALSE);

		// initialize shareholder list
		psks->hwndList = GetDlgItem (hwnd, IDC_SHAREHOLDERS);
		sInitKeyList (psks);

		// initialize name of key to split
		UTF8EditInit (GetDlgItem (hwnd, IDC_KEYTOSPLIT));
		UTF8EditSetText (GetDlgItem (hwnd, IDC_KEYTOSPLIT), psks->szUserIDToSplit);

		UTF8EditInit (GetDlgItem (hwnd, IDC_CURRENTSHAREHOLDER));


		LoadString (g_hinst, IDS_SPLITKEYTITLE, szTitle, sizeof(szTitle));
		SetWindowText (hwnd, szTitle);

		// limit number of shares
		SendDlgItemMessage (hwnd, IDC_SHARES, EM_SETLIMITTEXT,
				(WPARAM)MAX_SHARES_LEN, 0);
		SendDlgItemMessage (hwnd, IDC_THRESHOLD, EM_SETLIMITTEXT,
				(WPARAM)MAX_SHARES_LEN, 0);

		// initialize spin controls
		SendDlgItemMessage (hwnd, IDC_SHARESSPIN, UDM_SETRANGE,
				0, (LPARAM)MAKELONG (MAX_SHARES, 1));
		SetDlgItemText (hwnd, IDC_SHARES, "");
		EnableWindow (GetDlgItem (hwnd, IDC_SHARES), FALSE);
		EnableWindow (GetDlgItem (hwnd, IDC_SHARESSPIN), FALSE);

		SendDlgItemMessage (hwnd, IDC_THRESHOLDSPIN, UDM_SETRANGE,
				0, (LPARAM)MAKELONG (MAX_SHARES, 1));
		SendDlgItemMessage (hwnd, IDC_THRESHOLDSPIN, UDM_SETPOS,
				0, (LPARAM)MAKELONG (psks->uThreshold, 0));

		// initialize total number of shares
		SetDlgItemInt (hwnd, IDC_TOTALSHARES, psks->uTotalShares, FALSE);

		// "split key" and "remove" buttons initially disabled
		EnableWindow (GetDlgItem (hwnd, IDC_REMOVESHAREHOLDER), FALSE);
		EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);

		// initialize drag/drop
		psks->pDropTarget = PKCreateDropTarget (
				psks->hwndList, PK_IDROP_SPLITLIST, psks);
		CoLockObjectExternal ((IUnknown*)psks->pDropTarget, TRUE, TRUE);
		RegisterDragDrop (psks->hwndList, psks->pDropTarget);
		PKEnableDropTarget (psks->pDropTarget, TRUE);

		psks->hUTF8Font = SetUTF8Font(GetDlgItem(hwnd, IDC_SHAREHOLDERS));
		return TRUE;
	}

	case WM_DRAWITEM:
    {
        KeyDrawItem((LPDRAWITEMSTRUCT) lParam);
        return TRUE;
    }

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

	case WM_NOTIFY :
		pnmh = (NMHDR*)lParam;
		switch (pnmh->code) {

		case LVN_ITEMCHANGED :
			if (pnmh->idFrom == IDC_SHAREHOLDERS)
			{
				INT		iIndex;

				psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
				iIndex = ListView_GetNextItem (
						psks->hwndList, -1, LVNI_SELECTED);

				if (iIndex > -1)
				{
					LV_ITEM				lvI;
					PSHAREHOLDERSTRUCT	pshs;

					lvI.mask = LVIF_PARAM;
					lvI.iItem = iIndex;
					lvI.iSubItem = 0;
					ListView_GetItem(psks->hwndList, &lvI);

					pshs = (PSHAREHOLDERSTRUCT)lvI.lParam;
					psks->pshsCurrent = pshs;
					psks->iIndexCurrent = iIndex;

					UTF8EditSetText (GetDlgItem (hwnd, IDC_CURRENTSHAREHOLDER), pshs->szUserID);
					SendDlgItemMessage (hwnd, IDC_SHARESSPIN, UDM_SETPOS,
							0, (LPARAM)MAKELONG (pshs->uShares, 0));

					EnableWindow (GetDlgItem (hwnd, IDC_SHARES), TRUE);
					EnableWindow (GetDlgItem (hwnd, IDC_SHARESSPIN), TRUE);
					EnableWindow (
							GetDlgItem (hwnd, IDC_REMOVESHAREHOLDER), TRUE);
				}
				else
				{
					psks->iIndexCurrent = -1;
					psks->pshsCurrent = NULL;
					SetDlgItemText (hwnd, IDC_SHARES, "");
					UTF8EditSetText (GetDlgItem (hwnd, IDC_CURRENTSHAREHOLDER), "");
					EnableWindow (GetDlgItem (hwnd, IDC_SHARES), FALSE);
					EnableWindow (GetDlgItem (hwnd, IDC_SHARESSPIN), FALSE);
					EnableWindow (
							GetDlgItem (hwnd, IDC_REMOVESHAREHOLDER), FALSE);
				}
			}
			break;
		}
		break;

	case WM_DESTROY :
		psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

		// terminate drag/drop
		RevokeDragDrop (psks->hwndList);
		PKReleaseDropTarget (psks->pDropTarget);
		CoLockObjectExternal ((IUnknown*)psks->pDropTarget, FALSE, TRUE);

		// call function to remove hwnd from list
		PKAddRemoveWindowList (hwnd, FALSE, FALSE, FALSE);

		// destroy data objects
		ListView_SetImageList (psks->hwndList, NULL, LVSIL_SMALL);
		sDestroyShareHolders (psks);
		sDestroySplitKeyStruct (psks);
		DeleteObject(psks->hUTF8Font);

		// destroy edit controls
		UTF8EditDestroy (GetDlgItem (hwnd, IDC_KEYTOSPLIT));
		UTF8EditDestroy (GetDlgItem (hwnd, IDC_CURRENTSHAREHOLDER));
		break;

	case WM_COMMAND:

		switch (LOWORD(wParam)) {
		case IDCANCEL :
			DestroyWindow (hwnd);
			break;

		case IDOK :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			EnableWindow (psks->ppks->hwndMain, FALSE);
			if (sSplitKey (psks))
			{
				PKKeyDBModified (psks->ppks, PK_MOD_INDEX_0);
				EnableWindow (psks->ppks->hwndMain, TRUE);
				SetParent (hwnd, psks->ppks->hwndMain);
				DestroyWindow (hwnd);
			}
			else
				EnableWindow (psks->ppks->hwndMain, TRUE);
			break;

		case IDHELP :
			PGPclHtmlHelp (NULL, kPGPclHelpContext, 0, 0, 
					(char*)kPGPclHelpFile, (DWORD*)IDH_PGPPK_SPLITDIALOG);
			break;

		case IDC_ADDSHAREHOLDER :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			EnableWindow (psks->ppks->hwndMain, FALSE);
			sAddShareHolderToList (hwnd, psks);
			EnableWindow (psks->ppks->hwndMain, TRUE);
			SetFocus (GetDlgItem (hwnd, IDC_ADDSHAREHOLDER));
			break;

		case IDC_REMOVESHAREHOLDER :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			sRemoveShareHolderFromList (hwnd, psks);
			psks->iIndexCurrent = -1;
			psks->pshsCurrent = NULL;
			SetDlgItemText (hwnd, IDC_SHARES, "");
			UTF8EditSetText (GetDlgItem (hwnd, IDC_CURRENTSHAREHOLDER), "");
			EnableWindow (GetDlgItem (hwnd, IDC_SHARES), FALSE);
			EnableWindow (GetDlgItem (hwnd, IDC_REMOVESHAREHOLDER), FALSE);
			break;

		case IDC_THRESHOLD :
			switch (HIWORD(wParam)) {
			case EN_CHANGE :
				psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
				if (psks)
				{
					GetDlgItemText (hwnd, IDC_THRESHOLD, sz, sizeof(sz));
					if (lstrcmp (sz, "0"))
					{
						UINT u = GetDlgItemInt (hwnd,
								IDC_THRESHOLD, NULL, FALSE);
						if (u != 0)
						{
							psks->uThreshold = u;
							if (psks->uTotalShares >= psks->uThreshold)
								EnableWindow (GetDlgItem (hwnd, IDOK), TRUE);
							else
								EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
						}
					}
				}
				break;

			case EN_KILLFOCUS :
				u = GetDlgItemInt (hwnd, IDC_THRESHOLD, NULL, FALSE);
				if (u == 0) u = 1;
				SetDlgItemInt (hwnd, IDC_THRESHOLD, u, FALSE);
				break;
			}
			break;

		case IDC_SHARES :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			switch (HIWORD(wParam)) {
			case EN_CHANGE :
				if (psks)
				{
					PSHAREHOLDERSTRUCT	pshs;
					GetDlgItemText (hwnd, IDC_SHARES, sz, sizeof(sz));
					pshs = psks->pshsCurrent;
					if (pshs && (lstrcmp (sz, "0")))
					{
						UINT u = GetDlgItemInt (hwnd, IDC_SHARES, NULL, FALSE);
						if (u != 0)
						{
							psks->uTotalShares -= pshs->uShares;
							pshs->uShares = u;
							psks->uTotalShares += pshs->uShares;
							SetDlgItemInt (hwnd,
									IDC_TOTALSHARES, psks->uTotalShares, FALSE);

							wsprintf (sz, "%i", pshs->uShares);
							ListView_SetItemText (psks->hwndList,
									psks->iIndexCurrent, 1, sz);

							if ((psks->uTotalShares >= psks->uThreshold) &&
								(psks->uTotalShares <= MAX_TOTAL_SHARES))
							{
								EnableWindow (GetDlgItem (hwnd, IDOK), TRUE);
							}
							else
								EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
						}
					}
				}
				break;

			case EN_KILLFOCUS :
				u = GetDlgItemInt (hwnd, IDC_SHARES, NULL, FALSE);
				if (u == 0)
				{
					u = 1;
					MessageBeep (MB_ICONASTERISK);
				}
				else if (psks->uTotalShares-psks->pshsCurrent->uShares+u >
						MAX_TOTAL_SHARES)
				{
					u = MAX_TOTAL_SHARES - (psks->uTotalShares -
							psks->pshsCurrent->uShares);
					MessageBeep (MB_ICONASTERISK);
				}

				SetDlgItemInt (hwnd, IDC_SHARES, u, FALSE);
				break;
			}
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//  Split selected key

BOOL
PKSplitKey (
		PPGPKEYSSTRUCT ppks)
{
	PSPLITKEYSTRUCT			psks			= NULL;
	BOOL					bOK;
	PGPKeyDBObjRef			key;
	PGPKeyID				keyidToSplit;
	HWND					hwnd;
	PGPUInt32				u;

	// find existing dialog struct for this key
	PGPclKeyListGetSelectionInfo (ppks->hKL, NULL, &key, NULL, NULL);
	PGPGetKeyID (key, &keyidToSplit);

	psks = ppks->pSplitKeyDlgList;
	while (psks)
	{
		if (PGPCompareKeyIDs (&keyidToSplit, &(psks->keyidToSplit)) == 0)
			break;
		psks = psks->next;
	}

	// if dialog already exists, move to foreground
	if (psks)
	{
		SetForegroundWindow (psks->hwndDlg);
		bOK = TRUE;
	}

	// otherwise create new dialog
	else
	{
		psks = pkAlloc (sizeof (SPLITKEYSTRUCT));
		if (psks)
		{
			// initialize struct
			psks->ppks				= ppks;
			psks->uTotalShares		= 0;
			psks->uThreshold		= 2;
			psks->iIndexCurrent		= -1;
			psks->pshsCurrent		= NULL;
			psks->pDropTarget		= NULL;

			psks->pHeadOfList = (PSPLITKEYSTRUCT*)&(ppks->pSplitKeyDlgList);

			PGPGetKeyID (key, &(psks->keyidToSplit));
			PGPclGetPrimaryUserIDNameUTF8 (key, psks->szUserIDToSplit, 
					sizeof(psks->szUserIDToSplit), &u);

			// create modeless dialog
			hwnd = CreateDialogParam (g_hinst,
					MAKEINTRESOURCE (IDD_SPLITKEY),
					NULL, sSplitKeyDlgProc, (LPARAM)psks);

			// make it "floating"
			SetWindowPos (hwnd, HWND_TOPMOST,
					0, 0, 0, 0, SWP_NOSIZE|SWP_NOMOVE);

			// add dialog struct to list
			psks->next = ppks->pSplitKeyDlgList;
			ppks->pSplitKeyDlgList = psks;
			bOK = TRUE;
		}
		else
			bOK = FALSE;
	}

	return bOK;
}


//	_______________________________________________
//
//  Do any split key dialogs exist?

BOOL
PKExistSplitKeyDialog (
		PPGPKEYSSTRUCT ppks)
{
	if (IsntNull (ppks->pSplitKeyDlgList))
		return TRUE;
	else
		return FALSE;
}