archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/admin/wmi/wbem/shell/atlui/wmicntl/backuppage.cpp

1101 lines
28 KiB
Raw Blame History

// Copyright (c) 1999 Microsoft Corporation
#include "precomp.h"
#include "BackupPage.h"
#include <chstring1.h>
#include <util.h>
#include "resource.h"
#include "wbemerror.h"
#include <process.h>
#include "WMIHelp.h"
#include "ShlWapi.h"
#include <cominit.h>
#include <stdlib.h>
#include <stdio.h>
#define REC_WILDCARD _T("*.rec")
#define ALL_WILDCARD _T("*.*")
const static DWORD buPageHelpIDs[] = { // Context Help IDs
IDC_BACKUP_ENABLED, IDH_WMI_CTRL_BACKUP_AUTOMATIC_CHECKBOX,
IDC_BACKUPINTERVAL, IDH_WMI_CTRL_BACKUP_TIME,
IDC_BACKUP_UNITS, IDH_WMI_CTRL_BACKUP_MINUTES_HOURS,
IDC_LASTBACKUP_LABEL, IDH_WMI_CTRL_BACKUP_LAST,
IDC_LASTBACKUP, IDH_WMI_CTRL_BACKUP_LAST,
IDC_RESTORE_FM_AUTO, IDH_WMI_CTRL_BACKUP_RESTORE_AUTO,
IDC_BACKUP_BTN, IDH_WMI_CTRL_BACKUP_BACKUP_MANUAL,
IDC_RESTORE_BTN, IDH_WMI_CTRL_BACKUP_RESTORE_MANUAL,
IDC_DBDIRECTORY_LABEL, IDH_WMI_CTRL_ADVANCED_REPOSITORY_LOC,
IDC_DB_DIR, IDH_WMI_CTRL_ADVANCED_REPOSITORY_LOC,
IDC_ADV_NOW_TEXT, -1,
IDC_ADV_NOW_TEXT2, -1,
65535, -1,
0, 0
};
const double WIN2K_CORE_VERSION = 1085.0005; //Win2K Core Version
CBackupPage::CBackupPage(DataSource *ds, bool htmlSupport):
CUIHelpers(ds, &(ds->m_rootThread), htmlSupport),
m_AVIbox(NULL),
m_wszArgs(NULL),
m_cred(NULL),
m_bWhistlerCore(false),
m_hAccessToken(NULL),
m_fClearToken(false),
m_cloak(false)
{
memset(&m_luid,0,sizeof(LUID));
}
CBackupPage::~CBackupPage(void)
{
}
//-------------------------------------------------------------------------
void CBackupPage::InitDlg(HWND hDlg)
{
m_hDlg = hDlg;
::SendMessage(GetDlgItem(hDlg, IDC_BACKUPINTERVAL),
EM_LIMITTEXT, 3, 0);
HWND hWnd = GetDlgItem(hDlg, IDC_BACKUP_UNITS);
if(hWnd)
{
CHString1 str;
str.LoadString(IDS_MINUTES);
ComboBox_AddString(hWnd, str);
str.LoadString(IDS_HOURS);
ComboBox_AddString(hWnd, str);
}
if(m_DS)
{
USES_CONVERSION;
CHString1 strVersion = _T("0.0");
m_DS->GetBldNbr(strVersion);
double ver = _tstof(strVersion);
if(ver > WIN2K_CORE_VERSION)
{
HideAutomaticBackupControls(hDlg);
}
}
}
//---------------------------------------------------------------------------
// NOTE: This must match to order of the combobox.
#define UNIT_MINUTE 0
#define UNIT_HOUR 1
#define UNIT_DAY 2
#define MINS_IN_HOUR 60
#define MINS_IN_DAY 1440
#define DISABLE_BACKUP -1
void CBackupPage::SetInterval(HWND hDlg, UINT minutes)
{
int m_CBIdx = UNIT_MINUTE;
UINT value = minutes;
if((minutes % MINS_IN_HOUR) == 0)
{
m_CBIdx = UNIT_HOUR;
value = minutes / MINS_IN_HOUR;
}
else if((minutes % MINS_IN_DAY) == 0)
{
m_CBIdx = UNIT_DAY;
value = minutes / MINS_IN_DAY;
}
CHString1 temp;
temp.Format(_T("%d"), value);
SetWindowText(GetDlgItem(hDlg, IDC_BACKUPINTERVAL), temp);
ComboBox_SetCurSel(GetDlgItem(hDlg, IDC_BACKUP_UNITS), m_CBIdx);
}
//---------------------------------------------------------------------------
bool CBackupPage::GetInterval(HWND hDlg, UINT &iValue, bool &valid)
{
int idx = ComboBox_GetCurSel(GetDlgItem(hDlg, IDC_BACKUP_UNITS));
TCHAR value[4] = {0};
valid = false;
iValue = 0;
::GetWindowText(GetDlgItem(hDlg, IDC_BACKUPINTERVAL), value, 4);
iValue = _ttoi(value);
// scale to minutes based on the combo box.
switch(idx)
{
case UNIT_HOUR:
iValue *= MINS_IN_HOUR;
break;
case UNIT_DAY:
iValue *= MINS_IN_DAY;
break;
}
if((iValue == 0) ||
((iValue >= 5) && (iValue <= 1440)))
{
valid = true;
}
else
{
CHString1 caption, threat;
caption.LoadString(IDS_SHORT_NAME);
threat.LoadString(IDS_BAD_INTERVAL);
MessageBox(hDlg, (LPCTSTR)threat, (LPCTSTR)caption,
MB_OK|MB_ICONEXCLAMATION);
}
return (m_CBIdx != idx);
}
//---------------------------------------------------------------------------
void CBackupPage::Refresh(HWND hDlg, bool force)
{
if(force ||
(m_DS && m_DS->IsNewConnection(&m_sessionID)))
{
CHString1 temp;
UINT iTemp = 0;
CHString1 szNotRemoteable, szUnavailable;
HRESULT hr = S_OK;
BOOL enable = TRUE;
szNotRemoteable.LoadString(IDS_NOT_REMOTEABLE);
szUnavailable.LoadString(IDS_UNAVAILABLE);
PageChanged(PB_BACKUP, false);
// - - - - - - - - - - - - - -
// Interval:
iTemp = 0;
hr = m_DS->GetBackupInterval(iTemp);
if(SUCCEEDED(hr))
{
if(iTemp == 0)
{
Button_SetCheck(GetDlgItem(hDlg, IDC_BACKUP_ENABLED), BST_UNCHECKED);
SetWindowText(GetDlgItem(hDlg, IDC_BACKUPINTERVAL), _T("0"));
ComboBox_SetCurSel(GetDlgItem(hDlg, IDC_BACKUP_UNITS), -1);
enable = FALSE;
}
else
{
Button_SetCheck(GetDlgItem(hDlg, IDC_BACKUP_ENABLED), BST_CHECKED);
SetInterval(hDlg, iTemp);
enable = TRUE;
}
}
else //failed
{
enable = FALSE;
SetWindowText(GetDlgItem(hDlg, IDC_BACKUPINTERVAL),
szUnavailable);
::EnableWindow(GetDlgItem(hDlg, IDC_BACKUP_ENABLED), enable);
}
::EnableWindow(GetDlgItem(hDlg, IDC_BACKUPINTERVAL), enable);
::EnableWindow(GetDlgItem(hDlg, IDC_BACKUP_UNITS), enable);
// - - - - - - - - - - - - - -
// DB dir:
HWND hWnd = GetDlgItem(hDlg, IDC_DB_DIR);
if(hWnd)
{
CHString1 dir;
hr = m_DS->GetDBLocation(dir);
if(SUCCEEDED(hr))
{
enable = TRUE;
TCHAR shortPath[40] = {0};
PathCompactPathEx(shortPath, dir, 35,0);
Edit_SetText(hWnd, (LPCTSTR)shortPath);
}
else
{
enable = FALSE;
SetWindowText(hWnd,szUnavailable);
}
::EnableWindow(hWnd, enable);
::EnableWindow (GetDlgItem(hDlg, IDC_DBDIRECTORY_LABEL), enable);
}
// - - - - - - - - - - - - - -
// Last backup:
temp.Empty();
hr = m_DS->GetLastBackup(temp);
if(SUCCEEDED(hr))
{
enable = (hr != WBEM_S_FALSE);
SetWindowText(GetDlgItem(hDlg, IDC_LASTBACKUP),
temp);
}
else //failed
{
enable = FALSE;
SetWindowText(GetDlgItem(hDlg, IDC_LASTBACKUP),
szUnavailable);
}
::EnableWindow(GetDlgItem(hDlg, IDC_LASTBACKUP_LABEL), enable);
::EnableWindow(GetDlgItem(hDlg, IDC_LASTBACKUP), enable);
}
}
//------------------------------------------------------------------------
void CBackupPage::OnApply(HWND hDlg, bool bClose)
{
if(m_bWhistlerCore == false)
{
HWND intervalHWND = GetDlgItem(hDlg, IDC_BACKUPINTERVAL);
bool needToPut = false;
UINT iValue = 0;
bool valid = false;
bool changed = GetInterval(hDlg, iValue, valid);
if((changed || Edit_GetModify(intervalHWND)) && valid)
{
m_DS->SetBackupInterval(iValue);
needToPut = true;
}
if(needToPut)
{
NeedToPut(PB_BACKUP, !bClose);
if(!bClose)
Refresh(hDlg);
}
}
}
//-----------------------------------------------------
void CBackupPage::Reconnect(void)
{
HRESULT hr = 0;
LOGIN_CREDENTIALS *credentials = m_DS->GetCredentials();
m_DS->Disconnect();
hr = m_DS->Connect(credentials);
if(SUCCEEDED(hr))
{
m_alreadyAsked = false;
if(ServiceIsReady(NO_UI, 0,0))
{
m_DS->Initialize(0);
}
else
{
TCHAR caption[100] = {0}, msg[256] = {0};
::LoadString(_Module.GetModuleInstance(), IDS_SHORT_NAME,
caption, 100);
::LoadString(_Module.GetModuleInstance(), IDS_CONNECTING,
msg, 256);
if(DisplayAVIBox(m_hDlg, caption, msg, &m_AVIbox) == IDCANCEL)
{
g_serviceThread->Cancel();
}
}
}
}
//-----------------------------------------------------
void CBackupPage::Reconnect2(void)
{
m_DS->Disconnect();
TCHAR caption[100] = {0}, msg[256] = {0};
::LoadString(_Module.GetModuleInstance(), IDS_SHORT_NAME,
caption, 100);
::LoadString(_Module.GetModuleInstance(), IDS_POST_RESTORE,
msg, 256);
MessageBox(m_hDlg, (LPCTSTR)msg, (LPCTSTR)caption,
MB_OK|MB_DEFBUTTON1|MB_ICONEXCLAMATION);
PropSheet_SetCurSel(GetParent(m_hDlg), 0, 0);
}
//---------------------------------------------------------------------------
void CBackupPage::OnFinishConnected(HWND hDlg, LPARAM lParam)
{
if(m_AVIbox)
{
PostMessage(m_AVIbox,
WM_ASYNC_CIMOM_CONNECTED,
0, 0);
m_AVIbox = 0;
}
IStream *pStream = (IStream *)lParam;
IWbemServices *pServices = 0;
HRESULT hr = CoGetInterfaceAndReleaseStream(pStream,
IID_IWbemServices,
(void**)&pServices);
SetWbemService(pServices);
if(ServiceIsReady(NO_UI, 0,0))
{
m_DS->Initialize(pServices);
}
}
//---------------------------------------------------------------
void CBackupPage::SetPriv(LPCTSTR privName, IWbemBackupRestore *br)
{
if (ImpersonateSelf(SecurityImpersonation))
{
if(OpenThreadToken( GetCurrentThread(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
FALSE, &m_hAccessToken ) )
{
m_fClearToken = true;
// Now, get the LUID for the privilege from the local system
ZeroMemory(&m_luid, sizeof(m_luid));
LookupPrivilegeValue(NULL, privName, &m_luid);
// m_cloak = true;
EnablePriv(true, br);
}
else
{
DWORD err = GetLastError();
}
}
else
{
DWORD err = GetLastError();
}
}
//---------------------------------------------------------------------
bool CBackupPage::IsClientNT5OrMore(void)
{
OSVERSIONINFO os;
os.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if(!GetVersionEx(&os))
return FALSE; // should never happen
return ( os.dwPlatformId == VER_PLATFORM_WIN32_NT ) && ( os.dwMajorVersion >= 5 ) ;
}
//---------------------------------------------------------------
DWORD CBackupPage::EnablePriv(bool fEnable, IWbemBackupRestore *br)
{
DWORD dwError = ERROR_SUCCESS;
TOKEN_PRIVILEGES tokenPrivileges;
tokenPrivileges.PrivilegeCount = 1;
tokenPrivileges.Privileges[0].Luid = m_luid;
tokenPrivileges.Privileges[0].Attributes = ( fEnable ? SE_PRIVILEGE_ENABLED : 0 );
if(AdjustTokenPrivileges(m_hAccessToken,
FALSE,
&tokenPrivileges,
0, NULL, NULL) != 0)
{
HRESULT hr = E_FAIL;
if(br)
{
//Privileges for backup/restore are only set for the local box
//case, so in this case we need to set cloaking on the
//interface for the privileges to be transfered with the call.
//Make sure this is never called remotely, since in that case
//the authident needs to be used and privileges are transferred
//remotely so cloaking is NOT needed for remote (and if set
//will null the user authident out !!)
try
{
hr = SetInterfaceSecurityEx(
br,
m_cred->authIdent, //for local this is actually not relevant...
NULL,
RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
IsClientNT5OrMore() ? EOAC_DYNAMIC_CLOAKING :
EOAC_NONE);
}
catch( ... )
{
hr = E_FAIL;
}
}
}
else
{
dwError = ::GetLastError();
}
return dwError;
}
//---------------------------------------------------------------
void CBackupPage::ClearPriv(void)
{
// m_cloak = true;
EnablePriv(false);
if(m_fClearToken)
{
CloseHandle(m_hAccessToken);
m_hAccessToken = 0;
m_fClearToken = false;
}
RevertToSelf(); //to make sure token is removed from thread (counterpart to ImpersonateSelf() in SetPriv())
}
//-----------------------------------------------------
void __cdecl BackupRestoreThread(LPVOID lpParameter)
{
CBackupPage *me = (CBackupPage *)lpParameter;
MULTI_QI qi = {&IID_IWbemBackupRestore, 0, 0};
CoInitialize(0);
if(me->m_DS->IsLocal())
{
me->m_backupHr = CoCreateInstanceEx(CLSID_WbemBackupRestore, 0,
CLSCTX_LOCAL_SERVER, 0, 1, &qi);
}
else
{
COSERVERINFO server = {0,0,0,0};
WCHAR machine[MAXCOMPUTER_NAME + 1] = {0};
#ifdef UNICODE
wcscpy(machine, me->m_DS->m_whackedMachineName);
#else
mbstowcs(machine,
(LPCTSTR)me->m_DS->m_whackedMachineName,
_tcslen(me->m_DS->m_whackedMachineName) + 1);
#endif
server.pwszName = machine;
COAUTHINFO authInfo = {10,0, 0, RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
me->m_cred->authIdent, 0};
server.pAuthInfo = &authInfo;
me->m_backupHr = CoCreateInstanceEx(CLSID_WbemBackupRestore, 0,
CLSCTX_REMOTE_SERVER,
&server, 1, &qi);
}
if(SUCCEEDED(me->m_backupHr) && SUCCEEDED(qi.hr))
{
IWbemBackupRestore *pBR = (IWbemBackupRestore *)qi.pItf;
SetInterfaceSecurityEx(pBR,
me->m_cred->authIdent,
NULL,
RPC_C_AUTHN_LEVEL_DEFAULT,
RPC_C_IMP_LEVEL_IMPERSONATE,
0);
ATLTRACE(_T("begin backup/restore\n"));
//Sleep(1000);
CHString1 verStr;
bool TgtisNT5 = true;
if(me->m_DS)
{
me->m_DS->GetOSVersion(verStr);
if(verStr[0] == _T('4'))
TgtisNT5 = false;
}
if(me->m_doingBackup)
{
//Only set the privilege if we are local - otherwise the privilege is there already
//in the thread token...
if( me->m_DS->IsLocal() && TgtisNT5)
me->SetPriv(SE_BACKUP_NAME, pBR);
me->m_backupHr = pBR->Backup(me->m_wszArgs, 0);
}
else
{
//Only set the privilege if we are local - otherwise the privilege is there already
//in the thread token...
if( me->m_DS->IsLocal() && TgtisNT5)
me->SetPriv(SE_RESTORE_NAME, pBR);
me->m_backupHr = pBR->Restore(me->m_wszArgs,
WBEM_FLAG_BACKUP_RESTORE_FORCE_SHUTDOWN);
}
if(TgtisNT5)
me->ClearPriv();
ATLTRACE(_T("done backup/restore\n"));
qi.pItf->Release();
}
CoUninitialize();
// kill the distraction.
if(me->m_AVIbox)
{
::PostMessage(me->m_AVIbox, WM_ASYNC_CIMOM_CONNECTED, 0, 0);
}
_endthread();
}
//------------------------------------------------------------------------
void CBackupPage::DealWithPath(LPCTSTR pathFile)
{
#ifdef UNICODE
if (m_wszArgs != NULL)
delete m_wszArgs;
m_wszArgs = new TCHAR[lstrlen(pathFile) + 1];
if (m_wszArgs != NULL)
lstrcpy(m_wszArgs, pathFile);
#else
size_t nSize = mbstowcs(NULL, (LPCTSTR)pathFile, _tcslen(pathFile) + 1);
m_wszArgs = new wchar_t[nSize + 1];
mbstowcs(m_wszArgs, (LPCTSTR)pathFile, _tcslen(pathFile) + 1);
#endif
}
//------------------------------------------------------------------------
void CBackupPage::DealWithDomain(void)
{
m_cred = m_DS->GetCredentials();
// 54062- Nt 4.0 rpc crashes if given a null domain name along with a valid user name
if((m_cred->authIdent != 0) &&
(m_cred->authIdent->DomainLength == 0) &&
(m_cred->authIdent->UserLength > 0) && IsNT(4))
{
LPTSTR pNTDomain = NULL;
CNtSid sid(CNtSid::CURRENT_USER);
DWORD dwRet = sid.GetInfo(NULL, &pNTDomain, NULL);
if(dwRet == 0)
{
#ifdef UNICODE
if(m_cred->authIdent->Flags == SEC_WINNT_AUTH_IDENTITY_ANSI)
{
// convert UNICODE to ansi.
int size = wcstombs(NULL, pNTDomain, 0);
m_cred->authIdent->Domain =
(LPWSTR)CoTaskMemAlloc((size+1) * sizeof(TCHAR));
if (m_cred->authIdent->Domain != NULL)
{
memset(m_cred->authIdent->Domain, 0,
(size+1) * sizeof(TCHAR));
wcstombs((char *)m_cred->authIdent->Domain, pNTDomain,
size);
m_cred->authIdent->DomainLength = size;
}
}
else
{
//straight unicode copy.
m_cred->authIdent->DomainLength = wcslen(pNTDomain);
m_cred->authIdent->Domain = (LPWSTR)pNTDomain;
}
#else // ANSI
if(m_cred->authIdent->Flags == SEC_WINNT_AUTH_IDENTITY_ANSI)
{
//straight ansi copy.
m_cred->authIdent->DomainLength = strlen(pNTDomain);
m_cred->authIdent->Domain = (LPWSTR)pNTDomain;
}
else
{
// convert ansi to UNICODE.
int size = mbstowcs(NULL, pNTDomain, 0);
WCHAR temp[100] = {0};
m_cred->authIdent->Domain =
(LPWSTR)CoTaskMemAlloc((size+1) * sizeof(WCHAR));
if (m_cred->authIdent->Domain != NULL)
{
memset(m_cred->authIdent->Domain, 0,
(size+1) * sizeof(WCHAR));
mbstowcs(temp, pNTDomain, min(99, size)); //so it's always null terminated
wcscpy(m_cred->authIdent->Domain, temp);
m_cred->authIdent->DomainLength = size;
}
}
#endif UNICODE
}
}
}
//----------------------------------------------------------
BOOL CBackupPage::BackupMethod(HWND hDlg, LPCTSTR pathFile)
{
UINT prompt = IDYES;
TCHAR drive[_MAX_DRIVE] = {0}, path[_MAX_DIR] = {0},
temp[_MAX_PATH] = {0};
// rip it apart.
_tsplitpath(pathFile, drive, path, NULL, NULL);
_tcscpy(temp, drive);
_tcscat(temp, path);
if(!m_DS->IsValidDir(CHString1(temp)))
{
CHString1 caption, threat;
caption.LoadString(IDS_SHORT_NAME);
threat.LoadString(IDS_NEED_EXISTING_DIR);
MessageBox(hDlg, (LPCTSTR)threat, (LPCTSTR)caption,
MB_OK|MB_DEFBUTTON1|MB_ICONEXCLAMATION);
return FALSE;
}
else if(m_DS->IsValidFile(pathFile))
{
CHString1 caption, threat;
caption.LoadString(IDS_SHORT_NAME);
threat.LoadString(IDS_BACKUP_OVERWRITE);
prompt = MessageBox(hDlg, (LPCTSTR)threat, (LPCTSTR)caption,
MB_YESNO|MB_DEFBUTTON2|MB_ICONEXCLAMATION);
}
if(prompt == IDYES)
{
DealWithPath(pathFile);
// UI
CHString1 title, msg, fmt;
m_AVIbox = 0;
TCHAR shortPath[33] = {0};
m_backupHr = S_OK;
title.LoadString(IDS_BACKUP_TITLE);
fmt.LoadString(IDS_BACKUP_FMT);
PathCompactPathEx(shortPath, pathFile, 32,0);
msg.Format(fmt, shortPath);
DealWithDomain();
// m_DS->m_rootThread.m_WbemServices.SetPriv(SE_BACKUP_NAME);
m_doingBackup = true;
if(_beginthread(BackupRestoreThread, 0,
(LPVOID)this) != -1)
{
DisplayAVIBox(hDlg, title, msg, &m_AVIbox, FALSE);
}
if(FAILED(m_backupHr))
{
TCHAR msg[256] = {0};
if(ErrorStringEx(m_backupHr, msg, 256))
{
CHString1 caption;
caption.LoadString(IDS_SHORT_NAME);
MessageBox(hDlg, msg, caption, MB_OK| MB_ICONWARNING);
}
}
// m_DS->m_rootThread.m_WbemServices.ClearPriv();
} //endif doIt
return SUCCEEDED(m_backupHr);
}
//------------------------------------------------------------------------
HRESULT CBackupPage::RestoreMethod(HWND hDlg, LPCTSTR pathFile)
{
HRESULT hr = WBEM_E_NOT_FOUND;
if(m_DS->IsValidFile(pathFile))
{
DealWithPath(pathFile);
// UI
CHString1 title, msg, fmt;
m_AVIbox = 0;
TCHAR shortPath[33] = {0};
title.LoadString(IDS_RESTORE_TITLE);
fmt.LoadString(IDS_RESTORE_FMT);
PathCompactPathEx(shortPath, pathFile, 32,0);
msg.Format(fmt, shortPath);
DealWithDomain();
m_doingBackup = false;
if(_beginthread(BackupRestoreThread, 0,
(LPVOID)this) != -1)
{
DisplayAVIBox(hDlg, title, msg, &m_AVIbox, FALSE);
Reconnect2();
}
if(FAILED(m_backupHr))
{
TCHAR msg[256] = {0};
if(ErrorStringEx(m_backupHr, msg, 256))
{
CHString1 caption;
caption.LoadString(IDS_SHORT_NAME);
MessageBox(hDlg, msg, caption, MB_OK| MB_ICONWARNING);
}
}
hr = m_backupHr;
}
else
{
// NOTE: shouldn't ever get here... but..
CHString1 caption, threat;
caption.LoadString(IDS_SHORT_NAME);
threat.LoadString(IDS_NO_BACKUP_FILE);
MessageBox(hDlg, (LPCTSTR)threat, (LPCTSTR)caption,
MB_OK|MB_ICONEXCLAMATION);
}
return hr;
}
//------------------------------------------------------------------------
BOOL CBackupPage::DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
TCHAR * pszFilter;
switch(uMsg)
{
case WM_INITDIALOG:
InitDlg(hDlg);
break;
case WM_ASYNC_CIMOM_CONNECTED:
{
OnFinishConnected(hDlg, lParam);
Refresh(hDlg);
}
break;
case WM_NOTIFY:
switch(((LPNMHDR)lParam)->code)
{
case PSN_SETACTIVE:
Refresh(hDlg);
break;
case PSN_HELP:
HTMLHelper(hDlg);
break;
case PSN_APPLY:
OnApply(hDlg, (((LPPSHNOTIFY)lParam)->lParam == 1));
break;
}
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDC_BACKUPINTERVAL:
if(HIWORD(wParam) == EN_KILLFOCUS)
{
TCHAR buf[4] = {0};
int iVal = 0;
::GetWindowText((HWND)lParam, buf, ARRAYSIZE(buf));
iVal = _ttoi(buf);
if(iVal == 0)
{
BOOL enable = TRUE;
CHString1 caption, threat;
caption.LoadString(IDS_SHORT_NAME);
threat.LoadString(IDS_BACKUP_THREAT);
if(MessageBox(hDlg, (LPCTSTR)threat, (LPCTSTR)caption,
MB_YESNO|MB_DEFBUTTON2|MB_ICONEXCLAMATION) == IDYES)
{
ComboBox_SetCurSel(GetDlgItem(hDlg, IDC_BACKUP_UNITS), -1);
::EnableWindow((HWND)lParam, FALSE);
::EnableWindow(GetDlgItem(hDlg, IDC_BACKUP_UNITS), FALSE);
Button_SetCheck(GetDlgItem(hDlg, IDC_BACKUP_ENABLED), BST_UNCHECKED);
}
else
{
Button_SetCheck(GetDlgItem(hDlg, IDC_BACKUP_ENABLED), BST_CHECKED);
Refresh(hDlg, true);
return TRUE;
}
}
PageChanged(PB_BACKUP, true);
}
else if((HIWORD(wParam) == EN_CHANGE) &&
Edit_GetModify((HWND)lParam))
{
PageChanged(PB_BACKUP, true);
return TRUE;
}
break;
case IDC_BACKUP_UNITS:
if(HIWORD(wParam) == CBN_SELCHANGE)
{
PageChanged(PB_BACKUP, true);
return TRUE;
}
break;
case IDC_RESTORE_FM_AUTO:
if(HIWORD(wParam) == BN_CLICKED)
{
CHString1 dbPath;
m_DS->GetDBDir(dbPath);
dbPath += _T("\\Cim.rec");
CHString1 caption, threat;
caption.LoadString(IDS_AUTORESTORE);
threat.LoadString(IDS_SURE);
if(MessageBox(hDlg, threat, caption,
MB_YESNO|MB_DEFBUTTON2|MB_ICONQUESTION) == IDYES)
{
RestoreMethod(hDlg, dbPath);
}
}
break;
case IDC_BACKUP_BTN:
if(HIWORD(wParam) == BN_CLICKED)
{
TCHAR pathFile[MAX_PATH] = {0};
CHString1 dbPath;
TCHAR recFilter[200] = {0}, all[100] = {0};
TCHAR *pTemp = recFilter;
m_DS->GetDBDir(dbPath);
int recSize = ::LoadString(_Module.GetModuleInstance(), IDS_REC_FILTER,
recFilter, 100);
int allSize = ::LoadString(_Module.GetModuleInstance(), IDS_ALL_FILTER,
all, 100);
// Build this string with the words coming from the string table.
//_T("WMI Recovery Files (*.rec)\0*.rec\0All Files (*.*)\0*.*\0\0");
pszFilter = new TCHAR[_tcslen(recFilter) + 1 +
ARRAYSIZE(REC_WILDCARD) +
_tcslen(all) + 1 +
ARRAYSIZE(ALL_WILDCARD) + 1];
if (pszFilter != NULL)
{
TCHAR * psz = pszFilter;
_tcscpy(psz, recFilter);
psz += recSize + 1;
_tcscpy(psz,REC_WILDCARD);
psz += ARRAYSIZE(REC_WILDCARD);
_tcscpy(psz, all);
psz += allSize + 1;
_tcscpy(psz, ALL_WILDCARD);
psz += ARRAYSIZE(ALL_WILDCARD);
*psz = _T('\0');
if(BrowseForFile(hDlg,
IDS_OPEN_BACKUP,
recFilter,
(LPCTSTR)dbPath,
pathFile,
MAX_PATH))
{
BackupMethod(hDlg, pathFile);
}
delete pszFilter;
}
}
break;
case IDC_RESTORE_BTN:
if(HIWORD(wParam) == BN_CLICKED)
{
TCHAR pathFile[MAX_PATH] = {0};
CHString1 dbPath, title;
TCHAR recFilter[100] = {0}, all[100] = {0};
m_DS->GetDBDir(dbPath);
int recSize = ::LoadString(_Module.GetModuleInstance(), IDS_REC_FILTER,
recFilter, 100);
int allSize = ::LoadString(_Module.GetModuleInstance(), IDS_ALL_FILTER,
all, 100);
// Build this string with the words coming from the string table.
//_T("WMI Recovery Files (*.rec)\0*.rec\0All Files (*.*)\0*.*\0\0");
pszFilter = new TCHAR[_tcslen(recFilter) + 1 +
ARRAYSIZE(REC_WILDCARD) +
_tcslen(all) + 1 +
ARRAYSIZE(ALL_WILDCARD) + 1];
if (pszFilter != NULL)
{
TCHAR * psz = pszFilter;
_tcscpy(psz, recFilter);
psz += recSize + 1;
_tcscpy(psz,REC_WILDCARD);
psz += ARRAYSIZE(REC_WILDCARD);
_tcscpy(psz, all);
psz += allSize + 1;
_tcscpy(psz, ALL_WILDCARD);
psz += ARRAYSIZE(ALL_WILDCARD);
*psz = _T('\0');
if(BrowseForFile(hDlg,
IDS_OPEN_RESTORE,
pszFilter,
(LPCTSTR)dbPath,
pathFile,
MAX_PATH,
0))
{
RestoreMethod(hDlg, pathFile);
}
delete pszFilter;
}
}
break;
case IDC_BACKUP_ENABLED:
if(HIWORD(wParam) == BN_CLICKED)
{
int x = Button_GetState((HWND)lParam);
BOOL checked = (x & BST_CHECKED);
BOOL enable = FALSE;
if(checked)
{
// turn on and repopulate the edit fields.
CHString1 temp;
UINT iTemp = 30;
SetInterval(hDlg, iTemp);
enable = TRUE;
}
else // turning off.
{
CHString1 caption, threat;
caption.LoadString(IDS_SHORT_NAME);
threat.LoadString(IDS_BACKUP_THREAT);
if(MessageBox(hDlg, (LPCTSTR)threat, (LPCTSTR)caption,
MB_YESNO|MB_DEFBUTTON2|MB_ICONEXCLAMATION) == IDYES)
{
SetWindowText(GetDlgItem(hDlg, IDC_BACKUPINTERVAL), _T("0"));
ComboBox_SetCurSel(GetDlgItem(hDlg, IDC_BACKUP_UNITS), -1);
enable = FALSE;
}
else
{
Button_SetCheck(GetDlgItem(hDlg, IDC_BACKUP_ENABLED), BST_CHECKED);
Refresh(hDlg);
return TRUE;
}
}
::EnableWindow(GetDlgItem(hDlg, IDC_BACKUPINTERVAL), enable);
::EnableWindow(GetDlgItem(hDlg, IDC_BACKUP_UNITS), enable);
PageChanged(PB_BACKUP, true);
return TRUE;
}
break;
default: break;
} //endswitch(LOWORD(wParam))
break;
case WM_HELP:
if (IsWindowEnabled(hDlg))
{
WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle,
c_HelpFile,
HELP_WM_HELP,
(ULONG_PTR)buPageHelpIDs);
}
break;
case WM_CONTEXTMENU:
if (IsWindowEnabled(hDlg))
{
WinHelp(hDlg, c_HelpFile,
HELP_CONTEXTMENU,
(ULONG_PTR)buPageHelpIDs);
}
break;
default:
return FALSE;
}
return TRUE;
}
void CBackupPage::HideAutomaticBackupControls(HWND hDlg)
{
ShowWindow(GetDlgItem(hDlg,IDC_AUTOMATIC_GROUPBOX),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_ADV_NOW_TEXT),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_BACKUP_ENABLED),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_BACKUPINTERVAL),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_BACKUP_UNITS),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_LASTBACKUP_LABEL),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_LASTBACKUP),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_RESTORE_FM_AUTO),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_BACKUP_UNITS),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_DBDIRECTORY_LABEL),SW_HIDE);
ShowWindow(GetDlgItem(hDlg,IDC_DB_DIR),SW_HIDE);
SetWindowPos(GetDlgItem(hDlg,IDC_MANUAL_GROUPBOX),NULL,7,12,0,0,SWP_NOSIZE | SWP_NOZORDER);
SetWindowPos(GetDlgItem(hDlg,IDC_ADV_NOW_TEXT2),NULL,32,35,0,0,SWP_NOSIZE | SWP_NOZORDER);
SetWindowPos(GetDlgItem(hDlg,IDC_BACKUP_BTN),NULL,40,97,87,14,SWP_NOSIZE | SWP_NOZORDER);
SetWindowPos(GetDlgItem(hDlg,IDC_RESTORE_BTN),NULL,195,97,87,14,SWP_NOSIZE | SWP_NOZORDER);
m_bWhistlerCore = true;
}