able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/snapin/smonlog/smlogcfg/globals.cpp

1059 lines
31 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1998-1999 Microsoft Corporation
Module Name:
GLOBALS.CPP
Abstract:
Utility methods for the Performance Logs and Alerts MMC snap-in.
--*/
#include "stdAfx.h"
#include <pdhmsg.h> // For CreateSampleFileName
#include <pdhp.h> // For CreateSampleFileName
#include "smcfgmsg.h"
#include "globals.h"
USE_HANDLE_MACROS("SMLOGCFG(globals.cpp)");
extern "C" {
WCHAR GUIDSTR_TypeLibrary[] = {_T("{7478EF60-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_ComponentData[] = {_T("{7478EF61-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_Component[] = {_T("{7478EF62-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_RootNode[] = {_T("{7478EF63-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_MainNode[] = {_T("{7478EF64-8C46-11d1-8D99-00A0C913CAD4}")}; // Obsolete after Beta 3
WCHAR GUIDSTR_SnapInExt[] = {_T("{7478EF65-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_CounterMainNode[] = {_T("{7478EF66-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_TraceMainNode[] = {_T("{7478EF67-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_AlertMainNode[] = {_T("{7478EF68-8C46-11d1-8D99-00A0C913CAD4}")};
WCHAR GUIDSTR_PerformanceAbout[] = {_T("{7478EF69-8C46-11d1-8D99-00A0C913CAD4}")};
};
HINSTANCE g_hinst; // Global instance handle
CRITICAL_SECTION g_critsectInstallDefaultQueries;
const COMBO_BOX_DATA_MAP TimeUnitCombo[] =
{
{SLQ_TT_UTYPE_SECONDS, IDS_SECONDS},
{SLQ_TT_UTYPE_MINUTES, IDS_MINUTES},
{SLQ_TT_UTYPE_HOURS, IDS_HOURS},
{SLQ_TT_UTYPE_DAYS, IDS_DAYS}
};
const DWORD dwTimeUnitComboEntries = sizeof(TimeUnitCombo)/sizeof(TimeUnitCombo[0]);
//---------------------------------------------------------------------------
// Returns the current object based on the s_cfMmcMachineName clipboard format
//
CDataObject*
ExtractOwnDataObject
(
LPDATAOBJECT lpDataObject // [in] IComponent pointer
)
{
HGLOBAL hGlobal;
HRESULT hr = S_OK;
CDataObject* pDO = NULL;
hr = ExtractFromDataObject( lpDataObject,
CDataObject::s_cfInternal,
sizeof(CDataObject **),
&hGlobal
);
if( SUCCEEDED(hr) )
{
pDO = *(CDataObject **)(hGlobal);
ASSERT( NULL != pDO );
VERIFY ( NULL == GlobalFree(hGlobal) ); // Must return NULL
}
return pDO;
} // end ExtractOwnDataObject()
//---------------------------------------------------------------------------
// Extracts data based on the passed-in clipboard format
//
HRESULT
ExtractFromDataObject
(
LPDATAOBJECT lpDataObject, // [in] Points to data object
UINT cfClipFormat, // [in] Clipboard format to use
ULONG nByteCount, // [in] Number of bytes to allocate
HGLOBAL *phGlobal // [out] Points to the data we want
)
{
ASSERT( NULL != lpDataObject );
HRESULT hr = S_OK;
STGMEDIUM stgmedium = { TYMED_HGLOBAL, NULL };
FORMATETC formatetc = { (USHORT)cfClipFormat, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
*phGlobal = NULL;
do
{
// Allocate memory for the stream
stgmedium.hGlobal = GlobalAlloc( GMEM_SHARE, nByteCount );
if( !stgmedium.hGlobal )
{
hr = E_OUTOFMEMORY;
LOCALTRACE( _T("Out of memory\n") );
break;
}
// Attempt to get data from the object
hr = lpDataObject->GetDataHere( &formatetc, &stgmedium );
if (FAILED(hr))
{
break;
}
// stgmedium now has the data we need
*phGlobal = stgmedium.hGlobal;
stgmedium.hGlobal = NULL;
} while (0);
if (FAILED(hr) && stgmedium.hGlobal)
{
VERIFY ( NULL == GlobalFree(stgmedium.hGlobal)); // Must return NULL
}
return hr;
} // end ExtractFromDataObject()
//---------------------------------------------------------------------------
//
VOID DisplayError( LONG nErrorCode, LPWSTR wszDlgTitle )
{
LPVOID lpMsgBuf = NULL;
::FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
nErrorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&lpMsgBuf,
0,
NULL
);
if (lpMsgBuf) {
::MessageBox( NULL, (LPWSTR)lpMsgBuf, wszDlgTitle,
MB_OK|MB_ICONINFORMATION );
LocalFree( lpMsgBuf );
}
} // end DisplayError()
VOID DisplayError( LONG nErrorCode, UINT nTitleString )
{
CString strTitle;
LPVOID lpMsgBuf = NULL;
ResourceStateManager rsm;
::FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
nErrorCode,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPWSTR)&lpMsgBuf,
0,
NULL
);
strTitle.LoadString ( nTitleString );
if (lpMsgBuf) {
::MessageBox( NULL, (LPWSTR)lpMsgBuf, (LPCWSTR)strTitle,
MB_OK|MB_ICONINFORMATION );
LocalFree( lpMsgBuf );
}
} // end DisplayError()
//---------------------------------------------------------------------------
// Debug only message box
//
int DebugMsg( LPWSTR wszMsg, LPWSTR wszTitle )
{
int nRetVal = 0;
wszMsg;
wszTitle;
#ifdef _DEBUG
nRetVal = ::MessageBox( NULL, wszMsg, wszTitle, MB_OK );
#endif
return nRetVal;
}
//---------------------------------------------------------------------------
// Extracts data based on the passed-in clipboard format
HRESULT ExtractObjectTypeGUID( IDataObject* piDataObject, GUID* pguidObjectType )
{
HGLOBAL hGlobal;
HRESULT hr = S_OK;
hr = ExtractFromDataObject( piDataObject,
CDataObject::s_cfNodeType,
sizeof(GUID),
&hGlobal
);
if( SUCCEEDED(hr) )
{
*pguidObjectType = *(GUID*)(hGlobal);
ASSERT( NULL != pguidObjectType );
VERIFY ( NULL == GlobalFree(hGlobal) ); // Must return NULL
}
return hr;
}
HRESULT
ExtractMachineName(
IDataObject* piDataObject,
CString& rstrMachineName )
{
HRESULT hr = S_OK;
HGLOBAL hMachineName;
hr = ExtractFromDataObject(piDataObject,
CDataObject::s_cfMmcMachineName,
sizeof(TCHAR) * (MAX_PATH + 1),
&hMachineName);
if( SUCCEEDED(hr) )
{
LPWSTR pszNewData = reinterpret_cast<LPWSTR>(hMachineName);
if (NULL == pszNewData)
{
ASSERT(FALSE);
hr = E_UNEXPECTED;
} else {
pszNewData[MAX_PATH] = _T('\0'); // just to be safe
// USES_CONVERSION;
// rstrMachineName = OLE2T(pszNewData);
rstrMachineName = pszNewData;
VERIFY ( NULL == GlobalFree(hMachineName) ); // Must return NULL
}
}
return hr;
}
DWORD __stdcall
CreateSampleFileName (
const CString& rstrQueryName,
const CString& rstrMachineName,
const CString& rstrFolderName,
const CString& rstrInputBaseName,
const CString& rstrSqlName,
DWORD dwSuffixValue,
DWORD dwLogFileTypeValue,
DWORD dwCurrentSerialNumber,
CString& rstrReturnName)
{
DWORD dwStatus = ERROR_SUCCESS;
PPDH_PLA_INFO pInfo = NULL;
DWORD dwStrBufLen = 0;
DWORD dwInfoSize = 0;
DWORD dwFlags = 0;
rstrReturnName.Empty();
dwStatus = PdhPlaGetInfo(
(LPTSTR)(LPCTSTR)rstrQueryName,
(LPTSTR)(LPCTSTR)rstrMachineName,
&dwInfoSize,
pInfo );
if( ERROR_SUCCESS == dwStatus && 0 != dwInfoSize ){
pInfo = (PPDH_PLA_INFO)malloc(dwInfoSize);
if( NULL != pInfo && (sizeof(PDH_PLA_INFO) <= dwInfoSize) ){
ZeroMemory( pInfo, dwInfoSize );
pInfo->dwMask = PLA_INFO_CREATE_FILENAME;
dwStatus = PdhPlaGetInfo(
(LPTSTR)(LPCTSTR)rstrQueryName,
(LPTSTR)(LPCTSTR)rstrMachineName,
&dwInfoSize,
pInfo );
pInfo->dwMask = PLA_INFO_CREATE_FILENAME;
pInfo->dwFileFormat = dwLogFileTypeValue;
pInfo->strBaseFileName = (LPTSTR)(LPCTSTR)rstrInputBaseName;
pInfo->dwAutoNameFormat = dwSuffixValue;
// PLA_INFO_FLAG_TYPE is counter log vs trace log vs alert
pInfo->strDefaultDir = (LPTSTR)(LPCTSTR)rstrFolderName;
pInfo->dwLogFileSerialNumber = dwCurrentSerialNumber;
pInfo->strSqlName = (LPTSTR)(LPCTSTR)rstrSqlName;
pInfo->dwLogFileSerialNumber = dwCurrentSerialNumber;
// Create file name based on passed parameters only.
dwFlags = PLA_FILENAME_CREATEONLY; // PLA_FILENAME_CURRENTLOG for latest run log
dwStatus = PdhPlaGetLogFileName (
(LPTSTR)(LPCTSTR)rstrQueryName,
(LPTSTR)(LPCTSTR)rstrMachineName,
pInfo,
dwFlags,
&dwStrBufLen,
NULL );
if ( ERROR_SUCCESS == dwStatus || PDH_INSUFFICIENT_BUFFER == dwStatus ) {
dwStatus = PdhPlaGetLogFileName (
(LPTSTR)(LPCTSTR)rstrQueryName,
(LPTSTR)(LPCTSTR)rstrMachineName,
pInfo,
dwFlags,
&dwStrBufLen,
rstrReturnName.GetBufferSetLength ( dwStrBufLen ) );
rstrReturnName.ReleaseBuffer();
}
}
}
if ( NULL != pInfo ) {
free( pInfo );
}
return dwStatus;
}
DWORD __stdcall
IsDirPathValid (
CString& rstrPath,
BOOL bLastNameIsDirectory,
BOOL bCreateMissingDirs,
BOOL& rbIsValid )
/*++
Routine Description:
Creates the directory specified in szPath and any other "higher"
directories in the specified path that don't exist.
Arguments:
IN CString rstrPath
directory path to create (assumed to be a DOS path, not a UNC)
IN BOOL bLastNameIsDirectory
TRUE when the last name in the path is a Directory and not a File
FALSE if the last name is a file
IN BOOL bCreateMissingDirs
TRUE will create any dirs in the path that are not found
FALSE will only test for existence and not create any
missing dirs.
OUT BOOL rbIsValid
TRUE if the directory path now exists
FALSE if error (GetLastError to find out why)
Return Value:
DWSTATUS
--*/
{
CString strLocalPath;
LPTSTR szLocalPath;
LPTSTR szEnd;
LPSECURITY_ATTRIBUTES lpSA = NULL;
DWORD dwAttr;
TCHAR cBackslash = TEXT('\\');
DWORD dwStatus = ERROR_SUCCESS;
rbIsValid = FALSE;
szLocalPath = strLocalPath.GetBufferSetLength ( MAX_PATH );
if ( NULL == szLocalPath ) {
dwStatus = ERROR_OUTOFMEMORY;
} else {
if (GetFullPathName (
rstrPath,
MAX_PATH,
szLocalPath,
NULL) > 0) {
szEnd = &szLocalPath[3];
if (*szEnd != 0) {
// then there are sub dirs to create
while (*szEnd != 0) {
// go to next backslash
while ((*szEnd != cBackslash) && (*szEnd != 0)) szEnd++;
if (*szEnd == cBackslash) {
// terminate path here and create directory
*szEnd = 0;
if (bCreateMissingDirs) {
if (!CreateDirectory (szLocalPath, lpSA)) {
// see what the error was and "adjust" it if necessary
dwStatus = GetLastError();
if ( ERROR_ALREADY_EXISTS == dwStatus ) {
// this is OK
dwStatus = ERROR_SUCCESS;
rbIsValid = TRUE;
} else {
rbIsValid = FALSE;
}
} else {
// directory created successfully so update count
rbIsValid = TRUE;
}
} else {
if ((dwAttr = GetFileAttributes(szLocalPath)) != 0xFFFFFFFF) {
// make sure it's a dir
if ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) ==
FILE_ATTRIBUTE_DIRECTORY) {
rbIsValid = TRUE;
} else {
// if any dirs fail, then clear the return value
rbIsValid = FALSE;
}
} else {
// if any dirs fail, then clear the return value
rbIsValid = FALSE;
}
}
// replace backslash and go to next dir
*szEnd++ = cBackslash;
}
}
// create last dir in path now if it's a dir name and not a filename
if (bLastNameIsDirectory) {
if (bCreateMissingDirs) {
if (!CreateDirectory (szLocalPath, lpSA)) {
// see what the error was and "adjust" it if necessary
dwStatus = GetLastError();
if ( ERROR_ALREADY_EXISTS == dwStatus ) {
// this is OK
dwStatus = ERROR_SUCCESS;
rbIsValid = TRUE;
} else {
rbIsValid = FALSE;
}
} else {
// directory created successfully
rbIsValid = TRUE;
}
} else {
if ((dwAttr = GetFileAttributes(szLocalPath)) != 0xFFFFFFFF) {
// make sure it's a dir
if ((dwAttr & FILE_ATTRIBUTE_DIRECTORY) ==
FILE_ATTRIBUTE_DIRECTORY) {
rbIsValid = TRUE;
} else {
// if any dirs fail, then clear the return value
rbIsValid = FALSE;
}
} else {
// if any dirs fail, then clear the return value
rbIsValid = FALSE;
}
}
}
} else {
// else this is a root dir only so return success.
dwStatus = ERROR_SUCCESS;
rbIsValid = TRUE;
}
}
strLocalPath.ReleaseBuffer();
}
return dwStatus;
}
DWORD __stdcall
ProcessDirPath (
CString& rstrPath,
const CString& rstrLogName,
CWnd* pwndParent,
BOOL& rbIsValid,
BOOL bOnFilesPage )
{
DWORD dwStatus = ERROR_SUCCESS;
DWORD cchLen = 0;
CString strExpanded;
LPWSTR szExpanded;
DWORD cchExpandedLen;
ResourceStateManager rsm;
// Parse all environment symbols
cchLen = ExpandEnvironmentStrings ( rstrPath, NULL, 0 );
if ( 0 < cchLen ) {
MFC_TRY
//
// CString size does not include NULL.
// cchLen includes NULL. Include NULL count for safety.
//
szExpanded = strExpanded.GetBuffer ( cchLen );
MFC_CATCH_DWSTATUS;
if ( ERROR_SUCCESS == dwStatus ) {
cchExpandedLen = ExpandEnvironmentStrings (
rstrPath,
szExpanded,
cchLen);
if ( 0 == cchExpandedLen ) {
dwStatus = GetLastError();
}
}
strExpanded.ReleaseBuffer();
} else {
dwStatus = GetLastError();
}
dwStatus = IsDirPathValid (strExpanded, TRUE, FALSE, rbIsValid);
if ( ERROR_SUCCESS != dwStatus ) {
rbIsValid = FALSE;
} else {
if ( !rbIsValid ) {
INT nMbReturn;
CString strMessage;
strMessage.Format ( IDS_FILE_DIR_NOT_FOUND, rstrPath );
nMbReturn = pwndParent->MessageBox ( strMessage, rstrLogName, MB_YESNO | MB_ICONWARNING );
if (nMbReturn == IDYES) {
// create the dir(s)
dwStatus = IsDirPathValid (strExpanded, TRUE, TRUE, rbIsValid);
if (ERROR_SUCCESS != dwStatus || !rbIsValid ) {
// unable to create the dir, display message
if ( bOnFilesPage ) {
strMessage.Format ( IDS_FILE_DIR_NOT_MADE, rstrPath );
} else {
strMessage.Format ( IDS_DIR_NOT_MADE, rstrPath );
}
nMbReturn = pwndParent->MessageBox ( strMessage, rstrLogName, MB_OK | MB_ICONERROR);
rbIsValid = FALSE;
}
} else if ( IDNO == nMbReturn ) {
// then abort and return to the dialog
if ( bOnFilesPage ) {
strMessage.LoadString ( IDS_FILE_DIR_CREATE_CANCEL );
} else {
strMessage.LoadString ( IDS_DIR_CREATE_CANCEL );
}
nMbReturn = pwndParent->MessageBox ( strMessage, rstrLogName, MB_OK | MB_ICONINFORMATION);
rbIsValid = FALSE;
}
} // else the path is OK
}
return dwStatus;
}
DWORD __stdcall
IsCommandFilePathValid (
CString& rstrPath )
{
DWORD dwStatus = ERROR_SUCCESS;
ResourceStateManager rsm;
if ( !rstrPath.IsEmpty() ) {
HANDLE hOpenFile;
hOpenFile = CreateFile (
rstrPath,
GENERIC_READ,
0, // Not shared
NULL, // Security attributes
OPEN_EXISTING, //
FILE_ATTRIBUTE_NORMAL,
NULL );
if ( ( NULL == hOpenFile )
|| INVALID_HANDLE_VALUE == hOpenFile ) {
dwStatus = SMCFG_NO_COMMAND_FILE_FOUND;
} else {
CloseHandle(hOpenFile);
}
} else {
dwStatus = SMCFG_NO_COMMAND_FILE_FOUND;
}
return dwStatus;
}
INT __stdcall
BrowseCommandFilename (
CWnd* pwndParent,
CString& rstrFilename )
{
INT iReturn = IDCANCEL;
OPENFILENAME ofn;
CString strInitialDir;
WCHAR szFileName[MAX_PATH];
WCHAR szDrive[MAX_PATH];
WCHAR szDir[MAX_PATH];
WCHAR szExt[MAX_PATH];
WCHAR szFileFilter[MAX_PATH];
LPWSTR szNextFilter;
CString strTemp;
ResourceStateManager rsm;
_wsplitpath((LPCWSTR)rstrFilename,
szDrive, szDir, szFileName, szExt);
strInitialDir = szDrive;
strInitialDir += szDir;
lstrcat (szFileName, szExt);
ZeroMemory( &ofn, sizeof( OPENFILENAME ) );
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = pwndParent->m_hWnd;
ofn.hInstance = GetModuleHandle(NULL);
// load the file filter MSZ
szNextFilter = &szFileFilter[0];
strTemp.LoadString ( IDS_BROWSE_CMD_FILE_FILTER1 );
lstrcpyW (szNextFilter, (LPCWSTR)strTemp);
szNextFilter += strTemp.GetLength();
*szNextFilter++ = 0;
strTemp.LoadString ( IDS_BROWSE_CMD_FILE_FILTER2 );
lstrcpyW (szNextFilter, (LPCWSTR)strTemp);
szNextFilter += strTemp.GetLength();
*szNextFilter++ = 0;
strTemp.LoadString ( IDS_BROWSE_CMD_FILE_FILTER3 );
lstrcpyW (szNextFilter, (LPCWSTR)strTemp);
szNextFilter += strTemp.GetLength();
*szNextFilter++ = 0;
strTemp.LoadString ( IDS_BROWSE_CMD_FILE_FILTER4 );
lstrcpyW (szNextFilter, (LPCWSTR)strTemp);
szNextFilter += strTemp.GetLength();
*szNextFilter++ = 0;
*szNextFilter++ = 0; // msz terminator
ofn.lpstrFilter = szFileFilter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 1; // nFilterIndex is 1-based
ofn.lpstrFile = szFileName;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = (LPCTSTR)strInitialDir;
strTemp.LoadString( IDS_BROWSE_CMD_FILE_CAPTION );
ofn.lpstrTitle = (LPCWSTR)strTemp;
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = NULL;
ofn.lCustData = 0;
ofn.lpfnHook = NULL;
ofn.lpTemplateName = NULL;
iReturn = GetOpenFileName (&ofn);
if ( IDOK == iReturn ) {
// Update the fields with the new information
rstrFilename = szFileName;
} // else ignore if they canceled out
return iReturn;
}
DWORD __stdcall
FormatSmLogCfgMessage (
CString& rstrMessage,
HINSTANCE hResourceHandle,
UINT uiMessageId,
... )
{
DWORD dwStatus = ERROR_SUCCESS;
LPTSTR lpszTemp = NULL;
// format message into temporary buffer lpszTemp
va_list argList;
va_start(argList, uiMessageId);
dwStatus = ::FormatMessage (
FORMAT_MESSAGE_FROM_HMODULE
| FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_MAX_WIDTH_MASK,
hResourceHandle,
uiMessageId,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&lpszTemp,
0,
&argList );
if ( 0 != dwStatus && NULL != lpszTemp ) {
rstrMessage.GetBufferSetLength( lstrlen (lpszTemp) + 1 );
rstrMessage.ReleaseBuffer();
rstrMessage = lpszTemp;
} else {
dwStatus = GetLastError();
}
if ( NULL != lpszTemp ) {
LocalFree( lpszTemp);
lpszTemp = NULL;
}
va_end(argList);
return dwStatus;
}
BOOL __stdcall
FileRead (
HANDLE hFile,
void* lpMemory,
DWORD nAmtToRead)
{
BOOL bSuccess ;
DWORD nAmtRead ;
bSuccess = ReadFile (hFile, lpMemory, nAmtToRead, &nAmtRead, NULL) ;
return (bSuccess && (nAmtRead == nAmtToRead)) ;
} // FileRead
BOOL __stdcall
FileWrite (
HANDLE hFile,
void* lpMemory,
DWORD nAmtToWrite)
{
BOOL bSuccess = FALSE;
DWORD nAmtWritten = 0;
DWORD dwFileSizeLow, dwFileSizeHigh;
LONGLONG llResultSize;
dwFileSizeLow = GetFileSize (hFile, &dwFileSizeHigh);
// limit file size to 2GB
if (dwFileSizeHigh > 0) {
SetLastError (ERROR_WRITE_FAULT);
bSuccess = FALSE;
} else {
// note that the error return of this function is 0xFFFFFFFF
// since that is > the file size limit, this will be interpreted
// as an error (a size error) so it's accounted for in the following
// test.
llResultSize = dwFileSizeLow + nAmtToWrite;
if (llResultSize >= 0x80000000) {
SetLastError (ERROR_WRITE_FAULT);
bSuccess = FALSE;
} else {
// write buffer to file
bSuccess = WriteFile (hFile, lpMemory, nAmtToWrite, &nAmtWritten, NULL) ;
if (bSuccess) bSuccess = (nAmtWritten == nAmtToWrite ? TRUE : FALSE);
}
}
return (bSuccess) ;
} // FileWrite
static
DWORD _stdcall
CheckDuplicateInstances (
PDH_COUNTER_PATH_ELEMENTS* pFirst,
PDH_COUNTER_PATH_ELEMENTS* pSecond )
{
DWORD dwStatus = ERROR_SUCCESS;
ASSERT ( 0 == lstrcmpi ( pFirst->szMachineName, pSecond->szMachineName ) );
ASSERT ( 0 == lstrcmpi ( pFirst->szObjectName, pSecond->szObjectName ) );
if ( 0 == lstrcmpi ( pFirst->szInstanceName, pSecond->szInstanceName ) ) {
if ( 0 == lstrcmpi ( pFirst->szParentInstance, pSecond->szParentInstance ) ) {
if ( pFirst->dwInstanceIndex == pSecond->dwInstanceIndex ) {
dwStatus = SMCFG_DUPL_SINGLE_PATH;
}
}
} else if ( 0 == lstrcmpi ( pFirst->szInstanceName, _T("*") ) ) {
dwStatus = SMCFG_DUPL_FIRST_IS_WILD;
} else if ( 0 == lstrcmpi ( pSecond->szInstanceName, _T("*") ) ) {
dwStatus = SMCFG_DUPL_SECOND_IS_WILD;
}
return dwStatus;
}
//++
// Description:
// The function checks the relation between two counter paths
//
// Parameter:
// pFirst - First counter path
// pSecond - Second counter path
//
// Return:
// ERROR_SUCCESS - The two counter paths are different
// SMCFG_DUPL_FIRST_IS_WILD - The first counter path has wildcard name
// SMCFG_DUPL_SECOND_IS_WILD - The second counter path has wildcard name
// SMCFG_DUPL_SINGLE_PATH - The two counter paths are the same(may include
// wildcard name)
//
//--
DWORD _stdcall
CheckDuplicateCounterPaths (
PDH_COUNTER_PATH_ELEMENTS* pFirst,
PDH_COUNTER_PATH_ELEMENTS* pSecond )
{
DWORD dwStatus = ERROR_SUCCESS;
if ( 0 == lstrcmpi ( pFirst->szMachineName, pSecond->szMachineName ) ) {
if ( 0 == lstrcmpi ( pFirst->szObjectName, pSecond->szObjectName ) ) {
if ( 0 == lstrcmpi ( pFirst->szCounterName, pSecond->szCounterName ) ) {
dwStatus = CheckDuplicateInstances ( pFirst, pSecond );
} else if ( 0 == lstrcmpi ( pFirst->szCounterName, _T("*") )
|| 0 == lstrcmpi ( pSecond->szCounterName, _T("*") ) ) {
// Wildcard counter.
BOOL bIsDuplicate = ( ERROR_SUCCESS != CheckDuplicateInstances ( pFirst, pSecond ) );
if ( bIsDuplicate ) {
if ( 0 == lstrcmpi ( pFirst->szCounterName, _T("*") ) ) {
dwStatus = SMCFG_DUPL_FIRST_IS_WILD;
} else if ( 0 == lstrcmpi ( pSecond->szCounterName, _T("*") ) ) {
dwStatus = SMCFG_DUPL_SECOND_IS_WILD;
}
}
}
}
}
return dwStatus;
};
// This routine extracts the filename portion from a given full-path filename
LPTSTR _stdcall
ExtractFileName (LPTSTR pFileSpec)
{
LPTSTR pFileName = NULL ;
TCHAR DIRECTORY_DELIMITER1 = TEXT('\\') ;
TCHAR DIRECTORY_DELIMITER2 = TEXT(':') ;
if (pFileSpec)
{
pFileName = pFileSpec + lstrlen (pFileSpec) ;
while (*pFileName != DIRECTORY_DELIMITER1 &&
*pFileName != DIRECTORY_DELIMITER2)
{
if (pFileName == pFileSpec)
{
// done when no directory delimiter is found
break ;
}
pFileName-- ;
}
if (*pFileName == DIRECTORY_DELIMITER1 ||
*pFileName == DIRECTORY_DELIMITER2)
{
// directory delimiter found, point the
// filename right after it
pFileName++ ;
}
}
return pFileName ;
} // ExtractFileName
//+--------------------------------------------------------------------------
//
// Function: InvokeWinHelp
//
// Synopsis: Helper (ahem) function to invoke winhelp.
//
// Arguments: [message] - WM_CONTEXTMENU or WM_HELP
// [wParam] - depends on [message]
// [wszHelpFileName] - filename with or without path
// [adwControlIdToHelpIdMap] - see WinHelp API
//
// History: 06-10-1997 DavidMun Created
//
//---------------------------------------------------------------------------
VOID
InvokeWinHelp(
UINT message,
WPARAM wParam,
LPARAM lParam,
const CString& rstrHelpFileName,
DWORD adwControlIdToHelpIdMap[])
{
//TRACE_FUNCTION(InvokeWinHelp);
ASSERT ( !rstrHelpFileName.IsEmpty() );
ASSERT ( adwControlIdToHelpIdMap );
switch (message)
{
case WM_CONTEXTMENU: // Right mouse click - "What's This" context menu
{
ASSERT ( wParam );
if ( 0 != GetDlgCtrlID ( (HWND) wParam ) ) {
WinHelp(
(HWND) wParam,
rstrHelpFileName,
HELP_CONTEXTMENU,
(DWORD_PTR)adwControlIdToHelpIdMap);
}
}
break;
case WM_HELP: // Help from the "?" dialog
{
const LPHELPINFO pHelpInfo = (LPHELPINFO) lParam;
if (pHelpInfo ) {
if ( pHelpInfo->iContextType == HELPINFO_WINDOW ) {
WinHelp(
(HWND) pHelpInfo->hItemHandle,
rstrHelpFileName,
HELP_WM_HELP,
(DWORD_PTR) adwControlIdToHelpIdMap);
}
}
break;
}
default:
//Dbg(DEB_ERROR, "Unexpected message %uL\n", message);
break;
}
}
BOOL
FileNameIsValid ( CString* pstrFileName )
{
CString strfname;
CString strModName;
TCHAR BufferSrc[MAX_PATH];
LPTSTR Src;
BOOL bRetVal = TRUE;
strfname = *pstrFileName;
swprintf (BufferSrc,_T("%ws"), *pstrFileName);
Src = BufferSrc;
while(*Src != '\0'){
if (*Src == '?' ||
*Src == '\\' ||
*Src == '*' ||
*Src == '|' ||
*Src == '<' ||
*Src == '>' ||
*Src == '/' ||
*Src == ':' ||
*Src == '\"'
){
bRetVal = FALSE;
break;
}
Src++;
}
return bRetVal;
}
DWORD
FormatSystemMessage (
DWORD dwMessageId,
CString& rstrSystemMessage )
{
DWORD dwStatus = ERROR_SUCCESS;
HINSTANCE hPdh = NULL;
DWORD dwFlags = 0;
LPTSTR pszMessage = NULL;
DWORD dwChars;
rstrSystemMessage.Empty();
dwFlags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM;
hPdh = LoadLibrary( _T("PDH.DLL") );
if ( NULL != hPdh ) {
dwFlags |= FORMAT_MESSAGE_FROM_HMODULE;
}
dwChars = FormatMessage (
dwFlags,
hPdh,
dwMessageId,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR)&pszMessage,
0,
NULL );
if ( NULL != hPdh ) {
FreeLibrary( hPdh );
}
if ( 0 == dwChars ) {
dwStatus = GetLastError();
}
MFC_TRY
if ( NULL != pszMessage ) {
if ( _T('\0') != pszMessage[0] ) {
rstrSystemMessage = pszMessage;
}
}
MFC_CATCH_DWSTATUS
if ( rstrSystemMessage.IsEmpty() ) {
MFC_TRY
rstrSystemMessage.Format ( _T("0x%08lX"), dwMessageId );
MFC_CATCH_DWSTATUS
}
LocalFree ( pszMessage );
return dwStatus;
}
ResourceStateManager::ResourceStateManager ()
: m_hResInstance ( NULL )
{
AFX_MODULE_STATE* pModuleState;
HINSTANCE hNewResourceHandle;
pModuleState = AfxGetModuleState();
if ( NULL != pModuleState ) {
m_hResInstance = pModuleState->m_hCurrentResourceHandle;
hNewResourceHandle = (HINSTANCE)GetModuleHandleW (_CONFIG_DLL_NAME_W_);
pModuleState->m_hCurrentResourceHandle = hNewResourceHandle;
}
}
ResourceStateManager::~ResourceStateManager ()
{
AFX_MODULE_STATE* pModuleState;
pModuleState = AfxGetModuleState();
if ( NULL != pModuleState ) {
pModuleState->m_hCurrentResourceHandle = m_hResInstance;
}
}
Reference in a new issue Copy permalink