2077 lines
53 KiB
C++
2077 lines
53 KiB
C++
|
/**********************************************************************/
|
||
|
/** Microsoft Windows/NT **/
|
||
|
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
|
||
|
/**********************************************************************/
|
||
|
|
||
|
/*
|
||
|
srvlatpp.cpp
|
||
|
Brings up the property page for the server node
|
||
|
|
||
|
FILE HISTORY:
|
||
|
|
||
|
*/
|
||
|
|
||
|
#include "stdafx.h"
|
||
|
#include "winssnap.h"
|
||
|
#include "shlobj.h"
|
||
|
#include "srvlatpp.h"
|
||
|
|
||
|
#include "server.h"
|
||
|
#include "service.h"
|
||
|
|
||
|
#ifdef _DEBUG
|
||
|
#define new DEBUG_NEW
|
||
|
#undef THIS_FILE
|
||
|
static char THIS_FILE[] = __FILE__;
|
||
|
#endif
|
||
|
|
||
|
#define MAX_HOURS 23
|
||
|
#define MAX_MINUTES 59
|
||
|
#define MAX_SECONDS 59
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropGeneral property page
|
||
|
|
||
|
IMPLEMENT_DYNCREATE(CServerPropGeneral, CPropertyPageBase)
|
||
|
|
||
|
CServerPropGeneral::CServerPropGeneral() : CPropertyPageBase(CServerPropGeneral::IDD)
|
||
|
{
|
||
|
//{{AFX_DATA_INIT(CServerPropGeneral)
|
||
|
m_fBackupDB = FALSE;
|
||
|
m_fEnableAutoRefresh = FALSE;
|
||
|
m_strBackupPath = _T("");
|
||
|
m_nRefreshHours = 0;
|
||
|
m_nRefreshMinutes = 0;
|
||
|
m_nRefreshSeconds = 0;
|
||
|
//}}AFX_DATA_INIT
|
||
|
|
||
|
m_fUpdateConfig = FALSE;
|
||
|
}
|
||
|
|
||
|
CServerPropGeneral::~CServerPropGeneral()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
CServerPropGeneral::DoDataExchange(CDataExchange* pDX)
|
||
|
{
|
||
|
CPropertyPageBase::DoDataExchange(pDX);
|
||
|
//{{AFX_DATA_MAP(CServerPropGeneral)
|
||
|
DDX_Control(pDX, IDC_EDIT_REFRESH_MINUTES2, m_editRefreshMn);
|
||
|
DDX_Control(pDX, IDC_EDIT_REFRESH_HOURS2, m_editRefreshHr);
|
||
|
DDX_Control(pDX, IDC_EDIT_REFRESH_SECONDS2, m_editRefreshSc);
|
||
|
DDX_Control(pDX, IDC_SPIN_REFRESH_SECONDS2, m_spinRefreshSc);
|
||
|
DDX_Control(pDX, IDC_SPIN_REFRESH_MINUTES2, m_spinRefreshmn);
|
||
|
DDX_Control(pDX, IDC_SPIN_REFRESH_HOURS2, m_spinRefreshHr);
|
||
|
DDX_Control(pDX, IDC_EDIT_BACKUPPATH, m_editBackupPath);
|
||
|
DDX_Control(pDX, IDC_CHECK_BACKUPDB, m_check_BackupOnTermination);
|
||
|
DDX_Control(pDX, IDC_CHECK_ENABLE_AUTOREFRESH, m_check_EnableAutoRefresh);
|
||
|
DDX_Control(pDX, IDC_BUTTON_BROWSE, m_button_Browse);
|
||
|
DDX_Check(pDX, IDC_CHECK_BACKUPDB, m_fBackupDB);
|
||
|
DDX_Check(pDX, IDC_CHECK_ENABLE_AUTOREFRESH, m_fEnableAutoRefresh);
|
||
|
DDX_Text(pDX, IDC_EDIT_BACKUPPATH, m_strBackupPath);
|
||
|
DDX_Text(pDX, IDC_EDIT_REFRESH_HOURS2, m_nRefreshHours);
|
||
|
DDV_MinMaxInt(pDX, m_nRefreshHours, 0, MAX_HOURS);
|
||
|
DDX_Text(pDX, IDC_EDIT_REFRESH_MINUTES2, m_nRefreshMinutes);
|
||
|
DDV_MinMaxInt(pDX, m_nRefreshMinutes, 0, MAX_MINUTES);
|
||
|
DDX_Text(pDX, IDC_EDIT_REFRESH_SECONDS2, m_nRefreshSeconds);
|
||
|
DDV_MinMaxInt(pDX, m_nRefreshSeconds, 0, MAX_SECONDS);
|
||
|
//}}AFX_DATA_MAP
|
||
|
}
|
||
|
|
||
|
|
||
|
BEGIN_MESSAGE_MAP(CServerPropGeneral, CPropertyPageBase)
|
||
|
//{{AFX_MSG_MAP(CServerPropGeneral)
|
||
|
ON_BN_CLICKED(IDC_BUTTON_BROWSE, OnButtonBrowse)
|
||
|
ON_BN_CLICKED(IDC_CHECK_ENABLE_AUTOREFRESH, OnCheckEnableAutorefresh)
|
||
|
ON_EN_CHANGE(IDC_EDIT_BACKUPPATH, OnChangeEditBackuppath)
|
||
|
ON_EN_CHANGE(IDC_EDIT_REFRESH_HOURS2, OnChangeRefresh)
|
||
|
ON_EN_CHANGE(IDC_EDIT_REFRESH_MINUTES2, OnChangeRefresh)
|
||
|
ON_EN_CHANGE(IDC_EDIT_REFRESH_SECONDS2, OnChangeRefresh)
|
||
|
ON_BN_CLICKED(IDC_CHECK_BACKUPDB, OnChangeCheckBackupdb)
|
||
|
//}}AFX_MSG_MAP
|
||
|
END_MESSAGE_MAP()
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropGeneral message handlers
|
||
|
BOOL
|
||
|
CServerPropGeneral::OnApply()
|
||
|
{
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_fUpdateConfig = FALSE;
|
||
|
|
||
|
return CPropertyPageBase::OnApply();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
CServerPropGeneral::OnOK()
|
||
|
{
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (SUCCEEDED(hr))
|
||
|
{
|
||
|
CPropertyPageBase::OnOK();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
BOOL
|
||
|
CServerPropGeneral::OnInitDialog()
|
||
|
{
|
||
|
CPropertyPageBase::OnInitDialog();
|
||
|
|
||
|
GetConfig();
|
||
|
|
||
|
m_fBackupDB = m_pConfig->m_fBackupOnTermination;
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
SetRefreshData();
|
||
|
|
||
|
if (pServer->m_dwFlags & FLAG_AUTO_REFRESH)
|
||
|
{
|
||
|
m_fEnableAutoRefresh = TRUE;
|
||
|
m_check_EnableAutoRefresh.SetCheck(1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_fEnableAutoRefresh = FALSE;
|
||
|
m_check_EnableAutoRefresh.SetCheck(0);
|
||
|
|
||
|
// diable the controls
|
||
|
m_spinRefreshHr.EnableWindow(FALSE);
|
||
|
m_spinRefreshmn.EnableWindow(FALSE);
|
||
|
m_spinRefreshSc.EnableWindow(FALSE);
|
||
|
|
||
|
m_editRefreshHr.EnableWindow(FALSE);
|
||
|
m_editRefreshMn.EnableWindow(FALSE);
|
||
|
m_editRefreshSc.EnableWindow(FALSE);
|
||
|
}
|
||
|
|
||
|
m_spinRefreshHr.SetRange(0, 23);
|
||
|
m_spinRefreshmn.SetRange(0, 59);
|
||
|
m_spinRefreshSc.SetRange(0, 59);
|
||
|
|
||
|
// browse only available on local machine
|
||
|
m_button_Browse.EnableWindow(IsLocalConnection());
|
||
|
|
||
|
m_check_BackupOnTermination.SetCheck(m_pConfig->m_fBackupOnTermination);
|
||
|
|
||
|
m_editBackupPath.SetWindowText(m_pConfig->m_strBackupPath);
|
||
|
|
||
|
// 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;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_fUpdateConfig = FALSE;
|
||
|
|
||
|
SetDirty(FALSE);
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
void CServerPropGeneral::OnChangeEditBackuppath()
|
||
|
{
|
||
|
m_fUpdateConfig = TRUE;
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropGeneral::OnChangeRefresh()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropGeneral::OnChangeCheckBackupdb()
|
||
|
{
|
||
|
m_fUpdateConfig = TRUE;
|
||
|
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::IsLocalConnection()
|
||
|
Checks if the local machine is being monitored
|
||
|
---------------------------------------------------------------------------*/
|
||
|
BOOL
|
||
|
CServerPropGeneral::IsLocalConnection()
|
||
|
{
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
return pServer->IsLocalConnection();
|
||
|
}
|
||
|
|
||
|
void
|
||
|
CServerPropGeneral::OnButtonBrowse()
|
||
|
{
|
||
|
TCHAR szBuffer[MAX_PATH];
|
||
|
|
||
|
LPITEMIDLIST pidlPrograms = NULL; //CSIDL_DRIVES
|
||
|
SHGetSpecialFolderLocation(m_hWnd, CSIDL_DRIVES, &pidlPrograms);
|
||
|
|
||
|
BROWSEINFO browseInfo;
|
||
|
browseInfo.hwndOwner = m_hWnd;
|
||
|
browseInfo.pidlRoot = pidlPrograms;
|
||
|
browseInfo.pszDisplayName = szBuffer;
|
||
|
|
||
|
CString strSel;
|
||
|
strSel.LoadString(IDS_SELECT_FOLDER);
|
||
|
|
||
|
browseInfo.lpszTitle = strSel;
|
||
|
browseInfo.ulFlags = BIF_NEWDIALOGSTYLE | BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS ;
|
||
|
browseInfo.lpfn = NULL;
|
||
|
browseInfo.lParam = 0;
|
||
|
|
||
|
LPITEMIDLIST pidlBrowse = SHBrowseForFolder(&browseInfo);
|
||
|
|
||
|
if (pidlBrowse)
|
||
|
{
|
||
|
SHGetPathFromIDList(pidlBrowse, szBuffer);
|
||
|
|
||
|
CString strBackupPath(szBuffer);
|
||
|
|
||
|
// check if it's a network drive, if yes, don't allow.
|
||
|
/* int nPos = strBackupPath.Find(_T("\\"));
|
||
|
|
||
|
if (nPos != -1)
|
||
|
{
|
||
|
CString strDrive = strBackupPath.Left(nPos);
|
||
|
|
||
|
UINT uType = GetDriveType(strDrive);
|
||
|
|
||
|
if(uType == DRIVE_REMOTE)
|
||
|
{
|
||
|
// tell the user that the files ccanot be backed up the location chosen
|
||
|
CString strBackup;
|
||
|
AfxFormatString1(strBackup, IDS_BACKUP_LOCATION, strBackupPath);
|
||
|
AfxMessageBox(strBackup, MB_OK | MB_ICONINFORMATION);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
*/
|
||
|
if (!strBackupPath.IsEmpty())
|
||
|
m_editBackupPath.SetWindowText(strBackupPath);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::UpdateServerConfiguration()
|
||
|
Updates the variables in the Server Handler
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropGeneral::UpdateServerConfiguration()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
// Reflect the changes in the server's CConfiguration object
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
// update config displays any necessary error dialogs
|
||
|
if (!UpdateConfig())
|
||
|
return E_FAIL;
|
||
|
|
||
|
DWORD err = ERROR_SUCCESS;
|
||
|
|
||
|
// now write to server
|
||
|
if (m_fUpdateConfig)
|
||
|
{
|
||
|
err = m_pConfig->Store();
|
||
|
if (err != ERROR_SUCCESS)
|
||
|
{
|
||
|
// something bad happened
|
||
|
WinsMessageBox(err);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// success update our local copy
|
||
|
pServer->SetConfig(*m_pConfig);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return HRESULT_FROM_WIN32(err);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::UpdateConfig()
|
||
|
Updates the Config object in the server handler
|
||
|
---------------------------------------------------------------------------*/
|
||
|
BOOL
|
||
|
CServerPropGeneral::UpdateConfig()
|
||
|
{
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
CString strTemp;
|
||
|
m_editBackupPath.GetWindowText(strTemp);
|
||
|
|
||
|
// backup path needs to be non-null when backup on termination is set
|
||
|
if (m_fBackupDB && strTemp.IsEmpty())
|
||
|
{
|
||
|
AfxMessageBox(IDS_SPECIFY_DEFAULT_BACKUP_PATH);
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
if (m_fUpdateConfig)
|
||
|
{
|
||
|
m_pConfig->m_strBackupPath = strTemp;
|
||
|
m_pConfig->m_fBackupOnTermination = m_fBackupDB;
|
||
|
}
|
||
|
|
||
|
pServer->m_dwRefreshInterval = CalculateRefrInt();
|
||
|
|
||
|
if (m_fEnableAutoRefresh)
|
||
|
{
|
||
|
pServer->m_dwFlags |= FLAG_AUTO_REFRESH;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pServer->m_dwFlags &= ~FLAG_AUTO_REFRESH;
|
||
|
}
|
||
|
|
||
|
// since these settins are stored in the console file, mark it as dirty
|
||
|
SPITFSNode spRootNode;
|
||
|
spNode->GetParent(&spRootNode);
|
||
|
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::CalculateRefrInt()
|
||
|
Rteurns the refresh interval in seconds
|
||
|
---------------------------------------------------------------------------*/
|
||
|
int
|
||
|
CServerPropGeneral::CalculateRefrInt()
|
||
|
{
|
||
|
UpdateData();
|
||
|
CString strValue;
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
int nHour = m_spinRefreshHr.GetPos();
|
||
|
int nMinute = m_spinRefreshmn.GetPos();
|
||
|
int nSecond = m_spinRefreshSc.GetPos();
|
||
|
|
||
|
int nRenewInterval = nHour * SEC_PER_HOUR +
|
||
|
nMinute * SEC_PER_MINUTE +
|
||
|
nSecond;
|
||
|
|
||
|
pServer->m_dwRefreshInterval = nRenewInterval;
|
||
|
pServer->m_dlgStats.ReInitRefresherThread();
|
||
|
|
||
|
return nRenewInterval;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::ToString(int nNumber)
|
||
|
Returns string value of an integer
|
||
|
---------------------------------------------------------------------------*/
|
||
|
CString
|
||
|
CServerPropGeneral::ToString(int nNumber)
|
||
|
{
|
||
|
TCHAR szStr[20];
|
||
|
_itot(nNumber, szStr, 10);
|
||
|
CString str(szStr);
|
||
|
return str;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::SetRefreshData()
|
||
|
Sets the variables' dtata for the refresh group.
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropGeneral::SetRefreshData()
|
||
|
{
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
DWORD dwInterval = pServer->m_dwRefreshInterval;
|
||
|
|
||
|
m_spinRefreshmn.SetRange(0, MAX_MINUTES);
|
||
|
m_spinRefreshSc.SetRange(0, MAX_SECONDS);
|
||
|
m_spinRefreshHr.SetRange(0, UD_MAXVAL);
|
||
|
|
||
|
int nHours, nMinutes, nSeconds;
|
||
|
|
||
|
nHours = dwInterval / SEC_PER_HOUR;
|
||
|
|
||
|
dwInterval -= nHours * SEC_PER_HOUR;
|
||
|
|
||
|
nMinutes = dwInterval / SEC_PER_MINUTE;
|
||
|
dwInterval -= nMinutes * SEC_PER_MINUTE;
|
||
|
|
||
|
nSeconds = dwInterval ;
|
||
|
|
||
|
// convert them to strings
|
||
|
CString strHr = ToString(nHours);
|
||
|
CString strMn = ToString(nMinutes);
|
||
|
CString strSc = ToString(nSeconds);
|
||
|
|
||
|
m_spinRefreshHr.SetPos(nHours);
|
||
|
m_spinRefreshmn.SetPos(nMinutes);
|
||
|
m_spinRefreshSc.SetPos(nSeconds);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropGeneral::GetConfig()
|
||
|
Gets the Configuration object from the server
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropGeneral::GetConfig()
|
||
|
{
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
HRESULT hr = hrOK;
|
||
|
|
||
|
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
|
||
|
|
||
|
return hr;
|
||
|
}
|
||
|
|
||
|
|
||
|
void CServerPropGeneral::OnCheckEnableAutorefresh()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
|
||
|
UpdateData();
|
||
|
|
||
|
if (m_check_EnableAutoRefresh.GetCheck() == 1)
|
||
|
{
|
||
|
m_fEnableAutoRefresh = TRUE;
|
||
|
m_spinRefreshHr.EnableWindow(TRUE);
|
||
|
m_spinRefreshmn.EnableWindow(TRUE);
|
||
|
m_spinRefreshSc.EnableWindow(TRUE);
|
||
|
|
||
|
m_editRefreshHr.EnableWindow(TRUE);
|
||
|
m_editRefreshMn.EnableWindow(TRUE);
|
||
|
m_editRefreshSc.EnableWindow(TRUE);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_fEnableAutoRefresh = FALSE;
|
||
|
m_spinRefreshHr.EnableWindow(FALSE);
|
||
|
m_spinRefreshmn.EnableWindow(FALSE);
|
||
|
m_spinRefreshSc.EnableWindow(FALSE);
|
||
|
|
||
|
m_editRefreshHr.EnableWindow(FALSE);
|
||
|
m_editRefreshMn.EnableWindow(FALSE);
|
||
|
m_editRefreshSc.EnableWindow(FALSE);
|
||
|
}
|
||
|
|
||
|
// mark the snap-in as dirty, so as to prompt the user
|
||
|
// mark the snap-in as dirty
|
||
|
SPITFSNode spNode ;
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
|
||
|
SPITFSNodeMgr spNodeManager;
|
||
|
SPITFSNode spRootNode;
|
||
|
|
||
|
spNode->GetNodeMgr(&spNodeManager);
|
||
|
spNodeManager->GetRootNode(&spRootNode);
|
||
|
|
||
|
// mark the data as dirty so that we'll ask the user to save.
|
||
|
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropDBRecord property page
|
||
|
|
||
|
IMPLEMENT_DYNCREATE(CServerPropDBRecord, CPropertyPageBase)
|
||
|
|
||
|
CServerPropDBRecord::CServerPropDBRecord() : CPropertyPageBase(CServerPropDBRecord::IDD)
|
||
|
{
|
||
|
//{{AFX_DATA_INIT(CServerPropDBRecord)
|
||
|
m_nExtintDay = 0;
|
||
|
m_nExtIntHour = 0;
|
||
|
m_nExtIntMinute = 0;
|
||
|
m_nExtTmDay = 0;
|
||
|
m_nExtTmHour = 0;
|
||
|
m_nExtTmMinute = 0;
|
||
|
m_nRenewDay = 0;
|
||
|
m_nrenewMinute = 0;
|
||
|
m_nRenewMinute = 0;
|
||
|
m_nVerifyDay = 0;
|
||
|
m_nVerifyHour = 0;
|
||
|
m_nVerifyMinute = 0;
|
||
|
//}}AFX_DATA_INIT
|
||
|
}
|
||
|
|
||
|
|
||
|
CServerPropDBRecord::~CServerPropDBRecord()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
void CServerPropDBRecord::DoDataExchange(CDataExchange* pDX)
|
||
|
{
|
||
|
CPropertyPageBase::DoDataExchange(pDX);
|
||
|
//{{AFX_DATA_MAP(CServerPropDBRecord)
|
||
|
DDX_Control(pDX, IDC_EDIT_EXTINCT_INT_MINUTE, m_editExtIntMinute);
|
||
|
DDX_Control(pDX, IDC_SPIN_VERIFY_INT_MINUTE, m_spinVerifyMinute);
|
||
|
DDX_Control(pDX, IDC_SPIN_VERIFY_INT_HOUR, m_spinVerifyHour);
|
||
|
DDX_Control(pDX, IDC_SPIN_VERIFY_INT_DAY, m_spinVerifyDay);
|
||
|
DDX_Control(pDX, IDC_SPIN_RENEW_INT_MINUTE, m_spinRefrIntMinute);
|
||
|
DDX_Control(pDX, IDC_SPIN_RENEW_INT_HOUR, m_spinRefrIntHour);
|
||
|
DDX_Control(pDX, IDC_SPIN_RENEW_INT_DAY, m_spinRefrIntDay);
|
||
|
DDX_Control(pDX, IDC_SPIN_EXTINCT_TM_MINUTE, m_spinExtTmMinute);
|
||
|
DDX_Control(pDX, IDC_SPIN_EXTINCT_TM_HOUR, m_spinExtTmHour);
|
||
|
DDX_Control(pDX, IDC_SPIN_EXTINCT_TM_DAY, m_spinExtTmDay);
|
||
|
DDX_Control(pDX, IDC_SPIN_EXTINCT_INT_MINUTE, m_spinExtIntMinute);
|
||
|
DDX_Control(pDX, IDC_SPIN_EXTINCT_INT_HOUR, m_spinExtIntHour);
|
||
|
DDX_Control(pDX, IDC_SPIN_EXTINCT_INT_DAY, m_spinExtIntDay);
|
||
|
DDX_Control(pDX, IDC_EDIT_VERIFY_MINUTE, m_editVerifyMinute);
|
||
|
DDX_Control(pDX, IDC_EDIT_VERIFY_HOUR, m_editVerifyHour);
|
||
|
DDX_Control(pDX, IDC_EDIT_VERIFY_DAY, m_editVerifyDay);
|
||
|
DDX_Control(pDX, IDC_EDIT_RENEW_MINUTE, m_editRefrIntMinute);
|
||
|
DDX_Control(pDX, IDC_EDIT_RENEW_HOUR, m_editRefrIntHour);
|
||
|
DDX_Control(pDX, IDC_EDIT_RENEW_DAY, m_editRefrIntDay);
|
||
|
DDX_Control(pDX, IDC_EDIT_EXTINCT_TIMEOUT_HOUR, m_editExtTmHour);
|
||
|
DDX_Control(pDX, IDC_EDIT_EXTINCT_TIMEOUT_MINUTE, m_editExtTmMinute);
|
||
|
DDX_Control(pDX, IDC_EDIT_EXTINCT_TIMEOUT_DAY, m_editExtTmDay);
|
||
|
DDX_Control(pDX, IDC_EDIT_EXTINCT_INT_HOUR, m_editExtIntHour);
|
||
|
DDX_Control(pDX, IDC_EDIT_EXTINCT_INT_DAY, m_editExtIntDay);
|
||
|
DDX_Text(pDX, IDC_EDIT_EXTINCT_INT_DAY, m_nExtintDay);
|
||
|
DDV_MinMaxInt(pDX, m_nExtintDay, 0, 365);
|
||
|
DDX_Text(pDX, IDC_EDIT_EXTINCT_INT_HOUR, m_nExtIntHour);
|
||
|
DDV_MinMaxInt(pDX, m_nExtIntHour, 0, MAX_HOURS);
|
||
|
DDX_Text(pDX, IDC_EDIT_EXTINCT_INT_MINUTE, m_nExtIntMinute);
|
||
|
DDV_MinMaxInt(pDX, m_nExtIntMinute, 0, MAX_MINUTES);
|
||
|
DDX_Text(pDX, IDC_EDIT_EXTINCT_TIMEOUT_DAY, m_nExtTmDay);
|
||
|
DDV_MinMaxInt(pDX, m_nExtTmDay, 0, 365);
|
||
|
DDX_Text(pDX, IDC_EDIT_EXTINCT_TIMEOUT_HOUR, m_nExtTmHour);
|
||
|
DDV_MinMaxInt(pDX, m_nExtTmHour, 0, MAX_HOURS);
|
||
|
DDX_Text(pDX, IDC_EDIT_EXTINCT_TIMEOUT_MINUTE, m_nExtTmMinute);
|
||
|
DDV_MinMaxInt(pDX, m_nExtTmMinute, 0, MAX_MINUTES);
|
||
|
DDX_Text(pDX, IDC_EDIT_RENEW_DAY, m_nRenewDay);
|
||
|
DDV_MinMaxInt(pDX, m_nRenewDay, 0, 365);
|
||
|
DDX_Text(pDX, IDC_EDIT_RENEW_HOUR, m_nrenewMinute);
|
||
|
DDV_MinMaxInt(pDX, m_nrenewMinute, 0, MAX_HOURS);
|
||
|
DDX_Text(pDX, IDC_EDIT_RENEW_MINUTE, m_nRenewMinute);
|
||
|
DDV_MinMaxInt(pDX, m_nRenewMinute, 0, MAX_MINUTES);
|
||
|
DDX_Text(pDX, IDC_EDIT_VERIFY_DAY, m_nVerifyDay);
|
||
|
DDV_MinMaxInt(pDX, m_nVerifyDay, 0, 365);
|
||
|
DDX_Text(pDX, IDC_EDIT_VERIFY_HOUR, m_nVerifyHour);
|
||
|
DDV_MinMaxInt(pDX, m_nVerifyHour, 0, MAX_HOURS);
|
||
|
DDX_Text(pDX, IDC_EDIT_VERIFY_MINUTE, m_nVerifyMinute);
|
||
|
DDV_MinMaxInt(pDX, m_nVerifyMinute, 0, MAX_MINUTES);
|
||
|
//}}AFX_DATA_MAP
|
||
|
}
|
||
|
|
||
|
|
||
|
BEGIN_MESSAGE_MAP(CServerPropDBRecord, CPropertyPageBase)
|
||
|
//{{AFX_MSG_MAP(CServerPropDBRecord)
|
||
|
ON_BN_CLICKED(IDC_BUTTON_SET_DEFAULT, OnButtonSetDefault)
|
||
|
ON_EN_CHANGE(IDC_EDIT_EXTINCT_INT_DAY, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_EXTINCT_INT_HOUR, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_EXTINCT_INT_MINUTE, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_EXTINCT_TIMEOUT_DAY, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_EXTINCT_TIMEOUT_HOUR, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_EXTINCT_TIMEOUT_MINUTE, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_RENEW_DAY, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_RENEW_HOUR, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_RENEW_MINUTE, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_VERIFY_DAY, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_VERIFY_HOUR, OnChangeEditExtinctIntHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_VERIFY_MINUTE, OnChangeEditExtinctIntHour)
|
||
|
//}}AFX_MSG_MAP
|
||
|
END_MESSAGE_MAP()
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropDBRecord message handlers
|
||
|
|
||
|
BOOL
|
||
|
CServerPropDBRecord::OnInitDialog()
|
||
|
{
|
||
|
CPropertyPageBase::OnInitDialog();
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
// get the interval stuff from the server and display in the spinner controlss
|
||
|
HRESULT hr = GetConfig();
|
||
|
|
||
|
DWORD m_dwRefreshInterval = m_pConfig->m_dwRefreshInterval;
|
||
|
|
||
|
m_spinRefrIntHour.SetRange(0, MAX_HOURS);
|
||
|
m_spinRefrIntMinute.SetRange(0, MAX_MINUTES);
|
||
|
m_spinRefrIntDay.SetRange(0, UD_MAXVAL);
|
||
|
|
||
|
int nDays = 0, nHours = 0, nMinutes = 0;
|
||
|
|
||
|
nDays = m_dwRefreshInterval /86400;// SEC_PER_DAY;
|
||
|
m_dwRefreshInterval -= (nDays * SEC_PER_DAY);
|
||
|
|
||
|
if (m_dwRefreshInterval)
|
||
|
{
|
||
|
nHours = m_dwRefreshInterval / SEC_PER_HOUR;
|
||
|
|
||
|
m_dwRefreshInterval -= (nHours * SEC_PER_HOUR);
|
||
|
|
||
|
if(m_dwRefreshInterval)
|
||
|
{
|
||
|
nMinutes = m_dwRefreshInterval / SEC_PER_MINUTE;
|
||
|
m_dwRefreshInterval -= (nMinutes * SEC_PER_MINUTE);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_spinRefrIntDay.SetPos(nDays);
|
||
|
m_spinRefrIntHour.SetPos(nHours);
|
||
|
m_spinRefrIntMinute.SetPos(nMinutes);
|
||
|
|
||
|
SetVerifyData();
|
||
|
SetExtTimeData();
|
||
|
SetExtIntData();
|
||
|
|
||
|
SetDirty(FALSE);
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
|
||
|
BOOL
|
||
|
CServerPropDBRecord::OnApply()
|
||
|
{
|
||
|
if (!CheckValues())
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return CPropertyPageBase::OnApply();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
CServerPropDBRecord::OnOK()
|
||
|
{
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CPropertyPageBase::OnOK();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::CalculateRenewInt()
|
||
|
Returns the Renew interval in seconds
|
||
|
---------------------------------------------------------------------------*/
|
||
|
DWORD
|
||
|
CServerPropDBRecord::CalculateRenewInt()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
int nDay = m_spinRefrIntDay.GetPos();
|
||
|
int nHour = m_spinRefrIntHour.GetPos();
|
||
|
int nMinute = m_spinRefrIntMinute.GetPos();
|
||
|
|
||
|
int nRenewInterval = nDay * SEC_PER_DAY +
|
||
|
nHour * SEC_PER_HOUR +
|
||
|
nMinute * SEC_PER_MINUTE;
|
||
|
|
||
|
return nRenewInterval;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::CalculateExtInt()
|
||
|
Returns the Extinction interval in seconds
|
||
|
---------------------------------------------------------------------------*/
|
||
|
DWORD
|
||
|
CServerPropDBRecord::CalculateExtInt()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
int nDay = m_spinExtIntDay.GetPos();
|
||
|
int nHour = m_spinExtIntHour.GetPos();
|
||
|
int nMinute = m_spinExtIntMinute.GetPos();
|
||
|
|
||
|
int nExtInterval = nDay * SEC_PER_DAY +
|
||
|
nHour * SEC_PER_HOUR +
|
||
|
nMinute * SEC_PER_MINUTE;
|
||
|
|
||
|
return nExtInterval;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::CalculateExtTm()
|
||
|
Returns the Extinction timeout interval in seconds
|
||
|
---------------------------------------------------------------------------*/
|
||
|
DWORD
|
||
|
CServerPropDBRecord::CalculateExtTm()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
int nDay = m_spinExtTmDay.GetPos();
|
||
|
int nHour = m_spinExtTmHour.GetPos();
|
||
|
int nMinute = m_spinExtTmMinute.GetPos();
|
||
|
|
||
|
int nExtTm = nDay * SEC_PER_DAY +
|
||
|
nHour * SEC_PER_HOUR +
|
||
|
nMinute * SEC_PER_MINUTE;
|
||
|
|
||
|
return nExtTm;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*----------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::CalculateVerifyInt()
|
||
|
Returns the Verify interval in seconds
|
||
|
---------------------------------------------------------------------------*/
|
||
|
DWORD
|
||
|
CServerPropDBRecord::CalculateVerifyInt()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
int nDay = m_spinVerifyDay.GetPos();
|
||
|
int nHour = m_spinVerifyHour.GetPos();
|
||
|
int nMinute = m_spinVerifyMinute.GetPos();
|
||
|
|
||
|
int nVerifyInt = nDay * SEC_PER_DAY +
|
||
|
nHour * SEC_PER_HOUR +
|
||
|
nMinute * SEC_PER_MINUTE;
|
||
|
|
||
|
return nVerifyInt;
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::UpdateServerConfiguration()
|
||
|
Updates the server handler variables
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropDBRecord::UpdateServerConfiguration()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
// Reflect the changes in the server's CConfiguration object
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
m_pConfig->m_dwRefreshInterval = CalculateRenewInt();
|
||
|
m_pConfig->m_dwTombstoneInterval = CalculateExtInt();
|
||
|
m_pConfig->m_dwTombstoneTimeout = CalculateExtTm();
|
||
|
m_pConfig->m_dwVerifyInterval = CalculateVerifyInt();
|
||
|
|
||
|
// now write to server
|
||
|
DWORD err = m_pConfig->Store();
|
||
|
if (err != ERROR_SUCCESS)
|
||
|
{
|
||
|
// something bad happened
|
||
|
WinsMessageBox(err);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// success update our local copy
|
||
|
pServer->SetConfig(*m_pConfig);
|
||
|
}
|
||
|
|
||
|
return HRESULT_FROM_WIN32(err);
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
CServerPropDBRecord::OnButtonSetDefault()
|
||
|
{
|
||
|
SetDefaultRenewInt();
|
||
|
SetDefaultExtInt();
|
||
|
SetDefaultExtTm();
|
||
|
SetDefaultVerifyInt();
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// note, these defaults come from winscnf.c in the wins server code.
|
||
|
// if that code changes, these function will need to change as well.
|
||
|
//
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetDefaultRenewInt()
|
||
|
Sets the defalut values for the Renew interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetDefaultRenewInt()
|
||
|
{
|
||
|
int nValue = WINSCNF_DEF_REFRESH_INTERVAL;
|
||
|
|
||
|
int nDays = 0, nHours = 0, nMinutes = 0;
|
||
|
|
||
|
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
|
||
|
|
||
|
m_spinRefrIntDay.SetPos(nDays);
|
||
|
m_spinRefrIntHour.SetPos(nHours);
|
||
|
m_spinRefrIntMinute.SetPos(nMinutes);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetDefaultExtInt()
|
||
|
Sets the defalut values for the Extinction interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetDefaultExtInt()
|
||
|
{
|
||
|
int nValue = WINSCNF_MAKE_TOMB_INTVL_M(WINSCNF_DEF_REFRESH_INTERVAL, 0);
|
||
|
|
||
|
int nDays = 0, nHours = 0, nMinutes = 0;
|
||
|
|
||
|
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
|
||
|
|
||
|
m_spinExtIntDay.SetPos(nDays);
|
||
|
m_spinExtIntHour.SetPos(nHours);
|
||
|
m_spinExtIntMinute.SetPos(nMinutes);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetDefaultExtTm()
|
||
|
Sets the defalut values for the Extinction timeout interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetDefaultExtTm()
|
||
|
{
|
||
|
int nValue = WINSCNF_DEF_REFRESH_INTERVAL;
|
||
|
|
||
|
int nDays = 0, nHours = 0, nMinutes = 0;
|
||
|
|
||
|
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
|
||
|
|
||
|
m_spinExtTmDay.SetPos(nDays);
|
||
|
m_spinExtTmHour.SetPos(nHours);
|
||
|
m_spinExtTmMinute.SetPos(nMinutes);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetDefaultExtTm()
|
||
|
Sets the defalut values for the verify interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetDefaultVerifyInt()
|
||
|
{
|
||
|
int nValue = WINSCNF_MAKE_VERIFY_INTVL_M(WINSCNF_MAKE_TOMB_INTVL_M(WINSCNF_DEF_REFRESH_INTERVAL, 0));
|
||
|
|
||
|
int nDays = 0, nHours = 0, nMinutes = 0;
|
||
|
|
||
|
CalcDaysHoursMinutes(nValue, nDays, nHours, nMinutes);
|
||
|
|
||
|
m_spinVerifyDay.SetPos(nDays);
|
||
|
m_spinVerifyHour.SetPos(nHours);
|
||
|
m_spinVerifyMinute.SetPos(nMinutes);
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
CServerPropDBRecord::CalcDaysHoursMinutes(int nValue, int & nDays, int & nHours, int & nMinutes)
|
||
|
{
|
||
|
nDays = 0;
|
||
|
nHours = 0;
|
||
|
nMinutes = 0;
|
||
|
|
||
|
nDays = nValue / SEC_PER_DAY; // 86400;
|
||
|
nValue -= (nDays * SEC_PER_DAY);
|
||
|
|
||
|
if (nValue)
|
||
|
{
|
||
|
nHours = nValue / SEC_PER_HOUR;
|
||
|
|
||
|
nValue -= (nHours * SEC_PER_HOUR);
|
||
|
|
||
|
if (nValue)
|
||
|
{
|
||
|
nMinutes = nValue / SEC_PER_MINUTE;
|
||
|
nValue -= (nMinutes * SEC_PER_MINUTE);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::GetConfig()
|
||
|
Updates the configuration object from the server handler
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropDBRecord::GetConfig()
|
||
|
{
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
HRESULT hr = hrOK;
|
||
|
|
||
|
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
|
||
|
|
||
|
return hr;
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetVerifyData()
|
||
|
Sets the controls' data for verify interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetVerifyData()
|
||
|
{
|
||
|
DWORD dwInterval = m_pConfig->m_dwVerifyInterval;
|
||
|
|
||
|
m_spinVerifyHour.SetRange(0, MAX_HOURS);
|
||
|
m_spinVerifyMinute.SetRange(0, MAX_MINUTES);
|
||
|
m_spinVerifyDay.SetRange(0, UD_MAXVAL);
|
||
|
|
||
|
int nDays =0, nHours =0, nMinutes =0;
|
||
|
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nDays = dwInterval / SEC_PER_DAY;
|
||
|
dwInterval -= nDays * SEC_PER_DAY;
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nHours = dwInterval / SEC_PER_HOUR;
|
||
|
dwInterval -= nHours * SEC_PER_HOUR;
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
|
||
|
nMinutes = dwInterval / SEC_PER_MINUTE;
|
||
|
dwInterval -= nMinutes * SEC_PER_MINUTE;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_spinVerifyDay.SetPos(nDays);
|
||
|
m_spinVerifyHour.SetPos(nHours);
|
||
|
m_spinVerifyMinute.SetPos(nMinutes);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetExtTimeData()
|
||
|
Sets the controls' data for extinction timeout interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetExtTimeData()
|
||
|
{
|
||
|
DWORD dwInterval = m_pConfig->m_dwTombstoneTimeout;
|
||
|
|
||
|
m_spinExtTmHour.SetRange(0, MAX_HOURS);
|
||
|
m_spinExtTmMinute.SetRange(0, MAX_MINUTES);
|
||
|
m_spinExtTmDay.SetRange(0, UD_MAXVAL);
|
||
|
|
||
|
int nHours = 0, nMinutes =0, nDays =0;
|
||
|
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nDays = dwInterval / SEC_PER_DAY;
|
||
|
dwInterval -= nDays * SEC_PER_DAY;
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nHours = dwInterval / SEC_PER_HOUR;
|
||
|
dwInterval -= nHours * SEC_PER_HOUR;
|
||
|
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nMinutes = dwInterval / SEC_PER_MINUTE;
|
||
|
dwInterval -= nMinutes * SEC_PER_MINUTE;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_spinExtTmDay.SetPos(nDays);
|
||
|
m_spinExtTmHour.SetPos(nHours);
|
||
|
m_spinExtTmMinute.SetPos(nMinutes);
|
||
|
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::SetExtData()
|
||
|
Sets the controls' data for extinction interval
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBRecord::SetExtIntData()
|
||
|
{
|
||
|
DWORD dwInterval = m_pConfig->m_dwTombstoneInterval;
|
||
|
|
||
|
m_spinExtIntHour.SetRange(0, MAX_HOURS);
|
||
|
m_spinExtIntMinute.SetRange(0, MAX_MINUTES);
|
||
|
m_spinExtIntDay.SetRange(0, UD_MAXVAL);
|
||
|
|
||
|
int nHours =0, nMinutes =0, nDays =0;
|
||
|
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nDays = dwInterval / SEC_PER_DAY;
|
||
|
dwInterval -= nDays * SEC_PER_DAY;
|
||
|
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nHours = dwInterval / SEC_PER_HOUR;
|
||
|
dwInterval -= nHours * SEC_PER_HOUR;
|
||
|
|
||
|
if(dwInterval)
|
||
|
{
|
||
|
nMinutes = dwInterval / SEC_PER_MINUTE;
|
||
|
dwInterval -= nMinutes * SEC_PER_MINUTE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
m_spinExtIntDay.SetPos(nDays);
|
||
|
m_spinExtIntHour.SetPos(nHours);
|
||
|
m_spinExtIntMinute.SetPos(nMinutes);
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
void CServerPropDBRecord::OnChangeEditExtinctIntHour()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBRecord::CheckValues()
|
||
|
checks if the values are valid
|
||
|
NOTE: All of these checks mimic what the server does since we write
|
||
|
directly to the registry and don't go through an API. If these
|
||
|
every change, the error messages will need to be updated as well.
|
||
|
Author: EricDav
|
||
|
---------------------------------------------------------------------------*/
|
||
|
BOOL
|
||
|
CServerPropDBRecord::CheckValues()
|
||
|
{
|
||
|
BOOL fValid = TRUE;
|
||
|
|
||
|
UpdateData();
|
||
|
|
||
|
do
|
||
|
{
|
||
|
DWORD dwRenew = CalculateRenewInt();
|
||
|
|
||
|
if (dwRenew < WINSCNF_MIN_REFRESH_INTERVAL)
|
||
|
{
|
||
|
AfxMessageBox(IDS_ERR_RENEW_INTERVAL);
|
||
|
fValid = FALSE;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
DWORD dwExtTm = CalculateExtTm();
|
||
|
|
||
|
if (dwExtTm < WINSCNF_MIN_TOMBSTONE_TIMEOUT)
|
||
|
{
|
||
|
// minimum value
|
||
|
AfxMessageBox(IDS_ERR_EXTINCTION_TIMEOUT_MIN);
|
||
|
fValid = FALSE;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (dwExtTm < dwRenew)
|
||
|
{
|
||
|
// bad... must be at least this value
|
||
|
AfxMessageBox(IDS_ERR_EXTINCTION_TIMEOUT);
|
||
|
fValid = FALSE;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
DWORD dwExtInt = CalculateExtInt();
|
||
|
|
||
|
//--ft:07/10/00--
|
||
|
// replaced WINSCNF_MAKE_TOMB_INTVL_M macro with its expansion..
|
||
|
// otherwise, the compiler with CLEAN64_BIT=1 reports an error
|
||
|
// since max(any_dword, 0) is always true - and the compiler is dumb enough
|
||
|
// to signal this as an error..
|
||
|
//
|
||
|
//if (dwExtInt < WINSCNF_MAKE_TOMB_INTVL_M(dwRenew, 0))
|
||
|
if (dwExtInt < min(dwRenew, FOUR_DAYS))
|
||
|
{
|
||
|
// bad... must be at least that value
|
||
|
AfxMessageBox(IDS_ERR_EXTINCTION_INTERVAL);
|
||
|
fValid = FALSE;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
DWORD dwVerifyInt = CalculateVerifyInt();
|
||
|
|
||
|
if (dwVerifyInt < WINSCNF_MAKE_VERIFY_INTVL_M(dwExtInt))
|
||
|
{
|
||
|
// bad... must be at least this value
|
||
|
if (WINSCNF_MAKE_VERIFY_INTVL_M(dwExtInt) == TWENTY_FOUR_DAYS)
|
||
|
{
|
||
|
AfxMessageBox(IDS_ERR_VERIFY_INTERVAL_24_DAYS);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CString strTemp;
|
||
|
strTemp.Format(IDS_ERR_VERIFY_INTERVAL_CALC, TOMB_MULTIPLIER_FOR_VERIFY);
|
||
|
AfxMessageBox(strTemp);
|
||
|
}
|
||
|
|
||
|
fValid = FALSE;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
while (FALSE);
|
||
|
|
||
|
return fValid;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropDBVerification property page
|
||
|
|
||
|
IMPLEMENT_DYNCREATE(CServerPropDBVerification, CPropertyPageBase)
|
||
|
|
||
|
CServerPropDBVerification::CServerPropDBVerification() : CPropertyPageBase(CServerPropDBVerification::IDD)
|
||
|
{
|
||
|
//{{AFX_DATA_INIT(CServerPropDBVerification)
|
||
|
m_fCCPeriodic = FALSE;
|
||
|
m_nCCCheckRandom = -1;
|
||
|
m_nCCHour = 0;
|
||
|
m_nCCMinute = 0;
|
||
|
m_nCCSecond = 0;
|
||
|
m_nCCMaxChecked = 0;
|
||
|
m_nCCTimeInterval = 0;
|
||
|
//}}AFX_DATA_INIT
|
||
|
}
|
||
|
|
||
|
|
||
|
CServerPropDBVerification::~CServerPropDBVerification()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
void CServerPropDBVerification::DoDataExchange(CDataExchange* pDX)
|
||
|
{
|
||
|
CPropertyPageBase::DoDataExchange(pDX);
|
||
|
//{{AFX_DATA_MAP(CServerPropDBVerification)
|
||
|
DDX_Control(pDX, IDC_EDIT_CC_START_SECOND, m_editCCSecond);
|
||
|
DDX_Control(pDX, IDC_EDIT_CC_START_MINUTE, m_editCCMinute);
|
||
|
DDX_Control(pDX, IDC_EDIT_CC_START_HOUR, m_editCCHour);
|
||
|
DDX_Control(pDX, IDC_SPIN_CC_START_MINUTE, m_spinCCMinute);
|
||
|
DDX_Control(pDX, IDC_EDIT_CC_INTERVAL, m_editCCInterval);
|
||
|
DDX_Control(pDX, IDC_EDIT_CC_MAX_CHECKED, m_editCCMaxChecked);
|
||
|
DDX_Control(pDX, IDC_RADIO_CHECK_OWNER, m_radioCheckOwner);
|
||
|
DDX_Control(pDX, IDC_CHECK_PERIODIC_CC, m_checkEnableCC);
|
||
|
DDX_Control(pDX, IDC_SPIN_CC_START_SECOND, m_spinCCSecond);
|
||
|
DDX_Control(pDX, IDC_SPIN_CC_START_HOUR, m_spinCCHour);
|
||
|
DDX_Check(pDX, IDC_CHECK_PERIODIC_CC, m_fCCPeriodic);
|
||
|
DDX_Radio(pDX, IDC_RADIO_CHECK_OWNER, m_nCCCheckRandom);
|
||
|
DDX_Text(pDX, IDC_EDIT_CC_START_HOUR, m_nCCHour);
|
||
|
DDV_MinMaxInt(pDX, m_nCCHour, 0, MAX_HOURS);
|
||
|
DDX_Text(pDX, IDC_EDIT_CC_START_MINUTE, m_nCCMinute);
|
||
|
DDV_MinMaxInt(pDX, m_nCCMinute, 0, MAX_MINUTES);
|
||
|
DDX_Text(pDX, IDC_EDIT_CC_START_SECOND, m_nCCSecond);
|
||
|
DDV_MinMaxInt(pDX, m_nCCSecond, 0, MAX_SECONDS);
|
||
|
DDX_Text(pDX, IDC_EDIT_CC_MAX_CHECKED, m_nCCMaxChecked);
|
||
|
DDV_MinMaxUInt(pDX, m_nCCMaxChecked, WINSCNF_CC_MIN_RECS_AAT, 4294967295);
|
||
|
DDX_Text(pDX, IDC_EDIT_CC_INTERVAL, m_nCCTimeInterval);
|
||
|
DDV_MinMaxUInt(pDX, m_nCCTimeInterval, WINSCNF_CC_MIN_INTERVAL/(60*60), 24);
|
||
|
//}}AFX_DATA_MAP
|
||
|
}
|
||
|
|
||
|
|
||
|
BEGIN_MESSAGE_MAP(CServerPropDBVerification, CPropertyPageBase)
|
||
|
//{{AFX_MSG_MAP(CServerPropDBVerification)
|
||
|
ON_BN_CLICKED(IDC_CHECK_PERIODIC_CC, OnCheckPeriodicCc)
|
||
|
ON_EN_CHANGE(IDC_EDIT_CC_INTERVAL, OnChangeEditCcInterval)
|
||
|
ON_EN_CHANGE(IDC_EDIT_CC_MAX_CHECKED, OnChangeEditCcMaxChecked)
|
||
|
ON_EN_CHANGE(IDC_EDIT_CC_START_HOUR, OnChangeEditCcStartHour)
|
||
|
ON_EN_CHANGE(IDC_EDIT_CC_START_MINUTE, OnChangeEditCcStartMinute)
|
||
|
ON_EN_CHANGE(IDC_EDIT_CC_START_SECOND, OnChangeEditCcStartSecond)
|
||
|
ON_BN_CLICKED(IDC_RADIO_CHECK_OWNER, OnRadioCheckOwner)
|
||
|
ON_BN_CLICKED(IDC_RADIO_CHECK_RANDOM, OnRadioCheckRandom)
|
||
|
//}}AFX_MSG_MAP
|
||
|
END_MESSAGE_MAP()
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropDBVerification message handlers
|
||
|
|
||
|
BOOL
|
||
|
CServerPropDBVerification::OnInitDialog()
|
||
|
{
|
||
|
CPropertyPageBase::OnInitDialog();
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
// get the interval stuff from the server and display in the spinner controlss
|
||
|
HRESULT hr = GetConfig();
|
||
|
|
||
|
m_spinCCHour.SetRange(0, MAX_HOURS);
|
||
|
m_spinCCMinute.SetRange(0, MAX_MINUTES);
|
||
|
m_spinCCSecond.SetRange(0, MAX_SECONDS);
|
||
|
|
||
|
SetCCInfo();
|
||
|
UpdateCCControls();
|
||
|
|
||
|
SetDirty(FALSE);
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
BOOL
|
||
|
CServerPropDBVerification::OnApply()
|
||
|
{
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return CPropertyPageBase::OnApply();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
CServerPropDBVerification::OnOK()
|
||
|
{
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CPropertyPageBase::OnOK();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnCheckPeriodicCc()
|
||
|
{
|
||
|
UpdateCCControls();
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnChangeEditCcInterval()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnChangeEditCcMaxChecked()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnChangeEditCcStartHour()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnChangeEditCcStartMinute()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnChangeEditCcStartSecond()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnRadioCheckOwner()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropDBVerification::OnRadioCheckRandom()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBVerification::UpdateServerConfiguration()
|
||
|
Updates the server handler variables
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropDBVerification::UpdateServerConfiguration()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
// Reflect the changes in the server's CConfiguration object
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
// consistency check
|
||
|
m_pConfig->m_fPeriodicConsistencyCheck = m_fCCPeriodic;
|
||
|
m_pConfig->m_fCCUseRplPnrs = m_nCCCheckRandom;
|
||
|
m_pConfig->m_dwMaxRecsAtATime = m_nCCMaxChecked;
|
||
|
|
||
|
// convert to seconds
|
||
|
m_pConfig->m_dwCCTimeInterval = m_nCCTimeInterval * (60*60);
|
||
|
|
||
|
// start time
|
||
|
CTime curTime = CTime::GetCurrentTime();
|
||
|
|
||
|
int nYear = curTime.GetYear();
|
||
|
int nMonth = curTime.GetMonth();
|
||
|
int nDay = curTime.GetDay();
|
||
|
|
||
|
CTime tempTime(nYear, nMonth, nDay, m_nCCHour, m_nCCMinute, m_nCCSecond);
|
||
|
m_pConfig->m_itmCCStartTime = tempTime;
|
||
|
|
||
|
// now write to server
|
||
|
DWORD err = m_pConfig->Store();
|
||
|
if (err != ERROR_SUCCESS)
|
||
|
{
|
||
|
// something bad happened
|
||
|
WinsMessageBox(err);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// success update our local copy
|
||
|
pServer->SetConfig(*m_pConfig);
|
||
|
}
|
||
|
|
||
|
return HRESULT_FROM_WIN32(err);
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBVerification::GetConfig()
|
||
|
Updates the configuration object from the server handler
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropDBVerification::GetConfig()
|
||
|
{
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
HRESULT hr = hrOK;
|
||
|
|
||
|
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
|
||
|
|
||
|
return hr;
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBVerification::UpdateCCControls()
|
||
|
Enables/disables depending on checkbox
|
||
|
Author: EricDav
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBVerification::UpdateCCControls()
|
||
|
{
|
||
|
UpdateData();
|
||
|
BOOL fEnable = FALSE;
|
||
|
|
||
|
if (m_fCCPeriodic)
|
||
|
{
|
||
|
fEnable = TRUE;
|
||
|
}
|
||
|
|
||
|
m_spinCCHour.EnableWindow(fEnable);
|
||
|
m_spinCCMinute.EnableWindow(fEnable);
|
||
|
m_spinCCSecond.EnableWindow(fEnable);
|
||
|
|
||
|
m_editCCHour.EnableWindow(fEnable);
|
||
|
m_editCCMinute.EnableWindow(fEnable);
|
||
|
m_editCCSecond.EnableWindow(fEnable);
|
||
|
|
||
|
m_editCCMaxChecked.EnableWindow(fEnable);
|
||
|
m_editCCInterval.EnableWindow(fEnable);
|
||
|
m_radioCheckOwner.EnableWindow(fEnable);
|
||
|
GetDlgItem(IDC_RADIO_CHECK_RANDOM)->EnableWindow(fEnable);
|
||
|
|
||
|
// TODO: static text
|
||
|
}
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropDBVerification::SetCCInfo()
|
||
|
Sets the interval values for Consistency checking
|
||
|
Author: EricDav
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropDBVerification::SetCCInfo()
|
||
|
{
|
||
|
CString strTemp;
|
||
|
CButton * pRadio;
|
||
|
|
||
|
m_checkEnableCC.SetCheck(m_pConfig->m_fPeriodicConsistencyCheck);
|
||
|
|
||
|
if (m_pConfig->m_fCCUseRplPnrs)
|
||
|
{
|
||
|
pRadio = (CButton *) GetDlgItem(IDC_RADIO_CHECK_RANDOM);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pRadio = (CButton *) GetDlgItem(IDC_RADIO_CHECK_OWNER);
|
||
|
}
|
||
|
|
||
|
pRadio->SetCheck(TRUE);
|
||
|
|
||
|
strTemp.Format(_T("%lu"), m_pConfig->m_dwMaxRecsAtATime);
|
||
|
m_editCCMaxChecked.SetWindowText(strTemp);
|
||
|
|
||
|
// convert the TimeInterval into hours from seconds
|
||
|
int nTimeTemp = m_pConfig->m_dwCCTimeInterval / (60 * 60);
|
||
|
|
||
|
strTemp.Format(_T("%lu"), nTimeTemp);
|
||
|
m_editCCInterval.SetWindowText(strTemp);
|
||
|
|
||
|
m_spinCCHour.SetPos(m_pConfig->m_itmCCStartTime.GetHour());
|
||
|
m_spinCCMinute.SetPos(m_pConfig->m_itmCCStartTime.GetMinute());
|
||
|
m_spinCCSecond.SetPos(m_pConfig->m_itmCCStartTime.GetSecond());
|
||
|
}
|
||
|
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropAdvanced property page
|
||
|
|
||
|
IMPLEMENT_DYNCREATE(CServerPropAdvanced, CPropertyPageBase)
|
||
|
|
||
|
CServerPropAdvanced::CServerPropAdvanced() : CPropertyPageBase(CServerPropAdvanced::IDD)
|
||
|
{
|
||
|
//{{AFX_DATA_INIT(CServerPropAdvanced)
|
||
|
m_fLogEvents = FALSE;
|
||
|
m_strStartVersion = _T("");
|
||
|
m_fLanNames = FALSE;
|
||
|
m_fBurstHandling = FALSE;
|
||
|
m_nQueSelection = -1;
|
||
|
m_strDbPath = _T("");
|
||
|
//}}AFX_DATA_INIT
|
||
|
|
||
|
m_fRestart = FALSE;
|
||
|
}
|
||
|
|
||
|
CServerPropAdvanced::~CServerPropAdvanced()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::DoDataExchange(CDataExchange* pDX)
|
||
|
{
|
||
|
CPropertyPageBase::DoDataExchange(pDX);
|
||
|
//{{AFX_DATA_MAP(CServerPropAdvanced)
|
||
|
DDX_Control(pDX, IDC_BUTTON_BROWSE_DATABASE, m_buttonBrowse);
|
||
|
DDX_Control(pDX, IDC_EDIT_DATABASE_PATH, m_editDbPath);
|
||
|
DDX_Control(pDX, IDC_CHECK_BURST_HANDLING, m_checkBurstHandling);
|
||
|
DDX_Control(pDX, IDC_CHECK_LANNAMES, m_checkLanNames);
|
||
|
DDX_Control(pDX, IDC_EDIT_START_VERSION, m_editVersionCount);
|
||
|
DDX_Control(pDX, IDC_CHECK_LOGEVENTS, m_checkLogDetailedEvents);
|
||
|
DDX_Check(pDX, IDC_CHECK_LOGEVENTS, m_fLogEvents);
|
||
|
DDX_Text(pDX, IDC_EDIT_START_VERSION, m_strStartVersion);
|
||
|
DDV_MaxChars(pDX, m_strStartVersion, 16);
|
||
|
DDX_Check(pDX, IDC_CHECK_LANNAMES, m_fLanNames);
|
||
|
DDX_Check(pDX, IDC_CHECK_BURST_HANDLING, m_fBurstHandling);
|
||
|
DDX_Radio(pDX, IDC_RADIO_LOW, m_nQueSelection);
|
||
|
DDX_Text(pDX, IDC_EDIT_DATABASE_PATH, m_strDbPath);
|
||
|
//}}AFX_DATA_MAP
|
||
|
}
|
||
|
|
||
|
|
||
|
BEGIN_MESSAGE_MAP(CServerPropAdvanced, CPropertyPageBase)
|
||
|
//{{AFX_MSG_MAP(CServerPropAdvanced)
|
||
|
ON_BN_CLICKED(IDC_CHECK_LANNAMES, OnCheckLannames)
|
||
|
ON_BN_CLICKED(IDC_CHECK_BURST_HANDLING, OnCheckBurstHandling)
|
||
|
ON_BN_CLICKED(IDC_RADIO_CUSTOM, OnRadioCustom)
|
||
|
ON_BN_CLICKED(IDC_RADIO_HIGH, OnRadioHigh)
|
||
|
ON_BN_CLICKED(IDC_RADIO_LOW, OnRadioLow)
|
||
|
ON_BN_CLICKED(IDC_RADIO_MEDIUM, OnRadioMedium)
|
||
|
ON_EN_CHANGE(IDC_EDIT_CUSTOM_VALUE, OnChangeEditCustomValue)
|
||
|
ON_BN_CLICKED(IDC_BUTTON_BROWSE_DATABASE, OnButtonBrowseDatabase)
|
||
|
ON_BN_CLICKED(IDC_CHECK_LOGEVENTS, MarkDirty)
|
||
|
ON_EN_CHANGE(IDC_EDIT_START_VERSION, MarkDirty)
|
||
|
ON_EN_CHANGE(IDC_EDIT_DATABASE_PATH, OnChangeEditDatabasePath)
|
||
|
//}}AFX_MSG_MAP
|
||
|
END_MESSAGE_MAP()
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// CServerPropAdvanced message handlers
|
||
|
|
||
|
BOOL
|
||
|
CServerPropAdvanced::OnInitDialog()
|
||
|
{
|
||
|
CPropertyPageBase::OnInitDialog();
|
||
|
GetConfig();
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
m_fLogEvents = m_pConfig->m_fLogDetailedEvents;
|
||
|
if (m_fLogEvents)
|
||
|
{
|
||
|
m_checkLogDetailedEvents.SetCheck(1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_checkLogDetailedEvents.SetCheck(0);
|
||
|
}
|
||
|
|
||
|
if (pServer->m_dwFlags & FLAG_LANMAN_COMPATIBLE)
|
||
|
{
|
||
|
m_fLanNames = TRUE;
|
||
|
m_checkLanNames.SetCheck(TRUE);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_fLanNames = FALSE;
|
||
|
m_checkLanNames.SetCheck(FALSE);
|
||
|
}
|
||
|
|
||
|
LONG lLowWord = m_pConfig->m_dwVersCountStart_LowWord;
|
||
|
LONG lHighWord = m_pConfig->m_dwVersCountStart_HighWord;
|
||
|
|
||
|
CString strVersion = GetVersionInfo(lLowWord, lHighWord);
|
||
|
m_editVersionCount.SetWindowText(strVersion);
|
||
|
|
||
|
// burst que stuff
|
||
|
m_checkBurstHandling.SetCheck(m_pConfig->m_fBurstHandling);
|
||
|
|
||
|
((CEdit *) GetDlgItem(IDC_EDIT_CUSTOM_VALUE))->LimitText(5);
|
||
|
SetQueSize();
|
||
|
UpdateBurstHandling();
|
||
|
|
||
|
// db path stuff
|
||
|
// browse only available on local machine
|
||
|
// get the server
|
||
|
m_buttonBrowse.ShowWindow(FALSE); // we may add this back in later
|
||
|
m_buttonBrowse.EnableWindow(pServer->IsLocalConnection());
|
||
|
|
||
|
m_editDbPath.EnableWindow(pServer->IsLocalConnection());
|
||
|
m_editDbPath.SetWindowText(m_pConfig->m_strDbPath);
|
||
|
|
||
|
SetDirty(FALSE);
|
||
|
m_fRestart = FALSE;
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
CServerPropAdvanced::OnOK()
|
||
|
{
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CPropertyPageBase::OnOK();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
BOOL
|
||
|
CServerPropAdvanced::OnApply()
|
||
|
{
|
||
|
BOOL fRestartNow = FALSE;
|
||
|
|
||
|
UpdateData();
|
||
|
|
||
|
// validate the value for Hex
|
||
|
for (int i=0; i < m_strStartVersion.GetLength(); i++)
|
||
|
{
|
||
|
if (!(((m_strStartVersion[i] >= _T('0') ) &&
|
||
|
(m_strStartVersion[i] <= _T('9') )) ||
|
||
|
((m_strStartVersion[i] >= _T('A') ) &&
|
||
|
(m_strStartVersion[i] <= _T('F') )) ||
|
||
|
((m_strStartVersion[i] >= _T('a') ) &&
|
||
|
(m_strStartVersion[i] <= _T('f') ))
|
||
|
))
|
||
|
{
|
||
|
::WinsMessageBox(IDS_ERR_VERSION_NUMBER);
|
||
|
m_editVersionCount.SetFocus();
|
||
|
m_editVersionCount.SetSel(0,-1);
|
||
|
return FALSE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
DWORD dwSize = GetQueSize();
|
||
|
if (dwSize < WINS_QUEUE_HWM_MIN ||
|
||
|
dwSize > WINS_QUEUE_HWM_MAX)
|
||
|
{
|
||
|
CString strMin, strMax, strDisplay;
|
||
|
|
||
|
strMin.Format(_T("%d"), WINS_QUEUE_HWM_MIN);
|
||
|
strMax.Format(_T("%d"), WINS_QUEUE_HWM_MAX);
|
||
|
|
||
|
AfxFormatString2(strDisplay, IDS_ERR_BURST_QUE_SIZE, strMin, strMax);
|
||
|
|
||
|
AfxMessageBox(strDisplay);
|
||
|
|
||
|
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->SetFocus();
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
// warn the user
|
||
|
if (m_fRestart)
|
||
|
{
|
||
|
int nRet = AfxMessageBox(IDS_DATABASE_PATH_CHANGE, MB_YESNOCANCEL);
|
||
|
if (nRet == IDCANCEL)
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
else
|
||
|
if (nRet == IDYES)
|
||
|
{
|
||
|
fRestartNow = TRUE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
HRESULT hr = UpdateServerConfiguration();
|
||
|
if (FAILED(hr))
|
||
|
{
|
||
|
return FALSE;
|
||
|
}
|
||
|
|
||
|
if (fRestartNow)
|
||
|
{
|
||
|
CString strServiceName;
|
||
|
strServiceName.LoadString(IDS_SERVICE_NAME);
|
||
|
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler *pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
DWORD dwError = TFSStopServiceEx(m_pConfig->GetOwner(), _T("WINS"), _T("WINS Service"), strServiceName);
|
||
|
if (dwError)
|
||
|
{
|
||
|
WinsMessageBox(dwError);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
dwError = TFSStartServiceEx(m_pConfig->GetOwner(), _T("WINS"), _T("WINS Service"), strServiceName);
|
||
|
if (dwError)
|
||
|
{
|
||
|
WinsMessageBox(dwError);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
pServer->ConnectToWinsServer(spNode);
|
||
|
}
|
||
|
|
||
|
m_fRestart = FALSE;
|
||
|
|
||
|
return CPropertyPageBase::OnApply();
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropAdvanced::GetConfig()
|
||
|
Updates the configuration object from the server handler
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropAdvanced::GetConfig()
|
||
|
{
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
HRESULT hr = hrOK;
|
||
|
|
||
|
m_pConfig = ((CServerProperties *) GetHolder())->GetConfig();
|
||
|
|
||
|
return hr;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropAdvanced::UpdateServerConfiguration()
|
||
|
Updates the variables in the server handler
|
||
|
---------------------------------------------------------------------------*/
|
||
|
HRESULT
|
||
|
CServerPropAdvanced::UpdateServerConfiguration()
|
||
|
{
|
||
|
UpdateData();
|
||
|
|
||
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
||
|
|
||
|
// get the server
|
||
|
SPITFSNode spNode;
|
||
|
CWinsServerHandler * pServer;
|
||
|
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
pServer = GETHANDLER(CWinsServerHandler, spNode);
|
||
|
|
||
|
// update our settings
|
||
|
m_pConfig->m_fLogDetailedEvents = m_fLogEvents;
|
||
|
if (m_fLanNames)
|
||
|
{
|
||
|
pServer->m_dwFlags |= FLAG_LANMAN_COMPATIBLE;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pServer->m_dwFlags &= (~FLAG_LANMAN_COMPATIBLE);
|
||
|
}
|
||
|
|
||
|
// version stuff
|
||
|
LONG lLowWord, lHighWord;
|
||
|
FillVersionInfo(lLowWord, lHighWord);
|
||
|
|
||
|
m_pConfig->m_dwVersCountStart_HighWord = lHighWord;
|
||
|
m_pConfig->m_dwVersCountStart_LowWord = lLowWord;
|
||
|
|
||
|
// burst handling
|
||
|
m_pConfig->m_fBurstHandling = m_fBurstHandling;
|
||
|
m_pConfig->m_dwBurstQueSize = GetQueSize();
|
||
|
|
||
|
// db path
|
||
|
if (m_fRestart)
|
||
|
{
|
||
|
m_pConfig->m_strDbPath = m_strDbPath;
|
||
|
}
|
||
|
|
||
|
// now write to server
|
||
|
DWORD err = m_pConfig->Store();
|
||
|
if (err != ERROR_SUCCESS)
|
||
|
{
|
||
|
// something bad happened
|
||
|
WinsMessageBox(err);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// success update our local copy
|
||
|
pServer->SetConfig(*m_pConfig);
|
||
|
}
|
||
|
|
||
|
return HRESULT_FROM_WIN32(err);
|
||
|
}
|
||
|
|
||
|
|
||
|
/*---------------------------------------------------------------------------
|
||
|
CServerPropAdvanced::FillVersionInfo(LONG &lLowValue, LONG &lHighValue)
|
||
|
fills the version info in the related controls
|
||
|
---------------------------------------------------------------------------*/
|
||
|
void
|
||
|
CServerPropAdvanced::FillVersionInfo(LONG &lLowValue, LONG &lHighValue)
|
||
|
{
|
||
|
CString str ;
|
||
|
m_editVersionCount.GetWindowText(str);
|
||
|
|
||
|
int j = str.GetLength();
|
||
|
|
||
|
if ( j > 16 || !j )
|
||
|
{
|
||
|
//
|
||
|
// Invalid string
|
||
|
//
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
TCHAR sz[] = _T("0000000000000000");
|
||
|
TCHAR *pch;
|
||
|
|
||
|
::_tcscpy(sz + 16 - j, (LPCTSTR)str);
|
||
|
pch = sz + 8;
|
||
|
::_stscanf(pch, _T("%08lX"),&lLowValue);
|
||
|
*pch = '\0';
|
||
|
::_stscanf(sz, _T("%08lX"),&lHighValue);
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
CString
|
||
|
CServerPropAdvanced::GetVersionInfo(LONG lLowWord, LONG lHighWord)
|
||
|
{
|
||
|
CString strVersionCount;
|
||
|
|
||
|
TCHAR sz[20];
|
||
|
TCHAR *pch = sz;
|
||
|
::wsprintf(sz, _T("%08lX%08lX"), lHighWord, lLowWord);
|
||
|
// Kill leading zero's
|
||
|
while (*pch == '0')
|
||
|
{
|
||
|
++pch;
|
||
|
}
|
||
|
// At least one digit...
|
||
|
if (*pch == '\0')
|
||
|
{
|
||
|
--pch;
|
||
|
}
|
||
|
|
||
|
strVersionCount = pch;
|
||
|
|
||
|
return strVersionCount;
|
||
|
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnCheckLannames()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
|
||
|
// mark the snap-in as dirty
|
||
|
SPITFSNode spNode ;
|
||
|
spNode = GetHolder()->GetNode();
|
||
|
|
||
|
SPITFSNodeMgr spNodeManager;
|
||
|
SPITFSNode spRootNode;
|
||
|
|
||
|
spNode->GetNodeMgr(&spNodeManager);
|
||
|
spNodeManager->GetRootNode(&spRootNode);
|
||
|
|
||
|
// mark the data as dirty so that we'll ask the user to save.
|
||
|
spRootNode->SetData(TFS_DATA_DIRTY, TRUE);
|
||
|
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::MarkDirty()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnCheckBurstHandling()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
UpdateBurstHandling();
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnRadioCustom()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
EnableCustomEntry();
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnRadioHigh()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
EnableCustomEntry();
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnRadioLow()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
EnableCustomEntry();
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnRadioMedium()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
EnableCustomEntry();
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnChangeEditCustomValue()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnButtonBrowseDatabase()
|
||
|
{
|
||
|
// TODO: browse for a path
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::OnChangeEditDatabasePath()
|
||
|
{
|
||
|
SetDirty(TRUE);
|
||
|
m_fRestart = TRUE;
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::UpdateBurstHandling()
|
||
|
{
|
||
|
if (IsWindow(m_checkBurstHandling.GetSafeHwnd()))
|
||
|
{
|
||
|
EnableQueSelection(m_checkBurstHandling.GetCheck());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::EnableQueSelection(BOOL bEnable)
|
||
|
{
|
||
|
GetDlgItem(IDC_RADIO_LOW)->EnableWindow(bEnable);
|
||
|
GetDlgItem(IDC_RADIO_MEDIUM)->EnableWindow(bEnable);
|
||
|
GetDlgItem(IDC_RADIO_HIGH)->EnableWindow(bEnable);
|
||
|
GetDlgItem(IDC_RADIO_CUSTOM)->EnableWindow(bEnable);
|
||
|
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->EnableWindow(bEnable);
|
||
|
|
||
|
EnableCustomEntry();
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::EnableCustomEntry()
|
||
|
{
|
||
|
BOOL bEnable = ((CButton *)GetDlgItem(IDC_RADIO_CUSTOM))->GetCheck() &&
|
||
|
m_checkBurstHandling.GetSafeHwnd() &&
|
||
|
m_checkBurstHandling.GetCheck();
|
||
|
|
||
|
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->EnableWindow(bEnable);
|
||
|
}
|
||
|
|
||
|
void CServerPropAdvanced::SetQueSize()
|
||
|
{
|
||
|
UINT uControlID = IDC_RADIO_CUSTOM;
|
||
|
|
||
|
switch (m_pConfig->m_dwBurstQueSize)
|
||
|
{
|
||
|
case BURST_QUE_SIZE_LOW:
|
||
|
uControlID = IDC_RADIO_LOW;
|
||
|
m_nQueSelection = 0;
|
||
|
break;
|
||
|
|
||
|
case BURST_QUE_SIZE_MEDIUM:
|
||
|
uControlID = IDC_RADIO_MEDIUM;
|
||
|
m_nQueSelection = 1;
|
||
|
break;
|
||
|
|
||
|
case BURST_QUE_SIZE_HIGH:
|
||
|
uControlID = IDC_RADIO_HIGH;
|
||
|
m_nQueSelection = 2;
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
{
|
||
|
TCHAR szBuf[10];
|
||
|
|
||
|
_itot(m_pConfig->m_dwBurstQueSize, szBuf, 10);
|
||
|
m_nQueSelection = 3;
|
||
|
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->SetWindowText(szBuf);
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
((CButton *) GetDlgItem(uControlID))->SetCheck(TRUE);
|
||
|
}
|
||
|
|
||
|
DWORD CServerPropAdvanced::GetQueSize()
|
||
|
{
|
||
|
DWORD dwSize = 0;
|
||
|
|
||
|
UpdateData();
|
||
|
|
||
|
if (IsDlgButtonChecked(IDC_RADIO_LOW))
|
||
|
{
|
||
|
dwSize = BURST_QUE_SIZE_LOW;
|
||
|
}
|
||
|
else
|
||
|
if (IsDlgButtonChecked(IDC_RADIO_MEDIUM))
|
||
|
{
|
||
|
dwSize = BURST_QUE_SIZE_MEDIUM;
|
||
|
}
|
||
|
else
|
||
|
if (IsDlgButtonChecked(IDC_RADIO_HIGH))
|
||
|
{
|
||
|
dwSize = BURST_QUE_SIZE_HIGH;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// must be custom
|
||
|
CString strText;
|
||
|
|
||
|
GetDlgItem(IDC_EDIT_CUSTOM_VALUE)->GetWindowText(strText);
|
||
|
dwSize = (DWORD) _ttoi(strText);
|
||
|
}
|
||
|
|
||
|
return dwSize;
|
||
|
}
|
||
|
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
//
|
||
|
// CServerProperties holder
|
||
|
//
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
CServerProperties::CServerProperties
|
||
|
(
|
||
|
ITFSNode * pNode,
|
||
|
IComponentData * pComponentData,
|
||
|
ITFSComponentData * pTFSCompData,
|
||
|
LPCTSTR pszSheetName
|
||
|
) : CPropertyPageHolderBase(pNode, pComponentData, pszSheetName)
|
||
|
|
||
|
{
|
||
|
m_bAutoDeletePages = FALSE; // we have the pages as embedded members
|
||
|
|
||
|
AddPageToList((CPropertyPageBase*) &m_pageGeneral);
|
||
|
AddPageToList((CPropertyPageBase*) &m_pageDBRecord);
|
||
|
AddPageToList((CPropertyPageBase*) &m_pageDBVerification);
|
||
|
AddPageToList((CPropertyPageBase*) &m_pageAdvanced);
|
||
|
|
||
|
Assert(pTFSCompData != NULL);
|
||
|
m_spTFSCompData.Set(pTFSCompData);
|
||
|
}
|
||
|
|
||
|
CServerProperties::~CServerProperties()
|
||
|
{
|
||
|
RemovePageFromList((CPropertyPageBase*) &m_pageGeneral, FALSE);
|
||
|
RemovePageFromList((CPropertyPageBase*) &m_pageDBRecord, FALSE);
|
||
|
RemovePageFromList((CPropertyPageBase*) &m_pageDBVerification, FALSE);
|
||
|
RemovePageFromList((CPropertyPageBase*) &m_pageAdvanced, FALSE);
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|