windows-xp/Source/XPSP1/NT/net/mmc/rtrfiltr/ipadd.cpp

//============================================================================
// Copyright(c) 1996, Microsoft Corporation
//
// File:    ipadd.cpp
//
// History:
//  08/30/96	Ram Cherala		Created
//
// Implementation of IP Filter Add/Edit dialog code
//============================================================================

#include "stdafx.h"
#include "rtrfiltr.h"
#include "ipfltr.h"
#include "ipadd.h"
extern "C" {
#include <winsock.h>
#include <fltdefs.h>
#include <iprtinfo.h>
}
#include "ipaddr.h"

#include "rtradmin.hm"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

static	enum {
	PROTOCOL_TCP = 0,
	PROTOCOL_TCP_ESTABLISHED,
	PROTOCOL_UDP,
	PROTOCOL_ICMP,
	PROTOCOL_ANY,
	PROTOCOL_OTHER,
};

static UINT g_aPROTOCOLS[][2] = {
	{IDS_PROTOCOL_TCP,	PROTOCOL_TCP},
	{IDS_PROTOCOL_TCP_ESTABLISHED, PROTOCOL_TCP_ESTABLISHED},
	{IDS_PROTOCOL_UDP,  PROTOCOL_UDP},
	{IDS_PROTOCOL_ICMP, PROTOCOL_ICMP},
	{IDS_PROTOCOL_ANY,  PROTOCOL_ANY},
	{IDS_PROTOCOL_OTHER, PROTOCOL_OTHER},
};

#define IDS_ICMP_ECHO 1
#define IDS_ICMP_REDIRECT 2

#if 0
// TODO sample ICMP types - need to update with actual list
static UINT g_aICMPTYPE[][2] = {
    {1, IDS_ICMP_ECHO},
    {2, IDS_ICMP_REDIRECT}
}; 
#endif

HRESULT MultiEnableWindow(HWND hWndParent, BOOL fEnable, UINT first, ...)
{
	UINT	nCtrlId = first;
	HWND	hWndCtrl;
	
	va_list	marker;

	va_start(marker, first);

	while (nCtrlId != 0)
	{
		hWndCtrl = ::GetDlgItem(hWndParent, nCtrlId);
		Assert(hWndCtrl);
		if (hWndCtrl)
			::EnableWindow(hWndCtrl, fEnable);

		// get the next item
		nCtrlId = va_arg(marker, UINT);
	}

	
	va_end(marker);

	return hrOK;
}



/////////////////////////////////////////////////////////////////////////////
// CIpFltrAddEdit dialog


CIpFltrAddEdit::CIpFltrAddEdit(CWnd* pParent,
							   FilterListEntry ** ppFilterEntry,
							   DWORD dwFilterType)
	: CBaseDialog(CIpFltrAddEdit::IDD, pParent),
	  m_ppFilterEntry( ppFilterEntry ),
	  m_dwFilterType ( dwFilterType )
{
	//{{AFX_DATA_INIT(CIpFltrAddEdit)
	m_sProtocol = _T("");
	m_sSrcPort = _T("");
	m_sDstPort = _T("");
	//}}AFX_DATA_INIT

//	SetHelpMap(m_dwHelpMap);
}


