pnedit.c

vc环境下的pgp源码

/*____________________________________________________________________________
	Copyright (C) 1998 Network Associates, Inc.
	All rights reserved.
	
	PNedit.c - PGPnet edit host/gateway entry dialog
	

	$Id: PNedit.c,v 1.43.4.2.2.1 1999/06/29 18:46:09 pbj Exp $
____________________________________________________________________________*/

#include <windows.h>

#include "resource.h"
#include "PGPnetApp.h"
#include "IPAddressControl.h"
#include "PGPnetHelp.h"
#include "pgpClientLib.h"
#include "pgpBuildFlags.h"

#include "PGPcl.h"
#include "pgpIke.h"

#define	INSECURE_HOST		0
#define INSECURE_SUBNET		1
#define SECURE_HOST			2
#define	SECURE_SUBNET		3
#define SECURE_GATEWAY		4

#define BADIDENTITY			-2
#define NOIDENTITY			-1
#define IPADDRESS			0
#define	DOMAINNAME			1
#define	USERDOMAINNAME		2
#define DISTINGUISHEDNAME	3

#define	LOOKUP_TIMER_ID		111L
#define	LOOKUP_TIMER_MS		100L
#define	NUMLEDS				10
#define	LEDSPACING			2

extern HINSTANCE		g_hinst;
extern PGPContextRef	g_context;
extern CHAR				g_szHelpFile[];
extern APPOPTIONSSTRUCT	g_AOS;

static BOOL				g_bAskingUserForKey		= FALSE;

typedef struct {
	HWND				hwndIPAddr;
	HWND				hwndIPSubnet;
	HWND				hwndIPID;
	PPNCONFIG			ppnconfig;
	INT					iIndex;
	BOOL				bIsChild;
	BOOL				bHasChildren;
	PGPNetHostEntry		host;
	DWORD				dwAddress;
	INT					iPrevIDIndex;
	CHAR				szIdentity [kMaxNetHostIdentityLength +1];
	HIMAGELIST			hil;
} HOSTEDITSTRUCT, *PHOSTEDITSTRUCT;

typedef struct {
	CHAR		szHostName[256];
	DWORD		dwAddress;
	HWND		hwndAddress;
	HWND		hwndThreadParent;
	INT			iStatusValue;
	INT			iStatusDirection;
	HPALETTE	hPalette;
} DNSLOOKUPSTRUCT, *PDNSLOOKUPSTRUCT;

static DWORD aEditIds[] = {			// Help IDs
    IDC_DOMAINNAME,		IDH_PNEDITHOST_NAME, 
	IDC_IPADDRESS,		IDH_PNEDITHOST_IPADDRESS,
	IDC_DNSLOOKUP,		IDH_PNEDITHOST_DNSLOOKUP,
	IDC_TYPE,			IDH_PNEDITHOST_HOSTTYPE,
	IDC_IPMASK,			IDH_PNEDITHOST_SUBNETMASK,
	IDC_PASSPHRASE,		IDH_PNEDITHOST_SETCLEARPASSPHRASE,
	IDC_IDENTITYTYPE,	IDH_PNEDITHOST_IDENTITYTYPE,
	IDC_IDENTITY,		IDH_PNEDITHOST_IDENTITY,
	IDC_IPID,			IDH_PNEDITHOST_IDENTITY,
	IDC_ANYVALIDKEY,	IDH_PNEDITHOST_ANYVALIDKEY,
	IDC_PGPAUTHKEY,		IDH_PNEDITHOST_PGPAUTHKEY,
	IDC_X509CERT,		IDH_PNEDITHOST_X509AUTHCERT,
	IDC_AUTHEDIT,		IDH_PNEDITHOST_AUTHKEY,
	0,0
};

static DWORD aDNSIds[] = {			// Help IDs
    IDC_HOSTNAME,		IDH_PNDNSLOOKUP_HOST, 
	IDC_LOOKUP,			IDH_PNDNSLOOKUP_LOOKUP,
	IDC_IPADDRESS,		IDH_PNDNSLOOKUP_ADDRESS,
	IDOK,				IDH_PNDNSLOOKUP_USEADDRESS,
	0,0
};


//	____________________________________
//
//  Determine if the specified host is already in the host list

