1280 lines
30 KiB
C++
1280 lines
30 KiB
C++
/**********************************************************************/
|
|
/** Microsoft Windows/NT **/
|
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
|
/**********************************************************************/
|
|
|
|
/*
|
|
statmapp.cpp
|
|
Property Page for Active Registrations Record
|
|
|
|
FILE HISTORY:
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "winssnap.h"
|
|
#include "statmapp.h"
|
|
#include "server.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
// Static Record Types
|
|
CString g_strStaticTypeUnique;
|
|
CString g_strStaticTypeDomainName;
|
|
CString g_strStaticTypeMultihomed;
|
|
CString g_strStaticTypeGroup;
|
|
CString g_strStaticTypeInternetGroup;
|
|
CString g_strStaticTypeUnknown;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
static const char rgchHex[16*2+1] = "00112233445566778899aAbBcCdDeEfF";
|
|
|
|
/*---------------------------------------------------------------------------
|
|
FGetByte()
|
|
|
|
Return the byte value of a string.
|
|
Return TRUE pbNum is set to the byte value (only if the string contains
|
|
valid digits)
|
|
Return FALSE if string has unrecognized digits or byte overflow.
|
|
|
|
eg:
|
|
szNum = "xFF" => return TRUE
|
|
szNum = "255" => return TRUE
|
|
szNum = "256" => return FALSE (overflow)
|
|
szNum = "26a" => return TRUE (*pbNum = 26, *ppchNext = "a")
|
|
szNum = "ab" => return FALSE (unrecognized digits)
|
|
---------------------------------------------------------------------------*/
|
|
BOOL
|
|
FGetByte(IN const char szNum[], OUT BYTE * pbNum, OUT const char ** ppchNext)
|
|
{
|
|
ASSERT(szNum);
|
|
ASSERT(pbNum);
|
|
ASSERT(ppchNext);
|
|
|
|
int nResult;
|
|
char * pchNum = (char *)szNum;
|
|
int iBase = 10; // Assume a decimal base
|
|
|
|
if (*pchNum == 'x' || *pchNum == 'X') // Check if we are using hexadecimal base
|
|
{
|
|
iBase = 16;
|
|
pchNum++;
|
|
}
|
|
|
|
char * pchDigit = strchr(rgchHex, *pchNum++);
|
|
|
|
if (pchDigit == NULL)
|
|
return FALSE;
|
|
|
|
int iDigit = (int) ((pchDigit - rgchHex) >> 1);
|
|
|
|
if (iDigit >= iBase)
|
|
{
|
|
// Hexadecimal character in a decimal integer
|
|
return FALSE;
|
|
}
|
|
|
|
nResult = iDigit;
|
|
pchDigit = strchr(rgchHex, *pchNum);
|
|
iDigit = (int) ((pchDigit - rgchHex) >> 1);
|
|
|
|
if (pchDigit == NULL || iDigit >= iBase)
|
|
{
|
|
// Only one character was valid
|
|
*pbNum = (BYTE) nResult;
|
|
*ppchNext = pchNum;
|
|
return TRUE;
|
|
}
|
|
|
|
pchNum++;
|
|
nResult = (nResult * iBase) + iDigit;
|
|
|
|
ASSERT(nResult < 256);
|
|
|
|
if (iBase == 16)
|
|
{
|
|
// Hexadecimal value, stop there
|
|
*pbNum = (BYTE) nResult;
|
|
*ppchNext = pchNum;
|
|
return TRUE;
|
|
}
|
|
|
|
// Decimal digit, so search for an optional third character
|
|
pchDigit = strchr(rgchHex, *pchNum);
|
|
iDigit = (int) ((pchDigit - rgchHex) >> 1);
|
|
|
|
if (pchDigit == NULL || iDigit >= iBase)
|
|
{
|
|
*pbNum = (BYTE) nResult;
|
|
*ppchNext = pchNum;
|
|
return TRUE;
|
|
}
|
|
|
|
nResult = (nResult * iBase) + iDigit;
|
|
|
|
if (nResult >= 256)
|
|
return FALSE;
|
|
|
|
pchNum++;
|
|
*pbNum = (BYTE) nResult;
|
|
*ppchNext = pchNum;
|
|
|
|
return TRUE;
|
|
} // FGetByte
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStaticMappingProp property page
|
|
|
|
IMPLEMENT_DYNCREATE(CStaticMappingProp, CPropertyPageBase)
|
|
|
|
CStaticMappingProp::CStaticMappingProp(UINT uIDD)
|
|
: CPropertyPageBase(uIDD),
|
|
m_fStaticPropChanged (TRUE),
|
|
m_uIDD(uIDD)
|
|
{
|
|
//{{AFX_DATA_INIT(CStaticMappingProp)
|
|
m_strName = _T("");
|
|
m_strType = _T("");
|
|
m_strScopeName = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
CStaticMappingProp::~CStaticMappingProp()
|
|
{
|
|
}
|
|
|
|
void
|
|
CStaticMappingProp::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CPropertyPageBase::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CStaticMappingProp)
|
|
DDX_Control(pDX, IDC_EDIT_SCOPE_NAME, m_editScopeName);
|
|
DDX_Control(pDX, IDC_LIST_IPADD, m_listIPAdd);
|
|
DDX_Control(pDX, IDC_BUTTON_REMOVE, m_buttonRemove);
|
|
DDX_Control(pDX, IDC_BUTTON_ADD, m_buttonAdd);
|
|
DDX_Control(pDX, IDC_EDIT_COMPNAME, m_editName);
|
|
DDX_Control(pDX, IDC_COMBO_STATIC_TYPE, m_comboType);
|
|
DDX_Text(pDX, IDC_EDIT_COMPNAME, m_strName);
|
|
DDX_CBString(pDX, IDC_COMBO_STATIC_TYPE, m_strType);
|
|
DDX_Text(pDX, IDC_EDIT_SCOPE_NAME, m_strScopeName);
|
|
//}}AFX_DATA_MAP
|
|
|
|
DDX_Control(pDX, IDC_IPADD, m_editCustomIPAdd);
|
|
//DDX_Control(pDX, IDC_IPADD, m_ipControl);
|
|
DDX_Text(pDX, IDC_IPADD, m_strIPAdd);
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CStaticMappingProp, CPropertyPageBase)
|
|
//{{AFX_MSG_MAP(CStaticMappingProp)
|
|
ON_BN_CLICKED(IDC_BUTTON_ADD, OnButtonAdd)
|
|
ON_BN_CLICKED(IDC_BUTTON_REMOVE, OnButtonRemove)
|
|
ON_CBN_SELCHANGE(IDC_COMBO_STATIC_TYPE, OnSelchangeComboType)
|
|
ON_EN_CHANGE(IDC_EDIT_COMPNAME, OnChangeEditCompname)
|
|
ON_LBN_SELCHANGE(IDC_LIST_IPADD, OnSelChangeListIpAdd)
|
|
//}}AFX_MSG_MAP
|
|
|
|
// IP Address control
|
|
ON_EN_CHANGE(IDC_IPADD, OnChangeIpAddress)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStaticMappingProp message handlers
|
|
void CStaticMappingProp::OnOK()
|
|
{
|
|
CPropertyPageBase::OnOK();
|
|
}
|
|
|
|
|
|
BOOL
|
|
CStaticMappingProp::OnApply()
|
|
{
|
|
HRESULT hr = hrOK;
|
|
BOOL bRet = TRUE;
|
|
|
|
// if not dirtied return
|
|
if (!IsDirty())
|
|
return TRUE;
|
|
|
|
if (((CStaticMappingProperties*)GetHolder())->m_bWizard)
|
|
{
|
|
UpdateData();
|
|
|
|
CActiveRegistrationsHandler *pActReg;
|
|
|
|
SPITFSNode spNode;
|
|
spNode = GetHolder()->GetNode();
|
|
|
|
pActReg = GETHANDLER(CActiveRegistrationsHandler, spNode);
|
|
|
|
m_strName.TrimLeft();
|
|
m_strName.TrimRight();
|
|
|
|
int nMax = (pActReg->IsLanManCompatible()) ? 15 : 16;
|
|
if (m_strName.IsEmpty())
|
|
{
|
|
CString strMessage, strTemp;
|
|
strTemp.Format(_T("%d"), nMax);
|
|
|
|
AfxFormatString1(strMessage, IDS_INVALID_NAME, strTemp);
|
|
AfxMessageBox(strMessage);
|
|
|
|
m_editName.SetFocus();
|
|
m_editName.SetSel(0, -1);
|
|
|
|
return FALSE;
|
|
}
|
|
else
|
|
if (m_strType.IsEmpty())
|
|
{
|
|
AfxMessageBox(IDS_INVALID_TYPE, MB_OK);
|
|
m_comboType.SetFocus();
|
|
return FALSE;
|
|
}
|
|
|
|
CString strTemp;
|
|
|
|
// check this only for Unique and Normal Group addresses,
|
|
// for the rest, the ipcontrol is balnk and the list box holds the IP a
|
|
// IP addresses for them.
|
|
|
|
DWORD dwIp1, dwIp2, dwIp3, dwIp4;
|
|
int nAdd = m_ipControl.GetAddress(&dwIp1, &dwIp2, &dwIp3, &dwIp4);
|
|
|
|
LONG lIPAdd = (LONG) MAKEIPADDRESS(dwIp1, dwIp2, dwIp3, dwIp4);
|
|
|
|
// it's so bcoz' only in the case of Unique and Normal Group names,
|
|
// IP address is read from the IP control, else from the list box
|
|
|
|
if ( (m_strType.CompareNoCase(g_strStaticTypeUnique) == 0) || (m_strType.CompareNoCase(g_strStaticTypeGroup) == 0) )
|
|
{
|
|
if (nAdd != 4)
|
|
{
|
|
AfxMessageBox(IDS_INVALID_IPADDRESS, MB_OK);
|
|
m_editCustomIPAdd.SetFocus();
|
|
return FALSE;
|
|
}
|
|
|
|
// check if broadcast address has been entered
|
|
if (m_strIPAdd.CompareNoCase(_T("255.255.255.255")) == 0)
|
|
{
|
|
AfxMessageBox(IDS_INVALID_IPADDRESS, MB_OK);
|
|
m_editCustomIPAdd.SetFocus();
|
|
return FALSE;
|
|
}
|
|
|
|
// check to make sure something was entered
|
|
if ( (m_strIPAdd.IsEmpty()) ||
|
|
(m_strIPAdd.CompareNoCase(_T("0.0.0.0")) == 0) )
|
|
{
|
|
AfxMessageBox(IDS_INVALID_IPADDRESS, MB_OK);
|
|
m_editCustomIPAdd.SetFocus();
|
|
m_editCustomIPAdd.SetSel(0,-1);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_listIPAdd.GetCount() == 0)
|
|
{
|
|
AfxMessageBox(IDS_INVALID_IPADDRESS, MB_OK);
|
|
m_editCustomIPAdd.SetFocus();
|
|
m_editCustomIPAdd.SetSel(0,-1);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL fInternetGroup = FALSE;
|
|
|
|
if (m_strType.CompareNoCase(g_strStaticTypeInternetGroup) == 0)
|
|
fInternetGroup = TRUE;
|
|
|
|
// Parse the string
|
|
BOOL fValid = TRUE;
|
|
BOOL fBrackets = FALSE;
|
|
BYTE rgbData[100];
|
|
BYTE bDataT;
|
|
int cbData = 0;
|
|
LPSTR szTemp = (char*) alloca(2*(MAX_PATH+1));
|
|
|
|
// just use ACP here because we are just looking at the string
|
|
// we will do the OEM conversion later.
|
|
WideToMBCS(m_strName, szTemp);
|
|
|
|
const char * pch = (LPCSTR)szTemp;
|
|
|
|
while (*pch)
|
|
{
|
|
if (fBrackets)
|
|
{
|
|
fValid = FALSE;
|
|
goto Done;
|
|
}
|
|
|
|
if (cbData > 16)
|
|
goto Done;
|
|
|
|
switch (*pch)
|
|
{
|
|
case '\\':
|
|
pch++;
|
|
|
|
if (*pch == '\\' || *pch == '[')
|
|
{
|
|
rgbData[cbData++] = *pch++;
|
|
break;
|
|
}
|
|
|
|
if (!FGetByte(pch, &bDataT, &pch) || !bDataT)
|
|
{
|
|
fValid = FALSE;
|
|
goto Done;
|
|
}
|
|
|
|
rgbData[cbData++] = bDataT;
|
|
|
|
break;
|
|
|
|
case '[':
|
|
{
|
|
char szT[4] = { 0 };
|
|
const char * pchT;
|
|
|
|
fBrackets = TRUE;
|
|
pch++;
|
|
|
|
if (*(pch + 1) == 'h' || *(pch + 1) == 'H')
|
|
{
|
|
szT[0] = 'x';
|
|
szT[1] = *pch;
|
|
pch += 2;
|
|
}
|
|
|
|
else if (*(pch + 2) == 'h' || *(pch + 2) == 'H')
|
|
{
|
|
szT[0] = 'x';
|
|
szT[1] = *pch;
|
|
szT[2] = *(pch + 1);
|
|
pch += 3;
|
|
}
|
|
|
|
if (szT[0])
|
|
{
|
|
if (!FGetByte(szT, &bDataT, &pchT) || !bDataT || *pchT)
|
|
{
|
|
fValid = FALSE;
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
else if (!FGetByte(pch, &bDataT, &pch) || !bDataT)
|
|
{
|
|
fValid = FALSE;
|
|
goto Done;
|
|
}
|
|
|
|
if (*pch++ != ']')
|
|
{
|
|
fValid = FALSE;
|
|
goto Done;
|
|
}
|
|
|
|
while (cbData < 15)
|
|
rgbData[cbData++] = ' ';
|
|
|
|
rgbData[cbData++] = bDataT;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
|
|
#ifdef FE_SB
|
|
|
|
if (::IsDBCSLeadByte(*pch))
|
|
rgbData[cbData++] = *pch++;
|
|
|
|
#endif
|
|
|
|
rgbData[cbData++] = *pch++;
|
|
|
|
} // switch
|
|
|
|
}
|
|
|
|
|
|
|
|
Done:
|
|
// Put a null-terminator at end of string
|
|
rgbData[cbData] = 0;
|
|
|
|
if (!cbData || cbData > nMax)
|
|
{
|
|
CString strMessage, strTemp;
|
|
strTemp.Format(_T("%d"), nMax);
|
|
|
|
AfxFormatString1(strMessage, IDS_INVALID_NAME, strTemp);
|
|
AfxMessageBox(strMessage);
|
|
|
|
m_editName.SetFocus();
|
|
m_editName.SetSel(0,-1);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (!fValid)
|
|
{
|
|
CString strMessage, strTemp;
|
|
strTemp.Format(_T("%d"), nMax);
|
|
|
|
AfxFormatString1(strMessage, IDS_INVALID_NAME, strTemp);
|
|
AfxMessageBox(strMessage);
|
|
|
|
m_editName.SetFocus();
|
|
m_editName.SetSel(0,-1);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (fInternetGroup && rgbData[15] == 0x1C)
|
|
{
|
|
AfxMessageBox(IDS_INVALID_INTERNET_GROUP_NAME);
|
|
m_editName.SetFocus();
|
|
m_editName.SetSel(0,-1);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (fInternetGroup)
|
|
{
|
|
while (cbData <= 15)
|
|
rgbData[cbData++] = ' ';
|
|
|
|
rgbData[cbData] = 0;
|
|
}
|
|
|
|
szTemp = (LPSTR)rgbData;
|
|
|
|
// convert our touched up string back to unicode for use later
|
|
MBCSToWide(szTemp, pActReg->m_strStaticMappingName);
|
|
|
|
//pActReg->m_strStaticMappingName = rgbData;
|
|
pActReg->m_strStaticMappingScope = m_strScopeName;
|
|
pActReg->m_strStaticMappingType = m_strType;
|
|
|
|
AssignMappingType();
|
|
|
|
pActReg->m_nStaticMappingType = m_fType;
|
|
|
|
// clear the IP adress array maintained in theactreg handler first
|
|
pActReg->m_strArrayStaticMappingIPAddress.RemoveAll();
|
|
pActReg->m_lArrayIPAddress.RemoveAll();
|
|
|
|
if ( (m_strType.CompareNoCase(g_strStaticTypeUnique) == 0) || (m_strType.CompareNoCase(g_strStaticTypeGroup) == 0) )
|
|
{
|
|
pActReg->m_strArrayStaticMappingIPAddress.Add(m_strIPAdd);
|
|
pActReg->m_lArrayIPAddress.Add(lIPAdd);
|
|
}
|
|
// copy from the array
|
|
else
|
|
{
|
|
for (int i = 0; i < m_strArrayIPAdd.GetSize(); i++)
|
|
{
|
|
pActReg->m_strArrayStaticMappingIPAddress.Add(m_strArrayIPAdd.GetAt(i));
|
|
pActReg->m_lArrayIPAddress.Add(m_dwArrayIPAdd.GetAt(i));
|
|
}
|
|
}
|
|
|
|
// do the thread context switch so we can update the UI as well
|
|
bRet = CPropertyPageBase::OnApply();
|
|
|
|
if (bRet == FALSE)
|
|
{
|
|
// Something bad happened... grab the error code
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
::WinsMessageBox(GetHolder()->GetError());
|
|
}
|
|
else
|
|
{
|
|
// set back the defaults for the controls
|
|
m_comboType.SelectString(-1, g_strStaticTypeUnique);
|
|
|
|
m_editCustomIPAdd.ShowWindow(TRUE);
|
|
m_editCustomIPAdd.SetWindowText(_T(""));
|
|
m_editName.SetWindowText(_T(""));
|
|
m_editScopeName.SetWindowText(_T(""));
|
|
|
|
// clear and hide the list box and the Add and Remove buttons
|
|
m_buttonAdd.ShowWindow(FALSE);
|
|
m_buttonRemove.ShowWindow(FALSE);
|
|
|
|
int nCount = m_listIPAdd.GetCount();
|
|
|
|
for (int i= 0; i < nCount; i++)
|
|
{
|
|
m_listIPAdd.DeleteString(i);
|
|
}
|
|
|
|
m_listIPAdd.ShowWindow(FALSE);
|
|
m_listIPAdd.ResetContent();
|
|
m_strArrayIPAdd.RemoveAll();
|
|
m_dwArrayIPAdd.RemoveAll();
|
|
|
|
SetRemoveButtonState();
|
|
|
|
SetDirty(FALSE);
|
|
}
|
|
}
|
|
// if static mapping properties are modified, we need to do this
|
|
else
|
|
{
|
|
// validate the data and copy to ActReg node
|
|
UpdateData();
|
|
|
|
SPITFSNode spNode;
|
|
spNode = GetHolder()->GetNode();
|
|
|
|
CActiveRegistrationsHandler *pActReg;
|
|
|
|
pActReg = GETHANDLER(CActiveRegistrationsHandler, spNode);
|
|
|
|
// clear the array of IP addresses maintained in the act reg handler
|
|
pActReg->m_strArrayStaticMappingIPAddress.RemoveAll();
|
|
pActReg->m_lArrayIPAddress.RemoveAll();
|
|
|
|
|
|
DWORD dwIp1, dwIp2, dwIp3, dwIp4;
|
|
int nAdd = m_ipControl.GetAddress(&dwIp1, &dwIp2, &dwIp3, &dwIp4);
|
|
|
|
if ( (m_strType.CompareNoCase(g_strStaticTypeUnique) == 0)|| (m_strType.CompareNoCase(g_strStaticTypeGroup) == 0))
|
|
{
|
|
if (nAdd != 4)
|
|
{
|
|
AfxMessageBox(IDS_ERR_INVALID_IP, MB_OK);
|
|
// set focus to the IP address control
|
|
m_editCustomIPAdd.SetFocus();
|
|
return hrFalse;
|
|
}
|
|
|
|
}
|
|
|
|
LONG lIPAdd = (LONG) MAKEIPADDRESS(dwIp1, dwIp2, dwIp3, dwIp4);
|
|
|
|
pActReg->m_strStaticMappingName = m_strName;
|
|
pActReg->m_strStaticMappingType = m_strType;
|
|
|
|
AssignMappingType();
|
|
|
|
pActReg->m_nStaticMappingType = m_fType;
|
|
|
|
|
|
if ( (m_strType.CompareNoCase(g_strStaticTypeUnique) == 0)|| (m_strType.CompareNoCase(g_strStaticTypeGroup) == 0))
|
|
{
|
|
pActReg->m_strArrayStaticMappingIPAddress.Add(m_strIPAdd);
|
|
pActReg->m_lArrayIPAddress.Add(lIPAdd);
|
|
}
|
|
// copy from the array
|
|
else
|
|
{
|
|
for (int i = 0; i < m_strArrayIPAdd.GetSize(); i++)
|
|
{
|
|
pActReg->m_strArrayStaticMappingIPAddress.Add(m_strArrayIPAdd.GetAt(i));
|
|
pActReg->m_lArrayIPAddress.Add(m_dwArrayIPAdd.GetAt(i));
|
|
}
|
|
}
|
|
|
|
// do the thread context switch so we can update the UI as well
|
|
bRet = CPropertyPageBase::OnApply();
|
|
|
|
if (bRet == FALSE)
|
|
{
|
|
// Something bad happened... grab the error code
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
::WinsMessageBox(GetHolder()->GetError());
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void
|
|
CStaticMappingProp::AssignMappingType()
|
|
{
|
|
if (m_strType.CompareNoCase(g_strStaticTypeInternetGroup) == 0)
|
|
m_fType = WINSINTF_E_SPEC_GROUP;
|
|
else
|
|
if (m_strType.CompareNoCase(g_strStaticTypeUnique) == 0)
|
|
m_fType = WINSINTF_E_UNIQUE;
|
|
else
|
|
if (m_strType.CompareNoCase(g_strStaticTypeMultihomed) == 0)
|
|
m_fType = WINSINTF_E_MULTIHOMED;
|
|
else
|
|
if (m_strType.CompareNoCase(g_strStaticTypeGroup) == 0)
|
|
m_fType = WINSINTF_E_NORM_GROUP;
|
|
else
|
|
if (m_strType.CompareNoCase(g_strStaticTypeDomainName)== 0)
|
|
m_fType = WINSINTF_E_SPEC_GROUP;
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::OnChangeIpAddress()
|
|
{
|
|
SetDirty(TRUE);
|
|
CString strText;
|
|
m_editCustomIPAdd.GetWindowText(strText);
|
|
|
|
if (strText.IsEmpty())
|
|
{
|
|
// disable the Add and Remove buttons
|
|
CWnd * pCurFocus = GetFocus();
|
|
|
|
if (m_buttonAdd.GetSafeHwnd() == pCurFocus->GetSafeHwnd() ||
|
|
m_buttonRemove.GetSafeHwnd() == pCurFocus->GetSafeHwnd())
|
|
{
|
|
m_editCustomIPAdd.SetFocus();
|
|
}
|
|
|
|
m_buttonAdd.EnableWindow(FALSE);
|
|
m_buttonRemove.EnableWindow(FALSE);
|
|
}
|
|
|
|
UpdateData();
|
|
|
|
DWORD dwIp1, dwIp2, dwIp3, dwIp4;
|
|
int nAdd = m_ipControl.GetAddress(&dwIp1, &dwIp2, &dwIp3, &dwIp4);
|
|
|
|
if (nAdd != 4)
|
|
{
|
|
CWnd * pCurFocus = GetFocus();
|
|
|
|
if (m_buttonAdd.GetSafeHwnd() == pCurFocus->GetSafeHwnd())
|
|
{
|
|
m_editCustomIPAdd.SetFocus();
|
|
}
|
|
|
|
m_buttonAdd.EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
m_buttonAdd.EnableWindow(TRUE);
|
|
}
|
|
|
|
SetRemoveButtonState();
|
|
}
|
|
|
|
|
|
BOOL
|
|
CStaticMappingProp::OnInitDialog()
|
|
{
|
|
// Initialize the IP address controls
|
|
m_ipControl.Create(m_hWnd, IDC_IPADD);
|
|
m_ipControl.SetFieldRange(0, 0, 255);
|
|
|
|
CPropertyPageBase::OnInitDialog();
|
|
|
|
// fill in the type strings
|
|
m_comboType.AddString(g_strStaticTypeUnique);
|
|
m_comboType.AddString(g_strStaticTypeGroup);
|
|
m_comboType.AddString(g_strStaticTypeDomainName);
|
|
m_comboType.AddString(g_strStaticTypeInternetGroup);
|
|
m_comboType.AddString(g_strStaticTypeMultihomed);
|
|
|
|
::SendMessage(::GetDlgItem(m_hWnd, IDC_EDIT_COMPNAME), EM_LIMITTEXT, MAX_PATH, 0);
|
|
|
|
if (((CStaticMappingProperties*)GetHolder())->m_bWizard)
|
|
{
|
|
// set control states for the wizard part
|
|
HWND hWndSheet = ((CStaticMappingProperties*)GetHolder())->GetSheetWindow();
|
|
CString strTitle;
|
|
|
|
strTitle.LoadString(IDS_CREATE_STATIC_MAPPING);
|
|
::SetWindowText(hWndSheet, strTitle);
|
|
|
|
SetDefaultControlStates();
|
|
m_editScopeName.SetReadOnly(FALSE);
|
|
|
|
m_comboType.SelectString(-1, g_strStaticTypeUnique);
|
|
}
|
|
else
|
|
{
|
|
m_editScopeName.SetReadOnly(TRUE);
|
|
m_buttonAdd.ShowWindow(FALSE);
|
|
m_buttonRemove.ShowWindow(FALSE);
|
|
m_listIPAdd.ShowWindow(FALSE);
|
|
|
|
SetRemoveButtonState();
|
|
|
|
// owner only visible in properties mode
|
|
WinsRecord ws = ((CStaticMappingProperties*)GetHolder())->m_wsRecord;
|
|
|
|
if (ws.dwOwner != INVALID_OWNER_ID)
|
|
{
|
|
CString strOwner;
|
|
MakeIPAddress(ws.dwOwner, strOwner);
|
|
GetDlgItem(IDC_EDIT_OWNER)->SetWindowText(strOwner);
|
|
}
|
|
|
|
FillControls();
|
|
}
|
|
|
|
// load the correct icon
|
|
for (int i = 0; i < ICON_IDX_MAX; i++)
|
|
{
|
|
if (g_uIconMap[i][1] == m_uImage)
|
|
{
|
|
HICON hIcon = LoadIcon(AfxGetResourceHandle(), MAKEINTRESOURCE(g_uIconMap[i][0]));
|
|
if (hIcon)
|
|
((CStatic *) GetDlgItem(IDC_STATIC_ICON))->SetIcon(hIcon);
|
|
break;
|
|
}
|
|
}
|
|
|
|
SetDirty(FALSE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
CStaticMappingProp::FillControls()
|
|
{
|
|
// get the actreg node
|
|
BOOL fHasScope = FALSE;
|
|
CActiveRegistrationsHandler * pActReg;
|
|
SPITFSNode spNode;
|
|
|
|
spNode = GetHolder()->GetNode();
|
|
pActReg = GETHANDLER(CActiveRegistrationsHandler, spNode);
|
|
|
|
WinsRecord ws = ((CStaticMappingProperties*)GetHolder())->m_wsRecord;
|
|
|
|
// name and the IP address ypu anyway fill. the reamining depending on
|
|
// whether it's a static or dynamic record
|
|
|
|
if (ws.dwNameLen > 16)
|
|
{
|
|
fHasScope = TRUE;
|
|
}
|
|
|
|
// build the name string
|
|
CString strName, strScopeName;
|
|
pActReg->CleanNetBIOSName(ws.szRecordName,
|
|
strName,
|
|
TRUE, // Expand
|
|
TRUE, // Truncate
|
|
pActReg->IsLanManCompatible(),
|
|
TRUE, // name is OEM
|
|
FALSE, // No double backslash
|
|
ws.dwNameLen);
|
|
|
|
// check if it has a scope name attached to it., looking for a period
|
|
if (fHasScope)
|
|
{
|
|
LPSTR pScope = &ws.szRecordName[17];
|
|
|
|
// INTL$ should this be OEMCP, not ACP
|
|
MBCSToWide(pScope, strScopeName, WINS_NAME_CODE_PAGE);
|
|
|
|
int nPos = strName.Find(strScopeName);
|
|
// means that the scope name is attached
|
|
if ( (nPos != -1) &&
|
|
(!strScopeName.IsEmpty()) )
|
|
{
|
|
// all we want here is the name
|
|
strName = strName.Left(nPos - 1);
|
|
}
|
|
}
|
|
|
|
m_strName = strName;
|
|
m_strScopeName = strScopeName;
|
|
|
|
// IP address
|
|
CString strIP;
|
|
|
|
if (ws.dwState & WINSDB_REC_UNIQUE || ws.dwState & WINSDB_REC_NORM_GROUP)
|
|
{
|
|
for (DWORD i = 0; i < ws.dwNoOfAddrs; i++)
|
|
{
|
|
MakeIPAddress(ws.dwIpAdd[i], strIP);
|
|
m_strArrayIPAdd.Add(strIP);
|
|
m_dwArrayIPAdd.Add(ws.dwIpAdd[i]);
|
|
}
|
|
}
|
|
// in this case the first IP address is that of the owner,
|
|
else
|
|
{
|
|
DWORD dwPos = 1;
|
|
|
|
for (DWORD i = 0; i < ws.dwNoOfAddrs/2; ++i)
|
|
{
|
|
::MakeIPAddress(ws.dwIpAdd[dwPos], strIP);
|
|
m_strArrayIPAdd.Add(strIP);
|
|
m_dwArrayIPAdd.Add(ws.dwIpAdd[dwPos]);
|
|
++dwPos;
|
|
++dwPos;
|
|
}
|
|
}
|
|
|
|
// text in the controls now
|
|
m_editName.SetWindowText(m_strName);
|
|
m_editScopeName.SetWindowText(m_strScopeName);
|
|
|
|
//check if the record is static
|
|
if (ws.dwState & WINSDB_REC_STATIC)
|
|
{
|
|
// active status
|
|
CString strStaticType;
|
|
pActReg->GetStaticTypeString(ws.dwState, strStaticType);
|
|
|
|
if (strStaticType.CompareNoCase(g_strStaticTypeDomainName) == 0)
|
|
{
|
|
//could be either Internet Group or Domain Name
|
|
// check for the 15th character , if 1C, then Domain Name
|
|
// else Internet Group Name
|
|
|
|
if ((BYTE)ws.szRecordName[15] == 0x1C)
|
|
strStaticType = g_strStaticTypeDomainName;
|
|
else
|
|
strStaticType = g_strStaticTypeInternetGroup;
|
|
}
|
|
|
|
FillStaticRecData(strStaticType);
|
|
|
|
//m_fStaticPropChanged = TRUE;
|
|
m_strType = strStaticType;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::FillStaticRecData(CString& strType)
|
|
{
|
|
// hide the combobox too, show the IPAdd control
|
|
m_editCustomIPAdd.ShowWindow(TRUE);
|
|
|
|
// display the combobox
|
|
m_comboType.ShowWindow(TRUE);
|
|
|
|
// disable thew type combobox
|
|
m_comboType.EnableWindow(FALSE);
|
|
|
|
// get the type of record
|
|
m_comboType.SelectString(-1, strType);
|
|
|
|
// make the records read only.
|
|
m_editName.SetReadOnly();
|
|
|
|
// depending on the type, hide/show the list control
|
|
// and the add remove buttons.
|
|
if ( (strType.CompareNoCase(g_strStaticTypeUnique) == 0) || strType.CompareNoCase(g_strStaticTypeGroup) == 0)
|
|
{
|
|
m_listIPAdd.ShowWindow(FALSE);
|
|
m_buttonAdd.ShowWindow(FALSE);
|
|
m_buttonRemove.ShowWindow(FALSE);
|
|
|
|
m_editCustomIPAdd.ShowWindow(TRUE);
|
|
m_editCustomIPAdd.SetReadOnly(FALSE);
|
|
|
|
// set it's text to that in the combo box
|
|
CString strIP;
|
|
strIP = m_strArrayIPAdd.GetAt(0);
|
|
|
|
m_strOnInitIPAdd = strIP;
|
|
|
|
m_ipControl.SetAddress(strIP);
|
|
}
|
|
else
|
|
{
|
|
m_listIPAdd.ShowWindow(TRUE);
|
|
m_buttonAdd.ShowWindow(TRUE);
|
|
m_buttonRemove.ShowWindow(TRUE);
|
|
|
|
m_editCustomIPAdd.ShowWindow(TRUE);
|
|
m_editCustomIPAdd.SetReadOnly(FALSE);
|
|
|
|
// fill the contents with that from the combo box
|
|
FillList();
|
|
|
|
if (m_strArrayIPAdd.GetSize() > 0)
|
|
m_strOnInitIPAdd = m_strArrayIPAdd.GetAt(0);
|
|
}
|
|
|
|
SetRemoveButtonState();
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::FillList()
|
|
{
|
|
CString strIP;
|
|
|
|
// clear the list box next
|
|
for (int i = 0; i < m_listIPAdd.GetCount(); i++)
|
|
m_listIPAdd.DeleteString(i);
|
|
|
|
int nCount = (int) m_strArrayIPAdd.GetSize();
|
|
|
|
for (i = 0; i < nCount; i++)
|
|
{
|
|
strIP = m_strArrayIPAdd.GetAt(i);
|
|
|
|
m_listIPAdd.AddString(strIP);
|
|
|
|
if (nCount == 1)
|
|
m_ipControl.SetAddress(strIP);
|
|
}
|
|
|
|
m_ipControl.SetAddress(_T(""));
|
|
m_editCustomIPAdd.SetWindowText(_T(""));
|
|
|
|
SetRemoveButtonState();
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::FillDynamicRecData(CString& strType, CString& strActive, CString& strExpiration, CString& strVersion)
|
|
{
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::SetDefaultControlStates()
|
|
{
|
|
m_comboType.EnableWindow(TRUE);
|
|
m_comboType.ShowWindow(TRUE);
|
|
|
|
m_editCustomIPAdd.ShowWindow(TRUE);
|
|
|
|
SetRemoveButtonState();
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::OnButtonAdd()
|
|
{
|
|
UpdateData();
|
|
|
|
// add the IPAdd in the IPControl to the list box
|
|
// if valid
|
|
|
|
// check if broadcast address is being added
|
|
if (m_strIPAdd.CompareNoCase(_T("255.255.255.255")) == 0)
|
|
{
|
|
AfxMessageBox(IDS_INVALID_IPADDRESS, MB_OK);
|
|
m_editCustomIPAdd.SetFocus();
|
|
return;
|
|
}
|
|
|
|
DWORD dwIp1, dwIp2, dwIp3, dwIp4;
|
|
int nAdd = m_ipControl.GetAddress(&dwIp1, &dwIp2, &dwIp3, &dwIp4);
|
|
|
|
// check if the address is alreay in the list
|
|
for (int i = 0; i < m_strArrayIPAdd.GetSize() ; i++)
|
|
{
|
|
if (m_strArrayIPAdd[i].CompareNoCase(m_strIPAdd) == 0)
|
|
{
|
|
AfxMessageBox(IDS_ERR_IP_EXISTS, MB_OK);
|
|
m_editCustomIPAdd.SetFocus();
|
|
m_editCustomIPAdd.SetSel(0,-1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (m_dwArrayIPAdd.GetSize() == WINSINTF_MAX_MEM)
|
|
{
|
|
// cannot add any more addresses
|
|
AfxMessageBox(IDS_ERR_TOOMANY_IP);
|
|
return;
|
|
}
|
|
|
|
LONG lIPAdd = (LONG) MAKEIPADDRESS(dwIp1, dwIp2, dwIp3, dwIp4);
|
|
|
|
// add to the list
|
|
m_listIPAdd.AddString(m_strIPAdd);
|
|
m_strArrayIPAdd.Add(m_strIPAdd);
|
|
m_dwArrayIPAdd.Add(lIPAdd);
|
|
|
|
//m_fStaticPropChanged = TRUE;
|
|
|
|
m_editCustomIPAdd.SetWindowText(_T(""));
|
|
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void
|
|
CStaticMappingProp::OnButtonRemove()
|
|
{
|
|
SPITFSNode spNode;
|
|
spNode = GetHolder()->GetNode();
|
|
|
|
CActiveRegistrationsHandler* pActReg;
|
|
|
|
pActReg = GETHANDLER(CActiveRegistrationsHandler, spNode);
|
|
|
|
// remove from the list
|
|
int nSel = m_listIPAdd.GetCurSel();
|
|
CString strSel;
|
|
|
|
if (nSel != -1)
|
|
{
|
|
m_listIPAdd.GetText(nSel, strSel);
|
|
m_listIPAdd.DeleteString(nSel);
|
|
}
|
|
|
|
// set the IP address in the IP Control
|
|
m_ipControl.SetAddress(strSel);
|
|
|
|
UpdateData();
|
|
|
|
// delete from the CStringArray
|
|
for (int i = 0; i < m_strArrayIPAdd.GetSize(); i++)
|
|
{
|
|
if (strSel == m_strArrayIPAdd.GetAt(i))
|
|
{
|
|
m_strArrayIPAdd.RemoveAt(i);
|
|
m_dwArrayIPAdd.RemoveAt(i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// set the focus to the IP address control
|
|
m_editCustomIPAdd.SetFocus();
|
|
|
|
//m_fStaticPropChanged = TRUE;
|
|
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
|
|
void
|
|
CStaticMappingProp::OnSelchangeComboType()
|
|
{
|
|
SetDirty(TRUE);
|
|
|
|
if (m_comboType.GetCurSel() == 2 || m_comboType.GetCurSel() == 3 || m_comboType.GetCurSel() == 4)
|
|
{
|
|
// show the list control and the add and the remove buttons
|
|
m_buttonAdd.ShowWindow(TRUE);
|
|
m_buttonRemove.ShowWindow(TRUE);
|
|
m_listIPAdd.ShowWindow(TRUE);
|
|
}
|
|
// hide them
|
|
else
|
|
{
|
|
m_buttonAdd.ShowWindow(FALSE);
|
|
m_buttonRemove.ShowWindow(FALSE);
|
|
m_listIPAdd.ShowWindow(FALSE);
|
|
}
|
|
SetRemoveButtonState();
|
|
}
|
|
|
|
void CStaticMappingProp::OnChangeEditCompname()
|
|
{
|
|
SetDirty(TRUE);
|
|
}
|
|
|
|
void
|
|
CStaticMappingProp::SetRemoveButtonState()
|
|
{
|
|
UpdateData();
|
|
|
|
if (m_listIPAdd.GetCurSel() == -1)
|
|
{
|
|
CWnd * pCurFocus = GetFocus();
|
|
|
|
if (m_buttonRemove.GetSafeHwnd() == pCurFocus->GetSafeHwnd())
|
|
{
|
|
m_editCustomIPAdd.SetFocus();
|
|
}
|
|
|
|
m_buttonRemove.EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
m_buttonRemove.EnableWindow(TRUE);
|
|
}
|
|
|
|
DWORD dwIp1, dwIp2, dwIp3, dwIp4;
|
|
int nAdd = m_ipControl.GetAddress(&dwIp1, &dwIp2, &dwIp3, &dwIp4);
|
|
|
|
if (nAdd != 4)
|
|
{
|
|
CWnd * pCurFocus = GetFocus();
|
|
|
|
if (m_buttonAdd.GetSafeHwnd() == pCurFocus->GetSafeHwnd())
|
|
{
|
|
m_editCustomIPAdd.SetFocus();
|
|
}
|
|
|
|
m_buttonAdd.EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
m_buttonAdd.EnableWindow(TRUE);
|
|
|
|
}
|
|
}
|
|
|
|
void
|
|
CStaticMappingProp::OnSelChangeListIpAdd()
|
|
{
|
|
SetRemoveButtonState();
|
|
}
|
|
|
|
BOOL
|
|
CStaticMappingProp::OnPropertyChange(BOOL bScope, LONG_PTR *ChangeMask)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
HRESULT hr = hrOK;
|
|
SPITFSComponent spComponent;
|
|
SPITFSNode spNode;
|
|
|
|
spNode = GetHolder()->GetNode();
|
|
CActiveRegistrationsHandler * pActReg = GETHANDLER(CActiveRegistrationsHandler, spNode);
|
|
|
|
if (((CStaticMappingProperties*)GetHolder())->m_bWizard)
|
|
{
|
|
hr = pActReg->AddMapping(spNode);
|
|
if (FAILED(hr))
|
|
{
|
|
GetHolder()->SetError(WIN32_FROM_HRESULT(hr));
|
|
}
|
|
else
|
|
{
|
|
*ChangeMask = RESULT_PANE_CHANGE_ITEM_DATA;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
((CStaticMappingProperties *) GetHolder())->GetComponent(&spComponent);
|
|
|
|
DWORD dwErr = pActReg->EditMapping(spNode, spComponent, pActReg->m_nSelectedIndex);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
GetHolder()->SetError(dwErr);
|
|
}
|
|
else
|
|
{
|
|
*ChangeMask = RESULT_PANE_CHANGE_ITEM_DATA;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
CStaticMappingProperties::CStaticMappingProperties
|
|
(
|
|
ITFSNode * pNode,
|
|
IComponent * pComponent,
|
|
LPCTSTR pszSheetName,
|
|
WinsRecord * pwRecord,
|
|
BOOL bWizard
|
|
) : CPropertyPageHolderBase(pNode, pComponent, pszSheetName), m_bWizard(bWizard)
|
|
{
|
|
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
|
|
m_bTheme = TRUE;
|
|
|
|
InitPage(bWizard);
|
|
|
|
AddPageToList((CPropertyPageBase*) m_ppageGeneral);
|
|
|
|
Init(pwRecord);
|
|
}
|
|
|
|
CStaticMappingProperties::CStaticMappingProperties
|
|
(
|
|
ITFSNode * pNode,
|
|
IComponentData * pComponentData,
|
|
LPCTSTR pszSheetName,
|
|
WinsRecord * pwRecord,
|
|
BOOL bWizard
|
|
) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName), m_bWizard(bWizard)
|
|
{
|
|
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
|
|
m_bTheme = TRUE;
|
|
|
|
InitPage(bWizard);
|
|
|
|
AddPageToList((CPropertyPageBase*) m_ppageGeneral);
|
|
|
|
Init(pwRecord);
|
|
}
|
|
|
|
CStaticMappingProperties::~CStaticMappingProperties()
|
|
{
|
|
RemovePageFromList((CPropertyPageBase*) m_ppageGeneral, FALSE);
|
|
|
|
delete m_ppageGeneral;
|
|
m_ppageGeneral = NULL;
|
|
}
|
|
|
|
void
|
|
CStaticMappingProperties::InitPage(BOOL fWizard)
|
|
{
|
|
if (fWizard)
|
|
{
|
|
m_ppageGeneral = new CStaticMappingProp(IDD_STATIC_MAPPING_WIZARD);
|
|
}
|
|
else
|
|
{
|
|
m_ppageGeneral = new CStaticMappingProp(IDD_STATIC_MAPPING_PROPERTIES);
|
|
}
|
|
}
|
|
|
|
void
|
|
CStaticMappingProperties::Init(WinsRecord * pwRecord)
|
|
{
|
|
if (pwRecord)
|
|
{
|
|
strcpy(m_wsRecord.szRecordName , pwRecord->szRecordName);
|
|
m_wsRecord.dwExpiration = pwRecord->dwExpiration;
|
|
m_wsRecord.dwExpiration = pwRecord->dwExpiration;
|
|
m_wsRecord.dwNoOfAddrs = pwRecord->dwNoOfAddrs;
|
|
|
|
for (DWORD i = 0; i < pwRecord->dwNoOfAddrs; i++)
|
|
{
|
|
m_wsRecord.dwIpAdd[i] = pwRecord->dwIpAdd[i];
|
|
}
|
|
|
|
m_wsRecord.liVersion = pwRecord->liVersion;
|
|
m_wsRecord.dwNameLen = pwRecord->dwNameLen;
|
|
m_wsRecord.dwOwner = pwRecord->dwOwner;
|
|
m_wsRecord.dwState = pwRecord->dwState;
|
|
m_wsRecord.dwType = pwRecord->dwType;
|
|
}
|
|
}
|
|
|
|
HRESULT
|
|
CStaticMappingProperties::SetComponent(ITFSComponent * pComponent)
|
|
{
|
|
m_spTFSComponent.Set(pComponent);
|
|
|
|
return hrOK;
|
|
}
|
|
|
|
HRESULT
|
|
CStaticMappingProperties::GetComponent(ITFSComponent ** ppComponent)
|
|
{
|
|
if (ppComponent)
|
|
{
|
|
*ppComponent = m_spTFSComponent;
|
|
m_spTFSComponent->AddRef();
|
|
}
|
|
|
|
return hrOK;
|
|
}
|