void CIpFltrAddEdit::DoDataExchange(CDataExchange* pDX)
{
	CBaseDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CIpFltrAddEdit)
	DDX_Control(pDX, IDC_AEIP_ST_DEST_PORT, m_stDstPort);
	DDX_Control(pDX, IDC_AEIP_ST_SRC_PORT, m_stSrcPort);
	DDX_Control(pDX, IDC_AEIP_CB_SRC_PORT, m_cbSrcPort);
	DDX_Control(pDX, IDC_AEIP_CB_DEST_PORT, m_cbDstPort);
	DDX_Control(pDX, IDC_AEIP_CB_PROTOCOL, m_cbProtocol);
	DDX_CBString(pDX, IDC_AEIP_CB_PROTOCOL, m_sProtocol);
	DDV_MaxChars(pDX, m_sProtocol, 32);
	DDX_CBString(pDX, IDC_AEIP_CB_SRC_PORT, m_sSrcPort);
	DDV_MaxChars(pDX, m_sSrcPort, 16);
	DDX_CBString(pDX, IDC_AEIP_CB_DEST_PORT, m_sDstPort);
	DDV_MaxChars(pDX, m_sDstPort, 16);
    DDX_Check(pDX, IDC_AEIP_CB_SOURCE, m_bSrc);
    DDX_Check(pDX, IDC_AEIP_CB_DEST, m_bDst);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CIpFltrAddEdit, CBaseDialog)
	//{{AFX_MSG_MAP(CIpFltrAddEdit)
	ON_CBN_SELCHANGE(IDC_AEIP_CB_PROTOCOL, OnSelchangeProtocol)
	ON_BN_CLICKED(IDC_AEIP_CB_SOURCE, OnCbSourceClicked)
	ON_BN_CLICKED(IDC_AEIP_CB_DEST, OnCbDestClicked)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

DWORD CIpFltrAddEdit::m_dwHelpMap[] =
{
//	IDC_AEIP_ST_SOURCE, HIDC_AEIP_ST_SOURCE,
//	IDC_AEIP_CB_SOURCE, HIDC_AEIP_CB_SOURCE,
//	IDC_AEIP_ST_SOURCE_ADDRESS, HIDC_AEIP_ST_SOURCE_ADDRESS,
//	IDC_AEIP_EB_SOURCE_ADDRESS, HIDC_AEIP_EB_SOURCE_ADDRESS,
//	IDC_AEIP_ST_SOURCE_MASK, HIDC_AEIP_ST_SOURCE_MASK,
//	IDC_AEIP_EB_SOURCE_MASK, HIDC_AEIP_EB_SOURCE_MASK,
//	IDC_AEIP_ST_DEST, HIDC_AEIP_ST_DEST,
//	IDC_AEIP_CB_DEST, HIDC_AEIP_CB_DEST,
//	IDC_AEIP_ST_DEST_ADDRESS, HIDC_AEIP_ST_DEST_ADDRESS,
//	IDC_AEIP_EB_DEST_ADDRESS, HIDC_AEIP_EB_DEST_ADDRESS,
//	IDC_AEIP_ST_DEST_MASK, HIDC_AEIP_ST_DEST_MASK,
//	IDC_AEIP_EB_DEST_MASK, HIDC_AEIP_EB_DEST_MASK,
//	IDC_AEIP_ST_PROTOCOL, HIDC_AEIP_ST_PROTOCOL,
//	IDC_AEIP_CB_PROTOCOL, HIDC_AEIP_CB_PROTOCOL,
//	IDC_AEIP_ST_SRC_PORT, HIDC_AEIP_ST_SRC_PORT,
//	IDC_AEIP_CB_SRC_PORT, HIDC_AEIP_CB_SRC_PORT,
//	IDC_AEIP_ST_DEST_PORT, HIDC_AEIP_ST_DEST_PORT,
//	IDC_AEIP_CB_DEST_PORT, HIDC_AEIP_CB_DEST_PORT,
	0,0,
};

/////////////////////////////////////////////////////////////////////////////
// CIpFltrAddEdit message handlers

//-----------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::OnSelchangeProtocol
//
// Handles 'CBN_SELCHANGE' notification from Protocols combo box
//------------------------------------------------------------------------------

