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.
1849 lines
44 KiB
1849 lines
44 KiB
/*++
|
|
|
|
Copyright (c) 1992-1997 Microsoft Corporation
|
|
All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
splsvc.c
|
|
|
|
Abstract:
|
|
|
|
Resource DLL for Spooler
|
|
|
|
Author:
|
|
|
|
Albert Ting (albertt) 17-Sept-1996
|
|
Based on resdll\genapp
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.hxx"
|
|
#pragma hdrstop
|
|
|
|
#include "splsvc.hxx"
|
|
#include "spooler.hxx"
|
|
#include "clusinfo.hxx"
|
|
#include "clusrtl.h"
|
|
|
|
MODULE_DEBUG_INIT( DBG_ERROR|DBG_WARN|DBG_TRACE, DBG_ERROR );
|
|
|
|
#define MAX_SPOOLER 60
|
|
|
|
#define MAX_GROUP_NAME_LENGTH 120
|
|
|
|
#define SPOOLER_TERMINATE // Kill the spooler on terminate if pending offline.
|
|
|
|
#define SplSvcLogEvent ClusResLogEvent
|
|
#define SplSvcSetResourceStatus ClusResSetResourceStatus
|
|
|
|
#define NET_NAME_RESOURCE_NAME CLUS_RESTYPE_NAME_NETNAME
|
|
|
|
#define PARAM_NAME__DEFAULTSPOOLDIRECTORY CLUSREG_NAME_PRTSPOOL_DEFAULT_SPOOL_DIR
|
|
#define PARAM_NAME__JOBCOMPLETIONTIMEOUT CLUSREG_NAME_PRTSPOOL_TIMEOUT
|
|
|
|
#define KEY_NAME__DEFAULTSPOOLDIRECTORY L"Printers"
|
|
#define KEY_NAME__JOBCOMPLETIONTIMEOUT NULL
|
|
|
|
#define PARAM_MIN__JOBCOMPLETIONTIMEOUT 0
|
|
#define PARAM_MAX__JOBCOMPLETIONTIMEOUT ((DWORD) -1)
|
|
#define PARAM_DEFAULT_JOBCOMPLETIONTIMEOUT 160
|
|
|
|
typedef struct _SPOOLER_PARAMS {
|
|
LPWSTR DefaultSpoolDirectory;
|
|
DWORD JobCompletionTimeout;
|
|
} SPOOLER_PARAMS, *PSPOOLER_PARAMS;
|
|
|
|
//
|
|
// Properties
|
|
//
|
|
|
|
RESUTIL_PROPERTY_ITEM
|
|
SplSvcResourcePrivateProperties[] = {
|
|
{ PARAM_NAME__DEFAULTSPOOLDIRECTORY, KEY_NAME__DEFAULTSPOOLDIRECTORY, CLUSPROP_FORMAT_SZ, 0, 0, 0, RESUTIL_PROPITEM_REQUIRED, FIELD_OFFSET(SPOOLER_PARAMS,DefaultSpoolDirectory) },
|
|
{ PARAM_NAME__JOBCOMPLETIONTIMEOUT, KEY_NAME__JOBCOMPLETIONTIMEOUT, CLUSPROP_FORMAT_DWORD, PARAM_DEFAULT_JOBCOMPLETIONTIMEOUT, PARAM_MIN__JOBCOMPLETIONTIMEOUT, PARAM_MAX__JOBCOMPLETIONTIMEOUT, 0, FIELD_OFFSET(SPOOLER_PARAMS,JobCompletionTimeout) },
|
|
{ 0 }
|
|
};
|
|
|
|
//
|
|
// Lock to protect the ProcessInfo table
|
|
//
|
|
CRITICAL_SECTION gProcessLock;
|
|
|
|
//
|
|
// Global count of spooler resource instances.
|
|
//
|
|
UINT gcSpoolerInfo;
|
|
|
|
extern CLRES_FUNCTION_TABLE SplSvcFunctionTable;
|
|
|
|
#define PSPOOLERINFO_FROM_RESID(resid) ((PSPOOLER_INFORMATION)resid)
|
|
#define RESID_FROM_SPOOLERINFO(pSpoolerInfo) ((RESID)pSpoolerInfo)
|
|
|
|
//
|
|
// Forward prototypes.
|
|
//
|
|
|
|
#ifdef __cplusplus
|
|
extern "C"
|
|
#endif
|
|
|
|
BOOLEAN
|
|
WINAPI
|
|
SplSvcDllEntryPoint(
|
|
IN HINSTANCE DllHandle,
|
|
IN DWORD Reason,
|
|
IN LPVOID Reserved
|
|
);
|
|
|
|
RESID
|
|
WINAPI
|
|
SplSvcOpen(
|
|
IN LPCWSTR ResourceName,
|
|
IN HKEY ResourceKey,
|
|
IN RESOURCE_HANDLE ResourceHandle
|
|
);
|
|
|
|
VOID
|
|
WINAPI
|
|
SplSvcClose(
|
|
IN RESID Resid
|
|
);
|
|
|
|
DWORD
|
|
WINAPI
|
|
SplSvcOnline(
|
|
IN RESID Resid,
|
|
IN OUT PHANDLE EventHandle
|
|
);
|
|
|
|
DWORD
|
|
WINAPI
|
|
SplSvcOffline(
|
|
IN RESID Resid
|
|
);
|
|
|
|
VOID
|
|
WINAPI
|
|
SplSvcTerminate(
|
|
IN RESID Resource
|
|
);
|
|
|
|
BOOL
|
|
WINAPI
|
|
SplSvcIsAlive(
|
|
IN RESID Resource
|
|
);
|
|
|
|
BOOL
|
|
WINAPI
|
|
SplSvcLooksAlive(
|
|
IN RESID Resource
|
|
);
|
|
|
|
DWORD
|
|
SplSvcGetPrivateResProperties(
|
|
IN OUT PSPOOLER_INFORMATION ResourceEntry,
|
|
OUT PVOID OutBuffer,
|
|
IN DWORD OutBufferSize,
|
|
OUT LPDWORD BytesReturned
|
|
);
|
|
|
|
DWORD
|
|
SplSvcValidatePrivateResProperties(
|
|
IN OUT PSPOOLER_INFORMATION ResourceEntry,
|
|
IN PVOID InBuffer,
|
|
IN DWORD InBufferSize,
|
|
OUT PSPOOLER_PARAMS Params
|
|
);
|
|
|
|
DWORD
|
|
SplSvcSetPrivateResProperties(
|
|
IN OUT PSPOOLER_INFORMATION ResourceEntry,
|
|
IN PVOID InBuffer,
|
|
IN DWORD InBufferSize
|
|
);
|
|
|
|
|
|
PSPOOLER_INFORMATION
|
|
pNewSpoolerInfo(
|
|
LPCTSTR pszResource,
|
|
RESOURCE_HANDLE ResourceHandle,
|
|
PSET_RESOURCE_STATUS_ROUTINE SetResourceStatus,
|
|
PLOG_EVENT_ROUTINE LogEvent
|
|
)
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo = NULL;
|
|
LPTSTR pszResourceNew = NULL;
|
|
|
|
pSpoolerInfo = (PSPOOLER_INFORMATION)LocalAlloc(
|
|
LPTR,
|
|
sizeof( SPOOLER_INFORMATION ));
|
|
|
|
if( !pSpoolerInfo ){
|
|
goto Fail;
|
|
}
|
|
|
|
pszResourceNew = (LPTSTR)LocalAlloc(
|
|
LMEM_FIXED,
|
|
( lstrlen( pszResource ) + 1 )
|
|
* sizeof( TCHAR ));
|
|
|
|
if( !pszResourceNew ){
|
|
goto Fail;
|
|
}
|
|
|
|
lstrcpy( pszResourceNew, pszResource );
|
|
|
|
pSpoolerInfo->pfnLogEvent = LogEvent;
|
|
pSpoolerInfo->ResourceHandle = ResourceHandle;
|
|
pSpoolerInfo->pfnSetResourceStatus = SetResourceStatus;
|
|
|
|
pSpoolerInfo->pszResource = pszResourceNew;
|
|
pSpoolerInfo->pszName = NULL;
|
|
pSpoolerInfo->pszAddress = NULL;
|
|
|
|
return pSpoolerInfo;
|
|
|
|
Fail:
|
|
|
|
if( pszResourceNew ){
|
|
LocalFree( (HLOCAL)pszResourceNew );
|
|
}
|
|
|
|
if( pSpoolerInfo ){
|
|
LocalFree( (HLOCAL)pSpoolerInfo );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
VOID
|
|
vDeleteSpoolerInfo(
|
|
PSPOOLER_INFORMATION pSpoolerInfo
|
|
)
|
|
{
|
|
if( !pSpoolerInfo ){
|
|
return;
|
|
}
|
|
|
|
SPLASSERT( !pSpoolerInfo->cRef );
|
|
|
|
//
|
|
// Shut down everything.
|
|
//
|
|
if( pSpoolerInfo->pszName ){
|
|
LocalFree( (HLOCAL)pSpoolerInfo->pszName );
|
|
}
|
|
|
|
if( pSpoolerInfo->pszAddress ){
|
|
LocalFree( (HLOCAL)pSpoolerInfo->pszAddress );
|
|
}
|
|
|
|
if( pSpoolerInfo->pszResource ){
|
|
LocalFree( (HLOCAL)pSpoolerInfo->pszResource );
|
|
}
|
|
|
|
LocalFree( (HLOCAL)pSpoolerInfo );
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL
|
|
Init(
|
|
VOID
|
|
)
|
|
{
|
|
InitializeCriticalSection( &gProcessLock );
|
|
return bSplLibInit();
|
|
}
|
|
|
|
BOOLEAN
|
|
WINAPI
|
|
SplSvcDllEntryPoint(
|
|
IN HINSTANCE DllHandle,
|
|
IN DWORD Reason,
|
|
IN LPVOID Reserved
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(DllHandle);
|
|
UNREFERENCED_PARAMETER(Reserved);
|
|
|
|
switch( Reason ) {
|
|
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
if( !Init() ){
|
|
|
|
DBGMSG( DBG_ERROR, ( "DllEntryPoint: failed to init\n" ));
|
|
return FALSE;
|
|
}
|
|
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
/********************************************************************
|
|
|
|
Required exports and function table entries used by clustering.
|
|
|
|
********************************************************************/
|
|
|
|
|
|
|
|
|
|
/********************************************************************
|
|
|
|
Resource DLL functions.
|
|
|
|
********************************************************************/
|
|
|
|
|
|
|
|
BOOL
|
|
bSplRegCopyTree(
|
|
IN HKEY hClusterKey,
|
|
IN HKEY hLocalKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Recursives copies every key and value from under hLocalKey to hClusterKey
|
|
|
|
Arguments:
|
|
|
|
hClusterKey - handle to the cluster registry (destination)
|
|
hLocalKey - handle to the local registry (source)
|
|
|
|
Return Value:
|
|
|
|
TRUE - success
|
|
FALSE - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
DWORD dwError, dwIndex, cbValueName, cbData, cbKeyName, dwType;
|
|
DWORD cbMaxSubKeyLen, cbMaxValueNameLen, cValues, cSubKeys, cbMaxValueLen;
|
|
LPBYTE lpValueName = NULL, lpData = NULL, lpKeyName = NULL;
|
|
HKEY hLocalSubKey = NULL, hClusterSubKey = NULL;
|
|
|
|
//
|
|
// Retrieve the max buffer sizes required for the copy
|
|
//
|
|
dwError = RegQueryInfoKey( hLocalKey, NULL, NULL, NULL, &cSubKeys,
|
|
&cbMaxSubKeyLen, NULL, &cValues,
|
|
&cbMaxValueNameLen, &cbMaxValueLen,
|
|
NULL, NULL );
|
|
if( dwError ){
|
|
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Add for the terminating NULL character
|
|
//
|
|
++cbMaxSubKeyLen;
|
|
++cbMaxValueNameLen;
|
|
|
|
//
|
|
// Allocate the buffers
|
|
//
|
|
lpValueName = (LPBYTE) LocalAlloc( LMEM_FIXED, cbMaxValueNameLen * sizeof(WCHAR) );
|
|
lpData = (LPBYTE) LocalAlloc( LMEM_FIXED, cbMaxValueLen );
|
|
lpKeyName = (LPBYTE) LocalAlloc( LMEM_FIXED, cbMaxSubKeyLen * sizeof(WCHAR) );
|
|
|
|
if( !lpValueName || !lpData || !lpKeyName){
|
|
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Copy all the values in the current key
|
|
//
|
|
for (dwIndex = 0; dwIndex < cValues; ++ dwIndex) {
|
|
|
|
cbValueName = cbMaxValueNameLen;
|
|
cbData = cbMaxValueLen;
|
|
|
|
//
|
|
// Retrieve the value name and the data
|
|
//
|
|
dwError = RegEnumValue( hLocalKey, dwIndex, (LPWSTR) lpValueName, &cbValueName,
|
|
NULL, &dwType, lpData, &cbData );
|
|
|
|
if( dwError ){
|
|
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Set the value in the cluster registry
|
|
//
|
|
dwError = ClusterRegSetValue( hClusterKey, (LPWSTR) lpValueName, dwType,
|
|
lpData, cbData );
|
|
|
|
if( dwError ){
|
|
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Recursively copies all the subkeys
|
|
//
|
|
for (dwIndex = 0; dwIndex < cSubKeys; ++ dwIndex) {
|
|
|
|
cbKeyName = cbMaxSubKeyLen;
|
|
|
|
//
|
|
// Retrieve the key name
|
|
//
|
|
dwError = RegEnumKeyEx( hLocalKey, dwIndex, (LPWSTR) lpKeyName, &cbKeyName,
|
|
NULL, NULL, NULL, NULL );
|
|
|
|
if( dwError ){
|
|
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Open local subkey
|
|
//
|
|
if( dwError = RegOpenKeyEx( hLocalKey, (LPWSTR) lpKeyName, 0,
|
|
KEY_READ, &hLocalSubKey ) ){
|
|
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Create the cluster subkey
|
|
//
|
|
|
|
if(( dwError = ClusterRegOpenKey( hClusterKey, (LPWSTR) lpKeyName,
|
|
KEY_READ|KEY_WRITE,
|
|
&hClusterSubKey)) == ERROR_FILE_NOT_FOUND )
|
|
{
|
|
if( dwError = ClusterRegCreateKey( hClusterKey, (LPWSTR) lpKeyName,
|
|
0,KEY_READ|KEY_WRITE,
|
|
NULL, &hClusterSubKey, NULL ) )
|
|
{
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy the subkey tree
|
|
//
|
|
if( !bSplRegCopyTree( hClusterSubKey, hLocalSubKey ) ){
|
|
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Close the registry handle
|
|
//
|
|
RegCloseKey( hLocalSubKey );
|
|
ClusterRegCloseKey( hClusterSubKey );
|
|
|
|
hLocalSubKey = NULL;
|
|
hClusterSubKey = NULL;
|
|
|
|
}
|
|
|
|
bStatus = TRUE;
|
|
|
|
CleanUp:
|
|
|
|
if( lpValueName ){
|
|
LocalFree( lpValueName );
|
|
}
|
|
if( lpData ){
|
|
LocalFree( lpData );
|
|
}
|
|
if( lpKeyName ){
|
|
LocalFree( lpKeyName );
|
|
}
|
|
if( hLocalSubKey ){
|
|
RegCloseKey( hLocalSubKey );
|
|
}
|
|
if( hClusterSubKey ){
|
|
ClusterRegCloseKey( hClusterSubKey );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
BOOL
|
|
bUpdateRegPort(
|
|
IN HKEY hClusterKey,
|
|
OUT LPBOOL pbRegUpdated
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Moves Port data from the local to the cluster registry
|
|
|
|
Arguments:
|
|
|
|
hClusterKey - handle to the cluster registry
|
|
pbRegUpdated - flag to indicate if the registry was updated
|
|
|
|
Return Value:
|
|
|
|
TRUE - success
|
|
FALSE - failure
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL bStatus = FALSE;
|
|
DWORD dwError, dwType, dwValue, dwSize;
|
|
HKEY hLocalLPR = NULL, hClusterLPR = NULL;
|
|
|
|
WCHAR szLocalLPRKey[] = L"System\\CurrentControlSet\\Control\\Print\\Monitors\\LPR Port";
|
|
WCHAR szClusterLPRKey[] = L"Monitors\\LPR Port";
|
|
WCHAR szSplVersion[] = L"Spooler Version";
|
|
|
|
//
|
|
// Initialize the bRegUpdate flag
|
|
//
|
|
*pbRegUpdated = FALSE;
|
|
|
|
//
|
|
// Check if ports have been migrated already
|
|
//
|
|
dwSize = sizeof(DWORD);
|
|
if( dwError = ClusterRegQueryValue( hClusterKey, szSplVersion, &dwType,
|
|
(LPBYTE) &dwValue, &dwSize ) ){
|
|
|
|
if( dwError != ERROR_FILE_NOT_FOUND ){
|
|
|
|
SetLastError( dwError );
|
|
return FALSE;
|
|
}
|
|
|
|
} else {
|
|
|
|
if( dwValue == 1 ){
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Open the local LPR Port key, if any
|
|
//
|
|
if( dwError = RegOpenKeyEx( HKEY_LOCAL_MACHINE, szLocalLPRKey, 0,
|
|
KEY_READ, &hLocalLPR ) ){
|
|
|
|
//
|
|
// LPR Port key was not found
|
|
//
|
|
if( dwError == ERROR_FILE_NOT_FOUND ){
|
|
|
|
bStatus = TRUE;
|
|
|
|
} else {
|
|
|
|
SetLastError( dwError );
|
|
}
|
|
goto CleanUp;
|
|
}
|
|
|
|
//
|
|
// Create the LPR Port key on the cluster registry
|
|
//
|
|
|
|
if(( dwError = ClusterRegOpenKey( hClusterKey, szClusterLPRKey,
|
|
KEY_READ|KEY_WRITE,
|
|
&hClusterLPR ) ) == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
|
|
|
|
if( dwError = ClusterRegCreateKey( hClusterKey, szClusterLPRKey,
|
|
0,KEY_READ|KEY_WRITE,
|
|
NULL, &hClusterLPR, NULL ) )
|
|
{
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
}
|
|
else if ( dwError )
|
|
{
|
|
SetLastError( dwError );
|
|
goto CleanUp;
|
|
}
|
|
|
|
bStatus = bSplRegCopyTree( hClusterLPR, hLocalLPR );
|
|
|
|
if( bStatus ){
|
|
|
|
//
|
|
// Create a value in the cluster to avoid repeated copying of the port data
|
|
//
|
|
dwValue = 1;
|
|
dwSize = sizeof(dwValue);
|
|
ClusterRegSetValue( hClusterKey, szSplVersion, REG_DWORD,
|
|
(LPBYTE) &dwValue, dwSize );
|
|
*pbRegUpdated = TRUE;
|
|
}
|
|
|
|
CleanUp:
|
|
|
|
if( hLocalLPR ){
|
|
RegCloseKey( hLocalLPR );
|
|
}
|
|
|
|
if( hClusterLPR ){
|
|
ClusterRegCloseKey( hClusterLPR );
|
|
}
|
|
|
|
return bStatus;
|
|
}
|
|
|
|
RESID
|
|
WINAPI
|
|
SplSvcOpen(
|
|
IN LPCWSTR ResourceName,
|
|
IN HKEY ResourceKey,
|
|
IN RESOURCE_HANDLE ResourceHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Opens the spooler resource. This will start the spooler
|
|
service if necessary.
|
|
|
|
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
|
|
|
|
--*/
|
|
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo = NULL;
|
|
BOOL bTooMany = FALSE, bRegUpdated;
|
|
HKEY parametersKey = NULL;
|
|
DWORD status;
|
|
HCLUSTER hCluster;
|
|
|
|
UNREFERENCED_PARAMETER(ResourceKey);
|
|
|
|
vEnterSem();
|
|
|
|
DBGMSG( DBG_WARN, ( ">>> Open: called\n" ));
|
|
|
|
if( gcSpoolerInfo == MAX_SPOOLER ){
|
|
bTooMany = TRUE;
|
|
status = ERROR_ALLOTTED_SPACE_EXCEEDED;
|
|
goto FailLeave;
|
|
}
|
|
|
|
//
|
|
// Open the Parameters key for this resource.
|
|
//
|
|
|
|
status = ClusterRegOpenKey( ResourceKey,
|
|
CLUSREG_KEYNAME_PARAMETERS,
|
|
KEY_READ,
|
|
¶metersKey );
|
|
if ( status != ERROR_SUCCESS || parametersKey == NULL ) {
|
|
(SplSvcLogEvent)(
|
|
ResourceHandle,
|
|
LOG_ERROR,
|
|
L"Unable to open parameters key for resource '%1!ws!'. Error: %2!u!.\n",
|
|
ResourceName,
|
|
status );
|
|
goto FailLeave;
|
|
}
|
|
|
|
//
|
|
// Move the ports data from local to cluster registry
|
|
//
|
|
|
|
if( !bUpdateRegPort( parametersKey, &bRegUpdated ) ){
|
|
|
|
(SplSvcLogEvent)(
|
|
ResourceHandle,
|
|
LOG_WARNING,
|
|
L"LPR Port settings could not be moved to cluster registry.\n" );
|
|
|
|
DBGMSG( DBG_WARN, ( "Port settings could not be moved to cluster registry" ));
|
|
}
|
|
|
|
//
|
|
// Find a free index in the process info table for this new app.
|
|
//
|
|
|
|
pSpoolerInfo = pNewSpoolerInfo( ResourceName,
|
|
ResourceHandle,
|
|
SplSvcSetResourceStatus,
|
|
SplSvcLogEvent );
|
|
|
|
if( !pSpoolerInfo ){
|
|
status = ERROR_ALLOTTED_SPACE_EXCEEDED;
|
|
goto FailLeave;
|
|
}
|
|
|
|
//
|
|
// Save the name of the resource.
|
|
//
|
|
hCluster = OpenCluster( NULL );
|
|
if ( !hCluster ) {
|
|
status = GetLastError();
|
|
goto FailLeave;
|
|
}
|
|
pSpoolerInfo->hResource = OpenClusterResource( hCluster,
|
|
ResourceName );
|
|
status = GetLastError();
|
|
CloseCluster( hCluster );
|
|
if ( pSpoolerInfo->hResource == NULL ) {
|
|
goto FailLeave;
|
|
}
|
|
|
|
pSpoolerInfo->eState = kOpen;
|
|
pSpoolerInfo->ParametersKey = parametersKey;
|
|
|
|
vAddRef( pSpoolerInfo );
|
|
++gcSpoolerInfo;
|
|
|
|
vLeaveSem();
|
|
|
|
DBGMSG( DBG_WARN,
|
|
( "Open: return %x\n", RESID_FROM_SPOOLERINFO( pSpoolerInfo )));
|
|
|
|
return RESID_FROM_SPOOLERINFO(pSpoolerInfo);
|
|
|
|
FailLeave:
|
|
|
|
vLeaveSem();
|
|
|
|
if( bTooMany ){
|
|
|
|
(SplSvcLogEvent)(
|
|
ResourceHandle,
|
|
LOG_ERROR,
|
|
L"Too many spoolers.\n" );
|
|
|
|
DBGMSG( DBG_WARN, ( "SplSvcOpen: Too many spoolers.\n" ));
|
|
|
|
} else {
|
|
|
|
(SplSvcLogEvent)(
|
|
ResourceHandle,
|
|
LOG_ERROR,
|
|
L"Failed to create new spooler. Error: %1!u!.\n",
|
|
GetLastError() );
|
|
|
|
DBGMSG( DBG_ERROR, ( "SplSvcOpen: Unable to create spooler %d\n",
|
|
GetLastError()));
|
|
}
|
|
|
|
if ( parametersKey != NULL ) {
|
|
ClusterRegCloseKey( parametersKey );
|
|
}
|
|
|
|
if ( pSpoolerInfo && (pSpoolerInfo->hResource != NULL) ) {
|
|
CloseClusterResource( pSpoolerInfo->hResource );
|
|
}
|
|
|
|
vDeleteSpoolerInfo( pSpoolerInfo );
|
|
|
|
SetLastError( status );
|
|
|
|
return (RESID)0;
|
|
}
|
|
|
|
VOID
|
|
WINAPI
|
|
SplSvcClose(
|
|
IN RESID Resid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Close down the open spooler resource ID. Note that we'll leave
|
|
the spooler running, since it always should be running.
|
|
|
|
Arguments:
|
|
|
|
Resource - supplies resource id to be closed
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
DBGMSG( DBG_WARN, ( ">>> Close: called %x\n", Resid ));
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( Resid );
|
|
|
|
//
|
|
// If resource is still online, terminate it.
|
|
//
|
|
if( pSpoolerInfo->eState == kOnline ){
|
|
SplSvcTerminate( Resid );
|
|
}
|
|
|
|
vEnterSem();
|
|
|
|
--gcSpoolerInfo;
|
|
pSpoolerInfo->eState = kClose;
|
|
|
|
vLeaveSem();
|
|
|
|
if (pSpoolerInfo->hResource != NULL ) {
|
|
CloseClusterResource( pSpoolerInfo->hResource );
|
|
}
|
|
|
|
if (pSpoolerInfo->ParametersKey != NULL ) {
|
|
ClusterRegCloseKey( pSpoolerInfo->ParametersKey );
|
|
}
|
|
|
|
vDecRef( pSpoolerInfo );
|
|
}
|
|
|
|
DWORD
|
|
WINAPI
|
|
SplSvcOnline(
|
|
IN RESID Resid,
|
|
IN OUT PHANDLE EventHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Online the spooler resource.
|
|
|
|
This always completes asynchronously with ERROR_IO_PENDING.
|
|
|
|
Arguments:
|
|
|
|
Resource - supplies resource id to be brought online
|
|
|
|
EventHandle - supplies a pointer to a handle to signal on error.
|
|
|
|
Return Value:
|
|
|
|
In success case, this returns ERROR_IO_PENDING, else win32
|
|
error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL bStatus;
|
|
DWORD Status = ERROR_IO_PENDING;
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
|
|
UNREFERENCED_PARAMETER( EventHandle );
|
|
|
|
DBGMSG( DBG_WARN, ( ">>> Online: called %x\n", Resid ));
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( Resid );
|
|
|
|
//
|
|
// Rpc to the spooler to initiate Online.
|
|
//
|
|
bStatus = SpoolerOnline( pSpoolerInfo );
|
|
|
|
if( !bStatus ){
|
|
|
|
Status = GetLastError();
|
|
SPLASSERT( Status );
|
|
|
|
(pSpoolerInfo->pfnLogEvent)(
|
|
pSpoolerInfo->ResourceHandle,
|
|
LOG_ERROR,
|
|
L"Unable to online spooler resource. Error: %1!u!.\n",
|
|
Status );
|
|
|
|
DBGMSG( DBG_ERROR, ( "SplSvcOnline: Unable to online spooler\n" ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
DWORD
|
|
WINAPI
|
|
SplSvcOffline(
|
|
IN RESID Resid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Offline the spooler resource.
|
|
|
|
Arguments:
|
|
|
|
Resid - supplies the resource to be taken offline
|
|
|
|
Return Value:
|
|
|
|
In success case, this returns ERROR_IO_PENDING, else win32
|
|
error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
|
|
DBGMSG( DBG_WARN, ( ">>> Offline: called %x\n", Resid ));
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( Resid );
|
|
|
|
vEnterSem();
|
|
pSpoolerInfo->ClusterResourceState = ClusterResourceOffline;
|
|
vLeaveSem();
|
|
|
|
return(SpoolerOffline(pSpoolerInfo));
|
|
}
|
|
|
|
VOID
|
|
WINAPI
|
|
SplSvcTerminate(
|
|
IN RESID Resid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Terminate and restart the spooler--no waiting.
|
|
|
|
Arguments:
|
|
|
|
Resid - supplies resource id to be terminated
|
|
|
|
Return Value:
|
|
|
|
--*/
|
|
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
|
|
DBGMSG( DBG_WARN, ( ">>> Terminate: called %x\n", Resid ));
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( Resid );
|
|
|
|
vEnterSem();
|
|
pSpoolerInfo->ClusterResourceState = ClusterResourceFailed;
|
|
vLeaveSem();
|
|
|
|
SpoolerTerminate(pSpoolerInfo);
|
|
return;
|
|
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
SplSvcIsAlive(
|
|
IN RESID Resid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
IsAlive routine for Generice Applications resource.
|
|
|
|
Arguments:
|
|
|
|
Resource - supplies the resource id to be polled.
|
|
|
|
Return Value:
|
|
|
|
TRUE - Resource is alive and well
|
|
|
|
FALSE - Resource is toast.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( Resid );
|
|
|
|
return SpoolerIsAlive( pSpoolerInfo );
|
|
}
|
|
|
|
|
|
BOOL
|
|
WINAPI
|
|
SplSvcLooksAlive(
|
|
IN RESID Resid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
LooksAlive routine for Generic Applications resource.
|
|
|
|
Arguments:
|
|
|
|
Resource - 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.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( Resid );
|
|
|
|
return SpoolerLooksAlive( pSpoolerInfo );
|
|
}
|
|
|
|
|
|
DWORD
|
|
SplSvcGetRequiredDependencies(
|
|
OUT PVOID OutBuffer,
|
|
IN DWORD OutBufferSize,
|
|
OUT LPDWORD BytesReturned
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes the CLCTL_GET_REQUIRED_DEPENDENCIES control function
|
|
for resources of type Print Spooler.
|
|
|
|
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.
|
|
|
|
--*/
|
|
|
|
{
|
|
typedef struct DEP_DATA {
|
|
CLUSPROP_RESOURCE_CLASS storageEntry;
|
|
CLUSPROP_SZ_DECLARE( netnameEntry, sizeof(NET_NAME_RESOURCE_NAME) / sizeof(WCHAR) );
|
|
CLUSPROP_SYNTAX endmark;
|
|
} DEP_DATA, *PDEP_DATA;
|
|
PDEP_DATA pdepdata = (PDEP_DATA)OutBuffer;
|
|
DWORD status;
|
|
|
|
*BytesReturned = sizeof(DEP_DATA);
|
|
if ( OutBufferSize < sizeof(DEP_DATA) ) {
|
|
if ( OutBuffer == NULL ) {
|
|
status = ERROR_SUCCESS;
|
|
} else {
|
|
status = ERROR_MORE_DATA;
|
|
}
|
|
} else {
|
|
ZeroMemory( pdepdata, sizeof(DEP_DATA) );
|
|
pdepdata->storageEntry.Syntax.dw = CLUSPROP_SYNTAX_RESCLASS;
|
|
pdepdata->storageEntry.cbLength = sizeof(DWORD);
|
|
pdepdata->storageEntry.rc = CLUS_RESCLASS_STORAGE;
|
|
pdepdata->netnameEntry.Syntax.dw = CLUSPROP_SYNTAX_NAME;
|
|
pdepdata->netnameEntry.cbLength = sizeof(NET_NAME_RESOURCE_NAME);
|
|
lstrcpyW( pdepdata->netnameEntry.sz, NET_NAME_RESOURCE_NAME );
|
|
pdepdata->endmark.dw = CLUSPROP_SYNTAX_ENDMARK;
|
|
status = ERROR_SUCCESS;
|
|
}
|
|
|
|
return status;
|
|
|
|
} // SplSvcGetRequiredDependencies
|
|
|
|
|
|
DWORD
|
|
SplSvcResourceControl(
|
|
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 Print Spooler 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;
|
|
PSPOOLER_INFORMATION pSpoolerInfo;
|
|
DWORD required;
|
|
LPWSTR pszResourceNew;
|
|
|
|
pSpoolerInfo = PSPOOLERINFO_FROM_RESID( ResourceId );
|
|
|
|
switch ( ControlCode ) {
|
|
|
|
case CLUSCTL_RESOURCE_UNKNOWN:
|
|
*BytesReturned = 0;
|
|
status = ERROR_SUCCESS;
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTY_FMTS:
|
|
status = ResUtilGetPropertyFormats( SplSvcResourcePrivateProperties,
|
|
OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned,
|
|
&required );
|
|
if ( status == ERROR_MORE_DATA ) {
|
|
*BytesReturned = required;
|
|
}
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_SET_NAME:
|
|
pszResourceNew = (LPWSTR)LocalAlloc(
|
|
LMEM_FIXED,
|
|
( lstrlenW( (LPWSTR)InBuffer ) + 1 )
|
|
* sizeof( WCHAR ));
|
|
|
|
if ( pszResourceNew ) {
|
|
LocalFree( (HLOCAL)pSpoolerInfo->pszResource );
|
|
lstrcpyW( pszResourceNew, (LPWSTR)InBuffer );
|
|
pSpoolerInfo->pszResource = (LPTSTR)pszResourceNew;
|
|
status = ERROR_SUCCESS;
|
|
} else {
|
|
status = GetLastError();
|
|
}
|
|
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_GET_REQUIRED_DEPENDENCIES:
|
|
status = SplSvcGetRequiredDependencies( OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned
|
|
);
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_ENUM_PRIVATE_PROPERTIES:
|
|
status = ResUtilEnumProperties( SplSvcResourcePrivateProperties,
|
|
(LPWSTR) OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned,
|
|
&required );
|
|
if ( status == ERROR_MORE_DATA ) {
|
|
*BytesReturned = required;
|
|
}
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES:
|
|
status = SplSvcGetPrivateResProperties( pSpoolerInfo,
|
|
OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned );
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_VALIDATE_PRIVATE_PROPERTIES:
|
|
status = SplSvcValidatePrivateResProperties( pSpoolerInfo,
|
|
InBuffer,
|
|
InBufferSize,
|
|
NULL );
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES:
|
|
status = SplSvcSetPrivateResProperties( pSpoolerInfo,
|
|
InBuffer,
|
|
InBufferSize );
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_CLUSTER_VERSION_CHANGED:
|
|
|
|
{
|
|
LPWSTR pszResourceGuid = NULL;
|
|
|
|
//
|
|
// Retreive the guid of the spooler resource
|
|
//
|
|
if ((status = GetIDFromName(pSpoolerInfo->hResource,
|
|
&pszResourceGuid)) == ERROR_SUCCESS)
|
|
{
|
|
status = SpoolerWriteClusterUpgradedKey(pszResourceGuid);
|
|
|
|
LocalFree(pszResourceGuid);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_DELETE:
|
|
|
|
SpoolerCleanDriverDirectory(pSpoolerInfo->ParametersKey);
|
|
|
|
//
|
|
// Let the res mon do the rest of the job for us
|
|
//
|
|
status = ERROR_INVALID_FUNCTION;
|
|
|
|
break;
|
|
|
|
default:
|
|
status = ERROR_INVALID_FUNCTION;
|
|
break;
|
|
}
|
|
|
|
return(status);
|
|
|
|
} // SplSvcResourceControl
|
|
|
|
|
|
DWORD
|
|
SplSvcResourceTypeControl(
|
|
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 Print Spooler 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;
|
|
DWORD required;
|
|
|
|
switch ( ControlCode ) {
|
|
|
|
case CLUSCTL_RESOURCE_TYPE_UNKNOWN:
|
|
*BytesReturned = 0;
|
|
status = ERROR_SUCCESS;
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_RESOURCE_PROPERTY_FMTS:
|
|
status = ResUtilGetPropertyFormats( SplSvcResourcePrivateProperties,
|
|
OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned,
|
|
&required );
|
|
if ( status == ERROR_MORE_DATA ) {
|
|
*BytesReturned = required;
|
|
}
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_TYPE_GET_REQUIRED_DEPENDENCIES:
|
|
status = SplSvcGetRequiredDependencies( OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned
|
|
);
|
|
break;
|
|
|
|
case CLUSCTL_RESOURCE_TYPE_ENUM_PRIVATE_PROPERTIES:
|
|
status = ResUtilEnumProperties( SplSvcResourcePrivateProperties,
|
|
(LPWSTR) OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned,
|
|
&required );
|
|
if ( status == ERROR_MORE_DATA ) {
|
|
*BytesReturned = required;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
status = ERROR_INVALID_FUNCTION;
|
|
break;
|
|
}
|
|
|
|
return(status);
|
|
|
|
} // SplSvcResourceTypeControl
|
|
|
|
|
|
|
|
DWORD
|
|
SplSvcGetPrivateResProperties(
|
|
IN OUT PSPOOLER_INFORMATION ResourceEntry,
|
|
OUT PVOID OutBuffer,
|
|
IN DWORD OutBufferSize,
|
|
OUT LPDWORD BytesReturned
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes the CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES control
|
|
function for resources of type Print Spooler.
|
|
|
|
Arguments:
|
|
|
|
ResourceEntry - Supplies the resource entry on which to operate.
|
|
|
|
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_NOT_ENOUGH_MEMORY - An error occurred allocating memory.
|
|
|
|
Win32 error code - The function failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD status;
|
|
DWORD required;
|
|
|
|
*BytesReturned = 0;
|
|
|
|
//
|
|
// Clear the output buffer
|
|
//
|
|
ZeroMemory( OutBuffer, OutBufferSize );
|
|
|
|
//
|
|
// Get the common properties.
|
|
//
|
|
status = ResUtilGetAllProperties( ResourceEntry->ParametersKey,
|
|
SplSvcResourcePrivateProperties,
|
|
OutBuffer,
|
|
OutBufferSize,
|
|
BytesReturned,
|
|
&required );
|
|
|
|
if ( *BytesReturned == 0 ) {
|
|
*BytesReturned = required;
|
|
}
|
|
|
|
return(status);
|
|
|
|
} // SplSvcGetPrivateResProperties
|
|
|
|
|
|
|
|
DWORD
|
|
SplSvcValidateUniqueProperties(
|
|
IN HRESOURCE hSelf,
|
|
IN HRESOURCE hResource,
|
|
IN PVOID GroupName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Callback function to validate that a resources properties are unique.
|
|
|
|
For the SplSvc resource we must ensure that only one print spooler
|
|
resource exists in a group.
|
|
|
|
We will never be called for the resource we are creating, only for
|
|
other resources of the same type.
|
|
|
|
Arguments:
|
|
|
|
hSelf - A handle to the original resource.
|
|
|
|
hResource - A handle to a resource of the same Type. Check against this
|
|
to make sure the new properties do not conflict.
|
|
|
|
lpszGroupName - The name of the Group the creating resource is in.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS - The function completed successfully, only one print
|
|
spooler in the given group.
|
|
|
|
ERROR_OBJECT_ALREADY_EXISTS - The name is not unique (i.e., already have
|
|
a print spooler in that group).
|
|
|
|
A Win32 error code on other failure.
|
|
|
|
--*/
|
|
{
|
|
WCHAR groupName[MAX_GROUP_NAME_LENGTH + 1];
|
|
DWORD groupNameSize = MAX_GROUP_NAME_LENGTH * sizeof(WCHAR);
|
|
CLUSTER_RESOURCE_STATE resourceState;
|
|
LPWSTR lpszGroupName = (LPWSTR)GroupName;
|
|
|
|
UNREFERENCED_PARAMETER(hSelf);
|
|
|
|
groupName[0] = L'\0';
|
|
|
|
resourceState = GetClusterResourceState( hResource,
|
|
NULL,
|
|
0,
|
|
groupName,
|
|
&groupNameSize );
|
|
if ( !*groupName ) {
|
|
return(GetLastError());
|
|
}
|
|
|
|
if ( lstrcmpiW( lpszGroupName, groupName ) == 0 ) {
|
|
return(ERROR_OBJECT_ALREADY_EXISTS);
|
|
}
|
|
|
|
return( ERROR_SUCCESS );
|
|
|
|
} // SplSvcValidateUniqueProperties
|
|
|
|
|
|
|
|
DWORD
|
|
SplSvcValidatePrivateResProperties(
|
|
IN OUT PSPOOLER_INFORMATION ResourceEntry,
|
|
IN PVOID InBuffer,
|
|
IN DWORD InBufferSize,
|
|
OUT PSPOOLER_PARAMS Params
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes the CLUSCTL_RESOURCE_VALIDATE_PRIVATE_PROPERTIES control
|
|
function for resources of type Print Spooler.
|
|
|
|
Arguments:
|
|
|
|
ResourceEntry - Supplies the resource entry on which to operate.
|
|
|
|
InBuffer - Supplies a pointer to a buffer containing input data.
|
|
|
|
InBufferSize - Supplies the size, in bytes, of the data pointed
|
|
to by InBuffer.
|
|
|
|
Params - Supplies the parameter block to fill in.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS - The function completed successfully.
|
|
|
|
ERROR_INVALID_PARAMETER - The data is formatted incorrectly.
|
|
|
|
ERROR_NOT_ENOUGH_MEMORY - An error occurred allocating memory.
|
|
|
|
Win32 error code - The function failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD status;
|
|
SPOOLER_PARAMS currentProps;
|
|
SPOOLER_PARAMS newProps;
|
|
PSPOOLER_PARAMS pParams = NULL;
|
|
WCHAR groupName[MAX_GROUP_NAME_LENGTH + 1];
|
|
DWORD groupNameSize = MAX_GROUP_NAME_LENGTH * sizeof(WCHAR);
|
|
CLUSTER_RESOURCE_STATE resourceState;
|
|
LPWSTR nameOfPropInError;
|
|
|
|
//
|
|
// Check if there is input data.
|
|
//
|
|
if ( (InBuffer == NULL) ||
|
|
(InBufferSize < sizeof(DWORD)) ) {
|
|
return(ERROR_INVALID_DATA);
|
|
}
|
|
|
|
//
|
|
// Capture the current set of private properties from the registry.
|
|
//
|
|
ZeroMemory( ¤tProps, sizeof(currentProps) );
|
|
|
|
status = ResUtilGetPropertiesToParameterBlock(
|
|
ResourceEntry->ParametersKey,
|
|
SplSvcResourcePrivateProperties,
|
|
(LPBYTE) ¤tProps,
|
|
FALSE, /*CheckForRequiredProperties*/
|
|
&nameOfPropInError
|
|
);
|
|
|
|
if ( status != ERROR_SUCCESS ) {
|
|
(SplSvcLogEvent)(
|
|
ResourceEntry->ResourceHandle,
|
|
LOG_ERROR,
|
|
L"Unable to read the '%1' property. Error: %2!u!.\n",
|
|
(nameOfPropInError == NULL ? L"" : nameOfPropInError),
|
|
status );
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Duplicate the resource parameter block.
|
|
//
|
|
if ( Params == NULL ) {
|
|
pParams = &newProps;
|
|
} else {
|
|
pParams = Params;
|
|
}
|
|
|
|
ZeroMemory( pParams, sizeof(SPOOLER_PARAMS) );
|
|
status = ResUtilDupParameterBlock( (LPBYTE) pParams,
|
|
(LPBYTE) ¤tProps,
|
|
SplSvcResourcePrivateProperties );
|
|
if ( status != ERROR_SUCCESS ) {
|
|
return(status);
|
|
}
|
|
|
|
//
|
|
// Parse and validate the properties.
|
|
//
|
|
status = ResUtilVerifyPropertyTable( SplSvcResourcePrivateProperties,
|
|
NULL,
|
|
TRUE, // Allow unknowns
|
|
InBuffer,
|
|
InBufferSize,
|
|
(LPBYTE) pParams );
|
|
|
|
if ( status == ERROR_SUCCESS ) {
|
|
//
|
|
// Validate the Default Spool Directory
|
|
//
|
|
if ( pParams->DefaultSpoolDirectory &&
|
|
!ResUtilIsPathValid( pParams->DefaultSpoolDirectory ) ) {
|
|
status = ERROR_INVALID_PARAMETER;
|
|
goto FnExit;
|
|
}
|
|
|
|
//
|
|
// Make sure there is only one print spooler in this group.
|
|
//
|
|
resourceState = GetClusterResourceState( ResourceEntry->hResource,
|
|
NULL,
|
|
0,
|
|
groupName,
|
|
&groupNameSize );
|
|
if ( !*groupName ) {
|
|
status = GetLastError();
|
|
goto FnExit;
|
|
}
|
|
|
|
status = ResUtilEnumResources(ResourceEntry->hResource,
|
|
CLUS_RESTYPE_NAME_PRTSPLR,
|
|
SplSvcValidateUniqueProperties,
|
|
(PVOID)groupName);
|
|
|
|
if (status != ERROR_SUCCESS) {
|
|
goto FnExit;
|
|
}
|
|
}
|
|
|
|
FnExit:
|
|
|
|
//
|
|
// Cleanup our parameter block.
|
|
//
|
|
if ( ( (status != ERROR_SUCCESS)
|
|
&& (pParams != NULL) )
|
|
|| ( pParams == &newProps )
|
|
) {
|
|
ResUtilFreeParameterBlock( (LPBYTE) pParams,
|
|
(LPBYTE) ¤tProps,
|
|
SplSvcResourcePrivateProperties );
|
|
}
|
|
|
|
ResUtilFreeParameterBlock(
|
|
(LPBYTE) ¤tProps,
|
|
NULL,
|
|
SplSvcResourcePrivateProperties
|
|
);
|
|
|
|
return(status);
|
|
|
|
} // SplSvcValidatePrivateResProperties
|
|
|
|
|
|
|
|
DWORD
|
|
SplSvcSetPrivateResProperties(
|
|
IN OUT PSPOOLER_INFORMATION ResourceEntry,
|
|
IN PVOID InBuffer,
|
|
IN DWORD InBufferSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes the CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES control function
|
|
for resources of type Print Spooler.
|
|
|
|
Arguments:
|
|
|
|
ResourceEntry - Supplies the resource entry on which to operate.
|
|
|
|
InBuffer - Supplies a pointer to a buffer containing input data.
|
|
|
|
InBufferSize - Supplies the size, in bytes, of the data pointed
|
|
to by InBuffer.
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS - The function completed successfully.
|
|
|
|
ERROR_INVALID_PARAMETER - The data is formatted incorrectly.
|
|
|
|
ERROR_NOT_ENOUGH_MEMORY - An error occurred allocating memory.
|
|
|
|
Win32 error code - The function failed.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD status;
|
|
// SPOOLER_PARAMS params;
|
|
|
|
//
|
|
// Parse the properties so they can be validated together.
|
|
// This routine does individual property validation.
|
|
//
|
|
status = SplSvcValidatePrivateResProperties( ResourceEntry,
|
|
InBuffer,
|
|
InBufferSize,
|
|
NULL /*¶ms*/ );
|
|
if ( status != ERROR_SUCCESS ) {
|
|
return(status);
|
|
}
|
|
|
|
//
|
|
// Save the parameter values.
|
|
//
|
|
|
|
status = ResUtilSetPropertyTable( ResourceEntry->ParametersKey,
|
|
SplSvcResourcePrivateProperties,
|
|
NULL,
|
|
TRUE, // Allow unknowns
|
|
InBuffer,
|
|
InBufferSize,
|
|
NULL );
|
|
// status = ResUtilSetPropertyParameterBlock( ResourceEntry->ParametersKey,
|
|
// SplSvcResourcePrivateProperties,
|
|
// NULL,
|
|
// (LPBYTE) ¶ms,
|
|
// InBuffer,
|
|
// InBufferSize,
|
|
// (LPBYTE) &ResourceEntry->Params );
|
|
|
|
// ResUtilFreeParameterBlock( (LPBYTE) ¶ms,
|
|
// (LPBYTE) &ResourceEntry->Params,
|
|
// SplSvcResourcePrivateProperties );
|
|
|
|
//
|
|
// If the resource is online, return a non-success status.
|
|
//
|
|
if (status == ERROR_SUCCESS) {
|
|
if ( (ResourceEntry->eState == kOnline) ||
|
|
(ResourceEntry->eState == kOnlinePending) ) {
|
|
status = ERROR_RESOURCE_PROPERTIES_STORED;
|
|
} else {
|
|
status = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return(status);
|
|
|
|
} // SplSvcSetPrivateResProperties
|
|
|
|
|
|
/********************************************************************
|
|
|
|
Utility functions
|
|
|
|
********************************************************************/
|
|
|
|
|
|
VOID
|
|
vEnterSem(
|
|
VOID
|
|
)
|
|
{
|
|
EnterCriticalSection( &gProcessLock );
|
|
}
|
|
|
|
|
|
VOID
|
|
vLeaveSem(
|
|
VOID
|
|
)
|
|
{
|
|
LeaveCriticalSection( &gProcessLock );
|
|
}
|
|
|
|
VOID
|
|
vAddRef(
|
|
PSPOOLER_INFORMATION pSpoolerInfo
|
|
)
|
|
{
|
|
vEnterSem();
|
|
++pSpoolerInfo->cRef;
|
|
vLeaveSem();
|
|
}
|
|
|
|
|
|
VOID
|
|
vDecRef(
|
|
PSPOOLER_INFORMATION pSpoolerInfo
|
|
)
|
|
{
|
|
UINT uRef;
|
|
|
|
SPLASSERT( pSpoolerInfo->cRef );
|
|
|
|
vEnterSem();
|
|
uRef = --pSpoolerInfo->cRef;
|
|
vLeaveSem();
|
|
|
|
if( !uRef ){
|
|
vDeleteSpoolerInfo( pSpoolerInfo );
|
|
}
|
|
}
|
|
|
|
|
|
//***********************************************************
|
|
//
|
|
// Define Function Table
|
|
//
|
|
//***********************************************************
|
|
|
|
CLRES_V1_FUNCTION_TABLE( SplSvcFunctionTable,
|
|
CLRES_VERSION_V1_00,
|
|
SplSvc,
|
|
NULL,
|
|
NULL,
|
|
SplSvcResourceControl,
|
|
SplSvcResourceTypeControl );
|
|
|