// MSInfo.cpp : Implementation of DLL Exports, main application object
// and Registry Object Map. All registry information (apart from
// MIDL) lives here.
//
// Copyright (c) 1998-1999 Microsoft Corporation
#include "stdafx.h"
#include "resource.h"
#include "initguid.h"
// This hack is required because we may be building in an environment
// which doesn't have a late enough version of rpcndr.h
#if __RPCNDR_H_VERSION__ < 440
#define __RPCNDR_H_VERSION__ 440
#define MIDL_INTERFACE(x) interface
#endif
#include "MSInfo.h"
#include "DataObj.h"
#include "CompData.h"
#include "About.h"
#include "Toolset.h"
#include "Dispatch.h"
#include "MSInfo_i.c"
static LPCTSTR cszBasePath = _T("Software\\Microsoft\\MMC");
static LPCTSTR cszBaseSnapinPath = _T("Software\\Microsoft\\MMC\\Snapins");
static LPCTSTR cszBaseNodeTypePath = _T("Software\\Microsoft\\MMC\\NodeTypes");
static LPCTSTR cszNameString = _T("NameString");
static LPCTSTR cszProvider = _T("Provider");
static LPCTSTR cszVersion = _T("Version");
static LPCTSTR cszAbout = _T("About");
static LPCTSTR cszStandAlone = _T("StandAlone");
static LPCTSTR cszNodeTypes = _T("NodeTypes");
static LPCTSTR cszExtensions = _T("Extensions");
static LPCTSTR cszNameSpace = _T("NameSpace");
static LPCTSTR cszTask = _T("Task");
static LPCTSTR cszMSInfoBaseKey = _T("Software\\Microsoft\\Shared Tools");
static LPCTSTR cszMSInfoSubKey = _T("MSInfo");
static LPCTSTR cszMSInfoKey = _T("Software\\Microsoft\\Shared Tools\\MSInfo");
static LPCTSTR cszPathValue = _T("Path");
static LPCTSTR cszRunKey = _T("Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\msinfo32.exe");
static LPCTSTR cszRunRootKey = _T("Software\\Microsoft\\Windows\\CurrentVersion\\App Paths");
static LPCTSTR cszRunSubKey = _T("msinfo32.exe");
static LPCTSTR cszNFOExtension = _T(".nfo");
static LPCTSTR cszOLERegistration = _T("MSInfo.Document");
static LPCTSTR cszDefaultIconKey = _T("DefaultIcon");
static LPCTSTR cszCLSIDKey = _T("CLSID");
static LPCTSTR cszShellKey = _T("shell");
static LPCTSTR cszOpenCommandKey = _T("open\\command");
static LPCTSTR cszPrintCommandKey = _T("print\\command");
static LPCTSTR cszPrintToKey = _T("printto\\command");
// note trailing quotes on file path
static LPCTSTR cszMSInfoPath = _T("Microsoft Shared\\MSInfo\\MSInfo32.exe\"");
static LPCTSTR cszDefaultIconValue = _T("Microsoft Shared\\MSInfo\\MSInfo32.exe\",0");
static LPCTSTR cszOpenCommand = _T("Microsoft Shared\\MSInfo\\MSInfo32.exe\" /msinfo_file \"%1\"");
// these are never referenced
static LPCTSTR cszMSInfoDir = _T("Common Files\\Microsoft Shared\\MSInfo\\");
static LPCTSTR cszPrintToCommand = _T("Common Files\\Microsoft Shared\\MSInfo\\MSInfo32.exe /pt \"%1\" \"%2\" \"%3\" \"%4\"");
//static LPCTSTR cszPrintCommand = _T("Common Files\\Microsoft Shared\\MSInfo\\MSInfo32.exe /p \"%1\"");
//a-kjaw
static LPCTSTR cszPrintCommand = _T("Microsoft Shared\\MSInfo\\MSInfo32.exe\" /p \"%1\"");
//a-kjaw
// Nodes we extend
static LPCTSTR cszCompMgrNode = _T("{476E6448-AAFF-11D0-B944-00C04FD8D5B0}");
CComModule _Module;
/*
* Object Map of Registered objects, allowing the Active Template Library to
* register our CLSIDs.
*/
BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_MSInfo, CSystemInfoScopePrimary)
OBJECT_ENTRY(CLSID_Extension, CSystemInfoScopeExtension)
OBJECT_ENTRY(CLSID_About, CAboutImpl)
OBJECT_ENTRY(CLSID_SystemInfo, CMSInfo)
END_OBJECT_MAP()
/*
* The MSInfo application object.
*
* History: a-jsari 10/1/97 Initial version.
*/
class CMSInfoApp : public CWinApp
{
public:
virtual BOOL InitInstance();
virtual int ExitInstance();
};
CMSInfoApp theApp;
/*
* InitInstance - Initialize an instance of the application.
*
* History: a-jsari 10/1/97 Initial version.
*/
extern void LoadDialogResources();
BOOL CMSInfoApp::InitInstance()
{
_Module.Init(ObjectMap, m_hInstance);
LoadDialogResources(); // loads dialog strings from resources
return CWinApp::InitInstance();
}
/*
* ExitInstance - Deconstruct an instance of the application.
*
* History: a-jsari 10/1/97 Initial version.
*/
int CMSInfoApp::ExitInstance()
{
_Module.Term();
return CWinApp::ExitInstance();
}
/////////////////////////////////////////////////////////////////////////////
// Used to determine whether the DLL can be unloaded by OLE
STDAPI DllCanUnloadNow(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
return (AfxDllCanUnloadNow()==S_OK && _Module.GetLockCount()==0) ? S_OK : S_FALSE;
}
/////////////////////////////////////////////////////////////////////////////
// Returns a class factory to create an object of the requested type
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
return _Module.GetClassObject(rclsid, riid, ppv);
}
/*
* RegOpenMMCRoot - Open CRegKey
*
* History: a-jsari 9/9/97 Initial version
*/
static inline long RegOpenMMCRoot(CRegKey *pcrkMMCRoot)
{
return pcrkMMCRoot->Open(HKEY_LOCAL_MACHINE, cszBasePath);
}
/*
* RegOpenMMCSnapinRoot - Return MMC's registry Snapin root
*
* History: a-jsari 9/9/97 Initial version
*/
static inline long RegOpenMMCSnapinRoot(CRegKey *pcrkSnapinRoot)
{
return pcrkSnapinRoot->Open(HKEY_LOCAL_MACHINE, cszBaseSnapinPath);
}
/*
* RegOpenMMCNodeTypeRoot - Return MMC's registry NodeType root
*
* History: a-jsari 9/9/97 Initial version
*/
static inline long RegOpenMMCNodeTypeRoot(CRegKey *pcrkNodeTypesRoot)
{
return pcrkNodeTypesRoot->Open(HKEY_LOCAL_MACHINE, cszBaseNodeTypePath);
}
/*
* RegisterStandaloneSnapin() - Do all registration for the Standalone
* portion of the snapin.
*
* History: a-jsari 9/9/97 Initial version
*
* Note: Would require AFX_MANAGE_STATE, except that the calling function
* handles it.
*/
static inline HRESULT RegisterStandaloneSnapin()
{
CRegKey crkRoot;
CRegKey crkClsid;
CRegKey crkIterator;
CString szResourceLoader;
HRESULT hr = E_FAIL;
do {
// HKEY_CLASSES_ROOT\.nfo
long lRegOpenResult = crkRoot.Create(HKEY_CLASSES_ROOT, cszNFOExtension);
if (lRegOpenResult != ERROR_SUCCESS) break;
lRegOpenResult = crkRoot.SetValue(cszOLERegistration);
if (lRegOpenResult != ERROR_SUCCESS) break;
crkRoot.Close();
// HKEY_CLASSES_ROOT\MSInfo.Document
lRegOpenResult = crkRoot.Create(HKEY_CLASSES_ROOT, cszOLERegistration);
if (lRegOpenResult != ERROR_SUCCESS) break;
// This originally set the default value for the key to "msinfo.document", which
// is what would show up in the UI for a description of the NFO filetype. Fixing
// this to load the string from a resource (bug 10442).
//
// lRegOpenResult = crkRoot.SetValue(cszOLERegistration);
// if (lRegOpenResult != ERROR_SUCCESS) break;
CString strDescription;
strDescription.LoadString(IDS_NFODESCRIPTION);
crkRoot.SetValue((LPCTSTR)strDescription);
lRegOpenResult = crkIterator.Create(crkRoot, cszCLSIDKey);
if (lRegOpenResult != ERROR_SUCCESS) break;
lRegOpenResult = crkIterator.SetValue(cszClsidMSInfoSnapin);
if (lRegOpenResult != ERROR_SUCCESS) break;
crkIterator.Close();
TCHAR szWindowsPath[MAX_PATH];
DWORD dwSize;
CString szPathValue;
dwSize = sizeof(szWindowsPath);
lRegOpenResult = crkIterator.Open(HKEY_LOCAL_MACHINE, cszWindowsCurrentKey);
if (lRegOpenResult != ERROR_SUCCESS) break;
lRegOpenResult = crkIterator.QueryValue(szWindowsPath, cszCommonFilesValue, &dwSize);
if (lRegOpenResult != ERROR_SUCCESS) break;
lRegOpenResult = crkIterator.Create(crkRoot, cszDefaultIconKey);
if (lRegOpenResult != ERROR_SUCCESS) break;
szPathValue = _T("\"");
szPathValue += szWindowsPath;
szPathValue += _T("\\");
szPathValue += cszDefaultIconValue;
lRegOpenResult = crkIterator.SetValue(szPathValue);
if (lRegOpenResult != ERROR_SUCCESS) break;
crkIterator.Close();
lRegOpenResult = crkRoot.Create(crkRoot, cszShellKey);
if (lRegOpenResult != ERROR_SUCCESS) break;
lRegOpenResult = crkIterator.Create(crkRoot, cszOpenCommandKey);
if (lRegOpenResult != ERROR_SUCCESS) break;
szPathValue = _T("\"");
szPathValue += szWindowsPath;
szPathValue += _T("\\");
szPathValue += cszOpenCommand;
lRegOpenResult = crkIterator.SetValue(szPathValue);
if (lRegOpenResult != ERROR_SUCCESS) break;
crkIterator.Close();
//crkRoot.Close();
//a-kjaw
lRegOpenResult = crkIterator.Create(crkRoot, cszPrintCommandKey);
if (lRegOpenResult != ERROR_SUCCESS) break;
szPathValue = _T("\"");
szPathValue += szWindowsPath;
szPathValue += _T("\\");
szPathValue += cszPrintCommand;
lRegOpenResult = crkIterator.SetValue(szPathValue);
if (lRegOpenResult != ERROR_SUCCESS) break;
crkIterator.Close();
crkRoot.Close();
//a-kjaw
// HKEY_LOCAL_MACHINE\Software\Microsoft\MMC\Snapins
lRegOpenResult = RegOpenMMCSnapinRoot(&crkRoot);
// FIX: This fail should behave differently (registering the DLL
// w/o MMC registered).
if (lRegOpenResult != ERROR_SUCCESS) break;
// {45ac8c63-23e2-11e1-a696-00c04fd58bc3}
lRegOpenResult = crkClsid.Create(crkRoot, cszClsidMSInfoSnapin);
if (lRegOpenResult != ERROR_SUCCESS) break;
// NameString = REG_SZ "Microsoft System Information"
VERIFY(szResourceLoader.LoadString(IDS_DESCRIPTION));
lRegOpenResult = crkClsid.SetValue(szResourceLoader, cszNameString);
if (lRegOpenResult != ERROR_SUCCESS) break;
// About = REG_SZ "{45ac8c65-23e2-11e1-a696-00c04fd58bc3}"
lRegOpenResult = crkClsid.SetValue(cszClsidAboutMSInfo, cszAbout);
if (lRegOpenResult != ERROR_SUCCESS) break;
// Provider = REG_SZ "Microsoft Corporation"
VERIFY(szResourceLoader.LoadString(IDS_COMPANY));
lRegOpenResult = crkClsid.SetValue(szResourceLoader, cszProvider);
if (lRegOpenResult != ERROR_SUCCESS) break;
// Version = REG_SZ "5.0"
VERIFY(szResourceLoader.LoadString(IDS_VERSION));
lRegOpenResult = crkClsid.SetValue(szResourceLoader, cszVersion);
if (lRegOpenResult != ERROR_SUCCESS) break;
// StandAlone
lRegOpenResult = crkIterator.Create(crkClsid, cszStandAlone);
if (lRegOpenResult != ERROR_SUCCESS) break;
// NodeTypes
lRegOpenResult = crkIterator.Create(crkClsid, cszNodeTypes);
if (lRegOpenResult != ERROR_SUCCESS) break;
// {45ac8c66-23e2-11e1-a696-00c04fd58bc3}
CRegKey crkNodeType;
lRegOpenResult = crkNodeType.Create(crkIterator, cszNodeTypeStatic);
if (lRegOpenResult != ERROR_SUCCESS) break;
// Replace the SnapinRoot with the NodeType root;
// work from the new base.
// HKEY_LOCAL_MACHINE\Software\Microsoft\MMC\NodeTypes
lRegOpenResult = RegOpenMMCNodeTypeRoot(&crkRoot);
if (lRegOpenResult != ERROR_SUCCESS) break;
// {45ac8c66-23e2-11e1-a696-00c04fd58bc3}
// = REG_SZ "Microsoft System Information Root"
VERIFY(szResourceLoader.LoadString(IDS_NODEDESCRIPTION));
lRegOpenResult = crkRoot.SetKeyValue(cszNodeTypeStatic, szResourceLoader);
if (lRegOpenResult != ERROR_SUCCESS) break;
hr = S_OK;
} while (0);
return hr;
}
/*
* HRESULT UnregisterStandaloneSnapin - Remove all registry entries for
* the standalone portion of the snapin.
*
* History: a-jsari 9/9/97 Initial version.
*/
static inline HRESULT UnregisterStandaloneSnapin()
{
CRegKey crkSnapinRoot;
// Remove HKEY_CLASSES_ROOT\.nfo
long lRegOpenResult = crkSnapinRoot.Open(HKEY_CLASSES_ROOT, NULL);
if (lRegOpenResult != ERROR_SUCCESS) {
if (lRegOpenResult != ERROR_FILE_NOT_FOUND) return E_FAIL;
} else {
lRegOpenResult = crkSnapinRoot.RecurseDeleteKey(cszNFOExtension);
// It's not really an error to not find a key we were deleting anyhow.
if (lRegOpenResult != ERROR_SUCCESS
&& lRegOpenResult != ERROR_FILE_NOT_FOUND) {
return E_FAIL;
}
crkSnapinRoot.Close();
}
// Remove HKEY_CLASSES_ROOT\MSInfo.Document
lRegOpenResult = crkSnapinRoot.Open(HKEY_CLASSES_ROOT, NULL);
if (lRegOpenResult != ERROR_SUCCESS) {
if (lRegOpenResult != ERROR_FILE_NOT_FOUND) return E_FAIL;
} else {
lRegOpenResult = crkSnapinRoot.RecurseDeleteKey(cszOLERegistration);
// It's not really an error to not find a key we were deleting anyhow.
if (lRegOpenResult != ERROR_SUCCESS
&& lRegOpenResult != ERROR_FILE_NOT_FOUND) {
return E_FAIL;
}
crkSnapinRoot.Close();
}
lRegOpenResult = RegOpenMMCSnapinRoot(&crkSnapinRoot);
if (lRegOpenResult != ERROR_SUCCESS) {
if (lRegOpenResult != ERROR_FILE_NOT_FOUND) return E_FAIL;
} else {
// Just recursively delete our root. Extensions will be automatically
// deleted as well.
lRegOpenResult = crkSnapinRoot.RecurseDeleteKey(cszClsidMSInfoSnapin);
// It's not really an error to not find a key we were deleting anyhow.
if (lRegOpenResult != ERROR_SUCCESS
&& lRegOpenResult != ERROR_FILE_NOT_FOUND) {
return E_FAIL;
}
}
lRegOpenResult = RegOpenMMCNodeTypeRoot(&crkSnapinRoot);
if (lRegOpenResult != ERROR_SUCCESS) {
if (lRegOpenResult != ERROR_FILE_NOT_FOUND) return E_FAIL;
} else {
lRegOpenResult = crkSnapinRoot.RecurseDeleteKey(cszNodeTypeStatic);
ASSERT(lRegOpenResult == ERROR_SUCCESS);
// It's not really an error to not find a key we were deleting anyhow.
if (lRegOpenResult != ERROR_SUCCESS
&& lRegOpenResult != ERROR_FILE_NOT_FOUND) {
return E_FAIL;
}
}
return S_OK;
}
/*
* OpenExtendKeyForNodeType - Return in pcrkExtension the Registry Key for
* HKEY_LOCAL_MACHINE\Software\Microsoft\MMC\NodeTypes\
* cszNodeTypeGuid (GUID string) \Extensions
* If fCreateIfNonextistent is TRUE, the Extensions key (only) is created
* if it doesn't exist.
*
* Return Codes:
* S_OK - All operations succeeded.
* E_FAIL - A critical registry operation failed.
* E_ABORT - The GUID string could not be opened, or
* the Extensions key could not be opened (and
* fCreateIfNonexistent is FALSE).
*
* History: a-jsari 9/18/97 Initial version
*/
static inline HRESULT OpenExtendKeyForNodeType(LPCTSTR cszNodeTypeGuid,
CRegKey *pcrkExtension, BOOL fCreateIfNonexistent = TRUE)
{
CRegKey crkRoot;
CRegKey crkNodeToExtend;
ASSERT(pcrkExtension != NULL);
long lRegOpenResult = RegOpenMMCNodeTypeRoot(&crkRoot);
if (lRegOpenResult != ERROR_SUCCESS) return E_FAIL;
// Not finding the proper nodetype is a different kind of error
// than not finding MMC, or not creating a new one.
if (fCreateIfNonexistent) {
lRegOpenResult = crkNodeToExtend.Create(crkRoot, cszNodeTypeGuid);
if (lRegOpenResult != ERROR_SUCCESS) return E_FAIL;
lRegOpenResult = pcrkExtension->Create(crkNodeToExtend, cszExtensions);
} else {
lRegOpenResult = crkNodeToExtend.Open(crkRoot, cszNodeTypeGuid);
if (lRegOpenResult != ERROR_SUCCESS) return E_ABORT;
lRegOpenResult = pcrkExtension->Open(crkNodeToExtend, cszExtensions);
if (lRegOpenResult == ERROR_FILE_NOT_FOUND) return E_ABORT;
}
if (lRegOpenResult != ERROR_SUCCESS) return E_FAIL;
return S_OK;
}
/*
* ExtendNode - Does all registry extension required for the NodeType
* cszNodeTypeGuid.
*
* Return Codes:
* S_OK - Upon successful completion, or if cszNodeTypeGuid can't
* be found.
* E_FAIL - If MMC cannot be found or NodeTypeGuid can't be opened.
*
* History: a-jsari 9/9/97 Initial version
*/
static HRESULT ExtendNode(LPCTSTR cszNodeTypeGuid)
{
CRegKey crkExtension;
CRegKey crkIterator;
CString szResourceLoader;
HRESULT hrOpenExtension = OpenExtendKeyForNodeType(cszNodeTypeGuid,
&crkExtension, TRUE);
// Don't return an error if we can't open the cszNodeTypeGuid
if (hrOpenExtension != S_OK)
return hrOpenExtension == E_ABORT ? S_OK : hrOpenExtension;
// NameSpace
// {GUID} = "System Information Extension"
long lRegOpenResult = crkIterator.Create(crkExtension, cszNameSpace);
if (lRegOpenResult != ERROR_SUCCESS) return E_FAIL;
VERIFY(szResourceLoader.LoadString(IDS_EXTENSIONDESCRIPTION));
lRegOpenResult = crkIterator.SetValue(szResourceLoader, cszClsidMSInfoExtension);
if (lRegOpenResult != ERROR_SUCCESS) return E_FAIL;
// Task
// {GUID} = "System Information Extension"
lRegOpenResult = crkIterator.Create(crkExtension, cszTask);
if (lRegOpenResult != ERROR_SUCCESS) return E_FAIL;
lRegOpenResult = crkIterator.SetValue(szResourceLoader, cszClsidMSInfoExtension);
return S_OK;
}
/*
* HRESULT UnregisterNode - Remove all registry entries for a specific
* Nodetype.
*
* Return Codes:
* S_OK - If all of the essential nodes are found.
* E_FAIL - If any of the path to the keys to remove fail to be found.
*
* History: a-jsari 9/9/97 Initial version.
*/
static HRESULT UnregisterNode(LPCTSTR cszNodeTypeGuid)
{
CRegKey crkExtension;
CRegKey crkIterator;
HRESULT hrOpenExtension = OpenExtendKeyForNodeType(cszNodeTypeGuid,
&crkExtension);
ASSERT(hrOpenExtension == S_OK);
// Don't return an error if we can't open the cszNodeTypeGuid
if (hrOpenExtension != S_OK)
return (hrOpenExtension == E_ABORT) ? S_OK : hrOpenExtension;
long lRegOpenResult = crkIterator.Open(crkExtension, cszNameSpace);
if (lRegOpenResult != ERROR_SUCCESS)
return (lRegOpenResult == ERROR_FILE_NOT_FOUND) ? S_OK : E_FAIL;
lRegOpenResult = crkIterator.DeleteValue(cszClsidMSInfoExtension);
// It's not really an error to not find a key we were deleting anyhow.
if (lRegOpenResult != ERROR_SUCCESS
&& lRegOpenResult != ERROR_FILE_NOT_FOUND) {
return E_FAIL;
}
return S_OK;
}
/*
* RegisterExtensionSnapin - Do all registration required for the extension side
* of the snapin.
*
* History: a-jsari 9/9/97 Initial version
*/
static inline HRESULT RegisterExtensionSnapin()
{
const HRESULT hrErrorReturn = E_FAIL;
CRegKey crkRoot;
CRegKey crkClsid;
CRegKey crkIterator;
CString szResourceLoader;
// HKEY_LOCAL_MACHINE\Software\Microsoft\MMC\Snapins
long lRegOpenResult = RegOpenMMCSnapinRoot(&crkRoot);
// FIX: This fail should behave differently (registering the DLL
// w/o MMC registered).
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// {45ac8c63-23e2-11e1-a696-00c04fd58bc3}
lRegOpenResult = crkClsid.Create(crkRoot, cszClsidMSInfoExtension);
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// NameString = REG_SZ "System Information Extension"
VERIFY(szResourceLoader.LoadString(IDS_EXTENSIONDESCRIPTION));
lRegOpenResult = crkClsid.SetValue(szResourceLoader, cszNameString);
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// Provider = REG_SZ "Microsoft Corporation"
VERIFY(szResourceLoader.LoadString(IDS_COMPANY));
lRegOpenResult = crkClsid.SetValue(szResourceLoader, cszProvider);
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// Version = REG_SZ "5.0"
VERIFY(szResourceLoader.LoadString(IDS_VERSION));
lRegOpenResult = crkClsid.SetValue(szResourceLoader, cszVersion);
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// Register our about interface CLSID under the "About" value, so when
// we're being added as an extension, our information shows up.
lRegOpenResult = crkClsid.SetValue(cszClsidAboutMSInfo, cszAbout);
if (lRegOpenResult != ERROR_SUCCESS)
return hrErrorReturn;
// NodeTypes
lRegOpenResult = crkIterator.Create(crkClsid, cszNodeTypes);
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// {45ac8c66-23e2-11e1-a696-00c04fd58bc3}
CRegKey crkNodeType;
lRegOpenResult = crkNodeType.Create(crkIterator, cszNodeTypeStatic);
if (lRegOpenResult != ERROR_SUCCESS) return hrErrorReturn;
// We no longer want to extend the computer management node (138503).
// So we won't make this call to create the extension key. Also, we'll
// delete it if it exists.
//
// HRESULT hrExtend = ExtendNode(cszCompMgrNode);
// ASSERT(hrExtend == S_OK);
// return hrExtend;
CRegKey crkCompmgmtExtension;
if (SUCCEEDED(OpenExtendKeyForNodeType(cszCompMgrNode, &crkCompmgmtExtension, TRUE)))
{
CRegKey crkNameSpace, crkTaskPad;
if (ERROR_SUCCESS == crkNameSpace.Open((HKEY)crkCompmgmtExtension, cszNameSpace))
crkNameSpace.DeleteValue(cszClsidMSInfoExtension);
if (ERROR_SUCCESS == crkTaskPad.Open((HKEY)crkCompmgmtExtension, cszTask))
crkTaskPad.DeleteValue(cszClsidMSInfoExtension);
}
return S_OK;
}
/*
* UnregisterExtensionSnapin - Unregister the extension part of the snapin.
*
* History: a-jsari 9/9/97 Initial version
*/
static inline HRESULT UnregisterExtensionSnapin()
{
CRegKey crkSnapinRoot;
long lRegOpenResult = RegOpenMMCSnapinRoot(&crkSnapinRoot);
if (lRegOpenResult != ERROR_SUCCESS) {
if (lRegOpenResult != ERROR_FILE_NOT_FOUND) return E_FAIL;
} else {
// CHECK: Is this appropriate for potential extensions (probably)
lRegOpenResult = crkSnapinRoot.RecurseDeleteKey(cszClsidMSInfoExtension);
ASSERT(lRegOpenResult == ERROR_SUCCESS);
// It's not really an error to not find a key we were deleting anyhow.
if (lRegOpenResult != ERROR_SUCCESS
&& lRegOpenResult != ERROR_FILE_NOT_FOUND) {
return E_FAIL;
}
}
HRESULT hrUnregister = UnregisterNode(cszCompMgrNode);
return hrUnregister;
}
/*
* RegisterPaths - Perform registration for path items
*
* History: a-jsari 12/4/97 Initial version.
*/
static inline HRESULT RegisterPaths()
{
CRegKey crkSnapinRoot;
CRegKey crkProgramFilesKey;
TCHAR szBuffer[MAX_PATH];
CString strPath;
DWORD dwSize;
long lResult;
do {
// Register MSInfo's Windows App Path.
lResult = crkSnapinRoot.Open(HKEY_LOCAL_MACHINE, cszMSInfoKey);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
dwSize = sizeof(szBuffer);
// Get the Path registry value into szBuffer
lResult = crkSnapinRoot.QueryValue(szBuffer, cszPathValue, &dwSize);
if (lResult != ERROR_SUCCESS) {
// The path can't be read from the registry; register it.
lResult = crkProgramFilesKey.Open(HKEY_LOCAL_MACHINE, cszWindowsCurrentKey);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
dwSize = sizeof(szBuffer);
lResult = crkProgramFilesKey.QueryValue(szBuffer, cszCommonFilesValue, &dwSize);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
// Remove the quotes from around the path. Bug #363834.
// strPath = "\"";
strPath = CString(_T(""));
strPath += szBuffer;
strPath += _T("\\");
strPath += cszMSInfoPath;
// Remove the quotes from around the path to mimic the behaviour of MSInfo 4.10
// (so that apps which used this key to launch MSInfo will continue to work). Bug #363834.
if (strPath.Right(1) == CString(_T("\"")))
strPath = strPath.Left(strPath.GetLength() - 1);
// Set the path value: Path = <Path to MSInfo32.exe>
lResult = crkSnapinRoot.SetValue(strPath, cszPathValue);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
} else {
// Read the path from the previously registered location and set the variable
// equal to it.
strPath = szBuffer;
// Remove the quotes from around the path. Bug #363834.
if (strPath.Left(1) == CString(_T("\"")))
{
strPath = strPath.Right(strPath.GetLength() - 1);
if (strPath.Right(1) == CString(_T("\"")))
strPath = strPath.Left(strPath.GetLength() - 1);
lResult = crkSnapinRoot.SetValue(strPath, cszPathValue);
}
}
// Bug #363834 - we still want quotes around the string when it's written elsewhere in the registry.
if (strPath.Left(1) != CString(_T("\"")))
strPath = _T("\"") + strPath;
if (strPath.Right(1) != CString(_T("\"")))
strPath += _T("\"");
lResult = crkSnapinRoot.Create(HKEY_LOCAL_MACHINE, cszRunKey);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
lResult = crkSnapinRoot.SetValue(strPath);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
int iValue = strPath.ReverseFind((TCHAR)'\\');
strPath = strPath.Left(iValue);
strPath += "\"";
lResult = crkSnapinRoot.SetValue(strPath, cszPathValue);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
#if 0
// We are now assuming that the path to MSInfo will be registered by some
// outside agent, presumably setup.
// Register the Path in the MSInfo directory
lResult = crkSnapinRoot.Open(HKEY_LOCAL_MACHINE, cszMSInfoKey);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
// Reuse the saved szPath value.
lResult = crkSnapinRoot.SetValue(szPath, cszPathValue);
ASSERT(lResult == ERROR_SUCCESS);
#endif
} while (FALSE);
return HRESULT_FROM_WIN32(lResult);
}
/*
* UnregisterPaths - Remove registry entries for path items.
*
* History: a-jsari 12/4/97 Initial version
*/
static inline HRESULT UnregisterPaths()
{
CRegKey crkRootKey;
long lResult;
do {
// Remove the App Path
lResult = crkRootKey.Open(HKEY_LOCAL_MACHINE, cszRunRootKey);
if (lResult != ERROR_SUCCESS) break;
lResult = crkRootKey.DeleteSubKey(cszRunSubKey);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
// Unregister the MSInfo Key
lResult = crkRootKey.Open(HKEY_LOCAL_MACHINE, cszMSInfoBaseKey);
ASSERT(lResult == ERROR_SUCCESS);
if (lResult != ERROR_SUCCESS) break;
lResult = crkRootKey.DeleteSubKey(cszMSInfoSubKey);
ASSERT(lResult == ERROR_SUCCESS);
} while (FALSE);
return HRESULT_FROM_WIN32(lResult);
}
/*
* DllRegisterServer - Registers the snapin in
* HKEY_LOCAL_MACHINE\Software\Microsoft\MMC
* HKEY_LOCAL_MACHINE\Software\Classes\MSInfo.*
* HKEY_CLASSES_ROOT\CLSID\{45AC8C6...}
*
* History: a-jsari 9/9/97 Initial version.
*/
STDAPI DllRegisterServer(void)
{
long lToolResult;
if ((lToolResult = CToolList::Register(TRUE)) != ERROR_SUCCESS)
return HRESULT_FROM_WIN32(lToolResult);
AFX_MANAGE_STATE(AfxGetStaticModuleState());
HRESULT hrRegister = RegisterStandaloneSnapin();
if (hrRegister != S_OK) return hrRegister;
hrRegister = RegisterExtensionSnapin();
if (hrRegister != S_OK) return hrRegister;
hrRegister = RegisterPaths();
if (hrRegister != S_OK) return hrRegister;
// Registers object and all interfaces in typelib
#if 0
// This version has been failing
return _Module.RegisterServer(TRUE);
#else
// So use this method.
return _Module.RegisterServer(FALSE);
#endif
}
/*
* DllUnregisterServer - Removes entries from the system registry
*
* History: a-jsari 9/9/97 Initial version.
*/
STDAPI DllUnregisterServer(void)
{
HRESULT hrReturn = S_OK;
long lToolResult;
if ((lToolResult = CToolList::Register(FALSE)) != ERROR_SUCCESS)
hrReturn = HRESULT_FROM_WIN32(lToolResult);
HRESULT hrUnregister = UnregisterStandaloneSnapin();
if (hrUnregister != S_OK) hrReturn = hrUnregister;
hrUnregister = UnregisterExtensionSnapin();
if (hrUnregister != S_OK) hrReturn = hrUnregister;
hrUnregister = UnregisterPaths();
if (hrUnregister != S_OK) hrReturn = hrUnregister;
_Module.UnregisterServer();
return hrReturn;
}
//-----------------------------------------------------------------------------
// Implementation for the CMSInfoLog class, used to keep a log of MSInfo
// activities.
//
// This global variable can be used elsewhere in the snap-in to write log
// entries. Only one should be created.
//-----------------------------------------------------------------------------
CMSInfoLog msiLog;
//-----------------------------------------------------------------------------
// The constructor needs to read the logging state information from the
// registry.
//-----------------------------------------------------------------------------
CMSInfoLog::CMSInfoLog()
{
m_pLogFile = NULL;
m_strEndMarker = _T("###"); // see note in OpenLogFile
ReadLoggingStatus();
}
//-----------------------------------------------------------------------------
// The destructor needs to close the file (if it was ever created and opened).
// Also, this is a good place to put the exit MSInfo log entry.
//-----------------------------------------------------------------------------
CMSInfoLog::~CMSInfoLog()
{
if (this->IsLogging())
this->WriteLog(CMSInfoLog::BASIC, _T("EXIT MSInfo\r\n"));
try
{
if (m_pLogFile)
{
// Advance past the marker we wrote.
m_pLogFile->Seek(m_strEndMarker.GetLength() * sizeof(TCHAR), CFile::current);
// If we aren't at the end of the file, then we've at some point wrapped
// to the beginning and are overwriting entries. To make it so there are
// no incomplete entries, write spaces until the end of the file or until
// we find a '\r' character.
DWORD dwLength = m_pLogFile->GetLength();
DWORD dwPosition = m_pLogFile->GetPosition();
if (dwPosition < dwLength)
{
DWORD dwBytesRead = 0;
TCHAR cRead;
do
{
if (m_pLogFile->Read((void *) &cRead, sizeof(TCHAR)) < sizeof(TCHAR))
break;
dwBytesRead += sizeof(TCHAR);
} while (cRead && cRead != _T('\r') && (dwPosition + dwBytesRead) < dwLength);
if (dwBytesRead)
{
m_pLogFile->Seek(dwBytesRead * -1, CFile::current);
// Write the spaces (but don't overwrite the '\r' character).
if (cRead == _T('\0') || cRead == _T('\r'))
dwBytesRead -= sizeof(TCHAR);
WriteSpaces(dwBytesRead / sizeof(TCHAR));
}
}
m_pLogFile->Close();
delete m_pLogFile;
m_pLogFile = NULL;
}
}
catch (CFileException *e)
{
// Some sort of file error - turn off logging.
m_fLoggingEnabled = FALSE;
m_iLoggingMask = 0;
}
}
//-----------------------------------------------------------------------------
// These two WriteLog functions are for writing a log entry directly to the
// file. The second (with two string parameters) assumes that the first
// string is a format with a '%s' and the second is the replacement string.
//
// The iType parameter is used to indicate what sort of log entry this is.
// The const int values from the class definition should be used.
//
// If fContinuation is TRUE, then this write is to terminate a log entry which
// spans an operation, and should not have a timestamp added.
//-----------------------------------------------------------------------------
BOOL CMSInfoLog::WriteLog(int iType, const CString & strMessage, BOOL fContinuation)
{
if (!OpenLogFile())
return FALSE;
if ((m_iLoggingMask & iType) == 0)
return FALSE;
CString strWorking(strMessage);
// If this isn't the continuation of a previous log entry, then
// possibly add a timestamp.
if (!fContinuation && m_fTimestamp)
{
CTime time = CTime::GetCurrentTime();
strWorking = time.Format(_T("%Y-%m-%d %H:%M:%S ")) + strWorking;
}
return WriteLogInternal(strWorking);
}
BOOL CMSInfoLog::WriteLog(int iType, const CString & strFormat, const CString & strReplace1)
{
CString strCombined;
strCombined.Format(strFormat, strReplace1);
return WriteLog(iType, strCombined);
}
//-----------------------------------------------------------------------------
// This function is called each time a log entry is written, to insure that
// the log file is open. If we can't open the file, or shouldn't be logging in
// the first place, this function should return FALSE.
//-----------------------------------------------------------------------------
BOOL CMSInfoLog::OpenLogFile()
{
if (!m_fLoggingEnabled)
return FALSE;
if (m_pLogFile == NULL)
{
m_pLogFile = new CFile;
if (m_pLogFile == NULL)
return FALSE;
try
{
if (!m_pLogFile->Open(m_strFilename, CFile::modeCreate | CFile::modeNoTruncate | CFile::modeReadWrite))
{
delete m_pLogFile;
m_pLogFile = NULL;
m_fLoggingEnabled = FALSE;
m_iLoggingMask = 0;
return FALSE;
}
// Move to the right place in the file. If the file is empty, we're
// already there. If not, look for the end marker (from the last time
// we added log entries). If there is one, we should be positioned over
// its first character. Otherwise, just move to the end of the file.
if (m_pLogFile->GetLength() != 0)
{
// IMPORTANT NOTE: We assume here (for efficiency) that the end
// marker is structured so that we don't need to back up when
// searching the file. For example, no markers of the form "aaab".
TCHAR cRead;
int iMarker = 0;
while (iMarker != m_strEndMarker.GetLength())
{
if (m_pLogFile->Read((void *) &cRead, sizeof(TCHAR)) < sizeof(TCHAR))
break;
if (cRead != m_strEndMarker[iMarker])
iMarker = 0;
if (cRead == m_strEndMarker[iMarker])
iMarker++;
}
if (iMarker == m_strEndMarker.GetLength())
m_pLogFile->Seek(m_strEndMarker.GetLength() * sizeof(TCHAR) * -1, CFile::current);
else
m_pLogFile->SeekToEnd();
}
}
catch (CFileException *e)
{
// Some sort of file error - turn off logging.
m_fLoggingEnabled = FALSE;
m_iLoggingMask = 0;
return FALSE;
}
}
return TRUE;
}
//-----------------------------------------------------------------------------
// This function reads information about logging (what to log, where to log,
// etc.) out of the registry.
//-----------------------------------------------------------------------------
void CMSInfoLog::ReadLoggingStatus()
{
m_fLoggingEnabled = FALSE;
m_fTimestamp = TRUE;
m_strFilename = _T("");
m_iLoggingMask = 0;
m_dwMaxFileSize = 32 * 1024;
CString strRegkey = CString(cszMSInfoKey) + CString(_T("\\Logging"));
CRegKey regkey;
if (ERROR_SUCCESS == regkey.Open(HKEY_LOCAL_MACHINE, strRegkey, KEY_READ))
{
DWORD dwTemp;
dwTemp = 0;
if (ERROR_SUCCESS == regkey.QueryValue(dwTemp, _T("LogMask")))
m_iLoggingMask = (int) dwTemp;
dwTemp = 0;
if (ERROR_SUCCESS == regkey.QueryValue(dwTemp, _T("LogFileMaxSize")))
m_dwMaxFileSize = dwTemp;
dwTemp = 0;
if (ERROR_SUCCESS == regkey.QueryValue(dwTemp, _T("LogTimestamp")))
m_fTimestamp = (dwTemp) ? TRUE : FALSE;
TCHAR szFilename[MAX_PATH];
dwTemp = MAX_PATH;
if (ERROR_SUCCESS == regkey.QueryValue(szFilename, _T("LogFilename"), &dwTemp))
m_strFilename = szFilename;
regkey.Close();
}
m_fLoggingEnabled = ((m_iLoggingMask != 0) && !m_strFilename.IsEmpty());
}
//-----------------------------------------------------------------------------
// Write a string to the log file. We should be positioned before the end
// marker in the file. Overwrite this, and add the end marker onto the end
// of the string we are writing.
//
// If we are too close to the maximum file size, then fill the rest of the
// file (to that point) with spaces, and wrap to the start of the file.
//
// After we've written the output, back up so that we are positioned over the
// start of the end marker.
//-----------------------------------------------------------------------------
BOOL CMSInfoLog::WriteLogInternal(const CString & strMessage)
{
CString strTerminated = strMessage + m_strEndMarker;
DWORD dwLength = strTerminated.GetLength() * sizeof(TCHAR);
if (m_pLogFile == NULL)
return FALSE;
try
{
// If we are too close to the max size of the file, write spaces to that
// size and start from the beginning.
DWORD dwPosition = m_pLogFile->GetPosition();
if (m_dwMaxFileSize && ((dwPosition + dwLength) > m_dwMaxFileSize))
{
WriteSpaces((m_dwMaxFileSize - dwPosition) / sizeof(TCHAR));
m_pLogFile->SeekToBegin();
}
// Write the string to the file.
m_pLogFile->Write((const void *) (LPCTSTR) strTerminated, strTerminated.GetLength() * sizeof(TCHAR));
// Finally, back up over the terminating characters.
m_pLogFile->Seek(m_strEndMarker.GetLength() * sizeof(TCHAR) * -1, CFile::current);
}
catch (CFileException *e)
{
// Some sort of file error - turn off logging.
m_fLoggingEnabled = FALSE;
m_iLoggingMask = 0;
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Write the specified number of spaces to the file. (Note, this will already
// be inside an exeption handling block from the caller.)
//-----------------------------------------------------------------------------
void CMSInfoLog::WriteSpaces(DWORD dwCount)
{
TCHAR * szSpaceBuffer = NULL;
szSpaceBuffer = new TCHAR[dwCount];
if (szSpaceBuffer)
{
_tcsnset(szSpaceBuffer, _T(' '), dwCount);
m_pLogFile->Write((const void *) (LPCTSTR) szSpaceBuffer, dwCount * sizeof(TCHAR));
delete [] szSpaceBuffer;
}
}