able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/resdll/common/svc.c

2094 lines
55 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1992-1999 Microsoft Corporation
Module Name:
gensvc.c
Abstract:
Resource DLL to control and monitor NT services.
Author:
Robs 3/28/96, based on RodGa's generic resource dll
Revision History:
--*/
#define UNICODE 1
#include "clusres.h"
#include "clusrtl.h"
#include "svc.h"
#include "localsvc.h"
#include "wincrypt.h"
#define DBG_PRINT printf
typedef struct _COMMON_RESOURCE {
#ifdef COMMON_PARAMS_DEFINED
COMMON_PARAMS Params;
#endif
HRESOURCE hResource;
HANDLE ServiceHandle;
RESOURCE_HANDLE ResourceHandle;
HKEY ResourceKey;
HKEY ParametersKey;
CLUS_WORKER PendingThread;
BOOL Online;
DWORD dwServicePid;
} COMMON_RESOURCE, * PCOMMON_RESOURCE;
//
// Global Data
//
// Handle to service controller, set by the first create resource call.
static SC_HANDLE g_ScHandle = NULL;
// Log Event Routine
#define g_LogEvent ClusResLogEvent
#define g_SetResourceStatus ClusResSetResourceStatus
#ifdef COMMON_SEMAPHORE
static HANDLE CommonSemaphore;
static PCOMMON_RESOURCE CommonResource;
#endif
#ifndef CRYPTO_VALUE_COUNT
static DWORD CryptoSyncCount = 0;
static LPWSTR CryptoSync[1] = {NULL};
#endif
#ifndef DOMESTIC_CRYPTO_VALUE_COUNT
static DWORD DomesticCryptoSyncCount = 0;
static LPWSTR DomesticCryptoSync[1] = {NULL};
#endif
//
// Forward routines
//
static
DWORD
CommonOnlineThread(
IN PCLUS_WORKER pWorker,
IN PCOMMON_RESOURCE ResourceEntry
);
DWORD
CommonOfflineThread(
PCLUS_WORKER pWorker,
IN PCOMMON_RESOURCE ResourceEntry
);
static
BOOL
CommonVerifyService(
IN RESID ResourceId,
IN BOOL IsAliveFlag
);
static
DWORD
SvcpTerminateServiceProcess(
IN PCOMMON_RESOURCE pResourceEntry,
IN BOOL bOffline,
OUT PDWORD pdwResourceState
);
#ifdef COMMON_ONLINE_THREAD
#define COMMON_ONLINE_THREAD_ROUTINE COMMON_ONLINE_THREAD
#else
#define COMMON_ONLINE_THREAD_ROUTINE CommonOnlineThread
#endif
//
// Local Routines
//
#ifndef COMMON_ONLINE_THREAD
static
DWORD
CommonOnlineThread(
IN PCLUS_WORKER pWorker,
IN PCOMMON_RESOURCE ResourceEntry
)
/*++
Routine Description:
Brings a disk resource online.
Arguments:
Worker - Supplies the worker structure
ResourceEntry - A pointer to the resource entry for this resource.
Returns:
ERROR_SUCCESS if successful.
Win32 error code on failure.
--*/
{
SERVICE_STATUS_PROCESS ServiceStatus;
DWORD status = ERROR_SUCCESS;
RESOURCE_STATUS resourceStatus;
DWORD valueSize;
PVOID pvEnvironment = NULL;
HKEY hkeyServicesKey;
HKEY hkeyServiceName;
DWORD cbBytesNeeded;
DWORD prevCheckPoint = 0;
DWORD idx;
LPSERVICE_FAILURE_ACTIONS pSvcFailureActions = NULL;
LPQUERY_SERVICE_CONFIG lpquerysvcconfig=NULL;
RESOURCE_EXIT_STATE exitState;
ResUtilInitializeResourceStatus( &resourceStatus );
resourceStatus.ResourceState = ClusterResourceFailed;
resourceStatus.CheckPoint = 1;
if ( ResourceEntry != CommonResource ) {
return(ERROR_SUCCESS);
}
//set it to NULL, when it is brought online and if the
//service is not running in the system or lsa process
//then store the process id for forced termination
ResourceEntry->dwServicePid = 0;
#if ENVIRONMENT
//
// Create the new environment with the simulated net name when the
// services queries GetComputerName.
//
pvEnvironment = ResUtilGetEnvironmentWithNetName( ResourceEntry->hResource );
if ( pvEnvironment != NULL ) {
WCHAR * pszEnvString;
//
// Compute the size of the environment. We are looking for
// the double NULL terminator that ends the environment block.
//
pszEnvString = (WCHAR *)pvEnvironment;
while (*pszEnvString) {
while (*pszEnvString++) {
}
}
valueSize = (DWORD)((PUCHAR)pszEnvString - (PUCHAR)pvEnvironment) + sizeof(WCHAR);
}
//
// Set the environment value in the service's registry key.
//
status = RegOpenKeyExW( HKEY_LOCAL_MACHINE,
LOCAL_SERVICES,
0,
KEY_READ,
&hkeyServicesKey );
if ( status != ERROR_SUCCESS ) {
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to open services key, error = %1!u!.\n",
status );
goto error_exit;
}
status = RegOpenKeyExW( hkeyServicesKey,
SERVICE_NAME,
0,
KEY_READ | KEY_WRITE,
&hkeyServiceName );
RegCloseKey( hkeyServicesKey );
if ( status != ERROR_SUCCESS ) {
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to open service key, error = %1!u!.\n",
status );
goto error_exit;
}
status = RegSetValueExW( hkeyServiceName,
L"Environment",
0,
REG_MULTI_SZ,
pvEnvironment,
valueSize );
RegCloseKey( hkeyServiceName );
if ( status != ERROR_SUCCESS ) {
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to set service environment value, error = %1!u!.\n",
status );
goto error_exit;
}
#endif //ENVIRONMENT
//
// Now open the requested service
//
ResourceEntry->ServiceHandle = OpenService( g_ScHandle,
SERVICE_NAME,
SERVICE_ALL_ACCESS );
if ( ResourceEntry->ServiceHandle == NULL ) {
status = GetLastError();
ClusResLogSystemEventByKeyData( ResourceEntry->ResourceKey,
LOG_CRITICAL,
RES_GENSVC_OPEN_FAILED,
sizeof(status),
&status );
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to open service, error = %1!u!.\n",
status );
goto error_exit;
}
valueSize = sizeof(QUERY_SERVICE_CONFIG);
AllocSvcConfig:
// Query the service to make sure it is not disabled
lpquerysvcconfig = (LPQUERY_SERVICE_CONFIG)LocalAlloc( LMEM_FIXED, valueSize );
if ( lpquerysvcconfig == NULL ){
status = GetLastError();
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"[Svc] Failed to allocate memory for query_service_config, error = %1!u!.\n",
status );
goto error_exit;
}
if ( ! QueryServiceConfig(
ResourceEntry->ServiceHandle,
lpquerysvcconfig,
valueSize,
&cbBytesNeeded ) )
{
status=GetLastError();
if (status != ERROR_INSUFFICIENT_BUFFER){
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"svc: Failed to query service configuration, error= %1!u!.\n",
status );
goto error_exit;
}
status=ERROR_SUCCESS;
LocalFree( lpquerysvcconfig );
lpquerysvcconfig=NULL;
valueSize = cbBytesNeeded;
goto AllocSvcConfig;
}
if ( lpquerysvcconfig->dwStartType == SERVICE_DISABLED )
{
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"svc:The service is DISABLED\n");
status=ERROR_SERVICE_DISABLED;
goto error_exit;
}
//
// Make sure service is set to manual start.
//
ChangeServiceConfig( ResourceEntry->ServiceHandle,
SERVICE_NO_CHANGE,
SERVICE_DEMAND_START, // Manual start
SERVICE_NO_CHANGE,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL );
// Use valuesize as the dummy buffer since the queryserviceconfig2
// api is not that friendly.
// If any of the service action is set to service restart, set it to
// none
if ( ! (QueryServiceConfig2(
ResourceEntry->ServiceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS,
(LPBYTE)&valueSize,
sizeof(DWORD),
&cbBytesNeeded )) )
{
status = GetLastError();
if ( status != ERROR_INSUFFICIENT_BUFFER )
{
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"svc: Failed to query service configuration for size, error= %1!u!.\n",
status );
goto error_exit;
}
else
status = ERROR_SUCCESS;
}
pSvcFailureActions = (LPSERVICE_FAILURE_ACTIONS)LocalAlloc( LMEM_FIXED, cbBytesNeeded );
if ( pSvcFailureActions == NULL ) {
status = GetLastError();
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to allocate memory of size %1!u!, error = %2!u!.\n",
cbBytesNeeded,
status );
goto error_exit;
}
if ( ! (QueryServiceConfig2(
ResourceEntry->ServiceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS,
(LPBYTE)pSvcFailureActions,
cbBytesNeeded,
&cbBytesNeeded )) )
{
status = GetLastError();
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"svc:Failed to query service configuration, error = %1!u!.\n",
status );
goto error_exit;
}
for ( idx=0; idx < pSvcFailureActions->cActions; idx++ )
{
if ( pSvcFailureActions->lpsaActions[idx].Type == SC_ACTION_RESTART ) {
pSvcFailureActions->lpsaActions[idx].Type = SC_ACTION_NONE;
}
}
ChangeServiceConfig2(
ResourceEntry->ServiceHandle,
SERVICE_CONFIG_FAILURE_ACTIONS,
pSvcFailureActions );
#ifdef COMMON_ONLINE_THREAD_CALLBACK
//
// Allow the resource DLL to perform some operations before the service
// is started, such as setting registry keys, etc.
//
status = CommonOnlineThreadCallback( ResourceEntry );
if ( status != ERROR_SUCCESS ) {
goto error_exit;
}
#endif // COMMON_ONLINE_THREAD_CALLBACK
if ( ! StartServiceW(
ResourceEntry->ServiceHandle,
0,
NULL ) ) {
status = GetLastError();
if (status != ERROR_SERVICE_ALREADY_RUNNING) {
ClusResLogSystemEventByKeyData( ResourceEntry->ResourceKey,
LOG_CRITICAL,
RES_GENSVC_START_FAILED,
sizeof(status),
&status );
(g_LogEvent)(ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to start %1!ws! service. Error: %2!u!.\n",
SERVICE_NAME,
status );
goto error_exit;
} else {
status = ERROR_SUCCESS;
}
}
resourceStatus.ResourceState = ClusterResourceOnlinePending;
while ( ! ClusWorkerCheckTerminate( &ResourceEntry->PendingThread ) ) {
if ( ! QueryServiceStatusEx(
ResourceEntry->ServiceHandle,
SC_STATUS_PROCESS_INFO,
(LPBYTE)&ServiceStatus,
sizeof(SERVICE_STATUS_PROCESS),
&cbBytesNeeded ) ) {
status = GetLastError();
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Query Service Status failed %1!u!.\n",
status );
resourceStatus.ResourceState = ClusterResourceFailed;
goto error_exit;
}
if ( ServiceStatus.dwCurrentState != SERVICE_START_PENDING ) {
break;
}
if ( prevCheckPoint != ServiceStatus.dwCheckPoint ) {
prevCheckPoint = ServiceStatus.dwCheckPoint;
++resourceStatus.CheckPoint;
}
exitState = (g_SetResourceStatus)(
ResourceEntry->ResourceHandle,
&resourceStatus );
if ( exitState == ResourceExitStateTerminate ) {
break;
}
Sleep( 500 ); // Sleep for 1/2 second
}
//
// Assume that we failed.
//
resourceStatus.ResourceState = ClusterResourceFailed;
//
// If we exited the loop before setting ServiceStatus, then return now.
//
if ( ClusWorkerCheckTerminate( &ResourceEntry->PendingThread ) ) {
goto error_exit;
}
if ( ServiceStatus.dwCurrentState != SERVICE_RUNNING ) {
if ( ServiceStatus.dwWin32ExitCode == ERROR_SERVICE_SPECIFIC_ERROR ) {
status = ServiceStatus.dwServiceSpecificExitCode;
} else {
status = ServiceStatus.dwWin32ExitCode;
}
ClusResLogSystemEventByKeyData(ResourceEntry->ResourceKey,
LOG_CRITICAL,
RES_GENSVC_FAILED_AFTER_START,
sizeof(status),
&status);
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_ERROR,
L"Service failed during initialization. Error: %1!u!.\n",
status );
goto error_exit;
}
resourceStatus.ResourceState = ClusterResourceOnline;
if ( ! (ServiceStatus.dwServiceFlags & SERVICE_RUNS_IN_SYSTEM_PROCESS) ) {
ResourceEntry->dwServicePid = ServiceStatus.dwProcessId;
}
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service is now on line.\n" );
error_exit:
(g_SetResourceStatus)( ResourceEntry->ResourceHandle,
&resourceStatus );
if ( resourceStatus.ResourceState == ClusterResourceOnline ) {
ResourceEntry->Online = TRUE;
} else {
ResourceEntry->Online = FALSE;
}
if(lpquerysvcconfig)
LocalFree(lpquerysvcconfig);
if (pSvcFailureActions)
LocalFree(pSvcFailureActions);
#if ENVIRONMENT
if ( pvEnvironment != NULL ) {
RtlDestroyEnvironment( pvEnvironment );
}
#endif
return(status);
} // CommonOnlineThread
#endif
static
RESID
WINAPI
CommonOpen(
IN LPCWSTR ResourceName,
IN HKEY ResourceKey,
IN RESOURCE_HANDLE ResourceHandle
)
/*++
Routine Description:
Open routine for generic service resource.
This routine gets a handle to the service controller, if we don't already have one,
and then gets a handle to the specified service. The service handle is saved
in the COMMON structure.
Arguments:
ResourceName - supplies the resource name
ResourceKey - supplies a handle to the resource's cluster registry key
ResourceHandle - the resource handle to be supplied with SetResourceStatus
is called.
Return Value:
RESID of created resource
Zero on failure
--*/
{
RESID svcResid = 0;
DWORD status;
HKEY parametersKey = NULL;
HKEY resKey = NULL;
PCOMMON_RESOURCE resourceEntry = NULL;
DWORD paramNameSize = 0;
DWORD paramNameMaxSize = 0;
HCLUSTER hCluster;
DWORD returnSize;
DWORD idx;
//
// Open registry parameters key for this resource.
//
status = ClusterRegOpenKey( ResourceKey,
L"Parameters",
KEY_READ,
&parametersKey );
if ( status != NO_ERROR ) {
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Unable to open parameters key. Error: %1!u!.\n",
status);
goto error_exit;
}
//
// Get a handle to our resource key so that we can get our name later
// if we need to log an event.
//
status = ClusterRegOpenKey( ResourceKey,
L"",
KEY_READ,
&resKey );
if ( status != ERROR_SUCCESS ) {
(g_LogEvent)(ResourceHandle,
LOG_ERROR,
L"Unable to open resource key. Error: %1!u!.\n",
status );
goto error_exit;
}
//
// First get a handle to the service controller.
//
if ( g_ScHandle == NULL ) {
g_ScHandle = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS);
if ( g_ScHandle == NULL ) {
status = GetLastError();
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Failed to open service control manager, error = %1!u!.\n",
status);
goto error_exit;
}
}
resourceEntry = LocalAlloc( LMEM_FIXED, sizeof(COMMON_RESOURCE) );
if ( resourceEntry == NULL ) {
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Failed to allocate a service info structure.\n");
status = ERROR_NOT_ENOUGH_MEMORY;
goto error_exit;
}
ZeroMemory( resourceEntry, sizeof(COMMON_RESOURCE) );
resourceEntry->ResourceHandle = ResourceHandle;
resourceEntry->ResourceKey = resKey;
resourceEntry->ParametersKey = parametersKey;
hCluster = OpenCluster(NULL);
if ( hCluster == NULL ) {
status = GetLastError();
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Failed to open cluster, error %1!u!.\n",
status );
goto error_exit;
}
resourceEntry->hResource = OpenClusterResource( hCluster, ResourceName );
status = GetLastError();
CloseCluster( hCluster );
if ( resourceEntry->hResource == NULL ) {
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Failed to open resource, error %1!u!.\n",
status );
goto error_exit;
}
//
// Set any registry checkpoints that we need.
//
if ( RegSyncCount != 0 ) {
returnSize = 0;
//
// Set registry sync keys if we need them.
//
for ( idx = 0; idx < RegSyncCount; idx++ ) {
status = ClusterResourceControl( resourceEntry->hResource,
NULL,
CLUSCTL_RESOURCE_ADD_REGISTRY_CHECKPOINT,
RegSync[idx],
(lstrlenW( RegSync[idx] ) + 1) * sizeof(WCHAR),
NULL,
0,
&returnSize );
if ( status != ERROR_SUCCESS ){
if ( status == ERROR_ALREADY_EXISTS ){
status = ERROR_SUCCESS;
}
else{
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to set registry checkpoint, status %1!u!.\n",
status );
goto error_exit;
}
}
}
}
//
// Set any crypto checkpoints that we need.
//
if ( CryptoSyncCount != 0 ) {
returnSize = 0;
//
// Set registry sync keys if we need them.
//
for ( idx = 0; idx < CryptoSyncCount; idx++ ) {
status = ClusterResourceControl( resourceEntry->hResource,
NULL,
CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT,
CryptoSync[idx],
(lstrlenW( CryptoSync[idx] ) + 1) * sizeof(WCHAR),
NULL,
0,
&returnSize );
if ( status != ERROR_SUCCESS ){
if (status == ERROR_ALREADY_EXISTS){
status = ERROR_SUCCESS;
}
else{
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to set crypto checkpoint, status %1!u!.\n",
status );
goto error_exit;
}
}
}
}
//
// Set any domestic crypto checkpoints that we need.
//
if ( DomesticCryptoSyncCount != 0 ) {
HCRYPTPROV hProv = 0;
//
// check if domestic crypto is available
//
if (CryptAcquireContextA( &hProv,
NULL,
MS_ENHANCED_PROV_A,
PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT)) {
CryptReleaseContext( hProv, 0 );
returnSize = 0;
//
// Set registry sync keys if we need them.
//
for ( idx = 0; idx < DomesticCryptoSyncCount; idx++ ) {
status = ClusterResourceControl( resourceEntry->hResource,
NULL,
CLUSCTL_RESOURCE_ADD_CRYPTO_CHECKPOINT,
DomesticCryptoSync[idx],
(lstrlenW( DomesticCryptoSync[idx] ) + 1) * sizeof(WCHAR),
NULL,
0,
&returnSize );
if ( status != ERROR_SUCCESS ){
if (status == ERROR_ALREADY_EXISTS){
status = ERROR_SUCCESS;
}
else{
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed to set domestic crypto checkpoint, status %1!u!.\n",
status );
goto error_exit;
}
}
}
}
}
#ifdef COMMON_PARAMS_DEFINED
//
// Get any parameters... so we can handle the GET_DEPENDENCIES request.
//
CommonReadParameters( resourceEntry );
// ignore status return
#endif // COMMON_PARAMS_DEFINED
#ifdef COMMON_SEMAPHORE
//
// Check if more than one resource of this type.
//
if ( WaitForSingleObject( CommonSemaphore, 0 ) == WAIT_TIMEOUT ) {
//
// A version of this service is already running
//
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Service is already running.\n");
status = ERROR_SERVICE_ALREADY_RUNNING;
goto error_exit;
}
if ( CommonResource ) {
(g_LogEvent)(
ResourceHandle,
LOG_ERROR,
L"Service resource info non-null!\n");
status = ERROR_DUPLICATE_SERVICE_NAME;
goto error_exit;
}
CommonResource = resourceEntry;
#endif // COMMON_SEMAPHORE
svcResid = (RESID)resourceEntry;
return(svcResid);
error_exit:
LocalFree( resourceEntry );
if ( parametersKey != NULL ) {
ClusterRegCloseKey( parametersKey );
}
if ( resKey != NULL) {
ClusterRegCloseKey( resKey );
}
SetLastError( status );
return((RESID)NULL);
} // CommonOpen
static
DWORD
WINAPI
CommonOnline(
IN RESID ResourceId,
IN OUT PHANDLE EventHandle
)
/*++
Routine Description:
Online routine for Common Service resource.
Arguments:
ResourceId - Supplies resource id to be brought online
EventHandle - Supplies a pointer to a handle to signal on error.
Return Value:
ERROR_SUCCESS if successful.
ERROR_RESOURCE_NOT_FOUND if RESID is not valid.
ERROR_RESOURCE_NOT_AVAILABLE if resource was arbitrated but failed to
acquire 'ownership'.
Win32 error code if other failure.
--*/
{
DWORD status;
PCOMMON_RESOURCE resourceEntry;
resourceEntry = (PCOMMON_RESOURCE)ResourceId;
if ( resourceEntry != CommonResource ) {
DBG_PRINT( "Common: Online request for wrong resource, 0x%p.\n",
ResourceId );
}
if ( resourceEntry == NULL ) {
DBG_PRINT( "Common: Online request for a nonexistent resource id 0x%p.\n",
ResourceId );
return(ERROR_RESOURCE_NOT_FOUND);
}
ClusWorkerTerminate( &resourceEntry->PendingThread );
status = ClusWorkerCreate( &resourceEntry->PendingThread,
COMMON_ONLINE_THREAD_ROUTINE,
resourceEntry );
if ( status == ERROR_SUCCESS ) {
status = ERROR_IO_PENDING;
}
return(status);
} // CommonOnline
static
VOID
WINAPI
CommonTerminate(
IN RESID ResourceId
)
/*++
Routine Description:
Terminate routine for Common Service resource.
Arguments:
ResourceId - Supplies resource id to be terminated
Return Value:
None.
--*/
{
SERVICE_STATUS ServiceStatus;
PCOMMON_RESOURCE resourceEntry;
resourceEntry = (PCOMMON_RESOURCE)ResourceId;
if ( resourceEntry != CommonResource ) {
DBG_PRINT( "Common: Offline request for wrong resource, 0x%p.\n",
ResourceId );
return;
}
if ( resourceEntry == NULL ) {
DBG_PRINT( "Common: Offline request for a nonexistent resource id 0x%p.\n",
ResourceId );
return;
}
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Offline request.\n" );
ClusWorkerTerminate( &resourceEntry->PendingThread );
if ( resourceEntry->ServiceHandle != NULL ) {
DWORD retryTime = 30*1000; // wait 30 secs for shutdown
DWORD retryTick = 300; // 300 msec at a time
DWORD status;
BOOL didStop = FALSE;
for (;;) {
status = (ControlService(
resourceEntry->ServiceHandle,
(didStop
? SERVICE_CONTROL_INTERROGATE
: SERVICE_CONTROL_STOP),
&ServiceStatus )
? NO_ERROR
: GetLastError());
if (status == NO_ERROR) {
didStop = TRUE;
if (ServiceStatus.dwCurrentState == SERVICE_STOPPED) {
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service stopped.\n" );
//set the status
resourceEntry->Online = FALSE;
resourceEntry->dwServicePid = 0;
break;
}
}
//
// Chittur Subbaraman (chitturs) - 2/21/2000
//
// Since SCM doesn't accept any control requests during
// windows shutdown, don't send any more control
// requests. Just exit from this loop and terminate
// the process brute force.
//
if (status == ERROR_SHUTDOWN_IN_PROGRESS)
{
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"System shutdown in progress. Will try to terminate the process...\n");
break;
}
if (status == ERROR_EXCEPTION_IN_SERVICE ||
status == ERROR_PROCESS_ABORTED ||
status == ERROR_SERVICE_NOT_ACTIVE) {
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service died; status = %1!u!.\n",
status);
//set the status
resourceEntry->Online = FALSE;
resourceEntry->dwServicePid = 0;
break;
}
if ((retryTime -= retryTick) <= 0) {
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_ERROR,
L"Service did not stop; giving up.\n" );
break;
}
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Offline: retrying...\n" );
Sleep(retryTick);
}
//if there is a pid for this, try and terminate that process
//note that terminating a process doesnt terminate all
//the child processes
if (resourceEntry->dwServicePid)
{
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SvcTerminate: terminating processid =%1!u!\n",
resourceEntry->dwServicePid);
SvcpTerminateServiceProcess( resourceEntry,
FALSE,
NULL );
}
CloseServiceHandle( resourceEntry->ServiceHandle );
resourceEntry->ServiceHandle = NULL;
resourceEntry->dwServicePid = 0;
}
resourceEntry->Online = FALSE;
} // CommonTerminate
static
DWORD
WINAPI
CommonOffline(
IN RESID ResourceId
)
/*++
Routine Description:
Offline routine for Common Service resource.
Arguments:
ResourceId - Supplies the resource to be taken offline
Return Value:
ERROR_SUCCESS - always successful.
--*/
{
PCOMMON_RESOURCE resourceEntry;
DWORD status;
resourceEntry = (PCOMMON_RESOURCE)ResourceId;
if ( resourceEntry == NULL ) {
DBG_PRINT( "Common: Offline request for a nonexistent resource id 0x%p.\n",
ResourceId );
return(ERROR_RESOURCE_NOT_FOUND);
}
if ( resourceEntry != CommonResource ) {
DBG_PRINT( "Common: Offline request for wrong resource, 0x%p.\n",
ResourceId );
return(ERROR_INVALID_PARAMETER);
}
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Offline request.\n" );
ClusWorkerTerminate( &resourceEntry->PendingThread );
status = ClusWorkerCreate( &resourceEntry->PendingThread,
CommonOfflineThread,
resourceEntry );
if ( status == ERROR_SUCCESS ) {
status = ERROR_IO_PENDING;
}
return(status);
}
static
DWORD
CommonOfflineThread(
PCLUS_WORKER pWorker,
IN PCOMMON_RESOURCE ResourceEntry
)
/*++
Routine Description:
Offline routine for Common Service resource.
Arguments:
ResourceId - Supplies the resource to be taken offline
Return Value:
ERROR_SUCCESS - always successful.
--*/
{
RESOURCE_STATUS resourceStatus;
DWORD retryTick = 300; // 300 msec at a time
DWORD status = ERROR_SUCCESS;
BOOL didStop = FALSE;
SERVICE_STATUS ServiceStatus;
ResUtilInitializeResourceStatus( &resourceStatus );
resourceStatus.ResourceState = ClusterResourceFailed;
//resourceStatus.WaitHint = 0;
resourceStatus.CheckPoint = 1;
//check if the service has gone offline or was never brought online
if ( ResourceEntry->ServiceHandle == NULL )
{
resourceStatus.ResourceState = ClusterResourceOffline;
goto FnExit;
}
//try to stop the cluster service, wait for it to be terminated
//as long as we are not asked to terminate
while (!ClusWorkerCheckTerminate(pWorker)) {
status = (ControlService(
ResourceEntry->ServiceHandle,
(didStop
? SERVICE_CONTROL_INTERROGATE
: SERVICE_CONTROL_STOP),
&ServiceStatus )
? NO_ERROR
: GetLastError());
if (status == NO_ERROR) {
didStop = TRUE;
if (ServiceStatus.dwCurrentState == SERVICE_STOPPED) {
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service stopped.\n" );
//set the status
ResourceEntry->Online = FALSE;
resourceStatus.ResourceState = ClusterResourceOffline;
CloseServiceHandle( ResourceEntry->ServiceHandle );
ResourceEntry->ServiceHandle = NULL;
ResourceEntry->dwServicePid = 0;
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service is now offline.\n" );
break;
}
}
//
// Chittur Subbaraman (chitturs) - 2/21/2000
//
// Since SCM doesn't accept any control requests during
// windows shutdown, don't send any more control
// requests. Just exit from this loop and terminate
// the process brute force.
//
if (status == ERROR_SHUTDOWN_IN_PROGRESS)
{
DWORD dwResourceState;
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"OfflineThread: System shutting down. Attempt to terminate service process %1!u!...\n",
ResourceEntry->dwServicePid );
status = SvcpTerminateServiceProcess( ResourceEntry,
TRUE,
&dwResourceState );
if ( status == ERROR_SUCCESS )
{
CloseServiceHandle( ResourceEntry->ServiceHandle );
ResourceEntry->ServiceHandle = NULL;
ResourceEntry->dwServicePid = 0;
ResourceEntry->Online = FALSE;
}
resourceStatus.ResourceState = dwResourceState;
break;
}
if (status == ERROR_EXCEPTION_IN_SERVICE ||
status == ERROR_PROCESS_ABORTED ||
status == ERROR_SERVICE_NOT_ACTIVE) {
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service died or not active any more; status = %1!u!.\n",
status);
//set the status
ResourceEntry->Online = FALSE;
resourceStatus.ResourceState = ClusterResourceOffline;
CloseServiceHandle( ResourceEntry->ServiceHandle );
ResourceEntry->ServiceHandle = NULL;
ResourceEntry->dwServicePid = 0;
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Service is now offline.\n" );
break;
}
(g_LogEvent)(
ResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Offline: retrying...\n" );
Sleep(retryTick);
}
FnExit:
(g_SetResourceStatus)( ResourceEntry->ResourceHandle,
&resourceStatus );
return(status);
}
// CommonOfflineThread
static
BOOL
WINAPI
CommonIsAlive(
IN RESID ResourceId
)
/*++
Routine Description:
IsAlive routine for Common service resource.
Arguments:
ResourceId - Supplies the resource id to be polled.
Return Value:
TRUE - if service is running
FALSE - if service is in any other state
--*/
{
return( CommonVerifyService( ResourceId, TRUE ) );
} // CommonIsAlive
static
BOOL
CommonVerifyService(
IN RESID ResourceId,
IN BOOL IsAliveFlag)
/*++
Routine Description:
Verify that a specified service is running
Arguments:
ResourceId - Supplies the resource id
IsAliveFlag - Says this is an IsAlive call - used only for debug print
Return Value:
TRUE - if service is running or starting
FALSE - service is in any other state
--*/
{
SERVICE_STATUS ServiceStatus;
PCOMMON_RESOURCE resourceEntry;
DWORD status = TRUE;
resourceEntry = (PCOMMON_RESOURCE)ResourceId;
if ( resourceEntry != CommonResource ) {
DBG_PRINT( "Common: IsAlive request for wrong resource 0x%p.\n",
ResourceId );
return(FALSE);
}
if ( resourceEntry == NULL ) {
DBG_PRINT( "Common: IsAlive request for a nonexistent resource id 0x%p.\n",
ResourceId );
return(FALSE);
}
if ( !QueryServiceStatus( resourceEntry->ServiceHandle,
&ServiceStatus ) ) {
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_ERROR,
L"Query Service Status failed %1!u!.\n",
GetLastError() );
return(FALSE);
}
//
// Now check the status of the service
//
if ((ServiceStatus.dwCurrentState != SERVICE_RUNNING)&&(ServiceStatus.dwCurrentState != SERVICE_START_PENDING)){
status = FALSE;
}
if (!status) {
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_ERROR,
L"Failed the IsAlive test. Current State is %1!u!.\n",
ServiceStatus.dwCurrentState );
}
return(status);
} // Verify Service
static
BOOL
WINAPI
CommonLooksAlive(
IN RESID ResourceId
)
/*++
Routine Description:
LooksAlive routine for Common Service resource.
Arguments:
ResourceId - Supplies the resource id to be polled.
Return Value:
TRUE - Resource looks like it is alive and well
FALSE - Resource looks like it is toast.
--*/
{
return( CommonVerifyService( ResourceId, FALSE ) );
} // CommonLooksAlive
static
VOID
WINAPI
CommonClose(
IN RESID ResourceId
)
/*++
Routine Description:
Close routine for Common Services resource.
This routine will stop the service, and delete the cluster
information regarding that service.
Arguments:
ResourceId - Supplies resource id to be closed
Return Value:
None.
--*/
{
PCOMMON_RESOURCE resourceEntry;
DWORD errorCode;
resourceEntry = (PCOMMON_RESOURCE)ResourceId;
if ( resourceEntry == NULL ) {
DBG_PRINT( "Common: Close request for a nonexistent resource id 0x%p\n",
ResourceId );
return;
}
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Close request.\n" );
//
// Shut it down if it's on line
//
CommonTerminate( ResourceId );
ClusterRegCloseKey( resourceEntry->ParametersKey );
ClusterRegCloseKey( resourceEntry->ResourceKey );
CloseClusterResource( resourceEntry->hResource );
#ifdef COMMON_SEMAPHORE
if ( resourceEntry == CommonResource ) {
(g_LogEvent)(
resourceEntry->ResourceHandle,
LOG_INFORMATION,
L"Setting Semaphore %1!ws!.\n",
COMMON_SEMAPHORE );
CommonResource = NULL;
ReleaseSemaphore( CommonSemaphore, 1 , NULL );
}
#endif
LocalFree( resourceEntry );
} // CommonClose
static
DWORD
SvcpTerminateServiceProcess(
IN PCOMMON_RESOURCE pResourceEntry,
IN BOOL bOffline,
OUT PDWORD pdwResourceState
)
/*++
Routine Description:
Attempts to terminate a service process.
Arguments:
pResourceEntry - Gensvc resource structure.
bOffline - Called from the offline thread or not.
pdwResourceState - State of the gensvc resource.
Return Value:
ERROR_SUCCESS - The termination was successful.
Win32 error - Otherwise.
--*/
{
HANDLE hSvcProcess = NULL;
DWORD dwStatus = ERROR_SUCCESS;
BOOLEAN bWasEnabled;
DWORD dwResourceState = ClusterResourceFailed;
//
// Chittur Subbaraman (chitturs) - 2/23/2000
//
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SvcpTerminateServiceProcess: Process with id=%1!u! might be terminated...\n",
pResourceEntry->dwServicePid );
//
// Adjust the privilege to allow debug. This is to allow
// termination of a service process which runs in a local
// system account from a different service process which runs in a
// domain user account.
//
dwStatus = ClRtlEnableThreadPrivilege( SE_DEBUG_PRIVILEGE,
&bWasEnabled );
if ( dwStatus != ERROR_SUCCESS )
{
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_ERROR,
L"SvcpTerminateServiceProcess: Unable to set debug privilege for process with id=%1!u!, status=%2!u!...\n",
pResourceEntry->dwServicePid,
dwStatus );
goto FnExit;
}
hSvcProcess = OpenProcess( PROCESS_TERMINATE,
FALSE,
pResourceEntry->dwServicePid );
if ( !hSvcProcess )
{
//
// Did this happen because the process terminated
// too quickly after we sent out one control request ?
//
dwStatus = GetLastError();
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SvcpTerminateServiceProcess: Unable to open pid=%1!u! for termination, status=%2!u!...\n",
pResourceEntry->dwServicePid,
dwStatus );
goto FnRestoreAndExit;
}
if ( !bOffline )
{
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SvcpTerminateServiceProcess: Pid=%1!u! will be terminated brute force...\n",
pResourceEntry->dwServicePid );
goto skip_waiting;
}
if ( WaitForSingleObject( hSvcProcess, 3000 )
== WAIT_OBJECT_0 )
{
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SvcpTerminateServiceProcess: Process with id=%1!u! shutdown gracefully...\n",
pResourceEntry->dwServicePid );
dwResourceState = ClusterResourceOffline;
dwStatus = ERROR_SUCCESS;
goto FnRestoreAndExit;
}
skip_waiting:
if ( !TerminateProcess( hSvcProcess, 0 ) )
{
dwStatus = GetLastError();
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_ERROR,
L"SvcpTerminateServiceProcess: Unable to terminate process with id=%1!u!, status=%2!u!...\n",
pResourceEntry->dwServicePid,
dwStatus );
goto FnRestoreAndExit;
}
dwResourceState = ClusterResourceOffline;
FnRestoreAndExit:
ClRtlRestoreThreadPrivilege( SE_DEBUG_PRIVILEGE,
bWasEnabled );
FnExit:
if ( hSvcProcess )
{
CloseHandle( hSvcProcess );
}
if ( ARGUMENT_PRESENT( pdwResourceState ) )
{
*pdwResourceState = dwResourceState;
}
(g_LogEvent)(
pResourceEntry->ResourceHandle,
LOG_INFORMATION,
L"SvcpTerminateServiceProcess: Process id=%1!u!, status=%2!u!, state=%3!u!...\n",
pResourceEntry->dwServicePid,
dwStatus,
dwResourceState );
return( dwStatus );
} // SvcpTerminateServiceProcess
#ifdef COMMON_CONTROL
static
DWORD
CommonGetRequiredDependencies(
OUT PVOID OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned
)
/*++
Routine Description:
Processes the CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES control function
for common service resources.
Arguments:
OutBuffer - Supplies a pointer to the output buffer to be filled in.
OutBufferSize - Supplies the size, in bytes, of the available space
pointed to by OutBuffer.
BytesReturned - Returns the number of bytes of OutBuffer actually
filled in by the resource. If OutBuffer is too small, BytesReturned
contains the total number of bytes for the operation to succeed.
Return Value:
ERROR_SUCCESS - The function completed successfully.
ERROR_MORE_DATA - The output buffer is too small to return the data.
BytesReturned contains the required size.
Win32 error code - The function failed.
--*/
{
PCOMMON_DEPEND_SETUP pdepsetup = CommonDependSetup;
PCOMMON_DEPEND_DATA pdepdata = (PCOMMON_DEPEND_DATA)OutBuffer;
CLUSPROP_BUFFER_HELPER value;
DWORD status;
*BytesReturned = sizeof(COMMON_DEPEND_DATA);
if ( OutBufferSize < sizeof(COMMON_DEPEND_DATA) ) {
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
ZeroMemory( OutBuffer, sizeof(COMMON_DEPEND_DATA) );
while ( pdepsetup->Syntax.dw != 0 ) {
value.pb = (PUCHAR)OutBuffer + pdepsetup->Offset;
value.pValue->Syntax.dw = pdepsetup->Syntax.dw;
value.pValue->cbLength = pdepsetup->Length;
switch ( pdepsetup->Syntax.wFormat ) {
case CLUSPROP_FORMAT_DWORD:
value.pDwordValue->dw = (DWORD)((DWORD_PTR)pdepsetup->Value);
break;
case CLUSPROP_FORMAT_ULARGE_INTEGER:
value.pULargeIntegerValue->li.LowPart =
(DWORD)((DWORD_PTR)pdepsetup->Value);
break;
case CLUSPROP_FORMAT_SZ:
case CLUSPROP_FORMAT_EXPAND_SZ:
case CLUSPROP_FORMAT_MULTI_SZ:
case CLUSPROP_FORMAT_BINARY:
memcpy( value.pBinaryValue->rgb, pdepsetup->Value, pdepsetup->Length );
break;
default:
break;
}
pdepsetup++;
}
pdepdata->endmark.dw = CLUSPROP_SYNTAX_ENDMARK;
status = ERROR_SUCCESS;
}
return(status);
} // CommonGetRequiredDependencies
static
DWORD
CommonGetRegistryCheckpoints(
OUT PVOID OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned
)
/*++
Routine Description:
Processes the CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS control function
for common service resources.
Arguments:
OutBuffer - Supplies a pointer to the output buffer to be filled in.
OutBufferSize - Supplies the size, in bytes, of the available space
pointed to by OutBuffer.
BytesReturned - Returns the number of bytes of OutBuffer actually
filled in by the resource. If OutBuffer is too small, BytesReturned
contains the total number of bytes for the operation to succeed.
Return Value:
ERROR_SUCCESS - The function completed successfully.
ERROR_MORE_DATA - The output buffer is too small to return the data.
BytesReturned contains the required size.
Win32 error code - The function failed.
--*/
{
DWORD status;
DWORD i;
DWORD totalBufferLength = 0;
LPWSTR psz = OutBuffer;
// Build a Multi-sz string.
//
// Calculate total buffer length needed.
//
for ( i = 0; i < RegSyncCount; i++ ) {
totalBufferLength += (lstrlenW( RegSync[i] ) + 1) * sizeof(WCHAR);
}
if ( !totalBufferLength ) {
*BytesReturned = 0;
return(ERROR_SUCCESS);
}
totalBufferLength += sizeof(UNICODE_NULL);
*BytesReturned = totalBufferLength;
if ( OutBufferSize < totalBufferLength ) {
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
//ZeroMemory( OutBuffer, totalBufferLength );
for ( i = 0; i < RegSyncCount; i++ ) {
lstrcpyW( psz, RegSync[i] );
psz += lstrlenW( RegSync[i] ) + 1;
}
*psz = L'\0';
status = ERROR_SUCCESS;
}
return(status);
} // CommonGetRegistryCheckpoints
static
DWORD
CommonGetCryptoCheckpoints(
OUT PVOID OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned
)
/*++
Routine Description:
Processes the CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS control function
for common service resources.
Arguments:
OutBuffer - Supplies a pointer to the output buffer to be filled in.
OutBufferSize - Supplies the size, in bytes, of the available space
pointed to by OutBuffer.
BytesReturned - Returns the number of bytes of OutBuffer actually
filled in by the resource. If OutBuffer is too small, BytesReturned
contains the total number of bytes for the operation to succeed.
Return Value:
ERROR_SUCCESS - The function completed successfully.
ERROR_MORE_DATA - The output buffer is too small to return the data.
BytesReturned contains the required size.
Win32 error code - The function failed.
--*/
{
DWORD status;
DWORD i;
DWORD totalBufferLength = 0;
LPWSTR psz = OutBuffer;
// Build a Multi-sz string.
//
// Calculate total buffer length needed.
//
for ( i = 0; i < CryptoSyncCount; i++ ) {
totalBufferLength += (lstrlenW( CryptoSync[i] ) + 1) * sizeof(WCHAR);
}
if ( !totalBufferLength ) {
*BytesReturned = 0;
return(ERROR_SUCCESS);
}
totalBufferLength += sizeof(UNICODE_NULL);
*BytesReturned = totalBufferLength;
if ( OutBufferSize < totalBufferLength ) {
if ( OutBuffer == NULL ) {
status = ERROR_SUCCESS;
} else {
status = ERROR_MORE_DATA;
}
} else {
//ZeroMemory( OutBuffer, totalBufferLength );
for ( i = 0; i < CryptoSyncCount; i++ ) {
lstrcpyW( psz, CryptoSync[i] );
psz += lstrlenW( CryptoSync[i] ) + 1;
}
*psz = L'\0';
status = ERROR_SUCCESS;
}
return(status);
} // CommonGetCryptoCheckpoints
static
DWORD
WINAPI
CommonResourceControl(
IN RESID ResourceId,
IN DWORD ControlCode,
IN PVOID InBuffer,
IN DWORD InBufferSize,
OUT PVOID OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned
)
/*++
Routine Description:
ResourceControl routine for Common Virtual Root resources.
Perform the control request specified by ControlCode on the specified
resource.
Arguments:
ResourceId - Supplies the resource id for the specific resource.
ControlCode - Supplies the control code that defines the action
to be performed.
InBuffer - Supplies a pointer to a buffer containing input data.
InBufferSize - Supplies the size, in bytes, of the data pointed
to by InBuffer.
OutBuffer - Supplies a pointer to the output buffer to be filled in.
OutBufferSize - Supplies the size, in bytes, of the available space
pointed to by OutBuffer.
BytesReturned - Returns the number of bytes of OutBuffer actually
filled in by the resource. If OutBuffer is too small, BytesReturned
contains the total number of bytes for the operation to succeed.
Return Value:
ERROR_SUCCESS - The function completed successfully.
ERROR_INVALID_FUNCTION - The requested control code is not supported.
In some cases, this allows the cluster software to perform the work.
Win32 error code - The function failed.
--*/
{
DWORD status;
PCOMMON_RESOURCE resourceEntry = NULL;
switch ( ControlCode ) {
case CLUSCTL_RESOURCE_UNKNOWN:
*BytesReturned = 0;
status = ERROR_SUCCESS;
break;
case CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES:
status = CommonGetRequiredDependencies( OutBuffer,
OutBufferSize,
BytesReturned
);
break;
case CLUSCTL_RESOURCE_GET_REGISTRY_CHECKPOINTS:
status = CommonGetRegistryCheckpoints( OutBuffer,
OutBufferSize,
BytesReturned
);
break;
case CLUSCTL_RESOURCE_GET_CRYPTO_CHECKPOINTS:
status = CommonGetCryptoCheckpoints( OutBuffer,
OutBufferSize,
BytesReturned
);
break;
default:
status = ERROR_INVALID_FUNCTION;
break;
}
return(status);
} // CommonResourceControl
static
DWORD
WINAPI
CommonResourceTypeControl(
IN LPCWSTR ResourceTypeName,
IN DWORD ControlCode,
IN PVOID InBuffer,
IN DWORD InBufferSize,
OUT PVOID OutBuffer,
IN DWORD OutBufferSize,
OUT LPDWORD BytesReturned
)
/*++
Routine Description:
ResourceTypeControl routine for Common Virtual Root resources.
Perform the control request specified by ControlCode.
Arguments:
ResourceTypeName - Supplies the name of the resource type.
ControlCode - Supplies the control code that defines the action
to be performed.
InBuffer - Supplies a pointer to a buffer containing input data.
InBufferSize - Supplies the size, in bytes, of the data pointed
to by InBuffer.
OutBuffer - Supplies a pointer to the output buffer to be filled in.
OutBufferSize - Supplies the size, in bytes, of the available space
pointed to by OutBuffer.
BytesReturned - Returns the number of bytes of OutBuffer actually
filled in by the resource. If OutBuffer is too small, BytesReturned
contains the total number of bytes for the operation to succeed.
Return Value:
ERROR_SUCCESS - The function completed successfully.
ERROR_INVALID_FUNCTION - The requested control code is not supported.
In some cases, this allows the cluster software to perform the work.
Win32 error code - The function failed.
--*/
{
DWORD status;
switch ( ControlCode ) {
case CLUSCTL_RESOURCE_TYPE_UNKNOWN:
*BytesReturned = 0;
status = ERROR_SUCCESS;
break;
case CLUSCTL_RESOURCE_TYPE_GET_REQUIRED_DEPENDENCIES:
status = CommonGetRequiredDependencies( OutBuffer,
OutBufferSize,
BytesReturned
);
break;
case CLUSCTL_RESOURCE_TYPE_GET_REGISTRY_CHECKPOINTS:
status = CommonGetRegistryCheckpoints( OutBuffer,
OutBufferSize,
BytesReturned
);
break;
case CLUSCTL_RESOURCE_TYPE_GET_CRYPTO_CHECKPOINTS:
status = CommonGetCryptoCheckpoints( OutBuffer,
OutBufferSize,
BytesReturned
);
break;
default:
status = ERROR_INVALID_FUNCTION;
break;
}
return(status);
} // CommonResourceTypeControl
#endif // COMMON_CONTROL
Reference in a new issue Copy permalink