void CIpFltrAddEdit::OnSelchangeProtocol() 
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
	CWnd * hWnd;
	CString   cStr;

	// if tcp or udp, then enable src/dest port
	// if icmp, rename strings and enable type/code
	// if Other enable src port
	// if Any disable everything

	switch(QueryCurrentProtocol()) {
	case PROTOCOL_TCP:
	case PROTOCOL_TCP_ESTABLISHED:
	case PROTOCOL_UDP:  
		VERIFY(cStr.LoadString(IDS_SRC_PORT));	  
		m_stSrcPort.SetWindowText(cStr);
		VERIFY(cStr.LoadString(IDS_DST_PORT));	  
		m_stDstPort.SetWindowText(cStr);
		m_cbSrcPort.ShowWindow(SW_SHOW);
		m_cbDstPort.ShowWindow(SW_SHOW);
		m_stSrcPort.ShowWindow(SW_SHOW);
		m_stDstPort.ShowWindow(SW_SHOW);
		break;

	case PROTOCOL_ICMP:
		VERIFY(cStr.LoadString(IDS_ICMP_TYPE));	  
		m_stSrcPort.SetWindowText(cStr);
		VERIFY(cStr.LoadString(IDS_ICMP_CODE));	  
		m_stDstPort.SetWindowText(cStr);
		m_cbSrcPort.ShowWindow(SW_SHOW);
		m_cbDstPort.ShowWindow(SW_SHOW);
   		m_stSrcPort.ShowWindow(SW_SHOW);
		m_stDstPort.ShowWindow(SW_SHOW);
		break;

	case PROTOCOL_ANY:
		m_cbSrcPort.ShowWindow(SW_HIDE);
		m_cbDstPort.ShowWindow(SW_HIDE);
		VERIFY(hWnd = GetDlgItem(IDC_AEIP_ST_SRC_PORT));
		hWnd->ShowWindow(SW_HIDE);
		VERIFY(hWnd = GetDlgItem(IDC_AEIP_ST_DEST_PORT));
		hWnd->ShowWindow(SW_HIDE);
		break;

	case PROTOCOL_OTHER:
		VERIFY(cStr.LoadString(IDS_OTHER_PROTOCOL));	  
		m_stSrcPort.SetWindowText(cStr);
		m_cbSrcPort.ShowWindow(SW_SHOW);
   		m_stSrcPort.ShowWindow(SW_SHOW);
		m_cbDstPort.ShowWindow(SW_HIDE);
		VERIFY(hWnd = GetDlgItem(IDC_AEIP_ST_DEST_PORT));
		hWnd->ShowWindow(SW_HIDE);
		break;
	}
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::OnInitDialog
//
// Handles 'WM_INITDIALOG' notification from the dialog
//------------------------------------------------------------------------------

