kmprops.c

vc环境下的pgp源码

	return;
}


//	___________________________________________________
//
//  check for valid date settings

static VOID 
sValidateSubKeyDates (
		HWND				hDlg, 
		KMPROPSHEETSTRUCT*	pkmpss) 
{
	BOOL		bOK;
	SYSTEMTIME	st;
	INT			iStartDays;
	INT			iExpireDays;

	// get starting date
	SendMessage (pkmpss->hwndStartDate, DTM_GETSYSTEMTIME, 0, 
					(LPARAM)&st);
	PGPclSystemTimeToDays (&st, &iStartDays);

	// get expiration date
	iExpireDays = iStartDays+1;
	if (IsDlgButtonChecked (hDlg, IDC_NEVEREXPIRES) == BST_UNCHECKED) {
		SendMessage (pkmpss->hwndExpireDate, DTM_GETSYSTEMTIME, 0, 
					(LPARAM)&st);
		PGPclSystemTimeToDays (&st, &iExpireDays);
	}

	if ((iStartDays >= 0) && 
		(iExpireDays > iStartDays) &&
		((pkmpss->iExpireDays == -1) ||
		 (iExpireDays <= pkmpss->iExpireDays)))
		bOK = TRUE;
	else 
		bOK = FALSE;

	if (bOK)
		EnableWindow (GetDlgItem (hDlg, IDOK), TRUE);
	else
		EnableWindow (GetDlgItem (hDlg, IDOK), FALSE);
}

//	___________________________________________________
//
//  subkey generation progress dialog procedure

