|
|
/////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1996-1999 Microsoft Corporation
//
// Module Name:
// clusocm.cpp
//
// Abstract:
// CLUSOCM.DLL is an Optional Components Manager DLL for installation of
// Microsoft Cluster Server. This file is the class implementation file
// for the CClusocmApp class which implements the component setup procedure.
//
// Author:
// C. Brent Thomas (a-brentt)
//
// Revision History:
// 1/29/98 original
//
// Notes:
//
// If this DLL is dynamically linked against the MFC
// DLLs, any functions exported from this DLL which
// call into MFC must have the AFX_MANAGE_STATE macro
// added at the very beginning of the function.
//
// For example:
//
// extern "C" BOOL PASCAL EXPORT ExportedFunction()
// {
// AFX_MANAGE_STATE(AfxGetStaticModuleState());
// // normal function body here
// }
//
// It is very important that this macro appear in each
// function, prior to any calls into MFC. This means that
// it must appear as the first statement within the
// function, even before any object variable declarations
// as their constructors may generate calls into the MFC
// DLL.
//
// Please see MFC Technical Notes 33 and 58 for additional
// details.
//
//
/////////////////////////////////////////////////////////////////////////////
//
#include "stdafx.h"
#include "clusocm.h"
#include <regcomobj.h>
#include <StopService.h>
#include <RemoveNetworkProvider.h>
#include <IsClusterServiceRegistered.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;#endif
/////////////////////////////////////////////////////////////////////////////
// Global Data
/////////////////////////////////////////////////////////////////////////////
// The one and only CClusocmApp object
CClusocmApp theApp;
/////////////////////////////////////////////////////////////////////////////
// Global Functions
// This is the function that OC Manager will call.
/////////////////////////////////////////////////////////////////////////////
//++
//
// ClusOcmSetupProc
//
// Routine Description:
// This is the exported function that OC Manager calls. It merely passes
// its' parameters to the CClusocmApp object and returns the results to
// OC Manager.
//
// Arguments:
// pvComponentId - points to a string that uniquely identifies the component
// to be set up to OC Manager.
// pvSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// uxFunction - A numeric value indicating which function is to be perfomed.
// See ocmanage.h for the macro definitions.
// uxParam1 - supplies a function specific parameter.
// pvParam2 - points to a function specific parameter (which may be an
// output).
//
// Return Value:
// A function specific value is returned to OC Manager.
//
//--
/////////////////////////////////////////////////////////////////////////////
extern "C" DWORD WINAPI ClusOcmSetupProc( IN LPCVOID pvComponentId, IN LPCVOID pvSubComponentId, IN UINT uxFunction, IN UINT uxParam1, IN OUT PVOID pvParam2 ){ return theApp.ClusOcmSetupProc( pvComponentId, pvSubComponentId, uxFunction, uxParam1, pvParam2 );
} //*** exported ClusOcmSetupProc()
/////////////////////////////////////////////////////////////////////////////
// CClusocmApp
BEGIN_MESSAGE_MAP(CClusocmApp, CWinApp) //{{AFX_MSG_MAP(CClusocmApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CClusocmApp construction
// Default constructor
CClusocmApp::CClusocmApp(){ // TODO: add construction code here,
// Place all significant initialization in InitInstance
// Initialize the values of the HINF members in the SETUP_INIT_COMPONENT
// structure data member.
m_SetupInitComponent.OCInfHandle = (HINF) INVALID_HANDLE_VALUE; m_SetupInitComponent.ComponentInfHandle = (HINF) INVALID_HANDLE_VALUE;
m_dwStepCount = 0L;}
/////////////////////////////////////////////////////////////////////////////
//++
//
// InitInstance
//
// Routine Description:
//
//
// Arguments:
//
//
//
// Return Value:
//
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::InitInstance( void ){ BOOL fReturnValue = (BOOL) TRUE;
m_hInstance = AfxGetInstanceHandle();
// Initialize OLE libraries
if (!AfxOleInit()) { if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) == (DWORDLONG) 0L ) { AfxMessageBox( IDS_OLE_INIT_FAILED ); }
ClRtlLogPrint( "OLE initialization failed. Make sure that the OLE libraries are the correct version.\n" );
fReturnValue = (BOOL) FALSE; }
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CClusocmApp::ClusOcmSetupProc
//
// Routine Description:
// This function implements the Optional Components Manager component
// setup procedure. This function is called by the exported function
// of the same name, which in turn is called by OC Manager.
//
// Arguments:
// pvComponentId - points to a string that uniquely identifies the component
// to be set up to OC Manager.
// pvSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// uxFunction - A numeric value indicating which function is to be perfomed.
// See ocmanage.h for the macro definitions.
// uxParam1 - supplies a function specific parameter.
// pvParam2 - points to a function specific parameter (which may be an
// output).
//
//
// Return Value:
// A function specific value is returned to OC Manager.
//
//--
/////////////////////////////////////////////////////////////////////////////
#pragma warning ( disable : 4100 ) // disable "unreferenced formal parameter" warning
// At this time (2/26/98) pvComponentId is unused.
DWORD CClusocmApp::ClusOcmSetupProc( IN LPCVOID pvComponentId, IN LPCVOID pvSubComponentId, IN UINT uxFunction, IN UINT uxParam1, IN OUT PVOID pvParam2 ){ AFX_MANAGE_STATE( AfxGetStaticModuleState() ); // As per the note in file header
DWORD dwReturnValue;
switch ( uxFunction ) { case OC_PREINITIALIZE:
// This is the first interface function that OC Manager calls.
// OnOcPreinitialize enables the log file for clusocm.dll, verifies
// that the OS version and Product Suite are correct, etc.
dwReturnValue = OnOcPreinitialize();
ClRtlLogPrint( "OnOcPreinitialize returned 0x%1!x!\n\n", dwReturnValue );
break;
case OC_INIT_COMPONENT:
// This function is called soon after the component's setup dll is
// loaded. This function provides initialization information to the
// dll, instructs the dll to initialize itself, and provides a
// mechanism for the dll to return information to OC Manager.
// It may be desirable to verify that Microsoft Cluster Server is being
// installed on NT Enterprise and to authenticate the user at this point.
dwReturnValue = OnOcInitComponent((PSETUP_INIT_COMPONENT) pvParam2 );
ClRtlLogPrint( "OnOcInitComponent returned 0x%1!x!\n\n", dwReturnValue );
break;
case OC_REQUEST_PAGES:
// OC Manager is requesting a set of wizard pages from the dll.
// As of 2/16/98 there are no wizard pages to supply.
dwReturnValue = (DWORD) 0L;
ClRtlLogPrint( "ClusOcmSetupProc is returning 0x%1!x! in response to OC_REQUEST_PAGES.\n\n", dwReturnValue );
break;
case OC_QUERY_STATE:
// Oc Manager is requesting the selection state of the component.
// It does that at least three times.
dwReturnValue = OnOcQueryState( (LPCTSTR) pvSubComponentId, uxParam1 );
ClRtlLogPrint( "OnQueryState returned 0x%1!x!\n\n", dwReturnValue );
break;
case OC_SET_LANGUAGE:
// OC Manager documentation states:
//
// "If a component does not support multiple languages, or if it does
// not support the requested language, then it may ignore OC_SET_LANGUAGE."
// I have replicated the functionality in Pat Styles' generic sample, ocgen.cpp.
dwReturnValue = OnOcSetLanguage();
ClRtlLogPrint( "OnOcSetLanguage returned 0x%1!x!.\n\n", dwReturnValue );
break;
case OC_CALC_DISK_SPACE:
dwReturnValue = OnOcCalcDiskSpace( (LPCTSTR) pvSubComponentId, uxParam1, (HDSKSPC) pvParam2 );
ClRtlLogPrint( "OnOcCalcDiskSpace returned 0x%1!x!.\n\n", dwReturnValue );
break;
case OC_QUEUE_FILE_OPS:
if ( (pvSubComponentId != (PVOID) NULL) && (*((LPCTSTR) pvSubComponentId) != _T('\0')) ) { dwReturnValue = OnOcQueueFileOps( (LPCTSTR) pvSubComponentId, (HSPFILEQ) pvParam2 );
ClRtlLogPrint( "OnOcQueueFileOps returned 0x%1!x!.\n\n", dwReturnValue ); } else { dwReturnValue = (DWORD) NO_ERROR; }
break;
case OC_QUERY_CHANGE_SEL_STATE:
dwReturnValue = OnOcQueryChangeSelState( (LPCTSTR) pvSubComponentId, (UINT) uxParam1, (DWORD) ((DWORD_PTR)pvParam2) );
ClRtlLogPrint( "OnOnQueryChangeSelState returned 0x%1!x!.\n\n", dwReturnValue );
break;
case OC_COMPLETE_INSTALLATION:
if ( (pvSubComponentId != (PVOID) NULL) && (*((LPCTSTR) pvSubComponentId) != _T('\0')) ) { dwReturnValue = OnOcCompleteInstallation( (LPCTSTR) pvSubComponentId );
ClRtlLogPrint( "OnOcCompleteInstallation returned 0x%1!x!.\n\n", dwReturnValue ); } else { dwReturnValue = (DWORD) NO_ERROR; }
break;
case OC_WIZARD_CREATED:
// This interface function code is not documented. I have replicated the
// functionality of Pat Styles' generic sample, ocgen.cpp.
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "returning 0x%1!x! for OC_WIZARD_CREATED.\n\n", dwReturnValue );
break;
case OC_NEED_MEDIA:
// This interface function code is not documented. I have replicated the
// functionality of Pat Styles' generic sample, ocgen.cpp.
dwReturnValue = (DWORD) FALSE;
ClRtlLogPrint( "returning 0x%1!x! for OC_NEED_MEDIA.\n\n" );
break;
case OC_QUERY_SKIP_PAGE:
// This interface function code is not documented. I have replicated the
// functionality of Pat Styles' generic sample, ocgen.cpp.
dwReturnValue = (DWORD) FALSE;
ClRtlLogPrint( "returning 0x%1!x! for OC_QUERY_SKIP_PAGE.\n\n", dwReturnValue );
break;
case OC_QUERY_STEP_COUNT:
// OC Manager uses this interface function code to request the number
// of "steps", other than file operations, that must be performed to
// install the component.
if ( (pvSubComponentId != (PVOID) NULL) && (*((LPCTSTR) pvSubComponentId) != _T('\0')) ) { dwReturnValue = CalculateStepCount( (LPCTSTR) pvSubComponentId );
if ( dwReturnValue != 0L ) { // Update the data member.
SetStepCount( dwReturnValue ); } } else { dwReturnValue = (DWORD) NO_ERROR; }
ClRtlLogPrint( "returning 0x%1!x! for OC_QUERY_STEP_COUNT.\n\n", dwReturnValue );
break;
case OC_CLEANUP:
// This interface function code is the last to be processed.
// OC Manager documentation states that the return value from processing
// this interface function code is ignored.
dwReturnValue = OnOcCleanup();
break;
case OC_ABOUT_TO_COMMIT_QUEUE:
if ( (pvSubComponentId != (PVOID) NULL) && (*((LPCTSTR) pvSubComponentId) != _T('\0')) ) { dwReturnValue = OnOcAboutToCommitQueue( (LPCTSTR) pvSubComponentId );
ClRtlLogPrint( "OnOcAboutToCommitQueue returned 0x%1!x!.\n\n", dwReturnValue ); } else { dwReturnValue = (DWORD) NO_ERROR; }
break;
case OC_EXTRA_ROUTINES:
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "returning 0x%1!x! for OC_EXTRA_ROUTINES.\n\n", dwReturnValue );
break;
default:
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "ClusOcmSetupProc received an unknown function code, 0x%1!x!.\n", uxFunction ); ClRtlLogPrint( "returning 0x%1!x!.\n", dwReturnValue );
break; } // end of switch( uxFunction )
return ( (DWORD) dwReturnValue );}
#pragma warning ( default : 4100 ) // default behavior "unreferenced formal parameter" warning
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcPreinitialize
//
// Routine Description:
// This funcion processes OC_PREINITIALIZE "messages" from Optional
// Components Manager. This is the first function in the component
// setup dll that OC Manager calls.
//
// This function prevents clusocm.dll from running on down level operating
// systems and unuthorized platforms.
//
// Since Microsoft Cluster Server can only be installed on NT this function
// selects the UNICODE character set.
//
// Arguments:
// None
//
// Return Value:
// (DWORD) OCFLAG_UNICODE - indicates success
// (DWORD) 0 - indicates that the component cannot be initialized.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcPreinitialize( void ){ DWORD dwReturnValue;
// The ClRtlInitialize function that opens a log file reads the ClusterLog
// environment variable. This code segment reads that environment variable
// and saves it so that it can be restored on exit.
char * pszOriginalLogFileName;
pszOriginalLogFileName = getenv( "ClusterLog" );
if ( pszOriginalLogFileName != (char *) NULL ) { strcpy( m_szOriginalLogFileName, pszOriginalLogFileName ); } else { *m_szOriginalLogFileName = (char) '\0'; }
// Build the string used to set the ClusterLog environment variable to point
// to the log for clusocm.dll.
char szClusterLogEnvString[MAX_PATH];
// Initialize the string to be empty.
*szClusterLogEnvString = '\0';
// The log file for clusocm.dll will be located in the windows directory.
// Note that if the path to the Windows directory cannot be obtained the
// ClusterLog environment variable will be set empty. Then function ClRtlInitialize
// will use the default log file name and location.
TCHAR tszWindowsDirectory[MAX_PATH];
UINT uxReturnValue;
uxReturnValue = GetWindowsDirectory( tszWindowsDirectory, (UINT) MAX_PATH );
if ( uxReturnValue > 0 ) { // The first part of the string to set the ClusterLog environment variable is
// "ClusterLog=".
strcpy( szClusterLogEnvString, "ClusterLog=" );
// Convert the path to the Windows directory to MBCS.
char szWindowsDirectory[MAX_PATH];
wcstombs( szWindowsDirectory, tszWindowsDirectory, MAX_PATH );
// Append the path to the Windows directory.
strcat( szClusterLogEnvString, szWindowsDirectory );
// Append the log file name.
strcat( szClusterLogEnvString, "\\clusocm.log" ); } // Was the path to the Windows directory obtained?
// Set the ClusterLog environment variable. Note that _putenv returns 0
// on success.
if ( _putenv( szClusterLogEnvString ) != 0 ) { dwReturnValue = GetLastError(); // just here for debugging
}
// Initialize the cluster runtime library. FALSE indicates that debug
// output should not be redirected to a console window. If ClRtlInitialize
// fails the calls to ClRtlLogPrint will be benign.
ClRtlInitialize( FALSE );
// Note: The date in the following statement is hardcoded on purpose. It is to
// indicate when the last time the logging statements were revised.
ClRtlLogPrint( "\n\nCLUSOCM.LOG version 04/09/99 13:20.\n" );
// Microsoft Cluster Server can only be installed on Windows NT Server Enterprise 5.0+.
// This code segment checks the operating system version.
// Since Microsoft Cluster Server can only be installed on NT indicate
// to OC Manager that the UNICODE character set should be used.
dwReturnValue = (DWORD) OCFLAG_UNICODE;
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcInitComponent
//
// Routine Description:
// This funcion processes OC_INIT_COMPONENT "messages" from Optional
// Components Manager.
//
// This function is called soon after the component's setup dll is
// loaded. This function provides initialization information to the
// dll, instructs the dll to initialize itself, and provides a
// mechanism for the dll to return information to OC Manager.
//
// Arguments:
// pSetupInitComponent - points to a SETUP_INIT_COMPONENT structure
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
// Note:
// The SETUP_INIT_COMPONENT structure pointed to by pSetupInitComponent
// DOES NOT PERSIST. It is ncessary to save a copy in the CClusocmApp object.
// This function initializes the SETUP_INIT_COMPONENT data member,
// m_SetupInitComponent.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcInitComponent( IN OUT PSETUP_INIT_COMPONENT pSetupInitComponent ){ DWORD dwReturnValue;
if ( pSetupInitComponent != (PSETUP_INIT_COMPONENT) NULL ) { // Save the pointer to the SETUP_INIT_COMPONENT structure.
m_SetupInitComponent = *pSetupInitComponent;
// This code segment determines whether the version of OC Manager is
// correct.
if ( OCMANAGER_VERSION <= m_SetupInitComponent.OCManagerVersion ) { // Indicate to OC Manager which version of OC Manager this dll expects.
pSetupInitComponent->ComponentVersion = OCMANAGER_VERSION;
// Update CClusocmApp's copy of the SETUP_INIT_COMPONENT structure.
m_SetupInitComponent.ComponentVersion = OCMANAGER_VERSION;
// Is the handle to the component INF valid ?
if ( (m_SetupInitComponent.ComponentInfHandle != (HINF) INVALID_HANDLE_VALUE) && (m_SetupInitComponent.ComponentInfHandle != (HINF) NULL) ) { // The following call to SetupOpenAppendInfFile ensures that layout.inf
// gets appended to clusocm.inf. This is required for several reasons
// dictated by the Setup API. In theory OC Manager should do this, but
// as per Andrew Ritz, 8/24/98, OC manager neglects to do it and it is
// harmless to do it here after OC Manager is revised.
// Note that passing NULL as the first parameter causes SetupOpenAppendInfFile
// to append the file(s) listed on the LayoutFile entry in clusocm.inf.
UINT uxStatus;
SetupOpenAppendInfFile( NULL, m_SetupInitComponent.ComponentInfHandle, &uxStatus );
if ( ClRtlIsOSValid() == TRUE ) { // Since Microsoft Cluster Server can only be installed on NT indicate
// to OC Manager that the UNICODE character set should be used.
dwReturnValue = (DWORD) NO_ERROR; } else { // The operating system version is not correct.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) == (DWORDLONG) 0L ) { CString csMessage;
csMessage.LoadString( IDS_ERR_INCORRECT_OS_VERSION );
AfxMessageBox( csMessage ); }
DWORD dwErrorCode;
dwErrorCode = GetLastError();
ClRtlLogPrint( "ClRtlIsOSValid failed with error code %1!x!.\n", dwErrorCode );
dwReturnValue = (DWORD) ERROR_CALL_NOT_IMPLEMENTED; } } else { // Indicate failure.
ClRtlLogPrint( "In OnOcInitComponent the ComponentInfHandle is bad.\n" );
dwReturnValue = (DWORD) ERROR_CALL_NOT_IMPLEMENTED; } } else { // Indicate failure.
ClRtlLogPrint( "An OC Manager version mismatch. Version %1!d! is required, version %2!d! was reported.\n", OCMANAGER_VERSION, m_SetupInitComponent.OCManagerVersion );
dwReturnValue = (DWORD) ERROR_CALL_NOT_IMPLEMENTED; } } else { ClRtlLogPrint( "In OnOcInitComponent the pointer to the SETUP_INIT_COMPONENT structure is NULL.\n" );
dwReturnValue = (DWORD) ERROR_CALL_NOT_IMPLEMENTED; }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcQueryState
//
// Routine Description:
// This funcion sets the original, current, and final selection states of the
// Cluster service optional component.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// uxSelStateQueryType - indicates whether OC Manager is requesting the
// original, current, or final selection state of the
// component
//
// Return Value:
// SubcompOn - indicates that the checkbox should be set
// SubcompOff - indicates that the checkbox should be clear
// SubcompUseOCManagerDefault - OC Manager should set the state of the checkbox
// according to state information that is maintained
// internally by OC Manager itself.
//
// Note:
// By the time this function gets called OnOcInitComponent has already determined
// that Terminal Services is not installed. It is only necessary to determine
// whether Terminal Services is selected for installation.
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcQueryState( IN LPCTSTR ptszSubComponentId, IN UINT uxSelStateQueryType ){ DWORD dwReturnValue; eClusterInstallState eState;
// For unattended setup the selection state of the Cluster service optional
// component is specified in the answer file. Pat Styles recommends returning
// SubcompUseOcManagerDefault in every case.
// The following "if" statement forces SubcompUseOcManagerDefault to be returned
// if the subcomponent name is invalid.
if ( ptszSubComponentId != (LPCTSTR) NULL ) { // The subcomponent ID is valid. For what purpose was this function called?
switch ( uxSelStateQueryType ) { case OCSELSTATETYPE_ORIGINAL:
// OC Manager is requesting the intitial (original) selection state
// of the component.
// Is this a fresh install running under GUI mode setup ?
if ( ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) == (DWORDLONG) 0L ) && ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) == (DWORDLONG) 0L ) ) { // SETUPOP_STANDALONE flag clear means running under GUI mode setup.
// SETUPOP_NTUPGRADE flag clear means not performing an upgrade.
// Both flags clear means a fresh install in GUI MODE setup.
// Return SubcompUseOcManagerDefault. As per AndrewR, for unattended
// clean install return SubcompUseOcManagerDefault. For attended
// clean install let OC Manager manage the selection state. Returning
// SubcompUseOcManagerDefault will allow OC Manager to honor the
// "modes" line in clusocm.inf if one is present.
dwReturnValue = (DWORD) SubcompUseOcManagerDefault;
ClRtlLogPrint( "OnOcQueryState is returning SubcompUseOcManagerDefault for ORIGINAL on a clean install.\n" ); } // clean install?
else { // This is standalone or upgrade. Is this an unattended clean install?
if ( ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) != (DWORDLONG) 0L ) && ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) == (DWORDLONG) 0L ) ) { // This is UNATTENDED INSTALL with OCM running STANDALONE. Since
// this is STANDALONE, the MUST be an answer file.
// As per AndrewR for unattended clean install return SubcompUseOcManagerDefault.
dwReturnValue = (DWORD) SubcompUseOcManagerDefault;
ClRtlLogPrint( "ORIGINAL selection state: SubcompUseOcManagerDefault - UNATTENDED CLEAN install.\n" ); } else { // Either an upgrade is in progress or OC Manager is running standalone.
// The state of the checkbox depends on whether Cluster service has
// previously been installed.
// GetClusterInstallationState reports on the state of the registry value
// that records the state of the Cluster service installation on NT 5 machines.
// IsClusterServiceRegistered indicates whether the Cluster service is registered on
// BOTH NT 4 and NT 5 machines. Both tests are required: IsClusterServiceRegistered for
// upgrading NT 4 machines, GetClusterInstallationState for NT 5 machines.
ClRtlGetClusterInstallState( NULL, &eState );
if ( ( eState != eClusterInstallStateUnknown ) || ( IsClusterServiceRegistered() == (BOOL) TRUE ) ) { // No error was detected.
dwReturnValue = (DWORD) SubcompOn;
ClRtlLogPrint( "ORIGINAL selection state: SubcompOn - UPGRADE or STANDALONE - Cluster service previously installed.\n" ); } else { // Some error occured.
dwReturnValue = (DWORD) SubcompOff;
ClRtlLogPrint( "ORIGINAL selection state: SubcompOff - UPGRADE or STANDALONE - Cluster service NOT previously installed.\n" ); } // Were the Cluster service files installed?
} // unattended?
} // Is this a fresh install?
break;
case OCSELSTATETYPE_CURRENT:
// OC Manager is requesting the current selection state of the component.
// For the cases of a "clean" install or when OC manager is running
// standalone it is safe to let OC Manager use the default selection state
// to determine the cuttent selection state. The UPGRADE case requires
// specific handling. Is this an UPGRADE?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) != (DWORDLONG) 0L ) { // This is an upgrade. The state of the checkbox depends on whether
// Cluster service has previously been installed.
// GetClusterInstallationState reports on the state of the registry value
// that records the state of the Cluster service installation on NT 5 machines.
// IsClusterServiceRegistered indicates whether the Cluster service is registered on
// BOTH NT 4 and NT 5 machines. Both tests are required: IsClusterServiceRegistered for
// upgrading NT 4 machines, GetClusterInstallationState for NT 5 machines.
ClRtlGetClusterInstallState( NULL, &eState );
if ( ( eState != eClusterInstallStateUnknown ) || ( IsClusterServiceRegistered() == (BOOL) TRUE ) ) { // No error was detected.
dwReturnValue = (DWORD) SubcompOn;
ClRtlLogPrint( "CURRENT selection state: SubcompOn - UPGRADE - Cluster service previously installed.\n" ); } else { // Some error occured.
dwReturnValue = (DWORD) SubcompOff;
ClRtlLogPrint( "CURRENT selection state: SubcompOff - UPGRADE - Cluster service NOT previously installed.\n" ); } // Were the Cluster service files installed?
} else { // This is either a "fresh" install or OC Manager is running standalone.
dwReturnValue = (DWORD) SubcompUseOcManagerDefault;
ClRtlLogPrint( "CURRENT selection state: SubcompUseOcManagerDefault - CLEAN install or STANDALONE.\n" ); } // Is this an UPGRADE?
break;
case OCSELSTATETYPE_FINAL:
// OC Manager is requesting the final selection state of the component.
// As per Pat Styles, this call to OnOcQueryState will occur AFTER
// OnOcCompleteInstallation has been called. The registry operation that
// creates the registry key that GetClusterInstallationState checks as
// its' indicator of success is queued by OnOcCompleteInstallation.
// Does this OC Manager Setup DLL believe it has completed without error?
ClRtlGetClusterInstallState( NULL, &eState ); if ( eState != eClusterInstallStateUnknown ) { // No error was detected.
dwReturnValue = (DWORD) SubcompOn;
ClRtlLogPrint( "FINAL selection state: SubcompOn.\n" ); } else { // Some error occured.
dwReturnValue = (DWORD) SubcompOff;
ClRtlLogPrint( "FINAL selection state: SubcompOff.\n" ); } // Were the Cluster service files installed?
break;
default:
// This is an error condition.
dwReturnValue = (DWORD) SubcompUseOcManagerDefault;
ClRtlLogPrint( "Bad Param1 passed to OnOcQueryState.\n" );
break; } // end of switch ( uxSelStateQueryType )
} else { // The subcomponent ID is invalid.
dwReturnValue = (DWORD) SubcompUseOcManagerDefault;
ClRtlLogPrint( "In OnOcQueryState the subcomponent ID is NULL.\n" ); } // Is the subcomponent ID legal?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcSetLanguage
//
// Routine Description:
// This funcion indicates to OC Manager that clusocm.dll cannot handle
// alternate langiages.
//
// Arguments:
// None
//
// Return Value:
// (DWORD) FALSE
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcSetLanguage( void ){ // Returning (DWORD) FALSE will indicate to OC Manager that the component
// setup dll does not support the requested language.
return (DWORD) FALSE;}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcCalcDiskSpace
//
// Routine Description:
// This function processes the OC_CALC_DISK_SPACE "messages" from the
// Optional Components Manager. It either adds or removes disk space
// requirements from the Disk Space List maintained by OC Manager.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// uxAddOrRemoveFlag - Non-zero means that the component setup dll is being
// asked to add space requirements for a subcomponent to
// the disk space list. ZERO means that the component
// setup dll is being asked to remove space requirements
// for the subcomponent from the disk space list.
// hDiskSpaceList - a HDSPSPC (typedefed in setupapi.h to PVOID)
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcCalcDiskSpace( IN LPCTSTR ptszSubComponentId, IN UINT uxAddOrRemoveFlag, IN OUT HDSKSPC hDiskSpaceList ){ DWORD dwReturnValue = NO_ERROR;
// Is the subcomponent ID meaningfull?
if ( ptszSubComponentId != (LPCTSTR) NULL ) { // Is the handle to the component INF file meaningfull?
if ( (m_SetupInitComponent.ComponentInfHandle != (HINF) INVALID_HANDLE_VALUE) && (m_SetupInitComponent.ComponentInfHandle != (HINF) NULL) ) { BOOL fReturnValue;
// The INF file is open. Now we can use it.
// Associate the user defined Directory IDs in the [DestinationDirs] section
// of clusocm.inf with actual directories.
BOOL fClusterServiceRegistered;
fClusterServiceRegistered = IsClusterServiceRegistered();
if ( SetDirectoryIds( fClusterServiceRegistered ) == (BOOL) TRUE ) { if ( uxAddOrRemoveFlag != (UINT) 0 ) { // Add disk space requirements to the file disk space list.
fReturnValue = SetupAddInstallSectionToDiskSpaceList( hDiskSpaceList, m_SetupInitComponent.ComponentInfHandle, NULL, ptszSubComponentId, 0, 0 );
if ( fReturnValue == (BOOL) FALSE ) { dwReturnValue = GetLastError(); }
ClRtlLogPrint( "SetupAddInstallSectionToDiskSpaceList returned 0x%1!x! to OnOcCalcDiskSpace.\n", fReturnValue ); } else { // Remove disk space requirements from the disk space list.
fReturnValue = SetupRemoveInstallSectionFromDiskSpaceList( hDiskSpaceList, m_SetupInitComponent.ComponentInfHandle, NULL, ptszSubComponentId, 0, 0 );
if ( fReturnValue == (BOOL) FALSE ) { dwReturnValue = GetLastError(); }
ClRtlLogPrint( "SetupRemoveInstallSectionFromDiskSpaceList returned 0x%1!x! to OnOcCalcDiskSpace.\n", fReturnValue ); } } else { dwReturnValue = GetLastError();
ClRtlLogPrint( "In OnCalcDiskSpace the call to SetDirectoryIds failed.\n" ); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwReturnValue ); } // Were the directory Id associations made successfully?
} else { ClRtlLogPrint( "In OnOcCalcDiskSpace ComponentInfHandle is bad.\n" );
dwReturnValue = ERROR_FILE_NOT_FOUND; } }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcCompleteInstallation
//
// Routine Description:
// This function processes the OC_COMPLETE_INSTALLATION "messages" from the
// Optional Components Manager. It queues registry operations.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcCompleteInstallation( IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue = NO_ERROR;
if ( (m_SetupInitComponent.ComponentInfHandle != (HINF) INVALID_HANDLE_VALUE) && (m_SetupInitComponent.ComponentInfHandle != (HINF) NULL) ) { // The INF file handle is valid.
BOOL fOriginalSelectionState; BOOL fCurrentSelectionState;
// Is the subcomponent currently selected ?
fCurrentSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) ptszSubComponentId, (UINT) OCSELSTATETYPE_CURRENT );
if ( fCurrentSelectionState == (BOOL) TRUE ) { ClRtlLogPrint( "In OnOcCompleteInstallation the current selection state is TRUE.\n" );
// The subcomponent is currently selected. Is this a fresh install ?
if ( ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) == (DWORDLONG) 0L ) && ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) == (DWORDLONG) 0L ) ) { ClRtlLogPrint( "In OnOcCompleteInstallation this is a GUI mode clean install.\n" );
// SETUPOP_STANDALONE flag clear means running under GUI mode setup.
// SETUPOP_NTUPGRADE flag clear means not performing an upgrade.
// Both flags clear means a fresh install. Do not check for a selection
// state transition.
dwReturnValue = CompleteInstallingClusteringService( (LPCTSTR) ptszSubComponentId );
ClRtlLogPrint( "CompleteInstallingClusteringService returned 0x%1!x! to OnOcCompleteInstallation.\n", dwReturnValue ); } else { // This is not a GUI mode fresh install. Is it an UPGRADE ?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcCompleteInstallation - This is an UPGRADE.\n" );
// Complete the process of upgrading Cluster service.
dwReturnValue = CompleteUpgradingClusteringService( (LPCTSTR) ptszSubComponentId );
ClRtlLogPrint( "CompleteUpgradingClusteringService returned 0x%1!x! to OnOnCompleteInstallation.\n", dwReturnValue ); } else { ClRtlLogPrint( "In OnOcCompleteinstallation - this is STANDALONE.\n" );
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcCompleteInstallation this is UNATTENDED STANDALONE and Cluster service is selected.\n" ); }
// This is not an upgrade. That means Add/Remove Programs must be
// running.
// Check for a selection state transition.
fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
if ( fCurrentSelectionState != fOriginalSelectionState ) { ClRtlLogPrint( "In OnOcCompleteInstallation a selection state transition has been detected.\n" );
dwReturnValue = CompleteStandAloneInstallationOfClusteringService( (LPCTSTR) ptszSubComponentId );
ClRtlLogPrint( "CompleteStandAloneInstallationOfClusteringService returned 0x%1!x! to OnOcCompleteInstallation.\n", dwReturnValue ); } else { ClRtlLogPrint( "In OnOcCompleteInstallation since no selection state transition was detected there is nothing to do.\n" );
// The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR; } // was there a selection state transition?
} // is this an UPGRADE?
} // is this a fresh install ?
} else { ClRtlLogPrint( "In OnOcCompleteInstallation the current selection state is FALSE.\n" );
// The subcomponent is not selected. Is OC Manager running stand-alone ?
// If not, i.e. if GUI mode setup is running, there is nothing to do.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcCompleteInstallation this is STANDALONE.\n" );
// SETUPOP_STANDALONE set implies GUI mode setup is not running. If
// there was a selection state change (to unselected) then delete
// registry entries.
fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
// Has there been a selection state transition ?
if ( fCurrentSelectionState != fOriginalSelectionState ) { ClRtlLogPrint( "In OnOcCompleteInstallation a selection state transition has been detected.\n" );
// Complete the process of uninstalling Cluster service.
dwReturnValue = CompleteUninstallingClusteringService( (LPCTSTR) ptszSubComponentId );
ClRtlLogPrint( "CompleteUninstallingClusteringService returned 0x%1!x! to OnOcCompleteInstallation.\n", dwReturnValue ); } else { // The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "In OnOcCompleteInstallation a selection state transition was not detected\n" ); ClRtlLogPrint( "so there is nothing to do.\n" ); } // Was there a selection state transition ?
} else { // GUI mode setup is running. Perform no action.
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "In OnOcCompleteInstallation GUI mode setup is running and the\n" ); ClRtlLogPrint( "component is not selected so there is nothing to do.\n" ); } // Is GUI mode setup running ?
} // Is the subcomponent currently selected ?
} else { dwReturnValue = ERROR_FILE_NOT_FOUND;
ClRtlLogPrint( "In OnOcCompleteInstallation the handle to the component INF file is bad.\n" ); } // Is the handle to the component INF file valid ?
ClRtlLogPrint( "OnOcCompleteInstallation is preparing to return 0x%1!x!.\n", dwReturnValue );
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcQueryChangeSelState
//
// Routine Description:
// This function processes the OC_QUERY_CHANGE_SEL_STATE "messages" from the
// Optional Components Manager.
//
// Arguments:
// pvComponentId - points to a string that uniquely identifies the component
// to be set up to OC Manager.
// pvSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// uxFunction - OC_QUERY_CHANGE_SEL_STATE - See ocmanage.h for the macro definitions.
// uxParam1 - proposed state of the subcomponent
// zero means unselected
// non-zero means selected
// pvParam2 - Flags
//
// Return Value:
// (DWORD) TRUE - the proposed selection state should be accepted
// (DWORD) FALSE - the proposed selection state should be rejected
//
// Note:
// As currently implemented on 2/25/1998, this function will disallow all
// changes to the selection state of Cluster service during an upgrade to a
// machine on which Cluster service has previously been installed.
//
// I have assumed that if the SETUPOP_NTUPGRADE flag is set that GUI mode
// setup is running because there is no way to perform and upgrade other
// than running NT setup.
//
// Cluster service and Terminal Services are mutually exclusive. By the
// time that this function gets called, OnOcInitComponent has already determined
// that Terminal Services is not installed. Therefore it is only necessary to
// determine whether Terminal Services is selected for installation.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcQueryChangeSelState( IN LPCTSTR ptszSubComponentId, IN UINT uxProposedSelectionState, IN DWORD dwFlags ){ DWORD dwReturnValue = (DWORD) TRUE;
eClusterInstallState eState;
// Is an upgrade in progress ?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOnQueryChangeSelState this is an UPGRADE. Selection state transitions are not allowed.\n" );
// Since this is an UPGRADE the selection state cannot be changed.
// Return FALSE to disallow selection state changes.
dwReturnValue = (DWORD) FALSE; } else { if ( dwReturnValue == (DWORD) TRUE ) { // Either Cluster service is being deselected, which implies that the
// selection state of Terminal Services is inconsequential, or Terminal
// Services is not selected for installation.
// Is GUI mode setup running?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) == (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcQueryChangeSelState this is NOT STANDALONE.\n" );
// SETUPOP_STANDALONE clear means GUI mode setup is running.
// In conjunction with SETUPOP_NTUPGRADE clear it means that
// a fresh NT installation is in progress.
// It is possible for the user to request that a fresh install target
// the directory for an existing NT installation. In that event, as per
// David P., if Cluster Server has been installed, the user should
// not be allowed to deselect the Cluster Server component.
// GetClusterInstallationState reports on the state of the registry value
// that records the state of the Cluster service installation on NT 5 machines.
// IsClusterServiceRegistered indicates whether the Cluster service is registered on
// BOTH NT 4 and NT 5 machines. Both tests are required: IsClusterServiceRegistered for
// upgrading NT 4 machines, GetClusterInstallationState for NT 5 machines.
ClRtlGetClusterInstallState( NULL, &eState ); if ( ( eState != eClusterInstallStateUnknown ) || ( IsClusterServiceRegistered() == (BOOL) TRUE ) ) { // Disallow deselection of the cluster component(s).
dwReturnValue = (DWORD) FALSE;
ClRtlLogPrint( "In OnOcQueryChangeSelState since Clustering Server has previously\n" ); ClRtlLogPrint( "been installed selection state transitions are not allowed.\n" ); } else { // Allow the selection state to be changed.
dwReturnValue = (DWORD) TRUE;
ClRtlLogPrint( "In OnOcQueryChangeSelState since Clustering Server has never\n" ); ClRtlLogPrint( "been installed selection state transitions are allowed.\n" ); } } // GUI mode setup running?
else { // This is a standalone operation. Allow the selection state to be changed.
dwReturnValue = (DWORD) TRUE;
ClRtlLogPrint( "In OnOcQueryChangeSelState this is STANDALONE so selection state transitions are allowed.\n" ); } // GUI mode setup running?
} }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// PerformRegistryOperations
//
// Routine Description:
// This function performs the registry operations, both the AddReg and DelReg
// in the section indicated by ptszSectionName are processed.
// registry entries.
//
// Arguments:
// hInfHandle - a handle to the component INF file.
// ptszSectionName - points to a string containing the name of a section in
// the INF file.
//
// Return Value:
// (DWORD) NO_ERROR - indicated success
// Any other retuen value is a Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::PerformRegistryOperations( HINF hInfHandle, LPCTSTR ptszSectionName ){ DWORD dwReturnValue;
// Install ... perform the registry operations.
dwReturnValue = SetupInstallFromInfSection( NULL, // hwndOwner
m_SetupInitComponent.ComponentInfHandle, // inf handle
ptszSectionName, // name of section
SPINST_REGISTRY, // operation flags
NULL, // relative key root
NULL, // source root path -
// irrelevant for registry operations
0, // copy flags
NULL, // callback routine
NULL, // callback routine context
NULL, // device info set
NULL ); // device info struct
// Were the registry operations performed successfully?
if ( dwReturnValue == (DWORD) TRUE ) { dwReturnValue = (DWORD) NO_ERROR; } else { dwReturnValue = GetLastError(); } // Were the registry operations performed successfully?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// UninstallRegistryOperations
//
// Routine Description:
// This function queues the registry operations that delete cluster related
// registry entries on UNINSTALL.
//
// Arguments:
// hInfHandle - a handle to the component INF file.
// ptszSubComponentId - points to a string containing the name of the subcomponent.
//
//
// Return Value:
// (DWORD) NO_ERROR - indicated success
// Any other retuen value is a Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::UninstallRegistryOperations( IN HINF hInfHandle, IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue;
BOOL fReturnValue;
INFCONTEXT InfContext;
// There is an entry called "Uninstall" in the [Cluster] section of
// cluster.inf. That entry provides the name of an "install" section
// that should be substituted for the [Cluster] section when uninstalling.
// The following function locates that line so it can be read.
CString csSectionName;
csSectionName = UNINSTALL_INF_KEY;
fReturnValue = SetupFindFirstLine( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, csSectionName, &InfContext );
if ( fReturnValue == (BOOL) TRUE ) { // Read the name of the replacement section.
TCHAR tszReplacementSection[256]; // Receives the section name
fReturnValue = SetupGetStringField( &InfContext, 1, // there should be a single field
tszReplacementSection, sizeof( tszReplacementSection ) / sizeof( TCHAR ), NULL );
if ( fReturnValue == (BOOL) TRUE ) { // Remove the registry keys.
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, tszReplacementSection );
ClRtlLogPrint( "PerformRegistryOperations returned 0x%1!x! to UninstallRegistryOperations.\n", dwReturnValue ); } else { ClRtlLogPrint( "UninstallDelRegistryOperations could not read the INF file.\n" );
dwReturnValue = (DWORD) ERROR_FILE_NOT_FOUND; } } else { ClRtlLogPrint( "UninstallDelRegistryOperations could not read the INF file.\n" );
dwReturnValue = (DWORD) ERROR_FILE_NOT_FOUND; }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// QueueInstallFileOperations
//
// Routine Description:
// This function queues the file operations that install cluster related files.
//
// Arguments:
// hInfHandle - a handle to the component INF file.
// ptszSubComponentId - points to a string containing the name of the subcomponent.
//
//
// Return Value:
// (DWORD) NO_ERROR - indicated success
// Any other retuen value is a Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::QueueInstallFileOperations( IN HINF hInfHandle, IN LPCTSTR ptszSubComponentId, IN OUT HSPFILEQ hSetupFileQueue ){ DWORD dwReturnValue; CString csSectionName;
// Dummy do-while loop to avoid gotos.
do { // As per Pat Styles on 7/16/98 pass NULL in the SourcePath parameter.
dwReturnValue = SetupInstallFilesFromInfSection( hInfHandle, // handle to the INF file
NULL, // optional, layout INF handle
hSetupFileQueue, // handle to the file queue
ptszSubComponentId, // name of the Install section
NULL, // optional, root path to source files
SP_COPY_NEWER // optional, specifies copy behavior
);
ClRtlLogPrint( "The first call to SetupInstallFilesFromInfSection returned 0x%1!x! to QueueInstallFileOperations.\n", dwReturnValue );
// Was the operation successful ?
if ( dwReturnValue == (DWORD) FALSE ) { dwReturnValue = GetLastError(); break; }
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) == (DWORDLONG) 0L ) { dwReturnValue = (DWORD) NO_ERROR; // This is not an UPGRADE.
break; }
// If this is an UPGRADE (from NT 4.0) then queue the file operations
// specified in the [Upgrade] section.
ClRtlLogPrint( "In QueueInstallFileOperations this is an UPGRADE.\n" );
// Copy the replace-only files. Some files like IISCLUS3.DLL need to be copied
// on an upgrade only if they already existed before the upgrade.
// This is what I learnt from Brent (a-brentt) on 7/15/1999.
csSectionName = UPGRADE_REPLACEONLY_INF_KEY;
// As per Pat Styles on 7/16/98 pass NULL in the SourcePath parameter.
dwReturnValue = SetupInstallFilesFromInfSection( hInfHandle, // handle to the INF file
NULL, // optional, layout INF handle
hSetupFileQueue, // handle to the file queue
csSectionName, // name of the Install section
NULL, // optional, root path to source files
SP_COPY_REPLACEONLY // optional, specifies copy behavior
);
ClRtlLogPrint( "The first call to SetupInstallFilesFromInfSection returned 0x%1!x! to QueueInstallFileOperations.\n", dwReturnValue );
if ( dwReturnValue == (DWORD) FALSE ) { dwReturnValue = GetLastError(); break; }
// The replace only copy was successful. Now do the normal CopyFiles and DelFiles
// subsections.
csSectionName = UPGRADE_INF_KEY;
// This function processes the CopyFiles subsection under the UPGRADE_INF_KEY section.
dwReturnValue = SetupInstallFilesFromInfSection( hInfHandle, // handle to the INF file
NULL, // optional, layout INF handle
hSetupFileQueue, // handle to the file queue
csSectionName, // name of the Install section
NULL, // optional, root path to source files
SP_COPY_NEWER // optional, specifies copy behavior
);
ClRtlLogPrint( "The second call to SetupInstallFilesFromInfSection returned 0x%1!x! to QueueInstallFileOperations.\n", dwReturnValue );
if ( dwReturnValue == (DWORD) FALSE ) { dwReturnValue = GetLastError(); break; }
// This function processes the DelFiles subsection under the UPGRADE_INF_KEY section.
dwReturnValue = SetupQueueDeleteSection( hSetupFileQueue, // handle to the file queue
hInfHandle, // handle to the INF file containing the [DestinationDirs] section
hInfHandle, // handle to the INF file
csSectionName // INF section that lists the files to delete
);
ClRtlLogPrint( "The call to SetupQueueDeleteSection returned 0x%1!x! to QueueInstallFileOperations.\n", dwReturnValue );
if ( dwReturnValue == (DWORD) FALSE ) { dwReturnValue = GetLastError(); break; }
dwReturnValue = (DWORD) NO_ERROR; } while ( FALSE ); // dummy do-while loop to avoid gotos.
if ( dwReturnValue == (DWORD) NO_ERROR ) { ClRtlLogPrint( "QueueInstallFileOperations compeleted successfully.\n" ); } else { ClRtlLogPrint( "Error in QueueInstallFileOperations.\n" ); }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// QueueRemoveFileOperations
//
// Routine Description:
// This function queues the file operations that delete cluster related files.
//
// Arguments:
// hInfHandle - a handle to the component INF file.
// ptszSubComponentId - points to a string containing the name of the subcomponent.
//
//
// Return Value:
// (DWORD) NO_ERROR - indicated success
// Any other return value is a Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::QueueRemoveFileOperations( IN HINF hInfHandle, IN LPCTSTR ptszSubComponentId, IN OUT HSPFILEQ hSetupFileQueue ){ DWORD dwReturnValue;
BOOL fReturnValue;
INFCONTEXT InfContext;
// There is an entry called "Uninstall" in the [Cluster] section of
// cluster.inf. That entry provides the name of an "install" section
// that should be substituted for the [Cluster] section when uninstalling.
// The following function locates that line so it can be read.
CString csSectionName;
csSectionName = UNINSTALL_INF_KEY;
fReturnValue = SetupFindFirstLine( hInfHandle, ptszSubComponentId, csSectionName, &InfContext );
if ( fReturnValue == (BOOL) TRUE ) { // Read the name of the replacement section.
TCHAR tszReplacementSection[256]; // Receives the section name
fReturnValue = SetupGetStringField( &InfContext, 1, // there should be a single field
tszReplacementSection, sizeof( tszReplacementSection ) / sizeof( TCHAR ), NULL );
if ( fReturnValue == (BOOL) TRUE ) { // Remove the files.
dwReturnValue = SetupInstallFilesFromInfSection( hInfHandle, (HINF) NULL, // No layout file
hSetupFileQueue, (LPCTSTR) tszReplacementSection, (LPCTSTR) NULL, // SourceRootPath is irrelevant
(UINT) 0 );
ClRtlLogPrint( "SetupInstallFilesFromInfSection returned 0x%1!x! to QueueRemoveFilesOperations.\n", dwReturnValue );
// Was the operation successfull ?
if ( dwReturnValue == (DWORD) TRUE ) { dwReturnValue = (DWORD) NO_ERROR; } else { dwReturnValue = GetLastError(); } } else { dwReturnValue = (DWORD) ERROR_FILE_NOT_FOUND;
ClRtlLogPrint( "QueueRemoveFileOperations was unable to read the [Uninstall] section in the INF file.\n" ); } } else { dwReturnValue = (DWORD) ERROR_FILE_NOT_FOUND;
ClRtlLogPrint( "QueueRemoveFileOperations was unable to locate the [Uninstall] section in the INF file.\n" ); }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcAboutToCommitQueue
//
// Routine Description:
// If clusocm.dll is performing an uninstall, this function unregisters the
// cluster services.
//
// if clusocm.dll is performing an install or an upgrade this function does
// nothing.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcAboutToCommitQueue( IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue;
if ( (m_SetupInitComponent.ComponentInfHandle != (HINF) INVALID_HANDLE_VALUE) && (m_SetupInitComponent.ComponentInfHandle != (HINF) NULL) ) { // The INF file handle is valid.
BOOL fOriginalSelectionState; BOOL fCurrentSelectionState;
// Is the subcomponent currently selected ?
fCurrentSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) ptszSubComponentId, (UINT) OCSELSTATETYPE_CURRENT );
if ( fCurrentSelectionState != (BOOL) TRUE ) { // The subcomponent is not selected. Is OC Manager running stand-alone ?
// If not, i.e. if GUI mode setup is running, there is nothing to do.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcAboutToCommitQueue this is STANDALONE and the component is not selected.\n" ); ClRtlLogPrint( "So, this is an uninstall operation.\n" );
// SETUPOP_STANDALONE set implies GUI mode setup is not running. If
// there was a selection state change (to unselected) then delete
// registry entries.
fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
// Has there been a selection state transition ?
if ( fCurrentSelectionState != fOriginalSelectionState ) { CString csTemp;
ClRtlLogPrint( "In OnOcAboutToCommitQueue a selection state transition has been detected.\n" );
// At this point in cluscfg.exe file utils.cpp function DoUninstall
// called function IsOtherSoftwareInstalled. That function apparently
// checked for the presence of custom cluster resources and warned the
// user to handle them before proceeding. (at least that is what David
// told me). So, that logic needs to be replicated here.
// NOTE: According to Andrew Ritz (AndrewR), there is no way to abort the
// installation at this point. So the user is just shown the list of
// custom resource types and is prompted to remove them after the cluster
// service has been uninstalled. The user is not given an option to abort
// the installation.
// (Vvasu 14-DEC-1999)
if ( ( m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH ) == (DWORDLONG) 0L ) { // If this is not an unattended operation.
BOOL fReturnValue = CheckForCustomResourceTypes();
ClRtlLogPrint( "CheckForCustomResourceTypes returned 0x%1!x! to OnOcAboutToCommitQueue.\n", fReturnValue ); } else { ClRtlLogPrint( "CheckForCustomResourceTypes not called in OnOcAboutToCommitQueue as this is an unattended operation.\n" ); }
// Stop ClusSvc. Note that if ClusDisk is someday revised so that
// it will unload, it will be appropriate to stop ClusDisk here
// as well.
csTemp = CLUSTER_SERVICE_NAME;
// I'm going to assume that, since UNICODE is defined, the casts
// in the calls to function StopService are OK, even though there
// is probably a better approach.
StopService( (LPCWSTR) (LPCTSTR) csTemp );
csTemp = TIME_SERVICE_NAME;
StopService( (LPCWSTR) (LPCTSTR) csTemp );
ClRtlLogPrint( "OnOcAboutToCommitQueue has attempted to stop ClusSvc and TimeServ.\n" );
//
// Unregister the COM objects that may previously have been registered.
//
// Note that since msclus.dll is registered as part of NT setup
// it is not unregistered here.
//
csTemp = CLUSTER_DIRECTORY;
TCHAR tszPathToClusterDir[_MAX_PATH];
if ( ExpandEnvironmentStrings( (LPCTSTR) csTemp, tszPathToClusterDir, _MAX_PATH ) > 0L ) { BOOL bUnregisterResult = UnRegisterClusterCOMObjects( m_hInstance, tszPathToClusterDir );
ClRtlLogPrint( "OnOcAboutToCommitQueue has unregistered the COM objects. The return value is %1!d!\n", bUnregisterResult ); } else { // Couldn't expand the environment string.
ClRtlLogPrint( "OnOcAboutToCommitQueue could not unregister the COM objects\n" ); ClRtlLogPrint( "because it could not locate the cluster directory.\n" ); }
// Unload the Cluster hive so that the Cluster hive file can be removed.
UnloadClusDB();
ClRtlLogPrint( "OnOcAbouToCommitQueue has unloaded the Cluster hive.\n" );
dwReturnValue = (DWORD) NO_ERROR; } else { // The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint("In OnOcAboutToCommitQueue no selection state transition was detected.\n" ); } // Was there a selection state transition ?
} else { // OC Manager is NOT running stand-alone. This CANNOT be an uninstall
// operation. There is nothing for this function to do.
dwReturnValue = (DWORD) NO_ERROR; } // Is GUI mode setup running ?
} // Is the subcomponent cuttently selected ?
else { // Since the component is selected this CANNOT be an uninstall operation.
// There is nothing for this function to do.
dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "In OnOcAboutToCommitQueue the component is selected so there is nothing to do.\n" ); } } else { dwReturnValue = ERROR_FILE_NOT_FOUND;
ClRtlLogPrint( "In OnOcAboutToCommitQueue the handle to the INF file is bad.\n" ); } // Is the handle to the component INF file valid ?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// LocateClusterHiveFile
//
// Routine Description:
// This function attempts to locate the Cluster hive file and supply the
// path to the calling function.
//
// Arguments:
// rcsClusterHiveFilePath - a reference to a the CString to receive the
// path to the Cluster hive file.
//
// Return Value:
// TRUE - incicates that the Cluster hive file was located and that
// rcsClusterHiveFilePath is meaningfull.
// FALSE - indicates that the Cluster hive file was not located and
// rcsClusterHiveFilePath is empty.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::LocateClusterHiveFile( CString & rcsClusterHiveFilePath ){ BOOL fReturnValue;
// The path to the Cluster hive file may be deduced by reading the
// [DestinationDirs] section of the INF file. The ClusterFiles entry
// will specify the file's location.
if ( (m_SetupInitComponent.ComponentInfHandle != (HINF) INVALID_HANDLE_VALUE) && (m_SetupInitComponent.ComponentInfHandle != (HINF) NULL) ) { // The handle to the INF file is valid.
TCHAR tszPathToClusterDirectory[MAX_PATH];
// First, get the path to the cluster directory.
DWORD dwRequiredSize;
CString csSectionName;
csSectionName = CLUSTER_FILES_INF_KEY;
fReturnValue = SetupGetTargetPath( m_SetupInitComponent.ComponentInfHandle, (PINFCONTEXT) NULL, (PCTSTR) csSectionName, tszPathToClusterDirectory, (DWORD) MAX_PATH, (PDWORD) &dwRequiredSize );
if ( fReturnValue == (BOOL) TRUE ) { rcsClusterHiveFilePath = (CString) tszPathToClusterDirectory;
// Append the name of the Cluster hive file to the path.
CString csClusterDatabaseName;
csClusterDatabaseName = CLUSTER_DATABASE_NAME;
rcsClusterHiveFilePath += (CString) _T("\\") + csClusterDatabaseName;
ClRtlLogPrint( "LocateClusterHiveFile has deduced that the cluster hive is in %1!s!.\n", rcsClusterHiveFilePath );
// The path to the Cluster hive file has been built. Now, make
// sure that the file is present.
HANDLE hSearchHandle;
WIN32_FIND_DATA FindData;
hSearchHandle = FindFirstFile( rcsClusterHiveFilePath, &FindData);
if( hSearchHandle != (HANDLE) INVALID_HANDLE_VALUE ) { FindClose( hSearchHandle );
// A file with the correct name was located. Is it the cluster hive
// file? If it is a directory it is not.
if( (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != (DWORD) 0L ) { // The file is a directory. That means that the Cluster
// hive file could not be located.
ClRtlLogPrint( "LocateClusterHiveFile could not find file %1!s!.\n", rcsClusterHiveFilePath );
rcsClusterHiveFilePath.Empty();
fReturnValue = (BOOL) FALSE; } else { // The Cluster hive file was found.
ClRtlLogPrint( "LocateClusterHiveFile found the Cluster hive at %1!s!.\n", rcsClusterHiveFilePath );
fReturnValue = (BOOL) TRUE; } } else { // The cluster hive file was not located.
ClRtlLogPrint( "LocateClusterHiveFile could not find file %1!s!.\n", rcsClusterHiveFilePath );
rcsClusterHiveFilePath.Empty();
fReturnValue = (BOOL) FALSE; } } else { rcsClusterHiveFilePath.Empty();
ClRtlLogPrint( "SetupGetTargetPath failed in LocateClusterHiveFile.\n" ); } } else { // The handle to the INF file is not valid. That means that the Cluster
// hive file could not be located.
ClRtlLogPrint( "LocateClusterHiveFile could not locate the cluster hive because the\n" ); ClRtlLogPrint( "handle to the INF file is bad.\n" );
rcsClusterHiveFilePath.Empty();
fReturnValue = (BOOL) FALSE; }
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CheckForCustomResourceTypes
//
// Routine Description:
// This function examines the ResourceTypes subkey of the Cluster key to
// determine whether custom resource types have been installed.
//
// Arguments:
// None
//
//
// Return Value:
// TRUE - indicates that either no custom resource types have been detected
// or the user chooses to continue uninstalling Cluster Server without
// first uninstalling the software packages associated with the custom
// resource types.
// FALSE - indicates that custom resource types were detected and the user
// wishes to terminate uninstallation of Cluster Server.
//
// Note:
// This function was originally called IsOtherSoftwareInstalled in the old
// cluster\newsetup project in the file called utils.cpp.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::CheckForCustomResourceTypes( void ){ BOOL fReturnValue = (BOOL) TRUE; BOOL fEnumerateResourceTypesKeys = (BOOL) TRUE; BOOL fClusterHiveLoadedByThisFunction = (BOOL) FALSE;
HKEY hClusterKey;
LONG lReturnValue;
// Attempt to open the Cluster Registry key.
CString csClusterRegKey;
csClusterRegKey = CLUSREG_KEYNAME_CLUSTER;
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, csClusterRegKey, 0, KEY_READ, &hClusterKey);
if ( lReturnValue != ERROR_SUCCESS ) { ClRtlLogPrint( "In CheckForCustomResourceTypes the first attempt to open the Cluster key failed.\n" );
// The Cluster hive is not currently loaded. This condition means that
// the cluster service has not been started. Attempt to load the Cluster
// hive so that it can be read.
// First, locate the Cluster hive file. It should be in the location
// specified for the ClusterFiles entry in the [DestinationDirs] section
// of clusocm.inf.
CString csClusterHiveFilePath;
fReturnValue = LocateClusterHiveFile( (CString &) csClusterHiveFilePath );
ClRtlLogPrint( "LocateClusterHiveFile returned 0x%1!x! to CheckForCustomResourceTypes.\n", fReturnValue );
// Was the Cluster hive file located?
if ( fReturnValue == (BOOL) TRUE ) { // The Cluster hive file was located. Custom resource types may exist.
// Attempt to load the cluster hive.
BOOLEAN OriginalState;
// I'm not sure what the following function does, but the prototype is
// in sdk\inc\ntrtl.h. Look in stdafx.h for the inclusion of ntrtl.h. I
// replicated the logic that was used in newsetup.h to make it work.
// RtlAdjustPrivilege returns NTSTATUS.
NTSTATUS Status;
Status = RtlAdjustPrivilege( SE_RESTORE_PRIVILEGE, TRUE, FALSE, &OriginalState );
if ( NT_SUCCESS( Status ) ) { // Attempt to Load the Cluster Hive.
lReturnValue = RegLoadKey( HKEY_LOCAL_MACHINE, csClusterRegKey, csClusterHiveFilePath );
if ( lReturnValue == ERROR_SUCCESS ) { fClusterHiveLoadedByThisFunction = (BOOL) TRUE;
// Now that the Cluster hive has been loaded, attempt to open the
// Cluster registry key.
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, csClusterRegKey, 0, KEY_READ, &hClusterKey );
// lReturnValue will be tested by the next BLOCK of code.
} // cluster hive loaded?
else { // The Cluster hive could not be loaded. Treat that as if there
// are no custom resource types.
// A return value of TRUE will allow the uninstall operation to
// continue. Since lReturnValue is NOT ERROR_SUCCESS no additional
// processing will be performed by this function.
fReturnValue = (BOOL) TRUE; } // Was the cluster hive loaded successfully?
// Undo whatever the preceding call to RtlAdjustPrivilege() did.
RtlAdjustPrivilege( SE_RESTORE_PRIVILEGE, OriginalState, FALSE, &OriginalState ); } // Initial call to RtlAdjustPrivilege succeeded?
else { // The initial call to RtlAdjustPrivilege FAILED.
ClRtlLogPrint( "In CheckForCustomResources the initial call to RtlAdjustPrivileges failed with status %1!d!.\n", Status );
// A return value of TRUE will allow the uninstall operation to
// continue. Since lReturnValue is NOT ERROR_SUCCESS no additional
// processing will be performed by this function.
fReturnValue = (BOOL) TRUE; } // Did RtlAdjustPrivilege succeed?
} // cluster hive file located?
else { // The Cluster hive file was not located. That implies that there can be
// no custom resources. Since lReturnValue is NOT ERROR_SUCCESS no
// additional processing will be done by this function. A return value
// of TRUE will allow the uninstall operation to continue.
ClRtlLogPrint( "Since the Cluster hive file could not be located CheckForCustomResources will\n" ); ClRtlLogPrint( "report that the uninstall operation may continue.\n" );
fReturnValue = (BOOL) TRUE; } // Was the cluster hive file located?
} // Was the Cluster registry key opened successfully?
// The preceeding code segment may have loaded the cluster hive and
// attempted to open the cluster key. Was it sucessful?
if ( lReturnValue == ERROR_SUCCESS ) { // At this point, the Cluster registry key was opened successfully. Now, attempt
// to open the Resource Type subkey.
HKEY hResourceTypesKey;
CString csResourceTypesRegKey;
csResourceTypesRegKey = CLUSREG_KEYNAME_RESOURCE_TYPES;
lReturnValue = RegOpenKeyEx( hClusterKey, csResourceTypesRegKey, 0, KEY_READ, &hResourceTypesKey );
if ( lReturnValue == ERROR_SUCCESS ) { // The ResourceTypes sub key is open.
// Enumerate the subkeys of the REG_RESTYPES.
FILETIME t_LastWriteTime; WCHAR wszSubKeyName[256]; DWORD dwCharCount; DWORD dwIndex = 0; // index of the first sub-key to enumerate
dwCharCount = sizeof( wszSubKeyName ) / sizeof( wszSubKeyName[0] ); lReturnValue = RegEnumKeyEx( hResourceTypesKey, dwIndex, wszSubKeyName, &dwCharCount, NULL, NULL,// Class of the Key. Not Reqd.
NULL,// Size of the above param.
&t_LastWriteTime );
// RegEnumKeyEx returns ERROR_NO_MORE_ITEMS when there are
// no additional sub-keys to enumerate.
if ( lReturnValue == ERROR_SUCCESS ) { // The initial call to RegEnumKeyEx succeeded. Determine whether
// the sub-key is associated with a non-standard resource type.
// Function TryToRecognizeResourceType builds a list of non-standard resource types
// in the CString variable csNonStandardResourceTypeList.
CString csNonStandardResourceTypeList;
TryToRecognizeResourceType( csNonStandardResourceTypeList, wszSubKeyName );
// The following loop checks the remaining sub-keys in the
// Resource Types registry key.
while ( lReturnValue == ERROR_SUCCESS ) { dwIndex++;
dwCharCount = sizeof( wszSubKeyName ) / sizeof( wszSubKeyName[0] ); lReturnValue = RegEnumKeyEx( hResourceTypesKey, dwIndex, wszSubKeyName, &dwCharCount, NULL, NULL,// Class of the Key. Not Reqd.
NULL,// Size of the above param.
&t_LastWriteTime );
TryToRecognizeResourceType( csNonStandardResourceTypeList, wszSubKeyName ); }
// Were all subkeys of the ResourceTypes registry key "verified"?
if( lReturnValue == ERROR_NO_MORE_ITEMS ) { CString csMessage;
fReturnValue = (BOOL) TRUE;
RegCloseKey( hResourceTypesKey ); RegCloseKey( hClusterKey );
// Were there any non-standard subkeys in the Resource Types registry key?
if ( csNonStandardResourceTypeList.IsEmpty() == (BOOL) FALSE ) { // Non-standard subkeys were found. Ask the user about removal.
// Build and present a message of the form:
//
// The following software packages should be removed before removing
// the Microsoft Cluster Server software.
//
// <list of packages>
//
// Do you want to continue with uninstall?
CString csLastPartOfMessage; CString csMessageBoxTitle;
csLastPartOfMessage.LoadString(IDS_ERR_UNINSTALL_OTHER_SW_EXT); csNonStandardResourceTypeList += csLastPartOfMessage;
// BUGBUG - The next two statements are commented out temporarily because the localization
// changes needed for this have not been approved. Uncomment after NT 5.0.
// Also restore clusocm.rc@v2 and resource.h@v2
// (Vvasu 05-Jan-2000
// csMessageBoxTitle.LoadString(IDS_TITLE_CUSTOM_RESTYPES);
//::MessageBox( NULL,
// csNonStandardResourceTypeList,
// csMessageBoxTitle,
// MB_OK | MB_ICONINFORMATION
// );
ClRtlLogPrint( "CheckForClusterResourceTypes detected custom resources.\n" ); } // Were non-standard resource typed detected?
else { ClRtlLogPrint( "CheckForCustomResourceTypes did not detect any custom resource types,\n" ); } } // Was there an error enumerating the ResourceTypes key?
else { ClRtlLogPrint( "CheckForCustomResourceTypes was unable to enumerate the resource types,\n" ); ClRtlLogPrint( "implying that no custom resource types exist, so the uninstall will continue.\n" ); ClRtlLogPrint( "The error code is %1!d!.\n", lReturnValue );
// An error occured while enumerating the ResourceTypes sub-keys.
RegCloseKey( hResourceTypesKey ); RegCloseKey( hClusterKey );
// The uninstall operation should continue because the installation
// is apparently defective.
fReturnValue = (BOOL) TRUE; } // Was there an error enumerating the ResourceTypes key?
} else { // The initial call to RegEnumKeyEx failed.
// Issue an error message and exit.
RegCloseKey( hClusterKey );
ClRtlLogPrint( "CheckForCustomResourceTypes was unable to enumerate the resource types,\n" ); ClRtlLogPrint( "implying that no custom resource types exist, so the uninstall will continue.\n" ); ClRtlLogPrint( "The error code is %1!d!.\n", lReturnValue );
// A return value of TRUE will allow the uninstall operation to
// continue.
fReturnValue = (BOOL) TRUE;
} // Did RegEnumKeyEx open the ResourceTypes key?
} // Was the ResourceTypes sub key opened?
else { // The ResourceTypes sub key could not be opened.
// Issue an error message and exit.
RegCloseKey( hClusterKey );
ClRtlLogPrint( "CheckForCustomResourceTypes was unable to open the Cluster\\ResourceTypes key,\n" ); ClRtlLogPrint( "implying that no custom resource types exist, so the uninstall will continue.\n" );
// A return value of TRUE will allow the uninstall operation to
// continue.
fReturnValue = (BOOL) TRUE; } // Was the ResourceTypes sub key opened?
} // cluster hive opened?
else { // The Cluster registry key could not be opened, even after possibly
// attempting to load the cluster hive.
ClRtlLogPrint( "CheckForCustomResourceTypes was unable to open the Cluster key,\n" ); ClRtlLogPrint( "implying that no custom resource types exist, so the uninstall will continue.\n" ); ClRtlLogPrint( "The error code is %1!d!.\n", lReturnValue );
// A return value of TRUE will allow the uninstall operation to
// continue.
fReturnValue = (BOOL) TRUE; } // Second test whether the Cluster registry key was opened successfully.
if ( fClusterHiveLoadedByThisFunction == (BOOL) TRUE ) { UnloadClusDB(); }
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// UnloadClusDB
//
// Routine Description:
// This function unloads the Cluster hive.
//
// Arguments:
// None
//
// Return Value:
// None
//
// Note:
// This function was originally in newsetup\utils.cpp.
//
//--
/////////////////////////////////////////////////////////////////////////////
VOID CClusocmApp::UnloadClusDB( VOID ){ DWORD Status; BOOLEAN WasEnabled;
Status = RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, TRUE, FALSE, &WasEnabled);
if ( Status == ERROR_SUCCESS ) { LONG lReturnValue;
CString csClusterRegKey;
csClusterRegKey = CLUSREG_KEYNAME_CLUSTER;
lReturnValue = RegUnLoadKeyW(HKEY_LOCAL_MACHINE, csClusterRegKey );
RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, WasEnabled, FALSE, &WasEnabled); }}
PWCHAR WellKnownResourceTypes[] = { CLUS_RESTYPE_NAME_GENAPP, CLUS_RESTYPE_NAME_GENSVC, CLUS_RESTYPE_NAME_FTSET, CLUS_RESTYPE_NAME_PHYS_DISK, CLUS_RESTYPE_NAME_IPADDR, CLUS_RESTYPE_NAME_NETNAME, CLUS_RESTYPE_NAME_FILESHR, CLUS_RESTYPE_NAME_PRTSPLR, CLUS_RESTYPE_NAME_TIMESVC, CLUS_RESTYPE_NAME_LKQUORUM, CLUS_RESTYPE_NAME_DHCP, CLUS_RESTYPE_NAME_MSMQ, CLUS_RESTYPE_NAME_NEW_MSMQ, CLUS_RESTYPE_NAME_MSDTC, CLUS_RESTYPE_NAME_WINS, CLUS_RESTYPE_NAME_IIS4, CLUS_RESTYPE_NAME_SMTP, CLUS_RESTYPE_NAME_NNTP, (PWCHAR) UNICODE_NULL};
/////////////////////////////////////////////////////////////////////////////
//++
//
// TryToRecognizeResourceType
//
// Routine Description:
// This function determines whether the resource type whose name is in
// parameter "keyname" is recognized as a standard resource type as defined
// in clusudef.h.
//
// This function builds a list of unrecognized reaource types in the CString
// referenced by parameter "str".
//
// Arguments:
// str - a reference to a CString in which to build a list of unrecognized
// resource types.
// keyname - points to a string that contains the resource type name.
//
// Return Value:
// None
//
// Note:
// This function was excerpted verbatim from newsetup\utils.cpp.
//
//--
/////////////////////////////////////////////////////////////////////////////
VOID CClusocmApp::TryToRecognizeResourceType( CString& str, LPTSTR keyname ){ PWCHAR * ppName = WellKnownResourceTypes;
while ( *ppName != (PWCHAR)UNICODE_NULL ) { if ( lstrcmp( keyname, *ppName) == 0 ) return; ++ppName; }
if ( !str.IsEmpty() ) str += L", "; else { str.LoadString(IDS_ERR_UNINSTALL_OTHER_SW);
str += _T('\n'); } str += keyname;}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetServiceBinaryPath
//
// Routine Description:
// This function retrieves the fully qualified path to a Service
// from the Service Control Manager.
//
// Arguments:
// lpwszServiceName - points to a wide character string containing the service name
// lptszBinaryPathName - points to a string to receive the fully qualified
// path to the Cluster Service.
//
// Return Value:
// TRUE - The path to the Cluster Service was obtained successfully.
// FALSE - The path to the Cluster Service was not obtained.
//
// Note:
// Calling this function makes sense IFF the Cluster Service is registered
// with the Service Control Manager. Call IsClusterServiceRegistered() to
// ascertain that BEFORE calling GetServiceBinaryPath.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::GetServiceBinaryPath( IN LPWSTR lpwszServiceName, OUT LPTSTR lptszBinaryPathName ){ BOOL fReturnValue;
DWORD dwErrorCode = (DWORD) ERROR_SUCCESS;
if ( lpwszServiceName != (LPWSTR) NULL ) { SC_HANDLE hscServiceMgr; SC_HANDLE hscService;
// Connect to the Service Control Manager and open the specified service
// control manager database.
hscServiceMgr = OpenSCManager( NULL, NULL, GENERIC_READ | GENERIC_WRITE );
// Was the service control manager database opened successfully?
if ( hscServiceMgr != NULL ) { // The service control manager database is open.
// Open a handle to the Service.
hscService = OpenService( hscServiceMgr, lpwszServiceName, GENERIC_READ );
// Was the handle to the service opened?
if ( hscService != NULL ) { // A valid handle to the Service was obtained.
DWORD dwBufferSize;
// Note that the size of the buffer required to get the service configuration
// information was determined empherically to be 240 bytes.
LPQUERY_SERVICE_CONFIG lpServiceConfig;
dwBufferSize = (DWORD) sizeof( QUERY_SERVICE_CONFIG ) + 256; // The delta from the
// size of the structure
// was chosen arbitrarily.
// Attempt to allocate the buffer.
lpServiceConfig = (LPQUERY_SERVICE_CONFIG) LocalAlloc( LMEM_ZEROINIT, dwBufferSize );
// Was the bufer allocated successfully?
if ( lpServiceConfig != (LPQUERY_SERVICE_CONFIG) NULL ) { // The following call to QueryServiceConfig should return something
// usefull. If it fails it is probably because the guess at the size
// of the buffer is too small.
fReturnValue = QueryServiceConfig( hscService, lpServiceConfig, dwBufferSize, (LPDWORD) &dwBufferSize );
// Was the Service configuration info obtained?
if ( fReturnValue == (BOOL) TRUE ) { // Update the output parameter.
_tcscpy( lptszBinaryPathName, lpServiceConfig->lpBinaryPathName );
// lptszBinaryPathName includes the service name. Strip that off.
LPTSTR ptszTemp;
ptszTemp = _tcsrchr( (const wchar_t *) lptszBinaryPathName, (int) _T('\\') );
*ptszTemp = _T('\0');
ClRtlLogPrint( "In GetServiceBinaryPath the first call to QueryServiceConfig succeeded.\n" ); } else { // Was the buffer too small?
dwErrorCode = GetLastError();
if ( dwErrorCode == (DWORD) ERROR_INSUFFICIENT_BUFFER ) { ClRtlLogPrint( "GetServiceBinaryPath is enlarging the buffer for the QUERY_SERVICE_CONFIG structure.\n" );
// Increase the size of the buffer.
HLOCAL hLocalBlock;
// As per RodGa LocalReAlloc is not always reliable. Here that functionality
// is implemented by freeing the buffer for the QUERY_SERVICE_CONFIG struct
// and allocating a nre block using LocalFree and LocalAlloc.
hLocalBlock = LocalFree( lpServiceConfig );
if ( hLocalBlock == (HLOCAL) NULL ) { // The previously allocated block has been released. Now,
// allocate a block of the proper size.
lpServiceConfig = (LPQUERY_SERVICE_CONFIG) LocalAlloc( LMEM_ZEROINIT, (UINT) dwBufferSize );
// Was the larger buffer allocated successfully?
if ( lpServiceConfig != (LPQUERY_SERVICE_CONFIG) NULL ) { // The following call to QueryServiceConfig should return something
// usefull. If it fails it is not because the buffer is too small.
fReturnValue = QueryServiceConfig( hscService, lpServiceConfig, dwBufferSize, (LPDWORD) &dwBufferSize );
// Was the Service configuration info obtained this time.
if ( fReturnValue == (BOOL) TRUE ) { // Update the output parameter.
_tcscpy( lptszBinaryPathName, lpServiceConfig->lpBinaryPathName );
// lptszBinaryPathName includes the service name. Strip that off.
LPTSTR ptszTemp;
ptszTemp = _tcsrchr( (const wchar_t *) lptszBinaryPathName, (int) _T('\\') );
*ptszTemp = _T('\0');
ClRtlLogPrint( "In GetServiceBinaryPath the second call to QueryServiceConfig succeeded.\n" ); } else { // The Service configuration info was not obtained.
dwErrorCode = GetLastError();
ClRtlLogPrint( "In GetServiceBinaryPath the second call to QueryServiceConfig failed\n" ); ClRtlLogPrint( "with error code 0x%1!x!,\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } // second call to QueryServiceConfig succeeded?
} else { // The attempt to enlarge the buffer failed.
dwErrorCode = GetLastError();
ClRtlLogPrint( "GetServiceBinaryPath was unable to enlarge the buffer for the QUERY_SERVICE_CONFIG structure.\n" ); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } } else { dwErrorCode = GetLastError();
ClRtlLogPrint( "In GetServiceBinaryPath the call to LocalFree failed with error code 0x%1!x!.\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } } else { // Some other error occured.
ClRtlLogPrint( "In GetServiceBinaryPath the first call to QueryServiceConfig failed\n" ); ClRtlLogPrint( "with error code 0x%1!x!.\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } // Was the buffer to small?
} // Service config info obtained from first call to QueryServiceConfig?
// Free the buffer if it was ever allocated successfully.
if ( lpServiceConfig != (LPQUERY_SERVICE_CONFIG) NULL ) { LocalFree( lpServiceConfig ); } } else { // Could not allocate the buffer.
dwErrorCode = GetLastError();
ClRtlLogPrint( "GetServiceBinaryPath could not allocate a buffer for the QUERY_SERVICE_CONFIG structure.\n" ); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } // Was the buffer allocated successfully?
// Close the handle to the Cluster Service.
CloseServiceHandle( hscService ); } else { // The Service could not be opened.
dwErrorCode = GetLastError();
ClRtlLogPrint( "GetServiceBinaryPath could not open an handle to %1!ws!.\n", lpwszServiceName ); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } // Was the Cluster Service opened?
// Close the handle to the Service Control Manager.
CloseServiceHandle( hscServiceMgr ); } else { // The Service Control Manager could not be opened.
dwErrorCode = GetLastError();
ClRtlLogPrint( "GetServiceBinaryPath could not open the Service Control Manager.\n" ); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwErrorCode );
fReturnValue = (BOOL) FALSE; } // Was the Service Control Manager opened?
} else { // The service name pointer was bogus.
ClRtlLogPrint( "The service name passed to GetServiceBinaryPath is invalid.\n" );
fReturnValue = FALSE; } // Is the service name legal?
if ( fReturnValue == (BOOL) FALSE ) { // Set the binary path invalid.
*lptszBinaryPathName = _T('\0'); } else { ClRtlLogPrint( "GetServiceBinaryPath located %1!ws! at %2!s!.\n", lpwszServiceName, lptszBinaryPathName ); }
SetLastError( dwErrorCode ); // Set the "last" error code (which may be ERROR_SUCCESS)
// because this function's caller is likely to call GetLastError().
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetDirectoryIds
//
// Routine Description:
// This function associates the user defined Directory Identifiers in the
// [DestinationDirs] section of the component INF file with particular
// directories, either the default location for NT 5 installations,
// %windir%\cluster, or the location of a previous installation.
//
// Arguments:
// fClusterServiceRegistered - TRUE indicates that Cluster service has
// previously been installed and the files should
// be updated in place.
//
// FALSE - indicates that the Cluster service
// files should be installed into the default
// location.
//
// Return Value:
// TRUE - indicates success
// FALSE - indicates error
//
// Note:
// The [DestinationDirs] section in clusocm.inf contains the following keys:
//
// ClusterFiles = 33001
// ClusterUpgradeFiles = 33002
// ClusterAdminFiles = 33003
// ClusterUninstallFiles = 33004
//
// Those directory IDs were chosen to be larger than DIRID_USER.
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::SetDirectoryIds( BOOL fClusterServiceRegistered ){ BOOL fReturnValue;
TCHAR tszClusterServiceBinaryPath[MAX_PATH];
// Are Cluster service files already present?
if ( fClusterServiceRegistered == (BOOL) TRUE ) { // Cluster service files should be upgraded in place.
// Query the path to the Cluster Service executable from the Service Control Manager.
CString csClusterService;
csClusterService = CLUSTER_SERVICE_NAME;
fReturnValue = GetServiceBinaryPath( (LPWSTR) (LPCTSTR) csClusterService, tszClusterServiceBinaryPath );
if ( fReturnValue == (BOOL) FALSE ) { DWORD dwErrorCode;
dwErrorCode = GetLastError();
ClRtlLogPrint( "In SetDirectoryIds the call to GetServiceBinaryPath failed with error code 0x%1!x!.\n", dwErrorCode ); } } else { // Cluster service files should be installed in the default location.
CString csClusterDirectory;
csClusterDirectory = CLUSTER_DIRECTORY;
if ( ExpandEnvironmentStrings( (LPCTSTR) csClusterDirectory, tszClusterServiceBinaryPath, MAX_PATH ) > 0L ) { fReturnValue = (BOOL) TRUE; } else { // Could not expand the enviornment string. The default location for the
// Cluster service could not be determined.
fReturnValue = (BOOL) FALSE;
DWORD dwErrorCode;
dwErrorCode = GetLastError();
ClRtlLogPrint( "ExpandEnvironmentString returned 0x%1!x! to SetDirectoryIds.\n", dwErrorCode ); } // Was the default location for the Cluster service determined?
} // Where should Cluster service files be installed?
// Was the location into which Cluster service files should be copied obtained?
if ( fReturnValue == (BOOL) TRUE ) { // Associate selected Directory Ids with the path in tszClusterServiceBinaryPath.
// Set the Directory Id for the ClusterFiles key in [DestinationDirs].
fReturnValue = SetupSetDirectoryId( m_SetupInitComponent.ComponentInfHandle, 33001, (PCTSTR) tszClusterServiceBinaryPath );
// Was the Directory Id for the ClusterFiles key set successfully?
if ( fReturnValue = (BOOL) TRUE ) { ClRtlLogPrint( "Directory Id 33001 was set to %1!s!.\n", tszClusterServiceBinaryPath );
// Set the Directory Id for the ClusterUpgradeFiles key in [DestinationDirs].
fReturnValue = SetupSetDirectoryId( m_SetupInitComponent.ComponentInfHandle, 33002, (PCTSTR) tszClusterServiceBinaryPath );
} // Was the Directory Id for the ClusterFiles key set successfully?
// Was the Directory Id for the ClusterUpgradeFiles key set successfully?
if ( fReturnValue = (BOOL) TRUE ) { ClRtlLogPrint( "Directory Id 33002 was set to %1!s!.\n", tszClusterServiceBinaryPath );
// Set the Directory Id for the ClusterAdminFiles key in [DestinationDirs].
fReturnValue = SetupSetDirectoryId( m_SetupInitComponent.ComponentInfHandle, 33003, (PCTSTR) tszClusterServiceBinaryPath );
} // Was the Directory Id for the ClusterUpgradeFiles key set successfully?
// Was the Directory Id for the ClusterAdminFiles key set successfully?
if ( fReturnValue = (BOOL) TRUE ) { ClRtlLogPrint( "Directory Id 33003 was set to %1!s!.\n", tszClusterServiceBinaryPath );
// Set the Directory Id for the ClusterUninstallFiles key in [DestinationDirs].
fReturnValue = SetupSetDirectoryId( m_SetupInitComponent.ComponentInfHandle, 33004, (PCTSTR) tszClusterServiceBinaryPath );
} // Was the Directory Id for the ClusterAdminFiles key set successfully?
// Was the Directory Id for the ClusterUninstallFiles key set successfully?
if ( fReturnValue = (BOOL) TRUE ) { ClRtlLogPrint( "Directory Id 33004 was set to %1!s!.\n", tszClusterServiceBinaryPath );
// Set the Directory Id for the NT4.files.root key in [DestinationDirs].
fReturnValue = SetupSetDirectoryId( m_SetupInitComponent.ComponentInfHandle, 33005, (PCTSTR) tszClusterServiceBinaryPath );
} // Was the Directory Id for the ClusterUninstallFiles key set successfully?
// Was the Directory Id for NT4.files.root key set successfully?
if ( fReturnValue = (BOOL) TRUE ) { ClRtlLogPrint( "Directory Id 33005 was set to %1!s!.\n", tszClusterServiceBinaryPath );
// Append the "private" directory to the path.
// Note, I didn't put this string in the stringtable because it is
// not localizable, and will never change.
_tcscat( tszClusterServiceBinaryPath, _T("\\private") );
// Set the Directory Id for the NT4.files.private key in [DestinationDirs].
fReturnValue = SetupSetDirectoryId( m_SetupInitComponent.ComponentInfHandle, 33006, (PCTSTR) tszClusterServiceBinaryPath );
} // Was the Directory Id for the NT4.files.root key set successfully?
// Was the Directory Id for NT4.files.private key set successfully?
if ( fReturnValue = (BOOL) TRUE ) { ClRtlLogPrint( "Directory Id 33006 was set to %1!s!.\n", tszClusterServiceBinaryPath ); } // Was the Directory Id for NT4.files.private key set successfully?
} // Was the path to the Cluster files determined?
else { ClRtlLogPrint( "SetDirectoryIds could not locate the cluster directory, so it failed.\n" ); }
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// UpgradeClusterServiceImagePath
//
// Routine Description:
// This function "upgrades" the ImagePath value in the Cluster Service registry
// key to the location queried from the Service Control Manager.
//
// Arguments:
// None
//
// Return Value:
// NO_ERROR - indicates success
// Any other value is a Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::UpgradeClusterServiceImagePath( void ){ BOOL fReturnValue;
DWORD dwReturnValue;
// Query the path to the Cluster Service from the Service Control Manager.
TCHAR tszClusterServiceBinaryPath[MAX_PATH];
CString csClusterService;
csClusterService = CLUSTER_SERVICE_NAME;
fReturnValue = GetServiceBinaryPath( (LPWSTR) (LPCTSTR) csClusterService, tszClusterServiceBinaryPath );
// Was the path to the Cluster Service obtained?
if ( fReturnValue == (BOOL) TRUE ) { // Set the ImagePath value in the Cluster Service reg key to the location
// obtained from the Service Control Manager.
LONG lReturnValue;
HKEY hClusterServiceKey;
DWORD dwType; DWORD dwSize;
// Attempt to open the Cluster Service reg key.
CString csClusterServiceRegKey;
csClusterServiceRegKey = CLUSREG_KEYNAME_CLUSSVC;
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, csClusterServiceRegKey, (DWORD) 0L, // reserved
(REGSAM) KEY_SET_VALUE, &hClusterServiceKey );
// Was the Cluster Service reg key opened?
if ( lReturnValue == (LONG) ERROR_SUCCESS ) { TCHAR tszClusterServicePath[MAX_PATH];
_tcscpy( tszClusterServicePath, tszClusterServiceBinaryPath );
_tcscat( tszClusterServicePath, _T("\\") );
// Append the name of the Cluster Service.
CString csClusterService;
csClusterService = CLUSTER_SERVICE_NAME;
csClusterService += (CString) _T(".exe");
_tcscat( tszClusterServicePath, csClusterService );
DWORD dwImagePathValueLength;
dwImagePathValueLength = (DWORD) ((_tcslen( tszClusterServicePath ) + 1) * sizeof( TCHAR ));
CString csImagePath;
csImagePath = CLUSREG_KEYNAME_IMAGE_PATH;
lReturnValue = RegSetValueEx( hClusterServiceKey, csImagePath, (DWORD) 0L, // reserved
(DWORD) REG_EXPAND_SZ, (CONST BYTE *) tszClusterServicePath, dwImagePathValueLength );
// Was the ImagePath written successfully?
if ( lReturnValue == (LONG) ERROR_SUCCESS ) { dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "UpgradeClusterServiceImagePath succeeded.\n" ); } else { dwReturnValue = GetLastError();
ClRtlLogPrint( "UpgradeClusterServiceImagePath failed with error code 0x%1!x!.\n", dwReturnValue ); } // Was the ImagePath written successfully?
// Close the Cluster Service registry key.
RegCloseKey( hClusterServiceKey ); // do we care about the return value?
} else { dwReturnValue = GetLastError();
ClRtlLogPrint( "UpgradeClusterServiceImagePath failed with error code 0x%1!x!.\n", dwReturnValue ); } // Was the Cluster Service reg key opened?
} // Was the path to the Cluster Service obtained?
else { // Indicate error.
dwReturnValue = GetLastError();
ClRtlLogPrint( "UpgradeClusterServiceImagePath failed with error code 0x%1!x!.\n", dwReturnValue ); }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcQueueFileOps
//
// Routine Description:
// This function processes the OC_QUEUE_FILE_OPS "messages" from the
// Optional Components Manager.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// hSetupFileQueue - a HSPFILEQ (typedefed in setupapi.h to PVOID)
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcQueueFileOps( IN LPCTSTR ptszSubComponentId, IN OUT HSPFILEQ hSetupFileQueue ){ DWORD dwReturnValue = NO_ERROR;
// Is the handle to the component INF file valid?
if ( (m_SetupInitComponent.ComponentInfHandle != (HINF) INVALID_HANDLE_VALUE) && (m_SetupInitComponent.ComponentInfHandle != (HINF) NULL) ) { // Is this UNATTENDED or ATTENDED?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) != (DWORDLONG) 0L ) { // This is UNATTENDED.
ClRtlLogPrint( "In OnOcQueueFileOps this is an UNATTENDED operation.\n" );
dwReturnValue = OnOcQueueFileOpsUnattended( (LPCTSTR) ptszSubComponentId, hSetupFileQueue ); } else { // This is ATTENDED.
ClRtlLogPrint( "In OnOcQueueFileOps this is an ATTENDED operation.\n" );
dwReturnValue = OnOcQueueFileOpsAttended( (LPCTSTR) ptszSubComponentId, hSetupFileQueue ); } // Is this UNATTENDED or ATTENDED?
} else { dwReturnValue = ERROR_FILE_NOT_FOUND;
ClRtlLogPrint( "In OnOcQueueFileOps the handle to the component INF file is bad.\n" ); } // Is the handle to the component INF file valid?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcQueueFileOpsUnattended
//
// Routine Description:
// This function processes the OC_QUEUE_FILE_OPS "messages" from the
// Optional Components Manager during UNATTENDED operations.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// hSetupFileQueue - a HSPFILEQ (typedefed in setupapi.h to PVOID)
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
// Note:
// OC Manager sends OC_QUEUE_FILE_OPS to the component DLL when the Components
// List wizard page is dismissed.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcQueueFileOpsUnattended( IN LPCTSTR ptszSubComponentId, IN OUT HSPFILEQ hSetupFileQueue ){ DWORD dwReturnValue;
// Is this an UPGRADE?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) != (DWORDLONG) 0L ) { // This is an unattended UPGRADE.
dwReturnValue = QueueFileOpsUnattendedUpgrade( (LPCTSTR) ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueFileOpsUnattendedUpgrade returned 0x%1!x!.\n", dwReturnValue ); } else { HINF hAnswerFile; // WARNING: NEVER close this handle because clusocm.dll
// did not open it.
// Get a handle to the answer file. WARNING: NEVER close this handle because clusocm.dll
// did not open it.
hAnswerFile = m_SetupInitComponent.HelperRoutines.GetInfHandle( INFINDEX_UNATTENDED, m_SetupInitComponent.HelperRoutines.OcManagerContext );
if ( (hAnswerFile != (HINF) NULL) && (hAnswerFile != (HINF) INVALID_HANDLE_VALUE) ) { ClRtlLogPrint( "In OnOcQueueFileOpsUnattended this is a CLEAN install.\n" );
// Is Cluster service selected? It is probably overkill to check, but
// it is safer to check than to be sorry later.
BOOL fCurrentSelectionState; BOOL fOriginalSelectionState;
fCurrentSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) ptszSubComponentId, (UINT) OCSELSTATETYPE_CURRENT );
fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
if ( fCurrentSelectionState == (BOOL) TRUE ) { // Was there a selection state transition?
if ( fCurrentSelectionState != fOriginalSelectionState ) { ClRtlLogPrint( "A selection state transition was detected.\n" );
// A selection state transition has occured. Install files.
dwReturnValue = QueueInstallFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueInstallFileOperations returned 0x%1!x! to OnOcQueueFileOpsAttended,\n", dwReturnValue ); } else { ClRtlLogPrint( "NO selection state transition was detected.\n" );
// The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR; } // Was there a selection state transition?
} else { // Has there been a selection state transition ?
ClRtlLogPrint( "In OnOcQueueFileOpsUnattended Cluster service is not selected for installation.\n" );
if ( fCurrentSelectionState != fOriginalSelectionState ) { // Remove files.
dwReturnValue = QueueRemoveFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueRemoveFileOperations returned 0x%1!x! to OnOcQueueFileOpsUnattended.\n", dwReturnValue ); } else { ClRtlLogPrint( "In OnOcQueueFileOpsUnattended NO selection state transition was detected.\n" );
// The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR; } // Was there a selection state transition ?
} } else { // A handle to the answer file could not be obtained. Treat it as a UPGRADE.
ClRtlLogPrint( "InOnOcQueueFileOpsUnattended the handle to the answer file could not be obtained.\n" );
dwReturnValue = QueueFileOpsUnattendedUpgrade( (LPCTSTR) ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueFileOpsUnattendedUpgrade returned 0x%1!x!.\n", dwReturnValue ); } }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// QueueFileOpsUnattendedUpgrade
//
// Routine Description:
// This function queues the file operations appropriate for an unattended
// upgrade operation.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// hSetupFileQueue - a HSPFILEQ (typedefed in setupapi.h to PVOID)
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::QueueFileOpsUnattendedUpgrade( IN LPCTSTR ptszSubComponentId, IN OUT HSPFILEQ hSetupFileQueue ){ DWORD dwReturnValue; eClusterInstallState eState;
// Has Cluster service previously been installed?
// GetClusterInstallationState reports on the state of the registry value
// that records the state of the Cluster service installation on NT 5 machines.
// IsClusterServiceRegistered indicates whether the Cluster service is registered on
// BOTH NT 4 and NT 5 machines. Both tests are required: IsClusterServiceRegistered for
// upgrading NT 4 machines, GetClusterInstallationState for NT 5 machines.
BOOL fClusteringServicePreviouslyInstalled;
ClRtlGetClusterInstallState( NULL, &eState ); if ( ( eState != eClusterInstallStateUnknown ) || ( IsClusterServiceRegistered() == (BOOL) TRUE ) ) { fClusteringServicePreviouslyInstalled = (BOOL) TRUE; } else { fClusteringServicePreviouslyInstalled = (BOOL) FALSE; }
if ( fClusteringServicePreviouslyInstalled == (BOOL) TRUE ) { // Upgrade the ClusteringService files.
dwReturnValue = QueueInstallFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueInstallFileOperations returned 0x%1!x! to QueueFileOpsUnattendedUpgrade.\n", dwReturnValue ); } // Has Cluster service previously been installed?
else { // Since Cluster service has not been previously installed there is
// nothing to do.
ClRtlLogPrint( "In QueueFileOpsUnattendedUpgrade Cluster service has never been installed.\n" );
dwReturnValue = (DWORD) NO_ERROR; } // Has Cluster service previously been installed?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcQueueFileOpsAttended
//
// Routine Description:
// This function processes the OC_QUEUE_FILE_OPS "messages" from the
// Optional Components Manager during ATTENDED operations.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
// hSetupFileQueue - a HSPFILEQ (typedefed in setupapi.h to PVOID)
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcQueueFileOpsAttended( IN LPCTSTR ptszSubComponentId, IN OUT HSPFILEQ hSetupFileQueue ){ DWORD dwReturnValue; eClusterInstallState eState;
// Is Cluster service selected?
BOOL fCurrentSelectionState; BOOL fOriginalSelectionState;
fCurrentSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) ptszSubComponentId, (UINT) OCSELSTATETYPE_CURRENT );
if ( fCurrentSelectionState == (BOOL) TRUE ) { // The subcomponent is selected. Is this a fresh install ?
ClRtlLogPrint( "In OnOcQueueFileOpsAttended the current selection state is TRUE.\n" );
if ( ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) == (DWORDLONG) 0L ) && ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) == (DWORDLONG) 0L ) ) { // SETUPOP_STANDALONE flag clear means running under GUI mode setup.
// SETUPOP_NTUPGRADE flag clear means not performing an upgrade.
// Both flags clear means a fresh install. Do not check for a selection
// state transition.
ClRtlLogPrint( "In OnOcQueueFileOpsAttended this is a CLEAN install.\n" );
dwReturnValue = QueueInstallFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueInstallFileOperations returned 0x%1!x! to OnOcQueueFileOpsAttended.\n", dwReturnValue ); } else { // This is either an upgrade or OC Manager is running stand-alone.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcQueueFileOpsAttended this is an UPGRADE.\n" );
// This is an upgrade, if Cluster Server has previously been
// been installed then queue the file copies.
// Has Cluster service perviously been installed? Ask the Service Control
// Manager whether the Cluster Service is registered.
// GetClusterInstallationState reports on the state of the registry value
// that records the state of the Cluster service installation on NT 5 machines.
// IsClusterServiceRegistered indicates whether the Cluster service is registered on
// BOTH NT 4 and NT 5 machines. Both tests are required: IsClusterServiceRegistered for
// upgrading NT 4 machines, GetClusterInstallationState for NT 5 machines.
BOOL fClusterServiceRegistered;
fClusterServiceRegistered = IsClusterServiceRegistered();
BOOL fClusterServicePreviouslyInstalled;
ClRtlGetClusterInstallState( NULL, &eState ); if ( ( eState != eClusterInstallStateUnknown ) || ( fClusterServiceRegistered == (BOOL) TRUE ) ) { fClusterServicePreviouslyInstalled = (BOOL) TRUE; } else { fClusterServicePreviouslyInstalled = (BOOL) FALSE; }
if ( fClusterServicePreviouslyInstalled == (BOOL) TRUE ) { // Since this is an UPGRADE and Cluster service has been
// installed there is no need to test for a selection state transition.
dwReturnValue = QueueInstallFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueInstallFileOperations returned 0x%1!x! to OnOcQueueFileOpsAttended.\n", dwReturnValue ); } else { ClRtlLogPrint( "In OnOcQueueFileOps attempted an UPGRADE but Cluster service has never been installed.\n" );
dwReturnValue = (DWORD) NO_ERROR; } // Was Cluster service perviously installed?
} else { ClRtlLogPrint( "In OnOcQueueFileOpsAttended this is STANDALONE.\n" );
// This is not an upgrade. That means Add/Remove Programs must be
// running. It is necessary to test for a selection state transition.
fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
// Was there a selection state transition?
if ( fCurrentSelectionState != fOriginalSelectionState ) { ClRtlLogPrint( "A selection state transition was detected.\n" );
// A selection state transition has occured. Install files.
dwReturnValue = QueueInstallFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueInstallFileOperations returned 0x%1!x! to OnOcQueueFileOpsAttended,\n", dwReturnValue ); } else { ClRtlLogPrint( "NO selection state transition was detected.\n" );
// The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR; } // Was there a selection state transition?
} // Is this an UPGRADE?
} // Is this a clean install?
} // Is Cluster service currently selected ?
else { ClRtlLogPrint( "In OnOcQueueFileOpsAttended the current selection state is FALSE.\n" );
// Cluster service is not selected. Is OC Manager running stand-alone ?
// If not, i.e. if GUI mode setup is running, there is nothing to do.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) != (DWORDLONG) 0L ) { ClRtlLogPrint( "In OnOcQueueFileOpsAttended this is STANDALONE.\n" );
// SETUPOP_STANDALONE set implies GUI mode setup is not running. If
// there was a selection state change (to unselected) then remove files.
fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
// Has there been a selection state transition ?
if ( fCurrentSelectionState != fOriginalSelectionState ) { // Remove files.
dwReturnValue = QueueRemoveFileOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId, hSetupFileQueue );
ClRtlLogPrint( "QueueRemoveFileOperations returned 0x%1!x! to OnOcQueueFileOpsAttended.\n", dwReturnValue ); } else { ClRtlLogPrint( "NO selection state transition was detected.\n" );
// The selection state has not been changed. Perform no action.
dwReturnValue = (DWORD) NO_ERROR; } // Was there a selection state transition ?
} else { // GUI mode setup is running and Cluster service is not selected.
// There is nothing to do.
dwReturnValue = (DWORD) NO_ERROR; } // Is GUI mode setup running ?
} // Is Cluster service currently selected ?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CompleteUninstallingClusteringService
//
// Routine Description:
// This function completes uninstalling ClusteringService by queuing the
// registry operations to delete the Cluster service registry keys,
// cleaning up the Start Menu, removing the Network Provider, and requesting
// a reboot.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::CompleteUninstallingClusteringService( IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue; eClusterInstallState ecisInstallState; BOOL bRebootRequired = FALSE;
// Update the "progress text"
CString csProgressText;
csProgressText.LoadString( IDS_REMOVING_CLUS_SERVICE );
m_SetupInitComponent.HelperRoutines.SetProgressText( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) csProgressText );
// Request that the system reboot only if clusdisk has been started.
// We can deduce this by looking at the cluster installation state.
// If the state is not eClusterInstallStateFilesCopied then it means that
// ClusCfg may have run successfully and therefore, clusdisk may have been started.
// We must call ClRtlGetClusterInstallState before calling UninstallRegistryOperations.
// Otherwise it will always return eClusterInstallStateUnknown!
// If ClRtlGetClusterInstallState fails, reboot anyway.
// If it succeeds, reboot only if ClusCfg has completed successfully.
if ( ( ClRtlGetClusterInstallState( NULL, &ecisInstallState ) != ERROR_SUCCESS ) || ( ecisInstallState != eClusterInstallStateFilesCopied ) ) { bRebootRequired = TRUE; }
// Delete registry entries. Queue the base registry operations.
dwReturnValue = UninstallRegistryOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId );
ClRtlLogPrint( "UninstallRegistryOperations returned 0x%1!x! to CompleteUninstallingClusteringService.\n", dwReturnValue );
//
// Remove the cluster item from the start menu
//
CString csGroupName; CString csItemName;
csGroupName.LoadString( IDS_START_GROUP_NAME ); csItemName.LoadString( IDS_START_ITEM_NAME );
DeleteLinkFile( CSIDL_COMMON_PROGRAMS, (LPCWSTR) csGroupName, (LPCWSTR) csItemName, (BOOL) FALSE );
// Delete the cluster directory. BUGBUG
//
// Remove the cluster network provider
//
dwReturnValue = RemoveNetworkProvider();
if ( bRebootRequired ) { BOOL fRebootRequestStatus;
// In the following call the value passed in the second parameter
// was chosen arbitrarily. Ocmanage.h implies that the parameter is not used.
fRebootRequestStatus = m_SetupInitComponent.HelperRoutines.SetReboot( m_SetupInitComponent.HelperRoutines.OcManagerContext, (BOOL) TRUE ); }
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OpenClusterRegistryRoot
//
// Routine Description:
// This function retuns a handle to the root key of the Cluster hive.
// It will load the hive if necessary.
//
// Arguments:
// none
//
//
// Return Value:
// If success, handle to the cluster root key. Otherwise, NULL
//
//--
/////////////////////////////////////////////////////////////////////////////
HKEY CClusocmApp::OpenClusterRegistryRoot( void ){ BOOL fReturnValue;
HKEY hClusterKey = NULL; LONG lReturnValue;
// Attempt to open the Cluster Registry key.
CString csClusterRegKey;
csClusterRegKey = CLUSREG_KEYNAME_CLUSTER;
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, csClusterRegKey, 0, KEY_READ, &hClusterKey);
if ( lReturnValue != ERROR_SUCCESS ) { ClRtlLogPrint( "In OpenClusterRegistryRoot, the first attempt to open the Cluster key failed.\n" );
// The Cluster hive is not currently loaded. This condition means that
// the cluster service has not been started. Attempt to load the Cluster
// hive so that it can be read.
// First, locate the Cluster hive file. It should be in the location
// specified for the ClusterFiles entry in the [DestinationDirs] section
// of clusocm.inf.
CString csClusterHiveFilePath;
fReturnValue = LocateClusterHiveFile( (CString &) csClusterHiveFilePath );
ClRtlLogPrint( "LocateClusterHiveFile returned 0x%1!x! to OpenClusterRegistryRoot.\n", fReturnValue );
// Was the Cluster hive file located?
if ( fReturnValue == (BOOL) TRUE ) { // The Cluster hive file was located.
// Attempt to load the cluster hive.
BOOLEAN OriginalState;
// I'm not sure what the following function does, but the prototype is
// in sdk\inc\ntrtl.h. Look in stdafx.h for the inclusion of ntrtl.h. I
// replicated the logic that was used in newsetup.h to make it work.
lReturnValue = RtlAdjustPrivilege( SE_RESTORE_PRIVILEGE, TRUE, FALSE, &OriginalState );
if ( lReturnValue == ERROR_SUCCESS ) { // Attempt to Load the Cluster Hive.
lReturnValue = RegLoadKey( HKEY_LOCAL_MACHINE, csClusterRegKey, csClusterHiveFilePath );
if ( lReturnValue == ERROR_SUCCESS ) {
// Now that the Cluster hive has been loaded, attempt to open the
// Cluster registry key.
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, csClusterRegKey, 0, KEY_READ, &hClusterKey );
// lReturnValue will be tested by the next BLOCK of code.
}
// Undo whatever the preceding call to RtlAdjustPrivilege() did.
RtlAdjustPrivilege( SE_RESTORE_PRIVILEGE, OriginalState, FALSE, &OriginalState );
if ( lReturnValue != ERROR_SUCCESS ) { // Set the error code.
SetLastError( lReturnValue ); }
} else { // The initial call to RtlAdjustPrivilege FAILED.
SetLastError( lReturnValue );
// A return value of TRUE will allow the uninstall operation to
// continue. Since lReturnValue is NOT ERROR_SUCCESS no additional
// processing will be performed by this function.
} // Did RtlAdjustPrivilege succeed?
} else { // The Cluster hive file was not located. Set last error and return
// a null handle
ClRtlLogPrint( "OpenClusterRegistryRoot couldn't locate the hive files\n" );
SetLastError( ERROR_FILE_NOT_FOUND );
} // Was the cluster hive file located?
} // Was the Cluster registry key opened successfully?
return ( hClusterKey );} // OpenClusterRegistryRoot
/////////////////////////////////////////////////////////////////////////////
//++
//
// FindNodeNumber
//
// Routine Description:
// This function looks through the cluster's Node key and returns a pointer to
// the node number string of the current node.
//
// Arguments:
// ClusterKey - handle to cluster root key
//
// NodeNumberString - pointer to location that receives the node number
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
PWSTR CClusocmApp::FindNodeNumber( HKEY ClusterKey ){ WCHAR nodeName[ MAX_COMPUTERNAME_LENGTH + 1 ]; DWORD nodeNameLength = sizeof( nodeName ); WCHAR registryNodeName[ MAX_COMPUTERNAME_LENGTH + 1 ]; DWORD registryNodeNameLength; HKEY nodesKey = NULL; HKEY nodesEnumKey = NULL; DWORD status; PWSTR nodeNumberString; DWORD nodeNumberStringLength; DWORD index = 0; DWORD dataType;
//
// allocate space for the node number string
//
nodeNumberString = (PWSTR)LocalAlloc( LMEM_FIXED | LMEM_ZEROINIT, ( CS_MAX_NODE_ID_LENGTH + 1 ) * sizeof( WCHAR )); if ( nodeNumberString == NULL ) { status = GetLastError(); ClRtlLogPrint( "FindNodeNumber couldn't allocate node number buffer: %1!u!\n", status ); return NULL; }
//
// get our node name and a handle to the root key in the cluster hive
//
if ( !GetComputerName( nodeName, &nodeNameLength )) { status = GetLastError(); ClRtlLogPrint( "FindNodeNumber failed to get computer name: %1!u!\n", status );
goto error_exit; }
status = RegOpenKeyEx( ClusterKey, CLUSREG_KEYNAME_NODES, 0, KEY_READ, &nodesKey );
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "FindNodeName failed to open Nodes key: %1!u!\n", status ); goto error_exit; }
//
// enum the entries under the Nodes key
//
do { nodeNumberStringLength = sizeof( nodeNumberString ); status = RegEnumKeyEx( nodesKey, index, nodeNumberString, &nodeNumberStringLength, NULL, NULL, NULL, NULL );
if ( status == ERROR_NO_MORE_ITEMS ) { ClRtlLogPrint( "FindNodeNumber finished enum'ing the Nodes key\n" ); break; } else if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "FindNodeNumber failed to enum Nodes key: %1!u!\n", status ); goto error_exit; }
//
// open this key and get the Name value
//
status = RegOpenKeyEx( nodesKey, nodeNumberString, 0, KEY_READ, &nodesEnumKey );
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "FindNodeNumber failed to open Nodes key %1!ws!: %2!u!\n", nodeNumberString, status ); goto error_exit;
}
registryNodeNameLength = sizeof( registryNodeName ); status = RegQueryValueEx( nodesEnumKey, CLUSREG_NAME_NODE_NAME, NULL, &dataType, (LPBYTE)registryNodeName, ®istryNodeNameLength );
RegCloseKey( nodesEnumKey ); nodesEnumKey = NULL;
if ( status != ERROR_SUCCESS || dataType != REG_SZ ) { ClRtlLogPrint( "FindNodeNumber failed to get NodeName value: " "status %1!u!, data type %2!u!\n", status, dataType ); goto error_exit;
}
//
// finally, we get to see if this is our node
//
if ( lstrcmpiW( nodeName, registryNodeName ) == 0 ) { break; }
++index; } while ( TRUE );
error_exit: if ( nodesKey != NULL ) { RegCloseKey( nodesKey ); }
if ( nodesEnumKey != NULL ) { RegCloseKey( nodesEnumKey ); }
if ( status != ERROR_SUCCESS || lstrlenW( nodeNumberString ) == 0 ) { LocalFree( nodeNumberString ); nodeNumberString = NULL; }
return nodeNumberString;} // FindNodeNumber
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetConnectionName
//
// Routine Description:
// This function finds the matching connection object based on the IP address
// of the network interface. NOTE that the return value is also pointed to in
// the Adapter Info of the Adapter enum struct. This return value must not be
// freed with LocalFree.
//
// Arguments:
// NetInterfacesKey - handle to key of network interface
//
// AdapterEnum - pointer to struct with adapter/IP interface info
//
// Return Value:
// If successful, pointer to connectoid name. Otherwise, NULL with Win32
// error available from GetLastError().
//
//--
/////////////////////////////////////////////////////////////////////////////
PWSTR CClusocmApp::GetConnectionName( HKEY NetInterfacesGuidKey, PCLRTL_NET_ADAPTER_ENUM AdapterEnum ){ WCHAR ipAddress[ 16 ]; DWORD ipAddressLength = sizeof( ipAddress ); DWORD status; PCLRTL_NET_ADAPTER_INFO adapterInfo; PCLRTL_NET_INTERFACE_INFO interfaceInfo; PWSTR connectoidName = NULL; DWORD dataType;
//
// query for the netIf's IP address
//
status = RegQueryValueEx( NetInterfacesGuidKey, CLUSREG_NAME_NETIFACE_ADDRESS, NULL, &dataType, (LPBYTE)ipAddress, &ipAddressLength );
if ( status != ERROR_SUCCESS || dataType != REG_SZ ) { ClRtlLogPrint( "GetConnectionName failed to get Address value: " "status %1!u!, data type %2!u!\n", status, dataType );
SetLastError( ERROR_INVALID_DATA ); goto error_exit; }
adapterInfo = ClRtlFindNetAdapterByInterfaceAddress( AdapterEnum, ipAddress, &interfaceInfo ); if ( adapterInfo != NULL ) { connectoidName = adapterInfo->ConnectoidName; }
error_exit: return connectoidName;} // GetConnectionName
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetTCPAdapterInfo
//
// Routine Description:
// This function opens a handle to the service controller and tries to
// start the DHCP service. If successful, then TCP is queried for its
// NIC and IP interface info.
//
// Arguments:
// none
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
PCLRTL_NET_ADAPTER_ENUM CClusocmApp::GetTCPAdapterInfo( void ){ SC_HANDLE schSCManager; SC_HANDLE serviceHandle; PCLRTL_NET_ADAPTER_ENUM adapterEnum = NULL; BOOL success; DWORD retryCount; DWORD status;
schSCManager = OpenSCManager(NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_CONNECT); // access required
if ( schSCManager ) {
//
// start DHCP for nodes that are using it. it will cause TCP to start
// as well. For statically configured nodes, starting DHCP causes no
// harm.
//
serviceHandle = OpenService(schSCManager, L"DHCP", SERVICE_START );
if ( serviceHandle ) { success = StartService( serviceHandle, 0, NULL );
if ( !success ) { status = GetLastError(); if ( status == ERROR_SERVICE_ALREADY_RUNNING ) { success = TRUE; } }
if ( success ) {
//
// wait while TCP gets bound to all its adapters and discovers
// its IP interfaces.
//
retryCount = 3; do { Sleep( 2000 ); adapterEnum = ClRtlEnumNetAdapters();
if (adapterEnum != NULL) { break; } } while ( --retryCount != 0 );
if (adapterEnum == NULL) { status = GetLastError(); ClRtlLogPrint( "Failed to obtain local system network config. " "status %1!u! retryCount %2!u!\n", status, retryCount); } } else { ClRtlLogPrint( "StartService returned %1!u! to StartTCP\n", status); } CloseServiceHandle( serviceHandle ); } else { status = GetLastError(); ClRtlLogPrint( "OpenService returned %1!u! to StartTCP\n", status); }
CloseServiceHandle( schSCManager ); } else { status = GetLastError(); ClRtlLogPrint("OpenSCManager returned %1!u! to StartTCP\n", status); }
return adapterEnum;}
/////////////////////////////////////////////////////////////////////////////
//++
//
// RenameConnectionObjects
//
// Routine Description:
// This function walks through the node's network interfaces and changes,
// if necessary, their associated connection objects.
//
// Arguments:
// none
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::RenameConnectionObjects( void ){ HKEY clusterKey; HKEY netInterfacesKey = NULL; HKEY netInterfacesGuidKey = NULL; HKEY networkGuidKey = NULL; HKEY networksKey = NULL; DWORD status; PCLRTL_NET_ADAPTER_ENUM adapterEnum = NULL; PCLRTL_NET_ADAPTER_INFO adapterInfo = NULL; PCLRTL_NET_INTERFACE_INFO adapterIfInfo = NULL; DWORD hiddenAdapterCount = 0; PWSTR ourNodeNumber = NULL; DWORD index = 0; WCHAR netIfGuidString[ CS_NETINTERFACE_ID_LENGTH + 1 ]; DWORD netIfGuidStringLength; WCHAR networkGuidString[ CS_NETWORK_ID_LENGTH + 1 ]; DWORD networkGuidStringLength; WCHAR netIfNodeNumber[ CS_MAX_NODE_ID_LENGTH + 1 ]; DWORD netIfNodeNumberLength; DWORD dataType; PWSTR connectoidName; PWSTR networkName = NULL; DWORD networkNameLength;
//
// initialize COM
//
status = CoInitializeEx( NULL, COINIT_DISABLE_OLE1DDE | COINIT_MULTITHREADED ); if ( !SUCCEEDED( status )) { ClRtlLogPrint( "RenameConnectionObjects Couldn't init COM %1!08X!\n", status ); return status; }
//
// get a handle to the root key in the cluster hive
//
clusterKey = OpenClusterRegistryRoot();
if ( clusterKey == NULL ) { status = GetLastError(); ClRtlLogPrint( "OpenClusterRegistryRoot returned %1!u! to RenameConnectionObjects\n", status ); goto error_exit; }
//
// start TCP if necessary
//
adapterEnum = GetTCPAdapterInfo(); if ( adapterEnum == NULL ) { status = GetLastError();
if ( status == ERROR_SUCCESS ) { ClRtlLogPrint( "No usable network adapters are installed in this system.\n" ); } else { ClRtlLogPrint( "GetTCPAdapterInfo returned %1!u! to RenameConnectionObjects\n", status ); } goto error_exit; }
//
// Ignore all adapters which are hidden or have an address of 0.0.0.0.
//
for (adapterInfo = adapterEnum->AdapterList; adapterInfo != NULL; adapterInfo = adapterInfo->Next ) { if (adapterInfo->Flags & CLRTL_NET_ADAPTER_HIDDEN) { ClRtlLogPrint( "Ignoring hidden adapter '%1!ws!'.\n", adapterInfo->DeviceName ); adapterInfo->Ignore = TRUE; hiddenAdapterCount++; } else { adapterIfInfo = ClRtlGetPrimaryNetInterface(adapterInfo);
if (adapterIfInfo->InterfaceAddress == 0) { ClRtlLogPrint( "Ignoring adapter '%1!ws!' because primary address is 0.0.0.0.\n", adapterInfo->DeviceName ); adapterInfo->Ignore = TRUE; hiddenAdapterCount++; } } }
if ((adapterEnum->AdapterCount - hiddenAdapterCount) == 0) { ClRtlLogPrint( "No usable network adapters are installed in this system.\n" ); status = ERROR_SUCCESS; goto error_exit; }
ClRtlLogPrint( "RenameConnectionObject found %1!u! adapters to process.\n", adapterEnum->AdapterCount - hiddenAdapterCount );
//
// now find our node number by looking through the node key in the cluster
// registry and comparing our netbios name with the names in the registry
//
ourNodeNumber = FindNodeNumber( clusterKey ); if ( ourNodeNumber == NULL ) { status = GetLastError(); ClRtlLogPrint( "FindNodeNumber failed: status %1!u!\n", status ); goto error_exit; }
//
// open the network and network interface keys
//
status = RegOpenKeyEx( clusterKey, CLUSREG_KEYNAME_NETWORKS, 0, KEY_READ, &networksKey );
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "RenameConnectionObjects failed to open Networks key: %1!u!\n", status ); goto error_exit;
}
status = RegOpenKeyEx( clusterKey, CLUSREG_KEYNAME_NETINTERFACES, 0, KEY_READ, &netInterfacesKey );
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "RenameConnectionObjects failed to open NetworkInterfaces key: %1!u!\n", status ); goto error_exit;
}
//
// enum the NetworkInterfaces key, looking for interfaces on this node. If
// we find one, get their IP address and find the corresponding network and
// connection object.
//
do { netIfGuidStringLength = sizeof( netIfGuidString ); status = RegEnumKeyEx( netInterfacesKey, index, netIfGuidString, &netIfGuidStringLength, NULL, NULL, NULL, NULL );
if ( status == ERROR_NO_MORE_ITEMS ) { ClRtlLogPrint( "RenameConnectionObjects finished enum'ing the " "NetworkInterfaces key\n" );
status = ERROR_SUCCESS; break; } else if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "RenameConnectionObjects failed to enum NetworkInterfaces " "key: %1!u!\n", status ); goto error_exit; }
//
// open this key and get the Node value
//
status = RegOpenKeyEx( netInterfacesKey, netIfGuidString, 0, KEY_READ, &netInterfacesGuidKey );
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "RenameConnectionObjects failed to open NetworkIntefaces " "subkey %1!ws!: %2!u!\n", netIfGuidString, status ); goto error_exit;
}
netIfNodeNumberLength = sizeof( netIfNodeNumber ); status = RegQueryValueEx( netInterfacesGuidKey, CLUSREG_NAME_NETIFACE_NODE, NULL, &dataType, (LPBYTE)netIfNodeNumber, &netIfNodeNumberLength );
if ( status != ERROR_SUCCESS || dataType != REG_SZ ) { ClRtlLogPrint( "RenameConnectionObjects failed to get Node value: " "status %1!u!, data type %2!u!\n", status, dataType ); status = ERROR_INVALID_DATA; goto error_exit;
}
//
// if this is one our interfaces, then adjust the name of the
// associated connection object
//
if ( lstrcmpiW( ourNodeNumber, netIfNodeNumber ) == 0 ) { ClRtlLogPrint( "Net Interface %1!ws! is on this node.\n", netIfGuidString );
connectoidName = GetConnectionName( netInterfacesGuidKey, adapterEnum );
if ( connectoidName != NULL ) {
ClRtlLogPrint( "Associated connectoid name is '%1!ws!'.\n", connectoidName);
//
// look up network GUID and open its Key to get the network name
//
networkGuidStringLength = sizeof( networkGuidString ); status = RegQueryValueEx( netInterfacesGuidKey, CLUSREG_NAME_NETIFACE_NETWORK, NULL, &dataType, (LPBYTE)networkGuidString, &networkGuidStringLength );
if ( status != ERROR_SUCCESS || dataType != REG_SZ ) { ClRtlLogPrint( "RenameConnectionObjects failed to get Network value: " "status %1!u!, data type %2!u!\n", status, dataType ); status = ERROR_INVALID_DATA; goto error_exit; }
status = RegOpenKeyEx( networksKey, networkGuidString, 0, KEY_READ, &networkGuidKey );
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "RenameConnectionObjects failed to open networks " "subkey %1!ws!: %2!u!\n", networkGuidString, status ); goto error_exit;
}
//
// query the Name value to get its size, allocate a buffer large
// enough to hold it and request the data contained in the value.
//
networkNameLength = 0; status = RegQueryValueEx( networkGuidKey, CLUSREG_NAME_NET_NAME, NULL, &dataType, (LPBYTE)NULL, &networkNameLength );
if ( status != ERROR_SUCCESS || dataType != REG_SZ ) { ClRtlLogPrint( "RenameConnectionObjects failed to get Network Name " "size: status %1!u!, data type %2!u!\n", status, dataType ); status = ERROR_INVALID_DATA; goto error_exit; }
networkName = (PWCHAR)LocalAlloc( LMEM_FIXED, networkNameLength ); if ( networkName == NULL ) { status = GetLastError(); ClRtlLogPrint( "RenameConnectionObjects failed to alloc space " "for network name: %1!u!\n", status ); goto error_exit; }
status = RegQueryValueEx( networkGuidKey, CLUSREG_NAME_NET_NAME, NULL, NULL, (LPBYTE)networkName, &networkNameLength );
RegCloseKey( networkGuidKey ); networkGuidKey = NULL;
if ( status != ERROR_SUCCESS ) { ClRtlLogPrint( "RenameConnectionObjects failed to get Network " "Name: status %1!u!\n", status ); goto error_exit; }
ClRtlLogPrint( "Network name is '%1!ws!'.\n", networkName );
if ( lstrcmpiW( connectoidName, networkName ) != 0 ) { ClRtlLogPrint( "Changing connectoid name to '%1!ws!'.\n", networkName ); ClRtlFindConnectoidByNameAndSetName( connectoidName, networkName ); } } else { ClRtlLogPrint( "RenameConnectionObjects failed to get connection name.\n" ); } }
RegCloseKey( netInterfacesGuidKey ); netInterfacesGuidKey = NULL;
++index; } while ( TRUE );
error_exit: if ( clusterKey != NULL ) { RegCloseKey( clusterKey ); }
if ( netInterfacesKey != NULL ) { RegCloseKey( netInterfacesKey ); }
if ( netInterfacesGuidKey != NULL ) { RegCloseKey( netInterfacesGuidKey ); }
if ( networksKey != NULL ) { RegCloseKey( networksKey ); }
if ( networkGuidKey != NULL ) { RegCloseKey( networkGuidKey ); }
if ( ourNodeNumber != NULL ) { LocalFree( ourNodeNumber ); }
if ( networkName != NULL ) { LocalFree( networkName ); }
if ( adapterEnum != NULL ) { ClRtlFreeNetAdapterEnum( adapterEnum ); }
CoUninitialize();
return status;} // RenameConnectionObjects
/////////////////////////////////////////////////////////////////////////////
//++
//
// CompleteUpgradingClusteringService
//
// Routine Description:
// This function completes the process of upgrading a Cluster service installation.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::CompleteUpgradingClusteringService( IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue; eClusterInstallState eState;
// This is an upgrade, if Cluster Server has previously been
// been installed then queue the registry additions.
// GetClusterInstallationState reports on the state of the registry value
// that records the state of the Cluster service installation on NT 5 machines.
// IsClusterServiceRegistered indicates whether the Cluster service is registered on
// BOTH NT 4 and NT 5 machines. Both tests are required: IsClusterServiceRegistered for
// upgrading NT 4 machines, ClRtlGetClusterInstallState for NT 5 machines.
BOOL fClusterServiceRegistered;
fClusterServiceRegistered = IsClusterServiceRegistered();
ClRtlGetClusterInstallState( NULL, &eState );
if ( ( eState != eClusterInstallStateUnknown ) || ( fClusterServiceRegistered == (BOOL) TRUE ) ) { // Update the progress bar.
m_SetupInitComponent.HelperRoutines.TickGauge( m_SetupInitComponent.HelperRoutines.OcManagerContext );
// Update the "progress text"
CString csProgressText;
csProgressText.LoadString( IDS_UPGRADING_CLUS_SERVICE );
m_SetupInitComponent.HelperRoutines.SetProgressText( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) csProgressText ); ClRtlLogPrint( "In CompleteUpgradingClusteringService Cluster service has previously been installed.\n" );
// Perform the base registry operations.
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId );
ClRtlLogPrint( "The base call to PerformRegistryOperations returned 0x%1!x! to " "CompleteUpgradingClusteringService.\n", dwReturnValue );
// Were the base registry operations performed successfully?
CString csUpgrade;
if ( dwReturnValue == (DWORD) NO_ERROR ) { // Perform the registry operations that pertain to UPGRADE.
csUpgrade = UPGRADE_INF_KEY;
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, csUpgrade );
ClRtlLogPrint( "The UPGRADE call to PerformRegistryOperations returned 0x%1!x! " "to CompleteUpgradingClusteringService.\n", dwReturnValue ); } // Were the base registry operations performed successfully?
// Were the UPGRADE registry operations performed successfully?
if ( dwReturnValue == (DWORD) NO_ERROR ) { // If the Cluster Service is registered with the Service Control Manager then
// the registry keys that add "Configure Cluster service" to the Welcome UI
// should be eliminated because the service has already been configured.
if ( fClusterServiceRegistered == (BOOL) TRUE ) { CString csClusterService;
csClusterService = CLUSTER_SERVICE_NAME;
CString csRegistered;
csRegistered = REGISTERED_INF_KEY_FRAGMENT;
CString csSectionName;
csSectionName = csUpgrade + (CString) _T(".") + csClusterService + (CString) _T(".") + csRegistered;
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, csSectionName );
ClRtlLogPrint( "The REGISTERED call to PerformRegistryOperations returned 0x%1!x! " "to CompleteUpgradingClusteringService.\n", dwReturnValue ); }
// Were the Welcome UI registry operations performed successfully?
if ( dwReturnValue == (DWORD) NO_ERROR ) { ClRtlLogPrint( "In CompleteUpgradingClusteringService the registry operations " "were performed successfully.\n" );
// In NT 4 the ImagePath value in HKLM\System\CurrentControlSet\Services\ClusSvc
// is set to reference clusprxy.exe. In NT 5 it must reference clussvc.exe.
// The ImagePath value in the Cluster Service registry key must
// be set programmatically because the path to the service
// executable image is not known to the component INF file. That
// is because in NT 4 "Cluster Server" as it was known, could be
// installed in an arbitrary location.
// There is no straightforward way to determine whether this upgrade
// is from NT 4 or NT 5. The assumption made here is that if the
// Cluster Service is registered with the Service Control Manager
// then it was upgraded in place, regardless of the OS level. In that
// case it will be safe to set the ImagePath value to reference clussvc.exe
// in that location. If the Cluster Service is not registered with the
// SC Manager then it is safe to leave that reg value alone because when
// cluscfg.exe configures the Cluster service the ImagePath value will
// get written correctly.
if ( fClusterServiceRegistered == (BOOL) TRUE ) { dwReturnValue = UpgradeClusterServiceImagePath();
ClRtlLogPrint( "UpgradeClusterServiceImagePath returned 0x%1!x! to " "CompleteUpgradingClusteringService.\n", dwReturnValue ); }
// Was the ImagePath set successfully?
if ( dwReturnValue == (DWORD) NO_ERROR ) { // did the connection objects get renamed?
dwReturnValue = RenameConnectionObjects();
ClRtlLogPrint( "RenameConnectionObjects returned 0x%1!x! to " "CompleteUpgradingClusteringService.\n", dwReturnValue );
if ( dwReturnValue == (DWORD) NO_ERROR ) { //
// set the service controller default failure actions
//
dwReturnValue = ClRtlSetSCMFailureActions( NULL );
ClRtlLogPrint( "ClRtlSetDefaultFailureActions returned 0x%1!x! to " "CompleteUpgradingClusteringService.\n", dwReturnValue );
if ( dwReturnValue == (DWORD) NO_ERROR ) { // In NT4 the "Display Name" for the Cluster service was
// "Cluster Server". It must be programatically changed to
// "Cluster service".
if ( fClusterServiceRegistered == (BOOL) TRUE ) { CString csClusterService;
csClusterService = CLUSTER_SERVICE_NAME;
SC_HANDLE hscServiceMgr; SC_HANDLE hscService;
// Connect to the Service Control Manager and open the specified service
// control manager database.
hscServiceMgr = OpenSCManager( NULL, NULL, GENERIC_READ | GENERIC_WRITE );
// Was the service control manager database opened successfully?
if ( hscServiceMgr != NULL ) { // The service control manager database is open.
// Get the current display name of the service.
TCHAR tszDisplayName[50]; // arbitrary size
DWORD dwBufferSize = 50;
BOOL fStatus;
fStatus = GetServiceDisplayName( hscServiceMgr, (LPCTSTR) csClusterService, tszDisplayName, &dwBufferSize );
if ( fStatus == (BOOL) TRUE ) { // Is the service name "Cluster service"?
if ( _tcscmp( tszDisplayName, _T("Cluster service") ) != 0 ) { // The display name is not correct. Change it.
// Open a handle to the Service. Allow configuration changes.
hscService = OpenService( hscServiceMgr, (LPWSTR) (LPCTSTR) csClusterService, SERVICE_CHANGE_CONFIG );
// Was the handle to the service opened?
if ( hscService != NULL ) { // A valid handle to the Service was obtained.
fStatus = ChangeServiceConfig( hscService, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, _T("Cluster service") );
// Was the change succesful?
if ( fStatus != (BOOL) TRUE ) { dwReturnValue = GetLastError();
ClRtlLogPrint( "Could not change the cluster service display name" " in CompleteUpgradingClusteringService." " Error: 0x%1!x!.\n", dwReturnValue ); }
// Close the handle to the Cluster Service.
CloseServiceHandle( hscService ); } // service opened?
} // display name correct?
} else { // Couldn't get the display name.
dwReturnValue = GetLastError();
ClRtlLogPrint( "Could not query the cluster service display name" " in CompleteUpgradingClusteringService." " Error: 0x%1!x!.\n", dwReturnValue ); }// got display name?
// Close the handle to the Service Control Manager.
CloseServiceHandle( hscServiceMgr ); } } // cluster service registered?
if ( dwReturnValue == (DWORD) NO_ERROR ) { // Register ClAdmWiz.
// First, get the path to the cluster directory.
CString csTemp;
csTemp = CLUSTER_DIRECTORY; TCHAR tszPathToClusterDir[_MAX_PATH]; if ( ExpandEnvironmentStrings( (LPCTSTR) csTemp, tszPathToClusterDir, _MAX_PATH ) > 0L ) { HRESULT hResult;
// Attempt to initialize the COM library.
hResult = CoInitializeEx( NULL, COINIT_APARTMENTTHREADED );
if ( (hResult == S_OK) || // success
(hResult == S_FALSE) || // already initialized
(hResult == RPC_E_CHANGED_MODE) ) // previous initialization specified
// a different concurrency model
{ DWORD dwRCOrv; // RegisterCOMObject returns ERROR_SUCCESS on success.
dwRCOrv = RegisterCOMObject( TEXT("ClAdmWiz.dll"), tszPathToClusterDir ); if ( dwRCOrv != (DWORD) ERROR_SUCCESS ) { ClRtlLogPrint( "CompleteUpgradingClusteringService failed to register ClAdmWiz.dll with error %1!d!.\n", dwRCOrv ); } // ClAdmWiz registered?
else { // ERROR_SUCCESS and NO_ERROR are coincidentally the same.
ClRtlLogPrint( "CompleteUpgradingClusteringService has registered ClAdmWiz.dll.\n" ); } // ClAdmWiz registered?
// RegisterCOMObject returns ERROR_SUCCESS on success.
dwRCOrv = RegisterCOMObject( TEXT("ClNetREx.dll"), tszPathToClusterDir ); if ( dwRCOrv != (DWORD) ERROR_SUCCESS ) { ClRtlLogPrint( "CompleteUpgradingClusteringService failed to register ClNetREx.dll with error %1!d!.\n", dwRCOrv ); } // ClNetREx registered?
else { // ERROR_SUCCESS and NO_ERROR are coincidentally the same.
ClRtlLogPrint( "CompleteUpgradingClusteringService has registered ClNetREx.dll.\n" ); } // ClNetREx registered?
// RegisterCOMObject returns ERROR_SUCCESS on success.
dwRCOrv = RegisterCOMObject( TEXT("CluAdMMC.dll"), tszPathToClusterDir ); if ( dwRCOrv != (DWORD) ERROR_SUCCESS ) { ClRtlLogPrint( "CompleteUpgradingClusteringService failed to register CluAdMMC.dll with error %1!d!.\n", dwRCOrv ); } // CluAdMMC registered?
else { // ERROR_SUCCESS and NO_ERROR are coincidentally the same.
ClRtlLogPrint( "CompleteUpgradingClusteringService has registered CluAdMMC.dll.\n" ); } // CluAdMMC registered?
// Close the COM library. As per MSDN, each successfull call
// to CoInitializeEx() must be balanced ba a call to CoUnitialize().
CoUninitialize();
} // COM library initialized?
else { // Could not inititlize the COM library.
ClRtlLogPrint( "CompleteUpgradingClusteringService could not initialize the COM library. Error %1!d!.\n", hResult ); } // COM library initialized?
} // path to cluster directory obtained?
else { // Couldn't expand the environment string.
dwReturnValue = GetLastError(); ClRtlLogPrint( "CompleteUpgradingClusteringService could not register ClAdmWiz.dll\n" ); ClRtlLogPrint( "because it could not locate the cluster directory. Error %1!d!.\n", dwReturnValue ); } // path to cluster directory obtained?
}
if ( dwReturnValue == (DWORD) NO_ERROR ) { // Set the ClusterInstallationState reg value to "UPGRADED"
ClRtlSetClusterInstallState( eClusterInstallStateUpgraded ); } } // did the default failure actions get set?
} // did the connection objects get renamed?
} // Was the ImagePath set successfully?
} // Were the Welcome UI registry operations performed successfully?
} // Were the UPGRADE registry operations performed successfully?
} else { ClRtlLogPrint( "In CompleteUpgradingClusteringService since Cluster service " "has never been installed there is nothing to do.\n" );
dwReturnValue = (DWORD) NO_ERROR; } // Has Cluster service previously been installed?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CompleteStandAloneInstallationOfClusteringService
//
// Routine Description:
// This function completes the process of installing Cluster service when
// either Add/Remove Programs is running or sysocmgr.exe was launched from
// a command prompt.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::CompleteStandAloneInstallationOfClusteringService( IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue; DWORD_PTR dwResult;
// Update the progress bar.
m_SetupInitComponent.HelperRoutines.TickGauge( m_SetupInitComponent.HelperRoutines.OcManagerContext );
// Update the "progress text"
CString csProgressText;
csProgressText.LoadString( IDS_INSTALLING_CLUS_SERVICE );
m_SetupInitComponent.HelperRoutines.SetProgressText( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) csProgressText ); // A selection state transition has occured. Perform the base
// registry operations.
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId );
// On a standalone installation, we need to send a WM_SETTINGCHANGE message to all top level windows
// so that any changes we have made to the system environment variables take effect.
// During fresh installation, this happens automatically since there is a reboot.
// See Knowledge Base article Q104011.
SendMessageTimeout( HWND_BROADCAST, // handle to window
WM_SETTINGCHANGE, // message
0, // wparam
(LPARAM) _T("Environment"), // lparam
SMTO_ABORTIFHUNG | SMTO_NORMAL, // send options
100, // time-out duration (ms). Note, each top level window can wait upto this time
&dwResult // return value for synchronous call - we ignore this
);
ClRtlLogPrint( "The base call to PerformRegistryOperations returned 0x%1!x! to CompleteStandAloneInstallationOfClusteringService.\n", dwReturnValue );
// Were the base registry operations performed successfully?
if ( dwReturnValue == (DWORD) NO_ERROR ) { // Queue the registry operations to add "Configure Cluster service"
// to the Welcome UI task list. As per Sharon Montgomery on 12/18/98 the
// Server Solutions will use those same keys.
CString csSectionName;
csSectionName = CLUSREG_KEYNAME_WELCOME_UI;
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, csSectionName );
ClRtlLogPrint( "The WelcomeUI call to PerformRegistryOperations returned 0x%1!x! to CompleteStandAloneInstallationOfClusteringService.\n", dwReturnValue );
if ( dwReturnValue == (DWORD) NO_ERROR ) { ClRtlLogPrint( "In CompleteStandAloneInstallationOfClusteringService the registry operations were queued successfully.\n" );
// Since this was a standalone installation launch the Cluster Configuration
// program, cluscfg.exe.
// First, build the command line used to launch cluscfg. The specific
// command depends on whether this is an unattended operation. Regardless
// of whether this is unattended, the first part of the command line is
// the fully qualified path to cluscfg.
BOOL fReturnValue;
TCHAR tszClusCfgCommandLine[MAX_PATH];
fReturnValue = GetPathToClusCfg( tszClusCfgCommandLine );
// Was the path to cluscfg.exe deduced?
if ( fReturnValue == (BOOL) TRUE ) { // Update the progress bar.
m_SetupInitComponent.HelperRoutines.TickGauge( m_SetupInitComponent.HelperRoutines.OcManagerContext );
// Update the "progress text"
CString csProgressText;
csProgressText.LoadString( IDS_CONFIGURING_CLUS_SERVICE );
m_SetupInitComponent.HelperRoutines.SetProgressText( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) csProgressText );
// Is this an unattended operation?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) != (DWORDLONG) 0L ) { // This is unattended.
HINF hAnswerFile; // WARNING: NEVER close this handle because clusocm.dll
// did not open it.
// Get a handle to the answer file. WARNING: NEVER close this handle because clusocm.dll
// did not open it.
hAnswerFile = m_SetupInitComponent.HelperRoutines.GetInfHandle( INFINDEX_UNATTENDED, m_SetupInitComponent.HelperRoutines.OcManagerContext ); // Is the handle to the answer file OK?
if ( (hAnswerFile != (HINF) NULL) && (hAnswerFile != (HINF) INVALID_HANDLE_VALUE) ) { // The handle to the answer file is legal.
// tszClusCfgCommandLine is the path to cluscfg.exe. Append the "-UNATTEND"
// command line option.
CString csUnattendCommandLineOption;
csUnattendCommandLineOption = UNATTEND_COMMAND_LINE_OPTION;
_tcscat( tszClusCfgCommandLine, _T(" ") ); _tcscat( tszClusCfgCommandLine, csUnattendCommandLineOption );
// Append the path to the answer file.
_tcscat( tszClusCfgCommandLine, _T(" ") ); _tcscat( tszClusCfgCommandLine, m_SetupInitComponent.SetupData.UnattendFile ); } // handle to answer file OK?
} // unattended?
// Launch cluscfg - tszClusCfgCommandLine contains the command, either
// attended or unattended.
STARTUPINFO StartupInfo;
ZeroMemory( &StartupInfo, sizeof( StartupInfo ) ); StartupInfo.cb = sizeof( StartupInfo );
PROCESS_INFORMATION ProcessInformation;
fReturnValue = CreateProcess( (LPCTSTR) NULL, (LPTSTR) tszClusCfgCommandLine, (LPSECURITY_ATTRIBUTES) NULL, (LPSECURITY_ATTRIBUTES) NULL, (BOOL) FALSE, (DWORD) (CREATE_DEFAULT_ERROR_MODE | CREATE_UNICODE_ENVIRONMENT), (LPVOID) GetEnvironmentStrings(), (LPCTSTR) NULL, (LPSTARTUPINFO) &StartupInfo, (LPPROCESS_INFORMATION) &ProcessInformation );
// Was the process created?
if ( fReturnValue == (BOOL) TRUE ) { // Wait for cluscfg.exe to complete. As per Pat Styles on 7/6/98,
// an OCM Setup DLL MUST wait for any process it spawns to complete.
DWORD dwWFSOrv;
dwWFSOrv = WaitForSingleObject( ProcessInformation.hProcess, INFINITE ); } else { DWORD dwErrorCode;
dwErrorCode = GetLastError();
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) == (DWORDLONG) 0L ) { CString csMessage;
csMessage.Format( IDS_ERROR_SPAWNING_CLUSCFG, dwErrorCode );
AfxMessageBox( csMessage ); }
ClRtlLogPrint( "Error %1!d! occured attempting to spawn cluscfg.exe.\n", dwErrorCode ); } // Was the process created?
} // Path to cluscfg obtained?
} // WelcomeUI registry operations succeeded?
} // Were the base registry operations performed successfully?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CompleteInstallingClusteringService
//
// Routine Description:
// This function performs much of the processing when OC_COMPLETE_INSTALLATION
// has been received and a clean installation is being performed.
//
// Arguments:
// ptszSubComponentId - points to a string that uniquely identifies a sub-
// component in the component's hiearchy.
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::CompleteInstallingClusteringService( IN LPCTSTR ptszSubComponentId ){ DWORD dwReturnValue;
// Update the progress bar.
if ( GetStepCount() != 0L ) { // Update the progress meter.
m_SetupInitComponent.HelperRoutines.TickGauge( m_SetupInitComponent.HelperRoutines.OcManagerContext ); }
// Update the "progress text"
CString csProgressText;
csProgressText.LoadString( IDS_INSTALLING_CLUS_SERVICE );
m_SetupInitComponent.HelperRoutines.SetProgressText( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) csProgressText );
// Perform the base registry operations.
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, ptszSubComponentId );
ClRtlLogPrint( "The base call to PerformRegistryOperations returned 0x%1!x! to CompleteInstallingClusteringService.\n", dwReturnValue );
// Were the base registry operations performed successfully?
if ( dwReturnValue == (DWORD) NO_ERROR ) { // Queue the registry operations to add "Configure Cluster service"
// to the Welcome UI task list. As per Sharon Montgomery on 12/18/98, Server
// Solutions will use those same keys.
CString csSectionName;
csSectionName = CLUSREG_KEYNAME_WELCOME_UI;
dwReturnValue = PerformRegistryOperations( m_SetupInitComponent.ComponentInfHandle, csSectionName );
ClRtlLogPrint( "The WelcomeUI call to PerformRegistryOperations returned 0x%1!x! to CompleteInstallingClusteringService.\n", dwReturnValue ); } // Were the base registry operations performed successfully?
// Were the Welcome UI registry operations performed successfully?
if ( dwReturnValue == (DWORD) NO_ERROR ) { ClRtlLogPrint( "In CompleteInstallingClusteringService for a clean install all registery operations were performed successfully.\n" ); } else { ClRtlLogPrint( "In CompleteInstallingClusteringService for a clean install the registry operations were not performed successfully.\n" ); }
// For unattended setup this needs to write the WelcomeUI reg keys in a way that
// will cause Configure Your Server to launch cluscfg.exe in unattended mode.
// revisions to CompleteInstallingClusteringService may be appropriate prior to this code segment.
// Were all registry operations performed correctly?
if ( dwReturnValue == (DWORD) NO_ERROR ) { LONG lReturnValue; // used below for registry operations
HKEY hKey; // used below for registry operations
// Is this an unattended installation?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) != (DWORDLONG) 0L ) { HINF hAnswerFile; // WARNING: NEVER close this handle because clusocm.dll
// did not open it.
// Get a handle to the answer file. WARNING: NEVER close this handle because clusocm.dll
// did not open it.
hAnswerFile = m_SetupInitComponent.HelperRoutines.GetInfHandle( INFINDEX_UNATTENDED, m_SetupInitComponent.HelperRoutines.OcManagerContext );
if ( (hAnswerFile != (HINF) NULL) && (hAnswerFile != (HINF) INVALID_HANDLE_VALUE) ) { // Write the WelcomeUI registry entry to launch cluscfg in unattended mode.
// Note that the registry operations performed when CLUSREG_KEYNAME_WELCOME_UI
// was passed to PerformRegistryOperations() above included creation of
// HKLM\Software\Microsoft\Windows NT\CurrentVersion\Setup\OCManager\ToDoList\Cluster\ConfigCommand.
// All that is necessary is to create the ConfigArgs value with the
// appropriate command line arguments to execute cluscfg.exe in unattended mode.
HKEY hKey;
DWORD dwType;
// Attempt to open an existing key in the registry.
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, _T( "Software\\Microsoft\\Windows NT\\CurrentVersion\\Setup\\OCManager\\ToDoList\\Cluster" ), (DWORD) 0, // reserved
KEY_SET_VALUE, &hKey );
// Was the Cluster "to do list" registry key opened?
if ( lReturnValue == (LONG) ERROR_SUCCESS ) { // The key is open.
TCHAR tszValue[MAX_PATH];
_tcscpy( tszValue, UNATTEND_COMMAND_LINE_OPTION );
// Append the path to the answer file.
_tcscat( tszValue, _T(" ") ); _tcscat( tszValue, m_SetupInitComponent.SetupData.UnattendFile );
// Set the key.
DWORD dwValueLength;
dwValueLength = (DWORD) ((_tcslen( tszValue ) + 1) * sizeof( TCHAR ));
lReturnValue = RegSetValueEx( hKey, _T( "ConfigArgs" ), (DWORD) 0L, // reserved
(DWORD) REG_EXPAND_SZ, (CONST BYTE *) tszValue, dwValueLength );
// Was the key written successfully?
if ( lReturnValue == (LONG) ERROR_SUCCESS ) { dwReturnValue = (DWORD) NO_ERROR;
ClRtlLogPrint( "CompleteInstallingClusteringService created the ConfigArgs reg key for unattended operation of cluscfg.\n" ); } else { dwReturnValue = GetLastError();
ClRtlLogPrint( "CompleteInstallingClusteringService failed to create the ConfigArgs reg key with error code %1!d!.\n", dwReturnValue ); } // Was the reg key written successfully?
// Close the registry key.
RegCloseKey( hKey ); // do we care about the return value?
} else { // The key could not be opened.
DWORD dwErrorCode;
dwErrorCode = GetLastError();
ClRtlLogPrint( "In CompleteInstallingClusteringService RegOpenKeyEx failed with error code 0x%1!x!.\n", dwErrorCode ); } // Was the key opened?
} // handle to answer file OK?
} // Is this unattended?
else { // This is NOT unattended, so make sure the ConfigArgs value is removed.
// That will prevent any value left from a previous unattended install
// which was never successfully configured from corrupting the behavior
// of Configure Your Server or Add/Remove Programs.
// Attempt to open an existing key in the registry.
lReturnValue = RegOpenKeyEx( HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Setup\\OCManager\\ToDoList\\Cluster"), (DWORD) 0, // reserved
KEY_READ, &hKey );
// Was the Cluster "to do list" registry key opened?
if ( lReturnValue == (long) ERROR_SUCCESS ) { // Delete the values (which may not exist).
RegDeleteValue( hKey, (LPCTSTR) TEXT("ConfigArgs") ); } // if ToDoList opened
} // if unattended?
} // registry operations successfull?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// OnOcCleanup
//
// Routine Description:
// This function processes the OC_CLEANUP messages by removing the "private"
// subdirectory in the cluster directory if it is empty and the cluster directory
// itself it it is empty.
//
// Arguments:
// none
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// Any other value is a standard Win32 error code.
//
// Note:
// The "private" subrirectory may exist in the cluster directory if the system
// was upgraded from NT4.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::OnOcCleanup( void ){ ClRtlLogPrint( "Processing OC_CLEANUP.\n" );
DWORD dwReturnValue;
dwReturnValue = CleanupDirectories();
ClRtlLogPrint( "\n\n\n\n" );
// Close the log file.
ClRtlCleanup();
// Set the ClusterLog environment variable back to its' original state.
char szLogFileName[MAX_PATH];
strcpy( szLogFileName, "ClusterLog=" );
if ( *m_szOriginalLogFileName != (char) '\0' ) { strcat( szLogFileName, m_szOriginalLogFileName ); }
_putenv( szLogFileName );
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CleanupDirectories
//
// Routine Description:
// This function removes the "private" subdirectory that may remain in the
// cluster directory if the system has ever been upgraded from NT 4 if that
// directory is empty. It will also remove the cluster directory itself if
// it is empty.
//
// Arguments:
// none
//
// Return Value:
// (DWORD) NO_ERROR - indicates success
// (DWORD) -1L - means that the cluster directory was not empty
// Any other value is a standard Win32 error code.
//
// Note:
// This function assumes that the path to the cluster directory is less than
// MAX_PATH TCHARs long and that function SetupGetTargetPath expects the fifth
// parameter to specify the number of TCHARS (not bytes) in the buffer.
//
// No recovery is attempted if the call to SetupGetTargetPath fails.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::CleanupDirectories( void ){ DWORD dwReturnValue = (DWORD) NO_ERROR;
BOOL fReturnValue;
DWORD dwRequiredSize;
TCHAR tszPathToClusterDirectory[MAX_PATH];
// First, get the path to the cluster directory.
CString csSectionName;
csSectionName = CLUSTER_FILES_INF_KEY;
fReturnValue = SetupGetTargetPath( m_SetupInitComponent.ComponentInfHandle, (PINFCONTEXT) NULL, (PCTSTR) csSectionName, tszPathToClusterDirectory, (DWORD) MAX_PATH, (PDWORD) &dwRequiredSize );
// Was the path to the cluster directory obtained?
if ( fReturnValue == (BOOL) TRUE ) { // Test for the presence of a subdirectory named "private".
TCHAR tszPathToPrivateDirectory[MAX_PATH];
// Append "\private" to the path to the cluster directory that was obtained above.
// Note, I didn't put this string in the stringtable because it is
// not localizable, and will never change.
_tcscpy( tszPathToPrivateDirectory, tszPathToClusterDirectory ); _tcscat( tszPathToPrivateDirectory, _T("\\private") );
HANDLE hFindHandle; WIN32_FIND_DATA FindData;
// Does a file or directory named "private" exist?
hFindHandle = FindFirstFile( (LPCTSTR) tszPathToPrivateDirectory, &FindData );
if ( hFindHandle != (HANDLE) INVALID_HANDLE_VALUE ) { // A file named "private" exists in the cluster directory. Is it a directory?
if ( (FindData.dwFileAttributes & (DWORD) FILE_ATTRIBUTE_DIRECTORY) != (DWORD) 0L ) { // The "private" directory has been located. Determine whether it is empty.
if ( IsDirectoryEmpty( tszPathToPrivateDirectory ) == (BOOL) TRUE ) { // No file was found in the "private" directory. Remove the "private" directory.
if ( RemoveDirectory( (LPCTSTR) tszPathToPrivateDirectory ) == (BOOL) TRUE ) { dwReturnValue = (DWORD) NO_ERROR; } else { // Could not delete the "private" directory even though it was empty.
dwReturnValue = GetLastError();
ClRtlLogPrint( "CleanupDirectories was unable to remove %1!s!. The error code is %2!x!.\n", tszPathToPrivateDirectory, dwReturnValue ); } // Was the "private" directory removed successfully?
} else { ClRtlLogPrint( "CleanupDirectories did not attempt to remove %1!s! because it is not empty.\n", tszPathToPrivateDirectory );
// An error code of -1 means the "private" directory, and thus the
// cluster directory was not empty.
dwReturnValue = (DWORD) -1L; } // Was any file found in the "private" directory?
} else { ClRtlLogPrint( "In CleanupDirectories the file named private is not a directory.\n");
dwReturnValue = (DWORD) ERROR_FILE_NOT_FOUND; } // Is it a directory?
// Close the search that located the "private" directory.
FindClose( hFindHandle ); } else { dwReturnValue = GetLastError();
ClRtlLogPrint( "CleanupDirectories was unable to find any file named private in the cluster directory.\n"); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwReturnValue ); } // Does a file or directory named "private" exist?
// Was the "private" directory absent or removed successfully?
if ( (dwReturnValue == (DWORD) ERROR_FILE_NOT_FOUND) || (dwReturnValue == (DWORD) NO_ERROR) ) { // The "private" directory either did not exist or has been removed.
// Now determine whether the cluster directory is empty and therefore should be removed.
// This code segment assumes that the cluster directory, as specified
// in tszPathToClusterDirectory exists.
if ( IsDirectoryEmpty( tszPathToClusterDirectory ) == (BOOL) TRUE ) { // The cluster directory is empty.
if ( RemoveDirectory( tszPathToClusterDirectory ) == (BOOL) TRUE ) { dwReturnValue = (DWORD) NO_ERROR; } else { // Could not delete the "cluster" directory even though it was empty.
dwReturnValue = GetLastError();
ClRtlLogPrint( "CleanupDirectories was unable to remove %1!s!. The error code is %2!x!.\n", tszPathToClusterDirectory, dwReturnValue ); } // Was the cluster directory removed?
} else { // The cluster directory is not empty.
ClRtlLogPrint( "CleanupDirectories did not attempt to remove %1!s! because it is not empty.\n", tszPathToClusterDirectory );
// An error code of -1 means the cluster directory was not empty.
dwReturnValue = (DWORD) -1L; } // Is the cluster directory empty?
} // Was the "private" directory absent or removed?
} else { dwReturnValue = GetLastError();
ClRtlLogPrint( "CleanupDirectories was unable to obtain the path to the cluster directory.\n"); ClRtlLogPrint( "The error code is 0x%1!x!.\n", dwReturnValue ); } // Was the path to the cluster directory obtained?
return ( dwReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// IsDirectoryEmpty
//
// Routine Description:
// This function determines whether a directory is empty.
//
// Arguments:
// ptzDirectoryName - points to a string specifying the directory name.
//
// Return Value:
// TRUE - indicates that the directory is empty
// FALSE - indicates that the directory is not empty
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::IsDirectoryEmpty( LPCTSTR ptszDirectoryName ){ BOOL fDirectoryEmpty;
HANDLE hFindHandle;
WIN32_FIND_DATA FindData;
TCHAR tszFindPath[MAX_PATH];
// Append the file specification to the path supplied.
_tcscpy( tszFindPath, ptszDirectoryName ); _tcscat( tszFindPath, _T("\\*") );
hFindHandle = FindFirstFile( tszFindPath, &FindData );
// Was any file found in the directory?
if ( hFindHandle != (HANDLE) INVALID_HANDLE_VALUE ) { // A file was found. It could be "." or "..".
if ( (_tcscmp( FindData.cFileName, _T(".") ) == 0) || (_tcscmp( FindData.cFileName, _T("..") ) == 0) ) { // The file was either "." or "..". Keep trying.
DWORD dwErrorCode;
if ( FindNextFile( hFindHandle, &FindData ) == (BOOL) TRUE ) { // A file was found. It could be "." or "..".
if ( (_tcscmp( FindData.cFileName, _T(".") ) == 0) || (_tcscmp( FindData.cFileName, _T("..") ) == 0) ) { // The file was either "." or "..". Keep trying.
if ( FindNextFile( hFindHandle, &FindData ) == (BOOL) TRUE ) { // The file cannot possibly be either "." or "..".
fDirectoryEmpty = (BOOL) FALSE; } else { dwErrorCode = GetLastError();
if ( dwErrorCode == (DWORD) ERROR_NO_MORE_FILES ) { fDirectoryEmpty = (BOOL) TRUE; } else { fDirectoryEmpty = (BOOL) FALSE; } } } else { // The private directory is not empty.
fDirectoryEmpty = (BOOL) FALSE; } } else { dwErrorCode = GetLastError();
if ( dwErrorCode == ERROR_NO_MORE_FILES ) { fDirectoryEmpty = (BOOL) TRUE; } else { fDirectoryEmpty = (BOOL) FALSE; } } } else { // The directory is not empty.
fDirectoryEmpty = (BOOL) FALSE; }
// Close the search.
FindClose( hFindHandle ); } else { fDirectoryEmpty = (BOOL) TRUE; }
return ( fDirectoryEmpty );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetPathToClusCfg
//
// Routine Description:
// This function deduces the path to the Cluster service configuration
// program, cluscfg.exe.
//
// It assumes that if the Cluster service is registered with the Service
// COntrol Manager then cluscfg.exe is located in the directory with clussvc.exe.
// Otherwise it expands %windir%\cluster and declares that to be the path.
//
// The name of the Cluster service configuration pogram is then appended to
// the path.
//
// Arguments:
// lptszPathToClusCfg - points to a string in which the fully qualified path to
// the Cluster service configuration program is to be placed.
//
// Return Value:
// TRUE - indicates that lptszPathToClusCfg is valid
// FALSE - indicates that an error occured
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CClusocmApp::GetPathToClusCfg( LPTSTR lptszPathToClusCfg ){ BOOL fReturnValue;
// If the Cluster service is registered assume that cluscfg is in
// the same directory as clussvc.exe and get the path to cluscfg.exe
// from the Service Control Mamager. If the Cluster service is not
// registered, assume cluscfg.exe is in %windir%\cluster.
if ( IsClusterServiceRegistered() == (BOOL) TRUE ) { // Query the path to the Cluster Service executable from the Service Control Manager.
CString csClusterService;
csClusterService = CLUSTER_SERVICE_NAME;
fReturnValue = GetServiceBinaryPath( (LPWSTR) (LPCTSTR) csClusterService, lptszPathToClusCfg ); } else { // Use the default location.
CString csClusterDirectory;
csClusterDirectory = CLUSTER_DIRECTORY;
if ( ExpandEnvironmentStrings( (LPCTSTR) csClusterDirectory, lptszPathToClusCfg, MAX_PATH ) > 0L ) { fReturnValue = (BOOL) TRUE; } else { // Could not expand the enviornment string. The default location for the
// Cluster service could not be determined.
fReturnValue = (BOOL) FALSE; } // Was the default location for cluscfg.exe determined?
} // Where is cluscfg.exe?
// Was the path to cluscfg.exe deduced?
if ( fReturnValue == (BOOL) TRUE ) { // tszPathToClusCfg is the path to cluscfg.exe. Append the program name.
CString csClusterConfigurationProgram;
csClusterConfigurationProgram = CLUSTER_CONFIGURATION_PGM;
_tcscat( lptszPathToClusCfg, _T("\\") ); _tcscat( lptszPathToClusCfg, csClusterConfigurationProgram ); } else { // Set the target string empty.
*lptszPathToClusCfg = _T( '\0' ); }
return ( fReturnValue );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// CalculateStepCount
//
// Routine Description:
// This function calculates the "step count", i.e the number of non-file operations
// to be performed when processing OC_COMPLETE_INSTALLATION.
//
// Arguments:
// ptszSubComponentId
//
// Return Value:
// The number of non-file operation (steps) to perform when processing
// OC_COMPLETE_INSTALLATION
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::CalculateStepCount( LPCTSTR ptszSubComponentId ){ DWORD dwStepCount;
// Is this UNATTENDED or ATTENDED?
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_BATCH) != (DWORDLONG) 0L ) { // This is UNATTENDED.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_NTUPGRADE) != (DWORDLONG) 0L ) { // This is UPGRADE. Cluscfg.exe will not be launched, so there is
// one non-file operation to be performed, registry revisions.
dwStepCount = 1L; } else { // This is a clean INSTALL. Cluscfg.exe may be launched.
// Is there a [cluster] section in the answer file? BUGBUG
// so there
// are two non-file operations to be performed, registry revisions
// and execution of cluscfg.
dwStepCount = 2L; } // unattended: upgrade or install?
} else { // This is ATTENDED.
if ( (m_SetupInitComponent.SetupData.OperationFlags & (DWORDLONG) SETUPOP_STANDALONE) != (DWORDLONG) 0L ) { // This is STANDALONE. Is Cluster service selected?
BOOL fCurrentSelectionState; BOOL fOriginalSelectionState;
fCurrentSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, (LPCTSTR) ptszSubComponentId, (UINT) OCSELSTATETYPE_CURRENT ); fOriginalSelectionState = m_SetupInitComponent.HelperRoutines.QuerySelectionState( m_SetupInitComponent.HelperRoutines.OcManagerContext, ptszSubComponentId, (UINT) OCSELSTATETYPE_ORIGINAL );
// Was there a selection state transition?
if ( fCurrentSelectionState != fOriginalSelectionState ) { if ( fCurrentSelectionState == (BOOL) TRUE ) { // Currently selected - This is a clean install. There are two
// non-file operations to be performed, registry revisions and
// execution of cluscfg.exe.
dwStepCount = 2L; } else { // Currently not selected - This is an uninstall. There is one
// non-file operation to be performed, registry revisions.
dwStepCount = 1L; } // currently selected?
dwStepCount = 1L; } else { // There was no selection state transition, therefore there
// are zero non-file operations to be performed.
dwStepCount = 0L; } // selection state transition?
} else { // This is GUI mode setup. The two operations that may be performed
// during GUI mode setup are clean install and upgrade. In neither
// case does cluscfg.exe get launched. Thus, there is one non-file
// operation to be performed, registry revisions.
dwStepCount = 1L; } // interactive: standalone or atttended?
} // Is this UNATTENDED or ATTENDED?
return ( dwStepCount );}
/////////////////////////////////////////////////////////////////////////////
//++
//
// SetStepCount
//
// Routine Description:
// This function sets the value of the m_dwStepCount member of the CClusocmApp object.
//
// Arguments:
// dwStepCount - the value to which the m_dwStepCount member should be set.
//
// Return Value:
// None
//
//--
/////////////////////////////////////////////////////////////////////////////
void CClusocmApp::SetStepCount( DWORD dwStepCount ){ m_dwStepCount = dwStepCount;}
/////////////////////////////////////////////////////////////////////////////
//++
//
// GetStepCount
//
// Routine Description:
// This function returns the content of the m_dwStepCount member of the
// CClusocmApp object.
//
// Arguments:
// None
//
// Return Value:
// The content of the m_dwStepCount member.
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CClusocmApp::GetStepCount( void ){ return ( m_dwStepCount );}
|
