mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6142 lines
218 KiB
6142 lines
218 KiB
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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 );
|
|
}
|