1750 lines
53 KiB
C++
1750 lines
53 KiB
C++
// compdata.cpp : Implementation of CFileMgmtComponentData
|
|
/*
|
|
History:
|
|
8/20/97 EricDav
|
|
Added Configure File Server for Macintosh menu item to the
|
|
root node. Only shows up if SFM is installed and the user
|
|
has admin access to that machine.
|
|
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "cookie.h"
|
|
#include "safetemp.h"
|
|
|
|
#include "macros.h"
|
|
USE_HANDLE_MACROS("FILEMGMT(compdata.cpp)")
|
|
|
|
#include "dataobj.h"
|
|
#include "compdata.h"
|
|
#include "cmponent.h"
|
|
#include "DynamLnk.h" // DynamicDLL
|
|
|
|
#include "FileSvc.h" // FileServiceProvider
|
|
#include "smb.h"
|
|
#include "sfm.h"
|
|
|
|
#include "SnapMgr.h" // CFileMgtGeneral: Snapin Manager property page
|
|
#include "chooser2.h" // CHOOSER2_PickTargetComputer
|
|
|
|
#include <compuuid.h> // UUIDs for Computer Management
|
|
|
|
#include <safeboot.h> // for SAFEBOOT_MINIMAL
|
|
#include <shlwapi.h> // for IsOS
|
|
#include <shlwapip.h> // for IsOS
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#include "stdcdata.cpp" // CComponentData implementation
|
|
#include "chooser2.cpp" // CHOOSER2_PickTargetComputer implementation
|
|
|
|
//
|
|
// CFileMgmtComponentData
|
|
//
|
|
|
|
CString g_strTransportSMB;
|
|
CString g_strTransportSFM;
|
|
|
|
BOOL g_fTransportStringsLoaded = FALSE;
|
|
|
|
CFileMgmtComponentData::CFileMgmtComponentData()
|
|
: m_fLoadedFileMgmtToolbarBitmap(FALSE),
|
|
m_fLoadedSvcMgmtToolbarBitmap(FALSE),
|
|
m_pRootCookie( NULL ),
|
|
m_hScManager( NULL ),
|
|
m_SchemaSupportSharePublishing(SHAREPUBLISH_SCHEMA_UNASSIGNED),
|
|
m_bIsSimpleUI(FALSE),
|
|
m_fQueryServiceConfig2( TRUE ) // Pretend the target machine does support QueryServiceConfig2() API
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
//
|
|
// We must refcount the root cookie, since a dataobject for it
|
|
// might outlive the IComponentData. JonN 9/2/97
|
|
//
|
|
m_pRootCookie = new CFileMgmtScopeCookie();
|
|
ASSERT(NULL != m_pRootCookie);
|
|
// JonN 10/27/98 All CRefcountedObject's start with refcount==1
|
|
// m_pRootCookie->AddRef();
|
|
|
|
m_apFileServiceProviders[FILEMGMT_SMB] = new SmbFileServiceProvider(this);
|
|
m_apFileServiceProviders[FILEMGMT_SFM] = new SfmFileServiceProvider(this);
|
|
m_dwFlagsPersist = 0;
|
|
m_fAllowOverrideMachineName = TRUE;
|
|
ASSERT( 2 == FILEMGMT_NUM_TRANSPORTS );
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
m_RegistryParsedYet = FALSE;
|
|
#endif
|
|
|
|
if (!g_fTransportStringsLoaded)
|
|
{
|
|
g_fTransportStringsLoaded = TRUE;
|
|
VERIFY( g_strTransportSMB.LoadString(IDS_TRANSPORT_SMB) );
|
|
VERIFY( g_strTransportSFM.LoadString(IDS_TRANSPORT_SFM) );
|
|
}
|
|
}
|
|
|
|
|
|
CFileMgmtComponentData::~CFileMgmtComponentData()
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState()); // required for CWaitCursor
|
|
for (INT i = 0; i < FILEMGMT_NUM_TRANSPORTS; i++)
|
|
{
|
|
delete m_apFileServiceProviders[i];
|
|
m_apFileServiceProviders[i] = NULL;
|
|
}
|
|
// Close the service control manager
|
|
Service_CloseScManager();
|
|
m_pRootCookie->Release();
|
|
m_pRootCookie = NULL;
|
|
}
|
|
|
|
DEFINE_FORWARDS_MACHINE_NAME( CFileMgmtComponentData, m_pRootCookie )
|
|
|
|
|
|
CFileSvcMgmtSnapin::CFileSvcMgmtSnapin()
|
|
{
|
|
// The identity of the default root node is the only difference
|
|
// between the File Management snapin and the Service Management snapins
|
|
QueryRootCookie().SetObjectType( FILEMGMT_ROOT );
|
|
SetHtmlHelpFileName (L"file_srv.chm");
|
|
}
|
|
|
|
CFileSvcMgmtSnapin::~CFileSvcMgmtSnapin()
|
|
{
|
|
}
|
|
|
|
CServiceMgmtSnapin::CServiceMgmtSnapin()
|
|
{
|
|
// The identity of the default root node is the only difference
|
|
// between the File Management snapin and the Service Management snapins
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
QueryRootCookie().SetObjectType( FILEMGMT_PROTOTYPER );
|
|
#else
|
|
QueryRootCookie().SetObjectType( FILEMGMT_SERVICES );
|
|
#endif
|
|
SetHtmlHelpFileName (L"sys_srv.chm");
|
|
}
|
|
|
|
CServiceMgmtSnapin::~CServiceMgmtSnapin()
|
|
{
|
|
}
|
|
|
|
CFileSvcMgmtExtension::CFileSvcMgmtExtension()
|
|
{
|
|
// The root cookie is not used
|
|
SetHtmlHelpFileName (L"file_srv.chm");
|
|
}
|
|
|
|
CFileSvcMgmtExtension::~CFileSvcMgmtExtension()
|
|
{
|
|
}
|
|
|
|
CServiceMgmtExtension::CServiceMgmtExtension()
|
|
{
|
|
// The root cookie is not used
|
|
SetHtmlHelpFileName (L"sys_srv.chm");
|
|
}
|
|
|
|
CServiceMgmtExtension::~CServiceMgmtExtension()
|
|
{
|
|
}
|
|
|
|
CCookie& CFileMgmtComponentData::QueryBaseRootCookie()
|
|
{
|
|
ASSERT(NULL != m_pRootCookie);
|
|
return (CCookie&)(*m_pRootCookie);
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFileMgmtComponentData::CreateComponent(LPCOMPONENT* ppComponent)
|
|
{
|
|
MFC_TRY;
|
|
|
|
ASSERT(ppComponent != NULL);
|
|
|
|
CComObject<CFileMgmtComponent>* pObject;
|
|
HRESULT hr = CComObject<CFileMgmtComponent>::CreateInstance(&pObject);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
pObject->SetComponentDataPtr( (CFileMgmtComponentData*)this );
|
|
|
|
return pObject->QueryInterface(IID_IComponent,
|
|
reinterpret_cast<void**>(ppComponent));
|
|
|
|
MFC_CATCH;
|
|
}
|
|
|
|
|
|
HRESULT CFileMgmtComponentData::LoadIcons(LPIMAGELIST pImageList, BOOL fLoadLargeIcons)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( )); // 2002/03/22-JonN 572859
|
|
|
|
HBITMAP hBMSm = NULL;
|
|
HBITMAP hBMLg = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
hBMSm = ::LoadBitmap(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDB_FILEMGMT_ICONS_16));
|
|
if (!hBMSm)
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
|
|
if (fLoadLargeIcons)
|
|
{
|
|
hBMLg = ::LoadBitmap(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDB_FILEMGMT_ICONS_32));
|
|
if (!hBMLg)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
DeleteObject(hBMSm);
|
|
return hr;
|
|
}
|
|
}
|
|
hr = pImageList->ImageListSetStrip((LONG_PTR *)hBMSm, (LONG_PTR *)hBMLg, iIconSharesFolder, RGB(255,0,255));
|
|
DeleteObject(hBMSm);
|
|
if (fLoadLargeIcons)
|
|
DeleteObject(hBMLg);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hBMSm = ::LoadBitmap(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDB_SVCMGMT_ICONS_16));
|
|
if (!hBMSm)
|
|
return HRESULT_FROM_WIN32(GetLastError());
|
|
if (fLoadLargeIcons)
|
|
{
|
|
hBMLg = ::LoadBitmap(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDB_SVCMGMT_ICONS_32));
|
|
if (!hBMLg)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
DeleteObject(hBMSm);
|
|
return hr;
|
|
}
|
|
}
|
|
hr = pImageList->ImageListSetStrip((LONG_PTR *)hBMSm, (LONG_PTR *)hBMLg, iIconService, RGB(255,0,255));
|
|
DeleteObject(hBMSm);
|
|
if (fLoadLargeIcons)
|
|
DeleteObject(hBMLg);
|
|
|
|
return hr;
|
|
}
|
|
|
|
GUID g_guidSystemTools = structuuidNodetypeSystemTools;
|
|
GUID g_guidServerApps = structuuidNodetypeServerApps;
|
|
|
|
BOOL CFileMgmtComponentData::IsExtendedNodetype( GUID& refguid )
|
|
{
|
|
return (refguid == g_guidSystemTools || refguid == g_guidServerApps);
|
|
}
|
|
|
|
HRESULT CFileMgmtComponentData::AddScopeCookie( HSCOPEITEM hParent,
|
|
LPCTSTR lpcszTargetServer,
|
|
FileMgmtObjectType objecttype,
|
|
CFileMgmtCookie* pParentCookie )
|
|
{
|
|
SCOPEDATAITEM tSDItem;
|
|
::ZeroMemory(&tSDItem,sizeof(tSDItem));
|
|
tSDItem.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE | SDI_STATE | SDI_PARAM | SDI_PARENT;
|
|
tSDItem.displayname = MMC_CALLBACK;
|
|
// CODEWORK should use MMC_ICON_CALLBACK here
|
|
tSDItem.relativeID = hParent;
|
|
tSDItem.nState = 0;
|
|
|
|
if (FILEMGMT_ROOT != objecttype)
|
|
{
|
|
// no children
|
|
tSDItem.mask |= SDI_CHILDREN; // note that cChildren is still 0
|
|
}
|
|
|
|
CFileMgmtScopeCookie* pCookie = new CFileMgmtScopeCookie(
|
|
lpcszTargetServer,
|
|
objecttype);
|
|
if (NULL != pParentCookie)
|
|
pParentCookie->m_listScopeCookieBlocks.AddHead( pCookie );
|
|
// WARNING cookie cast
|
|
tSDItem.lParam = reinterpret_cast<LPARAM>((CCookie*)pCookie);
|
|
tSDItem.nImage = QueryImage( *pCookie, FALSE );
|
|
tSDItem.nOpenImage = QueryImage( *pCookie, TRUE );
|
|
return m_pConsoleNameSpace->InsertItem(&tSDItem);
|
|
}
|
|
|
|
BOOL IsSimpleUI(PCTSTR pszMachineName);
|
|
|
|
HRESULT CFileMgmtComponentData::OnNotifyExpand(
|
|
LPDATAOBJECT lpDataObject,
|
|
BOOL bExpanding,
|
|
HSCOPEITEM hParent)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
CWaitCursor wait;
|
|
|
|
if (!bExpanding)
|
|
return S_OK;
|
|
|
|
GUID guidObjectType;
|
|
HRESULT hr = ExtractObjectTypeGUID( lpDataObject, &guidObjectType );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
if ( IsExtendedNodetype(guidObjectType) )
|
|
{
|
|
CString strServerName;
|
|
hr = ExtractString( lpDataObject, CFileMgmtDataObject::m_CFMachineName, &strServerName, MAX_PATH );
|
|
if ( FAILED(hr) )
|
|
{
|
|
ASSERT( FALSE );
|
|
return hr;
|
|
}
|
|
// JonN 10/27/98: We add these nodes under the root cookie
|
|
return AddScopeNodes( strServerName, hParent, &QueryRootCookie() );
|
|
}
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
FileMgmtObjectType objecttype =
|
|
(FileMgmtObjectType)CheckObjectTypeGUID( &guidObjectType );
|
|
hr = ExtractBaseCookie( lpDataObject, &pbasecookie );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
CFileMgmtCookie* pParentCookie = (CFileMgmtCookie*)pbasecookie;
|
|
|
|
if (NULL == pParentCookie) // JonN 05/30/00 PREFIX 110945
|
|
{
|
|
ASSERT(FALSE);
|
|
return S_OK;
|
|
}
|
|
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
//(void)Prototyper_HrEnumerateScopeChildren(pParentCookie, hParent);
|
|
return S_OK;
|
|
#endif
|
|
|
|
switch ( objecttype )
|
|
{
|
|
// This node type has a child
|
|
case FILEMGMT_ROOT:
|
|
if ( !IsExtensionSnapin() )
|
|
{
|
|
// Ensure that node is formatted correctly
|
|
CString machineName = pParentCookie->QueryNonNULLMachineName ();
|
|
if ( !pParentCookie->m_hScopeItem )
|
|
pParentCookie->m_hScopeItem = hParent;
|
|
|
|
m_strMachineNamePersist = machineName; // init m_strMachineNamePersist
|
|
hr = ChangeRootNodeName (machineName);
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
|
|
// These node types have no children
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
case FILEMGMT_SERVICES:
|
|
return S_OK;
|
|
|
|
case FILEMGMT_SHARE:
|
|
case FILEMGMT_SESSION:
|
|
case FILEMGMT_RESOURCE:
|
|
case FILEMGMT_SERVICE:
|
|
TRACE( "CFileMgmtComponentData::EnumerateScopeChildren node type should not be in scope pane\n" );
|
|
// fall through
|
|
default:
|
|
TRACE( "CFileMgmtComponentData::EnumerateScopeChildren bad parent type\n" );
|
|
ASSERT( FALSE );
|
|
return S_OK;
|
|
}
|
|
|
|
if ( NULL == hParent || !(pParentCookie->m_listScopeCookieBlocks).IsEmpty() )
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
return AddScopeNodes( pParentCookie->QueryTargetServer(), hParent, pParentCookie );
|
|
}
|
|
|
|
//
|
|
// 7/11/2001 LinanT
|
|
// Determine if the schema supports share publishing or not. This information is used
|
|
// to decide whether to show the Publish tab on a share's property sheet.
|
|
// We only need to do this once on current-retargeted computer. The ReInit() process
|
|
// will reset this member variable if computer has been retargeted.
|
|
//
|
|
BOOL CFileMgmtComponentData::GetSchemaSupportSharePublishing()
|
|
{
|
|
if (SHAREPUBLISH_SCHEMA_UNASSIGNED == m_SchemaSupportSharePublishing)
|
|
{
|
|
if (S_OK == CheckSchemaVersion(QueryRootCookie().QueryNonNULLMachineName()))
|
|
m_SchemaSupportSharePublishing = SHAREPUBLISH_SCHEMA_SUPPORTED;
|
|
else
|
|
m_SchemaSupportSharePublishing = SHAREPUBLISH_SCHEMA_UNSUPPORTED;
|
|
}
|
|
|
|
return (SHAREPUBLISH_SCHEMA_SUPPORTED == m_SchemaSupportSharePublishing);
|
|
}
|
|
|
|
//
|
|
// 7/11/2001 LinanT
|
|
// Cache the interface pointer to the computer object in AD. This information is
|
|
// used to speed up the multiple-shares-deletion process.
|
|
// We only need to do this once on current-retargeted computer. The ReInit() process
|
|
// will reset this member variable if computer has been retargeted.
|
|
//
|
|
IADsContainer *CFileMgmtComponentData::GetIADsContainer()
|
|
{
|
|
if (!m_spiADsContainer)
|
|
{
|
|
if (GetSchemaSupportSharePublishing())
|
|
{
|
|
CString strADsPath, strDCName;
|
|
HRESULT hr = GetADsPathOfComputerObject(QueryRootCookie().QueryNonNULLMachineName(), strADsPath, strDCName);
|
|
if (SUCCEEDED(hr))
|
|
ADsGetObject(strADsPath, IID_IADsContainer, (void**)&m_spiADsContainer);
|
|
}
|
|
}
|
|
|
|
return (IADsContainer *)m_spiADsContainer;
|
|
}
|
|
|
|
//
|
|
// 7/11/2001 LinanT
|
|
// Re-initialize several "global" member variables based on the current-targeted computer.
|
|
// These variables are all related to share operations.
|
|
//
|
|
HRESULT CFileMgmtComponentData::ReInit(LPCTSTR lpcszTargetServer)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
CWaitCursor wait;
|
|
|
|
//
|
|
// re-initialize several global variables based on the targeted server
|
|
//
|
|
|
|
SetIsSimpleUI(IsSimpleUI(lpcszTargetServer));
|
|
|
|
//
|
|
// reset schema version of the domain the targeted machine belongs to
|
|
//
|
|
m_SchemaSupportSharePublishing = SHAREPUBLISH_SCHEMA_UNASSIGNED;
|
|
|
|
//
|
|
// reset the interface pointer to the AD container
|
|
//
|
|
if ((IADsContainer *)m_spiADsContainer)
|
|
m_spiADsContainer.Release();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFileMgmtComponentData::AddScopeNodes( LPCTSTR lpcszTargetServer,
|
|
HSCOPEITEM hParent,
|
|
CFileMgmtCookie* pParentCookie )
|
|
{
|
|
ASSERT( NULL != pParentCookie );
|
|
|
|
//
|
|
// Create new cookies
|
|
//
|
|
|
|
LoadGlobalStrings();
|
|
|
|
if (IsExtensionSnapin())
|
|
{
|
|
ASSERT( pParentCookie->m_listScopeCookieBlocks.IsEmpty() );
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
if (IsServiceSnapin())
|
|
{
|
|
if ( IsExtensionSnapin() )
|
|
{
|
|
hr = AddScopeCookie( hParent, lpcszTargetServer, FILEMGMT_SERVICES, pParentCookie );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
if (IsExtensionSnapin() && (pParentCookie == m_pRootCookie)) // called as extension
|
|
{
|
|
QueryRootCookie().SetMachineName(lpcszTargetServer);
|
|
hr = AddScopeCookie( hParent, lpcszTargetServer, FILEMGMT_ROOT, pParentCookie );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// 7/11/2001 LinanT bug#433102
|
|
// Before we insert the "Shares" scope node, we need to
|
|
// re-initialize related global variables on currently targeted computer.
|
|
//
|
|
ReInit(lpcszTargetServer);
|
|
|
|
hr = AddScopeCookie( hParent, lpcszTargetServer, FILEMGMT_SHARES, pParentCookie );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
hr = AddScopeCookie( hParent, lpcszTargetServer, FILEMGMT_SESSIONS, pParentCookie );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
hr = AddScopeCookie( hParent, lpcszTargetServer, FILEMGMT_RESOURCES, pParentCookie );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT CFileMgmtComponentData::OnNotifyDelete(LPDATAOBJECT /*lpDataObject*/)
|
|
{
|
|
// CODEWORK The user hit the Delete key, I should deal with this
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// JonN 10/27/98: We must release the children of the root cookie
|
|
// JonN 10/27/98: We must release the cached Service Controller handle
|
|
HRESULT CFileMgmtComponentData::OnNotifyRelease(LPDATAOBJECT lpDataObject, HSCOPEITEM /*hItem*/)
|
|
{
|
|
GUID guidObjectType;
|
|
HRESULT hr = ExtractObjectTypeGUID( lpDataObject, &guidObjectType );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
if ( IsExtendedNodetype(guidObjectType) )
|
|
{
|
|
// EricDav 3/19/99: We need to close the SCManager for both the service
|
|
// snapin and the file mgmt snapin as the SFM config part uses this as well.
|
|
Service_CloseScManager();
|
|
|
|
QueryRootCookie().ReleaseScopeChildren();
|
|
}
|
|
// CODEWORK This will release all top-level extension scopenodes, not just those
|
|
// under this particular external scopenode. I depend on the fact that COMPMGMT
|
|
// will only create one instance of System Tools. JonN 10/27/98
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
STDMETHODIMP CFileMgmtComponentData::AddMenuItems(
|
|
IDataObject* piDataObject,
|
|
IContextMenuCallback* piCallback,
|
|
long* pInsertionAllowed)
|
|
{
|
|
MFC_TRY;
|
|
|
|
TRACE_METHOD(CFileMgmtComponentData,AddMenuItems);
|
|
TEST_NONNULL_PTR_PARAM(piDataObject);
|
|
TEST_NONNULL_PTR_PARAM(piCallback);
|
|
TEST_NONNULL_PTR_PARAM(pInsertionAllowed);
|
|
TRACE( "FileMgmt snapin: extending menu\n" );
|
|
|
|
DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
|
|
HRESULT hr = ExtractData( piDataObject,
|
|
CFileMgmtDataObject::m_CFDataObjectType,
|
|
&dataobjecttype,
|
|
sizeof(dataobjecttype) );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
|
|
GUID guidObjectType = GUID_NULL; // JonN 11/21/00 PREFIX 226044
|
|
hr = ExtractObjectTypeGUID( piDataObject, &guidObjectType );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
int objecttype = FilemgmtCheckObjectTypeGUID(IN &guidObjectType);
|
|
if (objecttype == -1)
|
|
{
|
|
// We don't recognize the GUID, therefore we assume
|
|
// the node wants to be extended by the service snapin.
|
|
(void)Service_FAddMenuItems(piCallback, piDataObject, TRUE);
|
|
return S_OK;
|
|
}
|
|
return DoAddMenuItems( piCallback, (FileMgmtObjectType)objecttype, dataobjecttype, pInsertionAllowed, piDataObject );
|
|
|
|
MFC_CATCH;
|
|
} // CFileMgmtComponentData::AddMenuItems()
|
|
|
|
HRESULT CFileMgmtComponentData::DoAddMenuItems( IContextMenuCallback* piCallback,
|
|
FileMgmtObjectType objecttype,
|
|
DATA_OBJECT_TYPES /*dataobjecttype*/,
|
|
long* pInsertionAllowed,
|
|
IDataObject* piDataObject)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if ( !IsExtensionSnapin()
|
|
&& (objecttype == m_pRootCookie->QueryObjectType()) )
|
|
{
|
|
if (CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_CHANGE_COMPUTER_TOP,
|
|
IDS_CHANGE_COMPUTER_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("ChangeComputerTop") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_CHANGE_COMPUTER_TASK,
|
|
IDS_CHANGE_COMPUTER_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("ChangeComputerTask") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
}
|
|
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_ROOT:
|
|
{
|
|
// check to see if this machine has SFM installed
|
|
// if so, display the menu item.
|
|
SfmFileServiceProvider* pProvider =
|
|
(SfmFileServiceProvider*) GetFileServiceProvider(FILEMGMT_SFM);
|
|
|
|
CString strServerName;
|
|
HRESULT hr = ExtractString( piDataObject, CFileMgmtDataObject::m_CFMachineName, &strServerName, MAX_PATH );
|
|
if ( FAILED(hr) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (m_hScManager == NULL)
|
|
{
|
|
Service_EOpenScManager(strServerName);
|
|
}
|
|
|
|
if ( pProvider->FSFMInstalled(strServerName) )
|
|
{
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_CONFIG_SFM_TASK,
|
|
IDS_CONFIG_SFM_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("ConfigSFMTask") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_CONFIG_SFM_TOP,
|
|
IDS_CONFIG_SFM_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("ConfigSFMTop") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case FILEMGMT_SHARES:
|
|
//
|
|
// don't add New Share Wizard to the menu whenever SimpleSharingUI appears in NT Explorer
|
|
//
|
|
if (GetIsSimpleUI())
|
|
break;
|
|
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_NEW_SHARE_TOP,
|
|
IDS_NEW_SHARE_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("NewShareTop") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_NEW & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_NEW_SHARE_NEW,
|
|
IDS_NEW_SHARE_NEW,
|
|
CCM_INSERTIONPOINTID_PRIMARY_NEW,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("NewShareNew") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
case FILEMGMT_SESSIONS:
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_DISCONNECT_ALL_SESSIONS_TOP,
|
|
IDS_DISCONNECT_ALL_SESSIONS_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("DisconnectAllSessionsTop") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_DISCONNECT_ALL_SESSIONS_TASK,
|
|
IDS_DISCONNECT_ALL_SESSIONS_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("DisconnectAllSessionsTask") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
case FILEMGMT_RESOURCES:
|
|
if ( CCM_INSERTIONALLOWED_TOP & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_DISCONNECT_ALL_RESOURCES_TOP,
|
|
IDS_DISCONNECT_ALL_RESOURCES_TOP,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TOP,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("DisconnectAllResourcesTop") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
if ( CCM_INSERTIONALLOWED_TASK & (*pInsertionAllowed) )
|
|
{
|
|
hr = LoadAndAddMenuItem(
|
|
piCallback,
|
|
IDS_DISCONNECT_ALL_RESOURCES_TASK,
|
|
IDS_DISCONNECT_ALL_RESOURCES_TASK,
|
|
CCM_INSERTIONPOINTID_PRIMARY_TASK,
|
|
0,
|
|
AfxGetInstanceHandle(),
|
|
_T("DisconnectAllResourcesTask") );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
}
|
|
break;
|
|
case FILEMGMT_SERVICES:
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
// (void)Prototyper_FAddMenuItemsFromHKey(piCallback, m_regkeySnapinDemoRoot);
|
|
#endif
|
|
break;
|
|
default:
|
|
ASSERT( FALSE );
|
|
break;
|
|
} // switch
|
|
|
|
return hr;
|
|
|
|
} // CFileMgmtComponentData::DoAddMenuItems()
|
|
|
|
|
|
STDMETHODIMP CFileMgmtComponentData::Command(
|
|
LONG lCommandID,
|
|
IDataObject* piDataObject )
|
|
{
|
|
MFC_TRY;
|
|
|
|
TRACE_METHOD(CFileMgmtComponentData,Command);
|
|
TEST_NONNULL_PTR_PARAM(piDataObject);
|
|
TRACE( "CFileMgmtComponentData::Command: command %ld selected\n", lCommandID );
|
|
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
Prototyper_ContextMenuCommand(lCommandID, piDataObject);
|
|
return S_OK;
|
|
#endif
|
|
|
|
BOOL fRefresh = FALSE;
|
|
switch (lCommandID)
|
|
{
|
|
case IDS_CHANGE_COMPUTER_TASK:
|
|
case IDS_CHANGE_COMPUTER_TOP:
|
|
{
|
|
HRESULT hr = OnChangeComputer(piDataObject);
|
|
fRefresh = ( SUCCEEDED(hr) && S_FALSE != hr );
|
|
}
|
|
break;
|
|
|
|
case IDS_NEW_SHARE_NEW:
|
|
case IDS_NEW_SHARE_TOP:
|
|
fRefresh = NewShare( piDataObject );
|
|
break;
|
|
|
|
case IDS_DISCONNECT_ALL_SESSIONS_TASK:
|
|
case IDS_DISCONNECT_ALL_SESSIONS_TOP:
|
|
fRefresh = DisconnectAllSessions( piDataObject );
|
|
break;
|
|
case IDS_DISCONNECT_ALL_RESOURCES_TASK:
|
|
case IDS_DISCONNECT_ALL_RESOURCES_TOP:
|
|
fRefresh = DisconnectAllResources( piDataObject );
|
|
break;
|
|
|
|
case IDS_CONFIG_SFM_TASK:
|
|
case IDS_CONFIG_SFM_TOP:
|
|
fRefresh = ConfigSfm( piDataObject );
|
|
break;
|
|
|
|
case cmServiceStart:
|
|
case cmServiceStop:
|
|
case cmServicePause:
|
|
case cmServiceResume:
|
|
case cmServiceRestart:
|
|
case cmServiceStartTask:
|
|
case cmServiceStopTask:
|
|
case cmServicePauseTask:
|
|
case cmServiceResumeTask:
|
|
case cmServiceRestartTask:
|
|
// Context menu extension
|
|
(void)Service_FDispatchMenuCommand(lCommandID, piDataObject);
|
|
Assert(FALSE == fRefresh && "Context menu extension not allowed to refresh result pane");
|
|
break;
|
|
|
|
case -1: // Received when back arrow pushed in console.
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE && "CFileMgmtComponentData::Command() - Invalid command ID");
|
|
break;
|
|
} // switch
|
|
|
|
if (fRefresh)
|
|
{
|
|
// clear all views of this data
|
|
m_pConsole->UpdateAllViews(piDataObject, 0L, 0L);
|
|
// reread all views of this data
|
|
m_pConsole->UpdateAllViews(piDataObject, 1L, 0L);
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
MFC_CATCH;
|
|
|
|
} // CFileMgmtComponentData::Command()
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// OnChangeComputer ()
|
|
//
|
|
// Purpose: Change the machine managed by the snapin
|
|
//
|
|
// Input: piDataObject - the selected node. This should be the root node
|
|
// of the snapin.
|
|
// Output: Returns S_OK on success
|
|
//
|
|
// JonN 12/10/99 Copied from MYCOMPUT
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
// 1. Launch object picker and get new computer name
|
|
// 2. Change root node text
|
|
// 3. Save new computer name to persistent name
|
|
// 4. Delete subordinate nodes
|
|
// 5. Re-add subordinate nodes
|
|
HRESULT CFileMgmtComponentData::OnChangeComputer( IDataObject * /*piDataObject*/ )
|
|
{
|
|
if ( IsExtensionSnapin() )
|
|
{
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
}
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
do { // false loop
|
|
|
|
HWND hWndParent = NULL;
|
|
hr = m_pConsole->GetMainWindow (&hWndParent);
|
|
ASSERT(SUCCEEDED(hr));
|
|
CComBSTR sbstrTargetComputer;
|
|
if ( !CHOOSER2_PickTargetComputer( AfxGetInstanceHandle(),
|
|
hWndParent,
|
|
&sbstrTargetComputer ) )
|
|
{
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
|
|
CString strTargetComputer = sbstrTargetComputer;
|
|
strTargetComputer.MakeUpper ();
|
|
|
|
// If the user chooses the local computer, treat that as if they had chosen
|
|
// "Local Computer" in Snapin Manager. This means that there is no way to
|
|
// reset the snapin to target explicitly at this computer without either
|
|
// reloading the snapin from Snapin Manager, or going to a different computer.
|
|
// When the Choose Target Computer UI is revised, we can make this more
|
|
// consistent with Snapin Manager.
|
|
if ( IsLocalComputername( strTargetComputer ) )
|
|
strTargetComputer = L"";
|
|
|
|
// If this is the same machine then don't do anything
|
|
if (m_strMachineNamePersist == strTargetComputer)
|
|
break;
|
|
|
|
if (strTargetComputer.Left(2) == _T("\\\\"))
|
|
QueryRootCookie().SetMachineName ((LPCTSTR)strTargetComputer + 2);
|
|
else
|
|
QueryRootCookie().SetMachineName (strTargetComputer);
|
|
|
|
// Set the persistent name. If we are managing the local computer
|
|
// this name should be empty.
|
|
m_strMachineNamePersist = strTargetComputer;
|
|
|
|
// This requires the MMCN_PRELOAD change so that we have the
|
|
// HSCOPEITEM for the root node
|
|
hr = ChangeRootNodeName (strTargetComputer);
|
|
if ( !SUCCEEDED(hr) )
|
|
break;
|
|
|
|
Service_CloseScManager();
|
|
|
|
// If the node hasn't already been expanded, or if it was previously
|
|
// expanded and there weren't any children, then there is no need
|
|
// to remove and replace and child nodes.
|
|
if ( QueryRootCookie().m_listScopeCookieBlocks.IsEmpty() )
|
|
{
|
|
//
|
|
// 7/11/2001 LinanT bug#433102
|
|
// When "Shares" is added to scope pane by itself as the root node, we need to
|
|
// re-initialize related global variables after computer retargeted.
|
|
//
|
|
FileMgmtObjectType objecttype = QueryRootCookie().QueryObjectType();
|
|
if (FILEMGMT_SHARES == objecttype)
|
|
ReInit(strTargetComputer); // these global variables are only needed by the share-related operations
|
|
break;
|
|
}
|
|
|
|
// Delete subordinates
|
|
HSCOPEITEM hRootScopeItem = QueryRootCookie().m_hScopeItem;
|
|
MMC_COOKIE lCookie = 0;
|
|
HSCOPEITEM hChild = 0;
|
|
|
|
do {
|
|
hr = m_pConsoleNameSpace->GetChildItem (hRootScopeItem,
|
|
&hChild, &lCookie);
|
|
if ( S_OK != hr )
|
|
break;
|
|
|
|
hr = m_pConsoleNameSpace->DeleteItem (hChild, TRUE);
|
|
ASSERT (SUCCEEDED (hr));
|
|
if ( !SUCCEEDED(hr) )
|
|
break;
|
|
} while (S_OK == hr);
|
|
|
|
QueryRootCookie().ReleaseScopeChildren();
|
|
|
|
hr = AddScopeNodes( strTargetComputer, hRootScopeItem, &QueryRootCookie() );
|
|
|
|
} while (false); // false loop
|
|
|
|
return hr;
|
|
|
|
} // CFileMgmtComponentData::OnChangeComputer
|
|
|
|
|
|
|
|
typedef enum _Shell32ApiIndex
|
|
{
|
|
SHELL_EXECUTE_ENUM = 0
|
|
};
|
|
|
|
// not subject to localization
|
|
static LPCSTR g_COMPDATA_apchShell32FunctionNames[] = {
|
|
"ShellExecuteW",
|
|
NULL
|
|
};
|
|
|
|
// not subject to localization
|
|
DynamicDLL g_COMPDATA_Shell32DLL( _T("SHELL32.DLL"), g_COMPDATA_apchShell32FunctionNames );
|
|
|
|
typedef HINSTANCE (*SHELLEXECUTEPROC)(HWND, LPCWSTR, LPCWSTR, LPCWSTR, LPCWSTR, INT);
|
|
|
|
BOOL CFileMgmtComponentData::NewShare( LPDATAOBJECT piDataObject )
|
|
{
|
|
TCHAR szWinDir[MAX_PATH];
|
|
if (GetSystemWindowsDirectory(szWinDir, MAX_PATH) == 0)
|
|
{
|
|
ASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
|
|
CString strServerName;
|
|
HRESULT hr = ExtractString( piDataObject, CFileMgmtDataObject::m_CFMachineName, &strServerName, MAX_PATH );
|
|
if ( FAILED(hr) )
|
|
{
|
|
ASSERT( FALSE );
|
|
return FALSE;
|
|
}
|
|
|
|
CString csAppName = szWinDir;
|
|
if (csAppName.Right(1) != _T('\\'))
|
|
csAppName += _T("\\");
|
|
csAppName += _T("System32\\shrpubw.exe");
|
|
|
|
CString strParameters;
|
|
if (strServerName.IsEmpty())
|
|
strParameters = _T(" /s");
|
|
else
|
|
strParameters.Format( _T(" /s %s"), strServerName );
|
|
|
|
HWND hWnd;
|
|
m_pConsole->GetMainWindow(&hWnd);
|
|
|
|
DWORD dwExitCode =0;
|
|
hr = SynchronousCreateProcess(hWnd, csAppName, strParameters, &dwExitCode);
|
|
if ( FAILED(hr) )
|
|
{
|
|
(void) DoErrMsgBox(GetActiveWindow(), MB_OK | MB_ICONSTOP, hr, IDS_POPUP_NEWSHARE);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CFileMgmtComponentData::DisconnectAllSessions( LPDATAOBJECT pDataObject )
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
FileMgmtObjectType objecttype;
|
|
HRESULT hr = ExtractBaseCookie( pDataObject, &pbasecookie, &objecttype );
|
|
ASSERT( SUCCEEDED(hr) && NULL != pbasecookie && FILEMGMT_SESSIONS == objecttype );
|
|
CFileMgmtCookie* pcookie = (CFileMgmtCookie*)pbasecookie;
|
|
|
|
if ( IDYES != DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_POPUP_CLOSE_ALL_SESSIONS) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CWaitCursor wait;
|
|
INT iTransport;
|
|
for ( iTransport = FILEMGMT_NUM_TRANSPORTS - 1; // bug#163500: follow this order: SFM/SMB
|
|
iTransport >= FILEMGMT_FIRST_TRANSPORT;
|
|
iTransport-- )
|
|
{
|
|
// NULL == pResultData means disconnect all sessions
|
|
// bug#210110: ignore error to attempt on all sessions
|
|
(void) GetFileServiceProvider(iTransport)->EnumerateSessions(
|
|
NULL, pcookie, true);
|
|
}
|
|
return TRUE; // always assume that something might have changed
|
|
}
|
|
|
|
BOOL CFileMgmtComponentData::DisconnectAllResources( LPDATAOBJECT pDataObject )
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState());
|
|
|
|
CCookie* pbasecookie = NULL;
|
|
FileMgmtObjectType objecttype;
|
|
HRESULT hr = ExtractBaseCookie( pDataObject, &pbasecookie, &objecttype );
|
|
ASSERT( SUCCEEDED(hr) && NULL != pbasecookie && FILEMGMT_RESOURCES == objecttype );
|
|
CFileMgmtCookie* pcookie = (CFileMgmtCookie*)pbasecookie;
|
|
|
|
if ( IDYES != DoErrMsgBox(GetActiveWindow(), MB_YESNO, 0, IDS_POPUP_CLOSE_ALL_RESOURCES) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
CWaitCursor wait;
|
|
INT iTransport;
|
|
for ( iTransport = FILEMGMT_NUM_TRANSPORTS - 1; // bug#163494: follow this order: SFM/SMB
|
|
iTransport >= FILEMGMT_FIRST_TRANSPORT;
|
|
iTransport-- )
|
|
{
|
|
// NULL == pResultData means disconnect all resources
|
|
// bug#210110: ignore error to attempt on all open files
|
|
(void) GetFileServiceProvider(iTransport)->EnumerateResources(
|
|
NULL,pcookie);
|
|
}
|
|
return TRUE; // always assume that something might have changed
|
|
}
|
|
|
|
BOOL CFileMgmtComponentData::ConfigSfm( LPDATAOBJECT pDataObject )
|
|
{
|
|
CString strServerName;
|
|
HRESULT hr = ExtractString( pDataObject, CFileMgmtDataObject::m_CFMachineName, &strServerName, MAX_PATH );
|
|
if ( FAILED(hr) )
|
|
{
|
|
ASSERT( FALSE );
|
|
return FALSE;
|
|
}
|
|
|
|
SfmFileServiceProvider* pProvider =
|
|
(SfmFileServiceProvider*) GetFileServiceProvider(FILEMGMT_SFM);
|
|
|
|
// make sure the service is running
|
|
if ( pProvider->StartSFM(::GetActiveWindow(), m_hScManager, strServerName) )
|
|
{
|
|
// does the user have access?
|
|
DWORD dwErr = pProvider->UserHasAccess(strServerName);
|
|
if ( dwErr == NO_ERROR )
|
|
{
|
|
pProvider->DisplaySfmProperties(pDataObject, (CFileMgmtCookie*) &QueryRootCookie());
|
|
}
|
|
else
|
|
{
|
|
// need to tell the user something here
|
|
DoErrMsgBox(::GetActiveWindow(), MB_OK | MB_ICONEXCLAMATION, dwErr);
|
|
}
|
|
}
|
|
|
|
return FALSE; // nothing to update in the UI
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
/// IExtendPropertySheet
|
|
|
|
STDMETHODIMP CFileMgmtComponentData::QueryPagesFor(LPDATAOBJECT pDataObject)
|
|
{
|
|
MFC_TRY;
|
|
|
|
if (NULL == pDataObject)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_POINTER;
|
|
}
|
|
|
|
HRESULT hr;
|
|
DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
|
|
FileMgmtObjectType objecttype = FileMgmtObjectTypeFromIDataObject(pDataObject);
|
|
hr = ExtractData( pDataObject, CFileMgmtDataObject::m_CFDataObjectType, &dataobjecttype, sizeof(dataobjecttype) );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
ASSERT( CCT_SCOPE == dataobjecttype ||
|
|
CCT_RESULT == dataobjecttype ||
|
|
CCT_SNAPIN_MANAGER == dataobjecttype );
|
|
|
|
// determine if it needs property pages
|
|
switch (objecttype)
|
|
{
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
case FILEMGMT_PROTOTYPER:
|
|
// return S_OK;
|
|
#endif
|
|
case FILEMGMT_ROOT:
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
case FILEMGMT_SERVICES:
|
|
return (CCT_SNAPIN_MANAGER == dataobjecttype) ? S_OK : S_FALSE;
|
|
default:
|
|
break;
|
|
}
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
|
|
MFC_CATCH;
|
|
} // CFileMgmtComponentData::QueryPagesFor()
|
|
|
|
STDMETHODIMP CFileMgmtComponentData::CreatePropertyPages(
|
|
LPPROPERTYSHEETCALLBACK pCallBack,
|
|
LONG_PTR /*handle*/, // This handle must be saved in the property page object to notify the parent when modified
|
|
LPDATAOBJECT pDataObject)
|
|
{
|
|
AFX_MANAGE_STATE(AfxGetStaticModuleState( ));
|
|
|
|
if (NULL == pCallBack || NULL == pDataObject)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_POINTER;
|
|
}
|
|
HRESULT hr;
|
|
|
|
// extract data from data object
|
|
FileMgmtObjectType objecttype = FileMgmtObjectTypeFromIDataObject(pDataObject);
|
|
DATA_OBJECT_TYPES dataobjecttype = CCT_SCOPE;
|
|
hr = ExtractData( pDataObject, CFileMgmtDataObject::m_CFDataObjectType, &dataobjecttype, sizeof(dataobjecttype) );
|
|
ASSERT( SUCCEEDED(hr) );
|
|
ASSERT( CCT_SCOPE == dataobjecttype ||
|
|
CCT_RESULT == dataobjecttype ||
|
|
CCT_SNAPIN_MANAGER == dataobjecttype );
|
|
|
|
// determine if it needs property pages
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_ROOT:
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
case FILEMGMT_PROTOTYPER:
|
|
#endif
|
|
case FILEMGMT_SERVICES:
|
|
{
|
|
if (CCT_SNAPIN_MANAGER != dataobjecttype)
|
|
{
|
|
ASSERT(FALSE);
|
|
return E_UNEXPECTED;
|
|
}
|
|
|
|
//
|
|
// Note that once we have established that this is a CCT_SNAPIN_MANAGER cookie,
|
|
// we don't care about its other properties. A CCT_SNAPIN_MANAGER cookie is
|
|
// equivalent to a BOOL flag asking for the Node Properties page instead of a
|
|
// managed object property page. JonN 10/9/96
|
|
//
|
|
CChooseMachinePropPage * pPage;
|
|
if (IsServiceSnapin())
|
|
{
|
|
pPage = new CChooseMachinePropPage();
|
|
pPage->SetCaption(IDS_CAPTION_SERVICES);
|
|
pPage->SetHelp(g_szHelpFileFilemgmt, g_a970HelpIDs);
|
|
}
|
|
else
|
|
{
|
|
CFileMgmtGeneral * pPageT = new CFileMgmtGeneral;
|
|
pPageT->SetFileMgmtComponentData(this);
|
|
pPage = pPageT;
|
|
pPage->SetHelp(g_szHelpFileFilemgmt, HELP_DIALOG_TOPIC(IDD_FILE_FILEMANAGEMENT_GENERAL));
|
|
}
|
|
// Initialize state of object
|
|
ASSERT(NULL != m_pRootCookie);
|
|
pPage->InitMachineName( QueryRootCookie().QueryTargetServer() );
|
|
pPage->SetOutputBuffers(
|
|
OUT &m_strMachineNamePersist,
|
|
OUT &m_fAllowOverrideMachineName,
|
|
OUT &m_pRootCookie->m_strMachineName); // Effective machine name
|
|
|
|
HPROPSHEETPAGE hPage=MyCreatePropertySheetPage(&pPage->m_psp);
|
|
pCallBack->AddPage(hPage);
|
|
return S_OK;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
ASSERT(FALSE);
|
|
return S_FALSE;
|
|
} // CFileMgmtComponentData::CreatePropertyPages()
|
|
|
|
|
|
CString g_strShares;
|
|
CString g_strSessions;
|
|
CString g_strResources;
|
|
CString g_strServices;
|
|
BOOL g_fScopeStringsLoaded = FALSE;
|
|
void CFileMgmtComponentData::LoadGlobalStrings()
|
|
{
|
|
if (!g_fScopeStringsLoaded )
|
|
{
|
|
g_fScopeStringsLoaded = TRUE;
|
|
VERIFY( g_strShares.LoadString( IDS_SCOPE_SHARES ) );
|
|
VERIFY( g_strSessions.LoadString( IDS_SCOPE_SESSIONS ) );
|
|
VERIFY( g_strResources.LoadString( IDS_SCOPE_RESOURCES ) );
|
|
VERIFY( g_strServices.LoadString( IDS_SCOPE_SERVICES ) );
|
|
}
|
|
}
|
|
|
|
// global space to store the string haded back to GetDisplayInfo()
|
|
// CODEWORK should use "bstr" for ANSI-ization
|
|
CString g_strResultColumnText;
|
|
|
|
BSTR CFileMgmtScopeCookie::QueryResultColumnText( int nCol, CFileMgmtComponentData& refcdata )
|
|
{
|
|
FileMgmtObjectType objtype = QueryObjectType();
|
|
BOOL fStaticNode = ( !refcdata.IsExtensionSnapin()
|
|
&& refcdata.QueryRootCookie().QueryObjectType() == objtype);
|
|
switch (objtype)
|
|
{
|
|
//
|
|
// These are scope items which can appear in the result pane.
|
|
// We only need to deal with column 0, others are blank
|
|
//
|
|
case FILEMGMT_ROOT:
|
|
switch (nCol)
|
|
{
|
|
case 0:
|
|
GetDisplayName( g_strResultColumnText, fStaticNode );
|
|
return const_cast<BSTR>(((LPCTSTR)g_strResultColumnText));
|
|
case 1: // Type - blank
|
|
break;
|
|
case 2: // Description
|
|
g_strResultColumnText.LoadString(IDS_SNAPINABOUT_DESCR_FILESVC);
|
|
return const_cast<BSTR>(((LPCTSTR)g_strResultColumnText));
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
if (0 == nCol)
|
|
{
|
|
GetDisplayName( g_strResultColumnText, fStaticNode );
|
|
return const_cast<BSTR>(((LPCTSTR)g_strResultColumnText));
|
|
}
|
|
break;
|
|
case FILEMGMT_SERVICES:
|
|
switch (nCol)
|
|
{
|
|
case 0:
|
|
GetDisplayName( g_strResultColumnText, fStaticNode );
|
|
return const_cast<BSTR>(((LPCTSTR)g_strResultColumnText));
|
|
case 1: // Type - blank
|
|
break;
|
|
case 2: // Description
|
|
g_strResultColumnText.LoadString(IDS_SNAPINABOUT_DESCR_SERVICES);
|
|
return const_cast<BSTR>(((LPCTSTR)g_strResultColumnText));
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
return L"";
|
|
}
|
|
|
|
|
|
|
|
BSTR MakeDwordResult(DWORD dw)
|
|
{
|
|
g_strResultColumnText.Format( _T("%d"), dw );
|
|
return const_cast<BSTR>((LPCTSTR)g_strResultColumnText);
|
|
}
|
|
|
|
BSTR MakeElapsedTimeResult(DWORD dwTime)
|
|
{
|
|
if ( -1L == dwTime )
|
|
return L""; // not known
|
|
DWORD dwSeconds = dwTime % 60;
|
|
dwTime /= 60;
|
|
DWORD dwMinutes = dwTime % 60;
|
|
dwTime /= 60;
|
|
DWORD dwHours = dwTime % 24;
|
|
dwTime /= 24;
|
|
DWORD dwDays = dwTime;
|
|
LoadStringPrintf(
|
|
(dwDays == 0) ? IDS_TIME_HOURPLUS :
|
|
((dwDays > 1) ? IDS_TIME_DAYPLUS : IDS_TIME_ONEDAY),
|
|
&g_strResultColumnText,
|
|
dwDays, dwHours, dwMinutes, dwSeconds );
|
|
return const_cast<BSTR>((LPCTSTR)g_strResultColumnText);
|
|
}
|
|
|
|
BSTR CFileMgmtComponentData::MakeTransportResult(FILEMGMT_TRANSPORT transport)
|
|
{
|
|
return const_cast<BSTR>(GetFileServiceProvider(transport)->QueryTransportString());
|
|
}
|
|
|
|
CString g_strPermissionNone;
|
|
CString g_strPermissionCreate;
|
|
CString g_strPermissionReadWrite;
|
|
CString g_strPermissionRead;
|
|
CString g_strPermissionWrite;
|
|
BOOL g_fPermissionStringsLoaded = FALSE;
|
|
|
|
BSTR MakePermissionsResult( DWORD dwPermissions )
|
|
{
|
|
if (!g_fPermissionStringsLoaded)
|
|
{
|
|
g_fPermissionStringsLoaded = TRUE;
|
|
VERIFY( g_strPermissionNone.LoadString(IDS_FILEPERM_NONE) );
|
|
VERIFY( g_strPermissionCreate.LoadString(IDS_FILEPERM_CREATE) );
|
|
VERIFY( g_strPermissionReadWrite.LoadString(IDS_FILEPERM_READWRITE) );
|
|
VERIFY( g_strPermissionRead.LoadString(IDS_FILEPERM_READ) );
|
|
VERIFY( g_strPermissionWrite.LoadString(IDS_FILEPERM_WRITE) );
|
|
}
|
|
|
|
if (PERM_FILE_CREATE & dwPermissions)
|
|
return const_cast<BSTR>((LPCTSTR)g_strPermissionCreate);
|
|
else if (PERM_FILE_WRITE & dwPermissions)
|
|
return ( (PERM_FILE_READ & dwPermissions)
|
|
? const_cast<BSTR>((LPCTSTR)g_strPermissionReadWrite)
|
|
: const_cast<BSTR>((LPCTSTR)g_strPermissionWrite) );
|
|
else if (PERM_FILE_READ & dwPermissions)
|
|
return const_cast<BSTR>((LPCTSTR)g_strPermissionRead);
|
|
|
|
return const_cast<BSTR>((LPCTSTR)g_strPermissionNone);
|
|
}
|
|
|
|
CString& CFileMgmtComponentData::ResultStorageString()
|
|
{
|
|
return g_strResultColumnText;
|
|
}
|
|
|
|
BSTR CFileMgmtComponentData::QueryResultColumnText(
|
|
CCookie& basecookieref,
|
|
int nCol )
|
|
{
|
|
CFileMgmtCookie& cookieref = (CFileMgmtCookie&)basecookieref;
|
|
return cookieref.QueryResultColumnText( nCol, *this );
|
|
/*
|
|
#ifndef UNICODE
|
|
#error not ANSI-enabled
|
|
#endif
|
|
HRESULT hr = S_OK;
|
|
switch (cookieref.QueryObjectType())
|
|
{
|
|
//
|
|
// These are scope items which can appear in the result pane.
|
|
// We only need to deal with column 0, others are blank
|
|
//
|
|
case FILEMGMT_SHARES:
|
|
if (0 == nCol)
|
|
return const_cast<BSTR>(((LPCTSTR)g_strShares));
|
|
break;
|
|
case FILEMGMT_SESSIONS:
|
|
if (0 == nCol)
|
|
return const_cast<BSTR>(((LPCTSTR)g_strSessions));
|
|
break;
|
|
case FILEMGMT_RESOURCES:
|
|
if (0 == nCol)
|
|
return const_cast<BSTR>(((LPCTSTR)g_strResources));
|
|
break;
|
|
|
|
//
|
|
// These are result items. We need to deal with all columns.
|
|
// It is no longer permitted to set this text at insert time.
|
|
//
|
|
case FILEMGMT_SHARE:
|
|
case FILEMGMT_SESSION:
|
|
case FILEMGMT_RESOURCE:
|
|
case FILEMGMT_SERVICE:
|
|
return cookieref.QueryResultColumnText( nCol, *this );
|
|
|
|
// CODEWORK do we need to deal with these? They never appear
|
|
// in the result pane.
|
|
case FILEMGMT_ROOT:
|
|
case FILEMGMT_SERVICES:
|
|
// fall through
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
return L"";
|
|
*/
|
|
}
|
|
|
|
int CFileMgmtComponentData::QueryImage(CCookie& basecookieref, BOOL fOpenImage)
|
|
{
|
|
CFileMgmtCookie& cookieref = (CFileMgmtCookie&)basecookieref;
|
|
// CODEWORK we need new icons for Resource, Open File and possibly also
|
|
// differentiating by transport
|
|
int iIconReturn = iIconSharesFolder;
|
|
switch (cookieref.QueryObjectType())
|
|
{
|
|
case FILEMGMT_ROOT:
|
|
case FILEMGMT_SHARES:
|
|
case FILEMGMT_SESSIONS:
|
|
case FILEMGMT_RESOURCES:
|
|
if (fOpenImage)
|
|
return iIconSharesFolderOpen;
|
|
return iIconSharesFolder;
|
|
case FILEMGMT_SERVICE:
|
|
case FILEMGMT_SERVICES:
|
|
return iIconService;
|
|
case FILEMGMT_SHARE:
|
|
iIconReturn = iIconSMBShare;
|
|
break;
|
|
case FILEMGMT_SESSION:
|
|
iIconReturn = iIconSMBSession;
|
|
break;
|
|
case FILEMGMT_RESOURCE:
|
|
iIconReturn = iIconSMBResource;
|
|
break;
|
|
default:
|
|
ASSERT(FALSE);
|
|
return iIconSharesFolder;
|
|
}
|
|
|
|
FILEMGMT_TRANSPORT transport = FILEMGMT_SMB;
|
|
VERIFY( SUCCEEDED(cookieref.GetTransport( &transport ) ) );
|
|
|
|
switch (transport)
|
|
{
|
|
case FILEMGMT_SMB:
|
|
break;
|
|
case FILEMGMT_SFM:
|
|
return iIconReturn+1;
|
|
#ifdef SNAPIN_PROTOTYPER
|
|
case FILEMGMT_PROTOTYPER:
|
|
if (((CPrototyperScopeCookie &)cookieref).m_ScopeType == HTML)
|
|
return iIconPrototyperHTML;
|
|
else return iIconPrototyperContainerClosed;
|
|
case FILEMGMT_PROTOTYPER_LEAF:
|
|
return iIconPrototyperLeaf;
|
|
#endif // FILEMGMT_PROTOTYPER
|
|
default:
|
|
ASSERT(FALSE);
|
|
break;
|
|
}
|
|
|
|
return iIconReturn;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ChangeRootNodeName ()
|
|
//
|
|
// Purpose: Change the text of the root node
|
|
//
|
|
// Input: newName - the new machine name that the snapin manages
|
|
// Output: Returns S_OK on success
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CFileMgmtComponentData::ChangeRootNodeName(const CString & newName)
|
|
{
|
|
MFC_TRY;
|
|
ASSERT (m_pRootCookie);
|
|
if ( !m_pRootCookie )
|
|
return E_FAIL;
|
|
// This should only happen per bug 453635/453636, when the snapin
|
|
// was just added to the console and we still don't have the
|
|
// root node's HSCOPEITEM. Ignore this for now.
|
|
if ( !QueryBaseRootCookie().m_hScopeItem )
|
|
return S_OK;
|
|
|
|
CString machineName (newName);
|
|
CString formattedName;
|
|
|
|
// If machineName is empty, then this manages the local machine. Get
|
|
// the local machine name. Then format the computer name with the snapin
|
|
// name
|
|
|
|
FileMgmtObjectType objecttype = QueryRootCookie().QueryObjectType();
|
|
|
|
// JonN 11/14/00 164998 set to SERVICES where appropriate
|
|
if (machineName.IsEmpty())
|
|
{
|
|
if (IsServiceSnapin())
|
|
formattedName.LoadString(IDS_DISPLAYNAME_SERVICES_LOCAL);
|
|
else
|
|
{
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_SHARES:
|
|
formattedName.LoadString(IDS_DISPLAYNAME_SHARES_LOCAL);
|
|
break;
|
|
case FILEMGMT_SESSIONS:
|
|
formattedName.LoadString(IDS_DISPLAYNAME_SESSIONS_LOCAL);
|
|
break;
|
|
case FILEMGMT_RESOURCES:
|
|
formattedName.LoadString(IDS_DISPLAYNAME_FILES_LOCAL);
|
|
break;
|
|
default:
|
|
formattedName.LoadString(IDS_DISPLAYNAME_ROOT_LOCAL);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
machineName.MakeUpper ();
|
|
if (IsServiceSnapin())
|
|
formattedName.FormatMessage(IDS_DISPLAYNAME_s_SERVICES, machineName);
|
|
else
|
|
{
|
|
switch (objecttype)
|
|
{
|
|
case FILEMGMT_SHARES:
|
|
formattedName.FormatMessage(IDS_DISPLAYNAME_s_SHARES, machineName);
|
|
break;
|
|
case FILEMGMT_SESSIONS:
|
|
formattedName.FormatMessage(IDS_DISPLAYNAME_s_SESSIONS, machineName);
|
|
break;
|
|
case FILEMGMT_RESOURCES:
|
|
formattedName.FormatMessage(IDS_DISPLAYNAME_s_FILES, machineName);
|
|
break;
|
|
default:
|
|
formattedName.FormatMessage(IDS_DISPLAYNAME_s_ROOT, machineName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
SCOPEDATAITEM item;
|
|
::ZeroMemory (&item, sizeof (SCOPEDATAITEM));
|
|
item.mask = SDI_STR;
|
|
item.displayname = (LPTSTR) (LPCTSTR) formattedName;
|
|
item.ID = QueryBaseRootCookie ().m_hScopeItem;
|
|
|
|
return m_pConsoleNameSpace->SetItem (&item);
|
|
MFC_CATCH;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// OnNotifyPreload ()
|
|
//
|
|
// Purpose: Remember the HSCOPEITEM of the root node
|
|
//
|
|
// Note: Requires that CCF_SNAPIN_PRELOADS be set
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
HRESULT CFileMgmtComponentData::OnNotifyPreload(
|
|
LPDATAOBJECT /*lpDataObject*/,
|
|
HSCOPEITEM hRootScopeItem)
|
|
{
|
|
QueryRootCookie().m_hScopeItem = hRootScopeItem;
|
|
|
|
//
|
|
// 7/11/2001 LinanT bug#433102
|
|
// Before "Shares" is added to scope pane by itself as the root node, we need to
|
|
// initialize related global variables.
|
|
//
|
|
PCWSTR lpwcszMachineName = QueryRootCookie().QueryNonNULLMachineName();
|
|
FileMgmtObjectType objecttype = QueryRootCookie().QueryObjectType();
|
|
if (FILEMGMT_SHARES == objecttype)
|
|
{
|
|
ReInit(lpwcszMachineName);
|
|
}
|
|
|
|
// JonN 3/13/01 342366
|
|
// Services: No credential defaults to local from command line
|
|
VERIFY( SUCCEEDED( ChangeRootNodeName(
|
|
QueryRootCookie().QueryNonNULLMachineName())));
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// The following 3 functions are cut & pasted from shell\osshell\lmui\ntshrui\util.cxx
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: IsSafeMode
|
|
//
|
|
// Synopsis: Checks the registry to see if the system is in safe mode.
|
|
//
|
|
// History: 06-Oct-00 JeffreyS Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
IsSafeMode(
|
|
VOID
|
|
)
|
|
{
|
|
BOOL fIsSafeMode = FALSE;
|
|
|
|
HKEY hkey = NULL;
|
|
LONG ec = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\CurrentControlSet\\Control\\SafeBoot\\Option"),
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hkey
|
|
);
|
|
|
|
if (ec == NO_ERROR)
|
|
{
|
|
DWORD dwValue = 0;
|
|
DWORD dwValueSize = sizeof(dwValue);
|
|
|
|
ec = RegQueryValueEx(hkey,
|
|
TEXT("OptionValue"),
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)&dwValue,
|
|
&dwValueSize);
|
|
|
|
if (ec == NO_ERROR)
|
|
{
|
|
fIsSafeMode = (dwValue == SAFEBOOT_MINIMAL || dwValue == SAFEBOOT_NETWORK);
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
|
|
return fIsSafeMode;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: IsForcedGuestModeOn
|
|
//
|
|
// Synopsis: Checks the registry to see if the system is using the
|
|
// Guest-only network access mode.
|
|
//
|
|
// History: 06-Oct-00 JeffreyS Created
|
|
// 19-Apr-00 GPease Modified and changed name
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
IsForcedGuestModeOn(
|
|
VOID
|
|
)
|
|
{
|
|
BOOL fIsForcedGuestModeOn = FALSE;
|
|
|
|
if (IsOS(OS_PERSONAL))
|
|
{
|
|
// Guest mode is always on for Personal
|
|
fIsForcedGuestModeOn = TRUE;
|
|
}
|
|
else if (IsOS(OS_PROFESSIONAL) && !IsOS(OS_DOMAINMEMBER))
|
|
{
|
|
// Professional, not in a domain. Check the ForceGuest value.
|
|
HKEY hkey = NULL;
|
|
LONG ec = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
TEXT("SYSTEM\\CurrentControlSet\\Control\\LSA"),
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hkey
|
|
);
|
|
|
|
if (ec == NO_ERROR)
|
|
{
|
|
DWORD dwValue = 0;
|
|
DWORD dwValueSize = sizeof(dwValue);
|
|
|
|
ec = RegQueryValueEx(hkey,
|
|
TEXT("ForceGuest"),
|
|
NULL,
|
|
NULL,
|
|
(LPBYTE)&dwValue,
|
|
&dwValueSize);
|
|
|
|
if (ec == NO_ERROR && 0 != dwValue)
|
|
{
|
|
fIsForcedGuestModeOn = TRUE;
|
|
}
|
|
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
|
|
return fIsForcedGuestModeOn;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: IsSimpleUI
|
|
//
|
|
// Synopsis: Checks whether to show the simple version of the UI.
|
|
//
|
|
// History: 06-Oct-00 JeffreyS Created
|
|
// 19-Apr-00 GPease Removed CTRL key check
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL IsSimpleUI(PCTSTR pszMachineName)
|
|
{
|
|
//
|
|
// no need to disable acl-related context menu items if targeted at a remote machine
|
|
//
|
|
if (!IsLocalComputername(pszMachineName))
|
|
return FALSE;
|
|
|
|
// Show old UI in safe mode and anytime network access involves
|
|
// true user identity (server, pro with GuestMode off).
|
|
|
|
// Show simple UI anytime network access is done using the Guest
|
|
// account (personal, pro with GuestMode on) except in safe mode.
|
|
|
|
return (!IsSafeMode() && IsForcedGuestModeOn());
|
|
}
|