text: /**********************************************************************/
  /**                       Microsoft Windows/NT                       **/
  /**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
  /**********************************************************************/
  
  /*
          servpp.cpp
                  This file contains the implementation for the server
                  property page(s).
  
      FILE HISTORY:
          
  */
  
  #include "stdafx.h"
  #include "servpp.h"
  #include "server.h"
  #include "shlobj.h"
  #include "service.h"
  #include "servbind.h"
  #include "cred.h"
  
  #ifdef _DEBUG
  #define new DEBUG_NEW
  #undef THIS_FILE
  static char THIS_FILE[] = __FILE__;
  #endif
  
  /////////////////////////////////////////////////////////////////////////////
  //
  // CServerProperties holder
  //
  /////////////////////////////////////////////////////////////////////////////
  CServerProperties::CServerProperties
  (
          ITFSNode *                      pNode,
          IComponentData *        pComponentData,
          ITFSComponentData * pTFSCompData,
          LPCTSTR                         pszSheetName
  ) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName)
  {
          //ASSERT(pFolderNode == GetContainerNode());
  
          m_bAutoDeletePages = FALSE; // we have the pages as embedded members
  
          AddPageToList((CPropertyPageBase*) &m_pageGeneral);
  
          m_liVersion.QuadPart = 0;
  
      Assert(pTFSCompData != NULL);
          m_spTFSCompData.Set(pTFSCompData);
  }
  
  CServerProperties::~CServerProperties()
  {
          RemovePageFromList((CPropertyPageBase*) &m_pageGeneral, FALSE);
          
          if (m_liVersion.QuadPart >= DHCP_NT5_VERSION)
          {
                  RemovePageFromList((CPropertyPageBase*) &m_pageDns, FALSE);
          }
  
          RemovePageFromList((CPropertyPageBase*) &m_pageAdvanced, FALSE);
  }
  
  void
  CServerProperties::SetVersion
  (
          LARGE_INTEGER &  liVersion
  )
  {
          m_liVersion = liVersion;
  
          if (m_liVersion.QuadPart >= DHCP_NT5_VERSION)
          {
                  AddPageToList((CPropertyPageBase*) &m_pageDns);
          }
  
          AddPageToList((CPropertyPageBase*) &m_pageAdvanced);
  }
  
  void
  CServerProperties::SetDnsRegistration
  (
          DWORD                                   dwDynDnsFlags,
          DHCP_OPTION_SCOPE_TYPE  dhcpOptionType
  )
  {
          m_pageDns.m_dwFlags = dwDynDnsFlags;
          m_pageDns.m_dhcpOptionType = dhcpOptionType;
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  // CServerPropGeneral property page
  //
  /////////////////////////////////////////////////////////////////////////////
  
  IMPLEMENT_DYNCREATE(CServerPropGeneral, CPropertyPageBase)
  
  CServerPropGeneral::CServerPropGeneral() : CPropertyPageBase(CServerPropGeneral::IDD)
  {
          //{{AFX_DATA_INIT(CServerPropGeneral)
          m_nAuditLogging = FALSE;
          m_nAutoRefresh = FALSE;
          m_bShowBootp = FALSE;
          //}}AFX_DATA_INIT
  
          m_dwSetFlags = 0;
          m_bUpdateStatsRefresh = FALSE;
      m_uImage = 0;
  }
  
  CServerPropGeneral::~CServerPropGeneral()
  {
  }
  
  void CServerPropGeneral::DoDataExchange(CDataExchange* pDX)
  {
          CPropertyPageBase::DoDataExchange(pDX);
          //{{AFX_DATA_MAP(CServerPropGeneral)
          DDX_Control(pDX, IDC_EDIT_REFRESH_MINUTES, m_editMinutes);
          DDX_Control(pDX, IDC_EDIT_REFRESH_HOURS, m_editHours);
          DDX_Control(pDX, IDC_SPIN_REFRESH_MINUTES, m_spinMinutes);
          DDX_Control(pDX, IDC_SPIN_REFRESH_HOURS, m_spinHours);
          DDX_Control(pDX, IDC_CHECK_AUTO_REFRESH, m_checkStatAutoRefresh);
          DDX_Control(pDX, IDC_CHECK_AUDIT_LOGGING, m_checkAuditLogging);
          DDX_Check(pDX, IDC_CHECK_AUDIT_LOGGING, m_nAuditLogging);
          DDX_Check(pDX, IDC_CHECK_AUTO_REFRESH, m_nAutoRefresh);
          DDX_Check(pDX, IDC_CHECK_SHOW_BOOTP, m_bShowBootp);
          DDX_Text(pDX, IDC_EDIT_REFRESH_MINUTES, m_nMinutes);
          DDX_Text(pDX, IDC_EDIT_REFRESH_HOURS, m_nHours);
          //}}AFX_DATA_MAP
  }
  
  
  BEGIN_MESSAGE_MAP(CServerPropGeneral, CPropertyPageBase)
          //{{AFX_MSG_MAP(CServerPropGeneral)
          ON_BN_CLICKED(IDC_CHECK_AUTO_REFRESH, OnCheckAutoRefresh)
          ON_BN_CLICKED(IDC_CHECK_AUDIT_LOGGING, OnCheckAuditLogging)
          ON_EN_CHANGE(IDC_EDIT_REFRESH_HOURS, OnChangeEditRefreshHours)
          ON_EN_CHANGE(IDC_EDIT_REFRESH_MINUTES, OnChangeEditRefreshMinutes)
          ON_BN_CLICKED(IDC_CHECK_SHOW_BOOTP, OnCheckShowBootp)
          //}}AFX_MSG_MAP
  END_MESSAGE_MAP()
  
  /////////////////////////////////////////////////////////////////////////////
  // CServerPropGeneral message handlers
  
  
  BOOL CServerPropGeneral::OnApply() 
  {
          UpdateData();
  
      BOOL bRet = CPropertyPageBase::OnApply();
  
          if (bRet == FALSE)
          {
                  // Something bad happened... grab the error code
                  AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
                  ::DhcpMessageBox(GetHolder()->GetError());
          }
      else
      {
          m_dwSetFlags = 0;
      }
  
      return bRet;
  }
  
  BOOL CServerPropGeneral::OnInitDialog() 
  {
      CPropertyPageBase::OnInitDialog();
      
      if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart < DHCP_SP2_VERSION) {
          // bootp and audit logging available.  Hide the options
          // to show bootp and classid
          m_checkAuditLogging.EnableWindow(FALSE);
          
          GetDlgItem(IDC_CHECK_SHOW_BOOTP)->ShowWindow(SW_HIDE);
      }
  
      m_spinMinutes.SetRange(0, 59);
      m_spinHours.SetRange(0, 23);
      
      m_editMinutes.LimitText(2);
      m_editHours.LimitText(2);
      
      DWORD dwRefreshInterval = m_dwRefreshInterval;
      
      m_nHours = dwRefreshInterval / MILLISEC_PER_HOUR;
      dwRefreshInterval -= m_nHours * MILLISEC_PER_HOUR;
      
      m_nMinutes = dwRefreshInterval / MILLISEC_PER_MINUTE;
      
      m_spinHours.SetPos(m_nHours);
      m_spinMinutes.SetPos(m_nMinutes);
          
      OnCheckAutoRefresh();
  
      m_dwSetFlags = 0;
      m_bUpdateStatsRefresh = FALSE;
  
      // 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;  // return TRUE unless you set the focus to a control
                        // EXCEPTION: OCX Property Pages should return FALSE
  }
  
  void CServerPropGeneral::OnCheckAutoRefresh() 
  {
          int nCheck = m_checkStatAutoRefresh.GetCheck();
          
          m_editHours.EnableWindow(nCheck);
          m_editMinutes.EnableWindow(nCheck);
  
          m_spinHours.EnableWindow(nCheck);
          m_spinMinutes.EnableWindow(nCheck);
  
          m_bUpdateStatsRefresh = TRUE;
  
          SetDirty(TRUE);
  }
  
  void CServerPropGeneral::OnCheckAuditLogging() 
  {
          m_dwSetFlags |= Set_AuditLogState;
  
          SetDirty(TRUE);
  }
  
  BOOL CServerPropGeneral::OnPropertyChange(BOOL bScope, LONG_PTR *ChangeMask)
  {
      SPITFSNode      spNode;
      SPITFSNode      spRootNode;
      CDhcpServer    *pServer;
      DWORD           dwError;
  
      BEGIN_WAIT_CURSOR;
  
      spNode = GetHolder()->GetNode();
      spNode->GetParent(&spRootNode);
      
      pServer = GETHANDLER(CDhcpServer, spNode);
      
      if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart >= DHCP_SP2_VERSION) {
          if (m_dwSetFlags) {
              dwError = pServer->SetConfigInfo(m_nAuditLogging, pServer->GetPingRetries());
              if (dwError != ERROR_SUCCESS) {
                  GetHolder()->SetError(dwError);
              }
          }
      }
  
      if (m_bUpdateStatsRefresh) {
   
          m_dwRefreshInterval =  ( m_nHours * MILLISEC_PER_HOUR ) +
              ( m_nMinutes * MILLISEC_PER_MINUTE );
          pServer->SetAutoRefresh(spNode, m_nAutoRefresh, m_dwRefreshInterval );
          
          // mark the console as dirty
          spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
      } // if m_bUpdateStatsRefresh
  
      // hide/show bootp and classid
      pServer->ShowNode(spNode, DHCPSNAP_BOOTP_TABLE, m_bShowBootp);
  
      DWORD dwServerOptions = pServer->GetServerOptions();
  
      // update options if they have changed
      if (dwServerOptions != pServer->GetServerOptions()) {
          pServer->SetServerOptions(dwServerOptions);
          
          // mark the console as dirty
          spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
      }
      
      END_WAIT_CURSOR;
      
      return FALSE;
  } // CServerPropGeneral::OnPropertyChange()
  
  void CServerPropGeneral::OnChangeEditRefreshHours() 
  {
      m_bUpdateStatsRefresh = TRUE;
      ValidateRefreshInterval();
      SetDirty(TRUE);
  }
  
  void CServerPropGeneral::OnChangeEditRefreshMinutes() 
  {
      m_bUpdateStatsRefresh = TRUE;
      ValidateRefreshInterval();
      SetDirty(TRUE);
  }
  
  void CServerPropGeneral::ValidateRefreshInterval()
  {
      CString strText;
      int hour = 0, min = 0;
  
      hour = m_spinHours.GetPos();
      min = m_spinMinutes.GetPos();
      if ( hour > HOURS_MAX ) {
          m_spinHours.SetPos( HOURS_MAX );
          MessageBeep( MB_ICONEXCLAMATION );
      }
      if ( min > MINUTES_MAX ) {
          m_spinMinutes.SetPos( MINUTES_MAX );
          MessageBeep( MB_ICONEXCLAMATION );
      }
      if (( 0 == hour ) && ( 0 == min )) {
          m_spinMinutes.SetPos( 1 );
          MessageBeep( MB_ICONEXCLAMATION );
      }
  
  } // CServerPropGeneral::ValidateRefreshInterval()
  
  void CServerPropGeneral::OnCheckShowBootp() 
  {
          SetDirty(TRUE);
  }
  
  /////////////////////////////////////////////////////////////////////////////
  // CServerPropAdvanced property page
  
  IMPLEMENT_DYNCREATE(CServerPropAdvanced, CPropertyPageBase)
  
  CServerPropAdvanced::CServerPropAdvanced() : CPropertyPageBase(CServerPropAdvanced::IDD)
  {
          //{{AFX_DATA_INIT(CServerPropAdvanced)
          //}}AFX_DATA_INIT
  
      m_nConflictAttempts = 0;
      m_fPathChange = FALSE;
  }
  
  CServerPropAdvanced::~CServerPropAdvanced()
  {
  }
  
  void CServerPropAdvanced::DoDataExchange(CDataExchange* pDX)
  {
          CPropertyPageBase::DoDataExchange(pDX);
          //{{AFX_DATA_MAP(CServerPropAdvanced)
          DDX_Control(pDX, IDC_STATIC_CREDENTIALS, m_staticCredentials);
          DDX_Control(pDX, IDC_BUTTON_CREDENTIALS, m_buttonCredentials);
          DDX_Control(pDX, IDC_BUTTON_BROWSE_BACKUP, m_buttonBrowseBackup);
          DDX_Control(pDX, IDC_STATIC_MODIFY_BINDINGS_STRING, m_staticBindings);
          DDX_Control(pDX, IDC_BUTTON_BINDINGS, m_buttonBindings);
          DDX_Control(pDX, IDC_STATIC_DATABASE, m_staticDatabase);
          DDX_Control(pDX, IDC_BUTTON_BROWSE_DATABASE, m_buttonBrowseDatabase);
          DDX_Control(pDX, IDC_EDIT_DATABASE_PATH, m_editDatabasePath);
          DDX_Control(pDX, IDC_BUTTON_BROWSE_LOG, m_buttonBrowseLog);
          DDX_Control(pDX, IDC_EDIT_LOG_PATH, m_editAuditLogPath);
          DDX_Control(pDX, IDC_EDIT_BACKUP, m_editBackupPath);
          DDX_Control(pDX, IDC_STATIC_LOGFILE, m_staticLogFile);
          DDX_Control(pDX, IDC_SPIN_CONFLICT_ATTEMPTS, m_spinConflictAttempts);
          DDX_Control(pDX, IDC_EDIT_CONFLICT_ATTEMPTS, m_editConflictAttempts);
          //}}AFX_DATA_MAP
  }
  
  
  BEGIN_MESSAGE_MAP(CServerPropAdvanced, CPropertyPageBase)
          //{{AFX_MSG_MAP(CServerPropAdvanced)
          ON_BN_CLICKED(IDC_BUTTON_BROWSE_DATABASE, OnButtonBrowseDatabase)
          ON_BN_CLICKED(IDC_BUTTON_BROWSE_LOG, OnButtonBrowseLog)
          ON_EN_CHANGE(IDC_EDIT_CONFLICT_ATTEMPTS, OnChangeEditConflictAttempts)
          ON_EN_CHANGE(IDC_EDIT_DATABASE_PATH, OnChangeEditDatabasePath)
          ON_EN_CHANGE(IDC_EDIT_LOG_PATH, OnChangeEditLogPath)
          ON_BN_CLICKED(IDC_BUTTON_BINDINGS, OnButtonBindings)
          ON_BN_CLICKED(IDC_BUTTON_BROWSE_BACKUP, OnButtonBrowseBackup)
          ON_EN_CHANGE(IDC_EDIT_BACKUP, OnChangeEditBackup)
          ON_BN_CLICKED(IDC_BUTTON_CREDENTIALS, OnButtonCredentials)
          //}}AFX_MSG_MAP
  END_MESSAGE_MAP()
  
  /////////////////////////////////////////////////////////////////////////////
  // CServerPropAdvanced message handlers
  
  BOOL CServerPropAdvanced::OnInitDialog() 
  {
      BOOL  fEnable = FALSE;
      TCHAR szBuffer[64];
      DWORD dwSize = sizeof( szBuffer ) / sizeof( TCHAR );
      SPITFSNode      spNode;
      CDhcpServer *   pServer;
      DWORD           dwError;
  
  
      CPropertyPageBase::OnInitDialog();
          
          // check to see if this is the local machine.  If so, enable the browse buttons
      BEGIN_WAIT_CURSOR;
      GetMachineName(m_strComputerName);
      END_WAIT_CURSOR;
  
      GetComputerName(szBuffer, &dwSize);
  
      if (m_strComputerName.CompareNoCase(szBuffer) == 0)
          fEnable = TRUE;
  
      // can only browse for folders if this is the local machine
      m_buttonBrowseLog.EnableWindow(fEnable);
      m_buttonBrowseDatabase.EnableWindow(fEnable);
      m_buttonBrowseBackup.EnableWindow(fEnable);
  
      // enable Bindings button only if server allows bindings..
      // also hide the buttons if they are not enabled.
      spNode = GetHolder()->GetNode();
      pServer = GETHANDLER(CDhcpServer, spNode);
  
      if( FALSE == pServer->FSupportsBindings() ) {
          m_buttonBindings.EnableWindow(FALSE);
          m_staticBindings.EnableWindow(FALSE);
          m_buttonBindings.ShowWindow(SW_HIDE);
          m_staticBindings.ShowWindow(SW_HIDE);
      }
  
      // enable the appropriate controls based on the server version  
          if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart < DHCP_NT5_VERSION)
          {
          // changing the audit logging path only available on NT5
          m_buttonBrowseLog.EnableWindow(FALSE);
          m_staticLogFile.EnableWindow(FALSE);
          m_editAuditLogPath.EnableWindow(FALSE);
      }
  
          if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart < DHCP_NT51_VERSION)
          {
          // DHCP credentials for Dynamic DNS registrations available on this version.
          m_buttonCredentials.EnableWindow(FALSE);
      }
  
      if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart < DHCP_SP2_VERSION)
          {
                  // conflict detection not available
                  m_editConflictAttempts.EnableWindow(FALSE);
                  m_spinConflictAttempts.EnableWindow(FALSE);
          }
          else
          {
                  m_spinConflictAttempts.SetPos(m_nConflictAttempts);
          }
  
      m_spinConflictAttempts.SetRange(0,5);
  
          m_dwSetFlags = 0;
  
      // set the path's
      m_editAuditLogPath.SetWindowText(m_strAuditLogPath);
      m_editDatabasePath.SetWindowText(m_strDatabasePath);
      m_editBackupPath.SetWindowText(m_strBackupPath);
      
      m_fPathChange = FALSE;
      SetDirty(FALSE);
  
          return TRUE;  // return TRUE unless you set the focus to a control
                        // EXCEPTION: OCX Property Pages should return FALSE
  }
  
  BOOL CServerPropAdvanced::OnApply() 
  {
          UpdateData();
  
      AFX_MANAGE_STATE(AfxGetStaticModuleState());
  
      BOOL fRestartService = FALSE;
  
          if (m_fPathChange)
      {
          if (AfxMessageBox(IDS_PATH_CHANGE_RESTART_SERVICE, MB_YESNO) == IDYES)
          {
              fRestartService = TRUE;        
          }
      }
      
      m_nConflictAttempts = m_spinConflictAttempts.GetPos();
  
      m_editAuditLogPath.GetWindowText(m_strAuditLogPath);
      m_editDatabasePath.GetWindowText(m_strDatabasePath);
      m_editBackupPath.GetWindowText(m_strBackupPath);
  
      BOOL bRet = CPropertyPageBase::OnApply();
  
      if (bRet == FALSE) {
  	// Something bad happened... grab the error code
  	// AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
  	::DhcpMessageBox(GetHolder()->GetError());
      }
      else  {
  	if (fRestartService) {
  	    SPITFSNode spNode;
  	    SPITFSNode spRootNode;
  	    CDhcpServer *pServer;
  	    SPIConsole  spConsole;
  
  	    spNode = GetHolder()->GetNode();
  	    spNode->GetParent( &spRootNode );
  	    pServer = GETHANDLER( CDhcpServer, spNode );
  
  	    // Restart the server
  	    pServer->RestartService( spRootNode );
              
  	    // Refresh the server node
  	    CMTDhcpHandler *pMTHandler = GETHANDLER( CMTDhcpHandler, spNode );
  	    pMTHandler->OnRefresh( spNode, NULL, 0, 0, 0 );
  
  	} // if
  
  	m_fPathChange = FALSE;
  	m_dwSetFlags = 0;
  
      } // else
  	
      return bRet;
  } // CServerPropAdvanced::OnApply()
  
  BOOL CServerPropAdvanced::OnPropertyChange(BOOL bScope, LONG_PTR *ChangeMask)
  {
      SPITFSNode      spNode;
      CDhcpServer *   pServer;
      DWORD           dwError;
      
      BEGIN_WAIT_CURSOR;
      
      spNode = GetHolder()->GetNode();
      pServer = GETHANDLER(CDhcpServer, spNode);
      
      if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart >= DHCP_NT5_VERSION) {
  	// Get all of the parameters so we can just change the audit log path
  	LPWSTR pAuditLogPath = NULL;
  	DWORD  dwDiskCheckInterval = 0, dwMaxLogFilesSize = 0, dwMinSpaceOnDisk = 0;
  	
  	dwError = ::DhcpAuditLogGetParams((LPWSTR) pServer->GetIpAddress(),
  					  0,
  					  &pAuditLogPath,
  					  &dwDiskCheckInterval,
  					  &dwMaxLogFilesSize,
  					  &dwMinSpaceOnDisk);
  	if (dwError == ERROR_SUCCESS) {
  	    ::DhcpRpcFreeMemory(pAuditLogPath);
  	    
  	    dwError = ::DhcpAuditLogSetParams((LPWSTR) pServer->GetIpAddress(),
  					      0,
  					      (LPWSTR) (LPCTSTR) m_strAuditLogPath,
  					      dwDiskCheckInterval,
  					      dwMaxLogFilesSize,
  					      dwMinSpaceOnDisk);
  	    if (dwError != ERROR_SUCCESS) {
  		GetHolder()->SetError(dwError);
  	    }
              else {
  		// don't update this until the service is restarted...
                  //pServer->SetAuditLogPath(m_strAuditLogPath);
              }
  	} // if success
      } // if NT5
  
      int nPingRetries = pServer->GetPingRetries();
  
      if (((CServerProperties *) GetHolder())->m_liVersion.QuadPart >= DHCP_SP2_VERSION) {
          // only available on NT4 Sp2 and higher
          nPingRetries = m_nConflictAttempts;
      }
      
      dwError = pServer->SetConfigInfo(pServer->GetAuditLogging(),
  				     nPingRetries, m_strDatabasePath,
  				     m_strBackupPath);
      if (dwError != ERROR_SUCCESS) {
  	GetHolder()->SetError(dwError);
      }
      
      END_WAIT_CURSOR;
      
      return FALSE;
  } // CServerPropAdvanced::OnPropertyChange()
  
  void CServerPropAdvanced::OnButtonBrowseDatabase() 
  {
      CString strNewPath, strHelpText;
      strHelpText.LoadString(IDS_BROWSE_DATABASE_PATH);
  
      UtilGetFolderName(m_strDatabasePath, strHelpText, strNewPath);
  
      if (!strNewPath.IsEmpty() && 
          strNewPath.CompareNoCase(m_strDatabasePath) != 0)
      {
          m_strDatabasePath = strNewPath;
          m_editDatabasePath.SetWindowText(strNewPath);
      }
  }
  
  void CServerPropAdvanced::OnButtonBrowseLog() 
  {
      CString strNewPath, strHelpText;
      strHelpText.LoadString(IDS_BROWSE_LOG_PATH);
  
      UtilGetFolderName(m_strAuditLogPath, strHelpText, strNewPath);
  
      if (!strNewPath.IsEmpty() && 
          strNewPath.CompareNoCase(m_strAuditLogPath) != 0)
      {
          m_strAuditLogPath = strNewPath;
          m_editAuditLogPath.SetWindowText(m_strAuditLogPath);
  
          SetDirty(TRUE);
      }
  }
  
  void CServerPropAdvanced::OnButtonBrowseBackup() 
  {
      CString strNewPath, strHelpText;
      strHelpText.LoadString(IDS_BACKUP_HELP);
  
      UtilGetFolderName(m_strBackupPath, strHelpText, strNewPath);
  
      if (!strNewPath.IsEmpty() && 
          strNewPath.CompareNoCase(m_strBackupPath) != 0)
      {
          m_strBackupPath = strNewPath;
          m_editBackupPath.SetWindowText(m_strBackupPath);
  
          SetDirty(TRUE);
      }
  }
  
  void CServerPropAdvanced::OnChangeEditConflictAttempts() 
  {
          m_dwSetFlags |= Set_PingRetries;
  
          SetDirty(TRUE);
  }
  
  void CServerPropAdvanced::OnChangeEditDatabasePath() 
  {
      m_fPathChange = TRUE;
      SetDirty(TRUE);
  }
  
  void CServerPropAdvanced::OnChangeEditLogPath() 
  {
      m_fPathChange = TRUE;
      SetDirty(TRUE);
  }
  
  void CServerPropAdvanced::OnChangeEditBackup() 
  {
      SetDirty(TRUE);
  }
  
  DWORD
  CServerPropAdvanced::GetMachineName(CString & strName)
  {
      CString strHostName, strNetbiosName;
      DHC_HOST_INFO_STRUCT dhcHostInfo;
  
      ::UtilGetHostInfo(m_dwIp, &dhcHostInfo);
  
      strHostName = dhcHostInfo._chHostName;
      strNetbiosName = dhcHostInfo._chNetbiosName;
  
      if (strNetbiosName.IsEmpty())
          strName = strHostName;
      else
          strName = strNetbiosName;
  
      // strip off any periods
      int nIndex = strName.Find(_T("."));
      if (nIndex > 0)
          strName = strName.Left(nIndex);
  
      return ERROR_SUCCESS;
  
  }
  
  
  void CServerPropAdvanced::OnButtonBindings() 
  {
      SPITFSNode      spNode;
      CDhcpServer *   pServer;
  
      spNode = GetHolder()->GetNode();
      pServer = GETHANDLER(CDhcpServer, spNode);
  
      CServerBindings BindingsDialog(pServer);
  
      BindingsDialog.DoModal();
  
      // if there is an error in CServerBindings.OnInitDialog,
      // it calls OnCancel, and for some reason loses focus.
      // So, regain focus.
      SetFocus();
  }
  
  
  void CServerPropAdvanced::OnButtonCredentials() 
  {
      CCredentials    dlgCred;
          SPITFSNode      spNode;
          CDhcpServer *   pServer;
  
      spNode = GetHolder()->GetNode();
          pServer = GETHANDLER(CDhcpServer, spNode);
      
      dlgCred.SetServerIp(pServer->GetIpAddress());
  
      dlgCred.DoModal();
  }
  