BOOL CIpFltrAddEdit::OnInitDialog() 
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());

    CString     st;
    
	CBaseDialog::OnInitDialog();

	// determine if a new filter is being added or if an
	// existing filter is being modified.
	m_bEdit = ( *m_ppFilterEntry != NULL );

    st.LoadString(m_bEdit ? IDS_IP_EDIT_FILTER : IDS_IP_ADD_FILTER);
    SetWindowText(st);
    

	// create the IP controls
    m_ipSrcAddress.Create(m_hWnd, IDC_AEIP_EB_SOURCE_ADDRESS);
    m_ipSrcMask.Create(m_hWnd, IDC_AEIP_EB_SOURCE_MASK);
	IpAddr_ForceContiguous((HWND) m_ipSrcMask);
	
    m_ipDstAddress.Create(m_hWnd, IDC_AEIP_EB_DEST_ADDRESS);
    m_ipDstMask.Create(m_hWnd, IDC_AEIP_EB_DEST_MASK);
	IpAddr_ForceContiguous((HWND) m_ipDstMask);

	// disable IP controls by default
	CheckDlgButton(IDC_AEIP_CB_SOURCE, FALSE);
	OnCbSourceClicked();
	CheckDlgButton(IDC_AEIP_CB_DEST, FALSE);
	OnCbDestClicked();

	CString sProtocol;

	// fill up the protocol combo box with list of protocols
    UINT  count = sizeof(g_aPROTOCOLS)/sizeof(g_aPROTOCOLS[0]);
	for ( UINT i = 0; i < count; i++ ) {
		sProtocol.LoadString(g_aPROTOCOLS[i][0]);
		UINT item = m_cbProtocol.AddString(sProtocol);
		m_cbProtocol.SetItemData(item, g_aPROTOCOLS[i][1]);
		if( g_aPROTOCOLS[i][1] == PROTOCOL_ANY ) 
		{
			m_cbProtocol.SetCurSel(item);
		}
	}

	// Fill in the controls if the user is editing a filter

    if(m_bEdit)
    {
	  FilterListEntry * pfle = *m_ppFilterEntry;

	  if( pfle->dwSrcAddr == 0 &&
		  pfle->dwSrcMask == 0 )
	  {
		  m_bSrc = FALSE;
		  CheckDlgButton( IDC_AEIP_CB_SOURCE, 0);
	  }
	  else
	  {
		  m_bSrc = TRUE;
		  CheckDlgButton( IDC_AEIP_CB_SOURCE, 1);
		  m_ipSrcAddress.SetAddress(INET_NTOA(pfle->dwSrcAddr));
		  m_ipSrcMask.SetAddress(INET_NTOA(pfle->dwSrcMask));
		  GetDlgItem(IDC_AEIP_EB_SOURCE_ADDRESS)->EnableWindow(TRUE);  
		  GetDlgItem(IDC_AEIP_EB_SOURCE_MASK)->EnableWindow(TRUE);  
	  }

	  if( pfle->dwDstAddr == 0 &&
		  pfle->dwDstMask == 0 )
	  {
		  m_bDst = FALSE;
		  CheckDlgButton( IDC_AEIP_CB_DEST, 0);
	  }
	  else
	  {
		  m_bDst = TRUE;
		  CheckDlgButton( IDC_AEIP_CB_DEST, 1);
		  m_ipDstAddress.SetAddress(INET_NTOA(pfle->dwDstAddr));
		  m_ipDstMask.SetAddress(INET_NTOA(pfle->dwDstMask));		
		  GetDlgItem(IDC_AEIP_EB_DEST_ADDRESS)->EnableWindow(TRUE);  	
		  GetDlgItem(IDC_AEIP_EB_DEST_MASK)->EnableWindow(TRUE);
	  }

	  if ( pfle->dwProtocol == FILTER_PROTO_ANY )
	  {
		  SetProtocolSelection(IDS_PROTOCOL_ANY);
	  }
	  else if ( pfle->dwProtocol == FILTER_PROTO_ICMP )
	  {
		  SetProtocolSelection(IDS_PROTOCOL_ICMP);
		  m_cbSrcPort.SetWindowText(GetIcmpTypeString( pfle->wSrcPort));
		  m_cbDstPort.SetWindowText(GetIcmpCodeString( pfle->wDstPort));
	  }
	  else if ( pfle->dwProtocol == FILTER_PROTO_TCP )	
	  {
          if(pfle->fLateBound & TCP_ESTABLISHED_FLAG)
          {
              SetProtocolSelection(IDS_PROTOCOL_TCP_ESTABLISHED);
          }
          else
          {
		      SetProtocolSelection(IDS_PROTOCOL_TCP);
          }

		  m_cbSrcPort.SetWindowText(GetPortString( pfle->dwProtocol, pfle->wSrcPort));
		  m_cbDstPort.SetWindowText(GetPortString( pfle->dwProtocol, pfle->wDstPort));
	  }
	  else if ( pfle->dwProtocol == FILTER_PROTO_UDP )
	  {
		  SetProtocolSelection(IDS_PROTOCOL_UDP);
		  m_cbSrcPort.SetWindowText(GetPortString( pfle->dwProtocol, pfle->wSrcPort));
		  m_cbDstPort.SetWindowText(GetPortString( pfle->dwProtocol, pfle->wDstPort));

	  }
	  else
	  {
		  WCHAR buffer[16+1];

		  SetProtocolSelection(IDS_PROTOCOL_OTHER);
		  m_cbSrcPort.SetWindowText(_itow(pfle->dwProtocol, buffer, 10) );
	  }
    }


	// enable/disable controls based on filter type
	if (m_dwFilterType == FILTER_PERUSER_OUT)
	{
		MultiEnableWindow(GetSafeHwnd(), FALSE,
						  IDC_AEIP_CB_SOURCE,
						  IDC_AEIP_ST_SOURCE_ADDRESS,
						  IDC_AEIP_EB_SOURCE_ADDRESS,
						  IDC_AEIP_ST_SOURCE_MASK,
						  IDC_AEIP_EB_SOURCE_MASK,
						  0);
	}
	else if (m_dwFilterType == FILTER_PERUSER_IN)
	{
		MultiEnableWindow(GetSafeHwnd(), FALSE,
						  IDC_AEIP_CB_DEST,
						  IDC_AEIP_ST_DEST_ADDRESS,
						  IDC_AEIP_EB_DEST_ADDRESS,
						  IDC_AEIP_ST_DEST_MASK,
						  IDC_AEIP_EB_DEST_MASK,
						  0);
	}	



	// enable disable controls depending on selection

	OnSelchangeProtocol();

    return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::SetProtocolSelection
