1455 lines
40 KiB
C++
1455 lines
40 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation 1996-2001.
|
|
//
|
|
// File: command.cpp
|
|
//
|
|
// Contents: implementation of CComponentDataImpl
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include "stdafx.h"
|
|
#include "wrapper.h"
|
|
#include "snapmgr.h"
|
|
#include "asgncnfg.h"
|
|
#include "util.h"
|
|
#include <io.h>
|
|
|
|
static BOOL RecursiveCreateDirectory(
|
|
IN LPCTSTR pszDir
|
|
)
|
|
{
|
|
DWORD dwAttr;
|
|
DWORD dwErr;
|
|
LPCTSTR psz;
|
|
DWORD cch;
|
|
WCHAR wch;
|
|
LPTSTR pszParent = NULL;
|
|
BOOL fResult = FALSE;
|
|
|
|
dwAttr = GetFileAttributes(pszDir);
|
|
|
|
if (0xFFFFFFFF != dwAttr)
|
|
{
|
|
if (FILE_ATTRIBUTE_DIRECTORY & dwAttr)
|
|
fResult = TRUE;
|
|
goto CommonReturn;
|
|
}
|
|
|
|
dwErr = GetLastError();
|
|
if (!(ERROR_PATH_NOT_FOUND == dwErr || ERROR_FILE_NOT_FOUND == dwErr))
|
|
return FALSE;
|
|
|
|
if (CreateDirectory(pszDir, NULL)) // lpSecurityAttributes
|
|
{
|
|
fResult = TRUE;
|
|
goto CommonReturn;
|
|
}
|
|
|
|
dwErr = GetLastError();
|
|
if (!(ERROR_PATH_NOT_FOUND == dwErr || ERROR_FILE_NOT_FOUND == dwErr))
|
|
goto CommonReturn;
|
|
|
|
// Peal off the last path name component
|
|
cch = _tcslen(pszDir);
|
|
psz = pszDir + cch;
|
|
|
|
while (TEXT('\\') != *psz)
|
|
{
|
|
if (psz == pszDir)
|
|
// Path didn't have a \.
|
|
goto CommonReturn;
|
|
psz--;
|
|
}
|
|
|
|
cch = (DWORD)(psz - pszDir);
|
|
if (0 == cch)
|
|
// Detected leading \Path
|
|
goto CommonReturn;
|
|
|
|
// Check for leading \\ or x:\.
|
|
wch = *(psz - 1);
|
|
if ((1 == cch && TEXT('\\') == wch) || (2 == cch && TEXT(':') == wch))
|
|
goto CommonReturn;
|
|
|
|
if (NULL == (pszParent = (LPWSTR) LocalAlloc(0, (cch + 1) * sizeof(WCHAR))))
|
|
goto CommonReturn;
|
|
memcpy(pszParent, pszDir, cch * sizeof(TCHAR));
|
|
pszParent[cch] = TEXT('\0');
|
|
|
|
if (!RecursiveCreateDirectory(pszParent))
|
|
goto CommonReturn;
|
|
if (!CreateDirectory(pszDir, NULL)) // lpSecurityAttributes
|
|
{
|
|
dwErr = GetLastError();
|
|
goto CommonReturn;
|
|
}
|
|
|
|
fResult = TRUE;
|
|
CommonReturn:
|
|
if (pszParent != NULL)
|
|
LocalFree(pszParent);
|
|
return fResult;
|
|
}
|
|
|
|
//+------------------------------------------------------------------------------------
|
|
// CComponentDataImpl::GetWorkingDir
|
|
//
|
|
// Gets the default or last set directory used for the uIDDir.
|
|
// Some defaults defined by this function are.
|
|
//
|
|
// %windir%\security\database - ANALYSIS
|
|
// %windir%\security\Templates - Default profile location.
|
|
//
|
|
// Arguments: [uIDDir] - The ID of the working directory to set or retrieve.
|
|
// [pStr] - Either the source or the return value. When the
|
|
// function returns this value will be set to a directory
|
|
// location.
|
|
//
|
|
// [bSet] - TRUE if [pStr] is to be set as the new working directory.
|
|
// [bFile] - [pStr] contains a file name.
|
|
//
|
|
// Returns: TRUE - If the function succees.
|
|
// FALSE - if something went wrong.
|
|
// We don't really need to much granularity because this is not a critical
|
|
// function.
|
|
//+------------------------------------------------------------------------------------
|
|
BOOL
|
|
CComponentDataImpl::GetWorkingDir(
|
|
GWD_TYPES uIDDir,
|
|
LPTSTR *pStr,
|
|
BOOL bSet,
|
|
BOOL bFile
|
|
)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
if(!pStr)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
LPTSTR szLocationValue = NULL;
|
|
switch(uIDDir)
|
|
{
|
|
case GWD_CONFIGURE_LOG:
|
|
szLocationValue = CONFIGURE_LOG_LOCATIONS_KEY;
|
|
break;
|
|
case GWD_ANALYSIS_LOG:
|
|
szLocationValue = ANALYSIS_LOG_LOCATIONS_KEY;
|
|
break;
|
|
case GWD_OPEN_DATABASE:
|
|
szLocationValue = OPEN_DATABASE_LOCATIONS_KEY;
|
|
break;
|
|
case GWD_IMPORT_TEMPLATE:
|
|
szLocationValue = IMPORT_TEMPLATE_LOCATIONS_KEY;
|
|
break;
|
|
case GWD_EXPORT_TEMPLATE:
|
|
szLocationValue = IMPORT_TEMPLATE_LOCATIONS_KEY; //104152, yanggao, 3/21/2001
|
|
break;
|
|
}
|
|
|
|
|
|
LPTSTR pszPath = NULL;
|
|
int i = 0;
|
|
|
|
if( bSet )
|
|
{
|
|
if(!pStr || !(*pStr))
|
|
return FALSE;
|
|
|
|
i = lstrlen( *pStr );
|
|
if(bFile)
|
|
{
|
|
//
|
|
// Remove the file from the end of the string.
|
|
//
|
|
while(i && (*pStr)[i] != '\\')
|
|
i--;
|
|
}
|
|
|
|
//
|
|
// Create space for the new path and copy what we want.
|
|
//
|
|
pszPath = (LPTSTR)LocalAlloc( 0, (i + 1) * sizeof(TCHAR));
|
|
if(!pszPath)
|
|
return FALSE;
|
|
|
|
memcpy(pszPath, *pStr, (i * sizeof(TCHAR)));
|
|
pszPath[i] = 0;
|
|
|
|
MyRegSetValue(HKEY_CURRENT_USER,
|
|
DEFAULT_LOCATIONS_KEY,
|
|
szLocationValue,
|
|
(BYTE*)pszPath,
|
|
(i+1)*sizeof(TCHAR),
|
|
REG_SZ);
|
|
|
|
LocalFree(pszPath);
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD dwType = REG_SZ;
|
|
if (MyRegQueryValue(HKEY_CURRENT_USER,
|
|
DEFAULT_LOCATIONS_KEY,
|
|
szLocationValue,
|
|
(PVOID*)&pszPath,
|
|
&dwType) == ERROR_SUCCESS)
|
|
{
|
|
*pStr = pszPath;
|
|
return TRUE;
|
|
}
|
|
|
|
CString sAppend;
|
|
DWORD dwRet;
|
|
pszPath = NULL;
|
|
|
|
switch ( uIDDir )
|
|
{
|
|
case GWD_CONFIGURE_LOG:
|
|
case GWD_ANALYSIS_LOG:
|
|
sAppend.LoadString(IDS_LOGFILE_DEFAULT);
|
|
// fall through
|
|
case GWD_OPEN_DATABASE:
|
|
//
|
|
// Used for open DB.
|
|
//
|
|
if (sAppend.IsEmpty())
|
|
{
|
|
sAppend.LoadString( IDS_DB_DEFAULT );
|
|
} // else fell through
|
|
|
|
|
|
//
|
|
// Default directory for analysis.
|
|
//
|
|
pszPath = (LPTSTR)LocalAlloc( 0, (MAX_PATH + sAppend.GetLength() + 1) * sizeof(TCHAR));
|
|
if (pszPath == NULL)
|
|
return FALSE;
|
|
|
|
if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, pszPath)))
|
|
{
|
|
lstrcpy( &(pszPath[lstrlen(pszPath)]), sAppend );
|
|
|
|
//
|
|
// Check to see if the directory does not exist, it may need
|
|
// to be created if this is the first time this user has
|
|
// opened a database.
|
|
//
|
|
TCHAR szTempFile[MAX_PATH];
|
|
CString str;
|
|
|
|
str.LoadString(IDS_TEMP_FILENAME);
|
|
if (!GetTempFileName(pszPath,str,0,szTempFile))
|
|
{
|
|
if ((GetLastError() == ERROR_DIRECTORY) && (RecursiveCreateDirectory(pszPath)))
|
|
{
|
|
fRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
LocalFree(pszPath);
|
|
fRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DeleteFile(szTempFile);
|
|
fRet = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LocalFree(pszPath);
|
|
pszPath = NULL;
|
|
}
|
|
break;
|
|
|
|
case GWD_IMPORT_TEMPLATE:
|
|
case GWD_EXPORT_TEMPLATE:
|
|
|
|
sAppend.LoadString( IDS_DEFAULT_TEMPLATE_DIR );
|
|
|
|
//
|
|
// Default directory for analysis.
|
|
//
|
|
dwRet = GetSystemWindowsDirectory( NULL, 0);
|
|
if (dwRet)
|
|
{
|
|
pszPath = (LPTSTR)LocalAlloc( 0, (dwRet + sAppend.GetLength() + 1) * sizeof(TCHAR));
|
|
if (!pszPath)
|
|
return FALSE;
|
|
|
|
GetSystemWindowsDirectory( pszPath, dwRet + 1);
|
|
lstrcpy( &(pszPath[lstrlen(pszPath)]), sAppend );
|
|
|
|
i = lstrlen(pszPath);
|
|
|
|
//
|
|
// Make sure the user can write to this directory:
|
|
//
|
|
TCHAR szTempFile[MAX_PATH];
|
|
HANDLE hTempFile=NULL;
|
|
CString str;
|
|
|
|
str.LoadString(IDS_TEMP_FILENAME);
|
|
szTempFile[0] = L'\0';
|
|
if (GetTempFileName(pszPath,str,0,szTempFile))
|
|
{
|
|
hTempFile = ExpandAndCreateFile(szTempFile,
|
|
GENERIC_READ|GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
CREATE_NEW,
|
|
FILE_ATTRIBUTE_TEMPORARY,
|
|
NULL);
|
|
}
|
|
if (hTempFile)
|
|
{
|
|
//
|
|
// We have write access to this directory
|
|
//
|
|
::CloseHandle(hTempFile);
|
|
DeleteFile(szTempFile);
|
|
fRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// We don't have write access to this directory. Find another
|
|
// or we can't get a temp file name
|
|
//
|
|
LPTSTR szPath;
|
|
LPITEMIDLIST pidl;
|
|
LPMALLOC pMalloc;
|
|
|
|
//
|
|
// For some reason this won't compile with SHGetFolderPath()
|
|
// Therefore go the long way around and deal with the pidl.
|
|
//
|
|
if (NOERROR == SHGetSpecialFolderLocation(m_hwndParent,CSIDL_PERSONAL,&pidl))
|
|
{
|
|
if (SHGetPathFromIDList(pidl,szTempFile))
|
|
{
|
|
szPath = (LPTSTR)LocalAlloc(LPTR, (lstrlen(szTempFile)+ 1) * sizeof(TCHAR));
|
|
if (szPath)
|
|
{
|
|
//
|
|
// If we can't create a new path then use the old one so the user
|
|
// at least has a starting place to browse from
|
|
//
|
|
lstrcpy(szPath,szTempFile);
|
|
LocalFree(pszPath);
|
|
pszPath = szPath;
|
|
fRet = TRUE;
|
|
}
|
|
}
|
|
if (SUCCEEDED(SHGetMalloc(&pMalloc)))
|
|
{
|
|
pMalloc->Free(pidl);
|
|
pMalloc->Release();
|
|
}
|
|
}
|
|
//
|
|
// If we can't write here the user will have to browse for something
|
|
//
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
*pStr = pszPath;
|
|
return fRet;
|
|
}
|
|
|
|
UINT_PTR CALLBACK OFNHookProc(
|
|
HWND hdlg, // handle to child dialog box
|
|
UINT uiMsg, // message identifier
|
|
WPARAM wParam, // message parameter
|
|
LPARAM lParam // message parameter
|
|
)
|
|
{
|
|
|
|
if ( WM_NOTIFY == uiMsg )
|
|
{
|
|
OFNOTIFY* pOFNotify = (OFNOTIFY*) lParam;
|
|
if ( pOFNotify && CDN_FILEOK == pOFNotify->hdr.code )
|
|
{
|
|
//
|
|
// Don't accept filenames with DBCS characters that are greater then 255 in them
|
|
//
|
|
//Raid #263854, 4/3/2001
|
|
BOOL ferr = TRUE;
|
|
CString strErr;
|
|
if(WideCharToMultiByte(CP_ACP, 0, pOFNotify->lpOFN->lpstrFile,
|
|
-1, NULL, 0, NULL, &ferr))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
strErr.LoadString(IDS_NO_DBCS);
|
|
strErr += L"\r\n\r\n";
|
|
strErr += pOFNotify->lpOFN->lpstrFile;
|
|
AfxMessageBox(strErr);
|
|
|
|
::SetWindowLongPtr(hdlg, DWLP_MSGRESULT, TRUE);
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: OnOpenDataBase()
|
|
//
|
|
// Synopsis: Picks a new database for SAV to work on
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnOpenDataBase()
|
|
{
|
|
//
|
|
// Find the desired new database
|
|
//
|
|
CString strDefExtension;
|
|
CString strFilter;
|
|
CString strOfnTitle;
|
|
CString strDir;
|
|
|
|
strDefExtension.LoadString(IDS_DEFAULT_DB_EXTENSION);
|
|
strFilter.LoadString(IDS_DB_FILTER);
|
|
|
|
strOfnTitle.LoadString(IDS_OPEN_DB_OFN_TITLE);
|
|
|
|
LPTSTR pszDir = NULL;
|
|
//
|
|
// Build a working directory for this object,
|
|
//
|
|
if (GetWorkingDir( GWD_OPEN_DATABASE, &pszDir ) )
|
|
{
|
|
strDir = pszDir;
|
|
LocalFree(pszDir);
|
|
pszDir = NULL;
|
|
}
|
|
|
|
WCHAR szFile[MAX_PATH];
|
|
::ZeroMemory (szFile, MAX_PATH * sizeof(WCHAR));
|
|
OPENFILENAME ofn;
|
|
::ZeroMemory (&ofn, sizeof (OPENFILENAME));
|
|
|
|
ofn.lStructSize = sizeof (OPENFILENAME);
|
|
ofn.hwndOwner = m_hwndParent;
|
|
//HINSTANCE hInstance;
|
|
|
|
// Translate filter into commdlg format (lots of \0)
|
|
LPTSTR szFilter = strFilter.GetBuffer(0); // modify the buffer in place
|
|
// MFC delimits with '|' not '\0'
|
|
LPTSTR pch = szFilter;
|
|
while ((pch = _tcschr(pch, '|')) != NULL)
|
|
*pch++ = '\0';
|
|
// do not call ReleaseBuffer() since the string contains '\0' characters
|
|
ofn.lpstrFilter = szFilter;
|
|
ofn.lpstrFile = szFile;
|
|
ofn.nMaxFile = MAX_PATH * sizeof(WCHAR);
|
|
ofn.lpstrInitialDir = (PCWSTR) strDir;
|
|
ofn.lpstrTitle = strOfnTitle;
|
|
ofn.Flags = OFN_HIDEREADONLY| // Don't show the read only prompt
|
|
OFN_SHAREAWARE|
|
|
OFN_NOREADONLYRETURN|
|
|
OFN_EXPLORER | // Explorer style dialog;
|
|
OFN_DONTADDTORECENT|
|
|
OFN_ENABLEHOOK;
|
|
ofn.lpstrDefExt = (PCWSTR) strDefExtension;
|
|
ofn.lpfnHook = OFNHookProc;
|
|
|
|
if ( GetOpenFileName (&ofn) )
|
|
{
|
|
//
|
|
// Set the working directory of the database.
|
|
//
|
|
pszDir = szFile;
|
|
GetWorkingDir( GWD_OPEN_DATABASE, &pszDir, TRUE, TRUE );
|
|
if( IsSystemDatabase( ofn.lpstrFile /*fo.GetPathName()*/) )
|
|
{
|
|
AfxMessageBox( IDS_CANT_OPEN_SYSTEM_DB, MB_OK);
|
|
return S_FALSE;
|
|
}
|
|
SadName = ofn.lpstrFile; //fo.GetPathName();
|
|
SetErroredLogFile(NULL);
|
|
//
|
|
// If new database doesn't exist then ask for a configuration to import
|
|
//
|
|
|
|
DWORD dwAttr = GetFileAttributes(SadName);
|
|
|
|
if (0xFFFFFFFF == dwAttr)
|
|
{
|
|
SCESTATUS sceStatus = SCESTATUS_SUCCESS;
|
|
//
|
|
// New database, so assign a configuration
|
|
//
|
|
if( OnAssignConfiguration( &sceStatus ) == S_FALSE)
|
|
{
|
|
//
|
|
// If the user decides to cancel the import of a configuration, then,
|
|
// we need to unload the sad information and display the correct
|
|
// error message. Set the sad errored to PROFILE_NOT_FOUND so error,
|
|
// is correct. There is no need to call LoadSadinfo.
|
|
//
|
|
UnloadSadInfo();
|
|
if( sceStatus != SCESTATUS_SUCCESS )
|
|
SadErrored = sceStatus;
|
|
else
|
|
SadErrored = SCESTATUS_PROFILE_NOT_FOUND;
|
|
if(m_AnalFolder)
|
|
{
|
|
m_pConsole->SelectScopeItem(m_AnalFolder->GetScopeItem()->ID);
|
|
}
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Invalidiate currently open database
|
|
//
|
|
RefreshSadInfo();
|
|
return S_OK;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwErr = CommDlgExtendedError();
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: OnNewDataBase()
|
|
//
|
|
// Synopsis: Picks a new database for SAV to work on
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnNewDatabase()
|
|
{
|
|
//
|
|
// Find the desired new database
|
|
//
|
|
CString strDefExtension;
|
|
CString strFilter;
|
|
CString strOfnTitle;
|
|
CWnd cwndParent;
|
|
|
|
strDefExtension.LoadString(IDS_DEFAULT_DB_EXTENSION);
|
|
strFilter.LoadString(IDS_DB_FILTER);
|
|
strOfnTitle.LoadString(IDS_NEW_DB_OFN_TITLE);
|
|
|
|
// Translate filter into commdlg format (lots of \0)
|
|
LPTSTR szFilter = strFilter.GetBuffer(0); // modify the buffer in place
|
|
LPTSTR pch = szFilter;
|
|
// MFC delimits with '|' not '\0'
|
|
while ((pch = _tcschr(pch, '|')) != NULL)
|
|
*pch++ = '\0';
|
|
// do not call ReleaseBuffer() since the string contains '\0' characters
|
|
|
|
OPENFILENAME ofn;
|
|
::ZeroMemory (&ofn, sizeof (OPENFILENAME));
|
|
ofn.lStructSize = sizeof(OPENFILENAME);
|
|
ofn.lpstrFilter = szFilter;
|
|
ofn.lpstrFile = SadName.GetBuffer(MAX_PATH);
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.lpstrDefExt = strDefExtension,
|
|
ofn.hwndOwner = m_hwndParent;
|
|
ofn.Flags = OFN_HIDEREADONLY |
|
|
OFN_SHAREAWARE |
|
|
OFN_EXPLORER |
|
|
OFN_DONTADDTORECENT;
|
|
ofn.lpstrTitle = strOfnTitle;
|
|
|
|
if (GetOpenFileName(&ofn))
|
|
{
|
|
PVOID pHandle = NULL;
|
|
|
|
SadName.ReleaseBuffer();
|
|
//
|
|
// If new database doesn't exist then ask for a configuration to import
|
|
//
|
|
DWORD dwAttr = GetFileAttributes(SadName);
|
|
|
|
if (0xFFFFFFFF == dwAttr)
|
|
{
|
|
//
|
|
// New database, so assign a configuration
|
|
//
|
|
SCESTATUS sceStatus;
|
|
OnAssignConfiguration(&sceStatus);
|
|
}
|
|
|
|
//
|
|
// Invalidiate currently open database
|
|
//
|
|
SetErroredLogFile(NULL);
|
|
RefreshSadInfo();
|
|
return S_OK;
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: OnAssignConfiguration()
|
|
//
|
|
// Synopsis: Assigns a configuration template to SAV's currently selected
|
|
// database
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnAssignConfiguration( SCESTATUS *pSceStatus )
|
|
{
|
|
|
|
//
|
|
//Currently pSceStatus is only used for passing back the error
|
|
//when user presses cancel on select template diaglog.
|
|
|
|
|
|
//
|
|
// Find the desired new database
|
|
//
|
|
CString strDefExtension; // Default extension
|
|
CString strCurFile;
|
|
CString strFilter; // Extension filter
|
|
CString strOfnTitle;
|
|
CWnd cwndParent;
|
|
BOOL bIncremental;
|
|
SCESTATUS status;
|
|
HKEY hKey; // HKEY of TemplateUsed.
|
|
DWORD dwBufSize = 0; // Size of szTemplateUsed in bytes
|
|
DWORD dwType = 0; // Type of registry item, return by query
|
|
DWORD dwStatus;
|
|
|
|
*pSceStatus = 0;
|
|
|
|
//
|
|
// Display a warning and give a chance to cancel
|
|
// if they try to configure a non-system database
|
|
//
|
|
if (IsSystemDatabase(SadName))
|
|
{
|
|
BOOL bImportAnyway;
|
|
|
|
bImportAnyway = AfxMessageBox(IDS_IMPORT_WARNING,MB_OKCANCEL);
|
|
if (IDCANCEL == bImportAnyway)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
strDefExtension.LoadString(IDS_PROFILE_DEF_EXT);
|
|
strFilter.LoadString(IDS_PROFILE_FILTER);
|
|
strOfnTitle.LoadString(IDS_ASSIGN_CONFIG_OFN_TITLE);
|
|
|
|
//
|
|
// Get the last directory used by templates.
|
|
//
|
|
LPTSTR pszDir = NULL;
|
|
if(strCurFile.IsEmpty())
|
|
{
|
|
if (GetWorkingDir( GWD_EXPORT_TEMPLATE, &pszDir ) )
|
|
{
|
|
strCurFile = pszDir;
|
|
LocalFree(pszDir);
|
|
pszDir = NULL;
|
|
}
|
|
}
|
|
strCurFile += TEXT("\\*.");
|
|
strCurFile += strDefExtension;
|
|
|
|
cwndParent.Attach(m_hwndParent);
|
|
CAssignConfiguration ac(TRUE, // File Open, not file save
|
|
strDefExtension, // Default Extension
|
|
strCurFile, // Initial File Name == current DB
|
|
OFN_HIDEREADONLY| // Don't show the read only prompt
|
|
OFN_EXPLORER| // Explorer style dialog
|
|
OFN_ENABLETEMPLATE| // custom template
|
|
OFN_SHAREAWARE| // We're not going to need exclusive
|
|
OFN_DONTADDTORECENT|
|
|
OFN_PATHMUSTEXIST, // The Template must exist for us to assign it.
|
|
strFilter, // Filter for allowed extensions
|
|
&cwndParent); // Dialog's Parent window
|
|
|
|
cwndParent.Detach();
|
|
|
|
ac.m_ofn.lpstrTitle = strOfnTitle.GetBuffer(1);
|
|
ac.m_ofn.lpTemplateName = MAKEINTRESOURCE(IDD_ASSIGN_CONFIG_CHECK);
|
|
if (IDOK == ac.DoModal())
|
|
{
|
|
CThemeContextActivator activator;
|
|
strCurFile = ac.GetPathName();
|
|
bIncremental = ac.m_bIncremental;
|
|
|
|
//
|
|
// Set the working dir to this file.
|
|
//
|
|
pszDir = strCurFile.GetBuffer(0);
|
|
GetWorkingDir( GWD_IMPORT_TEMPLATE, &pszDir, TRUE, TRUE);
|
|
strCurFile.ReleaseBuffer();
|
|
CWaitCursor wc;
|
|
|
|
//
|
|
// Unload the sad info before we choose to do an import.
|
|
//
|
|
UnloadSadInfo();
|
|
status = AssignTemplate(
|
|
strCurFile.IsEmpty() ? NULL:(LPCTSTR)strCurFile,
|
|
SadName,
|
|
bIncremental
|
|
);
|
|
|
|
if (SCESTATUS_SUCCESS != status)
|
|
{
|
|
CString strErr;
|
|
|
|
MyFormatResMessage(status,IDS_IMPORT_FAILED,NULL,strErr);
|
|
AfxMessageBox(strErr);
|
|
|
|
//
|
|
// We don't know if the database is still OK to read so open it anyways.
|
|
//
|
|
LoadSadInfo(TRUE);
|
|
if( SCESTATUS_SPECIAL_ACCOUNT == SadErrored ) //Raid #589139,XPSP1 DCR, yanggao, 4/12/2002.
|
|
*pSceStatus = SadErrored;
|
|
return S_FALSE;
|
|
}
|
|
|
|
RefreshSadInfo();
|
|
return S_OK;
|
|
}
|
|
*pSceStatus = SCESTATUS_NO_TEMPLATE_GIVEN;
|
|
return S_FALSE;
|
|
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: OnSecureWizard()
|
|
//
|
|
// Synopsis: Launch the secure wizard (registered)
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnSecureWizard()
|
|
{
|
|
|
|
HRESULT hr=S_FALSE;
|
|
PWSTR pstrWizardName=NULL;
|
|
|
|
if ( GetSecureWizardName(&pstrWizardName, NULL) )
|
|
{
|
|
|
|
PROCESS_INFORMATION ProcInfo;
|
|
STARTUPINFO StartInfo;
|
|
BOOL fOk;
|
|
|
|
|
|
RtlZeroMemory(&StartInfo,sizeof(StartInfo));
|
|
StartInfo.cb = sizeof(StartInfo);
|
|
StartInfo.dwFlags = STARTF_USESHOWWINDOW;
|
|
StartInfo.wShowWindow = (WORD)SW_SHOWNORMAL;
|
|
|
|
fOk = CreateProcess(pstrWizardName, NULL,
|
|
NULL, NULL, FALSE,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&StartInfo,
|
|
&ProcInfo
|
|
);
|
|
|
|
if ( fOk )
|
|
{
|
|
::CloseHandle(ProcInfo.hProcess);
|
|
::CloseHandle(ProcInfo.hThread);
|
|
|
|
hr = S_OK;
|
|
}
|
|
|
|
LocalFree(pstrWizardName);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: OnSaveConfiguration()
|
|
//
|
|
// Synopsis: Saves the assigned computer template to an INF file
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnSaveConfiguration()
|
|
{
|
|
//
|
|
// Find the desired new database
|
|
//
|
|
CString strDefExtension;
|
|
CString strFilter;
|
|
CWnd cwndParent;
|
|
CString strDefName;
|
|
CString strName;
|
|
SCESTATUS status = SCESTATUS_SUCCESS;
|
|
CString strOfnTitle;
|
|
|
|
strDefExtension.LoadString(IDS_PROFILE_DEF_EXT);
|
|
strFilter.LoadString(IDS_PROFILE_FILTER);
|
|
strOfnTitle.LoadString(IDS_EXPORT_CONFIG_OFN_TITLE);
|
|
|
|
//
|
|
// Get the working directory for INF files.
|
|
//
|
|
LPTSTR pszDir = NULL;
|
|
if( GetWorkingDir( GWD_EXPORT_TEMPLATE, &pszDir ) )
|
|
{
|
|
strDefName = pszDir;
|
|
LocalFree(pszDir);
|
|
pszDir = NULL;
|
|
}
|
|
strDefName += TEXT("\\*.");
|
|
strDefName += strDefExtension;
|
|
|
|
// Translate filter into commdlg format (lots of \0)
|
|
LPTSTR szFilter = strFilter.GetBuffer(0); // modify the buffer in place
|
|
LPTSTR pch = szFilter;
|
|
// MFC delimits with '|' not '\0'
|
|
while ((pch = _tcschr(pch, '|')) != NULL)
|
|
*pch++ = '\0';
|
|
// do not call ReleaseBuffer() since the string contains '\0' characters
|
|
|
|
|
|
OPENFILENAME ofn;
|
|
::ZeroMemory (&ofn, sizeof (OPENFILENAME));
|
|
ofn.lStructSize = sizeof(OPENFILENAME);
|
|
ofn.lpstrFilter = szFilter;
|
|
ofn.lpstrFile = strDefName.GetBuffer(MAX_PATH),
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.lpstrDefExt = strDefExtension,
|
|
ofn.hwndOwner = m_hwndParent;
|
|
ofn.Flags = OFN_HIDEREADONLY |
|
|
OFN_SHAREAWARE |
|
|
OFN_EXPLORER |
|
|
OFN_DONTADDTORECENT;
|
|
ofn.lpstrTitle = strOfnTitle;
|
|
|
|
if (GetSaveFileName(&ofn))
|
|
{
|
|
strDefName.ReleaseBuffer();
|
|
strName = ofn.lpstrFile;
|
|
|
|
//
|
|
// Set the working directory for inf files.
|
|
//
|
|
pszDir = strName.GetBuffer(0);
|
|
GetWorkingDir( GWD_EXPORT_TEMPLATE, &pszDir, TRUE, TRUE );
|
|
strName.ReleaseBuffer();
|
|
//
|
|
// Generate new inf file
|
|
//
|
|
|
|
status = SceCopyBaseProfile(GetSadHandle(),
|
|
SCE_ENGINE_SCP,
|
|
(LPTSTR)(LPCTSTR)strName,
|
|
AREA_ALL,
|
|
NULL );
|
|
if (SCESTATUS_SUCCESS != status)
|
|
{
|
|
CString str;
|
|
CString strErr;
|
|
GetSceStatusString(status, &strErr);
|
|
|
|
AfxFormatString2(str,IDS_EXPORT_FAILED,strName,strErr);
|
|
AfxMessageBox(str);
|
|
return S_FALSE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Method: OnExportPolicy()
|
|
//
|
|
// Synopsis: This function exports either the effective or local table
|
|
// from the system security database to a file.
|
|
//
|
|
// The function asks the user for a file through the CFileOpen
|
|
// class, then writes out the contents of either the effective
|
|
// or local policy table in the system database.
|
|
//
|
|
// Arguments: [bEffective] - Either to export the effect or local table.
|
|
//
|
|
// Returns: S_OK - if everything went well.
|
|
// S_FALSE - something failed.
|
|
//---------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnExportPolicy( BOOL bEffective )
|
|
{
|
|
CString strDefExtension;
|
|
CString strFilter;
|
|
CString strOfnTitle;
|
|
CString strDefName;
|
|
CString strName;
|
|
DWORD dwErr = 0;
|
|
BOOL bCopySuccess = FALSE;
|
|
|
|
strDefExtension.LoadString(IDS_PROFILE_DEF_EXT);
|
|
strFilter.LoadString(IDS_PROFILE_FILTER);
|
|
strOfnTitle.LoadString(IDS_EXPORT_POLICY_OFN_TITLE);
|
|
|
|
//
|
|
// Get the working directory for locations.
|
|
//
|
|
LPTSTR pszDir = NULL;
|
|
if( GetWorkingDir( GWD_EXPORT_TEMPLATE, &pszDir ) )
|
|
{
|
|
strDefName = pszDir;
|
|
LocalFree(pszDir);
|
|
pszDir = NULL;
|
|
}
|
|
strDefName += TEXT("\\*.");
|
|
strDefName += strDefExtension;
|
|
|
|
// Translate filter into commdlg format (lots of \0)
|
|
LPTSTR szFilter = strFilter.GetBuffer(0); // modify the buffer in place
|
|
LPTSTR pch = szFilter;
|
|
// MFC delimits with '|' not '\0'
|
|
while ((pch = _tcschr(pch, '|')) != NULL)
|
|
*pch++ = '\0';
|
|
// do not call ReleaseBuffer() since the string contains '\0' characters
|
|
|
|
|
|
OPENFILENAME ofn;
|
|
::ZeroMemory (&ofn, sizeof (OPENFILENAME));
|
|
ofn.lStructSize = sizeof(OPENFILENAME);
|
|
ofn.lpstrFilter = szFilter;
|
|
ofn.lpstrFile = strDefName.GetBuffer(MAX_PATH),
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.lpstrDefExt = strDefExtension,
|
|
ofn.hwndOwner = m_hwndParent;
|
|
ofn.Flags = OFN_HIDEREADONLY |
|
|
OFN_SHAREAWARE |
|
|
OFN_EXPLORER |
|
|
OFN_DONTADDTORECENT;
|
|
ofn.lpstrTitle = strOfnTitle;
|
|
|
|
if (GetSaveFileName(&ofn))
|
|
{
|
|
strDefName.ReleaseBuffer();
|
|
strName = ofn.lpstrFile;
|
|
|
|
//
|
|
// Set the working directory for locations.
|
|
//
|
|
pszDir = strName.GetBuffer(0);
|
|
GetWorkingDir( GWD_EXPORT_TEMPLATE, &pszDir, TRUE, TRUE );
|
|
strName.ReleaseBuffer();
|
|
|
|
//
|
|
// Make sure we can make the file.
|
|
//
|
|
DWORD dwErr = FileCreateError( strName, 0 );
|
|
if(dwErr == IDNO)
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
//
|
|
// Generate the template
|
|
//
|
|
|
|
SCESTATUS sceStatus;
|
|
CWaitCursor wc;
|
|
|
|
sceStatus = SceSetupGenerateTemplate(
|
|
NULL, // Computer name
|
|
NULL, // The system database
|
|
bEffective, // For right now just the Local Pol table.
|
|
strName.GetBuffer(0),
|
|
NULL,
|
|
AREA_ALL
|
|
);
|
|
strName.ReleaseBuffer();
|
|
|
|
if(sceStatus != SCESTATUS_SUCCESS)
|
|
{
|
|
//
|
|
// Display the error message
|
|
//
|
|
DWORD dwError = SceStatusToDosError( sceStatus );
|
|
CString strErr;
|
|
MyFormatMessage( sceStatus, NULL, NULL, strErr );
|
|
strErr += strName;
|
|
|
|
AfxMessageBox( strErr, MB_ICONEXCLAMATION | MB_OK );
|
|
return S_FALSE;
|
|
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
|
|
//+--------------------------------------------------------------------------------------------
|
|
// CComponentDataImpl::OnImportPolicy
|
|
//
|
|
// Import policy opens a file open dialog box in which the user is allowed to choose
|
|
// a security configuration INF file to import into security policy.
|
|
//
|
|
//
|
|
// Arguments: [pDataObject] - The data object associated with the folder calling
|
|
// this function.
|
|
// Returns: S_OK - Import was successful.
|
|
// S_FALSE - Something went wrong.
|
|
//---------------------------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnImportPolicy(LPDATAOBJECT pDataObject)
|
|
{
|
|
CEditTemplate *pet = NULL;
|
|
CString strDefExtension;
|
|
CString strFilter;
|
|
CString strOfnTitle;
|
|
CWnd cwndParent;
|
|
CString strDefName;
|
|
CString strName;
|
|
|
|
|
|
strDefExtension.LoadString(IDS_PROFILE_DEF_EXT);
|
|
strFilter.LoadString(IDS_PROFILE_FILTER);
|
|
strOfnTitle.LoadString(IDS_IMPORT_POLICY_OFN_TITLE);
|
|
|
|
|
|
LPTSTR pszDir = NULL;
|
|
if( GetWorkingDir( GWD_IMPORT_TEMPLATE, &pszDir ) )
|
|
{
|
|
strDefName = pszDir;
|
|
LocalFree(pszDir);
|
|
pszDir = NULL;
|
|
}
|
|
strDefName += TEXT("\\*.");
|
|
strDefName += strDefExtension;
|
|
|
|
cwndParent.Attach(m_hwndParent);
|
|
CAssignConfiguration fo(TRUE, // File open
|
|
strDefExtension, // Default Extension
|
|
strDefName, // Initial File Name == current DB
|
|
OFN_HIDEREADONLY| // Don't show the read only prompt
|
|
OFN_SHAREAWARE|
|
|
OFN_EXPLORER| // Explorer style dialog
|
|
OFN_ENABLETEMPLATE| // custom template
|
|
OFN_DONTADDTORECENT|
|
|
OFN_PATHMUSTEXIST, // The Template must exist for us to assign it.
|
|
strFilter, // Filter for allowed extensions
|
|
&cwndParent); // Dialog's Parent window
|
|
cwndParent.Detach();
|
|
|
|
fo.m_ofn.lpstrTitle = strOfnTitle.GetBuffer(1);
|
|
fo.m_ofn.lpTemplateName = MAKEINTRESOURCE(IDD_ASSIGN_CONFIG_CHECK);
|
|
|
|
CThemeContextActivator activator;
|
|
if (IDOK == fo.DoModal())
|
|
{
|
|
PVOID pHandle = NULL;
|
|
BOOL bIncremental = fo.m_bIncremental;
|
|
|
|
strName = fo.GetPathName();
|
|
pszDir = strName.GetBuffer(0);
|
|
GetWorkingDir( GWD_IMPORT_TEMPLATE, &pszDir, TRUE, TRUE );
|
|
strName.ReleaseBuffer();
|
|
CWaitCursor wc;
|
|
|
|
CEditTemplate *pet;
|
|
|
|
//
|
|
// pet will be freed in m_Templates in DeleteTemplate
|
|
//
|
|
pet = GetTemplate(strName,AREA_ALL);
|
|
|
|
CString strErr;
|
|
CString strSCE;
|
|
int ret=0;
|
|
|
|
if ( pet == NULL )
|
|
{
|
|
//
|
|
// this is an invalid template or something is wrong reading the data out
|
|
//
|
|
|
|
strSCE.LoadString(IDS_EXTENSION_NAME);
|
|
strErr.Format(IDS_IMPORT_POLICY_INVALID,strName);
|
|
m_pConsole->MessageBox(strErr,strSCE,MB_OK,&ret);
|
|
|
|
return S_FALSE;
|
|
|
|
}
|
|
else
|
|
{
|
|
if ( ( bIncremental &&
|
|
(SCESTATUS_SUCCESS != SceAppendSecurityProfileInfo(m_szSingleTemplateName,
|
|
AREA_ALL,
|
|
pet->pTemplate,
|
|
NULL))) ||
|
|
(!bIncremental && !CopyFile(strName,m_szSingleTemplateName,FALSE) ) )
|
|
{
|
|
//
|
|
// Import Failed
|
|
//
|
|
strSCE.LoadString(IDS_EXTENSION_NAME);
|
|
strErr.Format(IDS_IMPORT_POLICY_FAIL,strName);
|
|
m_pConsole->MessageBox(strErr,strSCE,MB_OK,&ret);
|
|
|
|
DeleteTemplate(strName);
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
DeleteTemplate(strName);
|
|
|
|
}
|
|
|
|
DeleteTemplate(m_szSingleTemplateName);
|
|
|
|
//
|
|
// Update the window.
|
|
//
|
|
pet = GetTemplate(m_szSingleTemplateName);
|
|
if(pet)
|
|
{
|
|
DWORD dwErr = pet->RefreshTemplate();
|
|
if ( 0 != dwErr )
|
|
{
|
|
CString strErr;
|
|
|
|
MyFormatResMessage (SCESTATUS_SUCCESS, dwErr, NULL, strErr);
|
|
AfxMessageBox(strErr);
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
RefreshAllFolders();
|
|
return S_OK;
|
|
}
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------------------------
|
|
// CComponentDataImpl::OnImportLocalPolicy
|
|
//
|
|
// Import policy opens a file open dialog box in which the user is allowed to choose
|
|
// a security configuration INF file to import into local policy.
|
|
//
|
|
// The function asks for the file name then calls SceConfigureSystem() with the
|
|
// SCE_NO_CONFIG option. This imports the specifide file into the local policy
|
|
// database.
|
|
//
|
|
// After the database is updated, we refresh the local policy template held in memory.
|
|
//
|
|
// Arguments: [pDataObject] - The data object associated with the folder calling
|
|
// this function.
|
|
// Returns: S_OK - Import was successful.
|
|
// S_FALSE - Something went wrong.
|
|
//---------------------------------------------------------------------------------------------
|
|
HRESULT
|
|
CComponentDataImpl::OnImportLocalPolicy(LPDATAOBJECT pDataObject)
|
|
{
|
|
CString strDefExtension;
|
|
CString strFilter;
|
|
CString strOfnTitle;
|
|
CString strDefName;
|
|
CString strName;
|
|
DWORD dwErr = 0;
|
|
SCESTATUS sceStatus = SCESTATUS_SUCCESS;
|
|
CString strErr;
|
|
CString strY;
|
|
|
|
|
|
strDefExtension.LoadString(IDS_PROFILE_DEF_EXT);
|
|
strFilter.LoadString(IDS_PROFILE_FILTER);
|
|
strOfnTitle.LoadString(IDS_IMPORT_POLICY_OFN_TITLE);
|
|
|
|
// Translate filter into commdlg format (lots of \0)
|
|
LPTSTR szFilter = strFilter.GetBuffer(0); // modify the buffer in place
|
|
LPTSTR pch = szFilter;
|
|
// MFC delimits with '|' not '\0'
|
|
while ((pch = _tcschr(pch, TEXT('|'))) != NULL)
|
|
*pch++ = TEXT('\0');
|
|
// do not call ReleaseBuffer() since the string contains '\0' characters
|
|
|
|
LPTSTR pszDir = NULL;
|
|
if( GetWorkingDir( GWD_IMPORT_TEMPLATE, &pszDir ) )
|
|
{
|
|
strDefName = pszDir;
|
|
LocalFree(pszDir);
|
|
pszDir = NULL;
|
|
}
|
|
strDefName += TEXT("\\*.");
|
|
strDefName += strDefExtension;
|
|
|
|
|
|
OPENFILENAME ofn;
|
|
::ZeroMemory (&ofn, sizeof (OPENFILENAME));
|
|
ofn.lStructSize = sizeof(OPENFILENAME);
|
|
ofn.lpstrFilter = szFilter;
|
|
ofn.lpstrFile = strDefName.GetBuffer(MAX_PATH),
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.lpstrDefExt = strDefExtension,
|
|
ofn.hwndOwner = m_hwndParent;
|
|
ofn.Flags = OFN_HIDEREADONLY |
|
|
OFN_SHAREAWARE |
|
|
OFN_EXPLORER |
|
|
OFN_DONTADDTORECENT;
|
|
ofn.lpstrTitle = strOfnTitle;
|
|
|
|
if (GetOpenFileName(&ofn))
|
|
{
|
|
PVOID pHandle = NULL;
|
|
|
|
strName = ofn.lpstrFile;
|
|
pszDir = strName.GetBuffer(0);
|
|
GetWorkingDir( GWD_IMPORT_TEMPLATE, &pszDir, TRUE, TRUE );
|
|
strName.ReleaseBuffer();
|
|
CWaitCursor wc;
|
|
|
|
CEditTemplate *pet;
|
|
pet = GetTemplate(strName,AREA_SECURITY_POLICY|AREA_PRIVILEGES);
|
|
if (!pet)
|
|
{
|
|
goto ret_error;
|
|
}
|
|
|
|
//
|
|
// We're going to alter this one so make sure it doesn't save out
|
|
//
|
|
pet->SetNoSave(TRUE);
|
|
|
|
//
|
|
// Remove entries that are set by domain policy since they'll be overwritten
|
|
// anyway and we don't allow setting things that'll be overwritten.
|
|
//
|
|
RemovePolicyEntries(pet);
|
|
|
|
//
|
|
// 120502 - SceUpdateSecurityProfile doesn't work with SCE_STRUCT_INF,
|
|
// but the AREA_SECURITY_POLICY and AREA_PRIVILEGES sections are
|
|
// compatable so we can call it SCE_ENGINE_SYSTEM, which will work.
|
|
//
|
|
SCETYPE origType = pet->pTemplate->Type;
|
|
pet->pTemplate->Type = SCE_ENGINE_SYSTEM;
|
|
|
|
sceStatus = SceUpdateSecurityProfile(NULL,
|
|
AREA_SECURITY_POLICY|AREA_PRIVILEGES,
|
|
pet->pTemplate,
|
|
SCE_UPDATE_SYSTEM
|
|
);
|
|
//
|
|
// Set the type back so the engine knows how to delete it properly
|
|
//
|
|
pet->pTemplate->Type = origType;
|
|
|
|
if (SCESTATUS_SUCCESS != sceStatus)
|
|
{
|
|
goto ret_error;
|
|
}
|
|
//
|
|
// Update the window.
|
|
//
|
|
pet = GetTemplate(GT_LOCAL_POLICY);
|
|
if(pet)
|
|
{
|
|
DWORD dwErr = pet->RefreshTemplate();
|
|
if ( 0 != dwErr )
|
|
{
|
|
CString strErr;
|
|
|
|
MyFormatResMessage (SCESTATUS_SUCCESS, dwErr, NULL, strErr);
|
|
AfxMessageBox(strErr);
|
|
return S_FALSE;
|
|
}
|
|
}
|
|
RefreshAllFolders();
|
|
return S_OK;
|
|
}
|
|
|
|
strDefName.ReleaseBuffer();
|
|
return S_FALSE;
|
|
ret_error:
|
|
strDefName.ReleaseBuffer();
|
|
MyFormatMessage( sceStatus, NULL, NULL, strErr);
|
|
strErr += strName;
|
|
strErr += L"\n";
|
|
strErr += strY;
|
|
AfxMessageBox( strErr, MB_OK);
|
|
return S_FALSE;
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CComponentDataImpl::OnAnalyze()
|
|
{
|
|
PEDITTEMPLATE pet;
|
|
|
|
//
|
|
// If the computer template has been changed then save it before
|
|
// we can inspect against it
|
|
//
|
|
pet = GetTemplate(GT_COMPUTER_TEMPLATE);
|
|
if (pet && pet->IsDirty())
|
|
{
|
|
pet->Save();
|
|
}
|
|
|
|
m_pUIThread->PostThreadMessage(SCEM_ANALYZE_PROFILE,(WPARAM)(LPCTSTR)SadName,(LPARAM)this);
|
|
return S_OK;
|
|
}
|
|
|
|
BOOL
|
|
CComponentDataImpl::RemovePolicyEntries(PEDITTEMPLATE pet)
|
|
{
|
|
PEDITTEMPLATE petPol = GetTemplate(GT_EFFECTIVE_POLICY);
|
|
|
|
if (!petPol)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
#define CD(X) if (petPol->pTemplate->X != SCE_NO_VALUE) { pet->pTemplate->X = SCE_NO_VALUE; };
|
|
|
|
CD(MinimumPasswordAge);
|
|
CD(MaximumPasswordAge);
|
|
CD(MinimumPasswordLength);
|
|
CD(PasswordComplexity);
|
|
CD(PasswordHistorySize);
|
|
CD(LockoutBadCount);
|
|
CD(ResetLockoutCount);
|
|
CD(LockoutDuration);
|
|
CD(RequireLogonToChangePassword);
|
|
CD(ForceLogoffWhenHourExpire);
|
|
CD(EnableAdminAccount);
|
|
CD(EnableGuestAccount);
|
|
|
|
// These members aren't declared in NT4
|
|
CD(ClearTextPassword);
|
|
CD(AuditDSAccess);
|
|
CD(AuditAccountLogon);
|
|
CD(LSAAnonymousNameLookup);
|
|
|
|
CD(MaximumLogSize[0]);
|
|
CD(MaximumLogSize[1]);
|
|
CD(MaximumLogSize[2]);
|
|
CD(AuditLogRetentionPeriod[0]);
|
|
CD(AuditLogRetentionPeriod[1]);
|
|
CD(AuditLogRetentionPeriod[2]);
|
|
CD(RetentionDays[0]);
|
|
CD(RetentionDays[1]);
|
|
CD(RetentionDays[2]);
|
|
CD(RestrictGuestAccess[0]);
|
|
CD(RestrictGuestAccess[1]);
|
|
CD(RestrictGuestAccess[2]);
|
|
CD(AuditSystemEvents);
|
|
CD(AuditLogonEvents);
|
|
CD(AuditObjectAccess);
|
|
CD(AuditPrivilegeUse);
|
|
CD(AuditPolicyChange);
|
|
CD(AuditAccountManage);
|
|
CD(AuditProcessTracking);
|
|
|
|
//
|
|
// These two are strings rather than DWORDs
|
|
//
|
|
if (petPol->pTemplate->NewAdministratorName && pet->pTemplate->NewAdministratorName)
|
|
{
|
|
LocalFree(pet->pTemplate->NewAdministratorName);
|
|
pet->pTemplate->NewAdministratorName = NULL;
|
|
}
|
|
if (petPol->pTemplate->NewGuestName && pet->pTemplate->NewGuestName)
|
|
{
|
|
LocalFree(pet->pTemplate->NewGuestName);
|
|
pet->pTemplate->NewGuestName = NULL;
|
|
}
|
|
|
|
#undef CD
|
|
|
|
//
|
|
// Clear privileges set in PetPol out of pet
|
|
//
|
|
|
|
SCE_PRIVILEGE_ASSIGNMENT *ppaPet = pet->pTemplate->OtherInfo.smp.pPrivilegeAssignedTo;
|
|
SCE_PRIVILEGE_ASSIGNMENT *ppaPol = petPol->pTemplate->OtherInfo.smp.pPrivilegeAssignedTo;
|
|
|
|
SCE_PRIVILEGE_ASSIGNMENT *ppaLast = NULL;
|
|
for(SCE_PRIVILEGE_ASSIGNMENT *ppa = ppaPol; ppa != NULL ; ppa = ppa->Next)
|
|
{
|
|
for (SCE_PRIVILEGE_ASSIGNMENT *ppa2 = ppaPet;
|
|
ppa2 != NULL;
|
|
ppaLast = ppa2, ppa2 = ppa2->Next) {
|
|
if (0 == lstrcmpi(ppa->Name,ppa2->Name))
|
|
{
|
|
if (ppaLast)
|
|
{
|
|
ppaLast->Next = ppa2->Next;
|
|
}
|
|
else
|
|
{
|
|
// Front of list
|
|
ppaPet = ppa2->Next;
|
|
}
|
|
ppa2->Next = NULL;
|
|
SceFreeMemory(ppa2,SCE_STRUCT_PRIVILEGE);
|
|
ppa2 = ppaLast;
|
|
//
|
|
// Found it, so don't bother checking the rest
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clear reg values set in PetPol out of pet
|
|
//
|
|
SCE_REGISTRY_VALUE_INFO *rvPet = pet->pTemplate->aRegValues;
|
|
SCE_REGISTRY_VALUE_INFO *rvPol = petPol->pTemplate->aRegValues;
|
|
for(DWORD i=0;i< petPol->pTemplate->RegValueCount;i++)
|
|
{
|
|
for (DWORD j=0;j<pet->pTemplate->RegValueCount;j++)
|
|
{
|
|
if (0 == lstrcmpi(rvPol[i].FullValueName,rvPet[j].FullValueName))
|
|
{
|
|
// Match. Delete Value from pet
|
|
if (rvPet[j].Value)
|
|
{
|
|
LocalFree(rvPet[j].Value);
|
|
rvPet[j].Value = NULL;
|
|
}
|
|
//
|
|
// Found it, so don't bother checking rest
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|