mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1056 lines
26 KiB
1056 lines
26 KiB
//============================================================================
|
|
// Copyright(c) 1996, Microsoft Corporation
|
|
//
|
|
// File: ipxadd.cpp
|
|
//
|
|
// History:
|
|
// 08/30/96 Ram Cherala Created
|
|
//
|
|
// Implementation of IPX Filter Add/Edit dialog code
|
|
//============================================================================
|
|
|
|
#include "stdafx.h"
|
|
#include "rtrfiltr.h"
|
|
#include "ipxfltr.h"
|
|
#include "datafmt.h"
|
|
#include "IpxAdd.h"
|
|
extern "C" {
|
|
#include <ipxrtdef.h>
|
|
#include <ipxtfflt.h>
|
|
}
|
|
|
|
#include "rtradmin.hm"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CIpxAddEdit dialog
|
|
|
|
|
|
CIpxAddEdit::CIpxAddEdit(CWnd* pParent,
|
|
FilterListEntry ** ppFilterEntry)
|
|
: CBaseDialog(CIpxAddEdit::IDD, pParent),
|
|
m_ppFilterEntry( ppFilterEntry ),
|
|
m_bValidate( TRUE )
|
|
{
|
|
//{{AFX_DATA_INIT(CIpxAddEdit)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
// SetHelpMap(m_dwHelpMap);
|
|
}
|
|
|
|
|
|
void CIpxAddEdit::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CString cStr;
|
|
|
|
CBaseDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CIpxAddEdit)
|
|
DDX_Control(pDX, IDC_AEIPX_EB_SRC_SOCKET, m_ebSrcSocket);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_SRC_NODE, m_ebSrcNode);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_SRC_NET, m_ebSrcNet);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_SRC_MASK, m_ebSrcMask);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_PACKET_TYPE, m_ebPacketType);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_DST_SOCKET, m_ebDstSocket);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_DST_NODE, m_ebDstNode);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_DST_NET, m_ebDstNet);
|
|
DDX_Control(pDX, IDC_AEIPX_EB_DST_MASK, m_ebDstMask);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_SRC_SOCKET, cStr);
|
|
DDV_MaxChars(pDX, cStr, 4);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_SRC_NODE, cStr);
|
|
DDV_MaxChars(pDX, cStr, 12);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_SRC_NET, cStr);
|
|
DDV_MaxChars(pDX, cStr, 8);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_SRC_MASK, cStr);
|
|
DDV_MaxChars(pDX, cStr, 8);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_DST_SOCKET, cStr);
|
|
DDV_MaxChars(pDX, cStr, 4);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_DST_NODE, cStr);
|
|
DDV_MaxChars(pDX, cStr, 12);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_DST_NET, cStr);
|
|
DDV_MaxChars(pDX, cStr, 8);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_DST_MASK, cStr);
|
|
DDV_MaxChars(pDX, cStr, 8);
|
|
DDX_Text(pDX, IDC_AEIPX_EB_PACKET_TYPE, cStr);
|
|
DDV_MaxChars(pDX, cStr, 4);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
// change not to use KILLFOCUS to do data entry validation:
|
|
// reason: create dead loop when the one loosing focus and the one getting focus both have invalid entries
|
|
// here we change to do validation with OnOK
|
|
BEGIN_MESSAGE_MAP(CIpxAddEdit, CBaseDialog)
|
|
//{{AFX_MSG_MAP(CIpxAddEdit)
|
|
/*
|
|
ON_MESSAGE(WM_EDITLOSTFOCUS, OnEditLostFocus)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_SRC_NET, OnKillFocusSrcNet)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_SRC_MASK, OnKillFocusSrcNetMask)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_SRC_NODE, OnKillFocusSrcNode)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_SRC_SOCKET, OnKillFocusSrcSocket)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_DST_NET, OnKillFocusDstNet)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_DST_MASK, OnKillFocusDstNetMask)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_DST_NODE, OnKillFocusDstNode)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_DST_SOCKET, OnKillFocusDstSocket)
|
|
ON_EN_KILLFOCUS(IDC_AEIPX_EB_PACKET_TYPE, OnKillFocusPacketType)
|
|
*/
|
|
ON_WM_PARENTNOTIFY()
|
|
ON_WM_ACTIVATEAPP()
|
|
ON_WM_QUERYENDSESSION()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
DWORD CIpxAddEdit::m_dwHelpMap[] =
|
|
{
|
|
// IDC_AI_ST_SRC_NET, HIDC_AI_ST_SRC_NET,
|
|
// IDC_AEIPX_EB_SRC_NET, HIDC_AEIPX_EB_SRC_NET,
|
|
// IDC_AI_ST_SRC_MASK, HIDC_AI_ST_SRC_MASK,
|
|
// IDC_AEIPX_EB_SRC_MASK, HIDC_AEIPX_EB_SRC_MASK,
|
|
// IDC_AI_ST_SRC_NODE, HIDC_AI_ST_SRC_NODE,
|
|
// IDC_AEIPX_EB_SRC_NODE, HIDC_AEIPX_EB_SRC_NODE,
|
|
// IDC_AI_ST_SRC_SOCKET, HIDC_AI_ST_SRC_SOCKET,
|
|
// IDC_AEIPX_EB_SRC_SOCKET, HIDC_AEIPX_EB_SRC_SOCKET,
|
|
// IDC_AI_ST_DST_NET, HIDC_AI_ST_DST_NET,
|
|
// IDC_AEIPX_EB_DST_NET, HIDC_AEIPX_EB_DST_NET,
|
|
// IDC_AI_ST_DST_MASK, HIDC_AI_ST_DST_MASK,
|
|
// IDC_AEIPX_EB_DST_MASK, HIDC_AEIPX_EB_DST_MASK,
|
|
// IDC_AI_ST_DST_NODE, HIDC_AI_ST_DST_NODE,
|
|
// IDC_AEIPX_EB_DST_NODE, HIDC_AEIPX_EB_DST_NODE,
|
|
// IDC_AI_ST_DST_SOCKET, HIDC_AI_ST_DST_SOCKET,
|
|
// IDC_AEIPX_EB_DST_SOCKET, HIDC_AEIPX_EB_DST_SOCKET,
|
|
// IDC_AI_ST_PACKET_TYPE, HIDC_AI_ST_PACKET_TYPE,
|
|
// IDC_AEIPX_EB_PACKET_TYPE, HIDC_AEIPX_EB_PACKET_TYPE,
|
|
0,0
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CIpxAddEdit message handlers
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnInitDialog
|
|
//
|
|
// Handles 'WM_INITDIALOG' notification from the dialog
|
|
//------------------------------------------------------------------------------
|
|
|
|
BOOL CIpxAddEdit::OnInitDialog()
|
|
{
|
|
CBaseDialog::OnInitDialog();
|
|
|
|
CString cStr;
|
|
|
|
//
|
|
// determine if a new filter is being added or if an
|
|
// existing filter is being modified.
|
|
//
|
|
|
|
m_bEdit = ( *m_ppFilterEntry != NULL );
|
|
|
|
cStr.LoadString(m_bEdit ? IDS_IPX_EDIT_FILTER : IDS_IPX_ADD_FILTER);
|
|
SetWindowText(cStr);
|
|
|
|
|
|
//
|
|
// Remove this style so we get the WM_PARENTNOTIFY when
|
|
// the user clicks on the Cancel button
|
|
//
|
|
|
|
GetDlgItem(IDCANCEL)->ModifyStyleEx(WS_EX_NOPARENTNOTIFY,0);
|
|
|
|
|
|
//
|
|
// fill in the controls if user is editing an existing filter
|
|
//
|
|
|
|
if(m_bEdit)
|
|
{
|
|
FilterListEntry * pfle = *m_ppFilterEntry;
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_SRCNET)
|
|
{
|
|
m_ebSrcNet.SetWindowText(cStr << CIPX_NETWORK(pfle->SourceNetwork));
|
|
m_ebSrcMask.SetWindowText(cStr << CIPX_NETWORK(pfle->SourceNetworkMask));
|
|
}
|
|
|
|
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_SRCNODE)
|
|
{
|
|
m_ebSrcNode.SetWindowText(cStr << CIPX_NODE(pfle->SourceNode));
|
|
}
|
|
|
|
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_SRCSOCKET)
|
|
{
|
|
m_ebSrcSocket.SetWindowText(cStr << CIPX_SOCKET(pfle->SourceSocket));
|
|
}
|
|
|
|
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_DSTNET)
|
|
{
|
|
m_ebDstNet.SetWindowText(cStr << CIPX_NETWORK(pfle->DestinationNetwork));
|
|
m_ebDstMask.SetWindowText(cStr << CIPX_NETWORK(pfle->DestinationNetworkMask));
|
|
}
|
|
|
|
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_DSTNODE)
|
|
{
|
|
m_ebDstNode.SetWindowText(cStr << CIPX_NODE(pfle->DestinationNode));
|
|
}
|
|
|
|
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_DSTSOCKET)
|
|
{
|
|
m_ebDstSocket.SetWindowText(cStr << CIPX_SOCKET(pfle->DestinationSocket));
|
|
}
|
|
|
|
|
|
if (pfle->FilterDefinition & IPX_TRAFFIC_FILTER_ON_PKTTYPE)
|
|
{
|
|
m_ebPacketType.SetWindowText(cStr << CIPX_PACKET_TYPE(pfle->PacketType));
|
|
}
|
|
}
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
DWORD IDCsToVerify[] = {
|
|
IDC_AEIPX_EB_SRC_NET,
|
|
IDC_AEIPX_EB_SRC_MASK,
|
|
IDC_AEIPX_EB_SRC_NODE,
|
|
IDC_AEIPX_EB_SRC_SOCKET,
|
|
IDC_AEIPX_EB_DST_NET,
|
|
IDC_AEIPX_EB_DST_MASK,
|
|
IDC_AEIPX_EB_DST_NODE,
|
|
IDC_AEIPX_EB_DST_SOCKET,
|
|
IDC_AEIPX_EB_PACKET_TYPE,
|
|
0 };
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnOK
|
|
//
|
|
// Handles 'BN_CLICKED' notification from the 'OK' button
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnOK()
|
|
{
|
|
DWORD net, mask;
|
|
|
|
CString cStr, cNet, cMask;
|
|
|
|
FilterListEntry * pfle;
|
|
|
|
INT n = 0;
|
|
|
|
// validate the data entries
|
|
while(IDCsToVerify[n] != 0)
|
|
{
|
|
if (TRUE != ValidateAnEntry(IDCsToVerify[n++]))
|
|
return;
|
|
|
|
};
|
|
|
|
if(!*m_ppFilterEntry)
|
|
{
|
|
//
|
|
// new filter added, allocate memory and save information
|
|
//
|
|
|
|
*m_ppFilterEntry = new FilterListEntry;
|
|
}
|
|
|
|
VERIFY(*m_ppFilterEntry);
|
|
|
|
pfle = *m_ppFilterEntry;
|
|
|
|
|
|
do {
|
|
|
|
//
|
|
// init. flags field.
|
|
//
|
|
|
|
pfle->FilterDefinition = 0;
|
|
|
|
|
|
//
|
|
// Traffic filter source parameters
|
|
//
|
|
|
|
m_ebSrcNet.GetWindowText(cNet);
|
|
m_ebSrcMask.GetWindowText(cMask);
|
|
|
|
|
|
//
|
|
// if net number is empty
|
|
//
|
|
|
|
if ( cNet.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T("00000000");
|
|
|
|
cEmpty >> CIPX_NETWORK(pfle->SourceNetwork);
|
|
|
|
|
|
//
|
|
// if net mask is also empty
|
|
//
|
|
|
|
if ( cMask.GetLength() == 0 )
|
|
{
|
|
cEmpty >> CIPX_NETWORK(pfle->SourceNetworkMask);
|
|
}
|
|
|
|
else
|
|
{
|
|
cMask >> CIPX_NETWORK( pfle-> SourceNetworkMask );
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_SRCNET;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// if net number is not empty
|
|
//
|
|
|
|
else
|
|
{
|
|
//
|
|
// if net mask is empty
|
|
//
|
|
|
|
if ( cMask.GetLength() == 0 )
|
|
{
|
|
AfxMessageBox(IDS_ENTER_MASK);
|
|
::SetFocus((HWND)m_ebSrcMask);
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// both net and mask specified. Verify validity
|
|
//
|
|
|
|
if ( ( _stscanf (cNet, TEXT("%lx%n"), &net, &n) == 1 ) &&
|
|
( n == cNet.GetLength() ) &&
|
|
( _stscanf (cMask, TEXT("%lx%n"), &mask, &n) == 1 ) &&
|
|
( n == cMask.GetLength() ) )
|
|
{
|
|
if ( ( net & mask ) != net)
|
|
{
|
|
AfxMessageBox(IDS_ENTER_VALID_MASK);
|
|
::SetFocus((HWND)m_ebSrcMask);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
AfxMessageBox(IDS_ENTER_VALID_MASK);
|
|
::SetFocus((HWND)m_ebSrcMask);
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// valid network number and mask combination
|
|
//
|
|
|
|
cNet >> CIPX_NETWORK( pfle-> SourceNetwork );
|
|
cMask >> CIPX_NETWORK( pfle-> SourceNetworkMask );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_SRCNET;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// get source node
|
|
//
|
|
|
|
m_ebSrcNode.GetWindowText( cStr );
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T( "000000000000" );
|
|
|
|
cEmpty >> CIPX_NODE(pfle->SourceNode);
|
|
}
|
|
|
|
else
|
|
{
|
|
cStr >> CIPX_NODE( pfle-> SourceNode );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_SRCNODE;
|
|
}
|
|
|
|
|
|
//
|
|
// get source socket
|
|
//
|
|
|
|
m_ebSrcSocket.GetWindowText( cStr );
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T( "0000" );
|
|
|
|
cEmpty >> CIPX_SOCKET( pfle->SourceSocket );
|
|
}
|
|
|
|
else
|
|
{
|
|
cStr >> CIPX_SOCKET( pfle-> SourceSocket );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_SRCSOCKET;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Traffic filter destination parameters
|
|
//
|
|
|
|
m_ebDstNet.GetWindowText(cNet);
|
|
m_ebDstMask.GetWindowText(cMask);
|
|
|
|
|
|
//
|
|
// if net number is empty
|
|
//
|
|
|
|
if ( cNet.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T("00000000");
|
|
|
|
cEmpty >> CIPX_NETWORK(pfle->DestinationNetwork);
|
|
|
|
|
|
//
|
|
// if net mask is also empty
|
|
//
|
|
|
|
if ( cMask.GetLength() == 0 )
|
|
{
|
|
cEmpty >> CIPX_NETWORK(pfle->DestinationNetworkMask);
|
|
}
|
|
|
|
else
|
|
{
|
|
cMask >> CIPX_NETWORK( pfle-> DestinationNetworkMask );
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_DSTNET;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// if net number is not empty
|
|
//
|
|
|
|
else
|
|
{
|
|
//
|
|
// if net mask is empty
|
|
//
|
|
|
|
if ( cMask.GetLength() == 0 )
|
|
{
|
|
AfxMessageBox(IDS_ENTER_MASK);
|
|
::SetFocus((HWND)m_ebDstMask);
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// both net and mask specified. Verify validity
|
|
//
|
|
|
|
if ( ( _stscanf (cNet, TEXT("%lx%n"), &net, &n) == 1 ) &&
|
|
( n == cNet.GetLength() ) &&
|
|
( _stscanf (cMask, TEXT("%lx%n"), &mask, &n) == 1 ) &&
|
|
( n == cMask.GetLength() ) )
|
|
{
|
|
if ( ( net & mask ) != net)
|
|
{
|
|
AfxMessageBox(IDS_ENTER_VALID_MASK);
|
|
::SetFocus((HWND)m_ebDstMask);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
AfxMessageBox(IDS_ENTER_VALID_MASK);
|
|
::SetFocus((HWND)m_ebDstMask);
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// valid network number and mask combination
|
|
//
|
|
|
|
cNet >> CIPX_NETWORK( pfle-> DestinationNetwork );
|
|
cMask >> CIPX_NETWORK( pfle-> DestinationNetworkMask );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_DSTNET;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// get destination node
|
|
//
|
|
|
|
m_ebDstNode.GetWindowText( cStr );
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T( "000000000000" );
|
|
|
|
cEmpty >> CIPX_NODE(pfle->DestinationNode);
|
|
}
|
|
|
|
else
|
|
{
|
|
cStr >> CIPX_NODE( pfle-> DestinationNode );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_DSTNODE;
|
|
}
|
|
|
|
|
|
//
|
|
// get destination socket
|
|
//
|
|
|
|
m_ebDstSocket.GetWindowText( cStr );
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T( "0000" );
|
|
|
|
cEmpty >> CIPX_SOCKET( pfle->DestinationSocket );
|
|
}
|
|
|
|
else
|
|
{
|
|
cStr >> CIPX_SOCKET( pfle-> DestinationSocket );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_DSTSOCKET;
|
|
}
|
|
|
|
|
|
//
|
|
// get packet type
|
|
//
|
|
|
|
m_ebPacketType.GetWindowText( cStr );
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
CString cEmpty = _T( "0" );
|
|
|
|
cEmpty >> CIPX_PACKET_TYPE( pfle-> PacketType );
|
|
}
|
|
|
|
else
|
|
{
|
|
cStr >> CIPX_PACKET_TYPE( &pfle-> PacketType );
|
|
|
|
pfle-> FilterDefinition |= IPX_TRAFFIC_FILTER_ON_PKTTYPE;
|
|
}
|
|
|
|
CBaseDialog::OnOK();
|
|
|
|
} while (FALSE);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnCancel
|
|
//
|
|
// Handles 'BN_CLICKED' notification from the 'Cancel' button
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnCancel()
|
|
{
|
|
// TODO: Add extra cleanup here
|
|
|
|
CBaseDialog::OnCancel();
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusSrcNet
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Source Network number' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusSrcNet()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_SRC_NET, 0 );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusSrcMask
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Source Network Mask' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusSrcNetMask()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_SRC_MASK, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusSrcNode
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Source Network Node' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusSrcNode()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_SRC_NODE, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusSrcSocket
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Source Network Socket' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusSrcSocket()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_SRC_SOCKET, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusDstNet
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Destination Network number'
|
|
// editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusDstNet()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_DST_NET, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusDstMask
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Destination Network mask'
|
|
// editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusDstNetMask()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_DST_MASK, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusDstNode
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Destination Node' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusDstNode()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_DST_NODE, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusSrcNet
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Destination socket' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusDstSocket()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_DST_SOCKET, 0 );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusPacketType
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Packet Type' editbox
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnKillFocusPacketType()
|
|
{
|
|
PostMessage( WM_EDITLOSTFOCUS, IDC_AEIPX_EB_PACKET_TYPE, 0 );
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnKillFocusPacketType
|
|
//
|
|
// Handles 'EN_KILLFOCUS' notification from the 'Packet Type' editbox
|
|
//------------------------------------------------------------------------------
|
|
afx_msg
|
|
LONG CIpxAddEdit::OnEditLostFocus( UINT uId, LONG lParam )
|
|
{
|
|
ValidateAnEntry(uId);
|
|
|
|
return 0;
|
|
|
|
};
|
|
BOOL CIpxAddEdit::ValidateAnEntry( UINT uId)
|
|
{
|
|
|
|
BOOL bOK = FALSE;
|
|
|
|
CString cStr, cStr1;
|
|
|
|
|
|
if ( m_bValidate )
|
|
{
|
|
if ( !UpdateData( TRUE ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
|
|
switch ( uId )
|
|
{
|
|
case IDC_AEIPX_EB_SRC_NET:
|
|
|
|
m_ebSrcNet.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_NETWORK_NUMBER );
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_SRC_MASK:
|
|
|
|
m_ebSrcMask.GetWindowText( cStr );
|
|
|
|
m_ebSrcNet.GetWindowText( cStr1 );
|
|
|
|
bOK = VerifyEntry( uId, cStr, cStr1 );
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_SRC_NODE:
|
|
|
|
m_ebSrcNode.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_NODE_NUMBER );
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_SRC_SOCKET:
|
|
|
|
m_ebSrcSocket.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_SOCKET_NUMBER );
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_DST_NET:
|
|
|
|
m_ebDstNet.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_NETWORK_NUMBER );
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_DST_MASK:
|
|
|
|
m_ebDstMask.GetWindowText( cStr );
|
|
|
|
m_ebDstNet.GetWindowText( cStr1 );
|
|
|
|
bOK = VerifyEntry( uId, cStr, cStr1 );
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_DST_NODE:
|
|
|
|
m_ebDstNode.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_NODE_NUMBER );
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_DST_SOCKET:
|
|
|
|
m_ebDstSocket.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_SOCKET_NUMBER );
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case IDC_AEIPX_EB_PACKET_TYPE:
|
|
|
|
m_ebPacketType.GetWindowText( cStr );
|
|
|
|
if ( !( bOK = VerifyEntry( uId, cStr, cStr1 ) ) )
|
|
{
|
|
::AfxMessageBox( IDS_INVALID_SERVICE_TYPE );
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if ( !bOK )
|
|
{
|
|
GetDlgItem( uId )-> SetFocus();
|
|
}
|
|
}
|
|
|
|
m_bValidate = TRUE;
|
|
|
|
return bOK;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnParentNotify
|
|
//
|
|
// Handles 'WM_PARENTNOTIFY' notification caused by a mouse click on the CANCEL
|
|
// button
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnParentNotify(UINT message, LPARAM lParam)
|
|
{
|
|
|
|
CBaseDialog::OnParentNotify(message, lParam);
|
|
|
|
//
|
|
// Mouse clicked on dialog.
|
|
//
|
|
|
|
CPoint ptButtonDown(LOWORD(lParam), HIWORD(lParam));
|
|
|
|
//
|
|
// Did the user click the mouse on the cancel button?
|
|
//
|
|
|
|
if ( ( message == WM_LBUTTONDOWN ) &&
|
|
( ChildWindowFromPoint( ptButtonDown ) == GetDlgItem(IDCANCEL) ) )
|
|
{
|
|
m_bValidate = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnActivateApp
|
|
//
|
|
// Handles 'WM_ACTIVATEAPP' notification
|
|
//------------------------------------------------------------------------------
|
|
|
|
void CIpxAddEdit::OnActivateApp(BOOL bActive, HTASK hTask)
|
|
{
|
|
CBaseDialog::OnActivateApp(bActive, hTask);
|
|
|
|
m_bValidate = bActive;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::OnQuerySession
|
|
//
|
|
// Handles 'WM_QUERYENDSESSION' notification
|
|
//------------------------------------------------------------------------------
|
|
|
|
BOOL CIpxAddEdit::OnQueryEndSession()
|
|
{
|
|
|
|
if ( !CBaseDialog::OnQueryEndSession() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Before ending this Windows session,
|
|
// validate the dialog controls.
|
|
// This is basically the code from CDialog::OnOK();
|
|
//
|
|
|
|
if (!UpdateData(TRUE))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
EndDialog(IDOK);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
#define ValidHexCharSet TEXT( "1234567890abcdefABCDEF" )
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Function: CIpxAddEdit::VerifyEntry
|
|
//
|
|
// Verifies entered data in each edit control
|
|
//------------------------------------------------------------------------------
|
|
|
|
BOOL CIpxAddEdit::VerifyEntry(
|
|
UINT uId,
|
|
const CString& cStr,
|
|
const CString& cNet
|
|
)
|
|
{
|
|
|
|
INT n = 0;
|
|
DWORD dwNet, dwMask;
|
|
|
|
|
|
//
|
|
// if the value in cStr is not a mask
|
|
//
|
|
|
|
if ( uId != IDC_AEIPX_EB_SRC_MASK &&
|
|
uId != IDC_AEIPX_EB_DST_MASK )
|
|
{
|
|
//
|
|
// if empty string skip it.
|
|
//
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// check string has only valid hex characters
|
|
//
|
|
|
|
CString cTmp = cStr.SpanIncluding( (LPCTSTR) ValidHexCharSet );
|
|
|
|
return ( cTmp.GetLength() == cStr.GetLength() );
|
|
}
|
|
|
|
|
|
//
|
|
// the value in CStr is a mask.
|
|
//
|
|
|
|
//
|
|
// Empty network and mask is a valid combination.
|
|
//
|
|
|
|
if ( cNet.GetLength() == 0 &&
|
|
cStr.GetLength() == 0 )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// no network mask specified
|
|
//
|
|
|
|
if ( cStr.GetLength() == 0 )
|
|
{
|
|
|
|
//
|
|
// check if network number is valid. If it isn't
|
|
// the network number check will fire, so do not
|
|
// pop a box here. HACK to circumvent the KILLFOCUS
|
|
// processing
|
|
//
|
|
|
|
CString cTmp = cNet.SpanIncluding( (LPCTSTR) ValidHexCharSet );
|
|
|
|
if ( cNet.GetLength() == cTmp.GetLength() )
|
|
{
|
|
::AfxMessageBox( IDS_ENTER_MASK );
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// verify mask has only hex chars.
|
|
//
|
|
|
|
CString cTmp = cStr.SpanIncluding( (LPCTSTR) ValidHexCharSet );
|
|
|
|
if ( cTmp.GetLength() != cStr.GetLength() )
|
|
{
|
|
::AfxMessageBox( IDS_ENTER_VALID_MASK );
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// If net number is empty, return TRUE.
|
|
//
|
|
|
|
if ( cNet.GetLength() == 0 )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// if net number contains invalid data, return TRUE.
|
|
// Net number validation will take care of this.
|
|
//
|
|
|
|
cTmp = cNet.SpanIncluding( (LPCTSTR) ValidHexCharSet );
|
|
|
|
if ( cNet.GetLength() != cTmp.GetLength() )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// verify net and mask jive
|
|
//
|
|
|
|
if ( ( _stscanf (cNet, TEXT("%lx%n"), &dwNet, &n) == 1 ) &&
|
|
( n == cNet.GetLength() ) &&
|
|
( _stscanf (cStr, TEXT("%lx%n"), &dwMask, &n) == 1 ) &&
|
|
( n == cStr.GetLength() ) )
|
|
{
|
|
if ( ( dwNet & dwMask ) != dwNet)
|
|
{
|
|
::AfxMessageBox( (uId == IDC_AEIPX_EB_SRC_MASK) ?
|
|
IDS_INVALID_SRC_MASK :
|
|
IDS_INVALID_DST_MASK );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
::AfxMessageBox( IDS_ENTER_VALID_MASK );
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|