2429 lines
59 KiB
C++
2429 lines
59 KiB
C++
/*++
|
|
|
|
Copyright (c) 1994-1998 Microsoft Corporation
|
|
|
|
Module Name :
|
|
|
|
inetmgr.h
|
|
|
|
Abstract:
|
|
|
|
Main program object and class definitions
|
|
|
|
Author:
|
|
|
|
Ronald Meijer (ronaldm)
|
|
|
|
Project:
|
|
|
|
Internet Services Manager
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#ifndef _INETMGR_H_
|
|
#define _INETMGR_H_
|
|
|
|
#ifndef __AFXWIN_H__
|
|
#error include 'stdafx.h' before including this file for PCH
|
|
#endif
|
|
|
|
#include <lmcons.h>
|
|
#include <wtypes.h>
|
|
#include <iis64.h>
|
|
|
|
extern "C"
|
|
{
|
|
typedef unsigned hyper ULONGLONG;
|
|
#include "svcloc.h"
|
|
}
|
|
|
|
#include "comprop.h"
|
|
#include "svrinfo.h"
|
|
#include "resource.h" // main symbols
|
|
|
|
|
|
|
|
LPOLESTR
|
|
CoTaskDupString(
|
|
IN LPCOLESTR szString
|
|
);
|
|
|
|
|
|
#define CoTaskStringFree(szString)\
|
|
if (szString) CoTaskMemFree(szString);
|
|
|
|
|
|
HRESULT
|
|
BuildResURL(
|
|
OUT CString & str,
|
|
IN HINSTANCE hSourceInstance = (HINSTANCE)-1
|
|
);
|
|
|
|
struct INTERNAL
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Internal information structure. This is used to get the private information
|
|
from the data object.
|
|
|
|
Public Interface:
|
|
|
|
INTERNAL : Constructor
|
|
~INTERNAL : Destructor
|
|
|
|
--*/
|
|
{
|
|
INTERNAL()
|
|
: m_type(CCT_UNINITIALIZED),
|
|
m_cookie(-1)
|
|
{
|
|
::ZeroMemory(&m_clsid, sizeof(CLSID));
|
|
};
|
|
|
|
~INTERNAL() {}
|
|
|
|
DATA_OBJECT_TYPES m_type; // What context is the data object.
|
|
MMC_COOKIE m_cookie; // What object the cookie represents
|
|
CString m_string; //
|
|
CLSID m_clsid; // Class ID of who created this data object
|
|
|
|
INTERNAL & operator=(const INTERNAL& rhs)
|
|
{
|
|
if (&rhs == this)
|
|
{
|
|
return *this;
|
|
}
|
|
|
|
//
|
|
// Deep copy the information
|
|
//
|
|
m_type = rhs.m_type;
|
|
m_cookie = rhs.m_cookie;
|
|
m_string = rhs.m_string;
|
|
CopyMemory(&m_clsid, &rhs.m_clsid, sizeof(CLSID));
|
|
|
|
return *this;
|
|
}
|
|
|
|
BOOL operator==(const INTERNAL& rhs) { return rhs.m_string == m_string; }
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// Menu Commands, listed in toolbar order.
|
|
//
|
|
// IMPORTANT! -- this must be kept in sync with MenuItemDefs
|
|
// in iisobj.cpp
|
|
//
|
|
enum
|
|
{
|
|
IDM_INVALID, /* invalid command ID */
|
|
IDM_CONNECT,
|
|
IDM_DISCOVER,
|
|
IDM_START,
|
|
IDM_STOP,
|
|
IDM_PAUSE,
|
|
/**/
|
|
IDM_TOOLBAR /* Toolbar commands start here */
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// Additional menu commands that do not show up in the toolbar
|
|
//
|
|
enum
|
|
{
|
|
IDM_EXPLORE = IDM_TOOLBAR,
|
|
IDM_OPEN,
|
|
IDM_BROWSE,
|
|
IDM_CONFIGURE,
|
|
IDM_DISCONNECT,
|
|
IDM_METABACKREST,
|
|
IDM_SHUTDOWN,
|
|
IDM_NEW_VROOT,
|
|
IDM_NEW_INSTANCE,
|
|
IDM_VIEW_TASKPAD,
|
|
IDM_TASK_SECURITY_WIZARD,
|
|
|
|
//
|
|
// Don't move this last one -- it will be used
|
|
// as an offset for service specific new instance
|
|
// commands
|
|
//
|
|
IDM_NEW_EX_INSTANCE
|
|
};
|
|
|
|
|
|
//
|
|
// Background colour mask of our own toolbar bitmaps.
|
|
//
|
|
#define TB_COLORMASK RGB(192,192,192) // Lt. Gray
|
|
|
|
//
|
|
// Default discovery wait time
|
|
//
|
|
#define DEFAULT_WAIT_TIME (30000L) // 30 seconds
|
|
|
|
|
|
|
|
class CServiceInfo : public CObjectPlus
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
Service info descriptor class. This is used for downlevel ISM objects.
|
|
|
|
Public Interface:
|
|
|
|
CServiceInfo : Constructor
|
|
~CServiceInfo : Destructor
|
|
|
|
QueryInstanceHandle : Get the instance handle of the config dll
|
|
for this service
|
|
QueryISMVersion : Get the ISM version the config DLL was written
|
|
for.
|
|
QueryDiscoveryMask : Get the inetsloc discovery mask
|
|
QueryButtonBkMask : Get the background mask for the toolbar button
|
|
QueryButtonBitmapID : Get the toolbar button resource ID
|
|
QueryServiceBkMask : Get the background mask for the view
|
|
QueryServiceBitmapID : Get the view bitmap resource ID
|
|
QueryServiceID : Get the service ID assigned to this service
|
|
GetShortName : Get the short name of the service
|
|
GetLongName : Get the full name of the service
|
|
UseInetSlocDiscover : TRUE if the service uses inetsloc discovery
|
|
CanControlService : TRUE if the service is controllable
|
|
CanPauseService : TRUE if the service is pausable
|
|
UseNormalColorMapping : TRUE if normal colour mapping should be used
|
|
SupportsInstances : TRUE if the service has instances
|
|
SupportsChildren : TRUE if the service has children
|
|
UnderstandsInstanceCodes : TRUE if instance ID codes are understood.
|
|
HasWebProtocol : TRYE if the service supports a web protocol name
|
|
IsSelected : TRUE if the service type is selected in the
|
|
toolbar.
|
|
SelectService : Set the selection state of the service
|
|
QueryReturnCode : Get the error return code of the service
|
|
InitializedOK : TRUE if the service config DLL was initialized
|
|
OK.
|
|
|
|
ISMQueryServiceInfo : Call the query service info API
|
|
ISMDiscoverServers : Call the discover servers API
|
|
ISMQueryServerInfo : Call the query server info API
|
|
ISMChangeServiceState : Call the change service state API
|
|
ISMConfigureServers : Call the configure server API
|
|
ISMEnumerateInstances : Call the enumerate instances API
|
|
ISMConfigureChild : Call the configure child API
|
|
|
|
--*/
|
|
{
|
|
protected:
|
|
//
|
|
// ISM Method prototype
|
|
//
|
|
typedef HRESULT (APIENTRY * pfnISMMethod)(...);
|
|
|
|
//
|
|
// ISM Method Definition
|
|
//
|
|
typedef struct tagISM_METHOD_DEF
|
|
{
|
|
int iID;
|
|
BOOL fMustHave;
|
|
LPCSTR lpszMethodName;
|
|
} ISM_METHOD_DEF;
|
|
|
|
//
|
|
// VTable entry IDs
|
|
//
|
|
enum
|
|
{
|
|
ISM_QUERY_SERVICE_INFO,
|
|
ISM_DISCOVER_SERVERS,
|
|
ISM_QUERY_SERVER_INFO,
|
|
ISM_CHANGE_SERVICE_STATE,
|
|
ISM_CONFIGURE,
|
|
ISM_BIND,
|
|
ISM_UNBIND,
|
|
ISM_CONFIGURE_CHILD,
|
|
ISM_ENUMERATE_INSTANCES,
|
|
ISM_ENUMERATE_CHILDREN,
|
|
ISM_ADD_INSTANCE,
|
|
ISM_DELETE_INSTANCE,
|
|
ISM_ADD_CHILD,
|
|
ISM_DELETE_CHILD,
|
|
ISM_RENAME_CHILD,
|
|
ISM_QUERY_INSTANCE_INFO,
|
|
ISM_QUERY_CHILD_INFO,
|
|
ISM_MMC_CONFIGURE,
|
|
ISM_MMC_CONFIGURE_CHILD,
|
|
ISM_SECURITY_WIZARD,
|
|
/* Don't move this one */
|
|
ISM_NUM_METHODS
|
|
};
|
|
|
|
//
|
|
// ISM Method VTable Definition
|
|
//
|
|
static ISM_METHOD_DEF s_imdMethods[ISM_NUM_METHODS];
|
|
|
|
//
|
|
// Construction/Destruction
|
|
//
|
|
public:
|
|
//
|
|
// Construct with DLL Name and a sequential unique
|
|
// ID Number.
|
|
//
|
|
CServiceInfo(
|
|
IN int nID,
|
|
IN LPCTSTR lpDLLName
|
|
);
|
|
|
|
~CServiceInfo();
|
|
|
|
//
|
|
// Access Functions
|
|
//
|
|
public:
|
|
//
|
|
// Get the instance handle
|
|
//
|
|
HINSTANCE QueryInstanceHandle() const { return m_hModule; }
|
|
|
|
//
|
|
// Get the ISM version number
|
|
//
|
|
DWORD QueryISMVersion() const { return m_si.dwVersion; }
|
|
|
|
//
|
|
// Get the discovery mask
|
|
//
|
|
ULONGLONG QueryDiscoveryMask() const { return m_si.ullDiscoveryMask; }
|
|
|
|
//
|
|
// Get toolbar background button mask for this service
|
|
//
|
|
COLORREF QueryButtonBkMask() const { return m_si.rgbButtonBkMask; }
|
|
|
|
//
|
|
// Get toolbar button bitmap id for this service
|
|
//
|
|
UINT QueryButtonBitmapID() const { return m_si.nButtonBitmapID; }
|
|
|
|
//
|
|
// Get the colour background mask for this service
|
|
//
|
|
COLORREF QueryServiceBkMask() const { return m_si.rgbServiceBkMask; }
|
|
|
|
//
|
|
// Get the resource ID for the service bitmap for this service
|
|
//
|
|
UINT QueryServiceBitmapID() const { return m_si.nServiceBitmapID; }
|
|
|
|
//
|
|
// Return TRUE if the service has 32x32 bitmap id
|
|
//
|
|
BOOL HasLargeServiceBitmapID() const { return m_si.nLargeServiceBitmapID != 0; }
|
|
|
|
//
|
|
// Get the large service bitmap background colour mask
|
|
//
|
|
COLORREF QueryLargeServiceBkMask() const { return m_si.rgbLargeServiceBkMask; }
|
|
|
|
//
|
|
// Get the resource ID of the large service bitmap
|
|
//
|
|
UINT QueryLargeServiceBitmapID() const { return m_si.nLargeServiceBitmapID; }
|
|
|
|
//
|
|
// Get the colour background mask for the child bitmap
|
|
//
|
|
COLORREF QueryChildBkMask() const { return m_si.rgbChildBkMask; }
|
|
|
|
//
|
|
// Get the bitmap ID for a child node
|
|
//
|
|
UINT QueryChildBitmapID() const { return m_si.nChildBitmapID; }
|
|
|
|
//
|
|
// Get the background colour mask for the large child bitmap
|
|
//
|
|
COLORREF QueryLargeChildBkMask() const { return m_si.rgbLargeChildBkMask; }
|
|
|
|
//
|
|
// Get the resource ID for the large child bitmap
|
|
//
|
|
UINT QueryLargeChildBitmapID() const { return m_si.nLargeChildBitmapID; }
|
|
|
|
//
|
|
// Get the ID assigned to this service
|
|
//
|
|
int QueryServiceID() const { return m_nID; }
|
|
|
|
//
|
|
// Get the short name for this service
|
|
//
|
|
LPCTSTR GetShortName() const { return m_si.atchShortName; }
|
|
|
|
//
|
|
// Get the longer name for this service
|
|
//
|
|
LPCTSTR GetLongName() const { return m_si.atchLongName; }
|
|
|
|
//
|
|
// Get the protocol for this service (if any)
|
|
//
|
|
LPCTSTR GetProtocol() const { return m_si.atchProtocol; }
|
|
|
|
//
|
|
// Get the metabase service name (if any)
|
|
//
|
|
LPCTSTR GetMetabaseName() const { return m_si.atchMetaBaseName; }
|
|
|
|
//
|
|
// Access Service Type Functions
|
|
//
|
|
public:
|
|
//
|
|
// TRUE if the service is a downlevel replacement service
|
|
//
|
|
BOOL RequiresSuperDll() const { return !m_strSupDLLName.IsEmpty(); }
|
|
BOOL IsSuperDllFor(CServiceInfo * pTarget) const;
|
|
BOOL HasSuperDll() const { return m_psiMaster != NULL; }
|
|
void AssignSuperDll(CServiceInfo * pTarget);
|
|
CServiceInfo * GetSuperDll();
|
|
LPCTSTR QueryDllName() const { return m_strDLLName; }
|
|
|
|
BOOL UseInetSlocDiscover() const;
|
|
|
|
//
|
|
// Return TRUE if the service is controllable
|
|
//
|
|
BOOL CanControlService() const;
|
|
|
|
//
|
|
// Return TRUE if the service is pausable
|
|
//
|
|
BOOL CanPauseService() const;
|
|
|
|
//
|
|
// Return TRUE if the service and toolbar bitmaps use default
|
|
// background colour mapping (the background colour masks
|
|
// will be ignored)
|
|
//
|
|
BOOL UseNormalColorMapping() const;
|
|
|
|
//
|
|
// True if the service supports file and directory properties
|
|
//
|
|
BOOL SupportsFileSystem() const;
|
|
|
|
//
|
|
// Does the service support Instances
|
|
//
|
|
BOOL SupportsInstances() const;
|
|
|
|
//
|
|
// Does the service support children
|
|
//
|
|
BOOL SupportsChildren() const;
|
|
|
|
//
|
|
// TRUE if the service supports the security wizard
|
|
//
|
|
BOOL SupportsSecurityWizard() const;
|
|
|
|
//
|
|
// Does the service understance instance ID codes
|
|
// -- eventhough it may not actually support
|
|
// instances
|
|
//
|
|
BOOL UnderstandsInstanceCodes() const;
|
|
|
|
//
|
|
// TRUE if the service supports prot://address browsing
|
|
//
|
|
BOOL HasWebProtocol() const;
|
|
|
|
//
|
|
// Use MMC property pages to show the property sheet for this
|
|
// service?
|
|
//
|
|
BOOL SupportsMMC() const;
|
|
|
|
//
|
|
// Does the service support the extended K2 services?
|
|
//
|
|
BOOL IsK2Service() const;
|
|
|
|
//
|
|
// Is this service currently selected to be in
|
|
// the service view?
|
|
//
|
|
BOOL IsSelected() const { return m_fIsSelected; }
|
|
|
|
//
|
|
// Select/Deselect this service
|
|
//
|
|
void SelectService(
|
|
IN BOOL fSelected = TRUE
|
|
);
|
|
|
|
//
|
|
// Get error return code
|
|
//
|
|
HRESULT QueryReturnCode() const { return m_hrReturnCode; }
|
|
|
|
//
|
|
// Was the module loaded, and all function ptrs initialised?
|
|
//
|
|
BOOL InitializedOK() const { return SUCCEEDED(m_hrReturnCode); }
|
|
|
|
//
|
|
// The bitmap indices refer to the index in inetmgr's
|
|
// master image list where they are stored, and have nothing
|
|
// to do with the resource IDs
|
|
//
|
|
public:
|
|
//
|
|
// Get the inetmgr assigned index for the service bitmap
|
|
//
|
|
int QueryBitmapIndex() const { return m_iBmpID; }
|
|
|
|
//
|
|
// Get the inetmgr assigned index for the child
|
|
//
|
|
int QueryChildBitmapIndex() const { return m_iBmpChildID; }
|
|
|
|
//
|
|
// Assign the service bitmap index
|
|
//
|
|
void SetBitmapIndex(IN int iID);
|
|
|
|
//
|
|
// Assign the child bitmap index
|
|
//
|
|
void SetChildBitmapIndex(IN int iID);
|
|
|
|
//
|
|
// ISM API Functions
|
|
//
|
|
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
|
public:
|
|
|
|
//
|
|
// Return service-specific information back to
|
|
// to the application. This function is called
|
|
// by the service manager immediately after
|
|
// LoadLibary();
|
|
//
|
|
DWORD ISMQueryServiceInfo(
|
|
OUT ISMSERVICEINFO * psi // Service information returned.
|
|
);
|
|
|
|
//
|
|
// Perform a discovery (if not using inetsloc discovery)
|
|
// The application will call this API the first time with
|
|
// a BufferSize of 0, which should return the required buffer
|
|
// size. Next it will attempt to allocate a buffer of that
|
|
// size, and then pass a pointer to that buffer to the api.
|
|
//
|
|
DWORD ISMDiscoverServers(
|
|
OUT ISMSERVERINFO * psi, // Server info buffer.
|
|
IN OUT DWORD * pdwBufferSize, // Size required/available.
|
|
OUT int * cServers // Number of servers in buffer.
|
|
);
|
|
|
|
//
|
|
// Get information on a single server with regards to
|
|
// this service.
|
|
//
|
|
DWORD ISMQueryServerInfo(
|
|
IN LPCTSTR lpszServerName, // Name of server.
|
|
OUT ISMSERVERINFO * psi // Server information returned.
|
|
);
|
|
|
|
//
|
|
// Change the state of the service (started, stopped, paused) for the
|
|
// listed servers.
|
|
//
|
|
DWORD ISMChangeServiceState(
|
|
IN int nNewState, // INetService* definition.
|
|
OUT int * pnCurrentState, // Current state information
|
|
IN DWORD dwInstance, // /* K2 */ -- Instance number
|
|
// (0 - for non-instance)
|
|
IN LPCTSTR lpszServers // Double NULL terminated list of servers.
|
|
);
|
|
|
|
//
|
|
// The big-one: Show the configuration dialog or
|
|
// property sheets, whatever, and allow the user
|
|
// to make changes as needed.
|
|
//
|
|
DWORD ISMConfigureServers(
|
|
IN HWND hWnd, // Main app window handle
|
|
IN DWORD dwInstance, // /* K2 */ -- Instance number
|
|
// (0 - for non-instance)
|
|
IN LPCTSTR lpszServers // Double NULL terminated list of servers
|
|
);
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// K2 Methods Below //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
// Bind to a server, and return a HANDLE. This handle is
|
|
// merely an opaque identifier that's meaningful to the
|
|
// service configuration module.
|
|
//
|
|
HRESULT ISMBind(
|
|
IN LPCTSTR lpszServer, // Server name
|
|
OUT HANDLE *phServer // Returns handle
|
|
);
|
|
|
|
//
|
|
// Sever the connection. The service configuration
|
|
// module does whatever needs to be done to cleanup
|
|
//
|
|
HRESULT ISMUnbind(
|
|
IN HANDLE hServer // Server handle
|
|
);
|
|
|
|
//
|
|
// Enumerate instances
|
|
//
|
|
HRESULT ISMEnumerateInstances(
|
|
IN HANDLE hServer, // Server handle
|
|
IN OUT ISMINSTANCEINFO * pii, // Instance info buffer
|
|
IN OUT HANDLE * pdwEnum // Enumeration handle
|
|
);
|
|
|
|
//
|
|
// Add an instance
|
|
//
|
|
HRESULT ISMAddInstance(
|
|
IN HANDLE hServer, // Server handle
|
|
IN DWORD dwSourceInstance, // Source instance ID to clone
|
|
OUT ISMINSTANCEINFO * pii, // Instance info buffer. May be NULL
|
|
IN DWORD dwBufferSize // Size of buffer
|
|
);
|
|
|
|
//
|
|
// Delete an instance
|
|
//
|
|
HRESULT ISMDeleteInstance(
|
|
IN HANDLE hServer, // Server handle
|
|
IN DWORD dwInstance // Instance to be deleted
|
|
);
|
|
|
|
//
|
|
// Get instance specific information.
|
|
//
|
|
HRESULT ISMQueryInstanceInfo(
|
|
IN HANDLE hServer, // Server handle
|
|
IN BOOL fInherit, // TRUE to inherit, FALSE otherwise
|
|
OUT ISMINSTANCEINFO * pii, // Instance info buffer
|
|
IN DWORD dwInstance // Instance number
|
|
);
|
|
|
|
//
|
|
// Enumerate children.
|
|
//
|
|
HRESULT ISMEnumerateChildren(
|
|
IN HANDLE hServer, // Server handle
|
|
IN OUT ISMCHILDINFO * pii, // Child info buffer
|
|
IN OUT HANDLE * phEnum, // Enumeration handle
|
|
IN DWORD dwInstance, // Instance
|
|
IN LPCTSTR lpszParent // Parent path
|
|
);
|
|
|
|
//
|
|
// Add a child
|
|
//
|
|
HRESULT ISMAddChild(
|
|
IN HANDLE hServer, // Server handle
|
|
OUT ISMCHILDINFO * pii, // Child info buffer
|
|
IN DWORD dwBufferSize, // Size of info buffer
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent // Parent path
|
|
);
|
|
|
|
//
|
|
// Delete a child
|
|
//
|
|
HRESULT ISMDeleteChild(
|
|
IN HANDLE hServer, // Server handle
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias // Alias of child to be deleted
|
|
);
|
|
|
|
//
|
|
// Rename a child
|
|
//
|
|
HRESULT ISMRenameChild(
|
|
IN HANDLE hServer, // Server handle
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias, // Alias of child to be renamed
|
|
IN LPCTSTR lpszNewName // New alias of child
|
|
);
|
|
|
|
//
|
|
// Configure Child
|
|
//
|
|
HRESULT ISMConfigureChild(
|
|
IN HANDLE hServer, // Server handle
|
|
IN HWND hWnd, // Main app window handle
|
|
IN DWORD dwAttributes, // Child attributes
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias // Child alias
|
|
);
|
|
|
|
//
|
|
// Get child-specific info
|
|
//
|
|
HRESULT ISMQueryChildInfo(
|
|
IN HANDLE hServer, // Server handle
|
|
IN BOOL fInherit, // TRUE to inherit, FALSE otherwise
|
|
OUT ISMCHILDINFO * pii, // Child info buffer
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent Path ("" for root)
|
|
IN LPCTSTR lpszAlias // Alias of child to be deleted
|
|
);
|
|
|
|
//
|
|
// Configure servers using MMC property pages
|
|
//
|
|
HRESULT ISMMMCConfigureServers(
|
|
IN HANDLE hServer, // Server handle
|
|
IN PVOID lpfnProvider, // MMC Parameter
|
|
IN LPARAM param, // MMC Parameter
|
|
IN LONG_PTR handle, // MMC Parameter
|
|
IN DWORD dwInstance // Instance number
|
|
);
|
|
|
|
//
|
|
// Configure Child using MMC property pages
|
|
//
|
|
HRESULT ISMMMCConfigureChild(
|
|
IN HANDLE hServer, // Server handle
|
|
IN PVOID lpfnProvider, // MMC Parameter
|
|
IN LPARAM param, // MMC Parameter
|
|
IN LONG_PTR handle, // MMC Parameter
|
|
IN DWORD dwAttributes, // Child attributes
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias // Child alias
|
|
);
|
|
|
|
//
|
|
// Launch security wizard
|
|
//
|
|
HRESULT ISMSecurityWizard(
|
|
HANDLE hServer, // Server handle
|
|
DWORD dwInstance, // Instance number
|
|
LPCTSTR lpszParent, // Parent path
|
|
LPCTSTR lpszAlias // Child alias name
|
|
);
|
|
|
|
//
|
|
// Function Pointers
|
|
//
|
|
protected:
|
|
|
|
#ifdef USE_VTABLE
|
|
|
|
//
|
|
// ISM Method VTable
|
|
//
|
|
pfnISMMethod m_rgpfnISMMethods[ISM_NUM_METHODS];
|
|
|
|
#else // !USE_VTABLE
|
|
|
|
//
|
|
// ISM Api Function pointers
|
|
//
|
|
pfnQueryServiceInfo m_pfnQueryServiceInfo;
|
|
pfnDiscoverServers m_pfnDiscoverServers;
|
|
pfnQueryServerInfo m_pfnQueryServerInfo;
|
|
pfnChangeServiceState m_pfnChangeServiceState;
|
|
pfnConfigure m_pfnConfigure;
|
|
pfnBind m_pfnBind;
|
|
pfnUnbind m_pfnUnbind;
|
|
pfnConfigureChild m_pfnConfigureChild;
|
|
pfnEnumerateInstances m_pfnEnumerateInstances;
|
|
pfnEnumerateChildren m_pfnEnumerateChildren;
|
|
pfnAddInstance m_pfnAddInstance;
|
|
pfnDeleteInstance m_pfnDeleteInstance;
|
|
pfnAddChild m_pfnAddChild;
|
|
pfnDeleteChild m_pfnDeleteChild;
|
|
pfnRenameChild m_pfnRenameChild;
|
|
pfnQueryInstanceInfo m_pfnQueryInstanceInfo;
|
|
pfnQueryChildInfo m_pfnQueryChildInfo;
|
|
pfnISMMMCConfigureServers m_pfnISMMMCConfigureServers;
|
|
pfnISMMMCConfigureChild m_pfnISMMMCConfigureChild;
|
|
pfnISMSecurityWizard m_pfnISMSecurityWizard;
|
|
|
|
#endif // USE_VTABLE
|
|
|
|
protected:
|
|
static LPCTSTR s_cszSupcfg;
|
|
|
|
protected:
|
|
CServiceInfo * m_psiMaster;
|
|
|
|
private:
|
|
int m_nID; // Service ID
|
|
int m_iBmpID; // Bitmap ID index
|
|
int m_iBmpChildID; // Child bitmap ID index
|
|
CString m_strDLLName; // DLL Name
|
|
CString m_strSupDLLName; // Superceed configuration DLL name.
|
|
ISMSERVICEINFO m_si; // Service Info.
|
|
HINSTANCE m_hModule; // Library handle
|
|
HRESULT m_hrReturnCode;
|
|
BOOL m_fIsSelected;
|
|
};
|
|
|
|
|
|
|
|
class CNewInstanceCmd : public CObjectPlus
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
New instance command object. MMC adds these items at the machine
|
|
node level for create new.
|
|
|
|
Public Interface:
|
|
|
|
CNewInstanceCmd : Constructor
|
|
|
|
GetServiceInfo : Get the service info object
|
|
GetMenuCommand : Get the menu command that describes this object
|
|
GetTTText : Get the tool tips text
|
|
|
|
--*/
|
|
{
|
|
public:
|
|
CNewInstanceCmd(
|
|
IN CServiceInfo * pServiceInfo
|
|
);
|
|
|
|
public:
|
|
CServiceInfo * GetServiceInfo() { return m_pServiceInfo; }
|
|
CString & GetMenuCommand() { return m_strMenuCommand; }
|
|
CString & GetTTText() { return m_strTTText; }
|
|
|
|
HINSTANCE QueryInstanceHandle();
|
|
|
|
private:
|
|
CServiceInfo * m_pServiceInfo;
|
|
CString m_strMenuCommand;
|
|
CString m_strTTText;
|
|
};
|
|
|
|
|
|
|
|
class CServerInfo : public CObjectPlus
|
|
{
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
Server info class. Each object describes a single server/service
|
|
relationship.
|
|
|
|
Public Interface:
|
|
|
|
CServerInfo : Various constructors
|
|
~CServerInfo : Destructor
|
|
|
|
operator= : Assignment operator
|
|
CompareByServer : Comparison function to compare server names
|
|
CompareByService : Comparison function to compare services
|
|
operator == : Comparison operator
|
|
CleanServerName : Static function to clean up a computer/hostname
|
|
ConfigureServer : Configure instance on this this server
|
|
ConfigureChild : Configure child on this server
|
|
ChangeServiceState : Change the server or instance state
|
|
QueryServerName : Return the API-suitable name
|
|
QueryServerDisplayName : Get the display name of the server
|
|
GetServerComment : Get the server comment
|
|
GetServiceStatePtr : Get service state pointer
|
|
QueryServiceState : Find out service state (running,
|
|
paused, stopped, unknown)
|
|
IsServiceRunning : TRUE if the service is running
|
|
IsServiceStopped : TRUE if the service is stopped
|
|
IsServicePaused : TRUE if the service is paused
|
|
IsServiceStatusUnknown : TRUE if the service status cannot be determined
|
|
IsConfigurable : TRUE if the service is configurable
|
|
|
|
QueryInstanceHandle : Get the config DLL instance handle
|
|
IsServiceSelected : TRUE if the service is selected in the toolbar
|
|
GetServiceName : Get the (short) service name.
|
|
QueryServiceID : Get ID code assigned to the config DLL
|
|
CanControlService : TRUE if this service controllable
|
|
CanPauseService : TRUE if this service is pausable
|
|
SupportsInstances : TRUE if the service supports instances
|
|
SupportsChildren : TRUE if the service supports children
|
|
UnderstandsInstanceCodes : TRUE if the service understands instance IDs
|
|
QueryServiceBitmapID : Get the bitmap resource ID of the service
|
|
Refresh : Refresh information
|
|
|
|
--*/
|
|
//
|
|
// Construction/Destruction
|
|
//
|
|
public:
|
|
//
|
|
// Construct with a server name. This is typically
|
|
// in response to a single connection attempt.
|
|
//
|
|
CServerInfo(
|
|
IN LPCTSTR lpszServerName, // Name of this server
|
|
OUT ISMSERVERINFO * psi, // Server info
|
|
IN CServiceInfo * pServiceInfo // service that found it.
|
|
);
|
|
|
|
//
|
|
// Construct with information from the inetsloc discover
|
|
// process.
|
|
//
|
|
CServerInfo(
|
|
IN LPCSTR lpszServerName, // Name of this server
|
|
IN LPINET_SERVICE_INFO lpisi, // Discovery information
|
|
IN CObListPlus & oblServices // List of installed services
|
|
);
|
|
|
|
//
|
|
// Copy constructor
|
|
//
|
|
CServerInfo(
|
|
IN const CServerInfo &si
|
|
);
|
|
|
|
~CServerInfo();
|
|
|
|
//
|
|
// Assignment operator
|
|
//
|
|
const CServerInfo & operator=(
|
|
IN const CServerInfo &si
|
|
);
|
|
|
|
//
|
|
// Comparison Functions and operators
|
|
//
|
|
int CompareByServer(IN CServerInfo * psi) const;
|
|
|
|
//
|
|
// Compare server names
|
|
//
|
|
BOOL MatchServerName(IN LPCTSTR lpszServerName) const;
|
|
|
|
//
|
|
// Compare two services
|
|
//
|
|
int CompareByService(IN CServerInfo * psi);
|
|
|
|
//
|
|
// Compare two service
|
|
//
|
|
BOOL operator ==(
|
|
IN CServerInfo & si
|
|
);
|
|
|
|
public:
|
|
//
|
|
// Utility function to clean up a computer/hostname
|
|
//
|
|
static LPCTSTR CleanServerName(
|
|
IN CString & str
|
|
);
|
|
|
|
//
|
|
// Server Info Access Functions
|
|
//
|
|
public:
|
|
//
|
|
// Perform configuration on this server
|
|
//
|
|
DWORD ConfigureServer(
|
|
IN HWND hWnd, // Window handle
|
|
IN DWORD dwInstance = MASTER_INSTANCE // Instance number
|
|
);
|
|
|
|
//
|
|
// Configure servers using MMC property pages
|
|
//
|
|
HRESULT MMMCConfigureServer(
|
|
IN PVOID lpfnProvider, // MMC Parameter
|
|
IN LPARAM param, // MMC Parameter
|
|
IN LONG_PTR handle, // MMC Parameter
|
|
IN DWORD dwInstance // Instance number
|
|
);
|
|
|
|
//
|
|
// Perform configuration on a child
|
|
//
|
|
HRESULT ConfigureChild(
|
|
IN HWND hWnd, // Window handle
|
|
IN DWORD dwAttributes, // Child attributes
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias // Child alias
|
|
);
|
|
|
|
//
|
|
// Perform configuration on a child using MMC property pages
|
|
//
|
|
HRESULT MMCConfigureChild(
|
|
IN PVOID lpfnProvider, // MMC parameter
|
|
IN LPARAM param, // MMC parameter
|
|
IN LONG_PTR handle, // MMC parameter
|
|
IN DWORD dwAttributes, // Child attributes
|
|
IN DWORD dwInstance, // Instance number
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias // Child alias
|
|
);
|
|
|
|
//
|
|
// Rename a child node
|
|
//
|
|
HRESULT RenameChild(
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias, // Alias of child to be renamed
|
|
IN LPCTSTR lpszNewName // New alias of child
|
|
);
|
|
|
|
//
|
|
// Add a child
|
|
//
|
|
HRESULT AddChild(
|
|
IN ISMCHILDINFO * pii, // Child info buffer or NULL
|
|
IN DWORD dwBufferSize, // Size of info buffer
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent // Parent Path ("" for root)
|
|
);
|
|
|
|
//
|
|
// Delete a child
|
|
//
|
|
HRESULT DeleteChild(
|
|
IN DWORD dwInstance, // Parent instance
|
|
IN LPCTSTR lpszParent, // Parent Path ("" for root)
|
|
IN LPCTSTR lpszAlias // Alias of child to be deleted
|
|
);
|
|
|
|
//
|
|
// Get instance specific information
|
|
//
|
|
HRESULT QueryInstanceInfo(
|
|
IN BOOL fInherit, // TRUE to inherit,
|
|
// FALSE otherwise
|
|
OUT ISMINSTANCEINFO * pii, // Returns instance info
|
|
IN DWORD dwInstance // Instance number
|
|
);
|
|
|
|
//
|
|
// Get child specific information
|
|
//
|
|
HRESULT QueryChildInfo(
|
|
IN BOOL fInherit, // TRUE to inherit,
|
|
// FALSE otherwise
|
|
OUT ISMCHILDINFO * pii, // Returns child info
|
|
IN DWORD dwInstance, // Instance number
|
|
IN LPCTSTR lpszParent, // Parent path
|
|
IN LPCTSTR lpszAlias // Alias name
|
|
);
|
|
|
|
//
|
|
// Add an instance
|
|
//
|
|
HRESULT AddInstance(
|
|
OUT ISMINSTANCEINFO * pii, // Instance info buffer or NULL
|
|
IN DWORD dwBufferSize // Size of buffer
|
|
);
|
|
|
|
//
|
|
// Delete an instance
|
|
//
|
|
HRESULT DeleteInstance(
|
|
IN DWORD dwInstance // Instance to be deleted
|
|
);
|
|
|
|
//
|
|
// Enumerate children.
|
|
//
|
|
HRESULT ISMEnumerateChildren(
|
|
IN OUT ISMCHILDINFO * pii, // Child info buffer
|
|
IN OUT HANDLE * phEnum, // Enumeration handle
|
|
IN DWORD dwInstance, // Instance
|
|
IN LPCTSTR lpszParent // Parent path
|
|
);
|
|
|
|
//
|
|
// Enumerate instances
|
|
//
|
|
HRESULT ISMEnumerateInstances(
|
|
IN OUT ISMINSTANCEINFO * pii, // Instance info buffer
|
|
IN OUT HANDLE * pdwEnum // Enumeration handle
|
|
);
|
|
|
|
//
|
|
// Launch security wizard
|
|
//
|
|
HRESULT ISMSecurityWizard(
|
|
DWORD dwInstance, // Instance number
|
|
LPCTSTR lpszParent, // Parent path
|
|
LPCTSTR lpszAlias // Child alias name
|
|
);
|
|
|
|
//
|
|
// Change service state
|
|
//
|
|
DWORD ChangeServiceState(
|
|
IN int nNewState, // New state to set
|
|
OUT int * pnCurrentState, // Returns current state
|
|
IN DWORD dwInstance = MASTER_INSTANCE // Instance number
|
|
);
|
|
|
|
//
|
|
// Return the API-suitable name (with
|
|
// backslashes)
|
|
//
|
|
LPCTSTR QueryServerName() const { return (LPCTSTR)m_strServerName; }
|
|
|
|
//
|
|
// Return the name without backslashes,
|
|
// suitable for display.
|
|
//
|
|
LPCTSTR QueryServerDisplayName() const;
|
|
|
|
//
|
|
// Obtain the server comment
|
|
//
|
|
CString & GetServerComment() { return m_strComment; }
|
|
|
|
//
|
|
// Allow modification
|
|
//
|
|
int * GetServiceStatePtr() { return &m_nServiceState; }
|
|
|
|
//
|
|
// Find out service state (running, stopped, paused)
|
|
//
|
|
int QueryServiceState() const { return m_nServiceState; }
|
|
|
|
//
|
|
// Return TRUE if the service is currently running
|
|
//
|
|
BOOL IsServiceRunning() const;
|
|
|
|
//
|
|
// Return TRUE if the service is currently stopped
|
|
//
|
|
BOOL IsServiceStopped() const;
|
|
|
|
//
|
|
// Return TRUE if the service is currently paused
|
|
//
|
|
BOOL IsServicePaused() const;
|
|
|
|
//
|
|
// Return TRUE if the service status is unknown
|
|
//
|
|
BOOL IsServiceStatusUnknown() const;
|
|
|
|
//
|
|
// Were we able to match it up to one of our installed services?
|
|
//
|
|
BOOL IsConfigurable() const { return m_pService != NULL; }
|
|
|
|
//
|
|
// Service Info Access Functions
|
|
//
|
|
public:
|
|
|
|
//
|
|
// Attempt to rebind lost connection...
|
|
//
|
|
HRESULT ISMRebind();
|
|
|
|
//
|
|
// Get the service info object
|
|
//
|
|
CServiceInfo * GetServiceInfo() { return m_pService; }
|
|
|
|
//
|
|
// Get the short name for this service
|
|
//
|
|
LPCTSTR GetShortName() const;
|
|
|
|
//
|
|
// Get the longer name for this service
|
|
//
|
|
LPCTSTR GetLongName() const;
|
|
|
|
//
|
|
// Get Server Handle
|
|
//
|
|
HANDLE GetHandle() { return m_hServer; }
|
|
|
|
//
|
|
// Get the protocol for this service (if any)
|
|
//
|
|
LPCTSTR GetProtocol() const;
|
|
|
|
//
|
|
// Get the metabase name for this service (if any)
|
|
//
|
|
LPCTSTR GetMetabaseName() const;
|
|
|
|
//
|
|
// Get the instance handle for the dll
|
|
//
|
|
HINSTANCE QueryInstanceHandle();
|
|
|
|
//
|
|
// Check to see if we're in the service mask -- that
|
|
// is, is the button depressed, and should we show
|
|
// this service in the view?
|
|
//
|
|
BOOL IsServiceSelected() const;
|
|
|
|
//
|
|
// Get the (short) service name.
|
|
//
|
|
LPCTSTR GetServiceName() const;
|
|
|
|
//
|
|
// Get the assigned service ID
|
|
//
|
|
int QueryServiceID() const;
|
|
|
|
//
|
|
// Get the assigned bitmap index for this service
|
|
//
|
|
int QueryBitmapIndex() const;
|
|
|
|
//
|
|
// Get the assigned child bitmap index
|
|
//
|
|
int QueryChildBitmapIndex() const;
|
|
|
|
//
|
|
// Is this service controllable?
|
|
//
|
|
BOOL CanControlService() const;
|
|
|
|
//
|
|
// Is the service pausable?
|
|
//
|
|
BOOL CanPauseService() const;
|
|
|
|
//
|
|
// Does the service support instances?
|
|
//
|
|
BOOL SupportsInstances() const;
|
|
|
|
//
|
|
// Does the service support children?
|
|
//
|
|
BOOL SupportsChildren() const;
|
|
|
|
//
|
|
// Use file system?
|
|
//
|
|
BOOL SupportsFileSystem() const;
|
|
|
|
//
|
|
// TRUE if the service supports a security wizard
|
|
//
|
|
BOOL SupportsSecurityWizard() const;
|
|
|
|
//
|
|
// Does the service understance instance ID codes
|
|
// -- eventhough it may not actually support
|
|
// instances
|
|
//
|
|
BOOL UnderstandsInstanceCodes() const;
|
|
|
|
//
|
|
// TRUE if the service supports prot://address browsing
|
|
//
|
|
BOOL HasWebProtocol() const;
|
|
|
|
//
|
|
// Use MMC property pages to show the property sheet for this
|
|
// service?
|
|
//
|
|
BOOL SupportsMMC() const;
|
|
|
|
//
|
|
// Does the service support the extended K2 services?
|
|
//
|
|
BOOL IsK2Service() const;
|
|
|
|
//
|
|
// Get the service bitmap ID (used for display
|
|
// in some views)
|
|
//
|
|
UINT QueryServiceBitmapID() const;
|
|
|
|
//
|
|
// Refresh information
|
|
//
|
|
DWORD Refresh();
|
|
|
|
protected:
|
|
//
|
|
// Given the inetsloc mask, return the service this
|
|
// fits. Return NULL if the service was not found.
|
|
//
|
|
static CServiceInfo * FindServiceByMask(
|
|
ULONGLONG ullTarget,
|
|
CObListPlus & oblServices
|
|
);
|
|
|
|
private:
|
|
//
|
|
// Name is maintained in API friendly format
|
|
//
|
|
CString m_strServerName;
|
|
|
|
//
|
|
// Maintain server handle for K2 services
|
|
//
|
|
HANDLE m_hServer;
|
|
|
|
//
|
|
// comment
|
|
//
|
|
CString m_strComment;
|
|
|
|
//
|
|
// Service state (started/stopped/paused)
|
|
//
|
|
int m_nServiceState;
|
|
|
|
//
|
|
// A pointer referring back to the service that
|
|
// it belongs to. This class does not own
|
|
// this pointer.
|
|
//
|
|
CServiceInfo * m_pService;
|
|
};
|
|
|
|
|
|
|
|
class CSnapinApp : public CWinApp
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
Main app object
|
|
|
|
Public Interface:
|
|
|
|
InitInstance : Instance initiation handler
|
|
ExitInstance : Exit instance handler
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Initialization
|
|
//
|
|
public:
|
|
CSnapinApp();
|
|
|
|
public:
|
|
virtual BOOL InitInstance();
|
|
virtual int ExitInstance();
|
|
|
|
//
|
|
// Access
|
|
//
|
|
public:
|
|
void SetHelpPath(CServerInfo * pItem = NULL);
|
|
LPCTSTR QueryInetMgrHelpPath() const { return m_strInetMgrHelpPath; }
|
|
|
|
protected:
|
|
//{{AFX_MSG(CSnapinApp)
|
|
afx_msg void OnHelp();
|
|
afx_msg void OnContextHelp();
|
|
//}}AFX_MSG
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
private:
|
|
LPCTSTR m_lpOriginalHelpPath;
|
|
CString m_strHelpPath;
|
|
CString m_strInetMgrHelpPath;
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// Inline Expansion
|
|
//
|
|
// <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
|
|
|
|
inline BOOL CServiceInfo::IsSuperDllFor(CServiceInfo * pTarget) const
|
|
{
|
|
return pTarget->m_strSupDLLName.CompareNoCase(m_strDLLName) == 0;
|
|
}
|
|
|
|
inline void CServiceInfo::AssignSuperDll(CServiceInfo * pTarget)
|
|
{
|
|
ASSERT(m_psiMaster == NULL);
|
|
m_psiMaster = pTarget;
|
|
}
|
|
|
|
inline CServiceInfo * CServiceInfo::GetSuperDll()
|
|
{
|
|
ASSERT(m_psiMaster != NULL);
|
|
return m_psiMaster;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::UseInetSlocDiscover() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_INETSLOCDISCOVER) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::CanControlService() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_CANCONTROLSERVICE) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::CanPauseService() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_CANPAUSESERVICE) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::UseNormalColorMapping() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_NORMALTBMAPPING) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::SupportsFileSystem() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_FILESYSTEM) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::SupportsSecurityWizard() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_SECURITYWIZARD) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::SupportsInstances() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_INSTANCES) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::SupportsChildren() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_CHILDREN) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::UnderstandsInstanceCodes() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_UNDERSTANDINSTANCE) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::HasWebProtocol() const
|
|
{
|
|
return (m_si.flServiceInfoFlags & ISMI_HASWEBPROTOCOL) != 0;
|
|
}
|
|
|
|
inline BOOL CServiceInfo::SupportsMMC() const
|
|
{
|
|
#ifdef USE_VTABLE
|
|
return m_rgpfnISMMethods[ISM_MMC_CONFIGURE] != NULL;
|
|
#else
|
|
return m_pfnISMMMCConfigureServers != NULL;
|
|
#endif // USE_VTABLE
|
|
}
|
|
|
|
inline BOOL CServiceInfo::IsK2Service() const
|
|
{
|
|
#ifdef USE_VTABLE
|
|
return m_rgpfnISMMethods[ISM_BIND] != NULL;
|
|
#else
|
|
return m_pfnBind != NULL;
|
|
#endif // USE_VTABLE
|
|
}
|
|
|
|
inline void CServiceInfo::SelectService(BOOL fSelected)
|
|
{
|
|
m_fIsSelected = fSelected;
|
|
}
|
|
|
|
#ifdef USE_VTABLE
|
|
|
|
//
|
|
// Helper Macros to access VTable
|
|
//
|
|
#define ISM_VTABLE_ENTRY(iID)\
|
|
(m_rgpfnISMMethods[iID] != NULL)
|
|
|
|
#define ISM_NO_VTABLE_ENTRY(iID)\
|
|
(m_rgpfnISMMethods[iID] == NULL)
|
|
|
|
#define ASSERT_VTABLE_ENTRY(iID)\
|
|
ASSERT(iID >= 0 && iID < ISM_NUM_METHODS);\
|
|
ASSERT(ISM_VTABLE_ENTRY(iID));
|
|
|
|
#define ISM_VTABLE(iID)\
|
|
(*m_rgpfnISMMethods[iID])
|
|
|
|
inline DWORD CServiceInfo::ISMDiscoverServers(
|
|
OUT ISMSERVERINFO * psi,
|
|
IN OUT DWORD * pdwBufferSize,
|
|
OUT int * pcServers
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_DISCOVER_SERVERS);
|
|
return ISM_VTABLE(ISM_DISCOVER_SERVERS)(
|
|
psi,
|
|
pdwBufferSize,
|
|
pcServers
|
|
);
|
|
}
|
|
|
|
inline DWORD CServiceInfo::ISMChangeServiceState(
|
|
IN int nNewState,
|
|
OUT int * pnCurrentState,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszServers
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_CHANGE_SERVICE_STATE);
|
|
return ISM_VTABLE(ISM_CHANGE_SERVICE_STATE)(
|
|
nNewState,
|
|
pnCurrentState,
|
|
dwInstance,
|
|
lpszServers
|
|
);
|
|
}
|
|
|
|
inline DWORD CServiceInfo::ISMConfigureServers(
|
|
IN HWND hWnd,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszServers
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_CONFIGURE);
|
|
return ISM_VTABLE(ISM_CONFIGURE)(
|
|
hWnd,
|
|
dwInstance,
|
|
lpszServers
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMBind(
|
|
IN LPCTSTR lpszServer,
|
|
OUT HANDLE *phServer
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_BIND);
|
|
return ISM_VTABLE(ISM_BIND)(lpszServer, phServer);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMUnbind(
|
|
IN HANDLE hServer
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_UNBIND);
|
|
return ISM_VTABLE(ISM_UNBIND)(hServer);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMEnumerateInstances(
|
|
IN HANDLE hServer,
|
|
IN OUT ISMINSTANCEINFO * pii,
|
|
IN OUT HANDLE * phEnum
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_ENUMERATE_INSTANCES);
|
|
return ISM_VTABLE(ISM_ENUMERATE_INSTANCES)(
|
|
hServer,
|
|
pii,
|
|
phEnum
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMAddInstance(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwSourceInstance,
|
|
OUT ISMINSTANCEINFO * pii,
|
|
IN DWORD dwBufferSize
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_ADD_INSTANCE);
|
|
return ISM_VTABLE(ISM_ADD_INSTANCE)(
|
|
hServer,
|
|
dwSourceInstance,
|
|
pii,
|
|
dwBufferSize
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMDeleteInstance(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_DELETE_INSTANCE);
|
|
return ISM_VTABLE(ISM_DELETE_INSTANCE)(
|
|
hServer,
|
|
dwInstance
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMQueryInstanceInfo(
|
|
IN HANDLE hServer,
|
|
IN BOOL fInherit,
|
|
OUT ISMINSTANCEINFO * pii,
|
|
IN DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_QUERY_INSTANCE_INFO);
|
|
return ISM_VTABLE(ISM_QUERY_INSTANCE_INFO)(
|
|
hServer,
|
|
fInherit,
|
|
pii,
|
|
dwInstance
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMEnumerateChildren(
|
|
IN HANDLE hServer,
|
|
IN OUT ISMCHILDINFO * pii,
|
|
IN OUT HANDLE * pdwEnum,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_ENUMERATE_CHILDREN);
|
|
return ISM_VTABLE(ISM_ENUMERATE_CHILDREN)(
|
|
hServer,
|
|
pii,
|
|
pdwEnum,
|
|
dwInstance,
|
|
lpszParent
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMQueryChildInfo(
|
|
IN HANDLE hServer,
|
|
IN BOOL fInherit,
|
|
OUT ISMCHILDINFO * pii,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_QUERY_CHILD_INFO);
|
|
return ISM_VTABLE(ISM_QUERY_CHILD_INFO)(
|
|
hServer,
|
|
fInherit,
|
|
pii,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMConfigureChild(
|
|
IN HANDLE hServer,
|
|
IN HWND hWnd,
|
|
IN DWORD dwAttributes,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_CONFIGURE_CHILD);
|
|
return ISM_VTABLE(ISM_CONFIGURE_CHILD)(
|
|
hServer,
|
|
hWnd,
|
|
dwAttributes,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMAddChild(
|
|
IN HANDLE hServer,
|
|
OUT ISMCHILDINFO * pii,
|
|
IN DWORD dwBufferSize,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_ADD_CHILD);
|
|
return ISM_VTABLE(ISM_ADD_CHILD)(
|
|
hServer,
|
|
pii,
|
|
dwBufferSize,
|
|
dwInstance,
|
|
lpszParent
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMSecurityWizard(
|
|
HANDLE hServer,
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent,
|
|
LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_SECURITY_WIZARD);
|
|
return ISM_VTABLE(ISM_SECURITY_WIZARD)(
|
|
hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMDeleteChild(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_DELETE_CHILD);
|
|
return ISM_VTABLE(ISM_DELETE_CHILD)(
|
|
hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMRenameChild(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias,
|
|
IN LPCTSTR lpszNewAlias
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_RENAME_CHILD);
|
|
return ISM_VTABLE(ISM_RENAME_CHILD)(
|
|
hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias,
|
|
lpszNewAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMMMCConfigureServers(
|
|
IN HANDLE hServer,
|
|
IN PVOID lpfnProvider,
|
|
IN LPARAM param,
|
|
IN LONG_PTR handle,
|
|
IN DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_MMC_CONFIGURE);
|
|
return ISM_VTABLE(ISM_MMC_CONFIGURE)(
|
|
hServer,
|
|
lpfnProvider,
|
|
param,
|
|
handle,
|
|
dwInstance
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMMMCConfigureChild(
|
|
IN HANDLE hServer,
|
|
IN PVOID lpfnProvider,
|
|
IN LPARAM param,
|
|
IN LONG_PTR handle,
|
|
IN DWORD dwAttributes,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT_VTABLE_ENTRY(ISM_MMC_CONFIGURE_CHILD);
|
|
return ISM_VTABLE(ISM_MMC_CONFIGURE_CHILD)(
|
|
hServer,
|
|
lpfnProvider,
|
|
param,
|
|
handle,
|
|
dwAttributes,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
#else ! USE_VTABLE
|
|
|
|
|
|
|
|
inline DWORD CServiceInfo::ISMDiscoverServers(
|
|
OUT ISMSERVERINFO * psi,
|
|
IN OUT DWORD * pdwBufferSize,
|
|
OUT int * pcServers
|
|
)
|
|
{
|
|
ASSERT(m_pfnDiscoverServers != NULL);
|
|
return (*m_pfnDiscoverServers)(psi, pdwBufferSize, pcServers);
|
|
}
|
|
|
|
inline DWORD CServiceInfo::ISMChangeServiceState(
|
|
IN int nNewState,
|
|
OUT int * pnCurrentState,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszServers
|
|
)
|
|
{
|
|
ASSERT(m_pfnChangeServiceState != NULL);
|
|
return (*m_pfnChangeServiceState)(
|
|
nNewState,
|
|
pnCurrentState,
|
|
dwInstance,
|
|
lpszServers
|
|
);
|
|
}
|
|
|
|
inline DWORD CServiceInfo::ISMConfigureServers(
|
|
IN HWND hWnd,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszServers
|
|
)
|
|
{
|
|
ASSERT(m_pfnConfigure != NULL);
|
|
return (*m_pfnConfigure)(hWnd, dwInstance, lpszServers);
|
|
}
|
|
|
|
|
|
inline HRESULT CServiceInfo::ISMBind(
|
|
IN LPCTSTR lpszServer,
|
|
OUT HANDLE *phServer
|
|
)
|
|
{
|
|
ASSERT(m_pfnBind != NULL);
|
|
return (*m_pfnBind)(lpszServer, phServer);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMUnbind(
|
|
IN HANDLE hServer
|
|
)
|
|
{
|
|
ASSERT(m_pfnUnbind != NULL);
|
|
return (*m_pfnUnbind)(hServer);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMEnumerateInstances(
|
|
IN HANDLE hServer,
|
|
IN OUT ISMINSTANCEINFO * pii,
|
|
IN OUT HANDLE * phEnum
|
|
)
|
|
{
|
|
ASSERT(m_pfnEnumerateInstances != NULL);
|
|
return (*m_pfnEnumerateInstances)(hServer, pii, phEnum);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMEnumerateChildren(
|
|
IN HANDLE hServer,
|
|
IN OUT ISMCHILDINFO * pii,
|
|
IN OUT HANDLE * phEnum,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent
|
|
)
|
|
{
|
|
ASSERT(m_pfnEnumerateChildren != NULL);
|
|
return (*m_pfnEnumerateChildren)(
|
|
hServer,
|
|
pii,
|
|
phEnum,
|
|
dwInstance,
|
|
lpszParent
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMConfigureChild(
|
|
IN HANDLE hServer,
|
|
IN HWND hWnd,
|
|
IN DWORD dwAttributes,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pfnConfigureChild != NULL);
|
|
return (*m_pfnConfigureChild)(
|
|
hServer,
|
|
hWnd,
|
|
dwAttributes,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMAddInstance(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwSourceInstance,
|
|
OUT ISMINSTANCEINFO * pii,
|
|
IN DWORD dwBufferSize
|
|
)
|
|
{
|
|
ASSERT(m_pfnAddInstance != NULL);
|
|
return (*m_pfnAddInstance)(hServer, dwSourceInstance, pii, dwBufferSize);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMDeleteInstance(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT(m_pfnDeleteInstance != NULL);
|
|
return (*m_pfnDeleteInstance)(hServer, dwInstance);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMQueryInstanceInfo(
|
|
IN HANDLE hServer,
|
|
IN BOOL fInherit,
|
|
OUT ISMINSTANCEINFO * pii,
|
|
IN DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT(m_pfnQueryInstanceInfo != NULL);
|
|
return (*m_pfnQueryInstanceInfo)(hServer, fInherit, pii, dwInstance);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMQueryChildInfo(
|
|
IN HANDLE hServer,
|
|
IN BOOL fInherit,
|
|
OUT ISMCHILDINFO * pii,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pfnQueryChildInfo != NULL);
|
|
return (*m_pfnQueryChildInfo)(
|
|
hServer,
|
|
fInherit,
|
|
pii,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMAddChild(
|
|
IN HANDLE hServer,
|
|
OUT ISMCHILDINFO * pii,
|
|
IN DWORD dwBufferSize,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent
|
|
)
|
|
{
|
|
ASSERT(m_pfnAddChild != NULL);
|
|
return (*m_pfnAddChild)(
|
|
hServer,
|
|
pii,
|
|
dwBufferSize,
|
|
dwInstance,
|
|
lpszParent
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMSecurityWizard(
|
|
HANDLE hServer,
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent,
|
|
LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pfnISMSecurityWizard != NULL);
|
|
return (*m_pfnISMSecurityWizard)(
|
|
hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMDeleteChild(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pfnDeleteChild != NULL);
|
|
return (*m_pfnDeleteChild)(hServer, dwInstance, lpszParent, lpszAlias);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMRenameChild(
|
|
IN HANDLE hServer,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias,
|
|
IN LPCTSTR lpszNewAlias
|
|
)
|
|
{
|
|
ASSERT(m_pfnDeleteChild != NULL);
|
|
return (*m_pfnRenameChild)(
|
|
hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias,
|
|
lpszNewAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMMMCConfigureServers(
|
|
IN HANDLE hServer,
|
|
IN PVOID lpfnProvider,
|
|
IN LPARAM param,
|
|
IN LONG_PTR handle,
|
|
IN DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT(m_pfnISMMMCConfigureServers != NULL);
|
|
return (*m_pfnISMMMCConfigureServers)(
|
|
hServer,
|
|
lpfnProvider,
|
|
param,
|
|
handle,
|
|
dwInstance
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServiceInfo::ISMMMCConfigureChild(
|
|
IN HANDLE hServer,
|
|
IN PVOID lpfnProvider,
|
|
IN LPARAM param,
|
|
IN LONG_PTR handle,
|
|
IN DWORD dwAttributes,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pfnISMMMCConfigureChild != NULL);
|
|
return (*m_pfnISMMMCConfigureChild)(
|
|
hServer,
|
|
lpfnProvider,
|
|
param,
|
|
handle,
|
|
dwAttributes,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
#endif // USE_VTABLE
|
|
|
|
//
|
|
// Assign the service bitmap index
|
|
//
|
|
inline void CServiceInfo::SetBitmapIndex(int iID)
|
|
{
|
|
m_iBmpID = iID;
|
|
}
|
|
|
|
//
|
|
// Assign the child bitmap index
|
|
//
|
|
inline void CServiceInfo::SetChildBitmapIndex(int iID)
|
|
{
|
|
m_iBmpChildID = iID;
|
|
}
|
|
|
|
inline HINSTANCE CNewInstanceCmd::QueryInstanceHandle()
|
|
{
|
|
return GetServiceInfo()->QueryInstanceHandle();
|
|
}
|
|
|
|
inline int CServerInfo::CompareByServer(CServerInfo * psi) const
|
|
{
|
|
return ::lstrcmpi(
|
|
QueryServerDisplayName(),
|
|
psi->QueryServerDisplayName()
|
|
);
|
|
}
|
|
|
|
inline BOOL CServerInfo::MatchServerName(LPCTSTR lpszServerName) const
|
|
{
|
|
return ::lstrcmpi(QueryServerDisplayName(), lpszServerName) == 0;
|
|
}
|
|
|
|
inline int CServerInfo::CompareByService(CServerInfo * psi)
|
|
{
|
|
return ::lstrcmpi(GetServiceName(), psi->GetServiceName());
|
|
}
|
|
|
|
inline HRESULT CServerInfo::ConfigureChild(
|
|
IN HWND hWnd,
|
|
IN DWORD dwAttributes,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMConfigureChild(
|
|
m_hServer,
|
|
hWnd,
|
|
dwAttributes,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::MMCConfigureChild(
|
|
IN PVOID lpfnProvider,
|
|
IN LPARAM param,
|
|
IN LONG_PTR handle,
|
|
IN DWORD dwAttributes,
|
|
IN DWORD dwInstance,
|
|
IN LPCTSTR lpszParent,
|
|
IN LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMMMCConfigureChild(
|
|
m_hServer,
|
|
lpfnProvider,
|
|
param,
|
|
handle,
|
|
dwAttributes,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::RenameChild(
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent,
|
|
LPCTSTR lpszAlias,
|
|
LPCTSTR lpszNewName
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMRenameChild(
|
|
m_hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias,
|
|
lpszNewName
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::AddChild(
|
|
ISMCHILDINFO * pii,
|
|
DWORD dwBufferSize,
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMAddChild(
|
|
m_hServer,
|
|
pii,
|
|
dwBufferSize,
|
|
dwInstance,
|
|
lpszParent
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::ISMSecurityWizard(
|
|
DWORD dwInstance, // Instance number
|
|
LPCTSTR lpszParent, // Parent path
|
|
LPCTSTR lpszAlias // Child alias name
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMSecurityWizard(
|
|
m_hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
|
|
inline HRESULT CServerInfo::DeleteChild(
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent,
|
|
LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMDeleteChild(
|
|
m_hServer,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::QueryInstanceInfo(
|
|
BOOL fInherit,
|
|
ISMINSTANCEINFO * pii,
|
|
DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMQueryInstanceInfo(
|
|
m_hServer,
|
|
fInherit,
|
|
pii,
|
|
dwInstance
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::QueryChildInfo(
|
|
BOOL fInherit,
|
|
ISMCHILDINFO * pii,
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent,
|
|
LPCTSTR lpszAlias
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMQueryChildInfo(
|
|
m_hServer,
|
|
fInherit,
|
|
pii,
|
|
dwInstance,
|
|
lpszParent,
|
|
lpszAlias
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::AddInstance(
|
|
ISMINSTANCEINFO * pii,
|
|
DWORD dwBufferSize
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMAddInstance(
|
|
m_hServer,
|
|
0L, // Source instance
|
|
pii,
|
|
dwBufferSize
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::DeleteInstance(
|
|
DWORD dwInstance
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMDeleteInstance(m_hServer, dwInstance);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::ISMEnumerateChildren(
|
|
ISMCHILDINFO * pii,
|
|
HANDLE * phEnum,
|
|
DWORD dwInstance,
|
|
LPCTSTR lpszParent
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMEnumerateChildren(
|
|
m_hServer,
|
|
pii,
|
|
phEnum,
|
|
dwInstance,
|
|
lpszParent
|
|
);
|
|
}
|
|
|
|
inline HRESULT CServerInfo::ISMEnumerateInstances(
|
|
ISMINSTANCEINFO * pii,
|
|
HANDLE * pdwEnum
|
|
)
|
|
{
|
|
ASSERT(m_pService);
|
|
return m_pService->ISMEnumerateInstances(m_hServer, pii, pdwEnum);
|
|
}
|
|
|
|
inline LPCTSTR CServerInfo::QueryServerDisplayName() const
|
|
{
|
|
#ifdef ENFORCE_NETBIOS
|
|
return ((LPCTSTR)m_strServerName) + 2;
|
|
#else
|
|
return (LPCTSTR)m_strServerName;
|
|
#endif // ENFORCE_NETBIOS
|
|
}
|
|
|
|
inline BOOL CServerInfo::IsServiceRunning() const
|
|
{
|
|
return m_nServiceState == INetServiceRunning;
|
|
}
|
|
|
|
inline BOOL CServerInfo::IsServiceStopped() const
|
|
{
|
|
return m_nServiceState == INetServiceStopped;
|
|
}
|
|
|
|
inline BOOL CServerInfo::IsServicePaused() const
|
|
{
|
|
return m_nServiceState == INetServicePaused;
|
|
}
|
|
|
|
inline BOOL CServerInfo::IsServiceStatusUnknown() const
|
|
{
|
|
return m_nServiceState == INetServiceUnknown;
|
|
}
|
|
|
|
inline HINSTANCE CServerInfo::QueryInstanceHandle()
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->QueryInstanceHandle();
|
|
}
|
|
|
|
inline BOOL CServerInfo::IsServiceSelected() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->IsSelected();
|
|
}
|
|
|
|
inline LPCTSTR CServerInfo::GetServiceName() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->GetShortName();
|
|
}
|
|
|
|
inline int CServerInfo::QueryServiceID() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->QueryServiceID();
|
|
}
|
|
|
|
inline int CServerInfo::QueryBitmapIndex() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->QueryBitmapIndex();
|
|
}
|
|
|
|
inline int CServerInfo::QueryChildBitmapIndex() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->QueryChildBitmapIndex();
|
|
}
|
|
|
|
inline LPCTSTR CServerInfo::GetShortName() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->GetShortName();
|
|
}
|
|
|
|
inline LPCTSTR CServerInfo::GetLongName() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->GetLongName();
|
|
}
|
|
|
|
inline LPCTSTR CServerInfo::GetProtocol() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->GetProtocol();
|
|
}
|
|
|
|
inline LPCTSTR CServerInfo::GetMetabaseName() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->GetMetabaseName();
|
|
}
|
|
|
|
inline BOOL CServerInfo::CanControlService() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->CanControlService();
|
|
}
|
|
|
|
inline BOOL CServerInfo::CanPauseService() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->CanPauseService();
|
|
}
|
|
|
|
inline BOOL CServerInfo::SupportsInstances() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->SupportsInstances();
|
|
}
|
|
|
|
inline BOOL CServerInfo::SupportsChildren() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->SupportsChildren();
|
|
}
|
|
|
|
inline BOOL CServerInfo::SupportsFileSystem() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->SupportsFileSystem();
|
|
}
|
|
|
|
inline BOOL CServerInfo::SupportsSecurityWizard() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->SupportsSecurityWizard();
|
|
}
|
|
|
|
inline BOOL CServerInfo::UnderstandsInstanceCodes() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->UnderstandsInstanceCodes();
|
|
}
|
|
|
|
inline BOOL CServerInfo::HasWebProtocol() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->HasWebProtocol();
|
|
}
|
|
|
|
inline BOOL CServerInfo::SupportsMMC() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->SupportsMMC();
|
|
}
|
|
|
|
inline BOOL CServerInfo::IsK2Service() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->IsK2Service();
|
|
}
|
|
|
|
inline UINT CServerInfo::QueryServiceBitmapID() const
|
|
{
|
|
ASSERT(m_pService != NULL);
|
|
return m_pService->QueryServiceBitmapID();
|
|
}
|
|
|
|
extern CSnapinApp theApp;
|
|
|
|
|
|
#include "iisobj.h"
|
|
#include "menuex.h"
|
|
|
|
#endif // _INETMGR_H
|