static BOOL CALLBACK
sSubkeyGenProgressDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	PSUBKEYGENSTRUCT	pskgs;
	DWORD				dw;

	switch (uMsg) {

	case WM_INITDIALOG:
		// store pointer to data structure
		SetWindowLong (hDlg, GWL_USERDATA, lParam);
		pskgs = (PSUBKEYGENSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
		pskgs->bAVIStarted = FALSE;
		pskgs->bAVIFinished = FALSE;
		pskgs->hwndProgress = hDlg;

		// Kick off generation proc, here
		_beginthreadex (NULL, 0, 
				(LPTHREAD_START_ROUTINE)sSubkeyGenerationThread, 
				(void *)pskgs, 0, &dw);
		SetTimer (hDlg, AVI_TIMER, 100, NULL);  // delay a few ms
												// before drawing
												// AVI
		return TRUE;

	case WM_TIMER :
		if (wParam == AVI_TIMER) {
			pskgs = (PSUBKEYGENSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			KillTimer (hDlg, AVI_TIMER);
			if (pskgs->bAVIStarted) {
				if (!pskgs->bAVIFinished) {
					pskgs->bAVIFinished = TRUE;
					if (pskgs->bGenDone) 
						PostMessage (hDlg, WM_CLOSE, 0, 0);
				}
			}
			else {
				sStartKeyGenAVI (GetDlgItem (hDlg, IDC_SUBKEYAVI),
									pskgs->pkmpss->pKM->szHelpFile);
				SetTimer (hDlg, AVI_TIMER, AVI_RUNTIME, NULL);
				pskgs->bAVIStarted = TRUE;
			}
		}
		break;
	
	case WM_DESTROY :
		pskgs = (PSUBKEYGENSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
		pskgs->bAVIFinished = TRUE;
		Animate_Close (GetDlgItem (hDlg, IDC_SUBKEYAVI));
		break;

	case WM_CLOSE :
		pskgs = (PSUBKEYGENSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
		EndDialog (hDlg, pskgs->bGenOK);
		break;

	case WM_COMMAND :
		switch(LOWORD (wParam)) {
		case IDCANCEL :
			pskgs = (PSUBKEYGENSTRUCT)GetWindowLong (hDlg, GWL_USERDATA);
			pskgs->bCancelPending = TRUE;
			break;
		}
		break;
	}

	return FALSE;
}

//	___________________________________________________
//
//  generate new subkey

static BOOL 
sAddNewSubkey (
		HWND				hDlg, 
		KMPROPSHEETSTRUCT*	pkmpss) 
{
	BOOL				bRetVal				= FALSE;

	PSUBKEYSTRUCT		psks;
	SUBKEYGENSTRUCT		skgs;

	SYSTEMTIME			st;
	UINT				uSubKeySize;
	CHAR				szSize[16];
	CHAR				szValid[32];
	CHAR				szExpires[32];
	LV_ITEM				lvI;
	INT					iItem, iStartDays;
	CHAR				sz[64];
	CHAR				sz2[128];
	PGPError			err;

	// initialize structs
	skgs.pkmpss = pkmpss;
	skgs.pszPhrase = NULL;
	skgs.pPasskey = NULL;
	skgs.bCancelPending = FALSE;
	skgs.bGenDone = FALSE;
	skgs.bGenOK = FALSE;

	// get subkey size
	uSubKeySize = 0;
	GetDlgItemText (hDlg, IDC_SUBKEYSIZE, szSize, sizeof(szSize) -1);
	uSubKeySize = atoi (szSize);
	if ((uSubKeySize < pkmpss->uMinSubkeySize) || 
		(uSubKeySize > MAXSUBKEYSIZE)) {

		LoadString (g_hInst, IDS_BADSUBKEYSIZE, sz, sizeof(sz));
		wsprintf (sz2, sz, pkmpss->uMinSubkeySize);
		LoadString (g_hInst, IDS_CAPTION, sz, sizeof(sz));
		MessageBox (hDlg, sz2, sz, MB_OK | MB_ICONEXCLAMATION);
		return FALSE;

	}
	wsprintf (szSize, "%i", uSubKeySize);

	// allocate new structure
	psks = KMAlloc (sizeof(SUBKEYSTRUCT));
	if (!psks) return FALSE;
	skgs.psks = psks;

	// initialize structure
	psks->subkey = NULL;
	psks->timeStart = 0;
	psks->iExpireDays = 0;
	psks->uSize = uSubKeySize;

	// get starting date
	SendMessage (pkmpss->hwndStartDate, DTM_GETSYSTEMTIME, 0, 
					(LPARAM)&st);
	sSystemTimeToPGPTime (&st, &psks->timeStart);
	GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, 
						NULL, szValid, sizeof(szValid));
	PGPclSystemTimeToDays (&st, &iStartDays);

	// get expiration date
	if (IsDlgButtonChecked (hDlg, IDC_NEVEREXPIRES) == BST_CHECKED) {
		psks->bNeverExpires = TRUE;
		psks->iExpireDays = 0;
	}
	else {
		psks->bNeverExpires = FALSE;
		SendMessage (pkmpss->hwndExpireDate, DTM_GETSYSTEMTIME, 0, 
					(LPARAM)&st);
		PGPclSystemTimeToDays (&st, &psks->iExpireDays);
		psks->iExpireDays -= iStartDays;
	}
	if (psks->bNeverExpires)
		LoadString (g_hInst, IDS_NEVER, szExpires, sizeof(szExpires));
	else
		GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, 
						NULL, szExpires, sizeof(szExpires));

	// get phrase from user
	LoadString (g_hInst, IDS_SELKEYPASSPHRASE, sz, sizeof(sz)); 
	KMRequestSDKAccess (pkmpss->pKM);
	err = KMGetKeyPhrase (pkmpss->pKM->Context, pkmpss->pKM->tlsContext,
					hDlg, sz, pkmpss->keyset, pkmpss->key,
					&skgs.pszPhrase, &skgs.pPasskey, &skgs.sizePasskey);
	KMReleaseSDKAccess (pkmpss->pKM);
	PGPclErrorBox (NULL, err);

	if (IsntPGPError (err)) {
		if (DialogBoxParam (g_hInst, MAKEINTRESOURCE (IDD_SUBKEYGENPROG), 
						hDlg, sSubkeyGenProgressDlgProc, (LPARAM)&skgs))
		{
			pkmpss->bNeedsCommit = TRUE;

			// figure item index to use
			iItem = ListView_GetItemCount (pkmpss->hwndSubKeys);

			// insert listview item
			lvI.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
			lvI.state = 0;      
			lvI.stateMask = 0;
			lvI.iImage = IDX_DSAPUBKEY;
		
			lvI.iItem = iItem;
			lvI.iSubItem = 0;
			lvI.pszText	= szValid; 
			lvI.cchTextMax = 0;
			lvI.lParam = (LPARAM)psks;

			iItem = ListView_InsertItem (pkmpss->hwndSubKeys, &lvI);
			if (iItem == -1) 
				KMFree (psks);
			else {
				// add strings for other columns
				ListView_SetItemText (pkmpss->hwndSubKeys, 
										iItem, 1, szExpires);
				ListView_SetItemText (pkmpss->hwndSubKeys, 
										iItem, 2, szSize);
				bRetVal = TRUE;
			}
		}
	}

	if (skgs.pszPhrase)
		KMFreePhrase (skgs.pszPhrase);

	if (skgs.pPasskey) 
		KMFreePasskey (skgs.pPasskey, skgs.sizePasskey);

	return bRetVal;
}


//	___________________________________________________
//
//  new subkey dialog procedure

static BOOL CALLBACK 
sNewSubkeyDlgProc (
		HWND	hDlg, 
		UINT	uMsg, 
		WPARAM	wParam,
		LPARAM	lParam) 
{
	KMPROPSHEETSTRUCT*	pkmpss;
	RECT				rc;
	INT					i;
	INT					iMinDefaultSize;			
	CHAR				sz[8];
	SYSTEMTIME			st;

	pkmpss = (KMPROPSHEETSTRUCT*)GetWindowLong (hDlg, GWL_USERDATA);

	switch (uMsg) {

	case WM_INITDIALOG:
		// store pointer to data structure
		SetWindowLong (hDlg, GWL_USERDATA, lParam);
		pkmpss = (KMPROPSHEETSTRUCT*)GetWindowLong (hDlg, GWL_USERDATA);

		// create and initialize start date control
		GetWindowRect (GetDlgItem (hDlg, IDC_STARTDATE), &rc);
		MapWindowPoints (NULL, hDlg, (LPPOINT)&rc, 2);
		pkmpss->hwndStartDate = CreateWindowEx (0, DATETIMEPICK_CLASS,
                             "DateTime",
                             WS_BORDER|WS_CHILD|WS_VISIBLE|WS_TABSTOP,
                             rc.left, rc.top, 
							 rc.right-rc.left, rc.bottom-rc.top, 
							 hDlg, (HMENU)IDC_STARTDATE, 
							 g_hInst, NULL);
		SetWindowPos (pkmpss->hwndStartDate, 
					GetDlgItem (hDlg, IDC_STARTDATETEXT),
					0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
		SendMessage (pkmpss->hwndStartDate, DTM_SETMCCOLOR, 
						MCSC_MONTHBK, (LPARAM)GetSysColor (COLOR_3DFACE));

		// create and initialize expire date control
		GetWindowRect (GetDlgItem (hDlg, IDC_EXPIRATIONDATE), &rc);
		MapWindowPoints (NULL, hDlg, (LPPOINT)&rc, 2);
		pkmpss->hwndExpireDate = CreateWindowEx (0, DATETIMEPICK_CLASS,
                             "DateTime",
                             WS_BORDER|WS_CHILD|WS_VISIBLE|WS_TABSTOP,
                             rc.left, rc.top, 
							 rc.right-rc.left, rc.bottom-rc.top, 
							 hDlg, (HMENU)IDC_EXPIRATIONDATE, 
							 g_hInst, NULL);
		SendMessage (pkmpss->hwndExpireDate, DTM_SETMCCOLOR, 
						MCSC_MONTHBK, (LPARAM)GetSysColor (COLOR_3DFACE));
		SetWindowPos (pkmpss->hwndExpireDate, 
					GetDlgItem (hDlg, IDC_EXPIRESON),
					0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
		EnableWindow (pkmpss->hwndExpireDate, FALSE);
		CheckDlgButton (hDlg, IDC_NEVEREXPIRES, BST_CHECKED);

		GetLocalTime (&st);
		st.wYear++;
		SendMessage (pkmpss->hwndExpireDate, DTM_SETSYSTEMTIME,
							GDT_VALID, (LPARAM)&st);

		// initialize subkey size combo box
		iMinDefaultSize = 0;
		for (i=0; i<(sizeof(uSubkeySizes)/sizeof(UINT)); i++) {
			if (uSubkeySizes[i] >= pkmpss->uMinSubkeySize) {
				wsprintf (sz, "%i", uSubkeySizes[i]);
				SendDlgItemMessage (hDlg, IDC_SUBKEYSIZE, CB_ADDSTRING, 
									0, (LPARAM)sz);
				if (iMinDefaultSize == 0) 
					iMinDefaultSize = uSubkeySizes[i];
			}
		}
		if (iMinDefaultSize < DEFAULTSUBKEYSIZE)
			iMinDefaultSize = DEFAULTSUBKEYSIZE;
		wsprintf (sz, "%i", iMinDefaultSize);
		SetDlgItemText (hDlg, IDC_SUBKEYSIZE, sz);

		sValidateSubKeyDates (hDlg, pkmpss);

		return TRUE;

	case WM_COMMAND:
		switch(LOWORD (wParam)) {
		case IDCANCEL :
			EndDialog (hDlg, FALSE);
			break;

		case IDC_NEVEREXPIRES :
		case IDC_EXPIRESON :
			if (IsDlgButtonChecked (hDlg, IDC_EXPIRESON) == BST_CHECKED) {
				EnableWindow (pkmpss->hwndExpireDate, TRUE);
				sValidateSubKeyDates (hDlg, pkmpss);
			}
			else {
				EnableWindow (pkmpss->hwndExpireDate, FALSE);
				sValidateSubKeyDates (hDlg, pkmpss);
			}
			break;

		case IDOK :
			if (sAddNewSubkey (hDlg, pkmpss))
				EndDialog (hDlg, TRUE);
			break;
		}
		return TRUE;

    case WM_HELP: 
        WinHelp (((LPHELPINFO) lParam)->hItemHandle, pkmpss->pKM->szHelpFile, 
            HELP_WM_HELP, (DWORD) (LPSTR) aNewSubkeyIds); 
        break; 
 
    case WM_CONTEXTMENU: 
        WinHelp ((HWND) wParam, pkmpss->pKM->szHelpFile, HELP_CONTEXTMENU, 
            (DWORD) (LPVOID) aNewSubkeyIds); 
        break; 

	case WM_DESTROY :
		break;

	case WM_NOTIFY :
		sValidateSubKeyDates (hDlg, pkmpss);
		break;
	}
	return FALSE;
}

//	___________________________________________________
//
//  remove subkey from listview control

static BOOL 
sRemoveSubKey (HWND hDlg, KMPROPSHEETSTRUCT* pkmpss)
{
	INT				iIndex;
	INT				iNumItems;
	INT				ids;
	LV_ITEM			lvI;
	PGPError		err;
	PSUBKEYSTRUCT	psks;

	iNumItems = ListView_GetItemCount (pkmpss->hwndSubKeys);
	if (iNumItems > 1) ids = IDS_REMOVESUBKEYCONF;
	else ids = IDS_REMOVEONLYSUBKEYCONF;

	if (KMMessageBox (hDlg, IDS_CAPTION, ids, 
			MB_YESNO | MB_ICONEXCLAMATION) == IDNO) 
		return FALSE;

	iIndex = ListView_GetNextItem (pkmpss->hwndSubKeys, -1, LVNI_SELECTED);

	if (iIndex > -1) {
		lvI.mask = LVIF_PARAM;
		lvI.iItem = iIndex;
		lvI.iSubItem = 0;
		ListView_GetItem (pkmpss->hwndSubKeys, &lvI);

		psks = (PSUBKEYSTRUCT)(lvI.lParam);

		KMRequestSDKAccess (pkmpss->pKM);
		err = PGPRemoveSubKey (psks->subkey);
		KMReleaseSDKAccess (pkmpss->pKM);
	
		if (IsntPGPError (PGPclErrorBox (hDlg, err))) {
			pkmpss->bNeedsCommit = TRUE;
			KMFree ((VOID*)lvI.lParam);
			ListView_DeleteItem (pkmpss->hwndSubKeys, iIndex);
		}
	}

	return TRUE;
}


//	___________________________________________________
//
//  revoke subkey from listview control

static BOOL 
sRevokeSubKey (HWND hDlg, KMPROPSHEETSTRUCT* pkmpss)
{
	PGPByte*		pPasskey			= NULL;
	PGPSize			sizePasskey			= 0;

	INT				iIndex;
	LV_ITEM			lvI;
	PGPError		err;
	PSUBKEYSTRUCT	psks;
	CHAR			sz[64];

	if (KMMessageBox (hDlg, IDS_CAPTION, IDS_REVOKESUBKEYCONF, 
			MB_YESNO | MB_ICONEXCLAMATION) == IDNO) 
		return FALSE;

	// get phrase from user if necessary
	LoadString (g_hInst, IDS_SELKEYPASSPHRASE, sz, sizeof(sz)); 
	KMRequestSDKAccess (pkmpss->pKM);
	err = KMGetKeyPhrase (pkmpss->pKM->Context, pkmpss->pKM->tlsContext,
					hDlg, sz, pkmpss->keyset, pkmpss->key,
					NULL, &pPasskey, &sizePasskey);
	KMReleaseSDKAccess (pkmpss->pKM);
	PGPclErrorBox (NULL, err);

	if (IsntPGPError (err)) {
		iIndex = ListView_GetNextItem (pkmpss->hwndSubKeys, 
										-1, LVNI_SELECTED);
		if (iIndex > -1) {
			lvI.mask = LVIF_PARAM;
			lvI.iItem = iIndex;
			lvI.iSubItem = 0;
			ListView_GetItem (pkmpss->hwndSubKeys, &lvI);

			psks = (PSUBKEYSTRUCT)(lvI.lParam);

			KMRequestSDKAccess (pkmpss->pKM);
			err = PGPRevokeSubKey (psks->subkey, 
							pPasskey ?
								PGPOPasskeyBuffer (pkmpss->pKM->Context, 
									pPasskey, sizePasskey) :