pnedit.c

vc环境下的pgp源码

		break;

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

	case WM_COMMAND :
		switch (LOWORD (wParam)) {
		case IDOK :
		{
			DWORD	dwIP, dwMask;
			INT		iIdIndex;
			BOOL	bBadMask = FALSE;

			phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

			GetDlgItemText (hwnd, IDC_DOMAINNAME,
					phes->host.hostName, sizeof(phes->host.hostName));

			// get IP address
			SendMessage (phes->hwndIPAddr, 
								PGP_IPM_GETADDRESS, 0, (LPARAM)&dwIP);
			if ((dwIP == 0x00000000) ||
				(dwIP == 0xFFFFFFFF))
			{
				PNMessageBox (hwnd, IDS_CAPTION, IDS_BADIPADDRESS,
									MB_OK | MB_ICONHAND);
				break;
			}
			else
				phes->host.ipAddress = dwIP;

			// get IP subnet
			SendMessage (phes->hwndIPSubnet, 
								PGP_IPM_GETADDRESS, 0, (LPARAM)&dwMask);
			phes->host.ipMask = dwMask;

			GetDlgItemText (hwnd, IDC_IDENTITY,
					phes->host.identity, sizeof(phes->host.identity));

			iIndex = SendDlgItemMessage (hwnd, IDC_TYPE, CB_GETCURSEL, 0, 0);
			switch (iIndex) {
			case SECURE_HOST :		
				phes->host.hostType = kPGPnetSecureHost;	
				phes->host.ipMask = 0xFFFFFFFF;
				iIdIndex = SendDlgItemMessage (hwnd, 
									IDC_IDENTITYTYPE, CB_GETCURSEL, 0, 0);
				if (iIdIndex == NOIDENTITY)
					iIdIndex = BADIDENTITY;
				break;
	
			case INSECURE_HOST :		
				phes->host.hostType = kPGPnetInsecureHost;		
				phes->host.ipMask = 0xFFFFFFFF;
				phes->host.identityType = kPGPike_ID_None;
				phes->host.identity[0] = '\0';
				phes->host.identityIPAddress = 0;
				phes->host.sharedSecret[0] = '\0';
				sRefsToExport (hwnd, kInvalidPGPKeyRef, kInvalidPGPSigRef, 
							&phes->host);
				sSetAuthKeyRadioButtons (hwnd, phes);
				sSetKeyControl (hwnd, phes);
				iIdIndex = NOIDENTITY;
				break;

			case SECURE_SUBNET :		
				phes->host.hostType = kPGPnetSecureHost;		
				iIdIndex = SendDlgItemMessage (hwnd, 
									IDC_IDENTITYTYPE, CB_GETCURSEL, 0, 0);
				if (!PNIsSubnetMaskValid (dwMask))
					bBadMask = TRUE;
				if (iIdIndex == NOIDENTITY)
					iIdIndex = BADIDENTITY;
				break;

			case INSECURE_SUBNET :		
				phes->host.hostType = kPGPnetInsecureHost;		
				phes->host.identityType = kPGPike_ID_None;
				phes->host.identity[0] = '\0';
				phes->host.identityIPAddress = 0;
				phes->host.sharedSecret[0] = '\0';
				sRefsToExport (hwnd, kInvalidPGPKeyRef, kInvalidPGPSigRef, 
							&phes->host);
				sSetAuthKeyRadioButtons (hwnd, phes);
				sSetKeyControl (hwnd, phes);
				if (!PNIsSubnetMaskValid (dwMask))
					bBadMask = TRUE;
				iIdIndex = NOIDENTITY;
				break;

			case SECURE_GATEWAY :	
				phes->host.hostType = kPGPnetSecureGateway;		
				phes->host.ipMask = 0xFFFFFFFF;
				iIdIndex = SendDlgItemMessage (hwnd, 
									IDC_IDENTITYTYPE, CB_GETCURSEL, 0, 0);
				if (iIdIndex == NOIDENTITY)
					iIdIndex = BADIDENTITY;
				break;
			}

			if (bBadMask)
			{
				PNMessageBox (hwnd, IDS_CAPTION, IDS_BADSUBNETMASK,
									MB_OK | MB_ICONHAND);
				break;
			}

			if (PNIsHostAlreadyInList (hwnd, 
					phes->host.hostType, 
					phes->host.ipAddress, 
					phes->host.ipMask, 
					phes->ppnconfig->pHostList, 
					phes->ppnconfig->uHostCount,
					phes->iIndex))
				break;

			switch (iIdIndex) {
			case IPADDRESS :
				phes->host.identityType = kPGPike_ID_IPV4_Addr;
				SendMessage (phes->hwndIPID, 
						PGP_IPM_GETADDRESS, 0, (LPARAM)&phes->dwAddress);
				phes->host.identityIPAddress = phes->dwAddress;
				break;

			case DOMAINNAME :
				phes->host.identityType = kPGPike_ID_FQDN;
				GetDlgItemText (hwnd, IDC_IDENTITY, 
							phes->host.identity, kMaxNetHostIdentityLength);
				break;

			case USERDOMAINNAME :
				phes->host.identityType = kPGPike_ID_UserFDQN;
				GetDlgItemText (hwnd, IDC_IDENTITY, 
							phes->host.identity, kMaxNetHostIdentityLength);
				break;

			case DISTINGUISHEDNAME :
			{
				PGPByte*	pbyte	= NULL;
				PGPSize		size;
				PGPError	err;

				phes->host.identityType = kPGPike_ID_DER_ASN1_DN;
				GetDlgItemText (hwnd, IDC_IDENTITY, 
							phes->host.identity, kMaxNetHostIdentityLength);

				if (phes->host.sharedSecret[0])
				{
					err = PGPCreateDistinguishedName (
									g_context, phes->host.identity, 
									&pbyte, &size);
					if (err == kPGPError_InvalidDistinguishedName)
						PNMessageBox (hwnd, IDS_CAPTION, IDS_DNINVALID,
											MB_OK|MB_ICONSTOP);
					else
						PGPclErrorBox (hwnd, err);

					if (IsPGPError (err))
					{
						SetFocus (GetDlgItem (hwnd, IDC_IDENTITY));
						SendDlgItemMessage (
								hwnd, IDC_IDENTITY, EM_SETSEL, 0, -1);
						iIdIndex = BADIDENTITY;
					}
				}

				if (pbyte)
					PGPFreeData (pbyte);
				break;
			}

			case NOIDENTITY :
				phes->host.identityType = kPGPike_ID_None;
				pgpClearMemory (phes->host.identity, 
										kMaxNetHostIdentityLength);
				break;

			default :
				PNMessageBox (hwnd, IDS_CAPTION, IDS_BADIDENTITY,
									MB_OK | MB_ICONHAND);
				break;
			}

			if (iIdIndex != BADIDENTITY)
				EndDialog (hwnd, 1);
			break;
		}

		case IDCANCEL :
			EndDialog (hwnd, 0);
			break;

		case IDC_IDENTITYTYPE :
		{
			CHAR	sz[256];

			phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

			if (HIWORD(wParam) != CBN_SELCHANGE)
				break;

			switch (phes->iPrevIDIndex) {
			case USERDOMAINNAME :
			case DISTINGUISHEDNAME :
				GetDlgItemText (hwnd, IDC_IDENTITY, phes->szIdentity,
									sizeof (phes->szIdentity));
				break;
			}

			phes->iPrevIDIndex = SendDlgItemMessage (hwnd, 
								IDC_IDENTITYTYPE, CB_GETCURSEL, 0, 0);

			switch (phes->iPrevIDIndex) {
			case IPADDRESS :
				PNGetLocalHostInfo (&phes->dwAddress, sz, sizeof(sz));
				SendMessage (phes->hwndIPID, PGP_IPM_SETADDRESS, 0, 
							(LPARAM)phes->dwAddress);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_HIDE);
				ShowWindow (phes->hwndIPID, SW_SHOW);
				break;

			case DOMAINNAME :
				PNGetLocalHostInfo (NULL, sz, sizeof(sz));
				SetDlgItemText (hwnd, IDC_IDENTITY, sz);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_SHOW);
				ShowWindow (phes->hwndIPID, SW_HIDE);
				break;

			case USERDOMAINNAME :
				SetDlgItemText (hwnd, IDC_IDENTITY, phes->szIdentity);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_SHOW);
				ShowWindow (phes->hwndIPID, SW_HIDE);
				break;

			case DISTINGUISHEDNAME :
				SetDlgItemText (hwnd, IDC_IDENTITY, phes->szIdentity);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_SHOW);
				ShowWindow (phes->hwndIPID, SW_HIDE);
				break;
			}
			break;
		}

		case IDC_TYPE :
		{
			BOOL	bSecure	= FALSE;

			phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

			if (HIWORD(wParam) != CBN_SELCHANGE)
				break;

			iIndex = SendDlgItemMessage (hwnd, IDC_TYPE, CB_GETCURSEL, 0, 0);

			if (phes->host.hostType == kPGPnetSecureGateway)
			{
				if ((iIndex != SECURE_GATEWAY) &&
					(phes->bHasChildren))
				{
					if (PNMessageBox (hwnd, IDS_CAPTION, 
							IDS_DELETEGATEWAYCONFIRMATION, 
							MB_OKCANCEL|MB_ICONEXCLAMATION) == IDCANCEL)
					{
						SendDlgItemMessage (hwnd, IDC_TYPE, CB_SETCURSEL, 
											SECURE_GATEWAY, 0);
						iIndex = SECURE_GATEWAY;
					}
				}
			}

			switch (iIndex) 
			{
			case SECURE_HOST :
				ShowWindow (GetDlgItem (hwnd, IDC_SUBNETTEXT), SW_HIDE);
				ShowWindow (phes->hwndIPSubnet, SW_HIDE);
				bSecure = TRUE;
				break;

			case INSECURE_HOST :
				ShowWindow (GetDlgItem (hwnd, IDC_SUBNETTEXT), SW_HIDE);
				ShowWindow (phes->hwndIPSubnet, SW_HIDE);
				break;

			case SECURE_SUBNET :
				ShowWindow (GetDlgItem (hwnd, IDC_SUBNETTEXT), SW_SHOW);
				ShowWindow (phes->hwndIPSubnet, SW_SHOW);
				bSecure = TRUE;
				break;

			case INSECURE_SUBNET :
				ShowWindow (GetDlgItem (hwnd, IDC_SUBNETTEXT), SW_SHOW);
				ShowWindow (phes->hwndIPSubnet, SW_SHOW);
				break;

			case SECURE_GATEWAY :
				ShowWindow (GetDlgItem (hwnd, IDC_SUBNETTEXT), SW_HIDE);
				ShowWindow (phes->hwndIPSubnet, SW_HIDE);
				bSecure = TRUE;
				break;
			}

			if (phes->host.sharedSecret[0] == '\0')
			{
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPETEXT), FALSE);
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPE), FALSE);
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITYTEXT), FALSE);
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITY), FALSE);
				EnableWindow (phes->hwndIPID, FALSE);
			}
			else
			{	
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPETEXT), TRUE);
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPE), TRUE);
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITYTEXT), TRUE);
				EnableWindow (GetDlgItem (hwnd, IDC_IDENTITY), TRUE);
				EnableWindow (phes->hwndIPID, TRUE);
			}

			if (bSecure)
			{
				ShowWindow (GetDlgItem (hwnd, IDC_SECRETGROUP), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPETEXT), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPE), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITYTEXT), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_PASSPHRASE), SW_SHOW);
				EnableWindow (GetDlgItem (hwnd, IDC_PASSPHRASE), TRUE);

				ShowWindow (GetDlgItem (hwnd, IDC_AUTHFRAME), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_AUTHICON), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_AUTHBORDER), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_AUTHEDIT), SW_SHOW);
				ShowWindow (GetDlgItem (hwnd, IDC_ANYVALIDKEY), SW_SHOW);
				EnableWindow (GetDlgItem (hwnd, IDC_ANYVALIDKEY), TRUE);
				ShowWindow (GetDlgItem (hwnd, IDC_PGPAUTHKEY), SW_SHOW);
				EnableWindow (GetDlgItem (hwnd, IDC_PGPAUTHKEY), TRUE);
