pnedit.c

vc环境下的pgp源码

			pdls->hwndThreadParent = hwnd;
			CreateThread (NULL, 0, sDNSLookupThread, (LPVOID)pdls, 0, &dw);
		}
		break;

	case WM_DESTROY :
		pdls = (PDNSLOOKUPSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		DestroyWindow (pdls->hwndAddress);
		break;

	case WM_ACTIVATE :
		InvalidateRect (hwnd, NULL, TRUE);
		break;

	case WM_PAINT :
		pdls = (PDNSLOOKUPSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		if (pdls->hPalette)
		{
			PAINTSTRUCT ps;
			HDC	hDC = BeginPaint (hwnd, &ps);
			SelectPalette (hDC, pdls->hPalette, FALSE);
			RealizePalette (hDC);
			EndPaint (hwnd, &ps);
		}
		sDrawSendStatus (GetDlgItem (hwnd, IDC_PROGRESS), pdls);
		break;

	case WM_HELP: 
		WinHelp (((LPHELPINFO) lParam)->hItemHandle, g_szHelpFile, 
			HELP_WM_HELP, (DWORD) (LPVOID) aDNSIds); 
		break; 
 
	case WM_CONTEXTMENU: 
		WinHelp ((HWND) wParam, g_szHelpFile, HELP_CONTEXTMENU, 
			(DWORD) (LPVOID) aDNSIds); 
		break; 

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDCANCEL :
			pdls = (PDNSLOOKUPSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			if (pdls->hwndThreadParent)
			{
				pdls->hwndThreadParent = NULL;
				SendMessage (hwnd, WM_APP, FALSE, 0);
			}
			else 
				EndDialog (hwnd, 0);
			break;

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

		case IDC_LOOKUP :
			pdls = (PDNSLOOKUPSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			EnableWindow (GetDlgItem (hwnd, IDC_LOOKUP), FALSE);
			ShowWindow (pdls->hwndAddress, SW_HIDE);
			ShowWindow (GetDlgItem (hwnd, IDC_HOSTFOUND), SW_HIDE);
			ShowWindow (GetDlgItem (hwnd, IDC_HOSTNOTFOUND), SW_HIDE);

			GetDlgItemText (hwnd, IDC_HOSTNAME, 
						pdls->szHostName, sizeof(pdls->szHostName));

			pdls->hwndThreadParent = NULL;
			SetTimer (hwnd, LOOKUP_TIMER_ID, LOOKUP_TIMER_MS, NULL); 
			break;

		case IDC_HOSTNAME :
			if (HIWORD (wParam) == EN_CHANGE) 
			{
				if (GetWindowTextLength ((HWND)lParam) > 0)
					EnableWindow (GetDlgItem (hwnd, IDC_LOOKUP), TRUE);
				else
					EnableWindow (GetDlgItem (hwnd, IDC_LOOKUP), FALSE);
			}
			break;
		}

		return 0;
	}

	return FALSE;
}


//	____________________________________
//
//	push the right button

static VOID
sSetAuthKeyRadioButtons (
		HWND			hwnd,
		PHOSTEDITSTRUCT	phes)
{
	UINT	uPushed		= IDC_ANYVALIDKEY;

	if (phes->host.authKeyAlg != kPGPPublicKeyAlgorithm_Invalid)
	{
		// if no IASN, must be a PGP key
		if (phes->host.authCertIASNLength == 0)
			uPushed = IDC_PGPAUTHKEY;
#if !PGP_FREEWARE
		else
			uPushed = IDC_X509CERT;
#endif //PGP_FREEWARE
	}

	CheckRadioButton (hwnd, IDC_ANYVALIDKEY, IDC_X509CERT, uPushed);
	SetFocus (GetDlgItem (hwnd, uPushed));
}


//	____________________________________
//
//	put name of key into control

static VOID
sSetKeyControl (
		HWND			hwnd,
		PHOSTEDITSTRUCT	phes)
{
	CHAR			sz[kPGPMaxUserIDSize +1];
	UINT			u, uIcon;
	HICON			hIcon;
	PGPKeyRef		key;
	PGPSigRef		sig;
	PGPKeyID		keyid;
	PGPError		err;

	sz[0] = '\0';
	uIcon = 0;
	hIcon = NULL;

	err = PGPnetGetConfiguredHostAuthKeys (g_context, &phes->host, 
										g_AOS.keysetMain, &key, &sig);

	if (IsntPGPError (err))
	{
		if (PGPKeyRefIsValid (key))
		{
			// X.509 certification
			if (PGPSigRefIsValid (sig))
			{
				uIcon = PNDetermineCertIcon (sig, NULL);
				PGPGetSigPropertyBuffer (sig,
							kPGPSigPropX509LongName, sizeof(sz), sz, &u);
			}
			// PGP key
			else
			{
				uIcon = PNDetermineKeyIcon (key, NULL);
				PGPGetPrimaryUserIDNameBuffer (key, sizeof(sz), sz, &u);
			}

			hIcon = ImageList_GetIcon (phes->hil, uIcon, ILD_TRANSPARENT);
		}
	}

	// couldn't find key or sig on keyring
	else
	{
		err = PGPImportKeyID (phes->host.authKeyExpKeyID, &keyid);
		if (IsntPGPError (err))
		{
			CHAR	szID[kPGPMaxKeyIDStringSize];

			if (PGPKeyRefIsValid (key))
				LoadString (g_hinst, IDS_UNKNOWNCERT, sz, sizeof(sz));
			else
				LoadString (g_hinst, IDS_UNKNOWNKEY, sz, sizeof(sz));

			PGPGetKeyIDString (&keyid, 
					kPGPKeyIDString_Abbreviated, szID);
			lstrcat (sz, szID);
		}
	}

	SetDlgItemText (hwnd, IDC_AUTHEDIT, sz);
	SendDlgItemMessage (hwnd, IDC_AUTHICON, STM_SETICON, (WPARAM)hIcon, 0);
}


//	____________________________________
//
//	initialize the list view control

static VOID
sInitKeyControl (
		PHOSTEDITSTRUCT	phes)
{
	HBITMAP			hBmp; 
	HDC				hDC;
	INT				iNumBits;

	// Initialize the tree view window.
	// First create imagelist and load the appropriate bitmaps based on 
	// current display capabilities.
	hDC = GetDC (NULL);		// DC for desktop
	iNumBits = GetDeviceCaps (hDC, BITSPIXEL) * GetDeviceCaps (hDC, PLANES);
	ReleaseDC (NULL, hDC);

	if (iNumBits <= 8) {
		phes->hil =	ImageList_Create (16, 16, ILC_COLOR|ILC_MASK, 
										NUM_KEY_BITMAPS, 0); 
		hBmp = LoadBitmap (g_hinst, MAKEINTRESOURCE (IDB_KEYIMG4));
		ImageList_AddMasked (phes->hil, hBmp, RGB(255, 0, 255));
		DeleteObject (hBmp);
	}
	else {
		phes->hil =	ImageList_Create (16, 16, ILC_COLOR24|ILC_MASK, 
										NUM_KEY_BITMAPS, 0); 
		hBmp = LoadBitmap (g_hinst, MAKEINTRESOURCE (IDB_KEYIMG24));
		ImageList_AddMasked (phes->hil, hBmp, RGB(255, 0, 255));
		DeleteObject (hBmp);
	}
}


//	___________________________________________________
//
//	get the first key from a keyset

static PGPError
sGetFirstKeyInSet(
	PGPKeySetRef 	keyset,
	PGPKeyRef*		pkey)
{
	PGPError		err;
	PGPKeyListRef	keylist;
	
	*pkey = kInvalidPGPKeyRef;
	
	err = PGPOrderKeySet (keyset, kPGPAnyOrdering, &keylist);
	if (IsntPGPError (err))
	{
		PGPKeyIterRef	keyiter;
		
		err = PGPNewKeyIter (keylist, &keyiter);
		if (IsntPGPError (err))
		{
			err = PGPKeyIterNext (keyiter, pkey);
			if (err == kPGPError_EndOfIteration)
				err = kPGPError_ItemNotFound;
			
			PGPFreeKeyIter (keyiter);
		}
		
		PGPFreeKeyList (keylist);
	}

	return err;
}


//	____________________________________
//
//	convert the key/cert to export format

BOOL
sRefsToExport (
		HWND				hwnd,
		PGPKeyRef			key,
		PGPSigRef			sig,
		PGPNetHostEntry*	pHost)
{
	BOOL		bReturn		= FALSE;
	PGPError	err;

	if (PGPSigRefIsValid (sig))
	{
		PGPByte*	pIASN	= NULL;

		err = PGPX509CertToExport (g_context, key, sig,
			&pHost->authKeyAlg, pHost->authKeyExpKeyID,
			&pIASN,
			&pHost->authCertIASNLength);

		if (!PGPclErrorBox (hwnd, err))
		{
			if (pHost->authCertIASNLength > kMaxNetHostIASNLength) 
			{
				PNMessageBox (hwnd, IDS_CAPTION, IDS_IASNTOOLONG, 
								MB_OK|MB_ICONSTOP);
			}
			else
			{
				pgpCopyMemory (pIASN, pHost->authCertIASN, 
										pHost->authCertIASNLength);
				bReturn = TRUE;
			}
		}

		if (IsntNull (pIASN))
			PGPFreeData (pIASN);
	}

	else if (PGPKeyRefIsValid (key))
	{
		PGPKeyID	keyid;
		PGPSize		size;

		err = PGPGetKeyNumber (key, 
						kPGPKeyPropAlgID, &pHost->authKeyAlg);

		if (IsntPGPError (err))
		{
			err = PGPGetKeyIDFromKey (key, &keyid);
			if (IsntPGPError (err))
			{
				err = PGPExportKeyID (
							&keyid, pHost->authKeyExpKeyID, &size);
				if (IsntPGPError (err))
				{
					pHost->authCertIASNLength = 0;
					bReturn = TRUE;
				}
			}
		}
	}

	else
	{
		pHost->authKeyAlg = kPGPPublicKeyAlgorithm_Invalid;
		pHost->authCertIASNLength = 0;
		bReturn = TRUE;
	}

	return bReturn;
}


//	____________________________________
//
//	dialog proc of edit dialog

static BOOL CALLBACK
sEditHostDlgProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam)
{
	PHOSTEDITSTRUCT		phes;
	INT					iIndex;

	switch (uMsg)
	{
	case WM_INITDIALOG :
	{
		CHAR			sz[32];
		RECT			rc;
		DWORD			dw;

		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		phes = (PHOSTEDITSTRUCT)lParam;

		sInitKeyControl (phes);

		SetDlgItemText (hwnd, IDC_DOMAINNAME, phes->host.hostName);
		SetDlgItemText (hwnd, IDC_IDENTITY, phes->host.identity);
		SendDlgItemMessage (hwnd, IDC_IDENTITY,
					EM_LIMITTEXT, kMaxNetHostIdentityLength, 0);

		// create IP edit control for address
		GetWindowRect (GetDlgItem (hwnd, IDC_IPADDRESS), &rc);
		MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
		phes->hwndIPAddr = CreateWindowEx (
				WS_EX_CLIENTEDGE,
				WC_PGPIPADDRESS, "", 
				WS_CHILD|WS_VISIBLE|WS_TABSTOP,
				rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top,
				hwnd, (HMENU)IDC_IPADDRESS, g_hinst, NULL);
		// set tab-order of control
		SetWindowPos (phes->hwndIPAddr, GetDlgItem (hwnd, IDC_IPADDRESS),
						0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
		// initialize contents of control
		dw = phes->host.ipAddress;
		if (dw != 0)
			SendMessage (phes->hwndIPAddr, PGP_IPM_SETADDRESS, 0, (LPARAM)dw);

		// create IP edit control for mask
		GetWindowRect (GetDlgItem (hwnd, IDC_IPMASK), &rc);
		MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
		phes->hwndIPSubnet = CreateWindowEx (
				WS_EX_CLIENTEDGE,
				WC_PGPIPADDRESS, "", 
				WS_CHILD|WS_VISIBLE|WS_TABSTOP,
				rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top,
				hwnd, (HMENU)IDC_IPMASK, g_hinst, NULL);
		// set tab-order of control
		SetWindowPos (phes->hwndIPSubnet, GetDlgItem (hwnd, IDC_IPMASK),
						0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
		// initialize contents of control
		dw = phes->host.ipMask;
		SendMessage (phes->hwndIPSubnet, PGP_IPM_SETADDRESS, 0, (LPARAM)dw);

		// create IP edit control for ID
		GetWindowRect (GetDlgItem (hwnd, IDC_IPID), &rc);
		MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
		phes->hwndIPID = CreateWindowEx (
				WS_EX_CLIENTEDGE,
				WC_PGPIPADDRESS, "", 
				WS_CHILD|WS_VISIBLE|WS_TABSTOP,
				rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top,
				hwnd, (HMENU)IDC_IPID, g_hinst, NULL);
		// set tab-order of control
		SetWindowPos (phes->hwndIPID, GetDlgItem (hwnd, IDC_IPID),
						0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);

		// initialize passphrase static text
		if (phes->host.sharedSecret[0] != '\0')
			LoadString (g_hinst, IDS_CLEARPASSPHRASE, sz, sizeof(sz));
		else
			LoadString (g_hinst, IDS_PASSPHRASE, sz, sizeof(sz));

		SetDlgItemText (hwnd, IDC_PASSPHRASE, sz);

		// initialize host type combo box
		LoadString (g_hinst, IDS_INSECUREHOST, sz, sizeof(sz));
		SendDlgItemMessage (hwnd, IDC_TYPE, CB_ADDSTRING, 0, (LPARAM)sz);
		LoadString (g_hinst, IDS_INSECURESUBNET, sz, sizeof(sz));
		SendDlgItemMessage (hwnd, IDC_TYPE, CB_ADDSTRING, 0, (LPARAM)sz);

#if !PGPNET_SECURE_HOSTS_BEHIND_GATEWAYS
		if (!phes->bIsChild) 
#endif
		{
			LoadString (g_hinst, IDS_SECUREHOST, sz, sizeof(sz));
			SendDlgItemMessage (hwnd, IDC_TYPE, CB_ADDSTRING, 0, (LPARAM)sz);
			LoadString (g_hinst, IDS_SECURESUBNET, sz, sizeof(sz));
			SendDlgItemMessage (hwnd, IDC_TYPE, CB_ADDSTRING, 0, (LPARAM)sz);
		}

#if !PGP_FREEWARE
		if (!phes->bIsChild) 
		{
			LoadString (g_hinst, IDS_SECUREGATEWAY, sz, sizeof(sz));
			SendDlgItemMessage (hwnd, IDC_TYPE, CB_ADDSTRING, 0, (LPARAM)sz);
		}
#endif //PGP_FREEWARE

		switch (phes->host.hostType) {
		case kPGPnetInsecureHost :	
			if (phes->host.ipMask == 0xFFFFFFFF)
				iIndex = INSECURE_HOST;		
			else
				iIndex = INSECURE_SUBNET;
			break; 

		case kPGPnetSecureHost :	
			if (phes->host.ipMask == 0xFFFFFFFF)
				iIndex = SECURE_HOST;		
			else
				iIndex = SECURE_SUBNET;
			break;

		case kPGPnetSecureGateway :	
			iIndex = SECURE_GATEWAY;	
			break;
		}
		SendDlgItemMessage (hwnd, IDC_TYPE, CB_SETCURSEL, (WPARAM)iIndex, 0);
		PostMessage (hwnd, WM_COMMAND, 
							MAKEWPARAM(IDC_TYPE, CBN_SELCHANGE), 0);

		// initialize identity type combo box
		LoadString (g_hinst, IDS_IPADDRESS, sz, sizeof(sz));
		SendDlgItemMessage (hwnd, IDC_IDENTITYTYPE, 
									CB_ADDSTRING, 0, (LPARAM)sz);
		LoadString (g_hinst, IDS_DOMAINNAME, sz, sizeof(sz));
		SendDlgItemMessage (hwnd, IDC_IDENTITYTYPE, 
									CB_ADDSTRING, 0, (LPARAM)sz);
		LoadString (g_hinst, IDS_USERDOMAINNAME, sz, sizeof(sz));
		SendDlgItemMessage (hwnd, IDC_IDENTITYTYPE, 
									CB_ADDSTRING, 0, (LPARAM)sz);
		LoadString (g_hinst, IDS_DISTINGUISHEDNAME, sz, sizeof(sz));
		SendDlgItemMessage (hwnd, IDC_IDENTITYTYPE, 
									CB_ADDSTRING, 0, (LPARAM)sz);

		switch (phes->host.identityType) {
		case kPGPike_ID_FQDN :	
			phes->iPrevIDIndex = DOMAINNAME;		
			phes->szIdentity[0] = '\0';
			SetDlgItemText (hwnd, IDC_IDENTITY, phes->host.identity);
			break; 

		case kPGPike_ID_UserFDQN :	
			phes->iPrevIDIndex = USERDOMAINNAME;
			lstrcpy (phes->szIdentity, phes->host.identity);
			SetDlgItemText (hwnd, IDC_IDENTITY, phes->host.identity);
			break; 

		case kPGPike_ID_DER_ASN1_DN :	
			phes->iPrevIDIndex = DISTINGUISHEDNAME;		
			lstrcpy (phes->szIdentity, phes->host.identity);
			SetDlgItemText (hwnd, IDC_IDENTITY, phes->host.identity);
			break; 

		case kPGPike_ID_IPV4_Addr :	
		default :
		{
			phes->iPrevIDIndex = IPADDRESS;	
			phes->szIdentity[0] = '\0';
			
			ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_HIDE);
			ShowWindow (phes->hwndIPID, SW_SHOW);

			phes->dwAddress = phes->host.identityIPAddress;
			SendMessage (phes->hwndIPID, PGP_IPM_SETADDRESS, 0, 
						(LPARAM)phes->dwAddress);
			break; 
		}

		}
		SendDlgItemMessage (hwnd, IDC_IDENTITYTYPE, 
							CB_SETCURSEL, (WPARAM)phes->iPrevIDIndex, 0);

		// initialize authentication info
		sSetAuthKeyRadioButtons (hwnd, phes);
		sSetKeyControl (hwnd, phes);

		// allow keyring reload messages to percolate
		g_AOS.hwndHostDlg = hwnd;

		return TRUE;
	}

	case WM_DESTROY :
		g_AOS.hwndHostDlg = NULL;
		break;

	case PGPNET_M_RELOADKEYRINGS :
		phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		sSetKeyControl (hwnd, phes);