//============================================================================
// 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 );
}