able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/print/spooler/spoolss/win32/cache.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4538 lines
123 KiB
C
Raw Blame History

/*++
Copyright (c) 1994 - 2000 Microsoft Corporation
Module Name:
cache.c
Abstract:
This module contains all the Cache Printer Connection for
true Connected Printers.
--*/
#include <windows.h>
#include <winspool.h>
#include <winsplp.h>
#include <winsprlp.h>
#include <dsgetdc.h>
#include <lm.h>
#include <stdio.h>
#include <string.h>
#include <rpc.h>
#include <offsets.h>
#include <w32types.h>
#include <splcom.h>
#include <local.h>
#include <search.h>
#include <splapip.h>
#include <winerror.h>
#include <gdispool.h>
#include <messages.h>
PWCHAR pszRaw = L"RAW";
PWCHAR szWin32SplDirectory = L"\\spool";
WCHAR szRegistryWin32Root[] = L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Print\\Providers\\LanMan Print Services\\Servers";
WCHAR szOldLocationOfServersKey[] = L"System\\CurrentControlSet\\Control\\Print\\Providers\\LanMan Print Services\\Servers";
WCHAR szPrinters[] = L"\\Printers";
PWCHAR pszRegistryMonitors = L"\\System\\CurrentControlSet\\Control\\Print\\Providers\\LanMan Print Services\\Monitors";
PWCHAR pszRegistryEnvironments = L"System\\CurrentControlSet\\Control\\Print\\Providers\\LanMan Print Services\\Environments";
PWCHAR pszRegistryEventLog = L"SYSTEM\\CurrentControlSet\\Services\\EventLog\\System\\Print";
PWCHAR pszRegistryProviders = L"Providers";
PWCHAR pszEventLogMsgFile = L"%SystemRoot%\\System32\\Win32Spl.dll";
PWCHAR pszDriversShareName = L"wn32prt$";
WCHAR szForms[] = L"\\Forms";
PWCHAR pszMyDllName = L"win32spl.dll";
PWCHAR pszMonitorName = L"LanMan Print Services Port";
const WCHAR gszPointAndPrintPolicies[] = L"Software\\Policies\\Microsoft\\Windows NT\\Printers\\PointAndPrint";
const WCHAR gszPointAndPrintRestricted[] = L"Restricted";
const WCHAR gszPointAndPrintInForest[] = L"InForest";
const WCHAR gszPointAndPrintTrustedServers[] = L"TrustedServers";
const WCHAR gszPointAndPrintServerList[] = L"ServerList";
PWSPOOL pFirstWSpool = NULL;
WCHAR *szCachePrinterInfo2 = L"CachePrinterInfo2";
WCHAR *szCacheTimeLastChange = L"CacheChangeID";
WCHAR *szServerVersion = L"ServerVersion";
WCHAR *szcRef = L"CacheReferenceCount";
WCHAR CacheTimeoutString[] = L"CacheTimeout";
DWORD CacheTimeout = 0;
//
// If we have an rpc handle created recently don't hit the net
//
#define REFRESH_TIMEOUT 15000 // 15 seconds
#define CACHE_TIMEOUT 5000 // Default to 5 seconds.
VOID
RefreshDriverEvent(
PWSPOOL pSpool
)
/*++
Routine Description:
Call out to the Printer Driver UI DLL to allow it to do any caching it might want to do.
For example there might be a large FONT metric file on the print server which is too large
to be written to the registry using SetPrinterData(). This callout will allow the printer
driver to copy this font file to the workstation when the cache is established and will
allow it to periodically check that the file is still valid.
Arguments:
pSpool - Handle to remote printer.
Return Value:
None
--*/
{
SplOutSem();
SplDriverEvent( pSpool->pName, PRINTER_EVENT_CACHE_REFRESH, (LPARAM)NULL );
}
/*++
-- GetCacheTimeout --
Routine Description:
Read the registry to see if anyone has changed the Timeout on the Cache. Default
to CACHE_TIMEOUT if not.
Arguments:
None
Return Value:
Cache Timeout in Milliseconds.
--*/
DWORD GetCacheTimeout(
VOID
)
{
DWORD Value = CACHE_TIMEOUT;
DWORD RegValue = 0;
DWORD RegValueSize = sizeof(RegValue);
HKEY RegKey = NULL;
DWORD dwReturn = ERROR_SUCCESS;
//
// This will only read the timeout from the registry once, after that, it will use
// the stored value. This is not ideal and could be fixed to be per-server,
// depending on the connection speed to the server.
//
if ( CacheTimeout )
{
Value = CacheTimeout;
}
else
{
dwReturn = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
szRegistryWin32Root,
0,
KEY_READ,
&RegKey );
if (dwReturn == ERROR_SUCCESS)
{
dwReturn = RegQueryValueEx( RegKey,
CacheTimeoutString,
NULL,
NULL,
(LPBYTE) &RegValue,
&RegValueSize );
if ( dwReturn == ERROR_SUCCESS )
{
Value = RegValue;
}
dwReturn = RegCloseKey( RegKey );
}
CacheTimeout = Value;
}
return Value;
}
HANDLE
CacheCreateSpooler(
LPWSTR pMachineName,
BOOL bOpenOnly
)
{
PWCHAR pScratch = NULL;
PWCHAR pRegistryRoot = NULL;
PWCHAR pRegistryPrinters = NULL;
SPOOLER_INFO_1 SpoolInfo1;
HANDLE hIniSpooler = INVALID_HANDLE_VALUE;
PWCHAR pMachineOneSlash;
MONITOR_INFO_2 MonitorInfo;
DWORD dwNeeded, cb;
DWORD Returned;
try {
// get size of szRegistryWin32Root (incl NULL) + (pMachineName + 1)
cb = (DWORD)(sizeof szRegistryWin32Root +
MAX(sizeof szPrinters, sizeof szForms) +
wcslen(pMachineName + 1)*sizeof *pMachineName);
if (!(pScratch = AllocSplMem(cb)))
leave;
pMachineOneSlash = pMachineName;
pMachineOneSlash++;
//
// Create a "Machine" for this Printer
//
SpoolInfo1.pDir = gpWin32SplDir; // %systemroot%\system32\win32spl
SpoolInfo1.pDefaultSpoolDir = NULL; // Default %systemroot%\system32\win32spl\PRINTERS
wcscpy( pScratch, szRegistryWin32Root);
wcscat( pScratch, pMachineOneSlash );
if (!(pRegistryRoot = AllocSplStr( pScratch )))
leave;
SpoolInfo1.pszRegistryRoot = pRegistryRoot;
wcscat( pScratch, szPrinters );
if (!(pRegistryPrinters = AllocSplStr( pScratch )))
leave;
SpoolInfo1.pszRegistryPrinters = pRegistryPrinters;
SpoolInfo1.pszRegistryMonitors = pszRegistryMonitors;
SpoolInfo1.pszRegistryEnvironments = pszRegistryEnvironments;
SpoolInfo1.pszRegistryEventLog = pszRegistryEventLog;
SpoolInfo1.pszRegistryProviders = pszRegistryProviders;
SpoolInfo1.pszEventLogMsgFile = pszEventLogMsgFile;
SpoolInfo1.pszDriversShare = pszDriversShareName;
wcscpy( pScratch, szRegistryWin32Root);
wcscat( pScratch, pMachineOneSlash );
wcscat( pScratch, szForms );
SpoolInfo1.pszRegistryForms = pScratch;
// The router graciously does the WIN.INI devices update so let have
// Spl not also create a printer for us.
//
// CLS
//
SpoolInfo1.SpoolerFlags = SPL_BROADCAST_CHANGE |
SPL_TYPE_CACHE |
(bOpenOnly ? SPL_OPEN_EXISTING_ONLY : 0);
SpoolInfo1.pfnReadRegistryExtra = (FARPROC) &CacheReadRegistryExtra;
SpoolInfo1.pfnWriteRegistryExtra = (FARPROC) &CacheWriteRegistryExtra;
SpoolInfo1.pfnFreePrinterExtra = (FARPROC) &CacheFreeExtraData;
SplOutSem();
hIniSpooler = SplCreateSpooler( pMachineName,
1,
(PBYTE)&SpoolInfo1,
NULL );
//
// CLS
//
if ( hIniSpooler == INVALID_HANDLE_VALUE ) {
if (!bOpenOnly)
{
SetLastError( ERROR_INVALID_PRINTER_NAME );
}
} else {
// Add WIN32SPL.DLL as the Monitor
MonitorInfo.pName = pszMonitorName;
MonitorInfo.pEnvironment = szEnvironment;
MonitorInfo.pDLLName = pszMyDllName;
if ( (!SplAddMonitor( NULL, 2, (LPBYTE)&MonitorInfo, hIniSpooler)) &&
( GetLastError() != ERROR_PRINT_MONITOR_ALREADY_INSTALLED ) ) {
DBGMSG( DBG_WARNING, ("CacheCreateSpooler failed SplAddMonitor %d\n", GetLastError()));
SplCloseSpooler( hIniSpooler );
hIniSpooler = INVALID_HANDLE_VALUE;
}
}
} finally {
FreeSplStr ( pScratch );
FreeSplStr ( pRegistryRoot );
FreeSplStr ( pRegistryPrinters );
}
return hIniSpooler;
}
VOID
RefreshCompletePrinterCache(
IN PWSPOOL pSpool,
IN EDriverDownload eDriverDownload
)
{
DBGMSG( DBG_TRACE, ("RefreshCompletePrinterCache %x\n", pSpool));
if (eDriverDownload == kCheckPnPPolicy)
{
BOOL bAllowPointAndPrint = FALSE;
if (BoolFromHResult(DoesPolicyAllowPrinterConnectionsToServer(pSpool->pName, &bAllowPointAndPrint)) &&
bAllowPointAndPrint)
{
eDriverDownload = kDownloadDriver;
}
else
{
eDriverDownload = kDontDownloadDriver;
}
}
//
// Note the order is important.
// Refreshing the printer might require that the new driver has
// been installed on the system. If policy doesn't allow us to
// fetch the driver, you are just out of luck.
//
RefreshPrinterDriver(pSpool, NULL, eDriverDownload);
RefreshFormsCache( pSpool );
RefreshPrinterDataCache(pSpool);
RefreshPrinterCopyFiles(pSpool);
RefreshDriverEvent( pSpool );
SplBroadcastChange(pSpool->hSplPrinter, WM_DEVMODECHANGE, 0, (LPARAM) pSpool->pName);
}
PPRINTER_INFO_2
GetRemotePrinterInfo(
PWSPOOL pSpool,
LPDWORD pReturnCount
)
{
PPRINTER_INFO_2 pRemoteInfo = NULL;
HANDLE hPrinter = (HANDLE) pSpool;
DWORD cbRemoteInfo = 0;
DWORD dwBytesNeeded = 0;
DWORD dwLastError = 0;
BOOL bReturnValue = FALSE;
*pReturnCount = 0;
do {
if ( pRemoteInfo != NULL ) {
FreeSplMem( pRemoteInfo );
pRemoteInfo = NULL;
cbRemoteInfo = 0;
}
if ( dwBytesNeeded != 0 ) {
pRemoteInfo = AllocSplMem( dwBytesNeeded );
if ( pRemoteInfo == NULL )
break;
}
cbRemoteInfo = dwBytesNeeded;
bReturnValue = RemoteGetPrinter( hPrinter,
2,
(LPBYTE)pRemoteInfo,
cbRemoteInfo,
&dwBytesNeeded );
dwLastError = GetLastError();
} while ( !bReturnValue && dwLastError == ERROR_INSUFFICIENT_BUFFER );
if ( !bReturnValue && pRemoteInfo != NULL ) {
FreeSplMem( pRemoteInfo );
pRemoteInfo = NULL;
cbRemoteInfo = 0;
}
*pReturnCount = cbRemoteInfo;
return pRemoteInfo;
}
//
// This routine Clones the Printer_Info_2 structure from the Remote machine
//
//
PWCACHEINIPRINTEREXTRA
AllocExtraData(
PPRINTER_INFO_2W pPrinterInfo2,
DWORD cbPrinterInfo2
)
{
PWCACHEINIPRINTEREXTRA pExtraData = NULL;
DWORD cbSize;
SPLASSERT( cbPrinterInfo2 != 0);
SPLASSERT( pPrinterInfo2 != NULL );
cbSize = sizeof( WCACHEINIPRINTEREXTRA );
pExtraData = AllocSplMem( cbSize );
if ( pExtraData != NULL ) {
pExtraData->signature = WCIP_SIGNATURE;
pExtraData->cb = cbSize;
pExtraData->cRef = 0;
pExtraData->cbPI2 = cbPrinterInfo2;
pExtraData->dwTickCount = GetTickCount();
pExtraData->pPI2 = AllocSplMem( cbPrinterInfo2 );
if ( pExtraData->pPI2 != NULL ) {
CacheCopyPrinterInfo( pExtraData->pPI2, pPrinterInfo2, cbPrinterInfo2 );
} else {
FreeSplMem( pExtraData );
pExtraData = NULL;
}
}
return pExtraData;
}
VOID
CacheFreeExtraData(
PWCACHEINIPRINTEREXTRA pExtraData
)
{
PWCACHEINIPRINTEREXTRA pPrev = NULL;
PWCACHEINIPRINTEREXTRA pCur = NULL;
if ( pExtraData != NULL ) {
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
if ( pExtraData->cRef != 0 ) {
DBGMSG( DBG_TRACE, ("CacheFreeExtraData pExtraData %x cRef %d != 0 freeing anyway\n",
pExtraData,
pExtraData->cRef ));
}
if ( pExtraData->pPI2 != NULL ) {
FreeSplMem( pExtraData->pPI2 );
}
FreeSplMem( pExtraData );
}
}
VOID
DownAndMarshallUpStructure(
LPBYTE lpStructure,
LPBYTE lpSource,
LPDWORD lpOffsets
)
{
register DWORD i=0;
while (lpOffsets[i] != -1) {
if ((*(LPBYTE *)(lpStructure+lpOffsets[i]))) {
(*(LPBYTE *)(lpStructure+lpOffsets[i]))-=(UINT_PTR)lpSource;
(*(LPBYTE *)(lpStructure+lpOffsets[i]))+=(UINT_PTR)lpStructure;
}
i++;
}
}
VOID
CacheCopyPrinterInfo(
PPRINTER_INFO_2W pDestination,
PPRINTER_INFO_2W pPrinterInfo2,
DWORD cbPrinterInfo2
)
{
LPWSTR SourceStrings[sizeof(PRINTER_INFO_2)/sizeof(LPWSTR)];
LPWSTR *pSourceStrings = SourceStrings;
//
// Copy the lot then fix up the pointers
//
CopyMemory( pDestination, pPrinterInfo2, cbPrinterInfo2 );
DownAndMarshallUpStructure( (LPBYTE)pDestination, (LPBYTE)pPrinterInfo2, PrinterInfo2Offsets );
}
VOID
ConvertRemoteInfoToLocalInfo(
PPRINTER_INFO_2 pPrinterInfo2
)
{
SPLASSERT( pPrinterInfo2 != NULL );
DBGMSG(DBG_TRACE,("%ws %ws ShareName %x %ws pSecurityDesc %x Attributes %x StartTime %d UntilTime %d Status %x\n",
pPrinterInfo2->pServerName,
pPrinterInfo2->pPrinterName,
pPrinterInfo2->pShareName,
pPrinterInfo2->pPortName,
pPrinterInfo2->pSecurityDescriptor,
pPrinterInfo2->Attributes,
pPrinterInfo2->StartTime,
pPrinterInfo2->UntilTime,
pPrinterInfo2->Status));
//
// GetPrinter returns the name \\server\printername we only want the printer name
//
pPrinterInfo2->pPrinterName = wcschr( pPrinterInfo2->pPrinterName + 2, L'\\' );
if( !pPrinterInfo2->pPrinterName ){
SPLASSERT( FALSE );
pPrinterInfo2->pPrinterName = pPrinterInfo2->pPrinterName;
} else {
pPrinterInfo2->pPrinterName++;
}
//
// LATER this should be a Win32Spl Port
//
pPrinterInfo2->pPortName = L"NExx:";
pPrinterInfo2->pSepFile = NULL;
pPrinterInfo2->pSecurityDescriptor = NULL;
pPrinterInfo2->pPrintProcessor = L"winprint";
pPrinterInfo2->pDatatype = pszRaw;
pPrinterInfo2->pParameters = NULL;
pPrinterInfo2->Attributes &= ~( PRINTER_ATTRIBUTE_NETWORK | PRINTER_ATTRIBUTE_DIRECT | PRINTER_ATTRIBUTE_SHARED );
pPrinterInfo2->StartTime = 0;
pPrinterInfo2->UntilTime = 0;
//
// ConvertRemoteInfoToLocalInfo is called once before an SplAddPrinter
// and once before an SplSetPrinter, both level 2. Neither SplAddPrinter, nor
// SplSetPrinter look at the Status field in the printer info. So the
// value below is artificial. We just give it an initial state.
//
pPrinterInfo2->Status = 0;
pPrinterInfo2->cJobs = 0;
pPrinterInfo2->AveragePPM = 0;
}
VOID
RefreshPrinter(
PWSPOOL pSpool
)
{
PPRINTER_INFO_2 pRemoteInfo = NULL;
DWORD cbRemoteInfo = 0;
BOOL ReturnValue;
PWCACHEINIPRINTEREXTRA pExtraData = NULL;
PWCACHEINIPRINTEREXTRA pNewExtraData = NULL;
PPRINTER_INFO_2 pTempPI2 = NULL;
PPRINTER_INFO_2 pCopyExtraPI2ToFree = NULL;
DWORD dwLastError;
//
// Get the Remote Printer Info
//
pRemoteInfo = GetRemotePrinterInfo( pSpool, &cbRemoteInfo );
if ( pRemoteInfo != NULL ) {
// LATER
// Optimization could be to only update the cache if something
// actually changed.
// IE Compare every field.
EnterSplSem();
ReturnValue = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( ReturnValue == FALSE ) {
DBGMSG( DBG_WARNING, ("RefreshPrinter SplGetPrinterExtra pSpool %x error %d\n", pSpool, GetLastError() ));
SPLASSERT( ReturnValue );
}
if ( pExtraData == NULL ) {
pExtraData = AllocExtraData( pRemoteInfo, cbRemoteInfo );
if ( pExtraData != NULL ) {
pExtraData->cRef++;
}
} else {
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
pTempPI2 = AllocSplMem( cbRemoteInfo );
if ( pTempPI2 != NULL ) {
SplInSem();
CacheCopyPrinterInfo( pTempPI2, pRemoteInfo, cbRemoteInfo );
pCopyExtraPI2ToFree = pExtraData->pPI2;
pExtraData->pPI2 = pTempPI2;
pExtraData->cbPI2 = cbRemoteInfo;
}
}
LeaveSplSem();
if ( pExtraData != NULL ) {
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
}
ConvertRemoteInfoToLocalInfo( pRemoteInfo );
ReturnValue = SplSetPrinter( pSpool->hSplPrinter, 2, (LPBYTE)pRemoteInfo, 0 );
if ( !ReturnValue ) {
//
// If the driver is blocked and the driver has changed, we want to log
// an event.
//
dwLastError = GetLastError();
if (ERROR_KM_DRIVER_BLOCKED == dwLastError &&
pCopyExtraPI2ToFree &&
pCopyExtraPI2ToFree->pDriverName &&
pRemoteInfo->pDriverName &&
_wcsicmp(pCopyExtraPI2ToFree->pDriverName, pRemoteInfo->pDriverName)) {
//
// We have entered a mismatched case through someone admin'ing a
// remote server. Log an error message, we cannot throw UI at this
// point.
//
SplLogEventExternal(LOG_ERROR,
MSG_DRIVER_MISMATCHED_WITH_SERVER,
pSpool->pName,
pRemoteInfo->pDriverName,
NULL);
}
else if(dwLastError == ERROR_UNKNOWN_PRINTER_DRIVER)
{
if (ReturnValue = AddDriverFromLocalCab(pRemoteInfo->pDriverName, pSpool->hIniSpooler))
{
ReturnValue = SplSetPrinter(pSpool->hSplPrinter, 2, (LPBYTE)pRemoteInfo, 0);
}
}
DBGMSG( DBG_WARNING, ("RefreshPrinter Failed SplSetPrinter %d\n", GetLastError() ));
}
ReturnValue = SplSetPrinterExtra( pSpool->hSplPrinter, (LPBYTE)pExtraData );
if (!ReturnValue) {
DBGMSG(DBG_ERROR, ("RefreshPrinter SplSetPrinterExtra failed %x\n", GetLastError()));
}
} else {
DBGMSG( DBG_WARNING, ("RefreshPrinter failed GetRemotePrinterInfo %x\n", GetLastError() ));
}
if ( pRemoteInfo != NULL )
FreeSplMem( pRemoteInfo );
if (pCopyExtraPI2ToFree != NULL) {
FreeSplMem(pCopyExtraPI2ToFree);
}
}
VOID
RefreshPrinterInfo7(
PWSPOOL pSpool
)
{
PPRINTER_INFO_7 pInfo = NULL;
DWORD cbNeeded = 0;
BOOL bRet;
bRet = RemoteGetPrinter((HANDLE) pSpool, 7, (PBYTE) pInfo, 0, &cbNeeded);
if (bRet) {
DBGMSG( DBG_ERROR, ("RefreshPrinterInfo7 Illegally succeeded RemoteGetPrinter %d\n"));
goto done;
} else if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
DBGMSG( DBG_WARNING, ("RefreshPrinterInfo7 Failed RemoteGetPrinter %d\n", GetLastError()));
goto done;
}
if (!(pInfo = (PPRINTER_INFO_7) AllocSplMem(cbNeeded))) {
DBGMSG( DBG_WARNING, ("RefreshPrinterInfo7 Failed RemoteGetPrinter %d\n", GetLastError()));
goto done;
}
if (!RemoteGetPrinter((HANDLE) pSpool, 7, (PBYTE) pInfo, cbNeeded, &cbNeeded)) {
DBGMSG( DBG_WARNING, ("RefreshPrinterInfo7 Failed RemoteGetPrinter %d\n", GetLastError()));
goto done;
}
if (!SplSetPrinter( pSpool->hSplPrinter, 7, (PBYTE) pInfo, 0)) {
DBGMSG( DBG_WARNING, ("RefreshPrinterInfo7 Failed RemoteSetPrinter %d\n", GetLastError()));
goto done;
}
done:
FreeSplMem(pInfo);
}
//
// TESTING
//
DWORD dwAddPrinterConnection = 0;
PWSPOOL
InternalAddPrinterConnection(
LPWSTR pName
)
/*++
Function Description: InternalAddPrinterConnection creates a printer connection.
Parameters: pName - name of the printer connection
Return Values: pSpool if successful;
NULL otherwise
--*/
{
PWSPOOL pSpool = NULL;
BOOL bReturnValue = FALSE;
HANDLE hIniSpooler = INVALID_HANDLE_VALUE;
PPRINTER_INFO_2 pPrinterInfo2 = NULL;
DWORD cbPrinterInfo2 = 0;
HANDLE hSplPrinter = INVALID_HANDLE_VALUE;
PWCACHEINIPRINTEREXTRA pExtraData = NULL;
PWCACHEINIPRINTEREXTRA pExtraData2 = NULL;
BOOL bSuccess = FALSE;
LPPRINTER_INFO_STRESSW pPrinter0 = NULL;
DWORD dwNeeded;
DWORD LastError = ERROR_SUCCESS;
BOOL bLoopDetected = FALSE;
BOOL bAllowPointAndPrint = FALSE;
BOOL bAllowDriverDownload = FALSE;
//
// TESTING
//
++dwAddPrinterConnection;
try {
if (!VALIDATE_NAME(pName)) {
SetLastError(ERROR_INVALID_NAME);
leave;
}
if (!RemoteOpenPrinter(pName, &pSpool, NULL, DO_NOT_CALL_LM_OPEN)) {
leave;
}
pPrinter0 = AllocSplMem( MAX_PRINTER_INFO0 );
if ( pPrinter0 == NULL )
leave;
SPLASSERT( pSpool != NULL );
SPLASSERT( pSpool->Type == SJ_WIN32HANDLE );
DBGMSG( DBG_TRACE, ("AddPrinterConnection pName %ws pSpool %x\n",pName, pSpool ));
//
// Get Remote ChangeID to be certain nothing changes on the Server
// whilst we are establishing our Cache.
//
bReturnValue = RemoteGetPrinter( pSpool, STRESSINFOLEVEL, (LPBYTE)pPrinter0, MAX_PRINTER_INFO0, &dwNeeded );
if ( !bReturnValue ) {
SPLASSERT( GetLastError() != ERROR_INSUFFICIENT_BUFFER );
DBGMSG(DBG_TRACE, ("AddPrinterConnection failed RemoteGetPrinter %d\n", GetLastError()));
pPrinter0->cChangeID = 0;
}
DBGMSG( DBG_TRACE, ("AddPrinterConnection << Server cCacheID %x >>\n", pPrinter0->cChangeID ));
//
// See If the Printer is already in the Cache
//
APC_OpenCache:
bReturnValue = OpenCachePrinterOnly( pName, &hSplPrinter, &hIniSpooler, NULL, FALSE);
if ( hIniSpooler == INVALID_HANDLE_VALUE ) {
DBGMSG( DBG_WARNING, ("AddPrinterConnection - CacheCreateSpooler Failed %x\n",GetLastError()));
leave;
}
pSpool->hIniSpooler = hIniSpooler;
if ( bReturnValue ) {
//
// Printer Exists in Cache
//
DBGMSG( DBG_TRACE,("AddPrinterConnection hIniSpooler %x hSplPrinter%x\n", hIniSpooler, hSplPrinter) );
pSpool->hSplPrinter = hSplPrinter;
pSpool->Status |= WSPOOL_STATUS_USE_CACHE;
//
// Update Connection Reference Count
//
EnterSplSem();
bReturnValue = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( bReturnValue == FALSE ) {
DBGMSG( DBG_WARNING, ("AddPrinterConnection SplGetPrinterExtra pSpool %x error %d\n", pSpool, GetLastError() ));
SPLASSERT( bReturnValue );
}
if ( pExtraData != NULL ) {
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
pExtraData->cRef++;
}
LeaveSplSem();
// Make Sure Reference Count Gets Updated in Registry
if ( !SplSetPrinterExtra( hSplPrinter, (LPBYTE)pExtraData ) ) {
DBGMSG( DBG_ERROR, ("AddPrinterConnection SplSetPrinterExtra failed %x\n", GetLastError() ));
}
// Refresh Cache
// It could be that the remote machine is old NT Daytona 3.5 or before
// which doesn't support the ChangeID, that would mean the only
// way for a user to force an update is to do a connection.
if ( pPrinter0->cChangeID == 0 ) {
// Old NT
RefreshCompletePrinterCache(pSpool, kCheckPnPPolicy);
} else {
//
// Since we have this in the cache anyway, we might as well sync
// settings, we only sync settings if we are allowed to download
// the driver.
//
ConsistencyCheckCache(pSpool, kCheckPnPPolicy);
}
pExtraData = NULL;
bSuccess = TRUE;
leave;
} else if ( GetLastError() != ERROR_INVALID_PRINTER_NAME &&
GetLastError() != ERROR_INVALID_NAME ) {
DBGMSG( DBG_WARNING, ("AddPrinterConnection failed OpenCachePrinterOnly %d\n", GetLastError() ));
leave;
}
//
// There is NO Cache Entry for This Printer
//
DBGMSG( DBG_TRACE, ("AddPrinterConnection failed SplOpenPrinter %ws %d\n", pName, GetLastError() ));
//
// Get PRINTER Info from Remote Machine
//
pPrinterInfo2 = GetRemotePrinterInfo( pSpool, &cbPrinterInfo2 );
if ( pPrinterInfo2 == NULL ) {
DBGMSG( DBG_WARNING, ("AddPrinterConnection failed GetRemotePrinterInfo %x\n", GetLastError() ));
leave;
}
if (BoolFromHResult(DoesPolicyAllowPrinterConnectionsToServer(pSpool->pName, &bAllowPointAndPrint)) &&
bAllowPointAndPrint)
{
bAllowDriverDownload = TRUE;
}
if (!RefreshPrinterDriver( pSpool, pPrinterInfo2->pDriverName, bAllowDriverDownload ? kDownloadDriver : kDontDownloadDriver) && (ERROR_PRINTER_DRIVER_BLOCKED == GetLastError()))
{
leave;
}
//
// Allocate My Extra Data for this Printer
// ( from RemoteGetPrinter )
// We need a pExtraData2 - if this is blocked by KM blocking we need to have a copy to
// retry the install.
//
pExtraData = AllocExtraData( pPrinterInfo2, cbPrinterInfo2 );
if ( pExtraData == NULL )
leave;
pExtraData2 = AllocExtraData( pPrinterInfo2, cbPrinterInfo2 );
if ( pExtraData2 == NULL )
leave;
pExtraData->cRef++;
pExtraData2->cRef++;
pExtraData2->cCacheID = pExtraData->cCacheID = pPrinter0->cChangeID;
pExtraData2->dwServerVersion = pExtraData->dwServerVersion = pPrinter0->dwGetVersion;
//
// Convert Remote Printer_Info_2 to Local Version for Cache
//
ConvertRemoteInfoToLocalInfo( pPrinterInfo2 );
//
// Add Printer to Cache
//
hSplPrinter = SplAddPrinter(NULL, 2, (LPBYTE)pPrinterInfo2,
hIniSpooler, (LPBYTE)pExtraData,
NULL, 0);
pExtraData = NULL;
if ( (hSplPrinter == NULL || hSplPrinter == INVALID_HANDLE_VALUE) &&
GetLastError() == ERROR_KM_DRIVER_BLOCKED ) {
//
// Failed due to KM Blocking
// - lets try add a driver from the local cab as this should fix this.
//
if( !AddDriverFromLocalCab( pPrinterInfo2->pDriverName, hIniSpooler ) ) {
//
// Set the old last error back as we don't really care that this failed.
//
SetLastError( ERROR_KM_DRIVER_BLOCKED );
} else {
hSplPrinter = SplAddPrinter(NULL, 2, (LPBYTE)pPrinterInfo2,
hIniSpooler, (LPBYTE)pExtraData2,
NULL, 0);
pExtraData2 = NULL;
}
}
if ( hSplPrinter == NULL ||
hSplPrinter == INVALID_HANDLE_VALUE ) {
LastError = GetLastError();
if ( LastError == ERROR_PRINTER_ALREADY_EXISTS ) {
SplCloseSpooler( pSpool->hIniSpooler );
hIniSpooler = INVALID_HANDLE_VALUE;
if ( bLoopDetected == FALSE ) {
bLoopDetected = TRUE;
goto APC_OpenCache;
} else {
DBGMSG( DBG_WARNING, ("AddPrinterConnection APC_OpenCache Loop Detected << Should Never Happen >>\n"));
leave;
}
}
//
// If we could not add the printer, and it wasn't because it is already
// there, and we weren't able to download the driver because of policy,
// then we need to return an appropriate error code so that the UI can
// inform the user about it.
//
else if (!bAllowDriverDownload && LastError == ERROR_UNKNOWN_PRINTER_DRIVER)
{
LastError = ERROR_ACCESS_DISABLED_BY_POLICY;
}
// If we failed to Create the printer above, we should NOT be able to Open it now.
DBGMSG( DBG_WARNING, ("AddPrinterConnection Failed SplAddPrinter error %d\n", LastError ));
hSplPrinter = INVALID_HANDLE_VALUE;
bSuccess = FALSE;
leave;
}
DBGMSG( DBG_TRACE, ("AddPrinterConnection SplAddPrinter SUCCESS hSplPrinter %x\n", hSplPrinter));
pSpool->hSplPrinter = hSplPrinter;
pSpool->Status |= WSPOOL_STATUS_USE_CACHE;
RefreshFormsCache(pSpool);
RefreshPrinterDataCache(pSpool);
RefreshPrinterCopyFiles(pSpool);
RefreshDriverEvent(pSpool);
//
// Just In Case something change whilst we were initializing the cache
// go check it again now. Don't check policy again since we have recently
// verified that we can comunicate with this server.
//
ConsistencyCheckCache(pSpool, bAllowDriverDownload ? kDownloadDriver : kDontDownloadDriver);
bSuccess = TRUE;
} finally {
if ( !bSuccess ) {
if ( LastError == ERROR_SUCCESS )
LastError = GetLastError();
InternalDeletePrinterConnection( pName, FALSE );
if ( pSpool != NULL && pSpool != INVALID_HANDLE_VALUE ) {
pSpool->Status &= ~WSPOOL_STATUS_TEMP_CONNECTION;
CacheClosePrinter( pSpool );
}
SetLastError( LastError );
DBGMSG( DBG_TRACE, ("AddPrinterConnection %ws Failed %d\n", pName, GetLastError() ));
pSpool = NULL;
}
if ( pPrinterInfo2 != NULL )
FreeSplMem( pPrinterInfo2 );
if ( pPrinter0 != NULL )
FreeSplMem( pPrinter0 );
if ( pExtraData != NULL )
CacheFreeExtraData( pExtraData );
if ( pExtraData2 != NULL )
CacheFreeExtraData( pExtraData2 );
}
return pSpool;
}
/*++
Function Name:
AddPrinterConnectionPrivate
Function Description:
AddPrinterConnectionPrivate creates a printer connection. It does
not check to see if the printer connection already exists in the
users registry.
Parameters:
pName - name of the printer connection
Return Values:
TRUE if successful;
FALSE otherwise
--*/
BOOL
AddPrinterConnectionPrivate(
LPWSTR pName
)
{
PWSPOOL pSpool;
BOOL bReturn;
pSpool = InternalAddPrinterConnection(pName);
if (pSpool != NULL)
{
//
// We have a valid handle. The connection has been created. Succeed after
// closing the handle
//
CacheClosePrinter(pSpool);
bReturn = TRUE;
}
else
{
//
// Failed to create the connection.
//
bReturn = FALSE;
}
return bReturn;
}
/*++
Function Name:
AddPrinterConnection
Function Description:
AddPrinterConnection creates a printer connection. We check to see
whether the printer connection already exists in the user registry.
This works because an OpenPrinter will always occur from the router
before an AddPrinter Connection. So, this will always create a
printer connection from the registry in CacheOpenPrinter(). If we see
this state, we simpy return TRUE.
Parameters:
pName - name of the printer connection
Return Values:
TRUE if successful;
FALSE otherwise
--*/
BOOL
AddPrinterConnection(
LPWSTR pName
)
{
BOOL bRet = FALSE;
if (PrinterConnectionExists(pName))
{
bRet = TRUE;
}
else
{
//
// Make sure that this call is local, otherwise a remote caller could
// come in and trick us into connection to him and downloading the
// driver.
//
bRet = IsLocalCall();
if (bRet)
{
bRet = AddPrinterConnectionPrivate(pName);
}
else
{
SetLastError(ERROR_ACCESS_DENIED);
}
}
return bRet;
}
//
// TESTING
//
DWORD dwRefreshFormsCache = 0;
DWORD dwNoMatch = 0;
DWORD dwDeleteForm = 0;
DWORD dwAddForm = 0;
VOID
RefreshFormsCache(
PWSPOOL pSpool
)
/*++
Routine Description:
This routine will check to see if any forms have changed. If anything changed it adds
or deletes forms from the cache so that it matches the server.
Note it is very important that the order of the forms on the workstation matches those
on the Server.
Implementation:
EnumRemoteForms
EnumLocalForms
If there is any difference
Delete All LocalForms
Add All the Remote Forms
The code is optimized for the typical case
Forms are added at the end only.
Forms are hardly ever deleted.
Arguments:
pSpool - Handle to remote printer.
Return Value:
None
--*/
{
PFORM_INFO_1 pRemoteForms = NULL , pSaveRemoteForms = NULL;
PFORM_INFO_1 pLocalCacheForms = NULL, pSaveLocalCacheForms = NULL;
PFORM_INFO_1 pRemote = NULL, pLocal = NULL;
DWORD dwBuf = 0;
DWORD dwSplBuf = 0;
DWORD dwNeeded = 0;
DWORD dwSplNeeded = 0;
DWORD dwRemoteFormsReturned = 0;
DWORD dwSplReturned = 0;
BOOL bReturnValue = FALSE;
DWORD LastError = ERROR_INSUFFICIENT_BUFFER;
INT iCompRes = 0;
DWORD LoopCount;
BOOL bCacheMatchesRemoteMachine = FALSE;
SPLASSERT( pSpool != NULL );
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
//
// Get Remote Machine Forms Data
//
//
// TESTING
//
++dwRefreshFormsCache;
do {
bReturnValue = RemoteEnumForms( (HANDLE)pSpool, 1, (LPBYTE)pRemoteForms, dwBuf, &dwNeeded, &dwRemoteFormsReturned);
if ( bReturnValue )
break;
LastError = GetLastError();
if ( LastError != ERROR_INSUFFICIENT_BUFFER ) {
DBGMSG( DBG_WARNING, ("RefreshFormsCache Failed RemoteEnumForms error %d\n", GetLastError()));
goto RefreshFormsCacheErrorReturn;
}
if ( pRemoteForms != NULL )
FreeSplMem( pRemoteForms );
pRemoteForms = AllocSplMem( dwNeeded );
pSaveRemoteForms = pRemoteForms;
dwBuf = dwNeeded;
if ( pRemoteForms == NULL ) {
DBGMSG( DBG_WARNING, ("RefreshFormsCache Failed AllocSplMem Error %d dwNeeded %d\n", GetLastError(), dwNeeded));
goto RefreshFormsCacheErrorReturn;
}
} while ( !bReturnValue && LastError == ERROR_INSUFFICIENT_BUFFER );
if( pRemoteForms == NULL ) {
DBGMSG( DBG_WARNING, ("RefreshFormsCache Failed pRemoteForms == NULL\n"));
goto RefreshFormsCacheErrorReturn;
}
//
// Get LocalCachedForms Data
//
do {
bReturnValue = SplEnumForms( pSpool->hSplPrinter, 1, (LPBYTE)pLocalCacheForms, dwSplBuf, &dwSplNeeded, &dwSplReturned);
if ( bReturnValue )
break;
LastError = GetLastError();
if ( LastError != ERROR_INSUFFICIENT_BUFFER ) {
DBGMSG( DBG_WARNING, ("RefreshFormsCache Failed SplEnumForms hSplPrinter %x error %d\n", pSpool->hSplPrinter, GetLastError()));
goto RefreshFormsCacheErrorReturn;
}
if ( pLocalCacheForms != NULL )
FreeSplMem( pLocalCacheForms );
pLocalCacheForms = AllocSplMem( dwSplNeeded );
pSaveLocalCacheForms = pLocalCacheForms;
dwSplBuf = dwSplNeeded;
if ( pLocalCacheForms == NULL ) {
DBGMSG( DBG_WARNING, ("RefreshFormsCache Failed AllocSplMem ( %d )\n",dwSplNeeded));
goto RefreshFormsCacheErrorReturn;
}
} while ( !bReturnValue && LastError == ERROR_INSUFFICIENT_BUFFER );
//
// Optimization Check Local vs Remote
// If nothing has changed no need to do anything
//
SPLASSERT( pRemoteForms != NULL );
for ( LoopCount = 0, pRemote = pRemoteForms, pLocal = pLocalCacheForms, bCacheMatchesRemoteMachine = TRUE;
LoopCount < dwSplReturned && LoopCount < dwRemoteFormsReturned && bCacheMatchesRemoteMachine;
LoopCount++, pRemote++, pLocal++ ) {
//
// If the form name is different, or the dimensions are different,
// then refresh the forms cache.
//
// Note: if the forms are both built-in, then bypass the string
// match since built in forms are standardized. We actually
// should be able to bypass all checks.
//
if (( wcscmp( pRemote->pName, pLocal->pName ) != STRINGS_ARE_EQUAL ) ||
( pRemote->Size.cx != pLocal->Size.cx ) ||
( pRemote->Size.cy != pLocal->Size.cy ) ||
( pRemote->ImageableArea.left != pLocal->ImageableArea.left ) ||
( pRemote->ImageableArea.top != pLocal->ImageableArea.top ) ||
( pRemote->ImageableArea.right != pLocal->ImageableArea.right ) ||
( pRemote->ImageableArea.bottom != pLocal->ImageableArea.bottom ) ) {
DBGMSG( DBG_TRACE, ("RefreshFormsCache Remote cx %d cy %d left %d right %d top %d bottom %d %ws\n",
pRemote->Size.cx, pRemote->Size.cy,
pRemote->ImageableArea.left,
pRemote->ImageableArea.right,
pRemote->ImageableArea.top,
pRemote->ImageableArea.bottom,
pRemote->pName));
DBGMSG( DBG_TRACE, ("RefreshFormsCache Local cx %d cy %d left %d right %d top %d bottom %d %ws - Does Not Match\n",
pLocal->Size.cx, pLocal->Size.cy,
pLocal->ImageableArea.left,
pLocal->ImageableArea.right,
pLocal->ImageableArea.top,
pLocal->ImageableArea.bottom,
pLocal->pName));
bCacheMatchesRemoteMachine = FALSE;
}
}
//
// If Everything matches we're done.
//
if ( bCacheMatchesRemoteMachine ) {
if ( dwRemoteFormsReturned == dwSplReturned ) {
DBGMSG( DBG_TRACE, ("RefreshFormsCache << Cache Forms Match Remote Forms - Nothing to do >>\n"));
goto RefreshFormsCacheReturn;
} else if (dwRemoteFormsReturned > dwSplReturned){
//
// All the forms we have in the cache match
// Now add the Extra Remote Forms.
dwRemoteFormsReturned -= dwSplReturned;
pRemoteForms = pRemote;
// dwSplReturned == 0 will skip the delete loop
dwSplReturned = 0;
}
}
//
// TESTING
//
++dwNoMatch;
DBGMSG( DBG_TRACE, ("RefreshFormsCache - Something Doesn't Match, Delete all the Cache and Refresh it\n"));
//
// Delete all the forms in the Cache
//
for ( LoopCount = dwSplReturned, pLocal = pLocalCacheForms;
LoopCount != 0;
pLocal++, LoopCount-- ) {
//
// TESTING
//
++dwDeleteForm;
bReturnValue = SplDeleteForm( pSpool->hSplPrinter, pLocal->pName );
DBGMSG( DBG_TRACE, ("RefreshFormsCache %x SplDeleteForm( %x, %ws)\n",bReturnValue, pSpool->hSplPrinter, pLocal->pName));
}
//
// Add all the Remote Forms to the Cache
//
for ( LoopCount = dwRemoteFormsReturned, pRemote = pRemoteForms;
LoopCount != 0;
LoopCount--, pRemote++ ) {
//
// TESTING
//
++dwAddForm;
SPLASSERT( pRemote != NULL );
bReturnValue = SplAddForm( pSpool->hSplPrinter, 1, (LPBYTE)pRemote );
DBGMSG( DBG_TRACE, ("RefreshFormsCache %x SplAddForm( %x, 1, %ws)\n",bReturnValue, pSpool->hSplPrinter, pRemote->pName));
}
RefreshFormsCacheReturn:
RefreshFormsCacheErrorReturn:
if ( pSaveRemoteForms != NULL )
FreeSplMem( pSaveRemoteForms );
if ( pSaveLocalCacheForms != NULL )
FreeSplMem( pSaveLocalCacheForms );
}
VOID
RefreshDriverDataCache(
PWSPOOL pSpool
)
{
DWORD iCount = 0;
DWORD dwType = 0;
DWORD ReturnValue = 0;
LPBYTE lpbData = NULL;
DWORD dwSizeData;
DWORD dwMaxSizeData;
LPWSTR pValueString = NULL;
DWORD dwSizeValueString;
DWORD dwMaxSizeValueString;
SPLASSERT( pSpool != NULL );
SPLASSERT( pSpool->signature == WSJ_SIGNATURE );
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->pName != NULL );
// Get the required sizes
ReturnValue = RemoteEnumPrinterData(pSpool,
iCount,
pValueString,
0,
&dwMaxSizeValueString,
&dwType,
lpbData,
0,
&dwMaxSizeData);
if (ReturnValue != ERROR_SUCCESS) {
DBGMSG( DBG_TRACE, ("RefreshDriverDataCache Failed first RemoteEnumPrinterData %d\n", GetLastError()));
goto RefreshDriverDataCacheError;
}
// Allocate
if ((pValueString = AllocSplMem(dwMaxSizeValueString)) == NULL) {
DBGMSG( DBG_WARNING, ("RefreshDriverDataCache Failed to allocate enough memory\n"));
goto RefreshDriverDataCacheError;
}
if ((lpbData = AllocSplMem(dwMaxSizeData)) == NULL) {
DBGMSG( DBG_WARNING, ("RefreshDriverDataCache Failed to allocate enough memory\n"));
goto RefreshDriverDataCacheError;
}
// Enumerate
for (iCount = 0 ;
RemoteEnumPrinterData( pSpool,
iCount,
pValueString,
dwMaxSizeValueString,
&dwSizeValueString,
&dwType,
lpbData,
dwMaxSizeData,
&dwSizeData) == ERROR_SUCCESS ;
++iCount) {
//
// Optimization - Do NOT write the data if it is the same
//
if ((ReturnValue = SplSetPrinterData(pSpool->hSplPrinter,
(LPWSTR)pValueString,
dwType,
lpbData,
dwSizeData )) != ERROR_SUCCESS) {
DBGMSG( DBG_WARNING, ("RefreshDriverDataCache Failed SplSetPrinterData %d\n",ReturnValue ));
goto RefreshDriverDataCacheError;
}
}
RefreshDriverDataCacheError:
FreeSplMem( lpbData );
FreeSplStr( pValueString );
}
VOID
RefreshPrinterDataCache(
PWSPOOL pSpool
)
{
DWORD ReturnValue = 0;
DWORD cbSubKeys;
DWORD dwResult;
SPLASSERT( pSpool != NULL );
SPLASSERT( pSpool->signature == WSJ_SIGNATURE );
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->pName != NULL );
// This call to RemoteEnumPrinterKey is here so we can find out
// if the server exists and supports EnumPrinterKey
dwResult = RemoteEnumPrinterKey(pSpool,
L"",
NULL,
0,
&cbSubKeys);
DBGMSG(DBG_TRACE, ("RefreshPrinterDataCache: EnumPrinterKey Return: %0x\n", dwResult));
if (dwResult == ERROR_MORE_DATA) { // Server exists and supports EnumPrinterKey
// Clean out old data
SplDeletePrinterKey(pSpool->hSplPrinter, L"");
// Enumerate and copy keys
ReturnValue = EnumerateAndCopyKey(pSpool, L"");
}
else if (dwResult == RPC_S_PROCNUM_OUT_OF_RANGE) { // Server exists but doesn't support EnumPrinterKey
// we still call refreshdriverdatacache so downlevel gets cached
// Optimize: Only call for downlevel since EnumerateAndCopyKey copies Driver Data
RefreshDriverDataCache(pSpool);
}
else if (dwResult == ERROR_INVALID_HANDLE || dwResult == RPC_S_CALL_FAILED) { // Server does not exist
DBGMSG(DBG_TRACE, ("RefreshPrinterDataCache: Server \"%ws\" absent\n", pSpool->pName));
}
// Refresh PrinterInfo2
RefreshPrinter(pSpool);
// Refresh PrinterInfo7
RefreshPrinterInfo7(pSpool);
}
DWORD
EnumerateAndCopyKey(
PWSPOOL pSpool,
LPWSTR pKeyName
)
{
DWORD i;
DWORD dwResult = ERROR_SUCCESS;
LPWSTR pSubKeys = NULL;
LPWSTR pSubKey = NULL;
LPWSTR pFullSubKey = NULL;
DWORD cbSubKey;
DWORD cbSubKeys;
LPBYTE pEnumValues = NULL;
DWORD cbEnumValues;
DWORD nEnumValues;
PPRINTER_ENUM_VALUES pEnumValue = NULL;
// Get SubKey size
dwResult = RemoteEnumPrinterKey(pSpool,
pKeyName,
pSubKeys,
0,
&cbSubKeys);
if (dwResult != ERROR_MORE_DATA)
goto Cleanup;
// Allocate SubKey buffer
pSubKeys = AllocSplMem(cbSubKeys);
if(!pSubKeys) {
dwResult = GetLastError();
goto Cleanup;
}
// Get SubKeys
dwResult = RemoteEnumPrinterKey(pSpool,
pKeyName,
pSubKeys,
cbSubKeys,
&cbSubKeys);
if (dwResult == ERROR_SUCCESS) { // Found subkeys
// Enumerate and copy Keys
if (*pKeyName && *pSubKeys) { // Allocate buffer for L"pKeyName\pSubKey"
pFullSubKey = AllocSplMem(cbSubKeys + (wcslen(pKeyName) + 2)*sizeof(WCHAR));
if(!pFullSubKey) {
dwResult = GetLastError();
goto Cleanup;
}
}
for(pSubKey = pSubKeys ; *pSubKey ; pSubKey += wcslen(pSubKey) + 1) {
if (*pKeyName) {
wsprintf(pFullSubKey, L"%ws\\%ws", pKeyName, pSubKey);
dwResult = EnumerateAndCopyKey(pSpool, pFullSubKey);
} else {
dwResult = EnumerateAndCopyKey(pSpool, pSubKey);
}
if (dwResult != ERROR_SUCCESS)
goto Cleanup;
}
}
dwResult = RemoteEnumPrinterDataEx( pSpool,
pKeyName,
pEnumValues,
0,
&cbEnumValues,
&nEnumValues);
// We quit here if *pKeyName == NULL so we don't copy root key values
if (dwResult != ERROR_MORE_DATA || !*pKeyName)
goto Cleanup;
// Allocate EnumValues buffer
pEnumValues = AllocSplMem(cbEnumValues);
if(!pEnumValues) {
dwResult = GetLastError();
goto Cleanup;
}
// Get Values
dwResult = RemoteEnumPrinterDataEx( pSpool,
pKeyName,
pEnumValues,
cbEnumValues,
&cbEnumValues,
&nEnumValues);
// Did we get any data, this could fail.
if (dwResult == ERROR_SUCCESS)
{
// Set Values for current key
for (i = 0, pEnumValue = (PPRINTER_ENUM_VALUES) pEnumValues ; i < nEnumValues ; ++i, ++pEnumValue)
{
dwResult = SplSetPrinterDataEx( pSpool->hSplPrinter,
pKeyName,
pEnumValue->pValueName,
pEnumValue->dwType,
pEnumValue->pData,
pEnumValue->cbData);
if (dwResult != ERROR_SUCCESS)
{
goto Cleanup;
}
}
}
Cleanup:
FreeSplMem(pSubKeys);
FreeSplMem(pEnumValues);
FreeSplMem(pFullSubKey);
return dwResult;
}
BOOL
CacheEnumForms(
HANDLE hPrinter,
DWORD Level,
LPBYTE pForm,
DWORD cbBuf,
LPDWORD pcbNeeded,
LPDWORD pcReturned
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
BOOL ReturnValue;
VALIDATEW32HANDLE( pSpool );
if ((pSpool->Status & WSPOOL_STATUS_USE_CACHE) && !IsAdminAccess(&pSpool->PrinterDefaults)) {
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
ReturnValue = SplEnumForms( pSpool->hSplPrinter,
Level,
pForm,
cbBuf,
pcbNeeded,
pcReturned );
} else {
ReturnValue = RemoteEnumForms( hPrinter,
Level,
pForm,
cbBuf,
pcbNeeded,
pcReturned );
}
return ReturnValue;
}
BOOL
CacheGetForm(
HANDLE hPrinter,
LPWSTR pFormName,
DWORD Level,
LPBYTE pForm,
DWORD cbBuf,
LPDWORD pcbNeeded
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
BOOL ReturnValue;
VALIDATEW32HANDLE( pSpool );
if ((pSpool->Status & WSPOOL_STATUS_USE_CACHE) && !IsAdminAccess(&pSpool->PrinterDefaults)) {
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
ReturnValue = SplGetForm( pSpool->hSplPrinter,
pFormName,
Level,
pForm,
cbBuf,
pcbNeeded );
} else {
ReturnValue = RemoteGetForm( hPrinter,
pFormName,
Level,
pForm,
cbBuf,
pcbNeeded );
}
return ReturnValue;
}
DWORD
CacheGetPrinterData(
HANDLE hPrinter,
LPWSTR pValueName,
LPDWORD pType,
LPBYTE pData,
DWORD nSize,
LPDWORD pcbNeeded
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
DWORD ReturnValue;
BOOL bPrintProc = FALSE;
WCHAR szPrintProcKey[] = L"PrintProcCaps_";
VALIDATEW32HANDLE( pSpool );
//
// If the pValueName is "PrintProcCaps_[datatype]" call the remote print processor which
// supports that datatype and return the options that it supports.
//
if (pValueName && wcsstr(pValueName, szPrintProcKey)) {
bPrintProc = TRUE;
}
if ((pSpool->Status & WSPOOL_STATUS_USE_CACHE) && !bPrintProc && !IsAdminAccess(&pSpool->PrinterDefaults)) {
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
ReturnValue = SplGetPrinterData( pSpool->hSplPrinter,
pValueName,
pType,
pData,
nSize,
pcbNeeded );
} else {
ReturnValue = RemoteGetPrinterData( hPrinter,
pValueName,
pType,
pData,
nSize,
pcbNeeded );
}
return ReturnValue;
}
DWORD
CacheGetPrinterDataEx(
HANDLE hPrinter,
LPCWSTR pKeyName,
LPCWSTR pValueName,
LPDWORD pType,
LPBYTE pData,
DWORD nSize,
LPDWORD pcbNeeded
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
DWORD ReturnValue;
VALIDATEW32HANDLE( pSpool );
if ((pSpool->Status & WSPOOL_STATUS_USE_CACHE) && !IsAdminAccess(&pSpool->PrinterDefaults)) {
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
ReturnValue = SplGetPrinterDataEx( pSpool->hSplPrinter,
pKeyName,
pValueName,
pType,
pData,
nSize,
pcbNeeded );
} else {
ReturnValue = RemoteGetPrinterDataEx( hPrinter,
pKeyName,
pValueName,
pType,
pData,
nSize,
pcbNeeded );
}
return ReturnValue;
}
DWORD
CacheEnumPrinterDataEx(
HANDLE hPrinter,
LPCWSTR pKeyName,
LPBYTE pEnumValues,
DWORD cbEnumValues,
LPDWORD pcbEnumValues,
LPDWORD pnEnumValues
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
DWORD ReturnValue;
VALIDATEW32HANDLE( pSpool );
if ((pSpool->Status & WSPOOL_STATUS_USE_CACHE) && !IsAdminAccess(&pSpool->PrinterDefaults)) {
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
ReturnValue = SplEnumPrinterDataEx( pSpool->hSplPrinter,
pKeyName,
pEnumValues,
cbEnumValues,
pcbEnumValues,
pnEnumValues );
} else {
ReturnValue = RemoteEnumPrinterDataEx( hPrinter,
pKeyName,
pEnumValues,
cbEnumValues,
pcbEnumValues,
pnEnumValues );
}
return ReturnValue;
}
DWORD
CacheEnumPrinterKey(
HANDLE hPrinter,
LPCWSTR pKeyName,
LPWSTR pSubkey,
DWORD cbSubkey,
LPDWORD pcbSubkey
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
DWORD ReturnValue;
VALIDATEW32HANDLE( pSpool );
if ((pSpool->Status & WSPOOL_STATUS_USE_CACHE) && !IsAdminAccess(&pSpool->PrinterDefaults)) {
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
ReturnValue = SplEnumPrinterKey(pSpool->hSplPrinter,
pKeyName,
pSubkey,
cbSubkey,
pcbSubkey);
} else {
ReturnValue = RemoteEnumPrinterKey( hPrinter,
pKeyName,
pSubkey,
cbSubkey,
pcbSubkey);
}
return ReturnValue;
}
BOOL
CacheOpenPrinter(
LPWSTR pName,
LPHANDLE phPrinter,
LPPRINTER_DEFAULTS pDefault
)
{
PWSPOOL pSpool = NULL;
PWSPOOL pRemoteSpool = NULL;
HANDLE hSplPrinter = INVALID_HANDLE_VALUE;
BOOL ReturnValue = FALSE;
HANDLE hIniSpooler = INVALID_HANDLE_VALUE;
BOOL DoOpenOnError = TRUE;
DWORD LastError = ERROR_SUCCESS;
BOOL bSync = FALSE;
BOOL bCreateCacheAfterCheck = FALSE;
LPWSTR pCommastr, pFixname = NULL;
if (!VALIDATE_NAME(pName)) {
SetLastError(ERROR_INVALID_NAME);
return FALSE;
}
//
// search for pszCnvrtdmToken on the end of pName
// note that pszCnvrtdmToken must begin with a ','
//
SPLASSERT(pszCnvrtdmToken[0] == L',');
pFixname = AllocSplStr( pName );
if ( pFixname == NULL )
{
EnterSplSem();
goto OpenPrinterError;
}
StripString(pFixname, pszCnvrtdmToken, L",");
StripString(pFixname, pszDrvConvert, L",");
pName = pFixname;
ReturnValue = OpenCachePrinterOnly( pName, &hSplPrinter, &hIniSpooler, pDefault , TRUE);
if ( hIniSpooler == INVALID_HANDLE_VALUE ) {
//
// This means that the inispooler does not exist yet. Only create it
// after some more confirmation.
//
hSplPrinter = INVALID_HANDLE_VALUE;
bCreateCacheAfterCheck = TRUE;
}
if ( ReturnValue == FALSE ) {
// Printer Not Found in Cache
DBGMSG(DBG_TRACE, ("CacheOpenPrinter SplOpenPrinter %ws error %d\n",
pName,
GetLastError() ));
// FLOATING PROFILE
// If this is a Floating Profile then the following condition applies
// there is an entry in HKEY_CURRENT_USER but not entry in
// HKEY_LOCAL_MACHINE for the cache.
// If this is the case then we need to establish the Cache now
if (PrinterConnectionExists( pName )) {
//
// The printer connection exists in the registry. See if the inispooler
// did not exist yet. If it does not, create it. This is to prevent us
// hitting the wire on a default printer when some apps start up.
//
if (bCreateCacheAfterCheck) {
bCreateCacheAfterCheck = FALSE;
ReturnValue = OpenCachePrinterOnly( pName, &hSplPrinter, &hIniSpooler, pDefault, FALSE);
if (hIniSpooler == INVALID_HANDLE_VALUE) {
EnterSplSem();
hSplPrinter = INVALID_HANDLE_VALUE;
goto OpenPrinterError;
}
}
if ( ReturnValue == FALSE ) {
if ( !AddPrinterConnectionPrivate( pName ) ||
SplOpenPrinter( pName ,
&hSplPrinter,
pDefault,
hIniSpooler,
NULL,
0) != ROUTER_SUCCESS ) {
DBGMSG( DBG_TRACE, ("CacheOpenPrinter Failed to establish Floating Profile into Cache %d\n",
GetLastError() ));
DoOpenOnError = FALSE;
EnterSplSem();
goto OpenPrinterError;
}
DBGMSG( DBG_TRACE, ("CacheOpenPrinter Floating Profile Added to Cache\n"));
}
}
else {
//
// This is just a remote open printer, just hit the wire.
//
EnterSplSem();
goto OpenPrinterError;
}
}
EnterSplSem();
SplInSem();
//
// Create a pSpool Object for this Cached Printer
//
pSpool = AllocWSpool();
if ( pSpool == NULL ) {
DBGMSG(DBG_WARNING, ("CacheOpenPrinter AllocWSpool error %d\n", GetLastError() ));
ReturnValue = FALSE;
goto OpenPrinterError;
}
pSpool->pName = AllocSplStr( pName );
if ( pSpool->pName == NULL ) {
DBGMSG(DBG_WARNING, ("CacheOpenPrinter AllocSplStr error %d\n", GetLastError() ));
ReturnValue = FALSE;
goto OpenPrinterError;
}
pSpool->Status = WSPOOL_STATUS_USE_CACHE | WSPOOL_STATUS_NO_RPC_HANDLE;
if (pFixname)
pSpool->Status |= WSPOOL_STATUS_CNVRTDEVMODE;
pSpool->hIniSpooler = hIniSpooler;
pSpool->hSplPrinter = hSplPrinter;
SPLASSERT( hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( hSplPrinter != INVALID_HANDLE_VALUE );
//
// We want to hit the network if:
// 1. The dwSyncOpenPrinter is non-zero, OR
// 2. A default is specified AND:
// a. A datatype is specified, and it's not RAW OR
// b. Administrative access is requested.
//
// For admin, we want to get the true status of the printer, since
// they will be administering it.
//
// If a non-default and non-RAW datatype is specified, we need to
// be synchronous, since the remote machine may refuse the datatype
// (e.g., connecting to 1057 with EMF).
//
if( pDefault ){
if( ( pDefault->pDatatype && ( _wcsicmp( pDefault->pDatatype, pszRaw ) != STRINGS_ARE_EQUAL )) ||
IsAdminAccess(pDefault)){
bSync = TRUE;
}
}
if( dwSyncOpenPrinter != 0 || bSync ){
LeaveSplSem();
ReturnValue = RemoteOpenPrinter( pName, &pRemoteSpool, pDefault, DO_NOT_CALL_LM_OPEN );
EnterSplSem();
if ( ReturnValue ) {
DBGMSG( DBG_TRACE, ( "CacheOpenPrinter Synchronous Open OK pRemoteSpool %x pSpool %x\n", pRemoteSpool, pSpool ));
SPLASSERT( pRemoteSpool->Type == SJ_WIN32HANDLE );
pSpool->RpcHandle = pRemoteSpool->RpcHandle;
pSpool->Status |= pRemoteSpool->Status;
pSpool->RpcError = pRemoteSpool->RpcError;
pSpool->bNt3xServer = pRemoteSpool->bNt3xServer;
pRemoteSpool->RpcHandle = INVALID_HANDLE_VALUE;
FreepSpool( pRemoteSpool );
pRemoteSpool = NULL;
CopypDefaultTopSpool( pSpool, pDefault );
pSpool->Status &= ~WSPOOL_STATUS_NO_RPC_HANDLE;
LeaveSplSem();
ConsistencyCheckCache(pSpool, kCheckPnPPolicy);
EnterSplSem();
} else {
DBGMSG( DBG_TRACE, ( "CacheOpenPrinter Synchronous Open Failed pSpool %x LastError %d\n", pSpool, GetLastError() ));
DoOpenOnError = FALSE;
}
} else {
ReturnValue = DoAsyncRemoteOpenPrinter( pSpool, pDefault );
}
OpenPrinterError:
SplInSem();
if ( !ReturnValue ) {
// Failure
LeaveSplSem();
LastError = GetLastError();
if (( hSplPrinter != INVALID_HANDLE_VALUE ) &&
( hSplPrinter != NULL ) ) {
SplClosePrinter( hSplPrinter );
}
if ( hIniSpooler != INVALID_HANDLE_VALUE ) {
SplCloseSpooler( hIniSpooler );
}
EnterSplSem();
if ( pSpool != NULL ) {
pSpool->hSplPrinter = INVALID_HANDLE_VALUE;
pSpool->hIniSpooler = INVALID_HANDLE_VALUE;
SPLASSERT( pSpool->cRef == 0 );
FreepSpool( pSpool );
pSpool = NULL;
}
LeaveSplSem();
SetLastError( LastError );
if ( DoOpenOnError ) {
ReturnValue = RemoteOpenPrinter( pName, phPrinter, pDefault, CALL_LM_OPEN );
}
} else {
// Success, pass back Handle
*phPrinter = (HANDLE)pSpool;
LeaveSplSem();
}
SplOutSem();
if ( ReturnValue == FALSE ) {
DBGMSG(DBG_TRACE,("CacheOpenPrinter %ws failed %d *phPrinter %x\n", pName, GetLastError(), *phPrinter ));
}
if (pFixname)
FreeSplStr(pFixname);
return ( ReturnValue );
}
BOOL
CopypDefaultTopSpool(
PWSPOOL pSpool,
LPPRINTER_DEFAULTSW pDefault
)
{
DWORD cbDevMode = 0;
BOOL ReturnValue = FALSE;
//
// Copy the pDefaults so we can use them later
//
try {
if ( ( pDefault != NULL ) &&
( pDefault != &pSpool->PrinterDefaults ) ) {
if (!ReallocSplStr( &pSpool->PrinterDefaults.pDatatype , pDefault->pDatatype )) {
leave;
}
if ( pSpool->PrinterDefaults.pDevMode != NULL ) {
cbDevMode = pSpool->PrinterDefaults.pDevMode->dmSize +
pSpool->PrinterDefaults.pDevMode->dmDriverExtra;
FreeSplMem( pSpool->PrinterDefaults.pDevMode );
pSpool->PrinterDefaults.pDevMode = NULL;
}
if ( pDefault->pDevMode != NULL ) {
cbDevMode = pDefault->pDevMode->dmSize + pDefault->pDevMode->dmDriverExtra;
pSpool->PrinterDefaults.pDevMode = AllocSplMem( cbDevMode );
if ( pSpool->PrinterDefaults.pDevMode != NULL ) {
CopyMemory( pSpool->PrinterDefaults.pDevMode, pDefault->pDevMode, cbDevMode );
} else {
leave;
}
} else pSpool->PrinterDefaults.pDevMode = NULL;
pSpool->PrinterDefaults.DesiredAccess = pDefault->DesiredAccess;
}
ReturnValue = TRUE;
} finally {
}
return ReturnValue;
}
BOOL
DoAsyncRemoteOpenPrinter(
PWSPOOL pSpool,
LPPRINTER_DEFAULTS pDefault
)
{
BOOL ReturnValue = FALSE;
HANDLE hThread = NULL;
DWORD IDThread;
SplInSem();
SPLASSERT( pSpool->Status & WSPOOL_STATUS_USE_CACHE );
CopypDefaultTopSpool( pSpool, pDefault );
pSpool->hWaitValidHandle = CreateEvent( NULL,
EVENT_RESET_MANUAL,
EVENT_INITIAL_STATE_NOT_SIGNALED,
NULL );
if ( pSpool->hWaitValidHandle != NULL ) {
ReturnValue = GetSid( &pSpool->hToken );
if ( ReturnValue ) {
pSpool->cRef++;
hThread = CreateThread( NULL, 0, RemoteOpenPrinterThread, pSpool, 0, &IDThread );
if ( hThread != NULL ) {
CloseHandle( hThread );
ReturnValue = TRUE;
} else {
pSpool->cRef--;
SPLASSERT( pSpool->cRef == 0 );
ReturnValue = FALSE;
}
}
}
return ReturnValue;
}
BOOL
DoRemoteOpenPrinter(
LPWSTR pPrinterName,
LPPRINTER_DEFAULTS pDefault,
PWSPOOL pSpool
)
{
PWSPOOL pRemoteSpool = NULL;
BOOL bReturnValue;
DWORD dwLastError;
SplOutSem();
bReturnValue = RemoteOpenPrinter( pPrinterName, &pRemoteSpool, pDefault, DO_NOT_CALL_LM_OPEN );
dwLastError = GetLastError();
//
// Copy useful values to our CacheHandle and discard the new handle
//
EnterSplSem();
if ( bReturnValue ) {
DBGMSG(DBG_TRACE, ("DoRemoteOpenPrinter RemoteOpenPrinter OK hRpcHandle %x\n", pRemoteSpool->RpcHandle ));
SPLASSERT( WSJ_SIGNATURE == pSpool->signature );
SPLASSERT( WSJ_SIGNATURE == pRemoteSpool->signature );
SPLASSERT( pRemoteSpool->Type == SJ_WIN32HANDLE );
SPLASSERT( pSpool->Type == pRemoteSpool->Type );
SPLASSERT( pRemoteSpool->pServer == NULL );
SPLASSERT( pRemoteSpool->pShare == NULL );
SPLASSERT( pRemoteSpool->cRef == 0 );
pSpool->RpcHandle = pRemoteSpool->RpcHandle;
pSpool->Status |= pRemoteSpool->Status;
pSpool->RpcError = pRemoteSpool->RpcError;
pSpool->bNt3xServer = pRemoteSpool->bNt3xServer;
pRemoteSpool->RpcHandle = INVALID_HANDLE_VALUE;
FreepSpool( pRemoteSpool );
pRemoteSpool = NULL;
if ( pSpool->RpcHandle != INVALID_HANDLE_VALUE ) {
pSpool->Status &= ~WSPOOL_STATUS_OPEN_ERROR;
}
} else {
DBGMSG(DBG_WARNING, ("DoRemoteOpenPrinter RemoteOpenPrinter %ws failed %d\n", pPrinterName, dwLastError ));
pSpool->RpcHandle = INVALID_HANDLE_VALUE;
pSpool->Status |= WSPOOL_STATUS_OPEN_ERROR;
pSpool->RpcError = dwLastError;
}
pSpool->Status &= ~WSPOOL_STATUS_NO_RPC_HANDLE;
if ( !SetEvent( pSpool->hWaitValidHandle )) {
DBGMSG(DBG_ERROR, ("DoRemoteOpenPrinter failed SetEvent pSpool %x pSpool->hWaitValidHandle %x\n",
pSpool, pSpool->hWaitValidHandle ));
}
LeaveSplSem();
// Check Cache Consistency
// The Workstation and the Server have a version ID
// If the version number has changed on the server then update the
// workstation Cache.
ConsistencyCheckCache(pSpool, kCheckPnPPolicy);
SplOutSem();
return ( bReturnValue );
}
DWORD
RemoteOpenPrinterThread(
PWSPOOL pSpool
)
{
DWORD Status;
PRINTER_DEFAULTS Defaults;
DWORD dwError = ERROR_SUCCESS;
DWORD cbDevMode;
SplOutSem();
SPLASSERT( pSpool->signature == WSJ_SIGNATURE );
SetCurrentSid( pSpool->hToken );
EnterSplSem();
// Before calling DoRemoteOpenPrinter, we need to make a copy of pSpool->PrinterDefaults
// because another thread doing ResetPrinter (or anything calling CopypDefaultsTopSpool)
// may free & realloc the PrinterDefaults contents.
if (pSpool->PrinterDefaults.pDatatype) {
if (!(Defaults.pDatatype = AllocSplStr(pSpool->PrinterDefaults.pDatatype))) {
dwError = GetLastError();
}
} else {
Defaults.pDatatype = NULL;
}
if (dwError == ERROR_SUCCESS && pSpool->PrinterDefaults.pDevMode) {
cbDevMode = pSpool->PrinterDefaults.pDevMode->dmSize +
pSpool->PrinterDefaults.pDevMode->dmDriverExtra;
Defaults.pDevMode = AllocSplMem(cbDevMode);
if (Defaults.pDevMode)
CopyMemory(Defaults.pDevMode, pSpool->PrinterDefaults.pDevMode, cbDevMode );
else
dwError = GetLastError();
} else {
Defaults.pDevMode = NULL;
}
Defaults.DesiredAccess = pSpool->PrinterDefaults.DesiredAccess;
LeaveSplSem();
if (dwError == ERROR_SUCCESS) {
DoRemoteOpenPrinter( pSpool->pName, &Defaults, pSpool );
} else {
pSpool->RpcHandle = INVALID_HANDLE_VALUE;
pSpool->Status |= WSPOOL_STATUS_OPEN_ERROR;
pSpool->RpcError = dwError;
pSpool->Status &= ~WSPOOL_STATUS_NO_RPC_HANDLE;
}
SplOutSem();
EnterSplSem();
SPLASSERT( pSpool->cRef != 0 );
pSpool->cRef--;
Status = pSpool->Status;
LeaveSplSem();
if ( Status & WSPOOL_STATUS_PENDING_DELETE ) {
DBGMSG(DBG_TRACE,
("RemoteOpenPrinterThread - WSPOOL_STATUS_PENDING_DELETE closing handle %x\n",
pSpool ));
SPLASSERT( pSpool->cRef == 0 );
CacheClosePrinter( pSpool );
pSpool = NULL;
}
SetCurrentSid( NULL );
FreeSplMem(Defaults.pDevMode);
FreeSplStr(Defaults.pDatatype);
SplOutSem();
ExitThread( 0 );
return ( 0 );
}
PWSPOOL
AllocWSpool(
VOID
)
{
PWSPOOL pSpool = NULL;
SplInSem();
if (pSpool = AllocSplMem(sizeof(WSPOOL))) {
pSpool->signature = WSJ_SIGNATURE;
pSpool->Type = SJ_WIN32HANDLE;
pSpool->RpcHandle = INVALID_HANDLE_VALUE;
pSpool->hFile = INVALID_HANDLE_VALUE;
pSpool->hIniSpooler = INVALID_HANDLE_VALUE;
pSpool->hSplPrinter = INVALID_HANDLE_VALUE;
pSpool->hToken = INVALID_HANDLE_VALUE;
pSpool->hWaitValidHandle = INVALID_HANDLE_VALUE;
// Add to List
pSpool->pNext = pFirstWSpool;
pSpool->pPrev = NULL;
if ( pFirstWSpool != NULL ) {
pFirstWSpool->pPrev = pSpool;
}
pFirstWSpool = pSpool;
} else {
DBGMSG( DBG_WARNING, ("AllocWSpool failed %d\n", GetLastError() ));
}
return ( pSpool );
}
VOID
FreepSpool(
PWSPOOL pSpool
)
{
SplInSem();
if ( pSpool->cRef == 0 ) {
SPLASSERT( pSpool->hSplPrinter == INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hIniSpooler == INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->RpcHandle == INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hFile == INVALID_HANDLE_VALUE );
if( pSpool->hWaitValidHandle != INVALID_HANDLE_VALUE ) {
SetEvent( pSpool->hWaitValidHandle );
CloseHandle( pSpool->hWaitValidHandle );
pSpool->hWaitValidHandle = INVALID_HANDLE_VALUE;
}
if( pSpool->hToken != INVALID_HANDLE_VALUE ) {
CloseHandle( pSpool->hToken );
pSpool->hToken = INVALID_HANDLE_VALUE;
}
// Remove form linked List
if ( pSpool->pNext != NULL ) {
SPLASSERT( pSpool->pNext->pPrev == pSpool);
pSpool->pNext->pPrev = pSpool->pPrev;
}
if ( pSpool->pPrev == NULL ) {
SPLASSERT( pFirstWSpool == pSpool );
pFirstWSpool = pSpool->pNext;
} else {
SPLASSERT( pSpool->pPrev->pNext == pSpool );
pSpool->pPrev->pNext = pSpool->pNext;
}
FreeSplStr( pSpool->pName );
FreeSplStr( pSpool->PrinterDefaults.pDatatype );
if ( pSpool->PrinterDefaults.pDevMode != NULL ) {
FreeSplMem( pSpool->PrinterDefaults.pDevMode );
}
FreeSplMem(pSpool);
// DbgDelHandle( pSpool );
} else {
pSpool->Status |= WSPOOL_STATUS_PENDING_DELETE;
}
}
BOOL
CacheClosePrinter(
HANDLE hPrinter
)
{
BOOL ReturnValue = TRUE;
PWSPOOL pSpool = (PWSPOOL)hPrinter;
VALIDATEW32HANDLE( pSpool );
if (pSpool->Status & WSPOOL_STATUS_PRINT_FILE) {
RemoteEndDocPrinter( pSpool );
}
SplOutSem();
EnterSplSem();
if ( pSpool->Status & WSPOOL_STATUS_TEMP_CONNECTION ) {
pSpool->Status &= ~WSPOOL_STATUS_TEMP_CONNECTION;
LeaveSplSem();
if (!DeletePrinterConnection( pSpool->pName )) {
DBGMSG( DBG_TRACE, ("CacheClosePrinter failed DeletePrinterConnection %ws %d\n",
pSpool->pName, GetLastError() ));
}
EnterSplSem();
SPLASSERT( pSpool->signature == WSJ_SIGNATURE );
}
SplInSem();
if ( pSpool->Status & WSPOOL_STATUS_USE_CACHE ) {
if ( pSpool->cRef == 0 ) {
pSpool->cRef++;
if ( pSpool->RpcHandle != INVALID_HANDLE_VALUE ) {
DBGMSG(DBG_TRACE, ("CacheClosePrinter pSpool %x RpcHandle %x Status %x cRef %d\n",
pSpool, pSpool->RpcHandle, pSpool->Status, pSpool->cRef));
LeaveSplSem();
SplOutSem();
ReturnValue = RemoteClosePrinter( hPrinter );
EnterSplSem();
}
SplInSem();
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
SPLASSERT( pSpool->hSplPrinter != INVALID_HANDLE_VALUE );
LeaveSplSem();
SplOutSem();
SplClosePrinter( pSpool->hSplPrinter );
SplCloseSpooler( pSpool->hIniSpooler );
EnterSplSem();
pSpool->hSplPrinter = INVALID_HANDLE_VALUE;
pSpool->hIniSpooler = INVALID_HANDLE_VALUE;
pSpool->Status &= ~WSPOOL_STATUS_USE_CACHE;
pSpool->cRef--;
SPLASSERT( pSpool->cRef == 0 );
}
FreepSpool( pSpool );
LeaveSplSem();
} else {
LeaveSplSem();
SplOutSem();
if ( pSpool->hIniSpooler != INVALID_HANDLE_VALUE ) {
SplCloseSpooler( pSpool->hIniSpooler );
pSpool->hIniSpooler = INVALID_HANDLE_VALUE;
}
ReturnValue = RemoteClosePrinter( hPrinter );
}
SplOutSem();
return ( ReturnValue );
}
BOOL
CacheSyncRpcHandle(
PWSPOOL pSpool
)
{
DWORD dwLastError;
EnterSplSem();
if ( pSpool->Status & WSPOOL_STATUS_NO_RPC_HANDLE ) {
LeaveSplSem();
DBGMSG(DBG_TRACE,("CacheSyncRpcHandle Status WSPOOL_STATUS_NO_RPC_HANDLE waiting for RpcHandle....\n"));
SplOutSem();
WaitForSingleObject( pSpool->hWaitValidHandle, INFINITE );
EnterSplSem();
}
if ( pSpool->Status & WSPOOL_STATUS_OPEN_ERROR ) {
DBGMSG(DBG_WARNING, ("CacheSyncRpcHandle pSpool %x Status %x; setting last error = %d\n",
pSpool,
pSpool->Status,
pSpool->RpcError));
dwLastError = pSpool->RpcError;
// If we failed to open the Server because it was unavailable
// then try and open it again ( provded the asynchronous thread is not active ).
if (!( pSpool->Status & WSPOOL_STATUS_PENDING_DELETE ) &&
( pSpool->RpcHandle == INVALID_HANDLE_VALUE ) &&
( pSpool->RpcError != ERROR_ACCESS_DENIED ) &&
( pSpool->cRef == 0 ) ) {
CloseHandle( pSpool->hWaitValidHandle );
pSpool->hWaitValidHandle = INVALID_HANDLE_VALUE;
pSpool->Status |= WSPOOL_STATUS_NO_RPC_HANDLE;
DBGMSG( DBG_WARNING, ("CacheSyncRpcHandle retrying Async OpenPrinter\n"));
if ( !DoAsyncRemoteOpenPrinter( pSpool, &pSpool->PrinterDefaults ) ) {
pSpool->Status &= ~WSPOOL_STATUS_NO_RPC_HANDLE;
SetEvent( pSpool->hWaitValidHandle );
}
}
LeaveSplSem();
SPLASSERT( dwLastError );
SetLastError( dwLastError );
return FALSE;
}
LeaveSplSem();
if ( pSpool->RpcHandle != INVALID_HANDLE_VALUE &&
pSpool->Status & WSPOOL_STATUS_RESETPRINTER_PENDING ) {
DBGMSG(DBG_TRACE, ("CacheSyncRpcHandle calling RemoteResetPrinter\n"));
pSpool->Status &= ~ WSPOOL_STATUS_RESETPRINTER_PENDING;
if ( ! RemoteResetPrinter( pSpool, &pSpool->PrinterDefaults ) ) {
pSpool->Status |= WSPOOL_STATUS_RESETPRINTER_PENDING;
}
}
return TRUE;
}
BOOL
CacheGetPrinterDriver(
HANDLE hPrinter,
LPWSTR pEnvironment,
DWORD Level,
LPBYTE pDriverInfo,
DWORD cbBuf,
LPDWORD pcbNeeded
)
{
BOOL ReturnValue = FALSE;
DWORD dwServerMajorVersion = 0, dwServerMinorVersion = 0, dwPrivateFlag = 0;
PWSPOOL pSpool = (PWSPOOL) hPrinter, pTempSpool = NULL;
DWORD dwLastError;
VALIDATEW32HANDLE( pSpool );
try {
if (pSpool->Type != SJ_WIN32HANDLE) {
SetLastError(ERROR_INVALID_FUNCTION);
leave;
}
if ( !(pSpool->Status & WSPOOL_STATUS_USE_CACHE) ) {
// Someone is calling GetPrinterDriver without a connection
// we must NEVER EVER pass the caller a UNC name since they
// will LoadLibrary accross the network, which might lead
// to InPageIOErrors ( if the net goes down).
// The solution is to establish a Temporary Connection for the life
// of the pSpool handle, the connection will be removed
// in CacheClosePrinter. The connection will ensure that the
// drivers are copied locally and a local cache is established
// for this printer.
pSpool->Status |= WSPOOL_STATUS_TEMP_CONNECTION;
pTempSpool = InternalAddPrinterConnection( pSpool->pName );
if ( !pTempSpool )
{
pSpool->Status &= ~WSPOOL_STATUS_TEMP_CONNECTION;
DBGMSG( DBG_TRACE, ("CacheGetPrinterDriver failed AddPrinterConnection %d\n",
GetLastError() ));
leave;
}
ReturnValue = OpenCachePrinterOnly( pSpool->pName, &pSpool->hSplPrinter,
&pSpool->hIniSpooler, NULL, FALSE);
if ( !ReturnValue )
{
SplCloseSpooler( pSpool->hIniSpooler );
DBGMSG( DBG_WARNING,
("CacheGetPrinterDriver Connection OK Failed CacheOpenPrinter %d\n",
GetLastError() ));
leave;
}
pSpool->Status |= WSPOOL_STATUS_USE_CACHE;
}
SPLASSERT( pSpool->Status & WSPOOL_STATUS_USE_CACHE );
ReturnValue = SplGetPrinterDriverEx( pSpool->hSplPrinter,
pEnvironment,
Level,
pDriverInfo,
cbBuf,
pcbNeeded,
cThisMajorVersion,
cThisMinorVersion,
&dwServerMajorVersion,
&dwServerMinorVersion);
} finally {
if (pTempSpool) {
dwLastError = GetLastError();
CacheClosePrinter(pTempSpool);
SetLastError(dwLastError);
}
}
return ReturnValue;
}
BOOL
CacheResetPrinter(
HANDLE hPrinter,
LPPRINTER_DEFAULTS pDefault
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
BOOL ReturnValue = FALSE;
VALIDATEW32HANDLE(pSpool);
if (pSpool->Status & WSPOOL_STATUS_USE_CACHE)
{
EnterSplSem();
ReturnValue = SplResetPrinter(pSpool->hSplPrinter, pDefault);
if (ReturnValue)
{
CopypDefaultTopSpool(pSpool, pDefault);
if (pSpool->RpcHandle != INVALID_HANDLE_VALUE)
{
//
// Have RPC Handle
//
LeaveSplSem();
ReturnValue = RemoteResetPrinter(hPrinter, pDefault);
}
else
{
//
// No RpcHandle
//
DBGMSG( DBG_TRACE, ("CacheResetPrinter %x NO_RPC_HANDLE Status Pending\n",
pSpool ));
pSpool->Status |= WSPOOL_STATUS_RESETPRINTER_PENDING;
LeaveSplSem();
}
}
else
{
LeaveSplSem();
}
}
else
{
ReturnValue = RemoteResetPrinter(hPrinter, pDefault);
}
return ReturnValue;
}
BOOL
CacheGetPrinter(
HANDLE hPrinter,
DWORD Level,
LPBYTE pPrinter,
DWORD cbBuf,
LPDWORD pcbNeeded
)
{
PWSPOOL pSpool = (PWSPOOL) hPrinter;
BOOL ReturnValue = FALSE;
PWCACHEINIPRINTEREXTRA pExtraData = NULL;
DWORD LastError = ERROR_SUCCESS;
DWORD cbSize = 0;
DWORD cbDevMode;
DWORD cbSecDesc;
LPWSTR SourceStrings[sizeof(PRINTER_INFO_2)/sizeof(LPWSTR)];
LPWSTR *pSourceStrings=SourceStrings;
LPBYTE pEnd;
DWORD *pOffsets;
PPRINTER_INFO_2W pPrinter2 = (PPRINTER_INFO_2)pPrinter;
PPRINTER_INFO_4W pPrinter4 = (PPRINTER_INFO_4)pPrinter;
PPRINTER_INFO_5W pPrinter5 = (PPRINTER_INFO_5)pPrinter;
BOOL bCallRemote = TRUE;
VALIDATEW32HANDLE( pSpool );
try {
if ( (Level == 2 || Level == 5) &&
(pSpool->Status & WSPOOL_STATUS_USE_CACHE) ) {
ReturnValue = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( ReturnValue ) {
if ( (GetTickCount() - pExtraData->dwTickCount) < REFRESH_TIMEOUT )
bCallRemote = FALSE;
}
pExtraData = NULL;
}
if (( Level != 4) &&
( ((pSpool->RpcHandle != INVALID_HANDLE_VALUE ) && bCallRemote ) ||
IsAdminAccess(&pSpool->PrinterDefaults) ||
!( pSpool->Status & WSPOOL_STATUS_USE_CACHE ) ||
( Level == GET_SECURITY_DESCRIPTOR ) ||
( Level == STRESSINFOLEVEL ))) {
ReturnValue = RemoteGetPrinter( hPrinter,
Level,
pPrinter,
cbBuf,
pcbNeeded );
if ( ReturnValue ) {
leave;
}
LastError = GetLastError();
if (IsAdminAccess(&pSpool->PrinterDefaults) ||
!( pSpool->Status & WSPOOL_STATUS_USE_CACHE ) ||
( Level == GET_SECURITY_DESCRIPTOR ) ||
( Level == STRESSINFOLEVEL )) {
leave;
}
SPLASSERT( pSpool->Status & WSPOOL_STATUS_USE_CACHE );
if (( LastError != RPC_S_SERVER_UNAVAILABLE ) &&
( LastError != RPC_S_CALL_FAILED ) &&
( LastError != RPC_S_CALL_FAILED_DNE ) &&
( LastError != RPC_S_SERVER_TOO_BUSY )) {
// Valid Error like ERROR_INSUFFICIENT_BUFFER or ERROR_INVALID_HANDLE.
leave;
}
}
//
// If it is level 4, we must check if we have the information in the cache
// If not, we return ERROR_INVALID_LEVEL.
//
if (Level == 4 && (! (pSpool->Status & WSPOOL_STATUS_USE_CACHE))) {
LastError = ERROR_INVALID_LEVEL;
ReturnValue = FALSE;
}
else {
//
// Assert to make sure the data is in the cache.
//
SPLASSERT( pSpool->Status & WSPOOL_STATUS_USE_CACHE );
switch ( Level ) {
case 1:
case 7:
ReturnValue = SplGetPrinter( pSpool->hSplPrinter,
Level,
pPrinter,
cbBuf,
pcbNeeded );
if ( ReturnValue == FALSE ) {
LastError = GetLastError();
}
break;
case 4:
EnterSplSem();
ReturnValue = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( ReturnValue == FALSE ) {
DBGMSG( DBG_WARNING, ("CacheGetPrinter SplGetPrinterExtra pSpool %x error %d\n", pSpool, GetLastError() ));
SPLASSERT( ReturnValue );
}
if ( pExtraData == NULL ) {
LeaveSplSem();
break;
}
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
cbSize = pExtraData->cbPI2;
*pcbNeeded = cbSize;
if ( cbSize > cbBuf ) {
LastError = ERROR_INSUFFICIENT_BUFFER;
ReturnValue = FALSE;
LeaveSplSem();
break;
}
*pSourceStrings++ = pExtraData->pPI2->pPrinterName;
*pSourceStrings++ = pExtraData->pPI2->pServerName;
pOffsets = PrinterInfo4Strings;
pEnd = pPrinter + cbBuf;
pEnd = PackStrings(SourceStrings, pPrinter, pOffsets, pEnd);
pPrinter4->Attributes = pExtraData->pPI2->Attributes;
ReturnValue = TRUE;
LeaveSplSem();
break;
case 2:
EnterSplSem();
ReturnValue = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( ReturnValue == FALSE ) {
DBGMSG( DBG_WARNING, ("CacheGetPrinter SplGetPrinterExtra pSpool %x error %d\n", pSpool, GetLastError() ));
SPLASSERT( ReturnValue );
}
if ( pExtraData == NULL ) {
LeaveSplSem();
break;
}
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
cbSize = pExtraData->cbPI2;
*pcbNeeded = cbSize;
if ( cbSize > cbBuf ) {
LastError = ERROR_INSUFFICIENT_BUFFER;
ReturnValue = FALSE;
LeaveSplSem();
break;
}
// NOTE
// In the case of EnumerateFavoritePrinters it expects us to pack our
// strings at the end of the structure not just following it.
// You might wrongly assume that you could just copy the complete structure
// inluding strings but you would be wrong.
*pSourceStrings++ = pExtraData->pPI2->pServerName;
*pSourceStrings++ = pExtraData->pPI2->pPrinterName;
*pSourceStrings++ = pExtraData->pPI2->pShareName;
*pSourceStrings++ = pExtraData->pPI2->pPortName;
*pSourceStrings++ = pExtraData->pPI2->pDriverName;
*pSourceStrings++ = pExtraData->pPI2->pComment;
*pSourceStrings++ = pExtraData->pPI2->pLocation;
*pSourceStrings++ = pExtraData->pPI2->pSepFile;
*pSourceStrings++ = pExtraData->pPI2->pPrintProcessor;
*pSourceStrings++ = pExtraData->pPI2->pDatatype;
*pSourceStrings++ = pExtraData->pPI2->pParameters;
pOffsets = PrinterInfo2Strings;
pEnd = pPrinter + cbBuf;
pEnd = PackStrings(SourceStrings, pPrinter, pOffsets, pEnd);
if ( pExtraData->pPI2->pDevMode != NULL ) {
cbDevMode = ( pExtraData->pPI2->pDevMode->dmSize + pExtraData->pPI2->pDevMode->dmDriverExtra );
pEnd -= cbDevMode;
pEnd = (LPBYTE)ALIGN_PTR_DOWN(pEnd);
pPrinter2->pDevMode = (LPDEVMODE)pEnd;
CopyMemory(pPrinter2->pDevMode, pExtraData->pPI2->pDevMode, cbDevMode );
} else {
pPrinter2->pDevMode = NULL;
}
if ( pExtraData->pPI2->pSecurityDescriptor != NULL ) {
cbSecDesc = GetSecurityDescriptorLength( pExtraData->pPI2->pSecurityDescriptor );
pEnd -= cbSecDesc;
pEnd = (LPBYTE)ALIGN_PTR_DOWN(pEnd);
pPrinter2->pSecurityDescriptor = pEnd;
CopyMemory( pPrinter2->pSecurityDescriptor, pExtraData->pPI2->pSecurityDescriptor, cbSecDesc );
} else {
pPrinter2->pSecurityDescriptor = NULL;
}
pPrinter2->Attributes = pExtraData->pPI2->Attributes;
pPrinter2->Priority = pExtraData->pPI2->Priority;
pPrinter2->DefaultPriority = pExtraData->pPI2->DefaultPriority;
pPrinter2->StartTime = pExtraData->pPI2->StartTime;
pPrinter2->UntilTime = pExtraData->pPI2->UntilTime;
pPrinter2->Status = pExtraData->pPI2->Status;
pPrinter2->cJobs = pExtraData->pPI2->cJobs;
pPrinter2->AveragePPM = pExtraData->pPI2->AveragePPM;
ReturnValue = TRUE;
LeaveSplSem();
break;
case 5:
//
// We need to support a cached level 5 get, the printer, the port
// name and the attributes we get from the Cached PI2. For the port
// attributes, we just return the default.
//
EnterSplSem();
ReturnValue = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( ReturnValue == FALSE ) {
DBGMSG( DBG_WARNING, ("CacheGetPrinter SplGetPrinterExtra pSpool %x error %d\n", pSpool, GetLastError() ));
SPLASSERT( ReturnValue );
}
if ( pExtraData == NULL ) {
LeaveSplSem();
break;
}
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
//
// The size is the size of the printer name, the port name, their NULL
// terminating characters and the size of the PRINTER_INFO_5 structure
// itself.
//
cbSize = (pExtraData->pPI2->pPrinterName ? (wcslen(pExtraData->pPI2->pPrinterName) + 1) : 0) * sizeof(WCHAR) +
(pExtraData->pPI2->pPortName ? (wcslen(pExtraData->pPI2->pPortName) + 1) : 0) * sizeof(WCHAR) +
sizeof(PRINTER_INFO_5);
*pcbNeeded = cbSize;
if ( cbSize > cbBuf ) {
LastError = ERROR_INSUFFICIENT_BUFFER;
ReturnValue = FALSE;
LeaveSplSem();
break;
}
*pSourceStrings++ = pExtraData->pPI2->pPrinterName;
*pSourceStrings++ = pExtraData->pPI2->pPortName;
pOffsets = PrinterInfo5Strings;
pEnd = pPrinter + cbBuf;
pEnd = PackStrings(SourceStrings, pPrinter, pOffsets, pEnd);
pPrinter5->Attributes = pExtraData->pPI2->Attributes;
pPrinter5->DeviceNotSelectedTimeout = kDefaultDnsTimeout;
pPrinter5->TransmissionRetryTimeout = kDefaultTxTimeout;
ReturnValue = TRUE;
LeaveSplSem();
break;
case 3:
DBGMSG( DBG_ERROR, ("CacheGetPrinter Level 3 impossible\n"));
default:
LastError = ERROR_INVALID_LEVEL;
ReturnValue = FALSE;
break;
}
}
} finally {
if ( !ReturnValue ) {
SetLastError( LastError );
}
}
return ReturnValue;
}
//
// Called When the Printer is read back from the registry
//
PWCACHEINIPRINTEREXTRA
CacheReadRegistryExtra(
HKEY hPrinterKey
)
{
PWCACHEINIPRINTEREXTRA pExtraData = NULL;
LONG ReturnValue;
PPRINTER_INFO_2W pPrinterInfo2 = NULL;
DWORD cbSizeRequested = 0;
DWORD cbSizeInfo2 = 0;
ReturnValue = RegQueryValueEx( hPrinterKey, szCachePrinterInfo2, NULL, NULL, NULL, &cbSizeRequested );
if ((ReturnValue == ERROR_MORE_DATA) || (ReturnValue == ERROR_SUCCESS)) {
cbSizeInfo2 = cbSizeRequested;
pPrinterInfo2 = AllocSplMem( cbSizeInfo2 );
if ( pPrinterInfo2 != NULL ) {
ReturnValue = RegQueryValueEx( hPrinterKey,
szCachePrinterInfo2,
NULL, NULL, (LPBYTE)pPrinterInfo2,
&cbSizeRequested );
if ( ReturnValue == ERROR_SUCCESS ) {
//
// Cached Structures on Disk have offsets for pointers
//
if (MarshallUpStructure((LPBYTE)pPrinterInfo2, PrinterInfo2Fields,
sizeof(PRINTER_INFO_2), NATIVE_CALL))
{
pExtraData = AllocExtraData( pPrinterInfo2, cbSizeInfo2 );
}
}
FreeSplMem( pPrinterInfo2 );
}
}
//
// Read the timestamp for the Cached Printer Data
//
if ( pExtraData != NULL ) {
cbSizeRequested = sizeof( pExtraData->cCacheID );
ReturnValue = RegQueryValueEx(hPrinterKey,
szCacheTimeLastChange,
NULL, NULL,
(LPBYTE)&pExtraData->cCacheID, &cbSizeRequested );
// Read the Connection Reference Count
cbSizeRequested = sizeof( pExtraData->cRef );
ReturnValue = RegQueryValueEx(hPrinterKey,
szcRef,
NULL, NULL,
(LPBYTE)&pExtraData->cRef, &cbSizeRequested );
cbSizeRequested = sizeof(pExtraData->dwServerVersion);
ReturnValue = RegQueryValueEx(hPrinterKey,
szServerVersion,
NULL, NULL,
(LPBYTE)&pExtraData->dwServerVersion,
&cbSizeRequested);
}
return pExtraData;
}
BOOL
CacheWriteRegistryExtra(
LPWSTR pName,
HKEY hPrinterKey,
PWCACHEINIPRINTEREXTRA pExtraData
)
{
PPRINTER_INFO_2 pPrinterInfo2 = NULL;
DWORD cbSize = 0;
DWORD dwLastError = ERROR_SUCCESS;
DWORD Status;
if ( pExtraData == NULL ) return FALSE;
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
cbSize = pExtraData->cbPI2;
if ( cbSize != 0 ) {
pPrinterInfo2 = AllocSplMem( cbSize );
if ( pPrinterInfo2 != NULL ) {
CacheCopyPrinterInfo( pPrinterInfo2, pExtraData->pPI2, cbSize );
//
// Before writing it to the registry make all pointers offsets
//
if (MarshallDownStructure((LPBYTE)pPrinterInfo2, PrinterInfo2Fields,
sizeof(PRINTER_INFO_2), NATIVE_CALL))
{
dwLastError = RegSetValueEx( hPrinterKey, szCachePrinterInfo2, 0,
REG_BINARY, (LPBYTE)pPrinterInfo2, cbSize );
}
else
{
dwLastError = GetLastError();
}
FreeSplMem( pPrinterInfo2 );
} else {
dwLastError = GetLastError();
}
}
//
// Write Cache TimeStamp to Registry
//
cbSize = sizeof ( pExtraData->cCacheID );
Status = RegSetValueEx( hPrinterKey, szCacheTimeLastChange, 0, REG_DWORD, (LPBYTE)&pExtraData->cCacheID, cbSize );
if ( Status != ERROR_SUCCESS ) dwLastError = Status;
cbSize = sizeof(pExtraData->dwServerVersion);
Status = RegSetValueEx( hPrinterKey, szServerVersion, 0, REG_DWORD, (LPBYTE)&pExtraData->dwServerVersion, cbSize );
if ( Status != ERROR_SUCCESS ) dwLastError = Status;
cbSize = sizeof ( pExtraData->cRef );
Status = RegSetValueEx( hPrinterKey, szcRef, 0, REG_DWORD, (LPBYTE)&pExtraData->cRef, cbSize );
if ( Status != ERROR_SUCCESS ) dwLastError = Status;
if ( dwLastError == ERROR_SUCCESS ) {
return TRUE;
} else {
SetLastError( dwLastError );
return FALSE;
}
}
/*++
-- ConsistencyCheckCache --
Routine Description:
This will determine if the Printer cache needs updating, and update it if necessary.
It has a timeout value so as to reduce traffic and have less calls going across the wire.
Checks the remote printer's ChangeID, and if the value differs from one stored in the cache
it triggers an update.
Arguments:
pSpool - Handle to remote printer.
bCheckPolicy - If TRUE, we should check to policy to see if we are
allowed to download the driver.
Return Value:
None
--*/
VOID
ConsistencyCheckCache(
IN PWSPOOL pSpool,
IN EDriverDownload eDriverDownload
)
{
BOOL ReturnValue = FALSE;
BOOL bGotID = TRUE;
BOOL RefreshNeeded = TRUE;
DWORD cbBuf = MAX_PRINTER_INFO0;
BYTE PrinterInfoW0[ MAX_PRINTER_INFO0 ];
LPPRINTER_INFO_STRESSW pPrinter0 = (LPPRINTER_INFO_STRESSW)&PrinterInfoW0;
DWORD dwNeeded;
PWCACHEINIPRINTEREXTRA pExtraData;
BOOL bGetPrinterExtra = TRUE;
DWORD NewTick;
DWORD RemoteChangeID = 0, DataType = 0, SizeNeeded = 0;
DWORD dwRetVal = ERROR_SUCCESS;
if ( ( pSpool->RpcHandle == INVALID_HANDLE_VALUE ) ||
!( pSpool->Status & WSPOOL_STATUS_USE_CACHE )) {
return;
}
SPLASSERT( pSpool->Status & WSPOOL_STATUS_USE_CACHE );
//
// Get the Printer ExtraData from the cache Printer. This is used for the copmparisons
// of the ChangeID and TickCount
//
bGetPrinterExtra = SplGetPrinterExtra( pSpool->hSplPrinter, &(PBYTE)pExtraData );
if ( bGetPrinterExtra && (pExtraData != NULL))
{
SPLASSERT( pExtraData->signature == WCIP_SIGNATURE );
SPLASSERT( pExtraData->pPI2 != NULL );
NewTick = GetTickCount();
//
// Make sure an appropriate amount of time has elapsed before hitting
// the network again.
//
//
// This takes care of the rollover case too, although you may get an extra refresh
// before the timeout is over.
//
if ( (NewTick > ( pExtraData->dwTickCount + GetCacheTimeout()))
|| (NewTick < pExtraData->dwTickCount))
{
//
// Get the new ChangeID from the Server. Try the GetPrinterData call
// first to reduce network usage. If that fails, fall back to the old way.
//
RefreshNeeded = TRUE;
//
// Keep Updating our Cache until we match the Server
//
while ( RefreshNeeded )
{
dwRetVal = RemoteGetPrinterData(
pSpool,
L"ChangeId",
&DataType,
(PBYTE) &RemoteChangeID,
sizeof(RemoteChangeID),
&SizeNeeded );
if ((dwRetVal == ERROR_INVALID_PARAMETER) ||
(dwRetVal == ERROR_FILE_NOT_FOUND) )
{
//
// Fall back to the old STRESSINFOLEVEL call.
//
ReturnValue = RemoteGetPrinter( pSpool, STRESSINFOLEVEL, (LPBYTE)&PrinterInfoW0, cbBuf, &dwNeeded );
if ( ReturnValue )
{
RemoteChangeID = pPrinter0->cChangeID;
bGotID = TRUE;
}
else
{
SPLASSERT( GetLastError() != ERROR_INSUFFICIENT_BUFFER );
DBGMSG( DBG_TRACE, ("ConsistencyCheckCache failed RemoteGetPrinter %d\n", GetLastError() ));
bGotID = FALSE;
}
}
else if (dwRetVal != ERROR_SUCCESS)
{
//
// Something went badly wrong here.
//
DBGMSG( DBG_TRACE, ("ConsistencyCheckCache failed RemoteGetPrinterData %d\n", GetLastError() ));
bGotID = FALSE;
}
else
{
bGotID = TRUE;
}
if ( bGotID && (pExtraData->cCacheID != RemoteChangeID) )
{
DBGMSG( DBG_TRACE, ("ConsistencyCheckCache << Server cCacheID %x Workstation cChangeID %x >>\n",
RemoteChangeID,
pExtraData->cCacheID ));
//
// Now we want to change the info, since we need to update
//
if ( !ReturnValue )
{
ReturnValue = RemoteGetPrinter(pSpool, STRESSINFOLEVEL, (LPBYTE)&PrinterInfoW0, cbBuf, &dwNeeded);
}
if ( ReturnValue )
{
//
// Update Data we can't get from GetPrinterData.
// We might be able to leave this out. Not sure yet.
//
pExtraData->dwServerVersion = pPrinter0->dwGetVersion;
pExtraData->pPI2->cJobs = pPrinter0->cJobs;
pExtraData->pPI2->Status = pPrinter0->Status;
}
else
{
SPLASSERT( GetLastError() != ERROR_INSUFFICIENT_BUFFER );
DBGMSG( DBG_TRACE, ("ConsistencyCheckCache failed RemoteGetPrinter %d\n", GetLastError() ));
}
//
// Don't have tons of threads doing a refresh at the same time
// In stress when there are lots of folks changing printer settings
// so the cChangeId changes a lot, but we don't want multiple threads
// all doing a refresh since you get a LOT, it doesn't buy anything
//
EnterSplSem();
if ( !(pExtraData->Status & EXTRA_STATUS_DOING_REFRESH) ) {
pExtraData->Status |= EXTRA_STATUS_DOING_REFRESH;
pExtraData->cCacheID = RemoteChangeID;
pExtraData->dwTickCount = GetTickCount();
LeaveSplSem();
RefreshCompletePrinterCache(pSpool, eDriverDownload);
EnterSplSem();
SPLASSERT( pExtraData->Status & EXTRA_STATUS_DOING_REFRESH );
pExtraData->Status &= ~EXTRA_STATUS_DOING_REFRESH;
}
LeaveSplSem();
}
else
{
if ( bGotID )
{
//
// We need to Update the TickCount anyway
//
pExtraData->dwTickCount = GetTickCount();
}
//
// We either failed the GetPrinterData's or the ChangeID's were
// the same. Either way, we don't want to try again.
//
RefreshNeeded = FALSE;
} // if gotid
} // while RefreshNeeded
} // if newtick > timeout
} // if SplGetPrinterExtra
else
{
DBGMSG( DBG_WARNING, ("ConsistencyCheckCache SplGetPrinterExtra pSpool %x error %d\n", pSpool, GetLastError() ));
SPLASSERT( bGetPrinterExtra );
}
}
BOOL
RefreshPrinterDriver(
IN PWSPOOL pSpool,
IN LPWSTR pszDriverName,
IN EDriverDownload eDriverDownload
)
{
LPBYTE pDriverInfo = NULL;
DWORD cbDriverInfo = MAX_DRIVER_INFO_VERSION;
DWORD cbNeeded, Level, dwLastError = ERROR_SUCCESS;
BOOL bReturnValue = FALSE;
BOOL bAttemptDownload = FALSE;
DWORD LevelArray[] = { DRIVER_INFO_VERSION_LEVEL, 6 , 4 , 3 , 2 , 1 , -1 };
DWORD dwIndex;
SPLASSERT( pSpool->hIniSpooler != INVALID_HANDLE_VALUE );
try {
if ( !(pDriverInfo = AllocSplMem(cbDriverInfo)) )
leave;
//
// Only download a driver from the remote server if we are allowed to by
// policy, or, if the trusted path is set up, in which case we might try.
//
bAttemptDownload = eDriverDownload == kDownloadDriver || IsTrustedPathConfigured();
if (bAttemptDownload) {
//
// When the trusted path is configured, we do not try the first level
// (DRIVER_INFO_VERSION_LEVEL) in the LeveLArray, because the code in
// DownloadDriverFiles doesnt know how to handle it. DownloadDriverFiles
// fails and returns error invalid level, if the level is
// DRIVER_INFO_VERSION_LEVEL. We are saving 2 RPC calls to the remote
// server by checking ahead if the trusted path is configured and passing
// the right level.
//
for (dwIndex = IsTrustedPathConfigured() ? 1 : 0;
LevelArray[dwIndex] != -1 &&
!(bReturnValue = CopyDriversLocally(pSpool,
szEnvironment,
pDriverInfo,
LevelArray[dwIndex],
cbDriverInfo,
&cbNeeded)) &&
(dwLastError = GetLastError()) == ERROR_INVALID_LEVEL ;
dwIndex++ );
Level = LevelArray[dwIndex];
if ( !bReturnValue && dwLastError == ERROR_INSUFFICIENT_BUFFER ) {
FreeSplMem( pDriverInfo );
if ( pDriverInfo = AllocSplMem(cbNeeded) ) {
cbDriverInfo = cbNeeded;
bReturnValue = CopyDriversLocally(pSpool,
szEnvironment,
pDriverInfo,
Level,
cbDriverInfo,
&cbNeeded);
}
}
}
//
// We could be looking at a remote environment that is different from ours
// and doesn't have a relevant driver installed in my environment (eg no IA64 driver on x86)
// or my environment didn't exist on the remote machine (e.g. w2K gold for IA64).
// Try the local install on the driver name that is being used by the remote printer.
// Only do this if we don't have SERVER_INSTALL_ONLY as the policy.
//
dwLastError = GetLastError();
if( !bReturnValue &&
pszDriverName &&
(dwLastError == ERROR_UNKNOWN_PRINTER_DRIVER ||
dwLastError == ERROR_INVALID_ENVIRONMENT ||
!bAttemptDownload) ) {
bReturnValue = AddDriverFromLocalCab(pszDriverName, pSpool->hIniSpooler);
}
if ( bReturnValue ) {
//
// Do Not add to KHKEY_CURRENT_USER for Temp connections
//
if ( !pSpool->Status & WSPOOL_STATUS_TEMP_CONNECTION ) {
bReturnValue = SavePrinterConnectionInRegistry(pSpool->pName,
pDriverInfo,
Level);
}
}
} finally {
FreeSplMem(pDriverInfo);
}
if ( !bReturnValue )
DBGMSG(DBG_WARNING,
("RefreshPrinterDriver Failed SplAddPrinterDriver %d\n",
GetLastError() ));
return bReturnValue;
}
BOOL
OpenCachePrinterOnly(
LPWSTR pName,
LPHANDLE phSplPrinter,
LPHANDLE phIniSpooler,
LPPRINTER_DEFAULTS pDefault,
BOOL bOpenOnly
)
{
PWCHAR pMachineName = NULL;
PWCHAR pPrinterName;
BOOL ReturnValue = FALSE;
PWSTR psz;
if (!VALIDATE_NAME(pName)) {
SetLastError(ERROR_INVALID_NAME);
return FALSE;
}
try {
//
// See if we already known about this server in the cache
//
DBGMSG(DBG_TRACE, ("OpenCachePrinterOnly pName %ws \n",pName));
//
// Find the Machine Name
//
SPLASSERT ( 0 == _wcsnicmp( pName, L"\\\\", 2 ) ) ;
pMachineName = AllocSplStr( pName );
if ( pMachineName == NULL )
leave;
// Get Past leading \\ or \\server\printer
pPrinterName = pMachineName + 2;
pPrinterName = wcschr( pPrinterName, L'\\' );
//
// If this is a \\ServerName or contains ,XcvPort or ,XcvMonitor then don't bother with Cache
//
if ( pPrinterName == NULL ||
wcsstr(pPrinterName, L",XcvPort") ||
wcsstr(pPrinterName, L",XcvMonitor")) {
leave;
} else {
psz = wcsstr(pName, L",NoCache");
if (psz) {
*psz = L'\0';
leave;
}
}
*pPrinterName = L'\0';
DBGMSG(DBG_TRACE,("MachineName %ws pName %ws\n", pMachineName, pName));
//
// Does this Machine Exist in the Cache ?
//
*phIniSpooler = CacheCreateSpooler( pMachineName , bOpenOnly);
if ( *phIniSpooler == INVALID_HANDLE_VALUE ) {
SPLASSERT( GetLastError( ));
leave;
}
//
// Try to Open the Cached Printer
//
ReturnValue = ( SplOpenPrinter( pName ,
phSplPrinter,
pDefault,
*phIniSpooler,
NULL,
0) == ROUTER_SUCCESS );
} finally {
FreeSplStr( pMachineName );
}
return ReturnValue;
}
/*++
Routine Name:
DoesPolicyAllowPrinterConnectionsToServer
Description:
Check to see whether policy allows us to connect to the server. The policy
might allow unrestricted access to point and print, or it might only allow
us to only point and print within our domain or it might allow us to only
point and print to a restricted subset of print servers.
Arguments:
pszQueue - The queue we are considering allowing point and
print on.
pbAllowPointAndPrint - If TRUE, we can point and print to the server.
Return Value:
An HRESULT.
--*/
HRESULT
DoesPolicyAllowPrinterConnectionsToServer(
IN PCWSTR pszQueue,
OUT BOOL *pbAllowPointAndPrint
)
{
HRESULT hr = pszQueue && pbAllowPointAndPrint ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
BOOL bAllowPointAndPrint = FALSE;
HKEY hKeyUser = NULL;
HKEY hKeyPolicy = NULL;
//
// First, are we on a domain? The policies only apply to domain joined machines.
//
if (SUCCEEDED(hr) && gbMachineInDomain)
{
DWORD dwPointAndPrintRestricted = 0;
DWORD dwPointAndPrintInForest = 1;
DWORD dwPointAndPrintTrustedServers = 0;
DWORD Type;
DWORD cbData = 0;
PWSTR pszServerName = NULL;
cbData = sizeof(dwPointAndPrintRestricted);
hr = HResultFromWin32(RegOpenCurrentUser(KEY_READ, &hKeyUser));
//
// Next, is the policy on.
//
if (SUCCEEDED(hr))
{
hr = HResultFromWin32(RegOpenKeyEx(hKeyUser, gszPointAndPrintPolicies, 0, KEY_READ, &hKeyPolicy));
}
//
// Read the value.
//
if (SUCCEEDED(hr))
{
hr = HResultFromWin32(RegQueryValueEx(hKeyPolicy,
gszPointAndPrintRestricted,
NULL,
&Type,
(BYTE *)&dwPointAndPrintRestricted,
&cbData));
hr = SUCCEEDED(hr) ? (Type == REG_DWORD ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_DATA)) : hr;
}
if (SUCCEEDED(hr))
{
bAllowPointAndPrint = dwPointAndPrintRestricted == 0;
if (!bAllowPointAndPrint)
{
cbData = sizeof(dwPointAndPrintInForest);
hr = HResultFromWin32(RegQueryValueEx(hKeyPolicy,
gszPointAndPrintInForest,
NULL,
&Type,
(BYTE *)(&dwPointAndPrintInForest),
&cbData));
hr = SUCCEEDED(hr) ? (Type == REG_DWORD ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_DATA)) : hr;
if (SUCCEEDED(hr))
{
cbData = sizeof(dwPointAndPrintTrustedServers);
hr = HResultFromWin32(RegQueryValueEx(hKeyPolicy,
gszPointAndPrintTrustedServers,
NULL,
&Type,
(BYTE *)(&dwPointAndPrintTrustedServers),
&cbData));
hr = SUCCEEDED(hr) ? (Type == REG_DWORD ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_DATA)) : hr;
}
}
}
else
{
//
// If the policy is unconfigured, we only allow point and print to
// a machine within the forst.
//
hr = S_OK;
}
if (SUCCEEDED(hr) && !bAllowPointAndPrint)
{
hr = CheckUserPrintAdmin(&bAllowPointAndPrint);
}
//
// If we are still not allowed to point and print we need to get the
// server name from the queue name.
//
if (SUCCEEDED(hr) && !bAllowPointAndPrint)
{
hr = GetServerNameFromPrinterName(pszQueue, &pszServerName);
}
//
// If the policy suggests checking against a set of trusted servers,
// then let's try that. We do this first because it is the faster
// check.
//
if (SUCCEEDED(hr) && dwPointAndPrintTrustedServers && !bAllowPointAndPrint)
{
hr = IsServerExplicitlyTrusted(hKeyPolicy, pszServerName, &bAllowPointAndPrint);
}
if (SUCCEEDED(hr) && dwPointAndPrintInForest && !bAllowPointAndPrint)
{
hr = IsServerInSameForest(pszServerName, &bAllowPointAndPrint);
}
FreeSplMem(pszServerName);
}
if (SUCCEEDED(hr) && !gbMachineInDomain)
{
bAllowPointAndPrint = TRUE;
}
if (pbAllowPointAndPrint)
{
*pbAllowPointAndPrint = bAllowPointAndPrint;
}
if (hKeyPolicy)
{
RegCloseKey(hKeyPolicy);
}
if (hKeyUser)
{
RegCloseKey(hKeyUser);
}
return hr;
}
/*++
Routine Name:
IsServerExplicitlyTrusted
Description:
Returns whether the server is in the semi-colon separated list of explicitely
trusted servers as read from the policy key. We always use fully qualified
DNS names for two reasons:
1. It prevents the admin having to type in all the possible variants that a
user might type.
2. It prevents the user getting away with specifying another name that maps
within their DNS search path.
Arguments:
hKeyPolicy - The key under which the policy is located.
pszServerName - The server name. We fully qualify
pbServerTrusted - If TRUE, then the server is trusted.
Return Value:
An HRESULT.
--*/
HRESULT
IsServerExplicitlyTrusted(
IN HKEY hKeyPolicy,
IN PCWSTR pszServerName,
OUT BOOL *pbServerTrusted
)
{
HRESULT hr = hKeyPolicy && pszServerName && pbServerTrusted ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
PWSTR pszServerList = NULL;
PWSTR pszFullyQualified = NULL;
BOOL bServerTrusted = FALSE;
DWORD cbData = 0;
DWORD Type;
//
// Get the list of servers, if this is empty, then no point and print.
//
if (SUCCEEDED(hr))
{
hr = HResultFromWin32(RegQueryValueEx(hKeyPolicy, gszPointAndPrintServerList, 0, &Type, NULL, &cbData));
hr = SUCCEEDED(hr) ? (Type == REG_SZ ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_DATA)) : hr;
}
if (SUCCEEDED(hr))
{
pszServerList = AllocSplMem(cbData);
hr = pszServerList ? S_OK : HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
}
if (SUCCEEDED(hr))
{
hr = HResultFromWin32(RegQueryValueEx(hKeyPolicy, gszPointAndPrintServerList, 0, &Type, (BYTE *)pszServerList, &cbData));
}
//
// See if we can get the actual DNS name, this is done through reverse
// address lookup and is gauranteed to be singular to the machine (of
// course, the DNS has to have the mapping).
//
if (SUCCEEDED(hr))
{
hr = GetFullyQualifiedDomainName(pszServerName, &pszFullyQualified);
//
// If full reverse lookup failed, just do the best be can with the host
// name.
//
if (hr == HRESULT_FROM_WIN32(WSANO_DATA))
{
hr = GetDNSNameFromServerName(pszServerName, &pszFullyQualified);
}
//
// OK, we could not get the fully qualified name, just use whatever
// name is specified.
//
if (FAILED(hr))
{
pszFullyQualified = AllocSplStr(pszServerName);
hr = pszFullyQualified ? S_OK : HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
}
}
//
// Run the fully qualified server name against the list in the registry.
//
if (SUCCEEDED(hr))
{
PWSTR pszServerStart = pszServerList;
PWSTR pszServerEnd = NULL;
SIZE_T cchFullyQualified = 0;
cchFullyQualified = wcslen(pszFullyQualified);
for(pszServerEnd = wcschr(pszServerStart, L';'); !bServerTrusted;
pszServerStart = pszServerEnd, pszServerEnd = wcschr(pszServerStart, L';'))
{
if (pszServerEnd)
{
//
// Are the names exactly the same? (Case insensitive comparison).
//
if (pszServerEnd - pszServerStart == cchFullyQualified)
{
bServerTrusted = !_wcsnicmp(pszFullyQualified, pszServerStart, cchFullyQualified);
}
//
// Skip past the ; to the next server name.
//
pszServerEnd++;
}
else
{
bServerTrusted = !_wcsicmp(pszFullyQualified, pszServerStart);
break;
}
}
}
if (SUCCEEDED(hr))
{
*pbServerTrusted = bServerTrusted;
}
FreeSplMem(pszServerList);
FreeSplMem(pszFullyQualified);
return hr;
}
/*++
Routine Name:
IsServerInSameForest
Description:
This routine determines whether the given server is in the same forest as we
are.
Arguments:
pszServerName - The server name.
pbServerInSameForest - If TRUE, then the server is in the same forest.
Return Value:
An HRESULT.
--*/
HRESULT
IsServerInSameForest(
IN PCWSTR pszServerName,
OUT BOOL *pbServerInSameForest
)
{
WCHAR ComputerName[MAX_COMPUTERNAME_LENGTH + 2];
DWORD cchComputerName = COUNTOF(ComputerName) - 1;
PSID pSid = NULL;
PWSTR pszDomainName = NULL;
DWORD cbSid = 0;
DWORD cchDomainName = 0;
PWSTR pszFullName = NULL;
BOOL bServerInForest = FALSE;
BOOL bSameAddress = FALSE;
PDOMAIN_CONTROLLER_INFO pDomainControllerInfo = NULL;
PUSER_INFO_1 pUserInfo1 = NULL;
SID_NAME_USE SidType;
HRESULT hr = pszServerName && pbServerInSameForest ? S_OK : HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
//
// Use the fully qualified DNS name if we can get it. This is to handle
// dotted notation resolution to the names. If we can't get it, then we
// just use the passed in name. This requires reverse domain lookup, which
// might not be available.
//
hr = GetFullyQualifiedDomainName(pszServerName, &pszFullName);
if (SUCCEEDED(hr))
{
hr = DnsHostnameToComputerName(pszFullName, ComputerName, &cchComputerName) ? S_OK : GetLastErrorAsHResultAndFail();
}
else if (hr == HRESULT_FROM_WIN32(WSANO_DATA))
{
hr = DnsHostnameToComputerName(pszServerName, ComputerName, &cchComputerName) ? S_OK : GetLastErrorAsHResultAndFail();
}
//
// Check to see whether the truncated computer name and the server name are
// the same machine. This is to prevent printserver.hack3rz.org being confused
// with printserver.mydomain.com.
//
if (SUCCEEDED(hr))
{
hr = CheckSamePhysicalAddress(pszServerName, ComputerName, &bSameAddress);
}
if (SUCCEEDED(hr) && bSameAddress)
{
//
// This is OK, because we subtract 1 from the buffer size when we query,
// thus, we know we can fit the NULL. The function return the number of
// characters copied, minus the NULL.
//
if (SUCCEEDED(hr))
{
ComputerName[cchComputerName++] = L'$';
ComputerName[cchComputerName] = L'\0';
}
if (SUCCEEDED(hr))
{
hr = LookupAccountName(NULL, ComputerName, NULL, &cbSid, NULL, &cchDomainName, &SidType) ? S_OK : GetLastErrorAsHResultAndFail();
//
// This should only return ERROR_INSUFFICIENT_BUFFER, any other return
// or a success is a failure.
//
hr = hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER) ? S_OK : (SUCCEEDED(hr) ? E_FAIL : hr);
}
if (SUCCEEDED(hr))
{
pszDomainName = AllocSplMem(cchDomainName * sizeof(WCHAR));
pSid = AllocSplMem(cbSid);
hr = pszDomainName && pSid ? S_OK : HRESULT_FROM_WIN32(ERROR_OUTOFMEMORY);
}
if (SUCCEEDED(hr))
{
hr = LookupAccountName(NULL, ComputerName, pSid, &cbSid, pszDomainName, &cchDomainName, &SidType) ? S_OK : GetLastErrorAsHResultAndFail();
}
//
// COMPUTER$ accounts are returned as user accounts when looked up, we don't
// want a disabled or inactive account.
//
if (SUCCEEDED(hr) && SidType == SidTypeUser)
{
//
// The account must be active. Otherwise I could create a workgroup machine
// with the same name as an inactive account and fox the system that way.
//
hr = HResultFromWin32(DsGetDcName(NULL, pszDomainName, NULL, NULL, DS_IS_FLAT_NAME | DS_RETURN_DNS_NAME, &pDomainControllerInfo));
if (SUCCEEDED(hr))
{
hr = HResultFromWin32(NetUserGetInfo(pDomainControllerInfo->DomainControllerName, ComputerName, 1, (BYTE **)(&pUserInfo1)));
}
//
// The account cannot be locked out or disabled.
//
if (SUCCEEDED(hr))
{
bServerInForest = !(pUserInfo1->usri1_flags & (UF_LOCKOUT | UF_ACCOUNTDISABLE));
}
}
}
if (pbServerInSameForest)
{
*pbServerInSameForest = bServerInForest;
}
if (pUserInfo1)
{
NetApiBufferFree(pUserInfo1);
}
if (pDomainControllerInfo)
{
NetApiBufferFree(pDomainControllerInfo);
}
FreeSplMem(pszDomainName);
FreeSplMem(pSid);
FreeSplMem(pszFullName);
return hr;
}
Reference in a new issue View git blame Copy permalink