#if !PGP_FREEWARE
				ShowWindow (GetDlgItem (hwnd, IDC_X509CERT), SW_SHOW);
				EnableWindow (GetDlgItem (hwnd, IDC_X509CERT), TRUE);
#endif //PGP_FREEWARE

				switch (phes->iPrevIDIndex) {
				case IPADDRESS :	
					ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_HIDE);
					ShowWindow (phes->hwndIPID, SW_SHOW);
					break;
				default :
					ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_SHOW);
					ShowWindow (phes->hwndIPID, SW_HIDE);
					break;
				}
			}
			else
			{
				ShowWindow (GetDlgItem (hwnd, IDC_SECRETGROUP), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPETEXT), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITYTYPE), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITYTEXT), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_PASSPHRASE), SW_HIDE);
				EnableWindow (GetDlgItem (hwnd, IDC_PASSPHRASE), FALSE);

				ShowWindow (GetDlgItem (hwnd, IDC_AUTHFRAME), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_AUTHICON), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_AUTHBORDER), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_AUTHEDIT), SW_HIDE);
				ShowWindow (GetDlgItem (hwnd, IDC_ANYVALIDKEY), SW_HIDE);
				EnableWindow (GetDlgItem (hwnd, IDC_ANYVALIDKEY), FALSE);
				ShowWindow (GetDlgItem (hwnd, IDC_PGPAUTHKEY), SW_HIDE);
				EnableWindow (GetDlgItem (hwnd, IDC_PGPAUTHKEY), FALSE);

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

				ShowWindow (GetDlgItem (hwnd, IDC_IDENTITY), SW_HIDE);
				ShowWindow (phes->hwndIPID, SW_HIDE);
			}

			break;
		}

		case IDC_PASSPHRASE :
			{
				CHAR sz[64];
				phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

				if (phes->host.sharedSecret[0] == '\0')
					PNGetSharedSecret (hwnd, 
								phes->host.sharedSecret,
								kMaxNetHostSharedSecretLength);
				else
					pgpClearMemory (phes->host.sharedSecret, 
										kMaxNetHostSharedSecretLength);

				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);

				PostMessage (hwnd, WM_COMMAND, 
									MAKEWPARAM(IDC_TYPE, CBN_SELCHANGE), 0);
			}
			break;

		case IDC_DNSLOOKUP :
		{
			DNSLOOKUPSTRUCT		dls;

			GetDlgItemText (hwnd, IDC_DOMAINNAME, 
								dls.szHostName, sizeof(dls.szHostName));

			if (DialogBoxParam (g_hinst, MAKEINTRESOURCE(IDD_DNSLOOKUP),
							hwnd, sDNSLookupDlgProc, (LPARAM)&dls))
			{
				phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
				SendMessage (phes->hwndIPAddr, PGP_IPM_SETADDRESS, 
								0, (LPARAM)dls.dwAddress);
			}
			break;
		}

		case IDC_ANYVALIDKEY :
			phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
			sRefsToExport (hwnd, kInvalidPGPKeyRef, kInvalidPGPSigRef, 
							&phes->host);
			sSetKeyControl (hwnd, phes);
			sSetAuthKeyRadioButtons (hwnd, phes);
			break;

		case IDC_PGPAUTHKEY :
			if (!g_bAskingUserForKey)
			{
				PGPKeySetRef	keyset;
				PGPKeyRef		key;
				PGPError		err;

				phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

				g_bAskingUserForKey = TRUE;
				err = PGPclSelectKeysEx (g_context, NULL, hwnd, NULL,
							g_AOS.keysetMain, g_AOS.keysetMain, 
							PGPCL_SINGLESELECTION, &keyset);

				if (IsntPGPError (err))
				{
					sGetFirstKeyInSet (keyset, &key);

					if (sRefsToExport (hwnd, key, kInvalidPGPSigRef, &phes->host))
					{
						PGPFreeKeySet (keyset);
						sSetKeyControl (hwnd, phes);
					}
				}
				sSetAuthKeyRadioButtons (hwnd, phes);

				g_bAskingUserForKey = FALSE;
			}
			break;

		case IDC_X509CERT :
			if (!g_bAskingUserForKey)
			{
				PGPError	err;
				PGPKeyRef	key;
				PGPSigRef	sig;

				phes = (PHOSTEDITSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);

				g_bAskingUserForKey = TRUE;
				err = PGPclSelectX509Cert (g_context, hwnd, NULL,
							g_AOS.keysetMain, 
							PGPCL_NOSPLITKEYS,
							&key, &sig);

				if (IsntPGPError (err) &&
					sRefsToExport (hwnd, key, sig, &phes->host))
				{
					sSetKeyControl (hwnd, phes);
				}
				sSetAuthKeyRadioButtons (hwnd, phes);

				g_bAskingUserForKey = FALSE;
			}

			break;
		}
		return 0;
	}

	return FALSE;
}


//	____________________________________
//
//	post the edit host dialog

BOOL
PNEditHostEntry (
		HWND		hwndParent,
		PPNCONFIG	ppnconfig,
		INT			iIndex,
		BOOL		bHasChildren)
{
	HOSTEDITSTRUCT		hes;
	
	if (ppnconfig->pHostList[iIndex].childOf == -1)
		hes.bIsChild = FALSE;
	else
		hes.bIsChild = TRUE;

	hes.ppnconfig		= ppnconfig;
	hes.iIndex			= iIndex;
	hes.bHasChildren	= bHasChildren;

	memcpy (&hes.host, &(ppnconfig->pHostList[iIndex]), sizeof(hes.host));

	if (DialogBoxParam (g_hinst, MAKEINTRESOURCE(IDD_HOSTGATEWAY),
			hwndParent, sEditHostDlgProc, (LPARAM)&hes))
	{
		// copy new host entry over old
		memcpy (&(ppnconfig->pHostList[iIndex]), &hes.host, sizeof(hes.host));
		return TRUE;
	}
	else
		return FALSE;
}