able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/admin/snapin/iismachine.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1825 lines
33 KiB
C++
Raw Blame History

/*++
Copyright (c) 1994-2000 Microsoft Corporation
Module Name :
iismachine.cpp
Abstract:
IIS Machine node
Author:
Ronald Meijer (ronaldm)
Sergei Antonov (sergeia)
Project:
Internet Services Manager
Revision History:
10/28/2000 sergeia Split from iisobj.cpp
--*/
#include "stdafx.h"
#include "common.h"
#include "inetprop.h"
#include "InetMgrApp.h"
#include "supdlgs.h"
#include "connects.h"
#include "metaback.h"
#include "iisobj.h"
#include "shutdown.h"
#include "machsht.h"
#include "w3sht.h"
#include "fltdlg.h"
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
#define new DEBUG_NEW
/* static */ LPOLESTR CIISMachine::_cszNodeName = _T("LM");
/* static */ CComBSTR CIISMachine::_bstrYes;
/* static */ CComBSTR CIISMachine::_bstrNo;
/* static */ CComBSTR CIISMachine::_bstrVersionFmt;
/* static */ BOOL CIISMachine::_fStaticsLoaded = FALSE;
//
// Define result view for machine objects
//
/* static */ int CIISMachine::_rgnLabels[COL_TOTAL] =
{
IDS_RESULT_COMPUTER_NAME,
IDS_RESULT_COMPUTER_LOCAL,
IDS_RESULT_COMPUTER_VERSION,
IDS_RESULT_STATUS,
};
/* static */ int CIISMachine::_rgnWidths[COL_TOTAL] =
{
200,
50,
//100,
150,
200,
};
/* static */
void
CIISMachine::InitializeHeaders(
IN LPHEADERCTRL lpHeader
)
/*++
Routine Description:
Initialize the result view headers for a machine object
Arguments:
LPHEADERCTRL lpHeader : Pointer to header control
Return Value:
None.
--*/
{
BuildResultView(lpHeader, COL_TOTAL, _rgnLabels, _rgnWidths);
if (!_fStaticsLoaded)
{
_fStaticsLoaded =
_bstrYes.LoadString(IDS_YES) &&
_bstrNo.LoadString(IDS_NO) &&
_bstrVersionFmt.LoadString(IDS_VERSION_FMT);
}
}
/* static */
HRESULT
CIISMachine::VerifyMachine(
IN OUT CIISMachine *& pMachine
)
/*++
Routine Description:
Create the interface on the given machine object.
Arguments:
CIISMachine *& pMachine : Machine object
BOOL fAskBeforeRedirecting
Return Value:
HRESULT
Notes:
THe CIISMachine object pass in may refer to the cluster master
on return.
--*/
{
CError err;
if (pMachine)
{
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
CWaitCursor wait;
//
// Attempt to create the interface to ensure the machine
// contains a metabase.
//
err = pMachine->CreateInterface(FALSE);
}
return err;
}
CIISMachine::CIISMachine(
CComAuthInfo * pAuthInfo,
CIISRoot * pRoot
)
: m_pInterface(NULL),
m_bstrDisplayName(NULL),
m_auth(pAuthInfo),
m_pRootExt(pRoot),
m_err(),
//
// By default we assume the password is entered.
// If this machine object is constructed from the
// cache, it will get reset by InitializeFromStream()
//
m_fPasswordEntered(TRUE),
m_dwVersion(MAKELONG(5, 0)), // Assume as a default
CIISMBNode(this, _cszNodeName)
{
//
// Load one-liner error messages
//
SetErrorOverrides(m_err, TRUE);
SetDisplayName();
}
CIISMachine::~CIISMachine()
/*++
Routine Description:
Destructor
Arguments:
N/A
Return Value:
N/A
--*/
{
if (m_bstrDisplayName)
{
::SysFreeString(m_bstrDisplayName);
}
SAFE_DELETE(m_pInterface);
}
/* static */
HRESULT
CIISMachine::ReadFromStream(
OUT IN IStream * pStream,
OUT CIISMachine ** ppMachine
)
/*++
Routine Description:
Static helper function to allocate a new CIISMachine object read
from the storage stream.
Arguments:
IStream * pStream : Stream to read from
CIISMachine ** ppMachine : Returns CIISMachine object
Return Value:
HRESULT
--*/
{
CComBSTR strMachine, strUser;
ASSERT_WRITE_PTR(ppMachine);
ASSERT_READ_WRITE_PTR(pStream);
CError err;
*ppMachine = NULL;
do
{
err = strMachine.ReadFromStream(pStream);
BREAK_ON_ERR_FAILURE(err);
err = strUser.ReadFromStream(pStream);
BREAK_ON_ERR_FAILURE(err);
*ppMachine = new CIISMachine(CComAuthInfo(strMachine, strUser));
if (!*ppMachine)
{
err = ERROR_NOT_ENOUGH_MEMORY;
break;
}
err = (*ppMachine)->InitializeFromStream(pStream);
}
while(FALSE);
return err;
}
HRESULT
CIISMachine::WriteToStream(
IN OUT IStream * pStgSave
)
/*++
Routine Description:
Write machine information to stream.
Arguments:
IStream * pStgSave : Open stream
Return Value:
HRESULT
Notes:
Be sure to keep this information in sync with CIISMachine::InitializeFromStream()
--*/
{
ASSERT_READ_WRITE_PTR(pStgSave);
CComBSTR bstrServerName(m_auth.QueryServerName());
CComBSTR bstrUserName(m_auth.QueryUserName());
CError err;
ULONG cb;
do
{
err = bstrServerName.WriteToStream(pStgSave);
BREAK_ON_ERR_FAILURE(err);
err = bstrUserName.WriteToStream(pStgSave);
BREAK_ON_ERR_FAILURE(err);
//
// Now cache the dynamically-generated information, such
// as version number, snapin status etc. This will be
// displayed in the result view before the interface is
// created.
//
err = pStgSave->Write(&m_dwVersion, sizeof(m_dwVersion), &cb);
BREAK_ON_ERR_FAILURE(err);
}
while(FALSE);
return err;
}
HRESULT
CIISMachine::InitializeFromStream(
IN IStream * pStream
)
/*++
Routine Description:
Read version number and other cached parameters that will
be overridden at runtime when the interface is created.
This is cached, because it's required before the interface
is created.
Arguments:
IStream * pStream : Open stream
Return Value:
HRESULT
Notes:
Be sure to keep this information in sync with CIISMachine::WriteToStream()
--*/
{
ASSERT_READ_PTR(pStream);
CError err;
ULONG cb;
//
// Passwords are never cached. IIS status will
// always be verified when the actual interface
// is created.
//
m_fPasswordEntered = FALSE;
//
// Version number
//
err = pStream->Read(&m_dwVersion, sizeof(m_dwVersion), &cb);
return err;
}
void
CIISMachine::SetDisplayName()
/*++
Routine Description:
Create a special display name for this machine object if it's
either the local machine, or
--*/
{
CString fmt;
if (IsLocal())
{
//
// Use the local computer name, and not the name
// that's on the server object, because that could
// be and ip address or "localhost".
//
TCHAR szLocalServer[MAX_PATH + 1];
DWORD dwSize = MAX_PATH;
VERIFY(::GetComputerName(szLocalServer, &dwSize));
fmt.Format(IDS_LOCAL_COMPUTER, szLocalServer);
}
else
{
//
// No special display name necessary
//
m_bstrDisplayName = NULL;
return;
}
m_bstrDisplayName = ::SysAllocStringLen(fmt, fmt.GetLength());
TRACEEOLID("Machine display name: " << m_bstrDisplayName);
}
LPOLESTR
CIISMachine::QueryDisplayName()
/*++
Routine Description:
Get the display name for the machine/cluster object
Arguments:
None
Return Value:
Display Name
--*/
{
if (m_pRootExt != NULL)
return m_pRootExt->QueryDisplayName();
else
return m_bstrDisplayName ? m_bstrDisplayName : QueryServerName();
}
int
CIISMachine::QueryImage() const
/*++
Routine Description:
Return machine bitmap index appropriate for the current
state of this machine object.
Arguments:
None
Return Value:
Bitmap index
--*/
{
if (m_pRootExt != NULL)
{
return m_pRootExt->QueryImage();
}
else
{
if (m_err.Failed())
{
return iErrorMachine;
}
return IsLocal() ? iLocalMachine : iMachine;
}
}
HRESULT
CIISMachine::CreateInterface(
IN BOOL fShowError
)
/*++
Routine Description:
Create the interface. If the interface is already created, recreate it.
Arguments:
BOOL fShowError : TRUE to display error messages
Return Value:
HRESULT
Notes:
This function is deliberately NOT called from the constructor for performance
reasons.
--*/
{
CError err;
if (HasInterface())
{
//
// Recreate the interface (this should re-use the impersonation)
//
TRACEEOLID("Warning: Rebinding existing interface.");
err = m_pInterface->Regenerate();
}
else
{
//
// Create new interface
//
m_pInterface = new CMetaKey(&m_auth);
err = m_pInterface
? m_pInterface->QueryResult()
: ERROR_NOT_ENOUGH_MEMORY;
}
if (err.Succeeded())
{
//
// Load its display parameters
//
err = RefreshData();
CMetabasePath path;
err = DetermineIfAdministrator(
m_pInterface,
path,
&m_fIsAdministrator
);
}
if (err.Failed())
{
if (fShowError)
{
DisplayError(err);
}
//
// Kill bogus interface
//
SAFE_DELETE(m_pInterface);
}
return err;
}
/* virtual */
int
CIISMachine::CompareScopeItem(
IN CIISObject * pObject
)
/*++
Routine Description:
Compare against another CIISMachine object.
Arguments:
CIISObject * pObject : Object to compare against
Return Value:
0 if the two objects are identical
<0 if this object is less than pObject
>0 if this object is greater than pObject
--*/
{
ASSERT_READ_PTR(pObject);
//
// First criteria is object type
//
int n1 = QuerySortWeight();
int n2 = pObject->QuerySortWeight();
if (n1 != n2)
{
return n1 - n2;
}
//
// pObject is a CIISMachine object (same sortweight)
//
CIISMachine * pMachine = (CIISMachine *)pObject;
//
// Next sort on local key (local sorts before non-local)
//
n1 = IsLocal() ? 0 : 1;
n2 = pMachine->IsLocal() ? 0 : 1;
if (n1 != n2)
{
return n1 - n2;
}
if (!n1 && !n2)
{
//
// This is the local machine, even if the name is different
//
return 0;
}
//
// Else sort on name.
//
return ::lstrcmpi(QueryServerName(), pMachine->QueryServerName());
}
BOOL
CIISMachine::SetCacheDirty()
/*++
Routine Description:
Set the cache as dirty
Arguments:
None
Return Value:
TRUE for success, FALSE if the cache was not found
--*/
{
ASSERT(m_pRootExt == NULL);
//
// Cache is stored at the root object
//
CIISRoot * pRoot = GetRoot();
ASSERT_PTR(pRoot);
if (pRoot)
{
pRoot->m_scServers.SetDirty();
return TRUE;
}
return FALSE;
}
int
CIISMachine::ResolvePasswordFromCache()
/*++
Routine Description:
Look through the machine cache for machines with the same username
as this object. If they have a password entered, grab it.
Arguments:
None
Return Value:
TRUE if a machine with the same username was found whose password
we stole. FALSE otherwise.
--*/
{
BOOL fUpdated = FALSE;
//
// Doesn't make sense if this machine object doesn't use impersonation
// or already has a password.
//
ASSERT(UsesImpersonation() && !PasswordEntered());
CIISRoot * pRoot = GetRoot();
ASSERT_PTR(pRoot);
if (pRoot)
{
CIISMachine * pMachine = pRoot->m_scServers.GetFirst();
while(pMachine)
{
if (pMachine->UsesImpersonation() && pMachine->PasswordEntered())
{
if (!::lstrcmpi(QueryUserName(), pMachine->QueryUserName()))
{
TRACEEOLID("Swiping cached password from " << pMachine->QueryServerName());
StorePassword(pMachine->QueryPassword());
++fUpdated;
break;
}
}
pMachine = pRoot->m_scServers.GetNext();
}
}
return fUpdated;
}
HRESULT
CIISMachine::Impersonate(
IN LPCTSTR szUserName,
IN LPCTSTR szPassword
)
/*++
Routine Description:
Set and store proxy blanket security information. Store username/password
for use by metaback and other interfaces.
Arguments:
LPCTSTR szUserName : Username (domain\username)
LPCTSTR szPassword : Password
Return Value:
None
--*/
{
ASSERT_READ_PTR(szUserName);
CError err;
if (m_pInterface)
{
//
// Already have an interface created; Change the
// the security blanket.
//
err = m_pInterface->ChangeProxyBlanket(szUserName, szPassword);
}
if (err.Succeeded())
{
//
// Store new username/password
//
m_auth.SetImpersonation(szUserName, szPassword);
m_fPasswordEntered = TRUE;
}
return err;
}
void
CIISMachine::RemoveImpersonation()
/*++
Routine Description:
Remove impersonation parameters. Destroy any existing interface.
Arguments:
None
Return Value:
N/A
--*/
{
m_auth.RemoveImpersonation();
m_fPasswordEntered = FALSE;
SAFE_DELETE(m_pInterface);
}
void
CIISMachine::StorePassword(
IN LPCTSTR szPassword
)
/*++
Routine Description:
Store password.
Arguments:
LPCTSTR szPassword : Password
Return Value:
None
--*/
{
ASSERT_READ_PTR(szPassword);
m_auth.StorePassword(szPassword);
m_fPasswordEntered = TRUE;
}
BOOL
CIISMachine::ResolveCredentials()
/*++
Routine Description:
If this machine object uses impersonation, but hasn't entered a password
yet, check to see if there are any other machines in the cache with the
same username and grab its password. If not, prompt the user for it.
Arguments:
None
Return Value:
TRUE if a password was entered. FALSE otherwise.
--*/
{
BOOL fPasswordEntered = FALSE;
if (UsesImpersonation() && !PasswordEntered())
{
//
// Attempt to find the password from the cache
//
if (!ResolvePasswordFromCache())
{
//
// Didn't find the password in the cache. Prompt
// the user for it.
//
CLoginDlg dlg(LDLG_ENTER_PASS, this);
if (dlg.DoModal() == IDOK)
{
fPasswordEntered = TRUE;
if (dlg.UserNameChanged())
{
//
// User name has changed -- remember to
// save the machine cache later.
//
SetCacheDirty();
}
}
else
{
//
// Pressing cancel on this dialog means the user
// wants to stop using impersonation.
//
RemoveImpersonation();
SetCacheDirty();
}
}
}
return fPasswordEntered;
}
BOOL
CIISMachine::HandleAccessDenied(
IN OUT CError & err
)
/*++
Routine Description:
After calling interface method, pass the error object to this function
to handle the access denied case. If the error is access denied,
give the user a chance to change credentials. Since we assume an
attempt has been made to create an interface at least -- the interface
will be recreated with the new credentials.
Arguments:
CError & err : Error object. Checked for ACCESS_DENIED on entry,
will contain new error code on exit if the interface
was recreated.
Return Value:
TRUE if new credentials were applied
--*/
{
BOOL fPasswordEntered = FALSE;
//
// If access denied occurs here -- give another chance
// at entering the password.
//
if (err.Win32Error() == ERROR_ACCESS_DENIED)
{
CLoginDlg dlg(LDLG_ACCESS_DENIED, this);
if (dlg.DoModal() == IDOK)
{
fPasswordEntered = TRUE;
err.Reset();
if (!HasInterface())
{
//
// If we already had an interface, the login dialog
// will have applied the new security blanket.
// If we didn't have an interface, it needs to be
// recreated with the new security blanket.
//
CWaitCursor wait;
err = CreateInterface(FALSE);
}
}
}
return fPasswordEntered;
}
HRESULT
CIISMachine::CheckCapabilities()
/*++
Routine Description:
Load the capabilities information for this server.
Arguments:
None
Return Value:
HRESULT
--*/
{
HRESULT hr = S_OK;
//
// Fetch capability bits and version numbers.
//
CString strMDInfo;
CMetabasePath::GetServiceInfoPath(_T(""), strMDInfo);
CServerCapabilities sc(m_pInterface, strMDInfo);
hr = sc.LoadData();
if (SUCCEEDED(hr))
{
DWORD dwVersion = sc.QueryMajorVersion();
if (dwVersion)
{
m_dwVersion = dwVersion | (sc.QueryMinorVersion() << SIZE_IN_BITS(WORD));
}
m_fCanAddInstance = sc.HasMultipleSites();
m_fHas10ConnectionsLimit = sc.Has10ConnectionLimit();
}
return hr;
}
/* virtual */
HRESULT
CIISMachine::RefreshData()
/*++
Routine Description:
Refresh relevant configuration data required for display.
Arguments:
None
Return Value:
HRESULT
--*/
{
//
// Check capability and version information.
//
CError err(CheckCapabilities());
SetDisplayName();
return err;
}
/* virtual */
void
CIISMachine::SetInterfaceError(
IN HRESULT hr
)
/*++
Routine Description:
Set the interface error. If different from current error,
change the display icon
Arguments:
HRESULT hr : Error code (S_OK is acceptable)
Return Value:
None
--*/
{
if (m_err.HResult() != hr)
{
//
// Change to error/machine icon for the parent machine.
//
m_err = hr;
RefreshDisplay();
}
}
/* virtual */
HRESULT
CIISMachine::BuildMetaPath(
OUT CComBSTR & bstrPath
) const
/*++
Routine Description:
Recursively build up the metabase path from the current node
and its parents
Arguments:
CComBSTR & bstrPath : Returns metabase path
Return Value:
HRESULT
--*/
{
//
// This starts off the path
//
bstrPath.Append(_cszSeparator);
bstrPath.Append(QueryNodeName());
return S_OK;
}
/* virtual */
HRESULT
CIISMachine::BuildURL(
OUT CComBSTR & bstrURL
) const
/*++
Routine Description:
Recursively build up the URL from the current node
and its parents. The URL built up from a machine node
doesn't make a lot of sense, but for want of anything better,
this will bring up the default web site.
Arguments:
CComBSTR & bstrURL : Returns URL
Return Value:
HRESULT
--*/
{
CString strOwner;
if (IsLocal())
{
//
// Security reasons restrict this to "localhost" oftentimes
//
strOwner = _bstrLocalHost;
}
else
{
LPOLESTR lpOwner = QueryMachineName();
strOwner = PURE_COMPUTER_NAME(lpOwner);
}
//
// An URL on the machine node is built in isolation.
//
// ISSUE: Is this really a desirable URL? Maybe we should
// use something else.
//
bstrURL = _T("http://");
bstrURL.Append(strOwner);
return S_OK;
}
/* virtual */
HRESULT
CIISMachine::CreatePropertyPages(
IN LPPROPERTYSHEETCALLBACK lpProvider,
IN LONG_PTR handle,
IN IUnknown * pUnk,
IN DATA_OBJECT_TYPES type
)
/*++
Routine Description:
Create the property pages for the given object
Arguments:
LPPROPERTYSHEETCALLBACK lpProvider : Provider
LONG_PTR handle : Handle.
IUnknown * pUnk,
DATA_OBJECT_TYPES type
Return Value:
HRESULT
--*/
{
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
CComBSTR bstrPath;
//
// ISSUE: What to do with m_err? This might be
// a bad machine object in the first place. Aborting
// when the machine object has an error code isn't
// such a bad solution here. If the error condition
// no longer exists, a refresh will cure.
//
if (m_err.Failed())
{
m_err.MessageBox();
return m_err;
}
CError err(BuildMetaPath(bstrPath));
if (err.Succeeded())
{
CIISMachineSheet * pSheet = new CIISMachineSheet(
QueryAuthInfo(),
bstrPath,
GetMainWindow(),
(LPARAM)this,
handle
);
if (pSheet)
{
pSheet->SetModeless();
//
// Add pages
//
err = AddMMCPage(lpProvider, new CIISMachinePage(pSheet));
}
else
{
err = ERROR_NOT_ENOUGH_MEMORY;
}
}
err.MessageBoxOnFailure();
return err;
}
/* virtual */
HRESULT
CIISMachine::EnumerateScopePane(
IN HSCOPEITEM hParent
)
/*++
Routine Description:
Enumerate scope child items.
Arguments:
HSCOPEITEM hParent : Parent console handle
Return Value:
HRESULT
--*/
{
ASSERT_PTR(_lpConsoleNameSpace);
ASSERT(m_hScopeItem == hParent);
CError err;
CString str;
CIISService * pService, * pWebService = NULL;
CWaitCursor wait;
CMetaEnumerator * pme = NULL;
if (IsExpanded())
{
//
// Verify user credentials are satisfactorily resolved.
// Machines objects are loaded from the cache without a
// password, so the function below will ask for it.
//
ResolveCredentials();
wait.Restore();
BOOL fShouldRefresh = !HasInterface();
err = AssureInterfaceCreated(FALSE);
if (err.Succeeded())
{
//
// Creation of the interface will have loaded display parameters, which
// may differ from the cached parameters.
//
if (fShouldRefresh)
{
RefreshDisplay();
}
err = CreateEnumerator(pme);
}
//
// Only check for acces denied now, because virtually any idiot
// is allowed to create a metabase interface, but will get the
// access denied when calling a method, such as enumeration.
//
if (HandleAccessDenied(err))
{
wait.Restore();
//
// Credentials were changed. Try again (interface should be
// created already)
//
SAFE_DELETE(pme);
if (err.Succeeded())
{
err = CreateEnumerator(pme);
}
}
//
// Enumerate administerable services from the metabase
//
while (err.Succeeded())
{
err = pme->Next(str);
if (err.Succeeded())
{
TRACEEOLID("Enumerating node: " << str);
pService = new CIISService(this, str);
if (!pService)
{
err = ERROR_NOT_ENOUGH_MEMORY;
break;
}
//
// See if we care
//
if (pService->IsManagedService())
{
err = pService->AddToScopePane(hParent);
if (err.Succeeded())
{
if (0 == lstrcmpi(pService->GetNodeName(), SZ_MBN_WEB))
{
pWebService = pService;
}
}
}
else
{
//
// Node is not a managed service, or we're managing the
// cluster and the service is not clustered.
//
delete pService;
}
}
}
if (err.Win32Error() == ERROR_NO_MORE_ITEMS)
{
err.Reset();
}
// If we are encountered web service, we should add
// Application Pools container before this service
//
if (err.Succeeded() && pWebService != NULL)
{
// We could have iis5 machine which doesn't have any pools
//
CMetaKey mk(pme, _T("/LM/W3SVC/AppPools"));
if (mk.Succeeded())
{
CAppPoolsContainer * pPools = new CAppPoolsContainer(
this, pWebService);
if (!pPools)
{
err = ERROR_NOT_ENOUGH_MEMORY;
goto Fail;
}
// Insert pools container before Web Services node
err = pPools->AddToScopePane(
pWebService->QueryScopeItem(), FALSE, TRUE);
}
}
Fail:
if (err.Failed())
{
DisplayError(err);
}
SetInterfaceError(err);
//
// Clean up
//
SAFE_DELETE(pme);
}
return err;
}
/* virtual */
HRESULT
CIISMachine::RemoveScopeItem()
/*++
Routine Description:
Remove the machine from the scope view and the cache.
Arguments:
None
Return Value:
HRESULT
--*/
{
ASSERT(m_pRootExt == NULL);
//
// Find out root before deleting scope node
//
CIISRoot * pRoot = GetRoot();
ASSERT_PTR(pRoot);
//
// Remove from the tree
//
HRESULT hr = CIISMBNode::RemoveScopeItem();
if (SUCCEEDED(hr) && pRoot)
{
pRoot->m_scServers.Remove(this);
}
return hr;
}
/* virtual */
LPOLESTR
CIISMachine::GetResultPaneColInfo(int nCol)
/*++
Routine Description:
Return result pane string for the given column number
Arguments:
int nCol : Column number
Return Value:
String
--*/
{
if (m_pRootExt != NULL)
{
return m_pRootExt->GetResultPaneColInfo(nCol);
}
ASSERT(_fStaticsLoaded);
switch(nCol)
{
case COL_NAME:
return QueryDisplayName();
case COL_LOCAL:
return IsLocal() ? _bstrYes : _bstrNo;
case COL_VERSION:
{
CString str;
str.Format(_bstrVersionFmt, QueryMajorVersion(), QueryMinorVersion());
_bstrResult = str;
}
return _bstrResult;
case COL_STATUS:
{
if (m_err.Succeeded())
{
return OLESTR("");
}
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
return m_err;
}
}
ASSERT_MSG("Bad column number");
return OLESTR("");
}
/* virtual */
HRESULT
CIISMachine::AddMenuItems(
IN LPCONTEXTMENUCALLBACK lpContextMenuCallback,
IN OUT long * pInsertionAllowed,
IN DATA_OBJECT_TYPES type
)
/*++
Routine Description:
Add menu items to the context menu
Arguments:
LPCONTEXTMENUCALLBACK lpContextMenuCallback : Context menu callback
long * pInsertionAllowed : Insertion allowed
DATA_OBJECT_TYPES type : Object type
Return Value:
HRESULT
--*/
{
ASSERT_READ_PTR(lpContextMenuCallback);
//
// Add base menu items
//
HRESULT hr = CIISObject::AddMenuItems(
lpContextMenuCallback,
pInsertionAllowed,
type
);
if (SUCCEEDED(hr))
{
if (IsAdministrator() && (*pInsertionAllowed & CCM_INSERTIONALLOWED_TASK) != 0)
{
AddMenuItemByCommand(lpContextMenuCallback, IDM_METABACKREST);
AddMenuItemByCommand(lpContextMenuCallback, IDM_SHUTDOWN);
}
#if 0
if (CanAddInstance())
{
ASSERT(pInsertionAllowed != NULL);
if ((*pInsertionAllowed & CCM_INSERTIONALLOWED_NEW) != 0)
{
#define ADD_SERVICE_MENU(x)\
if (!bSepAdded)\
{\
AddMenuSeparator(lpContextMenuCallback);\
bSepAdded = TRUE;\
}\
AddMenuItemByCommand(lpContextMenuCallback, (x))
HSCOPEITEM hChild = NULL, hCurrent;
LONG_PTR cookie;
BOOL bSepAdded = FALSE;
hr = _lpConsoleNameSpace->GetChildItem(QueryScopeItem(), &hChild, &cookie);
while (SUCCEEDED(hr) && hChild != NULL)
{
CIISMBNode * pNode = (CIISMBNode *)cookie;
ASSERT(pNode != NULL);
if (lstrcmpi(pNode->GetNodeName(), SZ_MBN_FTP) == 0)
{
ADD_SERVICE_MENU(IDM_NEW_FTP_SITE);
}
else if (lstrcmpi(pNode->GetNodeName(), SZ_MBN_WEB) == 0)
{
ADD_SERVICE_MENU(IDM_NEW_WEB_SITE);
}
else if (lstrcmpi(pNode->GetNodeName(), SZ_MBN_APP_POOLS) == 0)
{
ADD_SERVICE_MENU(IDM_NEW_APP_POOL);
}
hCurrent = hChild;
hr = _lpConsoleNameSpace->GetNextItem(hCurrent, &hChild, &cookie);
}
}
}
#endif
//
// CODEWORK: Add new instance commands for each of the services
// keeping in mind which ones are installed and all.
// add that info to the table, remembering that this
// is per service.
//
}
return hr;
}
#if 0
// BUGBUG: It should be quite different -> we don't know in advance
// which service is this site for
HRESULT
CIISMachine::InsertNewInstance(DWORD inst)
{
CError err;
// Now we should insert and select this new site
TCHAR buf[16];
CIISSite * pSite = new CIISSite(m_pOwner, this, _itot(inst, buf, 10));
if (pSite != NULL)
{
// If machine is not expanded we will get error and no effect
if (!IsExpanded())
{
SelectScopeItem();
IConsoleNameSpace2 * pConsole
= (IConsoleNameSpace2 *)GetConsoleNameSpace();
pConsole->Expand(QueryScopeItem());
}
// Now we should find the relevant service node, and inset this one under
// this node
err = pSite->AddToScopePaneSorted(QueryScopeItem(), FALSE);
if (err.Succeeded())
{
VERIFY(SUCCEEDED(pSite->SelectScopeItem()));
}
}
else
{
err = ERROR_NOT_ENOUGH_MEMORY;
}
return err;
}
#endif
HRESULT
CIISMachine::Command(
IN long lCommandID,
IN CSnapInObjectRootBase * pObj,
IN DATA_OBJECT_TYPES type
)
/*++
Routine Description:
Handle command from context menu.
Arguments:
long lCommandID : Command ID
CSnapInObjectRootBase * pObj : Base object
DATA_OBJECT_TYPES type : Data object type
Return Value:
HRESULT
--*/
{
HRESULT hr = S_OK;
switch (lCommandID)
{
case IDM_DISCONNECT:
hr = OnDisconnect();
break;
case IDM_METABACKREST:
hr = OnMetaBackRest();
break;
case IDM_SHUTDOWN:
hr = OnShutDown();
break;
#if 0
case IDM_NEW_FTP_SITE:
if (SUCCEEDED(hr = AddFTPSite(pObj, type, &inst)))
{
hr = InsertNewInstance(inst);
}
break;
case IDM_NEW_WEB_SITE:
if (SUCCEEDED(hr = AddWebSite(pObj, type, &inst)))
{
hr = InsertNewInstance(inst);
}
break;
case IDM_NEW_APP_POOL:
hr = AddAppPool(pObj, type);
break;
#endif
//
// Pass on to base class
//
default:
hr = CIISMBNode::Command(lCommandID, pObj, type);
}
return hr;
}
HRESULT
CIISMachine::OnDisconnect()
/*++
Routine Description:
Disconnect this machine. Confirm user choice.
Arguments:
None
Return Value:
HRESULT
--*/
{
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
CString str;
str.Format(IDS_CONFIRM_DISCONNECT, QueryDisplayName());
if (NoYesMessageBox(str))
{
return RemoveScopeItem();
}
return S_OK;
}
HRESULT
CIISMachine::OnMetaBackRest()
/*++
Routine Description:
Backup/Restore the metabase
Arguments:
None
Return Value:
HRESULT
--*/
{
CError err;
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
//
// Verify user credentials are satisfactorily resolved.
// Machines objects are loaded from the cache without a
// password, so the function below will ask for it.
//
ResolveCredentials();
CBackupDlg dlg(this, GetMainWindow());
dlg.DoModal();
if (dlg.HasChangedMetabase())
{
//
// Refresh and re-enumerate child objects
//
err = Refresh(TRUE);
}
return err;
}
HRESULT
CIISMachine::OnShutDown()
/*++
Routine Description:
Bring up the IIS shutdown dialog. If the services on the remote
machine are restarted, the metabase interface should be recreated.
Arguments:
None
Return Value:
HRESULT
--*/
{
CError err;
AFX_MANAGE_STATE(::AfxGetStaticModuleState());
//
// Verify user credentials are satisfactorily resolved.
// Machines objects are loaded from the cache without a
// password, so the function below will ask for it.
//
ResolveCredentials();
CIISShutdownDlg dlg(this, GetMainWindow());
dlg.DoModal();
if (dlg.ServicesWereRestarted())
{
//
// Rebind all metabase handles on this server
//
err = CreateInterface(TRUE);
//
// Now do a refresh on the computer node. Since we've forced
// the rebinding already, we should not get the disconnect warning.
//
if (err.Succeeded())
{
err = Refresh(TRUE);
}
}
return err;
}
Reference in a new issue View git blame Copy permalink