windows-xp/Source/XPSP1/NT/inetsrv/iis/ui/admin/mmc/inetmgr.h

/*++

   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