kmshare.c

PGP—Pretty Good Privacy

	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 (	psks->pKM->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, psks->pKM->Context, shares,
										psks->pKM->KeySetMain, 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 (psks->pKM->Context, 
					psks->pKM->KeySetMain, keyToSplit, 
					pszPhraseKeyToSplit, pPasskeyToSplit, sizePasskeyToSplit,
					pPasskey, sizePasskey);
			PGPclErrorBox (NULL, err);
			KMCommitKeyRingChanges (psks->pKM); 
			KMUpdateKeyInTree (psks->pKM, keyToSplit, FALSE);
			KMSelectKey (psks->pKM, keyToSplit, TRUE);
		}
	}

	// cleanup
SplitKeyCleanup :
	if (hwndProgress)
		DestroyWindow (hwndProgress);

	if (pszPhraseKeyToSplit) 
		KMFreePhrase (pszPhraseKeyToSplit);

	if (pPasskeyToSplit)
		KMFreePasskey (pPasskeyToSplit, sizePasskeyToSplit);

	if (pPasskey)
		PGPFreeData (pPasskey);

	if (shares != NULL)
		PGPFreeShares (shares);

	return (bRetVal);
}


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

static BOOL CALLBACK 
sSplitKeyDlgProc (HWND hDlg, 
				 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 (hDlg, GWL_USERDATA, lParam);
		psks = (PSPLITKEYSTRUCT)lParam;
		psks->hwndDlg = hDlg;

		// if we have a function to call to add hwnd to list, then call it
		if (psks->pKM->lpfnHwndListFunc) 
			(psks->pKM->lpfnHwndListFunc)(hDlg, TRUE, NULL, NULL);

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

		// initialize name of key to split
		SetDlgItemText (hDlg, IDC_KEYTOSPLIT, psks->szUserIDToSplit);
		LoadString (g_hInst, IDS_SPLITKEYTITLE, szTitle, sizeof(szTitle));
		lstrcat (szTitle, psks->szUserIDToSplit);
		SetWindowText (hDlg, szTitle);

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

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

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

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

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

		// initialize drag/drop
		psks->pDropTarget = KMCreateDropTarget (psks->hwndList, NULL, psks); 
		CoLockObjectExternal ((IUnknown*)psks->pDropTarget, TRUE, TRUE);
		RegisterDragDrop (psks->hwndList, psks->pDropTarget);
		KMEnableDropTarget (psks->pDropTarget, TRUE);

		return TRUE;
	}

	case WM_HELP: 
	{
	    WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
	        HELP_WM_HELP, (DWORD) (LPSTR) aSplitIds); 
	    break; 
	}

	case WM_CONTEXTMENU: 
	{
		WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
		    (DWORD) (LPVOID) aSplitIds); 
		break; 
	}

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

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

				psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, 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;

					SetDlgItemText (hDlg, IDC_CURRENTSHAREHOLDER, 
														pshs->szUserID);
					SendDlgItemMessage (hDlg, IDC_SHARESSPIN, UDM_SETPOS,
								0, (LPARAM)MAKELONG (pshs->uShares, 0));

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

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

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

		// call function to remove hwnd from list
		if (psks->pKM->lpfnHwndListFunc) 
			(psks->pKM->lpfnHwndListFunc)(hDlg, FALSE, NULL, NULL);

		// destroy data objects
		ImageList_Destroy (psks->hIml);
		sDestroyShareHolders (psks);
		sDestroySplitKeyStruct (psks);
		break;

	case WM_COMMAND:

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

		case IDOK :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			EnableWindow (psks->pKM->hWndParent, FALSE);
			if (sSplitKey (psks)) 
			{
				EnableWindow (psks->pKM->hWndParent, TRUE);
				DestroyWindow (hDlg);
			}
			else
				EnableWindow (psks->pKM->hWndParent, TRUE);
			break;

		case IDHELP :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			WinHelp (hDlg, psks->pKM->szHelpFile, HELP_CONTEXT, 
						IDH_PGPCLSPLIT_SPLITDIALOG); 
			break;

		case IDC_ADDSHAREHOLDER :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			EnableWindow (psks->pKM->hWndParent, FALSE);
			sAddShareHolderToList (hDlg, psks);
			EnableWindow (psks->pKM->hWndParent, TRUE);
			SetFocus (GetDlgItem (hDlg, IDC_ADDSHAREHOLDER));
			break;

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

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

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

		case IDC_SHARES :
			psks = (PSPLITKEYSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			switch (HIWORD(wParam)) {
			case EN_CHANGE :
				if (psks) {
					PSHAREHOLDERSTRUCT	pshs;
					GetDlgItemText (hDlg, IDC_SHARES, sz, sizeof(sz));
					pshs = psks->pshsCurrent;
					if (pshs && (lstrcmp (sz, "0"))) {
						UINT u = 
							GetDlgItemInt (hDlg, IDC_SHARES, NULL, FALSE);
						if (u != 0) {
							psks->uTotalShares -= pshs->uShares;
							pshs->uShares = u;
							psks->uTotalShares += pshs->uShares;
							SetDlgItemInt (hDlg, 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 (hDlg, IDOK), TRUE);
							else
								EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
						}
					}
				}
				break;

			case EN_KILLFOCUS :
				u = GetDlgItemInt (hDlg, 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 (hDlg, IDC_SHARES, u, FALSE);
				break;
			}
			break;
		}
		return TRUE;
	}
	return FALSE;
}


//	_______________________________________________
//
//  Split selected key

BOOL KMSplitKey (PKEYMAN pKM, PGPKeyRef key) 
{
	PSPLITKEYSTRUCT			psks;
	BOOL					bOK;
	PGPKeyID				keyidToSplit;
	PGPPublicKeyAlgorithm	keyalgToSplit;
	HWND					hwnd;

	// find existing dialog struct for this key
	PGPGetKeyIDFromKey (key, &keyidToSplit);
	PGPGetKeyNumber (key, kPGPKeyPropAlgID, &keyalgToSplit);
	psks = pKM->pSplitKeyDialogList;
	while (psks) {
		if (PGPCompareKeyIDs (&keyidToSplit, &(psks->keyidToSplit)) == 0) {
			if (keyalgToSplit == psks->keyalgToSplit) 
				break;
		}
		psks = psks->next;
	}

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

	// otherwise create new dialog
	else {
		psks = KMAlloc (sizeof (SPLITKEYSTRUCT));
		if (psks) {
			// initialize struct
			psks->pKM = pKM;
			psks->pHeadOfList = &(pKM->pSplitKeyDialogList);
			PGPGetKeyIDFromKey (key, &(psks->keyidToSplit));
			psks->keyalgToSplit = keyalgToSplit;
			KMGetKeyName (key, psks->szUserIDToSplit, kPGPMaxUserIDSize);
			psks->uTotalShares = 0;
			psks->uThreshold = 2;
			psks->iIndexCurrent = -1;
			psks->pshsCurrent = NULL;
			psks->pDropTarget = NULL; 

			// 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 = pKM->pSplitKeyDialogList;
			pKM->pSplitKeyDialogList = psks;
			bOK = TRUE;
		}
		else 
			bOK = FALSE;
	}

	return bOK;
}


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

BOOL KMExistSplitKeyDialog (PKEYMAN pKM) 
{
	if (pKM->pSplitKeyDialogList)
		return TRUE;
	else
		return FALSE;
}