able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/print/spooler/localspl/setprn.c

2264 lines
64 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990 - 1995 Microsoft Corporation
Module Name:
setprn.c
Abstract:
This module provides all the public exported APIs relating to Printer
management for the Local Print Providor
SplSetPrinter
Author:
Dave Snipp (DaveSn) 15-Mar-1991
Revision History:
Muhunthan Sivapragasam (MuhuntS) 25-Aug-95
-- support for level 4, and PRINTER_CONTROL_SET_STATUS.
-- eliminate duplicate code
Muhunthan Sivapragasam (MuhuntS) 18-Jun-1995 -- PeinterInfo5 changes
Krishna Ganugapati (KrishnaG) 1-Jun-1994 -- rewrote these functions.
SWilson - Added SetPrinter Level 7
--*/
#define NOMINMAX
#include <precomp.h>
#pragma hdrstop
#include "clusspl.h"
#define PRINTER_NO_CONTROL 0x00
typedef enum {
SECURITY_SUCCESS = 0,
SECURITY_NOCHANGE = 1,
SECURITY_FAIL = 2
} PRINTER_SECURITY_STATUS;
PRINTER_SECURITY_STATUS
SetPrinterSecurity(
SECURITY_INFORMATION SecurityInformation,
PINIPRINTER pIniPrinter,
PSECURITY_DESCRIPTOR pSecurityDescriptor
);
VOID
RegClearKey(
HKEY hKey,
PINISPOOLER pIniSpooler
);
DWORD
ValidatePrinterAttributes(
DWORD SourceAttributes,
DWORD OriginalAttributes,
LPWSTR pDatatype,
LPBOOL pbValid,
BOOL bSettableOnly
);
BOOL
ChangePrinterAttributes(
DWORD dNewAttributes,
DWORD dOldAttributes,
PINIPRINTER pIniPrinter,
PINISPOOLER pIniSpooler,
LPWSTR pszNewShareName,
BOOL bShareRecreate,
BOOL bShareUpdate
);
BOOL
NewPort(
PKEYDATA pKeyData,
PINIPRINTER pIniPrinter
);
BOOL
SplSetPrinterExtraEx(
HANDLE hPrinter,
DWORD dwPrivateFlag
)
{
BOOL ReturnValue = FALSE;
PSPOOL pSpool = (PSPOOL)hPrinter;
EnterSplSem();
if (ValidateSpoolHandle(pSpool, PRINTER_HANDLE_SERVER)) {
pSpool->pIniPrinter->dwPrivateFlag = dwPrivateFlag;
ReturnValue = TRUE;
}
LeaveSplSem();
return ReturnValue;
}
BOOL
SplGetPrinterExtraEx(
HANDLE hPrinter,
LPDWORD pdwPrivateFlag
)
{
BOOL ReturnValue = FALSE;
PSPOOL pSpool = (PSPOOL)hPrinter;
EnterSplSem();
if ((pSpool != NULL) &&
(pSpool != INVALID_HANDLE_VALUE) &&
ValidateSpoolHandle(pSpool, PRINTER_HANDLE_SERVER) &&
pdwPrivateFlag) {
*pdwPrivateFlag = pSpool->pIniPrinter->dwPrivateFlag;
ReturnValue = TRUE;
}
LeaveSplSem();
return ReturnValue;
}
BOOL
SplSetPrinterExtra(
HANDLE hPrinter,
LPBYTE pExtraData
)
{
BOOL ReturnValue;
PSPOOL pSpool = (PSPOOL)hPrinter;
EnterSplSem();
if (ValidateSpoolHandle(pSpool, PRINTER_HANDLE_SERVER)) {
pSpool->pIniPrinter->pExtraData = pExtraData;
UpdatePrinterIni( pSpool->pIniPrinter , UPDATE_CHANGEID );
ReturnValue = TRUE;
} else {
ReturnValue = FALSE;
}
LeaveSplSem();
return ReturnValue;
}
BOOL
SplGetPrinterExtra(
HANDLE hPrinter,
PBYTE *ppExtraData
)
{
PSPOOL pSpool = (PSPOOL)hPrinter;
BOOL ReturnValue;
if (ValidateSpoolHandle(pSpool, PRINTER_HANDLE_SERVER)) {
*ppExtraData = pSpool->pIniPrinter->pExtraData;
ReturnValue = TRUE;
} else {
ReturnValue = FALSE;
}
return ReturnValue;
}
BOOL
ValidateLevelAndSecurityAccesses(
PSPOOL pSpool,
DWORD Level,
LPBYTE pPrinterInfo,
DWORD Command,
PDWORD pdwAccessRequired,
PDWORD pSecurityInformation
)
{
DWORD AccessRequired = 0;
DWORD SecurityInformation= 0;
PSECURITY_DESCRIPTOR pSecurityDescriptor;
//
// Set pdwAccessRequired = 0 and
// Set pSecurityInformation = 0;
*pdwAccessRequired = 0;
*pSecurityInformation = 0;
switch (Level) {
case 0:
case 4:
case 5:
case 6:
case 7:
AccessRequired = PRINTER_ACCESS_ADMINISTER;
break;
case 2:
pSecurityDescriptor =
((PPRINTER_INFO_2)pPrinterInfo)->pSecurityDescriptor;
AccessRequired = PRINTER_ACCESS_ADMINISTER;
if (GetSecurityInformation(pSecurityDescriptor,
&SecurityInformation)) {
AccessRequired |= GetPrivilegeRequired( SecurityInformation );
} else {
//
// Bug 54918 - We should be returning the false on GetSecurityInformation
// failing. The reason we're not doing it is because this will break
// Printman. Printman should pass in Valid security descriptors for Level 2
// Fix in Printman KrishnaG 6/17
//
// LastError = GetLastError();
// return FALSE;
}
break;
case 3:
pSecurityDescriptor =
((PPRINTER_INFO_3)pPrinterInfo)->pSecurityDescriptor;
if (!pSecurityDescriptor) {
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
if (GetSecurityInformation(pSecurityDescriptor,
&SecurityInformation)) {
AccessRequired |= GetPrivilegeRequired( SecurityInformation );
} else {
// LastError = GetLastError();
return FALSE;
}
break;
default:
SetLastError(ERROR_INVALID_LEVEL);
return FALSE;
}
if (!AccessGranted(SPOOLER_OBJECT_PRINTER,
AccessRequired,
pSpool) ) {
SetLastError(ERROR_ACCESS_DENIED);
return FALSE;
}
*pdwAccessRequired = AccessRequired;
*pSecurityInformation = SecurityInformation;
return TRUE;
}
PKEYDATA
CreateAndValidatePortTokenList(
LPWSTR pPortName,
PINISPOOLER pIniSpooler
)
{
PKEYDATA pKeyData = CreateTokenList(pPortName);
if ( pKeyData ) {
if ( !ValidatePortTokenList(pKeyData, pIniSpooler, FALSE, NULL) ) {
FreePortTokenList(pKeyData);
SetLastError(ERROR_UNKNOWN_PORT);
pKeyData = NULL;
}
}
return pKeyData;
}
BOOL
NewPort(
PKEYDATA pKeyData,
PINIPRINTER pIniPrinter
)
{
DWORD i, j;
BOOL rc=TRUE;
if (!pKeyData) {
SetLastError(ERROR_UNKNOWN_PORT);
return FALSE;
}
// Check if # of requested vs. existing ports differs
if (pIniPrinter->cPorts != pKeyData->cTokens)
return TRUE;
// for each requested port see if printer already has it
for (i = 0 ; i < pKeyData->cTokens ; ++i) {
// see if requested port is already assigned to printer
for (j = 0 ; j < pIniPrinter->cPorts &&
wcscmp(pIniPrinter->ppIniPorts[j]->pName, ((PINIPORT)pKeyData->pTokens[i])->pName)
; ++j) {
DBGMSG(DBG_TRACE,("NewPort (Existing vs. Requested): \"%ws\" ?= \"%ws\"\n",
pIniPrinter->ppIniPorts[j]->pName, ((PINIPORT)pKeyData->pTokens[i])->pName));
}
if (j == pIniPrinter->cPorts) { // found new port, so return
DBGMSG(DBG_TRACE,("NewPort FOUND: \"%ws\"\n", ((PINIPORT)pKeyData->pTokens[i])->pName));
return TRUE;
}
}
return FALSE;
}
VOID
ChangePrinterName(
LPWSTR pszNewName,
PINIPRINTER pIniPrinter,
PINISPOOLER pIniSpooler,
LPDWORD pdwPrinterVector
)
/*++
Routine Description:
Changes printer name
Arguments:
pszNewName - New printer name allocated using AllocSplStr
pIniPrinter - for the printer we changing name
pIniSpooler - Spooler that owns printer
pdwPrinterVector - pointer to notification vector
Return Value:
nothing
History:
MuhuntS (Muhunthan Sivapragasam) July 95
--*/
{
LPWSTR pNewName, pOldName;
//
// Before deleting the printer entry make sure you copy
// all information with respect to the printer to the registry
// There could be several levels of keys.
//
CopyPrinterIni(pIniPrinter, pszNewName);
DeletePrinterIni(pIniPrinter);
pOldName = pIniPrinter->pName;
pIniPrinter->pName = pszNewName;
*pdwPrinterVector |= BIT(I_PRINTER_PRINTER_NAME);
//
// Delete the old entries in WIN.INI:
//
CheckAndUpdatePrinterRegAll(pIniSpooler,
pOldName,
NULL,
UPDATE_REG_DELETE );
FreeSplStr(pOldName);
//
// If printer is offline we need to write that info back with new name
//
if ( pIniPrinter->Attributes & PRINTER_ATTRIBUTE_WORK_OFFLINE )
WritePrinterOnlineStatusInCurrentConfig(pIniPrinter);
}
BOOL
SetLocalPrinterSTRESS(
PINIPRINTER pIniPrinter,
PPRINTER_INFO_STRESS pPrinterSTRESS
)
{
if ( !pPrinterSTRESS ) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//
// Allow the caller to update the counters.
//
pIniPrinter->cTotalJobs = pPrinterSTRESS->cTotalJobs;
pIniPrinter->cTotalBytes.LowPart = pPrinterSTRESS->cTotalBytes;
pIniPrinter->cTotalBytes.HighPart = pPrinterSTRESS->dwHighPartTotalBytes;
pIniPrinter->MaxcRef = pPrinterSTRESS->MaxcRef;
pIniPrinter->cTotalPagesPrinted = pPrinterSTRESS->cTotalPagesPrinted;
pIniPrinter->cMaxSpooling = pPrinterSTRESS->cMaxSpooling;
pIniPrinter->cErrorOutOfPaper = pPrinterSTRESS->cErrorOutOfPaper;
pIniPrinter->cErrorNotReady = pPrinterSTRESS->cErrorNotReady;
pIniPrinter->cJobError = pPrinterSTRESS->cJobError;
pIniPrinter->dwLastError = pPrinterSTRESS->dwLastError;
pIniPrinter->stUpTime = pPrinterSTRESS->stUpTime;
pIniPrinter->pIniSpooler->cEnumerateNetworkPrinters =
pPrinterSTRESS->cEnumerateNetworkPrinters;
pIniPrinter->pIniSpooler->cAddNetPrinters =
pPrinterSTRESS->cAddNetPrinters;
UpdatePrinterIni( pIniPrinter, KEEP_CHANGEID );
return TRUE;
}
BOOL
SetPrinterStatus(
PINIPRINTER pIniPrinter,
DWORD Status
)
{
DWORD OldStatus = pIniPrinter->Status;
pIniPrinter->Status &= PRINTER_STATUS_PRIVATE;
pIniPrinter->Status |= MapPrinterStatus(MAP_SETTABLE, Status);
if ( PrinterStatusBad(OldStatus) &&
!PrinterStatusBad(pIniPrinter->Status) ) {
CHECK_SCHEDULER();
}
SetPrinterChange(pIniPrinter,
NULL,
NVPrinterStatus,
PRINTER_CHANGE_SET_PRINTER,
pIniPrinter->pIniSpooler);
return TRUE;
}
BOOL
SetLocalPrinter0(
PINIPRINTER pIniPrinter,
DWORD Command
)
{
DWORD Change = PRINTER_CHANGE_SET_PRINTER;
BOOL bReturn = TRUE;
INCPRINTERREF( pIniPrinter );
switch (Command) {
case PRINTER_CONTROL_PURGE:
//
// PurgePrinter always returns TRUE now, still ..
//
if ( PurgePrinter(pIniPrinter) ) {
SplLogEvent(pIniPrinter->pIniSpooler,
LOG_WARNING,
MSG_PRINTER_PURGED,
TRUE,
pIniPrinter->pName,
NULL );
Change |= PRINTER_CHANGE_DELETE_JOB;
} else {
bReturn = FALSE;
}
break;
case PRINTER_CONTROL_RESUME:
pIniPrinter->Status &= ~PRINTER_PAUSED;
CHECK_SCHEDULER();
UpdatePrinterIni( pIniPrinter, KEEP_CHANGEID );
SplLogEvent(pIniPrinter->pIniSpooler,
LOG_WARNING,
MSG_PRINTER_UNPAUSED,
TRUE,
pIniPrinter->pName,
NULL );
//
// WMI Trace Events.
//
{
// Wmi only knows about jobs, so each job needs to be resumed
// separately.
PINIJOB pIniJob = pIniPrinter->pIniFirstJob;
while (pIniJob)
{
if ( !((pIniJob->Status & JOB_DESPOOLING) ||
(pIniJob->Status & JOB_PRINTING) ||
(pIniJob->Status & JOB_PRINTED) ||
(pIniJob->Status & JOB_ABANDON)) )
{
LogWmiTraceEvent(pIniJob->JobId,
EVENT_TRACE_TYPE_SPL_RESUME, NULL);
}
pIniJob = pIniJob->pIniNextJob;
}
}
break;
case PRINTER_CONTROL_PAUSE:
pIniPrinter->Status |= PRINTER_PAUSED;
UpdatePrinterIni( pIniPrinter, KEEP_CHANGEID );
SplLogEvent(pIniPrinter->pIniSpooler,
LOG_WARNING,
MSG_PRINTER_PAUSED,
TRUE,
pIniPrinter->pName,
NULL);
//
// WMI Trace Events
//
{
//
// Wmi only knows about jobs, so each job needs to be paused
// separately.
//
PINIJOB pIniJob = pIniPrinter->pIniFirstJob;
while (pIniJob)
{
//
// HANDLE PRINTING DIRECT ???
// I don't believe pausing a printer can stop a job already
// being sent to the printer.
//
if ( !((pIniJob->Status & JOB_DESPOOLING) ||
(pIniJob->Status & JOB_PRINTING) ||
(pIniJob->Status & JOB_PRINTED) ||
(pIniJob->Status & JOB_ABANDON)) )
{
LogWmiTraceEvent(pIniJob->JobId,
EVENT_TRACE_TYPE_SPL_PAUSE,
NULL);
}
pIniJob = pIniJob->pIniNextJob;
}
}
break;
default:
SetLastError(ERROR_INVALID_PRINTER_COMMAND);
bReturn = FALSE;
break;
}
DECPRINTERREF( pIniPrinter );
if (bReturn) {
SetPrinterChange(pIniPrinter,
NULL,
(Command == PRINTER_CONTROL_PURGE) ? NVPurge
: NVPrinterStatus,
Change,
pIniPrinter->pIniSpooler);
}
return bReturn;
}
BOOL
ValidateSetPrinter2(
PINIPRINTER pIniPrinter,
PINIPRINTER pTempIniPrinter,
PPRINTER_INFO_2 pPrinterInfo2
)
/*++
Routine Description:
Validates and builds request info about a SetPrinter info call for
Printer information that could be changed only for level2.
Arguments:
pIniPrinter - PINIPRINTER of the printer handle passed in
pTempIniPrinter - this structure is used to gather info about all
parameters being changed
pPrinterInfo2 - the PrinterInfo2 structure being passed in
Return Value:
TRUE: If all the validation is succesful
FALSE: If validation of one or more request fails
On succesful return fields which need to be changed will be set in
pTempIniPrinter. Cleanup of this structure will be done later.
History:
MuhuntS (Muhunthan Sivapragasam) Aug 95
--*/
{
BOOL bFail = FALSE;
DWORD LastError = ERROR_SUCCESS;
PINIVERSION pIniVersion = NULL;
PINIENVIRONMENT pIniEnvironment = NULL;
BOOL bSuccess = FALSE;
// Servername can't change
// Printername handled for level 2, 4, 5
// Sharenname length validation
if ( pPrinterInfo2->pShareName && wcslen(pPrinterInfo2->pShareName) > PATHLEN-1 ){
bFail = TRUE;
LastError = ERROR_INVALID_PARAMETER;
}
// Share Name (validation later if required)
AllocOrUpdateString(&pTempIniPrinter->pShareName,
pPrinterInfo2->pShareName,
pIniPrinter->pShareName,
TRUE,
&bFail);
if ( bFail )
goto Cleanup;
// Port Name for level 2, 5
// DriverName
bSuccess = FindLocalDriverAndVersion(pIniPrinter->pIniSpooler,
pPrinterInfo2->pDriverName,
&pTempIniPrinter->pIniDriver,
&pIniVersion);
if ( !bSuccess ) {
LastError = ERROR_UNKNOWN_PRINTER_DRIVER;
goto Cleanup;
}
pIniEnvironment = GetLocalArchEnv(pIniPrinter->pIniSpooler);
//
// If we have a queue with a KMPD, then we need to let the user manage it,
// even if the policy for blocking KMPD is enabled. However, if the caller
// wants to change the printer driver to a KMPD, then we do not allow that
//
if (pTempIniPrinter->pIniDriver != pIniPrinter->pIniDriver)
{
INCDRIVERREF(pTempIniPrinter->pIniDriver);
if (KMPrintersAreBlocked() &&
IniDriverIsKMPD(pIniPrinter->pIniSpooler,
pIniEnvironment,
pIniVersion,
pTempIniPrinter->pIniDriver)) {
SplLogEvent( pIniPrinter->pIniSpooler,
LOG_ERROR,
MSG_KM_PRINTERS_BLOCKED,
TRUE,
pIniPrinter->pName,
NULL );
LastError = ERROR_KM_DRIVER_BLOCKED;
goto Cleanup;
}
}
// Comment length validation
if ( pPrinterInfo2->pComment && wcslen(pPrinterInfo2->pComment) > PATHLEN-1 ){
bFail = TRUE;
LastError = ERROR_INVALID_PARAMETER;
}
// Comment
AllocOrUpdateString(&pTempIniPrinter->pComment,
pPrinterInfo2->pComment,
pIniPrinter->pComment,
TRUE,
&bFail);
// Location length validation
if ( pPrinterInfo2->pLocation && wcslen(pPrinterInfo2->pLocation) > MAX_PATH-1 ){
bFail = TRUE;
LastError = ERROR_INVALID_PARAMETER;
}
// Location
AllocOrUpdateString(&pTempIniPrinter->pLocation,
pPrinterInfo2->pLocation,
pIniPrinter->pLocation,
TRUE,
&bFail);
// DevMode at the end
// SepFile length validation
if( !CheckSepFile( pPrinterInfo2->pSepFile )) {
bFail = TRUE;
LastError = ERROR_INVALID_SEPARATOR_FILE;
}
// SepFile
AllocOrUpdateString(&pTempIniPrinter->pSepFile,
pPrinterInfo2->pSepFile,
pIniPrinter->pSepFile,
TRUE,
&bFail);
if ( bFail )
goto Cleanup;
if ( pIniPrinter->pSepFile != pTempIniPrinter->pSepFile &&
!CheckSepFile(pPrinterInfo2->pSepFile) ) {
LastError = ERROR_INVALID_SEPARATOR_FILE;
goto Cleanup;
}
// Print Processor
pTempIniPrinter->pIniPrintProc = FindPrintProc(
pPrinterInfo2->pPrintProcessor,
pIniEnvironment );
if ( !pTempIniPrinter->pIniPrintProc ) {
LastError = ERROR_UNKNOWN_PRINTPROCESSOR;
goto Cleanup;
}
if ( pTempIniPrinter->pIniPrintProc != pIniPrinter->pIniPrintProc )
pTempIniPrinter->pIniPrintProc->cRef++;
// Datatype
if ( !pPrinterInfo2->pDatatype || wcslen(pPrinterInfo2->pDatatype) > MAX_PATH-1) {
LastError = ERROR_INVALID_DATATYPE;
goto Cleanup; // Ok to fail ???
} else {
AllocOrUpdateString(&pTempIniPrinter->pDatatype,
pPrinterInfo2->pDatatype,
pIniPrinter->pDatatype,
TRUE,
&bFail);
}
// Parameters length validation
if (pPrinterInfo2->pParameters && wcslen(pPrinterInfo2->pParameters) > MAX_PATH-1){
bFail = TRUE;
LastError = ERROR_INVALID_PARAMETER;
}
// Parameters
AllocOrUpdateString(&pTempIniPrinter->pParameters,
pPrinterInfo2->pParameters,
pIniPrinter->pParameters,
TRUE,
&bFail);
if ( bFail )
goto Cleanup;
// SecurityDescriptor for level 2, 3
// Attributes for level 2, 4, 5
// Priority
pTempIniPrinter->Priority = pPrinterInfo2->Priority;
if ( pTempIniPrinter->Priority != pIniPrinter->Priority &&
pTempIniPrinter->Priority != NO_PRIORITY &&
( pTempIniPrinter->Priority > MAX_PRIORITY ||
pTempIniPrinter->Priority < MIN_PRIORITY ) ) {
LastError = ERROR_INVALID_PRIORITY;
goto Cleanup;
}
// Default Priority
pTempIniPrinter->DefaultPriority = pPrinterInfo2->DefaultPriority;
if ( pTempIniPrinter->DefaultPriority != pIniPrinter->DefaultPriority &&
pTempIniPrinter->DefaultPriority != NO_PRIORITY &&
( pTempIniPrinter->DefaultPriority > MAX_PRIORITY ||
pTempIniPrinter->DefaultPriority < MIN_PRIORITY ) ) {
LastError = ERROR_INVALID_PRIORITY;
goto Cleanup;
}
// Start time
pTempIniPrinter->StartTime = pPrinterInfo2->StartTime;
if ( pTempIniPrinter->StartTime != pIniPrinter->StartTime &&
pTempIniPrinter->StartTime >= ONEDAY ) {
LastError = ERROR_INVALID_TIME;
goto Cleanup;
}
// Until time
pTempIniPrinter->UntilTime = pPrinterInfo2->UntilTime;
if ( pTempIniPrinter->UntilTime != pIniPrinter->UntilTime &&
pTempIniPrinter->StartTime >= ONEDAY ) {
LastError = ERROR_INVALID_TIME;
goto Cleanup;
}
// Status for level 0, 2
// Status can't chg
// AveragePPM can't chg
Cleanup:
if ( LastError ) {
SetLastError(LastError);
return FALSE;
}
if ( bFail )
return FALSE;
return TRUE;
}
VOID
ProcessSetPrinter2(
PINIPRINTER pIniPrinter,
PINIPRINTER pTempIniPrinter,
PPRINTER_INFO_2 pPrinterInfo2,
LPDWORD pdwPrinterVector,
PDEVMODE pDevMode
)
/*++
Routine Description:
Process SetPrinter for level 2. Only fields which can be changed ONLY
by level 2 will be processed here. That is: All the fields built by
ValidateSetPrinter2.
Arguments:
pIniPrinter - PINIPRINTER of the printer handle passed in
pTempIniPrinter - this structure is has all the fields which needs to
be set. Other fields will be the same as the previous
pPrinterInfo2 - the PrinterInfo2 structure being passed in
pdwPrinterVector - Notification Info
pDevMode - New dev mode to be set
Return Value:
nothing
History:
MuhuntS (Muhunthan Sivapragasam) Aug 95
--*/
{
HANDLE hToken;
PINISPOOLER pIniSpooler = pIniPrinter->pIniSpooler;
HKEY hKey = NULL;
DWORD dwResult;
// Sharename
if ( pTempIniPrinter->pShareName != pIniPrinter->pShareName ) {
FreeSplStr(pIniPrinter->pShareName);
pIniPrinter->pShareName = pTempIniPrinter->pShareName;
*pdwPrinterVector |= BIT(I_PRINTER_SHARE_NAME);
}
// Driver
if ( pTempIniPrinter->pIniDriver != pIniPrinter->pIniDriver ) {
DECDRIVERREF(pIniPrinter->pIniDriver);
if (pIniPrinter->pIniSpooler->SpoolerFlags & SPL_PRINTER_DRIVER_EVENT)
{
hToken = RevertToPrinterSelf();
dwResult = OpenPrinterKey(pIniPrinter, KEY_READ | KEY_WRITE, &hKey, szPrinterData, TRUE);
if (dwResult == ERROR_SUCCESS) {
DeleteSubkeys( hKey, pIniSpooler );
RegClearKey( hKey, pIniSpooler );
SplRegCloseKey(hKey, pIniPrinter->pIniSpooler);
}
if (hToken)
ImpersonatePrinterClient(hToken);
}
pIniPrinter->pIniDriver = pTempIniPrinter->pIniDriver;
*pdwPrinterVector |= BIT(I_PRINTER_DRIVER_NAME);
}
// Comment
if ( pTempIniPrinter->pComment != pIniPrinter->pComment ) {
FreeSplStr(pIniPrinter->pComment);
pIniPrinter->pComment = pTempIniPrinter->pComment;
*pdwPrinterVector |= BIT(I_PRINTER_COMMENT);
}
// Location
if ( pTempIniPrinter->pLocation != pIniPrinter->pLocation ) {
FreeSplStr(pIniPrinter->pLocation);
pIniPrinter->pLocation = pTempIniPrinter->pLocation;
*pdwPrinterVector |= BIT(I_PRINTER_LOCATION);
}
// DevMode at the end
if ( CopyPrinterDevModeToIniPrinter(pIniPrinter,
pDevMode) ) {
*pdwPrinterVector |= BIT(I_PRINTER_DEVMODE);
}
// SepFile
if ( pTempIniPrinter->pSepFile != pIniPrinter->pSepFile ) {
FreeSplStr(pIniPrinter->pSepFile);
pIniPrinter->pSepFile = pTempIniPrinter->pSepFile;
*pdwPrinterVector |= BIT(I_PRINTER_SEPFILE);
}
// PrintProcessor
if ( pIniPrinter->pIniPrintProc != pTempIniPrinter->pIniPrintProc) {
pIniPrinter->pIniPrintProc->cRef--;
pIniPrinter->pIniPrintProc = pTempIniPrinter->pIniPrintProc;
*pdwPrinterVector |= BIT(I_PRINTER_PRINT_PROCESSOR);
}
// Datatype
if ( pIniPrinter->pDatatype != pTempIniPrinter->pDatatype ) {
FreeSplStr(pIniPrinter->pDatatype);
pIniPrinter->pDatatype = pTempIniPrinter->pDatatype;
*pdwPrinterVector |= BIT(I_PRINTER_DATATYPE);
}
// Parameters
if ( pIniPrinter->pParameters != pTempIniPrinter->pParameters ) {
FreeSplStr(pIniPrinter->pParameters);
pIniPrinter->pParameters = pTempIniPrinter->pParameters;
*pdwPrinterVector |= BIT(I_PRINTER_PARAMETERS);
}
// Priority
if ( pTempIniPrinter->Priority != pIniPrinter->Priority ) {
pIniPrinter->Priority = pTempIniPrinter->Priority;
*pdwPrinterVector |= BIT(I_PRINTER_PRIORITY);
}
// Default Priority
if ( pTempIniPrinter->DefaultPriority != pIniPrinter->DefaultPriority ) {
pIniPrinter->DefaultPriority = pTempIniPrinter->DefaultPriority;
*pdwPrinterVector |= BIT(I_PRINTER_DEFAULT_PRIORITY);
}
// Start time
if ( pTempIniPrinter->StartTime != pIniPrinter->StartTime ) {
pIniPrinter->StartTime = pTempIniPrinter->StartTime;
*pdwPrinterVector |= BIT(I_PRINTER_START_TIME);
}
// Until time
if ( pTempIniPrinter->UntilTime != pIniPrinter->UntilTime ) {
pIniPrinter->UntilTime = pTempIniPrinter->UntilTime;
*pdwPrinterVector |= BIT(I_PRINTER_UNTIL_TIME);
}
}
VOID
CleanupSetPrinter(
PINIPRINTER pIniPrinter,
PINIPRINTER pTempIniPrinter,
PKEYDATA pKeyData,
DWORD Level,
BOOL bReturnValue
)
/*++
Routine Description:
This routine is called at the end of SplSetPrinter call to free up all
the allocations done to process it which are not needed.
At the beginning of a SetPrinter we make an identical copy of the
pIniPrinter in pTempIniPrinter and collect all arguments in there.
Now if the call is failing each of the arguments collected in there
need to be freed.
Arguments:
pIniPrinter - PINIPRINTER of the printer handle passed in
pTempIniPrinter - this structure is has all the fields which needs to
be freed. Any field different than pIniPrinter was
built part of processing the call and needs to be freed.
pPrinterInfo2 - built for port info
bReturnValue - return value of SetPrinter
Return Value:
nothing
History:
MuhuntS (Muhunthan Sivapragasam) Aug 95
--*/
{
//
// We adjust INIPORT, INIDRIVER refcounts. So should be inside the spl sem
//
SplInSem();
FreePortTokenList(pKeyData);
if ( pTempIniPrinter ) {
if ( !bReturnValue && Level == 2 ) {
if ( pTempIniPrinter->pShareName != pIniPrinter->pShareName )
FreeSplStr(pTempIniPrinter->pShareName);
if ( pTempIniPrinter->pComment != pIniPrinter->pComment )
FreeSplStr(pTempIniPrinter->pComment);
if ( pTempIniPrinter->pLocation != pIniPrinter->pLocation )
FreeSplStr(pTempIniPrinter->pLocation);
if ( pTempIniPrinter->pSepFile != pIniPrinter->pSepFile )
FreeSplStr(pTempIniPrinter->pSepFile);
if ( pTempIniPrinter->pDatatype != pIniPrinter->pDatatype )
FreeSplStr(pTempIniPrinter->pDatatype);
if ( pTempIniPrinter->pParameters != pIniPrinter->pParameters )
FreeSplStr(pTempIniPrinter->pParameters);
if ( ( pTempIniPrinter->pIniDriver != NULL ) &&
( pTempIniPrinter->pIniDriver != pIniPrinter->pIniDriver )) {
DECDRIVERREF(pTempIniPrinter->pIniDriver);
}
if ( ( pTempIniPrinter->pIniPrintProc != NULL ) &&
( pTempIniPrinter->pIniPrintProc != pIniPrinter->pIniPrintProc )) {
pTempIniPrinter->pIniPrintProc->cRef--;
}
}
FreeSplMem(pTempIniPrinter);
}
}
BOOL
ValidateAndBuildSetPrinterRequest(
PINIPRINTER pIniPrinter,
PINIPRINTER pTempIniPrinter,
LPBYTE pPrinterInfo,
DWORD Level,
SECURITY_INFORMATION SecurityInformation,
LPBOOL pbSecurityChg,
LPBOOL pbNameChg,
LPBOOL pbAttributeChg,
LPWSTR *ppszNewPrinterName,
PKEYDATA *ppKeyData
)
/*++
Routine Description:
This routine is called to validate a SetPrinter request. We try to as
much vaidation as possible at the beginning to see the changes are
possible. The routine will collect all changes requested in the
pTempIniPrinter structure.
Arguments:
pIniPrinter - PINIPRINTER of the printer handle passed in
pTempIniPrinter - this structure will be used to collect all the
changes requested
pPrinterInfo - PrinterInfo_N structure passed in
Level - Level of PrinterInfo_N
SecurityInformation - security information
pbSecurityChg - this will be set if a security change is requested
pbNameChg - this will be set if a name change is requested
pbAttributeChg - this will be set if a attribute change is requested
ppszNewPrinterName - *ppszNewPrinterName will give the new printer name
to be set on a name change
ppKeyData - *ppKeyData will give the Port token info for a level 2 or 5
call
Return Value:
TRUE - if all the validations succeed
FALSE - a validation fails
History:
MuhuntS (Muhunthan Sivapragasam) Aug 95
--*/
{
PPRINTER_INFO_2 pPrinterInfo2 = (PPRINTER_INFO_2)pPrinterInfo;
PPRINTER_INFO_3 pPrinterInfo3 = (PPRINTER_INFO_3)pPrinterInfo;
PPRINTER_INFO_4 pPrinterInfo4 = (PPRINTER_INFO_4)pPrinterInfo;
PPRINTER_INFO_5 pPrinterInfo5 = (PPRINTER_INFO_5)pPrinterInfo;
LPWSTR pPortName;
DWORD dwLastError;
BOOL bValid = TRUE;
switch (Level) {
case 2:
pTempIniPrinter->pSecurityDescriptor =
pPrinterInfo2->pSecurityDescriptor;
if ( !ValidateSetPrinter2(pIniPrinter, pTempIniPrinter, pPrinterInfo2) )
return FALSE;
pTempIniPrinter->pName = pPrinterInfo2->pPrinterName;
pPortName = pPrinterInfo2->pPortName;
if ( !pTempIniPrinter->pIniDriver->pIniLangMonitor )
pPrinterInfo2->Attributes &= ~PRINTER_ATTRIBUTE_ENABLE_BIDI;
if ( pIniPrinter->pIniDriver != pTempIniPrinter->pIniDriver ) {
pPrinterInfo2->Attributes &= ~PRINTER_ATTRIBUTE_ENABLE_BIDI;
if ( pTempIniPrinter->pIniDriver->pIniLangMonitor )
pPrinterInfo2->Attributes |= PRINTER_ATTRIBUTE_ENABLE_BIDI;
}
pTempIniPrinter->Attributes =
ValidatePrinterAttributes(pPrinterInfo2->Attributes,
pIniPrinter->Attributes,
pPrinterInfo2->pDatatype,
&bValid,
TRUE);
if (!bValid) {
return FALSE;
}
*pbAttributeChg = pTempIniPrinter->Attributes != pIniPrinter->Attributes;
break;
case 3:
pTempIniPrinter->pSecurityDescriptor = pPrinterInfo3->pSecurityDescriptor;
if ( !SecurityInformation || !pTempIniPrinter->pSecurityDescriptor ) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
break;
case 4:
pTempIniPrinter->pName = pPrinterInfo4->pPrinterName;
if ( !pIniPrinter->pIniDriver->pIniLangMonitor )
pPrinterInfo4->Attributes &= ~PRINTER_ATTRIBUTE_ENABLE_BIDI;
pTempIniPrinter->Attributes =
ValidatePrinterAttributes(pPrinterInfo4->Attributes,
pIniPrinter->Attributes,
pIniPrinter->pDatatype,
&bValid,
TRUE);
if (!bValid) {
return FALSE;
}
*pbAttributeChg = pTempIniPrinter->Attributes != pIniPrinter->Attributes;
break;
case 5:
pTempIniPrinter->pName = pPrinterInfo5->pPrinterName;
pPortName = pPrinterInfo5->pPortName;
if ( !pIniPrinter->pIniDriver->pIniLangMonitor )
pPrinterInfo5->Attributes &= ~PRINTER_ATTRIBUTE_ENABLE_BIDI;
pTempIniPrinter->Attributes =
ValidatePrinterAttributes(pPrinterInfo5->Attributes,
pIniPrinter->Attributes,
pIniPrinter->pDatatype,
&bValid,
TRUE);
if (!bValid) {
return FALSE;
}
*pbAttributeChg = pTempIniPrinter->Attributes != pIniPrinter->Attributes;
//
// Validate timeout?
//
pTempIniPrinter->dnsTimeout = pPrinterInfo5->DeviceNotSelectedTimeout;
pTempIniPrinter->txTimeout = pPrinterInfo5->TransmissionRetryTimeout;
break;
default:
SetLastError(ERROR_INVALID_LEVEL);
return FALSE;
}
//
// Validate share name if the shared bit is getting set or share name
// is being changed
//
if ( (pTempIniPrinter->Attributes & PRINTER_ATTRIBUTE_SHARED) &&
( !(pIniPrinter->Attributes & PRINTER_ATTRIBUTE_SHARED) ||
pTempIniPrinter->pShareName != pIniPrinter->pShareName) ) {
dwLastError = ValidatePrinterShareName(pTempIniPrinter->pShareName,
pIniPrinter->pIniSpooler,
pIniPrinter);
if ( dwLastError != ERROR_SUCCESS ) {
SetLastError(dwLastError);
return FALSE;
}
}
//
// Is there a security change?
//
if ( SecurityInformation && (Level == 2 || Level == 3) ) {
DWORD dwSize;
dwSize = GetSecurityDescriptorLength(pIniPrinter->pSecurityDescriptor);
if ( dwSize !=
GetSecurityDescriptorLength(pTempIniPrinter->pSecurityDescriptor) ||
memcmp(pTempIniPrinter->pSecurityDescriptor,
pIniPrinter->pSecurityDescriptor,
dwSize) ) {
*pbSecurityChg = TRUE;
}
}
//
// Is there a name change?
//
if ( Level == 2 || Level == 4 || Level == 5 ) {
DWORD LastError;
if ( !pTempIniPrinter->pName || !*pTempIniPrinter->pName ) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//
// Validate name if a change is requested
//
if ( lstrcmpi(pTempIniPrinter->pName, pIniPrinter->pName) ) {
LastError = ValidatePrinterName(pTempIniPrinter->pName,
pIniPrinter->pIniSpooler,
pIniPrinter,
ppszNewPrinterName);
if ( LastError != ERROR_SUCCESS ) {
*ppszNewPrinterName = NULL;
SetLastError(LastError);
return FALSE;
}
//
// Check if printer name really changed for remote calls
//
if ( lstrcmpi(*ppszNewPrinterName, pIniPrinter->pName) ) {
*ppszNewPrinterName = AllocSplStr(*ppszNewPrinterName);
if ( !*ppszNewPrinterName )
return FALSE;
*pbNameChg = TRUE;
} else {
*ppszNewPrinterName = NULL;
}
}
//
// Validate attributes if a change is requested
// Don't allow a change from queued to direct or vice versa
// if there are already jobs on the printer.
//
if ( pIniPrinter->cJobs > 0 ) {
if ( (pTempIniPrinter->Attributes & PRINTER_ATTRIBUTE_DIRECT) !=
(pIniPrinter->Attributes & PRINTER_ATTRIBUTE_DIRECT) ) {
SetLastError(ERROR_PRINTER_HAS_JOBS_QUEUED);
return FALSE;
}
}
}
if ( Level == 2 || Level == 5 ) {
if ( !pPortName || !*pPortName ) {
SetLastError(ERROR_UNKNOWN_PORT);
return FALSE;
}
*ppKeyData = CreateAndValidatePortTokenList(pPortName,
pIniPrinter->pIniSpooler);
if ( !*ppKeyData )
return FALSE;
}
return TRUE;
}
BOOL
SplSetPrinter(
HANDLE hPrinter,
DWORD Level,
LPBYTE pPrinterInfo,
DWORD Command
)
{
PSPOOL pSpool = (PSPOOL)hPrinter;
DWORD i, LastError = ERROR_SUCCESS;
DWORD AccessRequired = 0;
PINIPRINTER pIniPrinter = pSpool->pIniPrinter, pTempIniPrinter = NULL;
PINISPOOLER pIniSpooler;
BOOL bReturn = TRUE;
DWORD dwResult;
BOOL bShareUpdate;
BOOL bShareRecreate;
DWORD dwPrinterVector = 0;
NOTIFYVECTOR NotifyVector;
BOOL bUpdateDsSpoolerKey = FALSE;
BOOL bNewPort;
BOOL bDataChanged = FALSE;
DWORD OldAttributes = 0;
PPRINTER_INFO_2 pPrinterInfo2 = (PPRINTER_INFO_2)pPrinterInfo;
PPRINTER_INFO_3 pPrinterInfo3 = (PPRINTER_INFO_3)pPrinterInfo;
PPRINTER_INFO_4 pPrinterInfo4 = (PPRINTER_INFO_4)pPrinterInfo;
PPRINTER_INFO_5 pPrinterInfo5 = (PPRINTER_INFO_5)pPrinterInfo;
PPRINTER_INFO_7 pPrinterInfo7 = (PPRINTER_INFO_7)pPrinterInfo;
PRINTER_INFO_7 PrinterInfo7;
BOOL bSecurityChg, bNameChg, bAttributeChg;
LPWSTR pszNewPrinterName = NULL, pszOldPrinterName = NULL;
PINIJOB pIniJob;
PKEYDATA pKeyData = NULL;
PDEVMODE pDevMode = NULL;
PINIDRIVER pIniDriver;
PINIPRINTPROC pIniPrintProc;
SECURITY_INFORMATION SecurityInformation;
ZERONV(NotifyVector);
bSecurityChg = bNameChg = bAttributeChg = FALSE;
bShareUpdate = bShareRecreate = FALSE;
//
// If level != 0 info struct should be non-null, and command 0
//
if ( Level && Command ) {
SetLastError(ERROR_INVALID_PRINTER_COMMAND);
return FALSE;
}
if ( Level && !pPrinterInfo ) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
EnterSplSem();
if (!ValidateSpoolHandle(pSpool, PRINTER_HANDLE_SERVER )) {
bReturn = FALSE;
goto Cleanup;
}
//
// If it is a remote call get default devmode from driver and then update it
//
if ( Level == 2 ) {
pDevMode = pPrinterInfo2->pDevMode;
if ( pDevMode && (pSpool->TypeofHandle & PRINTER_HANDLE_REMOTE_DATA) ) {
//
// If the driver can't convert devmode user's can't set devmode from remote m/c
//
pDevMode = ConvertDevModeToSpecifiedVersion(pIniPrinter,
pDevMode,
NULL,
NULL,
CURRENT_VERSION);
}
}
SplInSem();
pIniSpooler = pIniPrinter->pIniSpooler;
SPLASSERT(pIniPrinter->signature == IP_SIGNATURE );
SPLASSERT(pIniSpooler->signature == ISP_SIGNATURE );
if (pSpool->pIniPrinter->Status & PRINTER_ZOMBIE_OBJECT) {
LastError = ERROR_PRINTER_DELETED;
goto Cleanup;
}
if ( !ValidateLevelAndSecurityAccesses(pSpool,
Level,
pPrinterInfo,
Command,
&AccessRequired,
&SecurityInformation) ){
bReturn = FALSE;
goto Cleanup;
}
//
// Level 7 & publishing levels
//
if (Level == 7) {
if ( !(pIniPrinter->pIniSpooler->SpoolerFlags & SPL_TYPE_CACHE)) {
if (pPrinterInfo7->dwAction != DSPRINT_PUBLISH &&
pPrinterInfo7->dwAction != DSPRINT_UNPUBLISH &&
pPrinterInfo7->dwAction != DSPRINT_REPUBLISH &&
pPrinterInfo7->dwAction != DSPRINT_UPDATE) {
LastError = ERROR_INVALID_PARAMETER;
bReturn = FALSE;
goto Cleanup;
}
DBGMSG(DBG_EXEC, ("SplSetPrinter: DS Action %d: %ws %ws",
pPrinterInfo7->dwAction,
pIniPrinter->pName,
pIniPrinter->pszObjectGUID ?
pIniPrinter->pszObjectGUID : L"<NULL>"));
bUpdateDsSpoolerKey = TRUE;
} else {
//
// For connections, we rely directly on pPrinterInfo7->dwAction because
// the we cannot determine a pending publishing state based on attributes and GUID.
// If the remote printer is in Pending publishing, we need to save this in dwAction.
//
if (!pIniPrinter->pszObjectGUID || !pPrinterInfo7->pszObjectGUID) {
FreeSplStr(pIniPrinter->pszObjectGUID);
pIniPrinter->pszObjectGUID = NULL;
dwPrinterVector |= BIT(I_PRINTER_OBJECT_GUID);
} else if (wcscmp(pIniPrinter->pszObjectGUID, pPrinterInfo7->pszObjectGUID)) {
FreeSplStr(pIniPrinter->pszObjectGUID);
}
if ( pPrinterInfo7->pszObjectGUID ) {
if (!(pIniPrinter->pszObjectGUID = AllocSplStr(pPrinterInfo7->pszObjectGUID))) {
bReturn = FALSE;
goto Cleanup;
}
}
pIniPrinter->dwAction = pPrinterInfo7->dwAction;
dwPrinterVector |= BIT(I_PRINTER_OBJECT_GUID);
}
goto Finish;
} else if (Level != 3 && Level != 0) {
bUpdateDsSpoolerKey = TRUE;
}
//
// We need to do this for Level 0, 2, 3, 4, 5
// (except for level 3 which is security case)
//
if ( Level != 3 && pSpool->hPort ) {
if ( pSpool->hPort == INVALID_PORT_HANDLE ) {
//
// If this value is 0, then when we return GetLastError,
// the client will think we succeeded.
//
SPLASSERT( pSpool->OpenPortError );
LastError = pSpool->OpenPortError;
goto Cleanup;
} else {
bReturn = SetPrinter(pSpool->hPort,
Level,
pPrinterInfo,
Command);
if ( !Level )
goto Cleanup;
}
}
if ( Level != 6 && Level != 0 ) {
pTempIniPrinter = (PINIPRINTER) AllocSplMem(sizeof(INIPRINTER));
if ( !pTempIniPrinter )
goto Cleanup;
CopyMemory(pTempIniPrinter, pIniPrinter, sizeof(INIPRINTER));
}
//
// The actual processing begins here
//
if ( !Level && !Command ) {
bReturn = SetLocalPrinterSTRESS(pIniPrinter,
(PPRINTER_INFO_STRESS)pPrinterInfo);
goto Cleanup;
} else if ( !Level ) {
bReturn = SetLocalPrinter0(pIniPrinter, Command);
goto Cleanup;
} else if ( Level == 6 ) {
bReturn = SetPrinterStatus(pIniPrinter,
((LPPRINTER_INFO_6)pPrinterInfo)->dwStatus);
goto Cleanup;
} else {
if ( !ValidateAndBuildSetPrinterRequest(pIniPrinter,
pTempIniPrinter,
pPrinterInfo,
Level,
SecurityInformation,
&bSecurityChg,
&bNameChg,
&bAttributeChg,
&pszNewPrinterName,
&pKeyData) ) {
bReturn = FALSE;
goto Cleanup;
} // else we follow thru rest of code since all valiations succeded
// Just a flag stating whether we have a new port
bNewPort = NewPort(pKeyData, pIniPrinter);
if (bNewPort) {
dwPrinterVector |= BIT(I_PRINTER_PORT_NAME);
}
}
//
// --------------------All validation done---------------------------
//
//
// Now set security information; Remember we have
// a valid SecurityDescriptor and "SecurityInformation
// is non-zero at this point. We have validated this
// information
//
if ( bSecurityChg ) {
if ( SetPrinterSecurityDescriptor(SecurityInformation,
pTempIniPrinter->pSecurityDescriptor,
&pIniPrinter->pSecurityDescriptor) ) {
dwPrinterVector |= BIT(I_PRINTER_SECURITY_DESCRIPTOR);
bShareUpdate = TRUE;
} else {
bReturn = FALSE;
goto Cleanup;
}
}
// Can we avoid doing this if bNewPort == NULL?
if ( Level == 2 || Level == 5 ) {
//
// bi-dir associate pIniPrinter with ports inside pKeyData.
//
bReturn = SetPrinterPorts(pSpool, pIniPrinter, pKeyData);
if ( !bReturn )
goto Cleanup;
}
if ( bAttributeChg ) {
if ( !(pTempIniPrinter->Attributes & PRINTER_ATTRIBUTE_ENABLE_DEVQ) &&
pIniPrinter->cJobs) {
pIniJob = pIniPrinter->pIniFirstJob;
while (pIniJob) {
if (pIniJob->Status & JOB_BLOCKED_DEVQ) {
PNOTIFYVECTOR pNotifyVector = &NVJobStatus;
pIniJob->Status &= ~JOB_BLOCKED_DEVQ;
if( pIniJob->pStatus ){
FreeSplStr(pIniJob->pStatus);
pIniJob->pStatus = NULL;
pNotifyVector = &NVJobStatusAndString;
}
SetPrinterChange(pIniJob->pIniPrinter,
pIniJob,
*pNotifyVector,
PRINTER_CHANGE_SET_JOB,
pIniJob->pIniPrinter->pIniSpooler);
}
pIniJob = pIniJob->pIniNextJob;
}
}
}
//
// The comment must be changed here since ShareThisPrinter
// will look at pComment when the printer is reshared.
//
if ( Level == 2 &&
pIniPrinter->pComment != pTempIniPrinter->pComment ) {
FreeSplStr(pIniPrinter->pComment);
pIniPrinter->pComment = pTempIniPrinter->pComment;
dwPrinterVector |= BIT(I_PRINTER_COMMENT);
if (pTempIniPrinter->Attributes & PRINTER_ATTRIBUTE_SHARED) {
bShareUpdate = TRUE;
}
}
//
// Change printer name if different
//
if ( bNameChg ) {
pszOldPrinterName = AllocSplStr(pIniPrinter->pName);
if (!pszOldPrinterName && pIniPrinter->pName) {
bReturn = FALSE;
goto Cleanup;
}
ChangePrinterName(pszNewPrinterName, pIniPrinter, pIniSpooler,
&dwPrinterVector);
pszNewPrinterName = NULL;
//
// The print share must be recreated since there's no way
// to change the path without deleting and creating a new one.
//
bShareRecreate = TRUE;
}
//
// If Share name changed force update
//
if ( pIniPrinter->pShareName != pTempIniPrinter->pShareName ) {
bShareRecreate = TRUE;
}
if ( bAttributeChg || bShareUpdate || bShareRecreate ) {
OldAttributes = pIniPrinter->Attributes;
pIniPrinter->Attributes = pTempIniPrinter->Attributes;
bReturn = ChangePrinterAttributes(pIniPrinter->Attributes,
OldAttributes,
pIniPrinter,
pIniSpooler,
pTempIniPrinter->pShareName,
bShareRecreate,
bShareUpdate);
if (!bReturn) {
LastError = GetLastError();
}
if (pIniPrinter->Attributes != OldAttributes) {
dwPrinterVector |= BIT(I_PRINTER_ATTRIBUTES);
}
}
if ( Level == 2 ) {
ProcessSetPrinter2(pIniPrinter,
pTempIniPrinter,
pPrinterInfo2,
&dwPrinterVector,
pDevMode);
}
Finish:
// Sometimes SetPrinter can fail certain calls after it has modified some parameters.
// For instance, we may have failed to update some sharing fields. If we get to this
// point (or anywhere after the last goto Cleanup), then we need to update the ds keys.
// We should really clean up SetPrinter so it undoes everything, but we don't have enough time
// to fix it properly before NT6.
bDataChanged = TRUE;
CHECK_SCHEDULER();
// Can we avoid doing this if dwPrinterVector == NULL?
UpdatePrinterIni( pIniPrinter, UPDATE_CHANGEID );
// Can we avoid doing this if dwPrinterVector == NULL?
UpdateWinIni( pIniPrinter ); // So the port on the device is correct
//
// Log event that the SetPrinter was done.
//
INCPRINTERREF(pIniPrinter);
SplLogEvent(pIniSpooler, LOG_INFO, MSG_PRINTER_SET, TRUE, pIniPrinter->pName, NULL);
DECPRINTERREF(pIniPrinter);
NotifyVector[PRINTER_NOTIFY_TYPE] |= dwPrinterVector;
//
// Indicate that a change has occurred.
//
SetPrinterChange(pIniPrinter,
NULL,
NotifyVector,
PRINTER_CHANGE_SET_PRINTER,
pIniSpooler);
Cleanup:
SplInSem();
if ( LastError != ERROR_SUCCESS ) {
SetLastError(LastError);
bReturn = FALSE;
}
CleanupSetPrinter(pIniPrinter, pTempIniPrinter, pKeyData,
Level, bReturn);
if (bDataChanged) {
INCPRINTERREF(pIniPrinter);
LeaveSplSem();
SplOutSem();
//
// If the printer driver changed
// Call the printer driver to initialize itself
//
if (dwPrinterVector & BIT(I_PRINTER_DRIVER_NAME)) {
PDEVMODE pDevMode = NULL;
PrinterDriverEvent(pIniPrinter, PRINTER_EVENT_INITIALIZE, (LPARAM)NULL);
//
// If the driver name changed then convert the devmode to the new driver's
// devmode. Note this must be done after the printer event initialize
// because the driver is not able to handle a convert devmode call before
// being initialized. Also if the conversion fails we potentially end up
// having the old devmode in the registry. We could null out the devmode
// but is it better to have a bad old devmode in the registry rather than a null
// devmode. A null devmode is more dangerous because an application may
// get really confused with a null devmode rather than a bad devmode
// which the driver will eventually fix, because they have to handle foreign
// devmodes any way.
//
EnterSplSem();
//
// Now convert the devmode to the driver specific devmode.
//
pDevMode = ConvertDevModeToSpecifiedVersion(pIniPrinter,
pIniPrinter->pDevMode,
NULL,
NULL,
CURRENT_VERSION);
//
// If a new devmode was returned then release the current printer's
// devmode and save the new devmode.
//
if (pDevMode) {
FreeSplMem(pIniPrinter->pDevMode);
pIniPrinter->pDevMode = pDevMode;
pIniPrinter->cbDevMode = pDevMode->dmSize + pDevMode->dmDriverExtra;
}
//
// Write the newly converted devmode to the registry again.
//
UpdatePrinterIni( pIniPrinter, UPDATE_CHANGEID );
LeaveSplSem();
}
//
// If the printer attributes changed, call the driver with the two
// different sets of attributes, this is to allow the fax driver to
// start up the fax service when a printer gets shared out.
//
if (dwPrinterVector & BIT(I_PRINTER_ATTRIBUTES)) {
PRINTER_EVENT_ATTRIBUTES_INFO AttributesInfo = {
sizeof(PRINTER_EVENT_ATTRIBUTES_INFO),
OldAttributes,
pIniPrinter->Attributes
};
PrinterDriverEvent(pIniPrinter, PRINTER_EVENT_ATTRIBUTES_CHANGED, (LPARAM)&AttributesInfo);
}
EnterSplSem();
SplInSem();
DECPRINTERREF(pIniPrinter);
}
// Don't update if this is from cache
if (!bDataChanged || ((Level == 2 || Level == 5) && !dwPrinterVector) ||
(pIniPrinter->pIniSpooler->SpoolerFlags & SPL_TYPE_CACHE)) {
bUpdateDsSpoolerKey = FALSE;
} else if (bUpdateDsSpoolerKey) {
if (Level != 7)
{
//
// Update unly values that changed.
//
UpdateDsSpoolerKey(hPrinter, dwPrinterVector);
} else if (pPrinterInfo7->dwAction != DSPRINT_UNPUBLISH)
{
//
// Update the all values in Registry for level 7.
//
UpdateDsSpoolerKey(hPrinter, 0xffffffff);
}
//
// Reset Driver DS Properties if driver changed
//
if (dwPrinterVector & BIT(I_PRINTER_DRIVER_NAME)) {
INCPRINTERREF(pIniPrinter);
LeaveSplSem();
//
// This calls SetPrinterDs with DSPRINT_UPDATE anyway.
//
RecreateDsKey(hPrinter, SPLDS_DRIVER_KEY);
EnterSplSem();
DECPRINTERREF(pIniPrinter);
} else if (Level != 7 || pPrinterInfo7->dwAction != DSPRINT_UNPUBLISH) {
//
// If the driver didn't change, query the driver again for capabilities.
//
UpdateDsDriverKey(hPrinter);
}
}
if (bUpdateDsSpoolerKey) {
if (pIniPrinter->DsKeyUpdateForeground || (Level == 7 && pPrinterInfo7->dwAction == DSPRINT_UNPUBLISH)) {
if (Level == 7) {
if ((dwResult = SetPrinterDs(hPrinter, pPrinterInfo7->dwAction, FALSE)) != ERROR_SUCCESS) {
SetLastError(dwResult);
bReturn = FALSE;
}
} else {
//
// Update only, in the background thread.
//
SetPrinterDs(hPrinter, DSPRINT_UPDATE, FALSE);
}
}
}
LeaveSplSem();
SplOutSem();
if ( pDevMode && pDevMode != pPrinterInfo2->pDevMode )
FreeSplMem(pDevMode);
if ( pszOldPrinterName ) {
FreeSplStr(pszOldPrinterName);
}
FreeSplStr(pszNewPrinterName);
return bReturn;
}
PRINTER_SECURITY_STATUS
SetPrinterSecurity(
SECURITY_INFORMATION SecurityInformation,
PINIPRINTER pIniPrinter,
PSECURITY_DESCRIPTOR pSecurityDescriptor)
{
DWORD dwSize;
if (!pSecurityDescriptor)
return SECURITY_FAIL;
if (pIniPrinter->pSecurityDescriptor) {
dwSize = GetSecurityDescriptorLength(pIniPrinter->pSecurityDescriptor);
if (dwSize == GetSecurityDescriptorLength(pSecurityDescriptor)) {
if (!memcmp(pSecurityDescriptor,
pIniPrinter->pSecurityDescriptor,
dwSize)) {
return SECURITY_NOCHANGE;
}
}
}
if( !SetPrinterSecurityDescriptor( SecurityInformation,
pSecurityDescriptor,
&pIniPrinter->pSecurityDescriptor ) ) {
DBGMSG(DBG_WARNING, ("SetPrinterSecurityDescriptor failed. Error = %d\n",
GetLastError()));
return SECURITY_FAIL;
}
UpdatePrinterIni(pIniPrinter, UPDATE_CHANGEID);
return SECURITY_SUCCESS;
}
VOID
RegClearKey(
HKEY hKey,
PINISPOOLER pIniSpooler
)
{
DWORD dwError;
WCHAR szValue[4*MAX_PATH];
DWORD cchValue;
while (TRUE) {
cchValue = COUNTOF(szValue);
dwError = SplRegEnumValue( hKey,
0,
szValue,
&cchValue,
NULL,
NULL,
NULL,
pIniSpooler );
if( dwError != ERROR_SUCCESS ){
if( dwError != ERROR_NO_MORE_ITEMS ){
DBGMSG( DBG_ERROR, ( "RegClearKey: Failed %d\n", dwError ));
}
break;
}
dwError = SplRegDeleteValue( hKey, szValue, pIniSpooler );
if( dwError != ERROR_SUCCESS ){
DBGMSG( DBG_ERROR, ( "RegDeleteValue: %s Failed %d\n",
szValue, dwError ));
break;
}
}
}
BOOL
ChangePrinterAttributes(
DWORD dNewAttributes,
DWORD dOldAttributes,
PINIPRINTER pIniPrinter,
PINISPOOLER pIniSpooler,
LPWSTR pszNewShareName,
BOOL bShareRecreate,
BOOL bShareUpdate
)
/*++
Routine Description:
Changes printer attributes by validating sharing information.
Already the validated attributes are set, we want to validate
by changing the share information
Arguments:
dNewAttributes - New attributes specified on SetPrinter call
dOldAttributes - pIniPrinter->Attributes before the call
pIniPrinter - of the printer we are changing attributes
pIniSpooler - Spooler that owns printer
pszNewShareName - the share name that will be set if SetPrinter succeeds
bShareRecreate - Share must be recreated because the printer or share
name changed.
bShareUpdate - Share just needs to be updated, since comment / SD changed.
Return Value:
DWORD TRUE on success, FALSE else.
History:
MuhuntS (Muhunthan Sivapragasam) July 95
--*/
{
BOOL Shared, bReturn = TRUE;
//
// We are going to have to be able to restore the attributes if the share
// modification fails. We need to set the current attributes now because
// the NetSharexxx is going to call OpenPrinter, and possibly an AddJob
// which needs the correct Attributes.
//
if (dNewAttributes & PRINTER_ATTRIBUTE_SHARED) {
if (!(dOldAttributes & PRINTER_ATTRIBUTE_SHARED)) {
pIniPrinter->Attributes |= PRINTER_ATTRIBUTE_SHARED;
Shared = ShareThisPrinter( pIniPrinter, pszNewShareName, TRUE );
if ( !Shared ) {
pIniPrinter->Attributes = dOldAttributes;
bReturn = FALSE;
}
} else {
//
// We are shared, and so is the old one. If share name changed
// we have to remove old share and reshare.
//
if ( bShareRecreate ) {
if (ShareThisPrinter(pIniPrinter,
pIniPrinter->pShareName,
FALSE)) {
#if DBG
WCHAR pwszError[256];
wsprintf(pwszError,
L"Error %d, removing share",
GetLastError());
//
// Error: the printer shouldn't be shared at this
// point.
//
INCPRINTERREF(pIniPrinter);
SplLogEvent(pIniSpooler,
LOG_ERROR,
MSG_SHARE_FAILED,
TRUE,
L"SetLocalPrinter ShareThisPrinter FALSE",
pIniPrinter->pName,
pIniPrinter->pShareName,
pwszError,
NULL);
DECPRINTERREF(pIniPrinter);
#endif
bReturn = FALSE;
} else if (!ShareThisPrinter(pIniPrinter,
pszNewShareName,
TRUE)) {
#if DBG
WCHAR pwszError[256];
wsprintf(pwszError,
L"Error %d, adding share",
GetLastError());
//
// Error: the printer shouldn't be shared at this
// point.
//
INCPRINTERREF(pIniPrinter);
SplLogEvent(pIniSpooler,
LOG_ERROR,
MSG_SHARE_FAILED,
TRUE,
L"SetLocalPrinter ShareThisPrinter TRUE",
pIniPrinter->pName,
pIniPrinter->pShareName,
pwszError,
NULL);
DECPRINTERREF(pIniPrinter);
#endif
pIniPrinter->Attributes &= ~PRINTER_ATTRIBUTE_SHARED;
pIniPrinter->Status |= PRINTER_WAS_SHARED;
bReturn = FALSE;
}
} else if ( bShareUpdate ) {
//
// If comment/description changed then we just do a NetShareSet
//
bReturn = SetPrinterShareInfo(pIniPrinter);
}
}
} else if (dOldAttributes & PRINTER_ATTRIBUTE_SHARED) {
Shared = ShareThisPrinter(pIniPrinter, pIniPrinter->pShareName, FALSE);
if (!Shared) {
pIniPrinter->Attributes &= ~PRINTER_ATTRIBUTE_SHARED;
pIniPrinter->Status |= PRINTER_WAS_SHARED;
CreateServerThread();
} else {
pIniPrinter->Attributes = dOldAttributes;
bReturn = FALSE;
}
}
if (((dOldAttributes & PRINTER_ATTRIBUTE_WORK_OFFLINE) &&
!(dNewAttributes & PRINTER_ATTRIBUTE_WORK_OFFLINE) ) ||
(!(dOldAttributes & PRINTER_ATTRIBUTE_WORK_OFFLINE) &&
(dNewAttributes & PRINTER_ATTRIBUTE_WORK_OFFLINE) ) ) {
WritePrinterOnlineStatusInCurrentConfig(pIniPrinter);
}
return bReturn;
}
Reference in a new issue Copy permalink