BOOL
PNIsSubnetMaskValid (
		PGPUInt32	uSubnetMask)
{
	PGPUInt32	uBitMask	= 0x80000000;
	PGPUInt32	uMask		= 0x00;
	INT			i;

	if (uSubnetMask == 0xFFFFFFFF)
		return FALSE;

	if (uSubnetMask == 0x00000000)
		return FALSE;

	for (i=0; i<4; i++)
	{
		uMask <<= 8;
		uMask |= (uSubnetMask >> (i*8)) & 0xFF;
	}

	while (uBitMask && (uBitMask & uMask))
		uBitMask >>= 1;

	while (uBitMask && !(uBitMask & uMask))
		uBitMask >>= 1;

	if (uBitMask)
		return FALSE;

	return TRUE;
}


//	____________________________________
//
//  Determine if the specified hosts/subnets overlap

BOOL
sOverlap (
		PGPUInt32			uIP,
		PGPUInt32			uSubnetMask,
		PGPNetHostEntry*	pHost)
{
	PGPUInt32	uMask;

	uMask = uSubnetMask;
	if ((uIP & uMask) == (pHost->ipAddress & uMask))
	{
		 return TRUE;
	}

	uMask = pHost->ipMask;
	if ((uIP & uMask) == (pHost->ipAddress & uMask))
	{
		 return TRUE;
	}
	
	return FALSE;
}


//	____________________________________
//
//  Determine if the specified host is already in the host list

BOOL
PNIsHostAlreadyInList (
		HWND				hwnd,
		PGPNetHostType		hosttype,
		PGPUInt32			uIP,
		PGPUInt32			uSubnetMask,
		PGPNetHostEntry*	pHostList,
		PGPUInt32			uHostCount,
		PGPInt32			iIndex)
{
	BOOL		bInList		= FALSE;
	UINT		u;

	UINT		uNewType;
	UINT		uExistingType;

	switch (hosttype) {
		case kPGPnetInsecureHost :
			if (uSubnetMask == 0xFFFFFFFF)
				uNewType = INSECURE_HOST;
			else
				uNewType = INSECURE_SUBNET;
			break;

		case kPGPnetSecureHost :
			if (uSubnetMask == 0xFFFFFFFF)
				uNewType = SECURE_HOST;
			else
				uNewType = SECURE_SUBNET;
			break;

		default :
			uNewType = SECURE_GATEWAY;
			break;
	}

	for (u=0; u<uHostCount; u++)
	{
		if ((INT)u == iIndex)
			continue;

		switch (pHostList[u].hostType) {
			case kPGPnetInsecureHost :
				if (pHostList[u].ipMask == 0xFFFFFFFF)
					uExistingType = INSECURE_HOST;
				else
					uExistingType = INSECURE_SUBNET;
				break;

			case kPGPnetSecureHost :
				if (pHostList[u].ipMask == 0xFFFFFFFF)
					uExistingType = SECURE_HOST;
				else
					uExistingType = SECURE_SUBNET;
				break;

			default :
				uExistingType = SECURE_GATEWAY;
				break;
		}

		switch (uNewType) {
		case INSECURE_HOST :
			switch (uExistingType) {
				case INSECURE_HOST :
				case SECURE_HOST :
				case SECURE_GATEWAY :
					bInList = sOverlap (uIP, uSubnetMask, &pHostList[u]);
					break;
				case INSECURE_SUBNET :
				case SECURE_SUBNET :
					break;
			}
			break;

		case INSECURE_SUBNET :
			switch (uExistingType) {
				case INSECURE_SUBNET :
				case SECURE_SUBNET :
					bInList = sOverlap (uIP, uSubnetMask, &pHostList[u]);
					break;
				case INSECURE_HOST :
				case SECURE_HOST :
				case SECURE_GATEWAY :
					break;
			}
			break;

		case SECURE_HOST :
			switch (uExistingType) {
				case INSECURE_HOST :
				case SECURE_HOST :
				case SECURE_GATEWAY :
					bInList = sOverlap (uIP, uSubnetMask, &pHostList[u]);
					break;
				case INSECURE_SUBNET :
				case SECURE_SUBNET :
					break;
			}
			break;

		case SECURE_SUBNET :
			switch (uExistingType) {
				case INSECURE_SUBNET :
				case SECURE_SUBNET :
					bInList = sOverlap (uIP, uSubnetMask, &pHostList[u]);
					break;
				case INSECURE_HOST :
				case SECURE_HOST :
				case SECURE_GATEWAY :
					break;
			}
			break;

		case SECURE_GATEWAY :
			switch (uExistingType) {
				case INSECURE_HOST :
				case SECURE_HOST :
				case SECURE_GATEWAY :
					bInList = sOverlap (uIP, 0xFFFFFFFF, &pHostList[u]);
					break;
				case INSECURE_SUBNET :
				case SECURE_SUBNET :
					break;
			}
		}

		if (bInList)
		{
			break;
		}
	}

	if (bInList)
	{
		CHAR	szCaption[64];
		CHAR	szFormat[128];
		CHAR	szText[128+kMaxNetHostNameLength];

		if (uSubnetMask == 0xFFFFFFFF)
			LoadString (g_hinst, 
					IDS_ADDRESSUSED, szFormat, sizeof(szFormat));
		else
			LoadString (g_hinst, 
					IDS_ADDRESSSUBNETUSED, szFormat, sizeof(szFormat));

		wsprintf (szText, szFormat, pHostList[u].hostName);
		LoadString (g_hinst, IDS_CAPTION, szCaption, sizeof(szCaption));
		MessageBox (hwnd, szText, szCaption, MB_OK|MB_ICONHAND);
	}

	return bInList;
}