//
// Select the proper Protocol in the protocol 
//------------------------------------------------------------------------------

void CIpFltrAddEdit::SetProtocolSelection( UINT idProto )
{
    AFX_MANAGE_STATE(AfxGetStaticModuleState());
	CString cStr;

	if(!cStr.LoadString(idProto))
	{
		AfxMessageBox(_T("Error loading resource"));
	}
	
	m_cbProtocol.GetItemData(m_cbProtocol.GetCurSel());

	UINT item = m_cbProtocol.FindStringExact(-1, cStr);

	if(item != CB_ERR)
		m_cbProtocol.SetCurSel(item);
	else
		m_cbProtocol.SetCurSel(0);
}


//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetIcmpTypeString
//
// returns a CString representing ICMP type (if known) or a string version
// of the Type number.
//------------------------------------------------------------------------------

CString CIpFltrAddEdit::GetIcmpTypeString( WORD dwPort )
{
	WCHAR buffer[16];

	CString s = _T("");

    // look through our list of ICMP types and if we know the type, load
    // the corresponding string, else convert the port number to string
    // and return the string.
#if 0
    UINT  count = sizeof(g_aICMPTYPE)/sizeof(g_aICMPTYPE[0]);
    for(UINT i = 0; i < count; i++)
    {
        if(g_aICMPTYPE[i][0] == dwPort)
		{
			VERIFY(s.LoadString(g_aICMPTYPE[i][1]));
            return (s);
		}
    }
#endif
	return (CString((LPWSTR)_itow(dwPort, buffer, 10)));
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetIcmpCodeString
//
// returns a CString representing ICMP code (if known) or a string version
// of the Code number.
//------------------------------------------------------------------------------

CString CIpFltrAddEdit::GetIcmpCodeString( WORD dwPort )
{
	WCHAR buffer[16];

	return (CString((LPWSTR)_itow(dwPort, buffer, 10)));
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetPortString
//
// returns a CString representing port type (eg., FTP, ECHO) (if known) or a string 
// version of the port number
//------------------------------------------------------------------------------

CString CIpFltrAddEdit::GetPortString( DWORD dwProtocol, WORD dwPort )
{
	WCHAR buffer[16];

	return (CString((LPWSTR)_itow(dwPort, buffer, 10)));
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetPortNumber
//
// converts the port string name to port number and returns it
//------------------------------------------------------------------------------

WORD CIpFltrAddEdit::GetPortNumber( DWORD dwProtocol, CString& cStr)
{
	return ((WORD)(_wtoi((const wchar_t *)cStr.GetBuffer(10))));
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetIcmpType
//
// returns a number version of the ICMP type string
//------------------------------------------------------------------------------

WORD CIpFltrAddEdit::GetIcmpType( CString& cStr)
{
	return ((WORD)(_wtoi((const wchar_t *)cStr.GetBuffer(10))));
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetIcmpCode
//
// returns a number version of the ICMP code string
//------------------------------------------------------------------------------

WORD CIpFltrAddEdit::GetIcmpCode( CString& cStr)
{
	return ((WORD)(_wtoi((const wchar_t *)cStr.GetBuffer(10))));
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::OnOK
//
// handles 'BN_CLICKED' notification from "OK" button
//------------------------------------------------------------------------------

void CIpFltrAddEdit::OnOK() 
{

	FilterListEntry * pfle = new FilterListEntry;


    if ( !pfle )
    {
        AfxMessageBox( IDS_ERROR_NO_MEMORY );
        return;
    }

    ZeroMemory( pfle, sizeof(FilterListEntry) );


    //
    // Error breakout loop.
    //
    
	do {
	
		CString sAddr;


        //
		// if source network filter is specified, verify and
		// save data.
		//
		
		if ( m_bSrc = IsDlgButtonChecked(IDC_AEIP_CB_SOURCE) )
		{
			if(m_ipSrcAddress.GetAddress(sAddr) != 4)
			{
				AfxMessageBox(IDS_ENTER_SRC_ADDRESS);
				::SetFocus((HWND)m_ipSrcAddress);
				break;
			}
			
			pfle->dwSrcAddr = INET_ADDR(sAddr);
			
			if( m_ipSrcMask.GetAddress(sAddr) != 4)
			{
				AfxMessageBox(IDS_ENTER_SRC_MASK);
				::SetFocus((HWND)m_ipSrcMask);
				break;
			}
			
			pfle->dwSrcMask = INET_ADDR(sAddr);
			
            if ((pfle->dwSrcAddr & pfle->dwSrcMask) != pfle->dwSrcAddr)
            {
				AfxMessageBox(IDS_INVALID_SRC_MASK);
				::SetFocus((HWND)m_ipSrcMask);
				break;
            }
		}
		else
		{
			pfle->dwSrcAddr = 0;
			pfle->dwSrcMask = 0;
		}


        //
		// if destination network filter is specified, 
		// verify and save data.
		//
		
		if ( m_bDst = IsDlgButtonChecked(IDC_AEIP_CB_DEST) )
		{
			if(m_ipDstAddress.GetAddress(sAddr) != 4)
			{
				AfxMessageBox(IDS_ENTER_DST_ADDRESS);
				::SetFocus((HWND)m_ipDstAddress);
				break;
			}
			
			pfle->dwDstAddr = INET_ADDR(sAddr);

			
			if(m_ipDstMask.GetAddress(sAddr) != 4)
			{
				AfxMessageBox(IDS_ENTER_DST_MASK);
				::SetFocus((HWND)m_ipDstMask);
				break;
			}
			
			pfle->dwDstMask = INET_ADDR(sAddr);
			
            if ((pfle->dwDstAddr & pfle->dwDstMask) != pfle->dwDstAddr)
            {
				AfxMessageBox(IDS_INVALID_DST_MASK);
				::SetFocus((HWND)m_ipDstMask);
				break;
            }
		}
		else
		{
			pfle->dwDstAddr = 0;
			pfle->dwDstMask = 0;
		}


        //
        // verify and save protocol specific data
        //
        
		CString cStr = _T("");
		CString cStr2 = _T("");

		int index;

		switch(QueryCurrentProtocol()) {
		case PROTOCOL_TCP:
			pfle->dwProtocol = FILTER_PROTO_TCP;
			m_cbSrcPort.GetWindowText(cStr);
			pfle->wSrcPort = GetPortNumber(PROTOCOL_TCP, cStr);
			m_cbDstPort.GetWindowText(cStr);
			pfle->wDstPort = GetPortNumber(PROTOCOL_TCP, cStr);
			break;

		case PROTOCOL_TCP_ESTABLISHED:
			pfle->dwProtocol = FILTER_PROTO_TCP;
            pfle->fLateBound |= TCP_ESTABLISHED_FLAG;
			m_cbSrcPort.GetWindowText(cStr);
			pfle->wSrcPort = GetPortNumber(PROTOCOL_TCP_ESTABLISHED, cStr);
			m_cbDstPort.GetWindowText(cStr);
			pfle->wDstPort = GetPortNumber(PROTOCOL_TCP_ESTABLISHED, cStr);
			break;

		case PROTOCOL_UDP:
			pfle->dwProtocol = FILTER_PROTO_UDP;
			m_cbSrcPort.GetWindowText(cStr);
			pfle->wSrcPort = GetPortNumber(PROTOCOL_UDP, cStr);
			m_cbDstPort.GetWindowText(cStr);
			pfle->wDstPort = GetPortNumber(PROTOCOL_UDP, cStr);
			break;

		case PROTOCOL_ICMP:
			pfle->dwProtocol = FILTER_PROTO_ICMP;
			m_cbSrcPort.GetWindowText(cStr);
			m_cbDstPort.GetWindowText(cStr2);

			// Windows NT bugs: 83110
			// Default is 0xFF if none of the fields have data
			if (cStr.IsEmpty() && cStr2.IsEmpty())
			{
				pfle->wSrcPort = FILTER_ICMP_TYPE_ANY;
				pfle->wDstPort = FILTER_ICMP_CODE_ANY;
			}
			else
			{
				pfle->wSrcPort = GetIcmpType(cStr);
				pfle->wDstPort = GetIcmpCode(cStr2);
			}
			break;

		case PROTOCOL_ANY:
			pfle->dwProtocol = FILTER_PROTO_ANY;
			pfle->wSrcPort = pfle->wDstPort = 0;
			break;

		case PROTOCOL_OTHER:
			m_cbSrcPort.GetWindowText(cStr);
			pfle->dwProtocol = FILTER_PROTO(_wtoi((const wchar_t*)cStr.GetBuffer(16+1)));
			if(pfle->dwProtocol == 0)
			{
				AfxMessageBox(IDS_ENTER_OTHER_PROTOCOL);
				::SetFocus((HWND)m_cbSrcPort);
				delete pfle;
				return;
			}
			pfle->wSrcPort = pfle->wDstPort = 0;
			break;

		default:
		    AfxMessageBox( IDS_ERROR_SETTING_BLOCK );
		    delete pfle;
			return;
		}
		
        //
        // if this is a new filter, add it to m_ppFilterEntry
        //
        
    	if (!*m_ppFilterEntry)
	    {
	        *m_ppFilterEntry = pfle;
	    }

	    else
	    {
	        FilterListEntry *pfleDst = *m_ppFilterEntry;

	        pfleDst-> dwSrcAddr     = pfle-> dwSrcAddr;
	        pfleDst-> dwSrcMask     = pfle-> dwSrcMask;
	        pfleDst-> dwDstAddr     = pfle-> dwDstAddr;
	        pfleDst-> dwDstMask     = pfle-> dwDstMask;
	        pfleDst-> dwProtocol    = pfle-> dwProtocol;
	        pfleDst-> wSrcPort      = pfle-> wSrcPort;
	        pfleDst-> wDstPort      = pfle-> wDstPort;
	        pfleDst-> fLateBound      = pfle-> fLateBound;
	        
	        delete pfle;
	    }
	    
		// end the dialog
		CBaseDialog::OnOK();

		return;
		
	}while(FALSE);


    //
    // error condition
    //
    
	delete pfle;
	
	return;
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::OnCancel
//
// handles 'BN_CLICKED' notification from the Cancel button
//------------------------------------------------------------------------------

void CIpFltrAddEdit::OnCancel() 
{
	CBaseDialog::OnCancel();
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetIcmpTypeString
//
// Handles BN_CLICKED notification from "Source network" checkbox
//------------------------------------------------------------------------------

void CIpFltrAddEdit::OnCbSourceClicked() 
{
	m_bSrc = IsDlgButtonChecked(IDC_AEIP_CB_SOURCE);
    GetDlgItem(IDC_AEIP_EB_SOURCE_ADDRESS)->EnableWindow( m_bSrc );
    GetDlgItem(IDC_AEIP_EB_SOURCE_MASK)->EnableWindow( m_bSrc );
}

//------------------------------------------------------------------------------
// Function:	CIpFltrAddEdit::GetIcmpTypeString
//
// Handles BN_CLICKED notification from "Destination network" checkbox
//------------------------------------------------------------------------------


void CIpFltrAddEdit::OnCbDestClicked() 
{
	m_bDst = IsDlgButtonChecked(IDC_AEIP_CB_DEST);
    GetDlgItem(IDC_AEIP_EB_DEST_ADDRESS)->EnableWindow( m_bDst );
    GetDlgItem(IDC_AEIP_EB_DEST_MASK)->EnableWindow( m_bDst );
}