1006 lines
43 KiB
C++
1006 lines
43 KiB
C++
//=======================================================================
|
|
//
|
|
// Copyright (c) 1998-2000 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// File: iuxml.h
|
|
//
|
|
// Description:
|
|
//
|
|
// Declaration of the CIUXml class
|
|
//
|
|
//=======================================================================
|
|
|
|
#ifndef __IUXML_H_
|
|
#define __IUXML_H_
|
|
|
|
#include <msxml.h>
|
|
|
|
#define HANDLE_NODE_INVALID -1
|
|
#define HANDLE_NODELIST_INVALID -1
|
|
|
|
typedef DWORD HANDLE_NODE;
|
|
typedef DWORD HANDLE_NODELIST;
|
|
|
|
// Bitmap of existence of all possible system info classes
|
|
extern const DWORD COMPUTERSYSTEM;
|
|
extern const DWORD REGKEYS;
|
|
extern const DWORD PLATFORM;
|
|
extern const DWORD LOCALE;
|
|
extern const DWORD DEVICES;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CIUXml
|
|
class CIUXml
|
|
{
|
|
public:
|
|
CIUXml();
|
|
virtual ~CIUXml();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// SafeCloseHandleNode()
|
|
//
|
|
// User can explicitly can this function to release a node for reuse when
|
|
// writing a xml doc.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void SafeCloseHandleNode(HANDLE_NODE& hNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// SafeFindCloseHandle()
|
|
//
|
|
// User can explicitly can this function to release a nodelist for reuse when
|
|
// reading a xml doc.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void SafeFindCloseHandle(HANDLE_NODELIST& hNodeList);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetDOMNodebyHandle()
|
|
//
|
|
// Retrieve the xml node with the given index of m_ppNodeArray
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IXMLDOMNode* GetDOMNodebyHandle(HANDLE_NODE hNode);
|
|
|
|
private:
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Handle to the heap of the calling process, used for HeapAlloc()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE m_hHeap;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Length of the node array "m_ppNodeArray"
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD m_dwSizeNodeArray;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Length of the nodelist array "m_ppNodeListArray"
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD m_dwSizeNodeListArray;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// InitNodeArray()
|
|
//
|
|
// Allocate or re-allocate memory for the node array "m_ppNodeArray"
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT InitNodeArray(BOOL fRealloc = FALSE);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// InitNodeListArray()
|
|
//
|
|
// Allocate or re-allocate memory for the nodelist array "m_ppNodeListArray"
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT InitNodeListArray(BOOL fRealloc = FALSE);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetNodeHandle()
|
|
//
|
|
// Look for the first un-used node from the "m_ppNodeArray" array,
|
|
// including the memory allocation, if needed.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODE GetNodeHandle();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetNodeListHandle()
|
|
//
|
|
// Look for the first un-used nodelist from the "m_ppNodeListArray" array,
|
|
// including the memory allocation, if needed.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST GetNodeListHandle();
|
|
|
|
protected:
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// This array is used to keep track of different nodes that can remain
|
|
// opened at the same time to write into; the index of the array will be
|
|
// returned to caller as a HANDLE_NODE to perform writing against.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IXMLDOMNode** m_ppNodeArray;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// This array is used to keep track of different nodelists that can remain
|
|
// opened at the same time to read from; the index of the array will be
|
|
// returned to caller as a HANDLE_NODELIST to perform reading against.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IXMLDOMNodeList** m_ppNodeListArray;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindFirstDOMNode()
|
|
//
|
|
// Retrieve the first xml node with the given tag name under the given parent node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST FindFirstDOMNode(IXMLDOMNode* pParentNode, BSTR bstrName, IXMLDOMNode** ppNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindFirstDOMNode()
|
|
//
|
|
// Retrieve the handle of first xml node with the given tag name under the given parent node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST FindFirstDOMNode(IXMLDOMNode* pParentNode, BSTR bstrName, HANDLE_NODE* phNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindFirstDOMNode()
|
|
//
|
|
// Retrieve the first xml node with the given tag name in the given xml doc
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST FindFirstDOMNode(IXMLDOMDocument* pDoc, BSTR bstrName, IXMLDOMNode** ppNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindFirstDOMNode()
|
|
//
|
|
// Retrieve the handle of first xml node with the given tag name in the given xml doc
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST FindFirstDOMNode(IXMLDOMDocument* pDoc, BSTR bstrName, HANDLE_NODE* phNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindNextDOMNode()
|
|
//
|
|
// Retrieve the next xml node with the given tag name under the given parent node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT FindNextDOMNode(HANDLE_NODELIST hNodeList, IXMLDOMNode** ppNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindNextDOMNode()
|
|
//
|
|
// Retrieve the handle of next xml node with the given tag name under the given parent node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT FindNextDOMNode(HANDLE_NODELIST hNodeList, HANDLE_NODE* phNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CreateDOMNodeWithHandle()
|
|
//
|
|
// Create an xml node of the given type
|
|
// Return: index of the node array "m_ppNodeArray"; or -1 if failure.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODE CreateDOMNodeWithHandle(IXMLDOMDocument* pDoc, SHORT nType, BSTR bstrName, BSTR bstrNamespaceURI = NULL);
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CXmlSystemSpec
|
|
class CXmlSystemSpec : public CIUXml
|
|
{
|
|
public:
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
//
|
|
// Create IXMLDOMDocument* for SystemSpec
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CXmlSystemSpec();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
//
|
|
// Release IXMLDOMDocument* for SystemSpec
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
~CXmlSystemSpec();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddComputerSystem()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddComputerSystem(BSTR bstrManufacturer,
|
|
BSTR bstrModel,
|
|
BSTR bstrSupportSite = NULL,
|
|
INT iAdmin = -1,
|
|
INT iWUDisabled = -1,
|
|
INT iAUEnabled = -1,
|
|
BSTR bstrPID=NULL);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddDriveSpace()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddDriveSpace(BSTR bstrDrive, INT iKBytes);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddReg()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddReg(BSTR bstrProvider);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddPlatform()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddPlatform(BSTR bstrName);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddProcessor()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddProcessor(BSTR bstrProcessor);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddVersion()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddVersion(INT iMajor = -1,
|
|
INT iMinor = -1,
|
|
INT iBuild = -1,
|
|
INT iSPMajor = -1,
|
|
INT iSPMinor = -1,
|
|
BSTR bstrTimeStamp = NULL);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddSuite()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddSuite(BSTR bstrSuite);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddProductType()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddProductType(BSTR bstrProductType);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddLocale()
|
|
//
|
|
// We need to pass back a handle to differentiate different <locale> node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddLocale(BSTR bstrContext, HANDLE_NODE* phNodeLocale);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddLanguage()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddLanguage(HANDLE_NODE hNodeLocale, BSTR bstrLocale);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddDevice()
|
|
//
|
|
// We need to pass back a handle to differentiate different <device> node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddDevice(BSTR bstrDeviceInstance,
|
|
INT iIsPrinter,
|
|
BSTR bstrProvider,
|
|
BSTR bstrMfgName,
|
|
BSTR bstrDriverName,
|
|
HANDLE_NODE* phNodeDevice);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddHWID()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddHWID(HANDLE_NODE hNodeDevice,
|
|
BOOL fIsCompatible,
|
|
UINT iRank,
|
|
BSTR bstrHWID,
|
|
BSTR bstrDriverVer = NULL);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetSystemSpecBSTR()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetSystemSpecBSTR(BSTR *pbstrXmlSystemSpec);
|
|
|
|
private:
|
|
IXMLDOMDocument* m_pDocSystemSpec;
|
|
IXMLDOMNode* m_pNodeSystemInfo;
|
|
IXMLDOMNode* m_pNodeComputerSystem;
|
|
IXMLDOMNode* m_pNodeRegKeysSW;
|
|
IXMLDOMNode* m_pNodePlatform;
|
|
IXMLDOMNode* m_pNodeDevices;
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CXmlSystemClass
|
|
class CXmlSystemClass : public CIUXml
|
|
{
|
|
public:
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
//
|
|
// Create IXMLDOMDocument* for SystemInfoClasses
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CXmlSystemClass();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
//
|
|
// Release IXMLDOMDocument* for SystemInfoClasses
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
~CXmlSystemClass();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// LoadXMLDocument()
|
|
//
|
|
// Load an XML Document from string
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT LoadXMLDocument(BSTR bstrXml, BOOL fOfflineMode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetClasses()
|
|
//
|
|
// Return the bitmap of existence of all possible system info classes
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD GetClasses();
|
|
|
|
private:
|
|
IXMLDOMDocument* m_pDocSystemClass;
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CXmlCatalog
|
|
class CXmlCatalog : public CIUXml
|
|
{
|
|
public:
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
//
|
|
// Create IXMLDOMDocument* for Catalog
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CXmlCatalog();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
//
|
|
// Release IXMLDOMDocument* for Catalog
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
~CXmlCatalog();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// LoadXMLDocument()
|
|
//
|
|
// Load an XML Document from string
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT LoadXMLDocument(BSTR bstrXml, BOOL fOfflineMode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemCount()
|
|
//
|
|
// Gets a Count of How Many Items are in this Catalog
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemCount(LONG *plItemCount);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetProviders()
|
|
//
|
|
// Find a list of <provider> node in catalog xml
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
IXMLDOMNodeList* GetProviders();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetFirstProvider()
|
|
//
|
|
// Find the first provider in catalog xml doc
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST GetFirstProvider(HANDLE_NODE* phNodeProvider);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetNextProvider()
|
|
//
|
|
// Find the next provider in catalog xml doc
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetNextProvider(HANDLE_NODELIST hNodeListProvider, HANDLE_NODE* phNodeProvider);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetFirstItem()
|
|
//
|
|
// Find the first item in provider (parent) node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST GetFirstItem(HANDLE_NODE hNodeProvider, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetNextItem()
|
|
//
|
|
// Find the next item in provider (parent) node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetNextItem(HANDLE_NODELIST hNodeListItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetFirstItemDependency()
|
|
//
|
|
// Find the first dependency item in Item Dependencies node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST GetFirstItemDependency(HANDLE_NODE hNodeItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetNextItem()
|
|
//
|
|
// Find the next dependency item in the Item Dependencies node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetNextItemDependency(HANDLE_NODELIST hNodeListItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CloseItemList()
|
|
//
|
|
// Release the item nodelist
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CloseItemList(HANDLE_NODELIST hNodeListItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetIdentity()
|
|
//
|
|
// Retrieve the unique name (identity) of the given provider or item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetIdentity(HANDLE_NODE hNode,
|
|
BSTR* pbstrName,
|
|
BSTR* pbstrPublisherName,
|
|
BSTR* pbstrGUID);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetIdentityStr()
|
|
//
|
|
// Retrieve the string that can be used to uniquely identify an item.
|
|
// This function defines the logic about what components can be used
|
|
// to define the uniqueness of an item based on the 3 parts of data from
|
|
// GetIdentity().
|
|
//
|
|
// The created string will be language neutral. That is, it can not
|
|
// ensure the uniqueness for two items having the same <identity> node
|
|
// except different only on <langauge> part inside <identity>
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetIdentityStr(HANDLE_NODE hNode,
|
|
BSTR* pbstrUniqIdentifierString);
|
|
|
|
HRESULT GetIdentityStrForPing(HANDLE_NODE hNode,
|
|
BSTR* pbstrUniqIdentifierString);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetBSTRItemForCallback()
|
|
//
|
|
// Create an item node as the passed-in node, have child nodes identity and
|
|
// platform (anything uniquely idenitify this item) then output this
|
|
// item node data as string, then delete the crated node
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetBSTRItemForCallback(HANDLE_NODE hItem, BSTR* pbstrXmlItemForCallback);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IsPrinterDriver()
|
|
//
|
|
// Retrieves from the Catalog whether this Item is a Printer Driver
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL IsPrinterDriver(HANDLE_NODE hNode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetDriverInfo()
|
|
//
|
|
// Retrieves the Driver Information from the Catalog for this Item. Returns
|
|
// the Display Name and HWID for this driver - This is passed to the CDM
|
|
// installer
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetDriverInfo(HANDLE_NODE hNode,
|
|
BSTR* pbstrHWID,
|
|
BSTR* pbstrDisplayName);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetPrinterDriverInfo()
|
|
//
|
|
// Retrieves the Printer Driver Information from the Catalog for this Item.
|
|
// Returns the DriverName and the Architecture - This is passed to the CDM
|
|
// installer
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetPrinterDriverInfo(HANDLE_NODE hNode,
|
|
BSTR* pbstrDriverName,
|
|
BSTR* pbstrArchitecture);
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetDriverInfoEx()
|
|
//
|
|
// Combines functionality of IsPrinterDriver, GetDriverInfo, and
|
|
// GetPrinterDriverInfo plus retreives MfgName and DriverProvider.
|
|
// Used by FindMatchingDriver()
|
|
//
|
|
// If SUCCEEDES pbstrHWID, pbstrDriverVer, and pbstrDisplayName
|
|
// are always returned.
|
|
// If SUCCEEDES && *pFIsPrinter == TRUE then pbstrDriverName,
|
|
// pbstrDriverProvider, and pbstrMfgName are returned.
|
|
//
|
|
// Currently pbstrArchitecture is never returned.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CXmlCatalog::GetDriverInfoEx(HANDLE_NODE hNode,
|
|
BOOL* pfIsPrinter,
|
|
BSTR* pbstrHWID,
|
|
BSTR* pbstrDriverVer,
|
|
BSTR* pbstrDisplayName,
|
|
BSTR* pbstrDriverName,
|
|
BSTR* pbstrDriverProvider,
|
|
BSTR* pbstrMfgName,
|
|
BSTR* pbstrArchitecture);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemFirstPlatformStr()
|
|
//
|
|
// The input node pointer points to an item node has <platform> as its child.
|
|
// This function will retrieve the first <platform> node from this item node and
|
|
// convert the data inside <platform> into a string that can be used to
|
|
// uniquely identify a platform.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemFirstPlatformStr(HANDLE_NODE hNodeItem,
|
|
BSTR* pbstrPlatform);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemAllPlatformStr()
|
|
//
|
|
// The input node pointer points to an item node that has <platform> node(s).
|
|
// This function will retrieve every <platform> node from this item node and
|
|
// convert the data inside <platform> into a string that can be used to
|
|
// uniquely identify a platform.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemAllPlatformStr(HANDLE_NODE hNodeItem,
|
|
BSTR** ppbPlatforms, UINT* pnPlatformCount);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemFirstLanguageStr()
|
|
//
|
|
// The input node pointer points to a node has <identity> as its child.
|
|
// This function will retrieve the first <language> node from <identity>
|
|
// node
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemFirstLanguageStr(HANDLE_NODE hNodeItem,
|
|
BSTR* pbstrLanguage);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemAllLanguageStr()
|
|
//
|
|
// The input node pointer points to a node has <identity> as its child.
|
|
// This function will retrieve every <language> node from <identity> node and
|
|
// convert the data into an BSTR array to return.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemAllLanguageStr(HANDLE_NODE hNodeItem,
|
|
BSTR** ppbstrLanguage, UINT* pnLangCount);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemFirstCodeBase()
|
|
//
|
|
// Find the first codebase (path) of the given item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST GetItemFirstCodeBase(HANDLE_NODE hNodeItem,
|
|
BSTR* pbstrCodeBase,
|
|
BSTR* pbstrName,
|
|
BSTR* pbstrCRC,
|
|
BOOL* pfPatchAvailable,
|
|
LONG* plSize);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemNextCodeBase()
|
|
//
|
|
// Find the next codebase (path) of the given item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemNextCodeBase(HANDLE_NODELIST hNodeListCodeBase,
|
|
BSTR* pbstrCodeBase,
|
|
BSTR* pbstrName,
|
|
BSTR* pbstrCRC,
|
|
BOOL* pfPatchAvailable,
|
|
LONG* plSize);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemInstallInfo()
|
|
//
|
|
// Retrieve the installation information of the given item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemInstallInfo(HANDLE_NODE hNodeItem,
|
|
BSTR* pbstrInstallerType,
|
|
BOOL* pfExclusive,
|
|
BOOL* pfReboot,
|
|
LONG* plNumCommands);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemInstallCommand()
|
|
//
|
|
// Find the installation command type, command and switches of the given item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemInstallCommand(HANDLE_NODE hNodeItem,
|
|
INT iOrder,
|
|
BSTR* pbstrCommandType,
|
|
BSTR* pbstrCommand,
|
|
BSTR* pbstrSwitches,
|
|
BSTR* pbstrInfSection);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CloseItem()
|
|
//
|
|
// Release the item node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CloseItem(HANDLE_NODE hNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetTotalEstimatedSize()
|
|
//
|
|
// Get the Total Estimated Download Size of all Items based on Codebase Size
|
|
HRESULT GetTotalEstimatedSize(LONG *plTotalSize);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindItemByIdentity()
|
|
//
|
|
// Finds an Item in the Catalog that Matches the Supplied Identity
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT FindItemByIdentity(IXMLDOMNode* pNodeIdentity, HANDLE_NODE* phNodeItem);
|
|
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
|
// IfSameIdentity()
|
|
//
|
|
// Return TRUE if the two <identity> nodes are identical. Return FALSE otherwise.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL IfSameIdentity(IXMLDOMNode* pNodeIdentity1, IXMLDOMNode* pNodeIdentity2);
|
|
*/
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemLanguage()
|
|
//
|
|
// Get the Language Entity from the Item Identity
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemLanguage(HANDLE_NODE hNodeItem, BSTR* pbstrLanguage);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetCorpItemPlatformStr()
|
|
//
|
|
// Get the Simplified Platform String for an Item (uses the first available platform element)
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetCorpItemPlatformStr(HANDLE_NODE hNodeItem, BSTR* pbstrPlatformStr);
|
|
|
|
|
|
private:
|
|
IXMLDOMDocument* m_pDocCatalog;
|
|
|
|
//
|
|
// helper functions
|
|
//
|
|
|
|
//
|
|
// get data from a version node and convert them into a string with
|
|
// format:
|
|
// VersionStr = <Version>[,<SvcPackVer>[,<timeStamp>]]
|
|
// <Version> = <Major>[.<Minor>[.<Build>]]
|
|
// <SvcPackVer> = <Major>[.<minor>]
|
|
//
|
|
//
|
|
// Assumption:
|
|
// pszVersion points to a buffer LARGE ENOUGH to store
|
|
// any legal version number.
|
|
//
|
|
HRESULT getVersionStr(IXMLDOMNode* pVersionNode, LPTSTR pszVersion);
|
|
HRESULT getVersionStrWithoutSvcPack(IXMLDOMNode* pVersionNode, LPTSTR pszVersion);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemPlatformStr()
|
|
//
|
|
// The input node pointer points to a <platform> node.
|
|
// This function will retrieve the data from this <platform> node and
|
|
// convert the data into a string that can be used to
|
|
// uniquely identify a platform.
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetPlatformStr(IXMLDOMNode* pNodePlatform, BSTR* pbstrPlatform);
|
|
HRESULT GetPlatformStrForPing(IXMLDOMNode* pNodePlatform, BSTR* pbstrPlatform);
|
|
|
|
private:
|
|
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CXmlItems
|
|
class CXmlItems : public CIUXml
|
|
{
|
|
public:
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
//
|
|
// Create IXMLDOMDocument* for Items; this is for write only
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CXmlItems();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Constructor
|
|
//
|
|
// Create IXMLDOMDocument* for Items; take TRUE for read, FALSE for write
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CXmlItems(BOOL fRead);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Destructor
|
|
//
|
|
// Release IXMLDOMDocument* for Items
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
~CXmlItems();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemsDocumentPtr()
|
|
//
|
|
// Retrieve the items XML Document node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
inline IXMLDOMDocument* GetItemsDocumentPtr() { return m_pDocItems; };
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Clear()
|
|
//
|
|
// Reset IXMLDOMDocument* for Items
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void Clear();
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// LoadXMLDocument()
|
|
//
|
|
// Load an XML Document from string
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT LoadXMLDocument(BSTR bstrXml);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// LoadXMLDocumentFile()
|
|
//
|
|
// Load an XML Document from the specified file
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT LoadXMLDocumentFile(BSTR bstrFilePath);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// SaveXMLDocument()
|
|
//
|
|
// Save an XML Document to the specified location
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT SaveXMLDocument(BSTR bstrFilePath);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddGlobalErrorCodeIfNoItems()
|
|
//
|
|
// Add the errorCode attribute for <items> if there's no <itemStatus> child node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST AddGlobalErrorCodeIfNoItems(DWORD dwErrorCode);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetFirstItem()
|
|
//
|
|
// Find the first item in Items xml doc
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HANDLE_NODELIST GetFirstItem(HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetNextItem()
|
|
//
|
|
// Find the next item in Items xml doc
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetNextItem(HANDLE_NODELIST hNodeListItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CloseItemList()
|
|
//
|
|
// Release the item nodelist
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CloseItemList(HANDLE_NODELIST hNodeListItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemDownloadPath()
|
|
//
|
|
// Retrieve the download path of the given item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemDownloadPath(HANDLE_NODE hNodeItem, BSTR* pbstrDownloadPath);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemDownloadPath()
|
|
//
|
|
// Retrieve the download path of the given item in catalog
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemDownloadPath(CXmlCatalog* pCatalog, HANDLE_NODE hNodeItem, BSTR* pbstrDownloadPath);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CloseItem()
|
|
//
|
|
// Release the item node
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CloseItem(HANDLE_NODE hNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindItem()
|
|
//
|
|
// Input:
|
|
// pNodeItem - the <itemStatus> node of the install items xml; we need
|
|
// to find the corresponding <itemStatus> node in the existing
|
|
// items xml with the identical <identity>, <platform> and
|
|
// <client> nodes.
|
|
// Output:
|
|
// phNodeItem - the handle we pass back to differentiate different
|
|
// <itemStatus> node in the existing items xml
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT FindItem(IXMLDOMNode* pNodeItem, HANDLE_NODE* phNodeItem, BOOL fIdentityOnly = FALSE);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// FindItem()
|
|
//
|
|
// Input:
|
|
// pCatalog - the pointer to the CXmlCatalog object
|
|
// hNodeItem - the handle of the <item> node of the catalog xml; we need
|
|
// to find the corresponding <itemStatus> node in the existing
|
|
// items xml with the identical <identity>, <platform> and
|
|
// <client> nodes.
|
|
// Output:
|
|
// phNodeItem - the handle we pass back to differentiate different
|
|
// <itemStatus> node in items xml
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT FindItem(CXmlCatalog* pCatalog, HANDLE_NODE hNodeItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MergeItemDownloaded()
|
|
//
|
|
// Insert items with download history into existing history
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT MergeItemDownloaded(CXmlItems *pHistoryDownload);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// UpdateItemInstalled()
|
|
//
|
|
// Update items with installation history in existing history
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT UpdateItemInstalled(CXmlItems *pHistoryInstall);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// UpdateItemInstallStatus()
|
|
//
|
|
// Update the install status of the given item
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT UpdateItemInstallStatus(HANDLE_NODE hNodeItem,
|
|
BSTR bstrValue,
|
|
INT iNeedsReboot = -1,
|
|
DWORD dwErrorCode = 0);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddItem()
|
|
//
|
|
// Input:
|
|
// pNodeItem - the <item> node of the catalog xml; we need to read
|
|
// <identity> node, <description> node and <platform> nodes
|
|
// from it and write to the items xml (insert in front).
|
|
// Output:
|
|
// phNodeItem - the handle we pass back to differentiate different
|
|
// <itemStatus> node in items xml
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddItem(IXMLDOMNode* pNodeItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddItem()
|
|
//
|
|
// Input:
|
|
// pCatalog - the pointer to the CXmlCatalog object
|
|
// hNodeItem - the handle of the <item> node of the catalog xml; we need
|
|
// to read <identity> node, <description> node and <platform>
|
|
// nodes from it and write to the items xml (insert in front).
|
|
// Output:
|
|
// phNodeItem - the handle we pass back to differentiate different
|
|
// <itemStatus> node in items xml
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddItem(CXmlCatalog* pCatalog, HANDLE_NODE hNodeItem, HANDLE_NODE* phNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddTimeStamp()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddTimeStamp(HANDLE_NODE hNodeItem);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddDetectResult()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddDetectResult(HANDLE_NODE hNodeItem,
|
|
INT iInstalled = -1,
|
|
INT iUpToDate = -1,
|
|
INT iNewerVersion = -1,
|
|
INT iExcluded = -1,
|
|
INT iForce = -1,
|
|
INT iComputerSystem = -1);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddDownloadStatus()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddDownloadStatus(HANDLE_NODE hNodeItem, BSTR bstrValue, DWORD dwErrorCode = 0);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddDownloadPath()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddDownloadPath(HANDLE_NODE hNodeItem, BSTR bstrDownloadPath);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddInstallStatus()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddInstallStatus(HANDLE_NODE hNodeItem, BSTR bstrValue, BOOL fNeedsReboot, DWORD dwErrorCode = 0);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// AddClientInfo()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT AddClientInfo(HANDLE_NODE hNodeItem, BSTR bstrClient);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// MigrateV3History()
|
|
//
|
|
// Migrate V3 History: Consumer history only.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT MigrateV3History(LPCTSTR pszHistoryFilePath);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetItemsBSTR()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetItemsBSTR(BSTR *pbstrXmlItems);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// GetFilteredHistoryBSTR()
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
HRESULT GetFilteredHistoryBSTR(BSTR bstrBeginDateTime,
|
|
BSTR bstrEndDateTime,
|
|
BSTR bstrClient,
|
|
BSTR *pbstrXmlHistory);
|
|
|
|
private:
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Initialize XML DOC node pointers before writing
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void Init();
|
|
|
|
/* /////////////////////////////////////////////////////////////////////////////
|
|
// IfSameClientInfo()
|
|
//
|
|
// Return TRUE if the two <client> nodes are identical. Return FALSE otherwise.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL IfSameClientInfo(IXMLDOMNode* pNodeClient1, IXMLDOMNode* pNodeClient2);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IfSameIdentity()
|
|
//
|
|
// Return TRUE if the two <identity> nodes are identical. Return FALSE otherwise.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL IfSameIdentity(IXMLDOMNode* pNodeIdentity1, IXMLDOMNode* pNodeIdentity2);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// IfSamePlatform()
|
|
//
|
|
// Return TRUE if the two <platform> nodes are identical. Return FALSE otherwise.
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL IfSamePlatform(IXMLDOMNode* pNodePlatform1, IXMLDOMNode* pNodePlatform2);
|
|
*/
|
|
|
|
IXMLDOMDocument* m_pDocItems;
|
|
IXMLDOMNode* m_pNodeItems;
|
|
};
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CXmlClientInfo
|
|
class CXmlClientInfo
|
|
{
|
|
public:
|
|
|
|
CXmlClientInfo();
|
|
~CXmlClientInfo();
|
|
|
|
//
|
|
// load and parse and validate an XML document from string
|
|
//
|
|
HRESULT LoadXMLDocument(BSTR bstrXml, BOOL fOfflineMode);
|
|
|
|
//
|
|
// retrieve client name attribute
|
|
//
|
|
HRESULT GetClientName(BSTR* pbstrClientName);
|
|
|
|
inline IXMLDOMDocument* GetDocument() { return m_pDocClientInfo; }
|
|
|
|
private:
|
|
IXMLDOMDocument* m_pDocClientInfo;
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
#endif //__IUXML_H_
|