255 lines
8.5 KiB
C++
255 lines
8.5 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 2000.
|
|
//
|
|
// File: D E S C R I P T I O N M A N A G E R . H
|
|
//
|
|
// Contents: Process UPnP Description document
|
|
//
|
|
// Notes:
|
|
//
|
|
// Author: mbend 18 Aug 2000
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
#include "uhres.h" // main symbols
|
|
|
|
#include "ComUtility.h"
|
|
#include "Array.h"
|
|
#include "hostp.h"
|
|
#include "Table.h"
|
|
#include "UString.h"
|
|
#include "RegDef.h"
|
|
#include "uhsync.h"
|
|
#include "uhxml.h"
|
|
|
|
// Forward declarations
|
|
struct _SSDP_MESSAGE;
|
|
typedef _SSDP_MESSAGE SSDP_MESSAGE;
|
|
|
|
// Must define these here to satisfy data structure requirements
|
|
typedef CUString Filename;
|
|
typedef CUString Mimetype;
|
|
struct FileInfo
|
|
{
|
|
Filename m_filename;
|
|
Mimetype m_mimetype;
|
|
};
|
|
inline HRESULT HrTypeAssign(FileInfo & dst, const FileInfo & src)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
hr = HrTypeAssign(dst.m_filename, src.m_filename);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
hr = HrTypeAssign(dst.m_mimetype, src.m_mimetype);
|
|
}
|
|
return hr;
|
|
}
|
|
inline void TypeTransfer(FileInfo & dst, FileInfo & src)
|
|
{
|
|
TypeTransfer(dst.m_filename, src.m_filename);
|
|
TypeTransfer(dst.m_mimetype, src.m_mimetype);
|
|
}
|
|
inline void TypeClear(FileInfo & type)
|
|
{
|
|
TypeClear(type.m_filename);
|
|
TypeClear(type.m_mimetype);
|
|
}
|
|
typedef CTable<UDN, UDN> UDNReplacementTable;
|
|
// Not implemented - should not use
|
|
// inline HRESULT HrTypeAssign(UDNReplacementTable & dst, const UDNReplacementTable & src)
|
|
inline void TypeTransfer(UDNReplacementTable & dst, UDNReplacementTable & src)
|
|
{
|
|
dst.Swap(src);
|
|
}
|
|
inline void TypeClear(UDNReplacementTable & type)
|
|
{
|
|
type.Clear();
|
|
}
|
|
typedef CTable<PhysicalDeviceIdentifier, UDNReplacementTable> ReplacementTable;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// TestObject
|
|
class ATL_NO_VTABLE CDescriptionManager :
|
|
public CComObjectRootEx<CComMultiThreadModel>,
|
|
public CComCoClass<CDescriptionManager, &CLSID_UPnPDescriptionManager>,
|
|
public IUPnPDescriptionManager,
|
|
public IUPnPDynamicContentProvider
|
|
{
|
|
public:
|
|
CDescriptionManager();
|
|
~CDescriptionManager();
|
|
|
|
DECLARE_REGISTRY_RESOURCEID(IDR_DESCRIPTION_MANAGER)
|
|
DECLARE_NOT_AGGREGATABLE(CDescriptionManager)
|
|
|
|
BEGIN_COM_MAP(CDescriptionManager)
|
|
COM_INTERFACE_ENTRY(IUPnPDescriptionManager)
|
|
COM_INTERFACE_ENTRY(IUPnPDynamicContentProvider)
|
|
END_COM_MAP()
|
|
|
|
public:
|
|
// IUPnPDescriptionManager methods
|
|
STDMETHOD(GetContent)(
|
|
/*[in]*/ REFGUID guidContent,
|
|
/*[out]*/ long * pnHeaderCount,
|
|
/*[out, string, size_is(,*pnHeaderCount)]*/ wchar_t *** arszHeaders,
|
|
/*[out]*/ long * pnBytes,
|
|
/*[out, size_is(,*pnBytes)]*/ byte ** parBytes);
|
|
|
|
// IUPnPDynamicContentProvider methods
|
|
STDMETHOD(ProcessDescriptionTemplate)(
|
|
/*[in]*/ BSTR bstrTemplate,
|
|
/*[in, string]*/ const wchar_t * szResourcePath,
|
|
/*[in, out]*/ GUID * pguidPhysicalDeviceIdentifier,
|
|
/*[in]*/ BOOL bPersist,
|
|
/*[in]*/ BOOL bReregister);
|
|
STDMETHOD(PublishDescription)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier,
|
|
/*[in]*/ long nLifeTime);
|
|
STDMETHOD(LoadDescription)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier);
|
|
STDMETHOD(RemoveDescription)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier,
|
|
/*[in]*/ BOOL bPermanent);
|
|
STDMETHOD(GetDescriptionText)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier,
|
|
/*[out]*/ BSTR * pbstrDescriptionDocument);
|
|
STDMETHOD(GetUDNs)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier,
|
|
/*[out]*/ long * pnUDNCount,
|
|
/*[out, size_is(,*pnUDNCount,), string]*/
|
|
wchar_t *** parszUDNs);
|
|
STDMETHOD(GetUniqueDeviceName)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier,
|
|
/*[in, string]*/ const wchar_t * szTemplateUDN,
|
|
/*[out, string]*/ wchar_t ** pszUDN);
|
|
STDMETHOD(GetSCPDText)(
|
|
/*[in]*/ REFGUID guidPhysicalDeviceIdentifier,
|
|
/*[in, string]*/ const wchar_t * szUDN,
|
|
/*[in, string]*/ const wchar_t * szServiceId,
|
|
/*[out, string]*/ wchar_t ** pszSCPDText,
|
|
/*[out, string]*/ wchar_t ** pszServiceType);
|
|
private:
|
|
typedef BSTR DescriptionDocument;
|
|
typedef CTable<PhysicalDeviceIdentifier, DescriptionDocument> DocumentTable;
|
|
typedef GUID FileId;
|
|
typedef CTable<FileId, FileInfo> FileTable;
|
|
struct CleanupItem
|
|
{
|
|
PhysicalDeviceIdentifier m_physicalDeviceIdentifier;
|
|
FileId m_fileId;
|
|
};
|
|
typedef CUArray<CleanupItem> CleanupList;
|
|
typedef CUArray<HANDLE> HandleList;
|
|
typedef CTable<PhysicalDeviceIdentifier, HandleList *> SSDPRegistrationTable;
|
|
|
|
DocumentTable m_documentTable;
|
|
FileTable m_fileTable;
|
|
CleanupList m_cleanupList;
|
|
CUCriticalSection m_critSecReplacementTable;
|
|
ReplacementTable m_replacementTable;
|
|
SSDPRegistrationTable m_ssdpRegistrationTable;
|
|
|
|
// Internal helper routines
|
|
HRESULT HrPersistDeviceSettingsToRegistry(
|
|
const PhysicalDeviceIdentifier & physicalDeviceIdentifier,
|
|
const UDNReplacementTable & udnReplacementTable,
|
|
const FileTable & fileTable,
|
|
BOOL bPersist);
|
|
HRESULT HrLoadDocumentAndRootNode(
|
|
const PhysicalDeviceIdentifier & physicalDeviceIdentifier,
|
|
IXMLDOMNodePtr & pRootNode);
|
|
|
|
// (PDT) Process Device Template helper functions
|
|
HRESULT HrPDT_FetchCollections(
|
|
BSTR bstrTemplate,
|
|
IXMLDOMDocumentPtr & pDoc,
|
|
IXMLDOMNodePtr & pRootNode,
|
|
CUString & strRootUdnOld,
|
|
IXMLDOMNodeListPtr & pNodeListDevices,
|
|
IXMLDOMNodeListPtr & pNodeListUDNs,
|
|
IXMLDOMNodeListPtr & pNodeListSCPDURLs,
|
|
IXMLDOMNodeListPtr & pNodeListIcons);
|
|
HRESULT HrPDT_DoUDNToUDNMapping(
|
|
IXMLDOMNodeListPtr & pNodeListUDNs,
|
|
UDNReplacementTable & udnReplacementTable);
|
|
HRESULT HrPDT_ReregisterUDNsInDescriptionDocument(
|
|
UDNReplacementTable & udnReplacementTable,
|
|
IXMLDOMNodeListPtr & pNodeListUDNs);
|
|
HRESULT HrPDT_FetchPhysicalIdentifier(
|
|
UDNReplacementTable & udnReplacementTable,
|
|
const CUString & strRootUdnOld,
|
|
PhysicalDeviceIdentifier & pdi);
|
|
HRESULT HrPDT_ReplaceSCPDURLs(
|
|
IXMLDOMNodeListPtr & pNodeListSCPDURLs,
|
|
const wchar_t * szResourcePath,
|
|
FileTable & fileTable);
|
|
HRESULT HrPDT_ReplaceIcons(
|
|
IXMLDOMNodeListPtr & pNodeListIcons,
|
|
const wchar_t * szResourcePath,
|
|
FileTable & fileTable);
|
|
HRESULT HrPDT_ReplaceControlAndEventURLs(
|
|
IXMLDOMNodeListPtr & pNodeListDevices);
|
|
HRESULT HrPDT_PersistDescriptionDocument(
|
|
const PhysicalDeviceIdentifier & pdi,
|
|
IXMLDOMDocumentPtr & pDoc);
|
|
// presentation specific functions
|
|
HRESULT HrPDT_ProcessPresentationURLs(
|
|
REFGUID guidPhysicalDeviceIdentifier,
|
|
IXMLDOMNodeListPtr & pNodeListDevices,
|
|
BOOL *fIsPresURLTagPresent);
|
|
|
|
// (PD) Publish Description helper functions
|
|
HRESULT HrPD_DoRootNotification(
|
|
IXMLDOMNodePtr & pNodeRootDevice,
|
|
SSDP_MESSAGE * pMsg,
|
|
HandleList * pHandleList);
|
|
HRESULT HrPD_DoDevicePublication(
|
|
IXMLDOMNodeListPtr & pNodeListDevices,
|
|
SSDP_MESSAGE * pMsg,
|
|
HandleList * pHandleList);
|
|
HRESULT HrPD_DoServicePublication(
|
|
IXMLDOMNodePtr & pNodeDevice,
|
|
const CUString & strUDN,
|
|
SSDP_MESSAGE * pMsg,
|
|
HandleList * pHandleList);
|
|
|
|
// (LD) Load Description helper functions
|
|
HRESULT HrLD_ReadUDNMappings(
|
|
HKEY hKeyPdi,
|
|
UDNReplacementTable & udnReplacementTable);
|
|
HRESULT HrLD_ReadFileMappings(
|
|
HKEY hKeyPdi,
|
|
FileTable & fileTable);
|
|
HRESULT HrLD_LoadDescriptionDocumentFromDisk(
|
|
const PhysicalDeviceIdentifier & pdi,
|
|
IXMLDOMDocumentPtr & pDoc);
|
|
HRESULT HrLD_SaveDescriptionDocumentText(
|
|
IXMLDOMDocumentPtr & pDoc,
|
|
const PhysicalDeviceIdentifier & pdi);
|
|
|
|
// (RD) Remove Description helper functions
|
|
HRESULT HrRD_RemoveFromEventing(const PhysicalDeviceIdentifier & pdi);
|
|
HRESULT HrRD_RemoveFromDataStructures(const PhysicalDeviceIdentifier & pdi);
|
|
HRESULT HrRD_CleanupPublication(const PhysicalDeviceIdentifier & pdi);
|
|
};
|
|
|
|
HRESULT HrCreateOrOpenDescriptionKey(
|
|
HKEY * phKeyDescription);
|
|
HRESULT HrOpenPhysicalDeviceDescriptionKey(
|
|
const UUID & pdi,
|
|
HKEY * phKeyPdi);
|
|
HRESULT HrGetDescriptionDocumentPath(
|
|
const UUID & pdi,
|
|
CUString & strPath);
|
|
HRESULT HrRegisterServiceWithEventing(
|
|
IXMLDOMNodePtr & pNodeService,
|
|
const CUString & strUDN,
|
|
BOOL bRegister);
|
|
|
|
|
|
|