//	____________________________________
//
//  Draw the "LED" progress indicator

static VOID
sDrawSendStatus (
		HWND				hwnd,
		PDNSLOOKUPSTRUCT	pdls) 
{
	HBRUSH			hBrushLit, hBrushUnlit, hBrushOld;
	HPEN			hPen, hPenOld;
	INT				i;
	INT				itop, ibot, ileft, iright, iwidth;
	RECT			rc;
	HDC				hdc;
	PAINTSTRUCT		ps;

	if (pdls->iStatusValue < -1) return;

	hdc = BeginPaint (hwnd, &ps);

	// draw 3D shadow
	GetClientRect (hwnd, &rc);
	itop = rc.top+1;
	ibot = rc.bottom-2;

	iwidth = (rc.right-rc.left) / NUMLEDS;
	iwidth -= LEDSPACING;

	ileft = rc.left + 4;
	for (i=0; i<NUMLEDS; i++) {
		iright = ileft + iwidth;

		MoveToEx (hdc, ileft, ibot, NULL);
		LineTo (hdc, iright, ibot);
		LineTo (hdc, iright, itop);

		ileft += iwidth + LEDSPACING;
	}

	hPen = CreatePen (PS_SOLID, 0, RGB (128, 128, 128));
	hPenOld = SelectObject (hdc, hPen);
	hBrushLit = CreateSolidBrush (RGB (0, 255, 0));
	hBrushUnlit = CreateSolidBrush (RGB (0, 128, 0));

	ileft = rc.left + 4;

	// draw "Knight Rider" LEDs
	if (pdls->iStatusDirection) {
		hBrushOld = SelectObject (hdc, hBrushUnlit);
		for (i=0; i<NUMLEDS; i++) {
			iright = ileft + iwidth;
	
			if (i == pdls->iStatusValue) {
				SelectObject (hdc, hBrushLit);
				Rectangle (hdc, ileft, itop, iright, ibot);
				SelectObject (hdc, hBrushUnlit);
			}
			else  {
				Rectangle (hdc, ileft, itop, iright, ibot);
			}
	
			ileft += iwidth + LEDSPACING;
		}
	}

	// draw "progress bar" LEDs
	else { 
		if (pdls->iStatusValue >= 0) 
			hBrushOld = SelectObject (hdc, hBrushLit);
		else
			hBrushOld = SelectObject (hdc, hBrushUnlit);

		for (i=0; i<NUMLEDS; i++) {
			iright = ileft + iwidth;
	
			if (i > pdls->iStatusValue) {
				SelectObject (hdc, hBrushUnlit);
			}
			Rectangle (hdc, ileft, itop, iright, ibot);
	
			ileft += iwidth + LEDSPACING;
		}
	}

	SelectObject (hdc, hBrushOld);
	SelectObject (hdc, hPenOld);
	DeleteObject (hPen);
	DeleteObject (hBrushLit);
	DeleteObject (hBrushUnlit);

	EndPaint (hwnd, &ps);
}


