////////////////////////////////////////////////////////////////////////////// // // Copyright (c) 2000 Microsoft Corporation // // Module Name: // ClusComp.cpp // // Description: // This file implements that function that is called by WinNT32.exe before // an upgrade to ensure that no incompatibilities occur as a result of the // upgrade. For example, in a cluster of two NT4 nodes, one node cannot // be upgraded to Whistler while the other is still at NT4. The user is // warned about such problems by this function. // // NOTE: This function is called by WinNT32.exe on the OS *before* an // upgrade. If OS version X is being upgraded to OS version X+1, then // the X+1 verion of this DLL is loaded on OS version X. To make sure // that this DLL can function properly in an downlevel OS, it is linked // against only the indispensible libraries. // // Header File: // There is no header file for this source file. // // Maintained By: // Vij Vasu (Vvasu) 25-JUL-2000 // Created the original version. // ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // Include Files ////////////////////////////////////////////////////////////////////////////// // Precompiled header for this DLL #include "pch.h" // For the compatibility check function and types #include // For the cluster API #include // For the names of several cluster service related registry keys and values #include "clusudef.h" ////////////////////////////////////////////////////////////////////////////// // Forward declarations ////////////////////////////////////////////////////////////////////////////// DWORD DwIsClusterServiceRegistered( bool & rfIsRegisteredOut ); DWORD DwLoadString( UINT nStringIdIn, WCHAR *& rpszDestOut ); DWORD DwWriteOSVersionInfo( const OSVERSIONINFO & rcosviOSVersionInfoIn ); ////////////////////////////////////////////////////////////////////////////// //++ // // extern "C" // BOOL // ClusterUpgradeCompatibilityCheck() // // Description: // This function is called by WinNT32.exe before an upgrade to ensure that // no incompatibilities occur as a result of the upgrade. For example, // in a cluster of two NT4 nodes, one node cannot be upgraded to Whistler // while the other is still at NT4. // // Arguments: // PCOMPAIBILITYCALLBACK pfnCompatibilityCallbackIn // Points to the callback function used to supply compatibility // information to WinNT32.exe // // LPVOID pvContextIn // Pointer to the context buffer supplied by WinNT32.exe // // Return Value: // TRUE if there were no errors or no compatibility problems. // FALSE otherwise. // //-- ////////////////////////////////////////////////////////////////////////////// extern "C" BOOL ClusterUpgradeCompatibilityCheck( PCOMPAIBILITYCALLBACK pfnCompatibilityCallbackIn , LPVOID pvContextIn ) { TraceFunc( "" ); LogMsg( "Entering function " __FUNCTION__ "()" ); BOOL fReturnValue = TRUE; bool fWarningRequired = true; DWORD dwError = ERROR_SUCCESS; do { typedef CSmartResource< CHandleTrait< HCLUSTER, BOOL, CloseCluster > > SmartClusterHandle; OSVERSIONINFO osviOSVersionInfo; SmartClusterHandle schClusterHandle; DWORD cchBufferSize = 256; osviOSVersionInfo.dwOSVersionInfoSize = sizeof( osviOSVersionInfo ); // // First of all, get and store the OS version info into the registry. // // Cannot call VerifyVerionInfo as this requires Win2k. if ( GetVersionEx( &osviOSVersionInfo ) == FALSE ) { // We could not get OS version info. // Show the warning, just in case. dwError = TW32( GetLastError() ); TraceFlow1( "Error %#x occurred trying to get the OS version info.", dwError ); LogMsg( "Error %#x occurred trying to get the OS version info.", dwError ); break; } // if: GetVersionEx() failed // Write the OS version info to the registry. This data will be used later by ClusOCM // to figure out which OS version we are upgrading from. dwError = TW32( DwWriteOSVersionInfo( osviOSVersionInfo ) ); if ( dwError != ERROR_SUCCESS ) { TraceFlow1( "Error %#x occurred trying to store the OS version info. This is not a fatal error.", dwError ); LogMsg( "Error %#x occurred trying to store the OS version info. This is not a fatal error.", dwError ); // This is not a fatal error. So reset the error code. dwError = ERROR_SUCCESS; } // if: there was an error writing the OS version info else { TraceFlow( "The OS version info was successfully written to the registry." ); } // else: the OS version info was successfully written to the registry // Check if the cluster service is registered. dwError = TW32( DwIsClusterServiceRegistered( fWarningRequired ) ); if ( dwError != ERROR_SUCCESS ) { // We could not get the state of the cluster service // Show the warning, just in case. TraceFlow1( "Error %#x occurred trying to check if the cluster service is registered.", dwError ); LogMsg( "Error %#x occurred trying to check if the cluster service is registered.", dwError ); break; } // if: DwIsClusterServiceRegistered() returned an error if ( !fWarningRequired ) { // If the cluster service was not registered, no warning is needed. TraceFlow( "The cluster service is not registered." ); LogMsg( "The cluster service is not registered." ); break; } // if: no warning is required TraceFlow( "The cluster service is registered. Checking the node versions." ); LogMsg( "The cluster service is registered. Checking the node versions." ); // Check if this is an NT4 node if ( osviOSVersionInfo.dwMajorVersion < 5 ) { TraceFlow( "This is an NT4 node." ); LogMsg( "This is an NT4 node." ); fWarningRequired = true; break; } // if: this is an NT4 node TraceFlow( "This is not an NT4 node." ); // Check if the OS version is Whistler or if it is a non-NT OS if ( ( osviOSVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT ) || ( ( osviOSVersionInfo.dwMajorVersion >= 5 ) && ( osviOSVersionInfo.dwMinorVersion >= 1 ) ) ) { // If the OS not of the NT family or if the OS version of this // node is Whistler or greater, no warning is required. TraceFlow2( "The version of the OS on this node is %d.%d. So, this is Windows Whister or later (or is not running NT)." , osviOSVersionInfo.dwMajorVersion , osviOSVersionInfo.dwMinorVersion ); TraceFlow( "No NT4 nodes can exist in this cluster." ); LogMsg( "The version of the OS on this node is Windows Whister or later (or is not running NT)." ); LogMsg( "No NT4 nodes can exist in this cluster." ); fWarningRequired = false; break; } // if: the OS is not NT or if it is Win2k or greater TraceFlow( "This is not a Whistler node - this has to be a Windows 2000 node." ); TraceFlow( "Trying to check if there are any NT4 nodes in the cluster." ); // // Get the cluster version information // // Open a handle to the local cluster schClusterHandle.Assign( OpenCluster( NULL ) ); if ( schClusterHandle.HHandle() == NULL ) { // Show the warning, just to be safe. dwError = TW32( GetLastError() ); TraceFlow1( "Error %#x occurred trying to get a handle to the cluster.", dwError ); LogMsg( "Error %#x occurred trying to get information about the cluster.", dwError ); break; } // if: we could not get the cluster handle TraceFlow( "OpenCluster() was successful." ); // Get the cluster version info do { // Allocate the buffer - this memory is automatically freed when this object // goes out of scope ( or during the next iteration ). SmartSz sszClusterName( new WCHAR[ cchBufferSize ] ); CLUSTERVERSIONINFO cviClusterVersionInfo; if ( sszClusterName.FIsEmpty() ) { dwError = TW32( ERROR_NOT_ENOUGH_MEMORY ); TraceFlow1( "Error %#x occurred while allocating a buffer for the cluster name.", dwError ); LogMsg( "Error %#x occurred while allocating a buffer for the cluster name.", dwError ); break; } // if: memory allocation failed TraceFlow( "Memory for the cluster name has been allocated." ); cviClusterVersionInfo.dwVersionInfoSize = sizeof( cviClusterVersionInfo ); dwError = GetClusterInformation( schClusterHandle.HHandle() , sszClusterName.PMem() , &cchBufferSize , &cviClusterVersionInfo ); if ( dwError == ERROR_SUCCESS ) { // A warning is required if this node version is less than Win2k or // if there is a node in the cluster whose version is less than Win2k // NOTE: cviClusterVersionInfo.MajorVersion is the OS version // while cviClusterVersionInfo.dwClusterHighestVersion is the cluster version. fWarningRequired = ( ( cviClusterVersionInfo.MajorVersion < 5 ) || ( CLUSTER_GET_MAJOR_VERSION( cviClusterVersionInfo.dwClusterHighestVersion ) < NT5_MAJOR_VERSION ) ); if ( fWarningRequired ) { TraceFlow( "There is at least one node in the cluster whose OS version is earlier than Windows 2000." ); LogMsg( "There is at least one node in the cluster whose OS version is earlier than Windows 2000." ); } // if: a warning will be shown else { TraceFlow( "The OS versions of all the nodes in the cluster are Windows 2000 or later." ); LogMsg( "The OS versions of all the nodes in the cluster are Windows 2000 or later." ); } // else: a warning will not be shown break; } // if: we got the cluster version info else { if ( dwError == ERROR_MORE_DATA ) { // Insufficient buffer - try again ++cchBufferSize; dwError = ERROR_SUCCESS; TraceFlow1( "The buffer size is insufficient. Need %d bytes. Reallocating.", cchBufferSize ); continue; } // if: the size of the buffer was insufficient // If we are here, something has gone wrong - show the warning TW32( dwError ); TraceFlow1( "Error %#x occurred trying to get cluster information.", dwError ); LogMsg( "Error %#x occurred trying to get cluster information.", dwError ); break; } // else: we could not get the cluster version info } while( true ); // loop infinitely // We are done. break; } while( false ); // Dummy do-while loop to avoid gotos while ( fWarningRequired ) { SmartSz sszWarningTitle; COMPATIBILITY_ENTRY ceCompatibilityEntry; TraceFlow( "The compatibility warning is required." ); LogMsg( "The compatibility warning is required." ); { WCHAR * pszWarningTitle = NULL; dwError = TW32( DwLoadString( IDS_ERROR_UPGRADE_OTHER_NODES, pszWarningTitle ) ); if ( dwError != ERROR_SUCCESS ) { // We cannot show the warning TraceFlow1( "Error %#x occurred trying to load the warning string.", dwError ); LogMsg( "Error %#x occurred trying to show the warning.", dwError ); break; } // if: the load string failed sszWarningTitle.Assign( pszWarningTitle ); } // // Call the callback function // ceCompatibilityEntry.Description = sszWarningTitle.PMem(); ceCompatibilityEntry.HtmlName = L"CompData\\ClusComp.htm"; ceCompatibilityEntry.TextName = L"CompData\\ClusComp.txt"; ceCompatibilityEntry.RegKeyName = NULL; ceCompatibilityEntry.RegValName = NULL ; ceCompatibilityEntry.RegValDataSize = 0; ceCompatibilityEntry.RegValData = NULL; ceCompatibilityEntry.SaveValue = NULL; ceCompatibilityEntry.Flags = 0; ceCompatibilityEntry.InfName = NULL; ceCompatibilityEntry.InfSection = NULL; TraceFlow( "About to call the compatibility callback function." ); // This function returns TRUE if the compatibility warning data was successfully set. fReturnValue = pfnCompatibilityCallbackIn( &ceCompatibilityEntry, pvContextIn ); TraceFlow1( "The compatibility callback function returned %d.", fReturnValue ); break; } // while: we need to show the warning if ( !fWarningRequired ) { TraceFlow( "The compatibility warning need not be shown." ); LogMsg( "The compatibility warning need not be shown." ); } // if: we did not need to show the warning LogMsg( "Exiting function ClusterUpgradeCompatibilityCheck(). Return value is %d.", fReturnValue ); RETURN( fReturnValue ); } //*** ClusterUpgradeCompatibilityCheck() ///////////////////////////////////////////////////////////////////////////// //++ // // DWORD // DwIsClusterServiceRegistered() // // Description: // This function determines whether the Cluster Service has been registered // with the Service Control Manager or not. It is not possible to use the // GetNodeClusterState() API to see if this node is a member of a cluster // or not, since this API was not available on NT4 SP3. // // Arguments: // bool & rfIsRegisteredOut // If true, Cluster Service (ClusSvc) is registered with the Service // Control Manager (SCM). Else, Cluster Service (ClusSvc) is not // registered with SCM // // Return Value: // ERROR_SUCCESS if all went well. // Other Win32 error codes on failure. // //-- ///////////////////////////////////////////////////////////////////////////// DWORD DwIsClusterServiceRegistered( bool & rfIsRegisteredOut ) { TraceFunc( "" ); DWORD dwError = ERROR_SUCCESS; // Initialize the output rfIsRegisteredOut = false; // dummy do-while loop to avoid gotos do { // Instantiate the SmartServiceHandle smart handle class. typedef CSmartResource< CHandleTrait< SC_HANDLE, BOOL, CloseServiceHandle, NULL > > SmartServiceHandle; // Connect to the Service Control Manager SmartServiceHandle shServiceMgr( OpenSCManager( NULL, NULL, GENERIC_READ ) ); // Was the service control manager database opened successfully? if ( shServiceMgr.HHandle() == NULL ) { dwError = TW32( GetLastError() ); TraceFlow1( "Error %#x occurred trying open a handle to the service control manager.", dwError ); LogMsg( "Error %#x occurred trying open a handle to the service control manager.", dwError ); break; } // if: opening the SCM was unsuccessful // Open a handle to the Cluster Service. SmartServiceHandle shService( OpenService( shServiceMgr, L"ClusSvc", GENERIC_READ ) ); // Was the handle to the service opened? if ( shService.HHandle() != NULL ) { TraceFlow( "Successfully opened a handle to the cluster service. Therefore, it is registered." ); rfIsRegisteredOut = true; break; } // if: handle to clussvc could be opened dwError = GetLastError(); if ( dwError == ERROR_SERVICE_DOES_NOT_EXIST ) { TraceFlow( "The cluster service is not registered." ); dwError = ERROR_SUCCESS; break; } // if: the handle could not be opened because the service did not exist. // If we are here, then some error occurred. TW32( dwError ); TraceFlow1( "Error %#x occurred trying open a handle to the cluster service.", dwError ); LogMsg( "Error %#x occurred trying open a handle to the cluster service.", dwError ); // Handles are closed by the CSmartHandle destructor. } while ( false ); // dummy do-while loop to avoid gotos RETURN( dwError ); } //*** DwIsClusterServiceRegistered() ////////////////////////////////////////////////////////////////////////////// //++ // // DwLoadString() // // Description: // Allocate memory for and load a string from the string table. // // Arguments: // uiStringIdIn // Id of the string to look up // // rpszDestOut // Reference to the pointer that will hold the address of the // loaded string. The memory will have to be freed by the caller // by using the delete operator. // // Return Value: // S_OK // If the call succeeded // // Other Win32 error codes // If the call failed. // // Remarks: // This function cannot load a zero length string. //-- ////////////////////////////////////////////////////////////////////////////// DWORD DwLoadString( UINT nStringIdIn , WCHAR *& rpszDestOut ) { TraceFunc( "" ); DWORD dwError = ERROR_SUCCESS; UINT uiCurrentSize = 0; SmartSz sszCurrentString; UINT uiReturnedStringLen = 0; // Initialize the output. rpszDestOut = NULL; do { // Grow the current string by an arbitrary amount. uiCurrentSize += 256; sszCurrentString.Assign( new WCHAR[ uiCurrentSize ] ); if ( sszCurrentString.FIsEmpty() ) { dwError = TW32( ERROR_NOT_ENOUGH_MEMORY ); TraceFlow2( "Error %#x occurred trying allocate memory for string (string id is %d).", dwError, nStringIdIn ); LogMsg( "Error %#x occurred trying allocate memory for string (string id is %d).", dwError, nStringIdIn ); break; } // if: the memory allocation has failed uiReturnedStringLen = ::LoadString( g_hInstance , nStringIdIn , sszCurrentString.PMem() , uiCurrentSize ); if ( uiReturnedStringLen == 0 ) { dwError = TW32( GetLastError() ); TraceFlow2( "Error %#x occurred trying load string (string id is %d).", dwError, nStringIdIn ); LogMsg( "Error %#x occurred trying load string (string id is %d).", dwError, nStringIdIn ); break; } // if: LoadString() had an error ++uiReturnedStringLen; } while( uiCurrentSize <= uiReturnedStringLen ); if ( dwError == ERROR_SUCCESS ) { // Detach the smart pointer from the string, so that it is not freed by this function. // Store the string pointer in the output. rpszDestOut = sszCurrentString.PRelease(); } // if: there were no errors in this function else { rpszDestOut = NULL; } // else: something went wrong RETURN( dwError ); } //*** DwLoadString() ///////////////////////////////////////////////////////////////////////////// //++ // // DWORD // DwWriteOSVersionInfo() // // Description: // This function writes the OS major and minor version information into the // registry. This information will be used later by ClusOCM to determine the // OS version before the upgrade. // // Arguments: // const OSVERSIONINFO & rcosviOSVersionInfoIn // Reference to the OSVERSIONINFO structure that has information about the // OS version of this node. // // Return Value: // ERROR_SUCCESS if all went well. // Other Win32 error codes on failure. // //-- ///////////////////////////////////////////////////////////////////////////// DWORD DwWriteOSVersionInfo( const OSVERSIONINFO & rcosviOSVersionInfoIn ) { TraceFunc( "" ); DWORD dwError = ERROR_SUCCESS; // dummy do-while loop to avoid gotos do { // Instantiate the SmartRegistryKey smart handle class. typedef CSmartResource< CHandleTrait< HKEY, LONG, RegCloseKey, NULL > > SmartRegistryKey; SmartRegistryKey srkOSInfoKey; { HKEY hTempKey = NULL; // Open the node version info registry key dwError = TW32( RegCreateKeyEx( HKEY_LOCAL_MACHINE , CLUSREG_KEYNAME_NODE_DATA L"\\" CLUSREG_KEYNAME_PREV_OS_INFO , 0 , L"" , REG_OPTION_NON_VOLATILE , KEY_ALL_ACCESS , NULL , &hTempKey , NULL ) ); if ( dwError != ERROR_SUCCESS ) { TraceFlow1( "Error %#x occurred trying create the registry key where the node OS info is stored.", dwError ); LogMsg( "Error %#x occurred trying create the registry key where the node OS info is stored.", dwError ); break; } // if: RegCreateKeyEx() failed srkOSInfoKey.Assign( hTempKey ); } // Write the OS major version dwError = TW32( RegSetValueEx( srkOSInfoKey.HHandle() , CLUSREG_NAME_NODE_MAJOR_VERSION , 0 , REG_DWORD , reinterpret_cast< const BYTE * >( &rcosviOSVersionInfoIn.dwMajorVersion ) , sizeof( rcosviOSVersionInfoIn.dwMajorVersion ) ) ); if ( dwError != ERROR_SUCCESS ) { TraceFlow1( "Error %#x occurred trying to store the OS major version info.", dwError ); LogMsg( "Error %#x occurred trying to store the OS major version info.", dwError ); break; } // if: RegSetValueEx() failed while writing rcosviOSVersionInfoIn.dwMajorVersion // Write the OS minor version dwError = TW32( RegSetValueEx( srkOSInfoKey.HHandle() , CLUSREG_NAME_NODE_MINOR_VERSION , 0 , REG_DWORD , reinterpret_cast< const BYTE * >( &rcosviOSVersionInfoIn.dwMinorVersion ) , sizeof( rcosviOSVersionInfoIn.dwMinorVersion ) ) ); if ( dwError != ERROR_SUCCESS ) { TraceFlow1( "Error %#x occurred trying to store the OS minor version info.", dwError ); LogMsg( "Error %#x occurred trying to store the OS minor version info.", dwError ); break; } // if: RegSetValueEx() failed while writing rcosviOSVersionInfoIn.dwMinorVersion TraceFlow( "OS version information successfully stored in the registry." ); LogMsg( "OS version information successfully stored in the registry." ); } while ( false ); // dummy do-while loop to avoid gotos RETURN( dwError ); } //*** DwWriteOSVersionInfo()