able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/dnsmgr/recpag2.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2660 lines
68 KiB
C++
Raw Blame History

//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1998 - 1999
//
// File: recpag2.cpp
//
//--------------------------------------------------------------------------
#include "preDNSsn.h"
#include <SnapBase.h>
#include "resource.h"
#include "dnsutil.h"
#include "DNSSnap.h"
#include "snapdata.h"
#include "server.h"
#include "domain.h"
#include "record.h"
#include "zone.h"
#ifdef DEBUG_ALLOCATOR
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#endif
////////////////////////////////////////////////////////////////////////////
// CDNS_A_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_A_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_IPEDIT, OnIPv4CtrlChange)
ON_BN_CLICKED(IDC_UPDATE_PRT_CHECK, OnCreatePointerClicked)
END_MESSAGE_MAP()
CDNS_A_RecordPropertyPage::CDNS_A_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_A)
{
}
BOOL CDNS_A_RecordPropertyPage::OnInitDialog()
{
CDNSRecordStandardPropertyPage::OnInitDialog();
STANDARD_REC_PP_PTRS(CDNS_A_Record);
CDNSServerNode* pServerNode = pHolder->GetDomainNode()->GetZoneNode()->GetServerNode();
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER_NEW_SECURITY_SETTINGS ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER) ||
!pHolder->IsWizardMode())
{
GetSecurityCheckCtrl()->ShowWindow(FALSE);
GetSecurityCheckCtrl()->EnableWindow(FALSE);
}
return FALSE;
}
void CDNS_A_RecordPropertyPage::OnIPv4CtrlChange()
{
STANDARD_REC_PP_PTRS(CDNS_A_Record)
SetDirty(TRUE);
}
void CDNS_A_RecordPropertyPage::OnCreatePointerClicked()
{
STANDARD_REC_PP_PTRS(CDNS_A_Record)
SetDirty(TRUE);
}
void CDNS_A_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_A_Record);
GetIPv4Ctrl()->SetIPv4Val(pRecord->m_ipAddress);
CDNSRootData* pRootData = dynamic_cast<CDNSRootData*>(GetHolder()->GetComponentData()->GetRootData());
if (pRootData != NULL)
{
GetPTRCheckCtrl()->SetCheck(pRootData->GetCreatePTRWithHost());
}
}
DNS_STATUS CDNS_A_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_A_Record);
GetIPv4Ctrl()->GetIPv4Val(&(pRecord->m_ipAddress));
if (GetPTRCheckCtrl()->GetCheck())
{
pRecord->m_dwFlags |= DNS_RPC_RECORD_FLAG_CREATE_PTR;
}
if (pHolder->IsWizardMode() &&
GetSecurityCheckCtrl()->GetCheck())
{
pRecord->m_dwFlags |= DNS_RPC_FLAG_OPEN_ACL;
}
CDNSRootData* pRootData = dynamic_cast<CDNSRootData*>(GetHolder()->GetComponentData()->GetRootData());
if (pRootData != NULL)
{
pRootData->SetCreatePTRWithHost(GetPTRCheckCtrl()->GetCheck());
}
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_ATMA_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_ATMA_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_EDIT_ATMA_ADDRESS, OnAddressChange)
ON_BN_CLICKED(IDC_RADIO_E164, OnFormatRadioChange)
ON_BN_CLICKED(IDC_RADIO_NSAP, OnFormatRadioChange)
END_MESSAGE_MAP()
CDNS_ATMA_RecordPropertyPage::CDNS_ATMA_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_ATMA)
{
}
UCHAR CDNS_ATMA_RecordPropertyPage::GetFormat()
{
if (GetRadioNSAP()->GetCheck())
return DNS_ATMA_FORMAT_AESA;
ASSERT(GetRadioE164()->GetCheck());
return DNS_ATMA_FORMAT_E164;
}
void CDNS_ATMA_RecordPropertyPage::SetFormat(UCHAR chFormat)
{
GetRadioNSAP()->SetCheck(chFormat == DNS_ATMA_FORMAT_AESA);
GetRadioE164()->SetCheck(chFormat == DNS_ATMA_FORMAT_E164);
}
void _StripDots(CString& s)
{
int nLen = s.GetLength();
if (nLen == 0)
return;
WCHAR* pBuf = (WCHAR*)malloc((nLen+1)*sizeof(WCHAR));
if (!pBuf)
{
return;
}
ZeroMemory(pBuf, (nLen+1)*sizeof(WCHAR));
int k=0;
for (int i=0; i<nLen; i++)
{
if (s[i] != L'.')
{
pBuf[k++] = s[i];
}
}
s = pBuf;
if (pBuf)
{
free(pBuf);
pBuf = 0;
}
}
void CDNS_ATMA_RecordPropertyPage::OnAddressChange()
{
BOOL bValid = TRUE;
UCHAR chFormat = GetFormat();
CString s;
GetAddressCtrl()->GetWindowText(s);
_StripDots(s);
int nLen = s.GetLength();
if (chFormat == DNS_ATMA_FORMAT_E164)
{
//it is a string
bValid = (nLen <= DNS_ATMA_MAX_ADDR_LENGTH);
if (bValid)
{
// check only numeric digits
for (int i=0; i<nLen; i++)
{
if (iswdigit(s[i]) == 0)
{
bValid = FALSE;
break;
}
}
}
}
else
{
// must be of fixed length
bValid = (nLen == 2*DNS_ATMA_MAX_ADDR_LENGTH);
if (bValid)
{
// check only hex digits
for (int i=0; i<nLen; i++)
{
if (HexCharToByte(s[i]) == 0xFF)
{
bValid = FALSE;
break;
}
}
}
}
SetValidState(bValid);
}
void CDNS_ATMA_RecordPropertyPage::OnFormatRadioChange()
{
// reset the address, we changed format
GetAddressCtrl()->SetWindowText(NULL);
// it is OK th have E164 with empty field, but not NSAP
SetValidState(GetFormat() == DNS_ATMA_FORMAT_E164);
}
void CDNS_ATMA_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_ATMA_Record);
SetFormat(pRecord->m_chFormat);
GetAddressCtrl()->SetWindowText(pRecord->m_szAddress);
}
DNS_STATUS CDNS_ATMA_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_ATMA_Record);
pRecord->m_chFormat = GetFormat();
GetAddressCtrl()->GetWindowText(pRecord->m_szAddress);
_StripDots(pRecord->m_szAddress);
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_AAAA_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_AAAA_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_IPV6EDIT, OnIPv6CtrlChange)
END_MESSAGE_MAP()
CDNS_AAAA_RecordPropertyPage::CDNS_AAAA_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_AAAA)
{
}
void CDNS_AAAA_RecordPropertyPage::OnIPv6CtrlChange()
{
SetDirty(TRUE);
}
BOOL
CDNS_AAAA_RecordPropertyPage::OnInitDialog()
{
CDNSRecordStandardPropertyPage::OnInitDialog();
GetRRNameEdit()->SetLimitText(IP6_ADDRESS_STRING_BUFFER_LENGTH);
return TRUE;
}
void CDNS_AAAA_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_AAAA_Record);
// convert the address into it's string represenation
WCHAR buf[IP6_ADDRESS_STRING_BUFFER_LENGTH + 1];
::ZeroMemory(buf, sizeof buf);
Dns_Ip6AddressToString_W(buf, &pRecord->m_ipv6Address);
GetIPv6Edit()->SetWindowText(buf);
}
DNS_STATUS CDNS_AAAA_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_AAAA_Record);
// convert the string representation to the address
::ZeroMemory(&pRecord->m_ipv6Address, sizeof pRecord->m_ipv6Address);
CString text;
GetIPv6Edit()->GetWindowText(text);
BOOL successful =
Dns_Ip6StringToAddress_W(
&pRecord->m_ipv6Address,
(PWSTR) (PCWSTR) text);
if (!successful)
{
// the string is not valid. Complain to the user. Setting dwErr
// will cause CreateRecord to silently skip the attempt to create
// the record.
dwErr = DNS_ERROR_INVALID_IP_ADDRESS;
if (!bSilent)
{
::DNSMessageBox(IDS_ERRMSG_BAD_IPV6_TEXT);
}
}
return dwErr;
}
BOOL
CDNS_AAAA_RecordPropertyPage::CreateRecord()
{
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
ASSERT(pHolder->IsWizardMode());
//
// Get the data from the UI
//
DNS_STATUS err = GetUIDataEx(FALSE);
if (err != 0)
{
// the error message was already raised by GetUIDataEx
return FALSE;
}
//
// Create the new record
//
err = pHolder->CreateNewRecord(CanCreateDuplicateRecords());
if (err != 0)
{
DNSErrorDialog(err,IDS_MSG_RECORD_CREATE_FAILED);
return FALSE;
}
return TRUE;
}
BOOL
CDNS_AAAA_RecordPropertyPage::OnApply()
{
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
if(pHolder->IsWizardMode())
{
//
// this is the case of record creation,
// the user hit OK and we want to create the record
//
return CreateRecord();
}
//
// we are in the case of modeless sheet on existing record
//
CDNSRecordNodeBase* pRecordNode = pHolder->GetRecordNode();
ASSERT(pRecordNode != NULL);
DWORD dwZoneType = pRecordNode->GetDomainNode()->GetZoneNode()->GetZoneType();
if ((dwZoneType == DNS_ZONE_TYPE_SECONDARY) ||
(dwZoneType == DNS_ZONE_TYPE_STUB) ||
(dwZoneType == DNS_ZONE_TYPE_CACHE))
{
// read only case
return TRUE;
}
DNS_STATUS err = GetUIDataEx(FALSE);
if (err != 0)
{
// the error message was already raised by GetUIDataEx
return FALSE;
}
if (!IsDirty())
{
return TRUE;
}
err = pHolder->NotifyConsole(this);
if (err == DNS_WARNING_PTR_CREATE_FAILED)
{
DNSMessageBox(IDS_MSG_RECORD_WARNING_CREATE_PTR);
err = 0; // was just a warning
}
if (err != 0)
{
DNSErrorDialog(err,IDS_MSG_RECORD_UPDATE_FAILED);
return FALSE;
}
else
{
SetDirty(FALSE);
}
return TRUE; // all is cool
}
////////////////////////////////////////////////////////////////////////////
// CDNS_HINFO_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_HINFO_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_CPU_TYPE_EDIT, OnCPUTypeChange)
ON_EN_CHANGE(IDC_OPERATING_SYSTEM_EDIT, OnOperatingSystemChange)
END_MESSAGE_MAP()
CDNS_HINFO_RecordPropertyPage::CDNS_HINFO_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_HINFO)
{
}
BOOL CDNS_HINFO_RecordPropertyPage::OnInitDialog()
{
CDNSRecordStandardPropertyPage::OnInitDialog();
//
// The RDATA size field is a byte so we have to limit the size of the string
// to 253 characters (add one for the trailing NULL character)
//
GetCPUTypeCtrl()->SetLimitText(253);
GetOperatingSystemCtrl()->SetLimitText(253);
return TRUE;
}
void CDNS_HINFO_RecordPropertyPage::OnCPUTypeChange()
{
SetDirty((GetCPUTypeCtrl()->GetWindowTextLength() > 0) &&
(GetOperatingSystemCtrl()->GetWindowTextLength() > 0));
}
void CDNS_HINFO_RecordPropertyPage::OnOperatingSystemChange()
{
SetDirty((GetCPUTypeCtrl()->GetWindowTextLength() > 0) &&
(GetOperatingSystemCtrl()->GetWindowTextLength() > 0));
}
void CDNS_HINFO_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_HINFO_Record);
GetCPUTypeCtrl()->SetWindowText(pRecord->m_szCPUType);
GetOperatingSystemCtrl()->SetWindowText(pRecord->m_szOperatingSystem);
}
DNS_STATUS CDNS_HINFO_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_HINFO_Record);
GetCPUTypeCtrl()->GetWindowText(pRecord->m_szCPUType);
GetOperatingSystemCtrl()->GetWindowText(pRecord->m_szOperatingSystem);
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_ISDN_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_ISDN_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_PHONE_NUM_AND_DDI_EDIT, OnPhoneNumberAndDDIChange)
ON_EN_CHANGE(IDC_SUBADDRESS_EDIT, OnSubAddressChange)
END_MESSAGE_MAP()
CDNS_ISDN_RecordPropertyPage::CDNS_ISDN_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_ISDN)
{
}
void CDNS_ISDN_RecordPropertyPage::OnPhoneNumberAndDDIChange()
{
SetDirty(TRUE);
}
void CDNS_ISDN_RecordPropertyPage::OnSubAddressChange()
{
SetDirty(TRUE);
}
void CDNS_ISDN_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_ISDN_Record);
GetPhoneNumberAndDDICtrl()->SetWindowText(pRecord->m_szPhoneNumberAndDDI);
GetSubAddressCtrl()->SetWindowText(pRecord->m_szSubAddress);
}
DNS_STATUS CDNS_ISDN_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_ISDN_Record);
GetPhoneNumberAndDDICtrl()->GetWindowText(pRecord->m_szPhoneNumberAndDDI);
GetSubAddressCtrl()->GetWindowText(pRecord->m_szSubAddress);
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_X25_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_X25_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_X121_ADDRESS_EDIT, OnX121PSDNAddressChange)
END_MESSAGE_MAP()
CDNS_X25_RecordPropertyPage::CDNS_X25_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_X25)
{
}
BOOL CDNS_X25_RecordPropertyPage::OnInitDialog()
{
CDNSRecordStandardPropertyPage::OnInitDialog();
GetX121Edit()->SetLimitText(MAX_DNS_NAME_LEN);
return TRUE;
}
void CDNS_X25_RecordPropertyPage::OnX121PSDNAddressChange()
{
SetDirty(TRUE);
}
void CDNS_X25_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_X25_Record);
GetX121Edit()->SetWindowText(pRecord->m_szX121PSDNAddress);
}
DNS_STATUS CDNS_X25_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_X25_Record);
//
// Retrieve the text
//
CString szName;
GetX121Edit()->GetWindowText(szName);
CDNSZoneNode* pZone = pHolder->GetDomainNode()->GetZoneNode();
ASSERT(pZone != NULL);
//
// Any values are allowed for the data in advanced view
//
if (!(((CDNSRootData*)pZone->GetRootContainer()))->IsAdvancedView())
{
//
// Validate the record name using the server flags as a guideline
//
CString szFullName;
szFullName.Format(L"%s.%s", szName, pHolder->GetDomainNode()->GetFullName());
DWORD dwNameChecking = pZone->GetServerNode()->GetNameCheckFlag();
dwErr = ValidateRecordName(szFullName, dwNameChecking);
}
// Set the valid text
pRecord->m_szX121PSDNAddress = szName;
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_NAME_NODE_EDIT, OnNameNodeChange)
ON_BN_CLICKED(IDC_BROWSE_BUTTON, OnBrowse)
END_MESSAGE_MAP()
CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::
CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(UINT nIDTemplate) :
CDNSRecordStandardPropertyPage(nIDTemplate)
{
}
BOOL CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::OnInitDialog()
{
CDNSRecordStandardPropertyPage::OnInitDialog();
STANDARD_REC_PP_PTRS(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
GetNameNodeEdit()->SetLimitText(MAX_DNS_NAME_LEN);
return TRUE;
}
void CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::OnNameNodeChange()
{
STANDARD_REC_PP_PTRS(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
CString szNewName;
GetNameNodeEdit()->GetWindowText(szNewName);
CDNSServerNode* pServerNode = pHolder->GetDomainNode()->GetServerNode();
BOOL bIsValidName = TRUE;
// Only validate the name if it is not advanced view
if (!(((CDNSRootData*)pServerNode->GetRootContainer()))->IsAdvancedView())
{
DWORD dwNameChecking = pServerNode->GetNameCheckFlag();
bIsValidName = (0 == ValidateDnsNameAgainstServerFlags(szNewName,
DnsNameDomain,
dwNameChecking));
}
SetValidState(bIsValidName);
}
void CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::OnBrowse()
{
STANDARD_REC_PP_PTRS(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
FIX_THREAD_STATE_MFC_BUG();
CDNSBrowserDlg dlg(GetHolder()->GetComponentData(), GetHolder(),
(pRecord->GetType() == DNS_TYPE_CNAME) ? RECORD_A_AND_CNAME : RECORD_A);
if (IDOK == dlg.DoModal())
{
GetNameNodeEdit()->SetWindowText(dlg.GetSelectionString());
}
}
void CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
GetNameNodeEdit()->SetWindowText(pRecord->m_szNameNode);
}
DNS_STATUS CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
//
// Retrieve the text
//
CString szName;
GetNameNodeEdit()->GetWindowText(szName);
CDNSZoneNode* pZone = pHolder->GetDomainNode()->GetZoneNode();
ASSERT(pZone != NULL);
//
// Set the valid text, no need to validate the data field
//
pRecord->m_szNameNode = szName;
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_CNAME_RecordPropertyPage
CDNS_CNAME_RecordPropertyPage::CDNS_CNAME_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_CNAME)
{
}
BOOL CDNS_CNAME_RecordPropertyPage::OnInitDialog()
{
CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::OnInitDialog();
STANDARD_REC_PP_PTRS(CDNS_CNAME_Record);
CDNSServerNode* pServerNode = pHolder->GetDomainNode()->GetZoneNode()->GetServerNode();
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER_NEW_SECURITY_SETTINGS ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER) ||
!pHolder->IsWizardMode())
{
GetSecurityCheckCtrl()->ShowWindow(FALSE);
GetSecurityCheckCtrl()->EnableWindow(FALSE);
}
return FALSE;
}
DNS_STATUS CDNS_CNAME_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
DNS_STATUS dwErr = CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::GetUIDataEx(bSilent);
STANDARD_REC_PP_PTRS(CDNS_CNAME_Record);
if (pHolder->IsWizardMode() &&
GetSecurityCheckCtrl()->GetCheck())
{
pRecord->m_dwFlags |= DNS_RPC_FLAG_OPEN_ACL;
}
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MB_RecordPropertyPage
CDNS_MB_RecordPropertyPage::CDNS_MB_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_MB)
{
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MD_RecordPropertyPage
CDNS_MD_RecordPropertyPage::CDNS_MD_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_MD)
{
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MF_RecordPropertyPage
CDNS_MF_RecordPropertyPage::CDNS_MF_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_MF)
{
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MG_RecordPropertyPage
CDNS_MG_RecordPropertyPage::CDNS_MG_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_MG)
{
}
BEGIN_MESSAGE_MAP(CDNS_MG_RecordPropertyPage, CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage)
ON_BN_CLICKED(IDC_BROWSE_BUTTON, OnBrowse)
END_MESSAGE_MAP()
void CDNS_MG_RecordPropertyPage::OnBrowse()
{
STANDARD_REC_PP_PTRS(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
FIX_THREAD_STATE_MFC_BUG();
CDNSBrowserDlg dlg(GetHolder()->GetComponentData(), GetHolder(), RECORD_MB);
if (IDOK == dlg.DoModal())
{
GetNameNodeEdit()->SetWindowText(dlg.GetSelectionString());
}
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MR_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_MR_RecordPropertyPage, CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage)
ON_EN_CHANGE(IDC_NAME_NODE_EDIT, OnNameNodeChange)
ON_BN_CLICKED(IDC_BROWSE_BUTTON, OnBrowse)
END_MESSAGE_MAP()
CDNS_MR_RecordPropertyPage::CDNS_MR_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_MR)
{
}
void CDNS_MR_RecordPropertyPage::OnNameNodeChange()
{
//
// Get the name from the data
//
CString szNameNode;
GetNameNodeEdit()->GetWindowText(szNameNode);
//
// Get the new name of the record
//
CString szRecordName;
GetEditBoxText(szRecordName);
SetValidState(GetNameNodeEdit()->GetWindowTextLength() > 0 &&
_wcsicmp(szNameNode, szRecordName) != 0);
}
void CDNS_MR_RecordPropertyPage::OnBrowse()
{
STANDARD_REC_PP_PTRS(CDNS_PTR_NS_CNAME_MB_MD_MF_MG_MR_Record);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
FIX_THREAD_STATE_MFC_BUG();
CDNSBrowserDlg dlg(GetHolder()->GetComponentData(), GetHolder(), RECORD_MB);
if (IDOK == dlg.DoModal())
{
GetNameNodeEdit()->SetWindowText(dlg.GetSelectionString());
}
}
////////////////////////////////////////////////////////////////////////////
// CDNS_NSCache_RecordPropertyPage
CDNS_NSCache_RecordPropertyPage::CDNS_NSCache_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_NS_CACHE)
{
}
////////////////////////////////////////////////////////////////////////////
// CDNS_PTR_RecordPropertyPage
CDNS_PTR_RecordPropertyPage::CDNS_PTR_RecordPropertyPage()
: CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage(IDD_RR_PTR)
{
m_bAdvancedView = TRUE;
m_nOctects = -1; // invalid if advanced view
}
BEGIN_MESSAGE_MAP(CDNS_PTR_RecordPropertyPage,
CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage)
ON_EN_CHANGE(IDC_RR_NAME_IPEDIT, OnIPv4CtrlChange)
END_MESSAGE_MAP()
BOOL CDNS_PTR_RecordPropertyPage::OnInitDialog()
{
//
// we call three levels up in the deriviation chain to enable/disable TTL control
// we do not call the base class
// CDNSRecordPropertyPage::OnInitDialog();
//
CDNSRecordStandardPropertyPage::OnInitDialog();
//
// move the edit box in place of the IP control
//
CDNSIPv4Control* pNameIPCtrl = GetIPv4Ctrl();
CRect r;
pNameIPCtrl->GetWindowRect(r);
ScreenToClient(r);
GetRRNameEdit()->MoveWindow(&r);
//
// set limit on node name length
//
GetNameNodeEdit()->SetLimitText(MAX_DNS_NAME_LEN);
STANDARD_REC_PP_PTRS(CDNS_PTR_Record);
CDNSServerNode* pServerNode = pHolder->GetDomainNode()->GetZoneNode()->GetServerNode();
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER_NEW_SECURITY_SETTINGS ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER) ||
!pHolder->IsWizardMode())
{
GetSecurityCheckCtrl()->ShowWindow(FALSE);
GetSecurityCheckCtrl()->EnableWindow(FALSE);
}
return TRUE;
}
void CDNS_PTR_RecordPropertyPage::OnIPv4CtrlChange()
{
SetDirty(TRUE);
}
void CDNS_PTR_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_PTRS(CDNS_PTR_Record);
ASSERT(pRecord->GetType() == DNS_TYPE_PTR);
CDNS_PTR_CNAME_MB_MD_MF_MG_MR_NSCache_RecordPropertyPage::SetUIData();
//
// get useful pointers
//
CDNSIPv4Control* pNameIPCtrl = GetIPv4Ctrl();
CDNSRootData* pRootData = (CDNSRootData*)pHolder->GetComponentData()->GetRootData();
ASSERT(pRootData != NULL);
CDNSRecordNodeBase* pRecordNodeBase = pHolder->GetRecordNode();
ASSERT(pRecordNodeBase != NULL);
CDNSDomainNode* pDomainNode = pHolder->GetDomainNode();
ASSERT(pDomainNode != NULL);
//
// set standard fields
//
GetTTLCtrl()->SetTTL(pRecord->m_dwTtlSeconds);
GetRRNameEdit()->SetWindowText(pRecord->m_szNameNode);
//
// set the FQDN for the domain the record is in
//
GetDomainEditBox()->SetWindowText(pHolder->GetDomainNode()->GetFullName());
m_bAdvancedView = pRootData->IsAdvancedView();
//
// force advanced view if we are in a forward lookup zone
//
if (!(pDomainNode->GetZoneNode()->IsReverse()))
{
m_bAdvancedView = TRUE;
}
//
// determine if we can have a normal view representation
//
CString szDomainName = pDomainNode->GetFullName();
if (!m_bAdvancedView)
{
//
// to have normal view we have to have a valid arpa suffix
//
BOOL bArpa = RemoveInAddrArpaSuffix(szDomainName.GetBuffer(1));
szDomainName.ReleaseBuffer(); // got "77.80.55.157"
if (!bArpa)
{
m_bAdvancedView = TRUE; // no need to toggle
}
else
{
m_nOctects = ReverseIPString(szDomainName.GetBuffer(1));
szDomainName.ReleaseBuffer(); // finally got "157.55.80.77"
// to have a normal view representation we cannot
// have more than 3 octects
if (m_nOctects > 3)
{
m_bAdvancedView = TRUE; // force advanced for classless
}
else
{
ASSERT(m_nOctects > 0);
if (pHolder->IsWizardMode())
{
szDomainName += _T(".0"); // placeholder
}
else
{
szDomainName += _T(".");
szDomainName += ((CDNS_PTR_RecordNode*)pRecordNodeBase)->GetTrueRecordName();
}
switch(m_nOctects)
{
case 1: // e.g. "157", now "157._"
szDomainName += _T(".0.0"); // got "157._.0.0"
break;
case 2: // e.g. "157.55"
szDomainName += _T(".0"); // got "157.55._.0"
break;
};
// set the IP control with IP mask value
IP_ADDRESS ipAddr = IPStringToAddr(szDomainName);
if (ipAddr != INADDR_NONE)
{
pNameIPCtrl->SetIPv4Val(ipAddr);
switch(m_nOctects)
{
case 1:
pNameIPCtrl->Clear(2);
pNameIPCtrl->Clear(3);
break;
case 2:
pNameIPCtrl->Clear(3);
break;
}
// in wizard modeneed to disable all fields but the one to fill in
if (pHolder->IsWizardMode())
{
for (int k=0; k<4; k++)
pNameIPCtrl->EnableField(k, k >= m_nOctects);
}
}
else
{
m_bAdvancedView = TRUE;
}
}
}
}
//
// view might have been changed to advanced
//
if (m_bAdvancedView)
{
GetRRNameEdit()->SetWindowText(pRecordNodeBase->GetDisplayName());
}
//
// enable/hide appropriate controls
//
if (m_bAdvancedView)
{
pNameIPCtrl->EnableWindow(FALSE);
pNameIPCtrl->ShowWindow(FALSE);
//
// can edit the name only when creating the record
//
GetRRNameEdit()->SetReadOnly(!pHolder->IsWizardMode());
}
else
{
GetRRNameEdit()->EnableWindow(FALSE);
GetRRNameEdit()->ShowWindow(FALSE);
//
// can edit the name only when creating the record
//
pNameIPCtrl->EnableWindow(pHolder->IsWizardMode());
}
//
// Set the aging/scavenging controls
//
GetDeleteStale()->SetCheck(pRecord->m_dwScavengeStart != 0);
SetTimeStampEdit(pRecord->m_dwScavengeStart);
}
DNS_STATUS CDNS_PTR_RecordPropertyPage::GetUIDataEx(BOOL)
{
STANDARD_REC_PP_PTRS(CDNS_PTR_Record);
GetTTLCtrl()->GetTTL(&(pRecord->m_dwTtlSeconds));
GetNameNodeEdit()->GetWindowText(pRecord->m_szNameNode);
//
// only in wizard mode we can change the edit box content
//
if(pHolder->IsWizardMode())
{
CString s;
CDNSRecordNodeBase* pRecordNode = pHolder->GetRecordNode();
if (m_bAdvancedView)
{
//
// No need to validate name for PTR in advanced mode
//
GetEditBoxText(s);
ASSERT(!s.IsEmpty());
}
else // normal view
{
CDNSIPv4Control* pNameIPCtrl = GetIPv4Ctrl();
DWORD dwArr[4];
pNameIPCtrl->GetArray(dwArr, 4);
ASSERT(dwArr[m_nOctects] <= 255);
s.Format(_T("%d"), dwArr[m_nOctects]);
for (int idx = m_nOctects + 1; idx < 4; idx++)
{
if (dwArr[idx] != FIELD_EMPTY)
{
CString szTemp;
szTemp.Format(_T("%d."), dwArr[idx]);
s = szTemp + s;
}
}
}
pRecordNode->SetRecordName(s,FALSE /*bAtTheNode*/);
if (!m_bAdvancedView)
{
CDNSRecordNodeBase* pRecordNodeBase = pHolder->GetRecordNode();
ASSERT(pRecordNodeBase != NULL);
((CDNS_PTR_RecordNode*)pRecordNodeBase)->ChangeDisplayName(pHolder->GetDomainNode(),
m_bAdvancedView);
}
} // if wizard mode
//
// Get the aging/scavenging info from controls
//
if (GetDeleteStale()->GetCheck())
{
pRecord->m_dwFlags |= DNS_RPC_RECORD_FLAG_AGING_ON;
}
else
{
pRecord->m_dwFlags &= ~DNS_RPC_RECORD_FLAG_AGING_ON;
}
if (pHolder->IsWizardMode() &&
GetSecurityCheckCtrl()->GetCheck())
{
pRecord->m_dwFlags |= DNS_RPC_FLAG_OPEN_ACL;
}
return 0;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MINFO_RP_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_MINFO_RP_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_NAME_MAILBOX_EDIT, OnNameMailBoxChange)
ON_EN_CHANGE(IDC_ERROR_MAILBOX_EDIT, OnErrorToMailboxChange)
ON_BN_CLICKED(IDC_BROWSE_NAME_MAILBOX_BUTTON, OnBrowseNameMailBox)
ON_BN_CLICKED(IDC_BROWSE_ERROR_MAILBOX_BUTTON, OnBrowseErrorToMailbox)
END_MESSAGE_MAP()
CDNS_MINFO_RP_RecordPropertyPage::
CDNS_MINFO_RP_RecordPropertyPage(UINT nIDTemplate) :
CDNSRecordStandardPropertyPage(nIDTemplate)
{
}
void CDNS_MINFO_RP_RecordPropertyPage::OnNameMailBoxChange()
{
SetDirty(TRUE);
}
void CDNS_MINFO_RP_RecordPropertyPage::OnErrorToMailboxChange()
{
SetDirty(TRUE);
}
void CDNS_MINFO_RP_RecordPropertyPage::OnBrowseNameMailBox()
{
STANDARD_REC_PP_PTRS(CDNS_MINFO_RP_Record);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
FIX_THREAD_STATE_MFC_BUG();
CDNSBrowserDlg dlg(pHolder->GetComponentData(), pHolder, RECORD_MB);
if (IDOK == dlg.DoModal())
{
GetNameMailBoxCtrl()->SetWindowText(dlg.GetSelectionString());
}
}
void CDNS_MINFO_RP_RecordPropertyPage::OnBrowseErrorToMailbox()
{
STANDARD_REC_PP_PTRS(CDNS_MINFO_RP_Record);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
FIX_THREAD_STATE_MFC_BUG();
CDNSBrowserDlg dlg(pHolder->GetComponentData(), pHolder,
(pRecord->m_wType == DNS_TYPE_RP) ? RECORD_TEXT : RECORD_MB);
if (IDOK == dlg.DoModal())
{
GetErrorToMailboxCtrl()->SetWindowText(dlg.GetSelectionString());
}
}
void CDNS_MINFO_RP_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_MINFO_RP_Record);
GetNameMailBoxCtrl()->SetLimitText(MAX_DNS_NAME_LEN);
GetNameMailBoxCtrl()->SetWindowText(pRecord->m_szNameMailBox);
GetErrorToMailboxCtrl()->SetLimitText(MAX_DNS_NAME_LEN);
GetErrorToMailboxCtrl()->SetWindowText(pRecord->m_szErrorToMailbox);
}
DNS_STATUS CDNS_MINFO_RP_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_MINFO_RP_Record);
GetNameMailBoxCtrl()->GetWindowText(pRecord->m_szNameMailBox);
GetErrorToMailboxCtrl()->GetWindowText(pRecord->m_szErrorToMailbox);
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MINFO_RecordPropertyPage
CDNS_MINFO_RecordPropertyPage::CDNS_MINFO_RecordPropertyPage()
: CDNS_MINFO_RP_RecordPropertyPage(IDD_RR_MINFO)
{
}
////////////////////////////////////////////////////////////////////////////
// CDNS_RP_RecordPropertyPage
CDNS_RP_RecordPropertyPage::CDNS_RP_RecordPropertyPage()
: CDNS_MINFO_RP_RecordPropertyPage(IDD_RR_RP)
{
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MX_AFSDB_RT_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_MX_AFSDB_RT_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_NAME_EXCHANGE_EDIT, OnNameExchangeChange)
ON_BN_CLICKED(IDC_BROWSE_BUTTON, OnBrowse)
END_MESSAGE_MAP()
CDNS_MX_AFSDB_RT_RecordPropertyPage::
CDNS_MX_AFSDB_RT_RecordPropertyPage(UINT nIDTemplate) :
CDNSRecordStandardPropertyPage(nIDTemplate)
{
}
void CDNS_MX_AFSDB_RT_RecordPropertyPage::OnNameExchangeChange()
{
SetDirty(TRUE);
}
void CDNS_MX_AFSDB_RT_RecordPropertyPage::OnBrowse()
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
FIX_THREAD_STATE_MFC_BUG();
CDNSBrowserDlg dlg(GetHolder()->GetComponentData(), GetHolder(), RECORD_A);
if (IDOK == dlg.DoModal())
{
GetNameExchangeCtrl()->SetWindowText(dlg.GetSelectionString());
}
}
void CDNS_MX_AFSDB_RT_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_MX_AFSDB_RT_Record);
GetNameExchangeCtrl()->SetLimitText(MAX_DNS_NAME_LEN);
GetNameExchangeCtrl()->SetWindowText(pRecord->m_szNameExchange);
}
DNS_STATUS CDNS_MX_AFSDB_RT_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_MX_AFSDB_RT_Record);
CString szNameExchange;
GetNameExchangeCtrl()->GetWindowText(szNameExchange);
DWORD dwNameChecking = pHolder->GetDomainNode()->GetServerNode()->GetNameCheckFlag();
dwErr = ::ValidateDnsNameAgainstServerFlags(szNameExchange,
DnsNameHostnameFull,
dwNameChecking);
if (dwErr != 0)
{
return dwErr;
}
pRecord->m_szNameExchange = szNameExchange;
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MX_RT_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_MX_RT_RecordPropertyPage, CDNS_MX_AFSDB_RT_RecordPropertyPage)
ON_EN_CHANGE(IDC_PREFERENCE_EDIT, OnPreferenceChange)
END_MESSAGE_MAP()
CDNS_MX_RT_RecordPropertyPage::
CDNS_MX_RT_RecordPropertyPage(UINT nIDTemplate) :
CDNS_MX_AFSDB_RT_RecordPropertyPage(nIDTemplate)
{
}
BOOL CDNS_MX_RT_RecordPropertyPage::OnInitDialog()
{
CDNS_MX_AFSDB_RT_RecordPropertyPage::OnInitDialog();
VERIFY(m_preferenceEdit.SubclassDlgItem(IDC_PREFERENCE_EDIT, this));
m_preferenceEdit.SetRange(0,0xffff ); // unsigned short
// Disable IME support on the control
ImmAssociateContext(m_preferenceEdit.GetSafeHwnd(), NULL);
return TRUE;
}
void CDNS_MX_RT_RecordPropertyPage::OnPreferenceChange()
{
SetDirty(TRUE);
}
void CDNS_MX_RT_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_PTRS(CDNS_MX_AFSDB_RT_Record)
CDNS_MX_AFSDB_RT_RecordPropertyPage::SetUIData();
VERIFY(m_preferenceEdit.SetVal(pRecord->m_wPreference));
}
DNS_STATUS CDNS_MX_RT_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_PTRS(CDNS_MX_AFSDB_RT_Record)
DNS_STATUS dwErr = CDNS_MX_AFSDB_RT_RecordPropertyPage::GetUIDataEx(bSilent);
pRecord->m_wPreference = (WORD)m_preferenceEdit.GetVal();
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_MX_RecordPropertyPage
CDNS_MX_RecordPropertyPage::CDNS_MX_RecordPropertyPage()
: CDNS_MX_RT_RecordPropertyPage(IDD_RR_MX)
{
}
DNS_STATUS CDNS_MX_RecordPropertyPage::ValidateRecordName(PCWSTR pszName, DWORD dwNameChecking)
{
CDNSRecordPropertyPageHolder* pHolder = GetDNSRecordHolder();
CDNSRootData* pRootData = (CDNSRootData*)pHolder->GetComponentData()->GetRootData();
ASSERT(pRootData != NULL);
if (pRootData->IsAdvancedView())
{
//
// Don't validate the name in advanced view
//
return 0;
}
DNS_STATUS dwError = CDNSRecordStandardPropertyPage::ValidateRecordName(pszName, dwNameChecking);
if (dwError != 0)
{
DNS_STATUS dwWildcardError = ::ValidateDnsNameAgainstServerFlags(pszName, DnsNameWildcard, dwNameChecking);
if (dwWildcardError == 0)
{
dwError = 0;
}
}
return dwError;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_RT_RecordPropertyPage
CDNS_RT_RecordPropertyPage::CDNS_RT_RecordPropertyPage()
: CDNS_MX_RT_RecordPropertyPage(IDD_RR_RT)
{
}
/////////////////////////////////////////////////////////////////////////////
// CDNS_AFSDB_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_AFSDB_RecordPropertyPage, CDNS_MX_AFSDB_RT_RecordPropertyPage)
ON_EN_CHANGE(IDC_SUBTYPE_EDIT, OnSubtypeEditChange)
ON_BN_CLICKED(IDC_AFS_VLS_RADIO, OnSubtypeRadioChange)
ON_BN_CLICKED(IDC_DCE_ANS_RADIO, OnSubtypeRadioChange)
ON_BN_CLICKED(IDC_OTHER_RADIO, OnSubtypeRadioChange)
END_MESSAGE_MAP()
CDNS_AFSDB_RecordPropertyPage::CDNS_AFSDB_RecordPropertyPage()
: CDNS_MX_AFSDB_RT_RecordPropertyPage(IDD_RR_AFSDB)
{
}
BOOL CDNS_AFSDB_RecordPropertyPage::OnInitDialog()
{
CDNS_MX_AFSDB_RT_RecordPropertyPage::OnInitDialog();
VERIFY(m_subtypeEdit.SubclassDlgItem(IDC_SUBTYPE_EDIT, this));
m_subtypeEdit.SetRange(0,0xffff); // unsigned short
m_subtypeEdit.SetLimitText(5);
// Disable IME support on the controls
ImmAssociateContext(m_subtypeEdit.GetSafeHwnd(), NULL);
return TRUE;
}
void CDNS_AFSDB_RecordPropertyPage::OnSubtypeEditChange()
{
SetDirty(TRUE);
}
void CDNS_AFSDB_RecordPropertyPage::OnSubtypeRadioChange()
{
STANDARD_REC_PP_PTRS(CDNS_MX_AFSDB_RT_Record)
CButton* pAFSRadioButton = GetAFSRadioButton();
CButton* pDCERadioButton = GetDCERadioButton();
if (pAFSRadioButton->GetCheck())
{
m_subtypeEdit.EnableWindow(FALSE);
m_subtypeEdit.SetWindowText(NULL);
pRecord->m_wPreference = AFSDB_PREF_AFS_CELL_DB_SERV;
}
else if (pDCERadioButton->GetCheck())
{
m_subtypeEdit.EnableWindow(FALSE);
m_subtypeEdit.SetWindowText(NULL);
pRecord->m_wPreference = AFSDB_PREF_DCE_AUTH_NAME_SERV;
}
else
{
ASSERT(GetOtherRadioButton()->GetCheck());
m_subtypeEdit.EnableWindow(TRUE);
VERIFY(m_subtypeEdit.SetVal(pRecord->m_wPreference));
}
SetDirty(TRUE);
}
void CDNS_AFSDB_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_PTRS(CDNS_MX_AFSDB_RT_Record)
CDNS_MX_AFSDB_RT_RecordPropertyPage::SetUIData();
CButton* pAFSRadioButton = GetAFSRadioButton();
CButton* pDCERadioButton = GetDCERadioButton();
CButton* pOtherRadioButton = GetOtherRadioButton();
switch (pRecord->m_wPreference)
{
case AFSDB_PREF_AFS_CELL_DB_SERV:
{
pAFSRadioButton->SetCheck(TRUE);
pDCERadioButton->SetCheck(FALSE);
pOtherRadioButton->SetCheck(FALSE);
m_subtypeEdit.EnableWindow(FALSE);
m_subtypeEdit.SetWindowText(L"");
}
break;
case AFSDB_PREF_DCE_AUTH_NAME_SERV:
{
pAFSRadioButton->SetCheck(FALSE);
pDCERadioButton->SetCheck(TRUE);
pOtherRadioButton->SetCheck(FALSE);
m_subtypeEdit.EnableWindow(FALSE);
m_subtypeEdit.SetWindowText(L"");
}
break;
default:
{
pAFSRadioButton->SetCheck(FALSE);
pDCERadioButton->SetCheck(FALSE);
pOtherRadioButton->SetCheck(TRUE);
m_subtypeEdit.EnableWindow(TRUE);
VERIFY(m_subtypeEdit.SetVal(pRecord->m_wPreference));
}
}
}
DNS_STATUS CDNS_AFSDB_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_PTRS(CDNS_MX_AFSDB_RT_Record)
DNS_STATUS dwErr = CDNS_MX_AFSDB_RT_RecordPropertyPage::GetUIDataEx(bSilent);
CButton* pAFSRadioButton = GetAFSRadioButton();
CButton* pDCERadioButton = GetDCERadioButton();
if (pAFSRadioButton->GetCheck())
{
pRecord->m_wPreference = AFSDB_PREF_AFS_CELL_DB_SERV;
}
else if (pDCERadioButton->GetCheck())
{
pRecord->m_wPreference = AFSDB_PREF_DCE_AUTH_NAME_SERV;
}
else
{
ASSERT(GetOtherRadioButton()->GetCheck());
pRecord->m_wPreference = (WORD)m_subtypeEdit.GetVal();
}
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_WKS_RecordPropertyPage
BEGIN_MESSAGE_MAP(CDNS_WKS_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_EN_CHANGE(IDC_IPEDIT, OnIPv4CtrlChange)
ON_BN_CLICKED(IDC_TCP_RADIO, OnProtocolRadioChange)
ON_BN_CLICKED(IDC_UDP_RADIO, OnProtocolRadioChange)
ON_EN_CHANGE(IDC_SERVICES_EDIT, OnServicesEditChange)
END_MESSAGE_MAP()
CDNS_WKS_RecordPropertyPage::CDNS_WKS_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_WKS)
{
}
BOOL CDNS_WKS_RecordPropertyPage::CreateRecord()
{
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
ASSERT(pHolder->IsWizardMode());
//
// Get the data from the UI
//
DNS_STATUS err = GetUIDataEx(FALSE);
if (err != 0)
{
DNSErrorDialog(err,IDS_MSG_RECORD_CREATE_FAILED);
return FALSE;
}
//
// Create the new record
//
err = pHolder->CreateNewRecord(CanCreateDuplicateRecords());
if (err != 0)
{
if (err == DNS_ERROR_INVALID_DATA)
{
//
// Filter out invalid data error and present a more meaningful error message
//
DNSMessageBox(IDS_ERRMSG_WKS_INVALID_DATA);
}
else
{
DNSErrorDialog(err,IDS_MSG_RECORD_CREATE_FAILED);
}
return FALSE;
}
return TRUE;
}
void CDNS_WKS_RecordPropertyPage::OnIPv4CtrlChange()
{
STANDARD_REC_PP_PTRS(CDNS_WKS_Record)
SetDirty(TRUE);
}
void CDNS_WKS_RecordPropertyPage::OnProtocolRadioChange()
{
STANDARD_REC_PP_PTRS(CDNS_WKS_Record)
CButton* pTCPRadio = GetTCPRadioButton();
CButton* pUDPRadio = GetUDPRadioButton();
if (pTCPRadio->GetCheck())
{
pUDPRadio->SetCheck(FALSE);
}
else if (pUDPRadio->GetCheck())
{
pTCPRadio->SetCheck(FALSE);
}
SetDirty(TRUE);
}
void CDNS_WKS_RecordPropertyPage::OnServicesEditChange()
{
SetDirty(TRUE);
}
void CDNS_WKS_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_WKS_Record);
GetIPv4Ctrl()->SetIPv4Val(pRecord->m_ipAddress);
CButton* pTCPRadio = GetTCPRadioButton();
CButton* pUDPRadio = GetUDPRadioButton();
if (pRecord->m_chProtocol == DNS_WKS_PROTOCOL_TCP)
{
pTCPRadio->SetCheck(TRUE);
pUDPRadio->SetCheck(FALSE);
}
else // assume UDP
{
ASSERT(pRecord->m_chProtocol == DNS_WKS_PROTOCOL_UDP);
pTCPRadio->SetCheck(FALSE);
pUDPRadio->SetCheck(TRUE);
}
GetServicesEdit()->SetWindowText(pRecord->m_szServiceList);
}
DNS_STATUS CDNS_WKS_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_WKS_Record);
GetIPv4Ctrl()->GetIPv4Val(&(pRecord->m_ipAddress));
if (GetTCPRadioButton()->GetCheck())
{
pRecord->m_chProtocol = DNS_WKS_PROTOCOL_TCP;
}
else
{
ASSERT(GetUDPRadioButton()->GetCheck());
pRecord->m_chProtocol = DNS_WKS_PROTOCOL_UDP;
}
GetServicesEdit()->GetWindowText(pRecord->m_szServiceList);
return dwErr;
}
////////////////////////////////////////////////////////////////////////////
// CDNS_SRV_RecordPropertyPage
// Added by JEFFJON 2/26/99
// The following is used to prime the services, protocol, and port combo/edit boxes
//
struct SERVICE
{
LPCWSTR lpszService;
LPCWSTR protocolArr[2];
UINT uiPort;
};
// WARNING!!! REVIEW_JEFFJON : this has to be in alphabetical order on the lpszService field
// or else everything breaks below
SERVICE services[] = { L"_finger", { L"_tcp", L"_udp" }, 79 ,
L"_ftp", { L"_tcp", L"_udp" }, 21 ,
L"_http", { L"_tcp", L"_udp" }, 80 ,
L"_kerberos", { L"_tcp", L"_udp" }, 88 ,
L"_ldap", { L"_tcp", L"_udp" }, 389 ,
L"_nntp", { L"_tcp", L"_udp" }, 119 ,
L"_telnet", { L"_tcp", L"_udp" }, 23 ,
L"_whois", { L"_tcp", NULL }, 43 ,
NULL, { NULL }, 0 };
BOOL CALLBACK _ComboEnumChildWndProc(HWND hwnd, LPARAM lParam)
{
HWND* pHwnd = (HWND*)lParam;
*pHwnd = hwnd;
return TRUE;
}
BOOL CDNS_SRV_RR_ComboBox::Initialize(UINT nCtrlID, CWnd* pParent)
{
if (!SubclassDlgItem(nCtrlID, pParent))
{
return FALSE;
}
HWND hwndChildEdit = NULL;
EnumChildWindows(GetSafeHwnd(),_ComboEnumChildWndProc, (LPARAM)&hwndChildEdit);
ASSERT(hwndChildEdit != NULL);
::SendMessage(hwndChildEdit, EM_LIMITTEXT, MAX_DNS_NAME_LEN, 0);
return TRUE;
}
#define SRV_RR_PROTOCOL_COMBO_ITEM_COUNT 2
BEGIN_MESSAGE_MAP(CDNS_SRV_RecordPropertyPage, CDNSRecordStandardPropertyPage)
ON_CBN_EDITCHANGE(IDC_SERVICE_NAME_COMBO, OnServiceComboEditChange)
ON_CBN_EDITCHANGE(IDC_PROTOCOL_NAME_COMBO, OnProtocolComboEditChange)
ON_CBN_SELCHANGE(IDC_SERVICE_NAME_COMBO, OnServiceComboSelChange)
ON_CBN_SELCHANGE(IDC_PROTOCOL_NAME_COMBO, OnProtocolComboSelChange)
ON_EN_CHANGE(IDC_PRIORITY_EDIT, OnNumericEditChange)
ON_EN_CHANGE(IDC_WEIGHT_EDIT, OnNumericEditChange)
ON_EN_CHANGE(IDC_PORT_EDIT, OnNumericEditChange)
ON_EN_CHANGE(IDC_NAME_TARGET_EDIT, OnNameTargetEditChange)
END_MESSAGE_MAP()
CDNS_SRV_RecordPropertyPage::CDNS_SRV_RecordPropertyPage()
: CDNSRecordStandardPropertyPage(IDD_RR_SRV)
{
m_pOldDomainNode = NULL;
m_pSubdomainNode = NULL;
m_bCreateSubdomain = FALSE;
m_bSubdomainCreated = FALSE;
m_bCreated = FALSE;
}
void CDNS_SRV_RecordPropertyPage::OnInitName()
{
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
//
// initialize combo boxes
//
VERIFY(m_serviceCombo.Initialize(IDC_SERVICE_NAME_COMBO, this));
VERIFY(m_protocolCombo.Initialize(IDC_PROTOCOL_NAME_COMBO, this));
//
// limit the text length the user can type
//
int nUTF8ParentLen = UTF8StringLen(pHolder->GetDomainNode()->GetFullName());
m_serviceCombo.LimitText(MAX_DNS_NAME_LEN - nUTF8ParentLen - 1); // count dot when chaining
m_protocolCombo.LimitText(MAX_DNS_NAME_LEN - nUTF8ParentLen - 1); // count dot when chaining
//
// can edit/change combos only when creating the record
//
m_serviceCombo.EnableWindow(GetHolder()->IsWizardMode());
m_protocolCombo.EnableWindow(GetHolder()->IsWizardMode());
//
// set the FQDN for the parent of the domain the record is in
//
CEdit* pEdit = GetDomainEditBox();
CDNSDomainNode* pDomainNode = pHolder->GetDomainNode();
if (pHolder->IsWizardMode())
{
pEdit->SetWindowText(pDomainNode->GetFullName());
}
else
{
if (!pDomainNode->IsZone())
{
CDNSDomainNode* pParentDomainNode = dynamic_cast<CDNSDomainNode*>(pDomainNode->GetContainer());
ASSERT(pParentDomainNode != NULL);
pEdit->SetWindowText(pParentDomainNode->GetFullName());
}
else
{
//
// SRV record can be at the zone level if the _<protocol> domain was delegated
//
CDNSZoneNode* pZoneNode = dynamic_cast<CDNSZoneNode*>(pDomainNode);
ASSERT(pZoneNode != NULL);
if (pZoneNode != NULL)
{
pEdit->SetWindowText(pZoneNode->GetFullName());
}
}
}
}
void CDNS_SRV_RecordPropertyPage::PrimeServicesCombo()
{
m_serviceCombo.ResetContent();
SERVICE* service = services;
while (service->lpszService != NULL)
{
m_serviceCombo.AddString(service->lpszService);
service++;
}
}
void CDNS_SRV_RecordPropertyPage::OnSetName(CDNSRecordNodeBase* pRecordNode)
{
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
if (pHolder->IsWizardMode())
{
m_serviceCombo.SetCurSel(0);
m_protocolCombo.SetCurSel(0);
}
else
{
//
// service name is the RR record name
//
m_serviceCombo.SetWindowText(pRecordNode->GetDisplayName());
//
// protocol name from the parent domain FQDN
//
if (!pRecordNode->GetDomainNode()->IsZone())
{
m_protocolCombo.SetWindowText(pRecordNode->GetDomainNode()->GetDisplayName());
}
else
{
//
// The SRV record can be at the zone level if the _<protocol> domain
// was delegated
//
CString szZoneName = pRecordNode->GetDomainNode()->GetFullName();
//
// Retrieve a single label
//
int iDot = szZoneName.Find(L'.');
if (iDot != -1)
{
szZoneName = szZoneName.Left(iDot);
}
m_protocolCombo.SetWindowText(szZoneName);
}
}
}
void CDNS_SRV_RecordPropertyPage::OnGetName(CString& s)
{
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
ASSERT(pHolder->IsWizardMode());
//
// the service name is going to be the name of the RR record
//
m_serviceCombo.GetWindowText(s);
//
// the protocol name is going to be the name of the created folder
//
m_protocolCombo.GetWindowText(m_szProtocolName);
if (m_bCreated)
{
return;
}
//
// find a subfolder in the UI for the protocol
//
if (m_pSubdomainNode == NULL)
{
CDNSDomainNode* pCurrentDomainNode = pHolder->GetDomainNode();
//
// Retrieve the FQDN
// First check to see if the current domain node is a protocol domain
// if not then check for a subdomain that is
//
CString szCurrentDomainName = pCurrentDomainNode->GetFullName();
int iDot = szCurrentDomainName.Find(L'.');
if (iDot != -1)
{
szCurrentDomainName = szCurrentDomainName.Left(iDot);
}
CDNSDomainNode* pSubdomainNode = NULL;
if (_wcsicmp(szCurrentDomainName, m_szProtocolName) == 0)
{
pSubdomainNode = pCurrentDomainNode;
}
else
{
CString szSubdomainFQDN;
szSubdomainFQDN.Format(_T("%s.%s"), m_szProtocolName, pCurrentDomainNode->GetFullName());
//
// Find the sub-domain node
//
pSubdomainNode = pCurrentDomainNode->FindSubdomainNode(szSubdomainFQDN);
}
if (pSubdomainNode == NULL)
{
//
// If sub-domain doesn't exist, create it
//
pSubdomainNode = pCurrentDomainNode->CreateSubdomainNode();
ASSERT(pSubdomainNode != NULL);
CComponentDataObject* pComponentData = pHolder->GetComponentData();
CDNSRootData* pRootData = (CDNSRootData*)pComponentData->GetRootData();
pCurrentDomainNode->SetSubdomainName(pSubdomainNode, m_szProtocolName,
pRootData->IsAdvancedView());
m_bCreateSubdomain = TRUE;
}
//
// move down one level
//
m_pOldDomainNode = pCurrentDomainNode;
m_pSubdomainNode = pSubdomainNode;
pHolder->SetContainerNode(pSubdomainNode);
pHolder->GetRecordNode()->SetContainer(m_pSubdomainNode);
}
}
BOOL CDNS_SRV_RecordPropertyPage::CreateRecord()
{
if (m_bCreated)
{
return TRUE;
}
//
// create a subfolder i the server, if needed
//
if (m_bCreateSubdomain && !m_bSubdomainCreated)
{
DNS_STATUS err = m_pOldDomainNode->CreateSubdomain(m_pSubdomainNode,
GetHolder()->GetComponentData());
if (err != 0)
{
DNSErrorDialog(err,IDS_MSG_RECORD_CREATE_FAILED);
m_bCreated = FALSE;
//
// something went wrong, bail out
//
delete m_pSubdomainNode;
m_pSubdomainNode = NULL;
GetHolder()->SetContainerNode(m_pOldDomainNode);
((CDNSRecordPropertyPageHolder*)GetHolder())->GetRecordNode()->SetContainer(m_pOldDomainNode);
return FALSE;
}
m_bSubdomainCreated = TRUE;
//
// mark the node as enumerated and force transition to "loaded"
//
m_pSubdomainNode->MarkEnumeratedAndLoaded(GetHolder()->GetComponentData());
}
m_pSubdomainNode = NULL;
if (!CDNSRecordStandardPropertyPage::CreateRecord())
{
m_bCreated = FALSE;
return FALSE;
}
m_bCreated = TRUE;
return TRUE;
}
void CDNS_SRV_RecordPropertyPage::OnNumericEditChange()
{
SetDirty(TRUE);
}
void CDNS_SRV_RecordPropertyPage::OnNameTargetEditChange()
{
SetDirty(TRUE);
}
void CDNS_SRV_RecordPropertyPage::OnServiceComboEditChange()
{
CString szText;
m_serviceCombo.GetWindowText(szText);
GetHolder()->EnableSheetControl(IDOK,!szText.IsEmpty());
}
void CDNS_SRV_RecordPropertyPage::OnProtocolComboEditChange()
{
CString szText;
m_protocolCombo.GetWindowText(szText);
GetHolder()->EnableSheetControl(IDOK,!szText.IsEmpty());
}
void CDNS_SRV_RecordPropertyPage::OnServiceComboSelChange()
{
GetHolder()->EnableSheetControl(IDOK, TRUE);
m_protocolCombo.ResetContent();
int nSel = m_serviceCombo.GetCurSel();
for (int idx = 0; idx < SRV_RR_PROTOCOL_COMBO_ITEM_COUNT; idx++)
{
if (services[nSel].protocolArr[idx] != NULL)
{
m_protocolCombo.AddString(services[nSel].protocolArr[idx]);
}
}
m_protocolCombo.SetCurSel(0);
m_portEdit.SetVal(services[nSel].uiPort);
}
void CDNS_SRV_RecordPropertyPage::OnProtocolComboSelChange()
{
GetHolder()->EnableSheetControl(IDOK, TRUE);
}
void CDNS_SRV_RecordPropertyPage::SetUIData()
{
STANDARD_REC_PP_SETUI_PROLOGUE(CDNS_SRV_Record);
VERIFY(m_priorityEdit.SetVal(pRecord->m_wPriority));
VERIFY(m_weightEdit.SetVal(pRecord->m_wWeight));
if (pRecord->m_wPort != 0)
{
VERIFY(m_portEdit.SetVal(pRecord->m_wPort));
}
GetNameTargetEdit()->SetLimitText(MAX_DNS_NAME_LEN);
GetNameTargetEdit()->SetWindowText(pRecord->m_szNameTarget);
}
DNS_STATUS CDNS_SRV_RecordPropertyPage::GetUIDataEx(BOOL bSilent)
{
STANDARD_REC_PP_GETUI_PROLOGUE(CDNS_SRV_Record);
ASSERT(dwErr == 0);
pRecord->m_wPriority = (WORD)m_priorityEdit.GetVal();
pRecord->m_wWeight = (WORD)m_weightEdit.GetVal();
pRecord->m_wPort = (WORD)m_portEdit.GetVal();
GetNameTargetEdit()->GetWindowText(pRecord->m_szNameTarget);
if (pHolder->IsWizardMode() &&
GetSecurityCheckCtrl()->GetCheck())
{
pRecord->m_dwFlags |= DNS_RPC_FLAG_OPEN_ACL;
}
return 0;
}
BOOL CDNS_SRV_RecordPropertyPage::OnInitDialog()
{
CDNSRecordStandardPropertyPage::OnInitDialog();
VERIFY(m_priorityEdit.SubclassDlgItem(IDC_PRIORITY_EDIT, this));
m_priorityEdit.SetRange(0,0xffff ); // unsigned short
VERIFY(m_weightEdit.SubclassDlgItem(IDC_WEIGHT_EDIT, this));
m_weightEdit.SetRange(0,0xffff ); // unsigned short
VERIFY(m_portEdit.SubclassDlgItem(IDC_PORT_EDIT, this));
m_portEdit.SetRange(0,0xffff ); // unsigned short
//
// Disable IME support on the controls
//
ImmAssociateContext(m_priorityEdit.GetSafeHwnd(), NULL);
ImmAssociateContext(m_weightEdit.GetSafeHwnd(), NULL);
ImmAssociateContext(m_portEdit.GetSafeHwnd(), NULL);
//
// This has to be done after both m_serviceCombo and m_protocolCombo have been initialized
//
PrimeServicesCombo();
m_serviceCombo.SetCurSel(0);
OnServiceComboSelChange();
//
// Only enable the security checkbox if we are talking to a 2473 or greater
// Whistler server
//
CDNSRecordPropertyPageHolder* pHolder = (CDNSRecordPropertyPageHolder*)GetHolder();
CDNSServerNode* pServerNode = pHolder->GetDomainNode()->GetZoneNode()->GetServerNode();
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER_NEW_SECURITY_SETTINGS ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
{
GetSecurityCheckCtrl()->ShowWindow(FALSE);
GetSecurityCheckCtrl()->EnableWindow(FALSE);
}
return TRUE;
}
////////////////////////////////////////////////////////////////////////
// CNewHostDialog
#ifdef _USE_BLANK
BEGIN_MESSAGE_MAP(CNewHostDialog, CHelpDialog)
ON_BN_CLICKED(IDC_BUTTON_ADDHOST, OnAddHost)
END_MESSAGE_MAP()
#else
BEGIN_MESSAGE_MAP(CNewHostDialog, CHelpDialog)
ON_EN_CHANGE(IDC_RR_NAME_EDIT, OnEditChange)
ON_BN_CLICKED(IDC_BUTTON_ADDHOST, OnAddHost)
END_MESSAGE_MAP()
#endif
CNewHostDialog::CNewHostDialog(CDNSDomainNode* pParentDomainNode,
CComponentDataObject* pComponentData)
: CHelpDialog(IDD_DOMAIN_ADDNEWHOST, pComponentData)
{
ASSERT(pParentDomainNode != NULL);
ASSERT(pComponentData != NULL);
m_pParentDomainNode = pParentDomainNode;
m_pComponentData = pComponentData;
m_nUTF8ParentLen = UTF8StringLen(pParentDomainNode->GetFullName());
m_pTempDNSRecord = new CDNS_A_Record;
m_pTempDNSRecord->m_dwTtlSeconds = m_pParentDomainNode->GetDefaultTTL();
m_bFirstCreation = TRUE;
}
CNewHostDialog::~CNewHostDialog()
{
delete m_pTempDNSRecord;
}
BOOL CNewHostDialog::OnInitDialog()
{
CHelpDialog::OnInitDialog();
//
// hook up Cancel/Done button
//
UINT nButtonIDs[2] = { IDS_BUTTON_TEXT_CANCEL, IDS_BUTTON_TEXT_DONE };
VERIFY(m_cancelDoneTextHelper.Init(this, IDCANCEL, nButtonIDs));
m_cancelDoneTextHelper.SetToggleState(m_bFirstCreation);
//
// limit the text length the user can type
//
int nUTF8ParentLen = UTF8StringLen(m_pParentDomainNode->GetFullName());
int nUTF8Len = MAX_DNS_NAME_LEN - nUTF8ParentLen - 3; // count dot when chaining
//
// hook up name edit control
//
GetNameEdit()->SetLimitText(nUTF8Len);
//
// determine if we need to hide TTL control
//
CDNSRootData* pRootData = (CDNSRootData*)m_pComponentData->GetRootData();
ASSERT(pRootData != NULL);
BOOL bShow = pRootData->IsAdvancedView();
CDNSTTLControl* pCtrl = GetTTLCtrl();
ASSERT(pCtrl != NULL);
pCtrl->EnableWindow(bShow);
pCtrl->ShowWindow(bShow);
CWnd* pWnd = GetDlgItem(IDC_STATIC_TTL);
ASSERT(pWnd != NULL);
pWnd->EnableWindow(bShow);
pWnd->ShowWindow(bShow);
//
// Set Create PTR record checkbox
//
if (pRootData != NULL)
{
GetPTRCheckCtrl()->SetCheck(pRootData->GetCreatePTRWithHost());
}
//
// set the FQDN for the domain the record is in
//
GetDomainEditBox()->SetWindowText(m_pParentDomainNode->GetFullName());
//
// Only enable the security checkbox if we are talking to a 2473 or greater
// Whistler server
//
CDNSServerNode* pServerNode = m_pParentDomainNode->GetServerNode();
if (pServerNode->GetBuildNumber() < DNS_SRV_BUILD_NUMBER_WHISTLER_NEW_SECURITY_SETTINGS ||
(pServerNode->GetMajorVersion() <= DNS_SRV_MAJOR_VERSION_NT_5 &&
pServerNode->GetMinorVersion() < DNS_SRV_MINOR_VERSION_WHISTLER))
{
GetSecurityCheckCtrl()->ShowWindow(FALSE);
GetSecurityCheckCtrl()->EnableWindow(FALSE);
}
SetUIData(TRUE);
return TRUE; // return TRUE unless you set the focus to a control
}
#ifdef _USE_BLANK
#else
void CNewHostDialog::OnEditChange()
{
//
// Get the server name checking flags
//
DWORD dwNameChecking = m_pParentDomainNode->GetServerNode()->GetNameCheckFlag();
CString s;
GetNameEdit()->GetWindowText(s);
CString szFullName;
szFullName.Format(L"%s.%s", s, pHolder->GetDomainNode()->GetFullName());
GetDlgItem(IDC_BUTTON_ADDHOST)->EnableWindow(ValidateRecordName(szFullName, dwNameChecking) == 0);
}
#endif
DNS_STATUS CNewHostDialog::ValidateRecordName(PCWSTR pszName, DWORD dwNameChecking)
{
CDNSRootData* pRootData = (CDNSRootData*)m_pComponentData->GetRootData();
ASSERT(pRootData != NULL);
if (pRootData->IsAdvancedView())
{
//
// Don't validate the name in advanced view
//
return 0;
}
return ::ValidateDnsNameAgainstServerFlags(pszName, DnsNameHostnameFull, dwNameChecking);
}
CDNSRecordNodeBase* CNewHostDialog::CreateRecordNode()
{
//
// create a record node of type A
//
CDNSRecordNodeBase* pRecordNode = CDNSRecordInfo::CreateRecordNode(DNS_TYPE_A);
ASSERT(pRecordNode != NULL);
//
// set the normal/advanced view option
//
CDNSRootData* pRootData = (CDNSRootData*)m_pComponentData->GetRootData();
ASSERT(pRootData != NULL);
pRecordNode->SetFlagsDown(TN_FLAG_DNS_RECORD_FULL_NAME, !pRootData->IsAdvancedView());
//
// hookup container for node
//
pRecordNode->SetContainer(m_pParentDomainNode);
return pRecordNode;
}
void CNewHostDialog::SetUIData(BOOL bFirstTime)
{
CDNS_A_Record* pARec = (CDNS_A_Record*)m_pTempDNSRecord;
if (!bFirstTime)
{
//
// keep the first 3 octects and reset the last one to zero
//
pARec->m_ipAddress = static_cast<DWORD>(MAKEIPADDRESS(FIRST_IPADDRESS(0),
SECOND_IPADDRESS(pARec->m_ipAddress),
THIRD_IPADDRESS(pARec->m_ipAddress),
FOURTH_IPADDRESS(pARec->m_ipAddress)));
}
GetNameEdit()->SetWindowText(L"");
GetIPv4Ctrl()->SetIPv4Val(pARec->m_ipAddress);
GetTTLCtrl()->SetTTL(m_pTempDNSRecord->m_dwTtlSeconds);
}
DNS_STATUS CNewHostDialog::GetUIData(CDNSRecordNodeBase* pRecordNode)
{
ASSERT(m_pTempDNSRecord->m_dwFlags == DNS_RPC_RECORD_FLAG_DEFAULT);
#ifdef _USE_BLANK
BOOL bAtTheNode = GetNameEdit()->GetWindowTextLength() == 0;
#else
BOOL bAtTheNode = (s == g_szAtTheNodeInput);
#endif
if (bAtTheNode)
{
//
//name null, node is at the node level, use name of parent
//
pRecordNode->SetRecordName(pRecordNode->GetDomainNode()->GetDisplayName(),bAtTheNode);
}
else
{
//
// non null name, node is a child
//
CString szName;
GetNameEdit()->GetWindowText(szName);
pRecordNode->SetRecordName(szName, bAtTheNode);
}
GetIPv4Ctrl()->GetIPv4Val(&(((CDNS_A_Record*)m_pTempDNSRecord)->m_ipAddress));
GetTTLCtrl()->GetTTL(&(m_pTempDNSRecord->m_dwTtlSeconds));
if (GetPTRCheckCtrl()->GetCheck())
{
m_pTempDNSRecord->m_dwFlags |= DNS_RPC_RECORD_FLAG_CREATE_PTR;
}
if (GetSecurityCheckCtrl()->GetCheck())
{
m_pTempDNSRecord->m_dwFlags |= DNS_RPC_FLAG_OPEN_ACL;
}
CDNSRootData* pRootData = dynamic_cast<CDNSRootData*>(m_pComponentData->GetRootData());
if (pRootData != NULL)
{
pRootData->SetCreatePTRWithHost(GetPTRCheckCtrl()->GetCheck());
}
return 0;
}
void CNewHostDialog::OnAddHost()
{
CDNSRecordNodeBase* pRecordNode = CreateRecordNode();
ASSERT(pRecordNode != NULL);
ASSERT(m_pTempDNSRecord != NULL);
//
// get data from the UI
// Don't need to handle a failure here because the name is
//
DNS_STATUS dwErr = GetUIData(pRecordNode);
ASSERT(dwErr == 0);
DWORD dwNameChecking = m_pParentDomainNode->GetServerNode()->GetNameCheckFlag();
if (!pRecordNode->IsAtTheNode())
{
LPCWSTR lpszHostName = pRecordNode->GetTrueRecordName();
DNS_STATUS errName = ValidateRecordName(lpszHostName, dwNameChecking);
if (errName != 0)
{
//
// Bring up an error for an invalid name
//
CString szFmt, szMsg;
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_NAME_FAILED);
szMsg.Format((LPCWSTR)szFmt, lpszHostName);
if (DNSMessageBox(szMsg, MB_YESNO) != IDYES)
{
return;
}
}
}
//
// See if a child of that name already exists
//
RECORD_SEARCH recordSearch = RECORD_NOT_FOUND;
CDNSDomainNode* pNewParentDomain = NULL;
CString szFullRecordName;
pRecordNode->GetFullName(szFullRecordName);
CString szNonExistentDomain;
recordSearch = m_pParentDomainNode->GetZoneNode()->DoesContain(szFullRecordName,
m_pComponentData,
&pNewParentDomain,
szNonExistentDomain,
TRUE);
if ((recordSearch == RECORD_NOT_FOUND || pRecordNode->IsAtTheNode() || recordSearch == RECORD_NOT_FOUND_AT_THE_NODE) &&
pNewParentDomain != NULL)
{
//
// write record to server
//
BOOL bUseDefaultTTL = TRUE;
if (pNewParentDomain != NULL)
{
bUseDefaultTTL = (m_pTempDNSRecord->m_dwTtlSeconds == pNewParentDomain->GetDefaultTTL());
}
else
{
bUseDefaultTTL = (m_pTempDNSRecord->m_dwTtlSeconds == m_pParentDomainNode->GetDefaultTTL());
}
DNS_STATUS err = pRecordNode->Update(m_pTempDNSRecord, bUseDefaultTTL);
CString szFmt;
CString szMsg;
BOOL bNeedToggle = TRUE;
if (err == 0 || err == DNS_WARNING_PTR_CREATE_FAILED)
{
//
// add the node to the UI
//
if (pNewParentDomain != NULL)
{
//
// Set the container to the found domain and alter the record name to reflect this
//
pRecordNode->SetContainer(pNewParentDomain);
CString szSingleLabel;
int iFindResult = szFullRecordName.Find(L'.');
if (iFindResult != -1)
{
szSingleLabel = szFullRecordName.Left(iFindResult);
}
if (recordSearch == RECORD_NOT_FOUND)
{
pRecordNode->SetRecordName(szSingleLabel, pRecordNode->IsAtTheNode());
}
else
{
pRecordNode->SetRecordName(szSingleLabel, TRUE);
}
VERIFY(pNewParentDomain->AddChildToListAndUI(pRecordNode, m_pComponentData));
m_pComponentData->SetDescriptionBarText(pNewParentDomain);
}
SetUIData(FALSE);
if (err == DNS_WARNING_PTR_CREATE_FAILED)
{
DNSMessageBox(IDS_MSG_RECORD_WARNING_CREATE_PTR);
}
else
{
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_SUCCESS);
szMsg.Format((LPCWSTR)szFmt, (LPCWSTR)szFullRecordName);
DNSMessageBox(szMsg, MB_ICONINFORMATION | MB_OK);
}
}
else
{
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_FAIL);
szMsg.Format((LPCWSTR)szFmt, (LPCWSTR)szFullRecordName);
DNSErrorDialog(err, szMsg);
delete pRecordNode; // discarded on failure
bNeedToggle = FALSE;
}
//
// reset fields of temporary record
//
m_pTempDNSRecord->m_dwFlags = DNS_RPC_RECORD_FLAG_DEFAULT;
//
// toggle the Cancel/Done button label
//
if (bNeedToggle && m_bFirstCreation)
{
m_bFirstCreation = FALSE;
m_cancelDoneTextHelper.SetToggleState(m_bFirstCreation);
}
//
// Set the focus back to the name field
//
GetDlgItem(IDC_RR_NAME_EDIT)->SetFocus();
}
else if (recordSearch == NON_EXISTENT_SUBDOMAIN && pNewParentDomain != NULL)
{
//
// Create the record and then search for it so that we expand the newly
// created domains on the way down
//
BOOL bUseDefaultTTL = TRUE;
if (pNewParentDomain != NULL)
{
bUseDefaultTTL = (m_pTempDNSRecord->m_dwTtlSeconds == pNewParentDomain->GetDefaultTTL());
}
else
{
bUseDefaultTTL = (m_pTempDNSRecord->m_dwTtlSeconds == m_pParentDomainNode->GetDefaultTTL());
}
DNS_STATUS err = pRecordNode->Update(m_pTempDNSRecord, bUseDefaultTTL);
CString szFmt;
CString szMsg;
BOOL bNeedToggle = TRUE;
if (err == 0 || err == DNS_WARNING_PTR_CREATE_FAILED)
{
//
// add the node to the UI
//
if (pNewParentDomain != NULL)
{
//
// Set the container to the found domain and alter the record name to reflect this
//
pRecordNode->SetContainer(pNewParentDomain);
CString szSingleLabel;
int iFindResult = szFullRecordName.Find(L'.');
if (iFindResult != -1)
{
szSingleLabel = szFullRecordName.Left(iFindResult);
pRecordNode->SetRecordName(szSingleLabel, pRecordNode->IsAtTheNode());
}
ASSERT(!szNonExistentDomain.IsEmpty());
if (!szNonExistentDomain.IsEmpty())
{
//
// Create the first subdomain because the current domain is already enumerated
// so we have to start the remaining enumeration at the new subdomain that is needed
//
CDNSDomainNode* pSubdomainNode = pNewParentDomain->CreateSubdomainNode();
ASSERT(pSubdomainNode != NULL);
CDNSRootData* pRootData = (CDNSRootData*)m_pComponentData->GetRootData();
pNewParentDomain->SetSubdomainName(pSubdomainNode, szNonExistentDomain, pRootData->IsAdvancedView());
VERIFY(pNewParentDomain->AddChildToListAndUISorted(pSubdomainNode, m_pComponentData));
m_pComponentData->SetDescriptionBarText(pNewParentDomain);
//
// I don't care what the results of this are, I am just using it
// to do the expansion to the new record
//
recordSearch = pSubdomainNode->GetZoneNode()->DoesContain(szFullRecordName,
m_pComponentData,
&pNewParentDomain,
szNonExistentDomain,
TRUE);
}
}
SetUIData(FALSE);
if (err == DNS_WARNING_PTR_CREATE_FAILED)
{
DNSMessageBox(IDS_MSG_RECORD_WARNING_CREATE_PTR);
}
else
{
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_SUCCESS);
szMsg.Format((LPCWSTR)szFmt, (LPCWSTR)szFullRecordName);
DNSMessageBox(szMsg, MB_ICONINFORMATION | MB_OK);
}
}
else
{
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_FAIL);
szMsg.Format((LPCWSTR)szFmt, (LPCWSTR)szFullRecordName);
DNSErrorDialog(err, szMsg);
delete pRecordNode; // discarded on failure
bNeedToggle = FALSE;
}
//
// reset fields of temporary record
//
m_pTempDNSRecord->m_dwFlags = DNS_RPC_RECORD_FLAG_DEFAULT;
//
// toggle the Cancel/Done button label
//
if (bNeedToggle && m_bFirstCreation)
{
m_bFirstCreation = FALSE;
m_cancelDoneTextHelper.SetToggleState(m_bFirstCreation);
}
//
// Set the focus back to the name field
//
GetDlgItem(IDC_RR_NAME_EDIT)->SetFocus();
}
else
{
//
// write record to server
//
BOOL bUseDefaultTTL = TRUE;
if (pNewParentDomain != NULL)
{
bUseDefaultTTL = (m_pTempDNSRecord->m_dwTtlSeconds == pNewParentDomain->GetDefaultTTL());
}
else
{
bUseDefaultTTL = (m_pTempDNSRecord->m_dwTtlSeconds == m_pParentDomainNode->GetDefaultTTL());
}
DNS_STATUS err = pRecordNode->Update(m_pTempDNSRecord, bUseDefaultTTL);
CString szFmt;
CString szMsg;
BOOL bNeedToggle = TRUE;
if (err == 0 || err == DNS_WARNING_PTR_CREATE_FAILED)
{
if (pNewParentDomain != NULL)
{
//
// Set the container to the found domain and alter the record name to reflect this
//
pRecordNode->SetContainer(pNewParentDomain);
CString szSingleLabel;
int iFindResult = szFullRecordName.Find(L'.');
if (iFindResult != -1)
{
szSingleLabel = szFullRecordName.Left(iFindResult);
pRecordNode->SetRecordName(szSingleLabel, pRecordNode->IsAtTheNode());
}
VERIFY(pNewParentDomain->AddChildToListAndUI(pRecordNode, m_pComponentData));
m_pComponentData->SetDescriptionBarText(pNewParentDomain);
}
SetUIData(FALSE);
if (err == DNS_WARNING_PTR_CREATE_FAILED)
{
DNSMessageBox(IDS_MSG_RECORD_WARNING_CREATE_PTR);
}
else
{
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_SUCCESS);
szMsg.Format((LPCWSTR)szFmt, (LPCWSTR)szFullRecordName);
DNSMessageBox(szMsg, MB_ICONINFORMATION | MB_OK);
}
}
else
{
szFmt.LoadString(IDS_MSG_RECORD_CREATE_HOST_FAIL);
szMsg.Format((LPCWSTR)szFmt, (LPCWSTR)szFullRecordName);
DNSErrorDialog(err, szMsg);
delete pRecordNode; // discarded on failure
bNeedToggle = FALSE;
}
//
// reset fields of temporary record
//
m_pTempDNSRecord->m_dwFlags = DNS_RPC_RECORD_FLAG_DEFAULT;
//
// toggle the Cancel/Done button label
//
if (bNeedToggle && m_bFirstCreation)
{
m_bFirstCreation = FALSE;
m_cancelDoneTextHelper.SetToggleState(m_bFirstCreation);
}
//
// Set the focus back to the name field
//
GetDlgItem(IDC_RR_NAME_EDIT)->SetFocus();
}
}
Reference in a new issue View git blame Copy permalink