//	______________________________________________
//
//	thread procedure for looking up IP address

static DWORD WINAPI 
sDNSLookupThread (LPVOID pvoid)
{
	PDNSLOOKUPSTRUCT	pdls	= (PDNSLOOKUPSTRUCT)pvoid;

	if (PNGetRemoteHostIP (pdls->szHostName, &pdls->dwAddress))
	{
		if (pdls->hwndThreadParent)
			SendMessage (pdls->hwndThreadParent, WM_APP, TRUE, 0);
	}
	else
	{
		if (pdls->hwndThreadParent)
			SendMessage (pdls->hwndThreadParent, WM_APP, FALSE, 0);
	}

	return 0;
}


//	____________________________________
//
//	dialog proc of DNS lookup dialog

static BOOL CALLBACK
sDNSLookupDlgProc (
		HWND	hwnd, 
		UINT	uMsg, 
		WPARAM	wParam, 
		LPARAM	lParam)
{
	PDNSLOOKUPSTRUCT	pdls;

	switch (uMsg)
	{
	case WM_INITDIALOG :
	{
		RECT			rc;

		SetWindowLong (hwnd, GWL_USERDATA, lParam);
		pdls = (PDNSLOOKUPSTRUCT)lParam;

		// misc initialization
		pdls->hwndThreadParent = NULL;

		// initialize host name
		SetDlgItemText (hwnd, IDC_HOSTNAME, pdls->szHostName);

		// create IP edit control for address
		GetWindowRect (GetDlgItem (hwnd, IDC_IPADDRESS), &rc);
		MapWindowPoints (NULL, hwnd, (LPPOINT)&rc, 2);
		pdls->hwndAddress = CreateWindowEx (
				WS_EX_STATICEDGE,
				WC_PGPIPADDRESS, "", 
				WS_CHILD|WS_TABSTOP|ES_READONLY,
				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 (pdls->hwndAddress, 
						GetDlgItem (hwnd, IDC_IPADDRESS),
						0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
		// disable window
		EnableWindow (pdls->hwndAddress, FALSE);

		return FALSE;
	}

	case WM_APP :
		pdls = (PDNSLOOKUPSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		pdls->hwndThreadParent = NULL;
		ShowWindow (GetDlgItem (hwnd, IDC_PROGRESS), SW_HIDE);
		EnableWindow (GetDlgItem (hwnd, IDC_LOOKUP), TRUE);

		KillTimer (hwnd, LOOKUP_TIMER_ID);
		if (wParam)
		{
			ShowWindow (GetDlgItem (hwnd, IDC_PROGRESS), SW_HIDE);
			ShowWindow (GetDlgItem (hwnd, IDC_HOSTFOUND), SW_SHOW);
			ShowWindow (pdls->hwndAddress, SW_SHOW);
			SendMessage (pdls->hwndAddress, 
						PGP_IPM_SETADDRESS, 0, (LPARAM)pdls->dwAddress);
			EnableWindow (GetDlgItem (hwnd, IDOK), TRUE);
		}
		else
		{
			ShowWindow (GetDlgItem (hwnd, IDC_PROGRESS), SW_HIDE);
			ShowWindow (GetDlgItem (hwnd, IDC_HOSTNOTFOUND), SW_SHOW);
			EnableWindow (GetDlgItem (hwnd, IDOK), FALSE);
		}
		break;

	case WM_TIMER :
		pdls = (PDNSLOOKUPSTRUCT)GetWindowLong (hwnd, GWL_USERDATA);
		if (pdls->hwndThreadParent)
		{
			ShowWindow (GetDlgItem (hwnd, IDC_PROGRESS), SW_SHOW);
			pdls->iStatusValue += pdls->iStatusDirection;
			if (pdls->iStatusValue <= 0) {
				pdls->iStatusValue = 0;
				pdls->iStatusDirection = 1;
			}
			else if (pdls->iStatusValue >= NUMLEDS-1) {
				pdls->iStatusValue = NUMLEDS-1;
				pdls->iStatusDirection = -1;
			}
			InvalidateRect (hwnd, NULL, FALSE);
		}
		else 
		{
			DWORD	dw;

			pdls->iStatusValue = -1;
			pdls->iStatusDirection = 1;