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

1887 lines
53 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990 - 1996 Microsoft Corporation
Module Name:
port.c
Abstract:
This module contains functions to control port threads
PrintDocumentThruPrintProcessor
CreatePortThread
DestroyPortThread
PortThread
Author:
Dave Snipp (DaveSn) 15-Mar-1991
Revision History:
KrishnaG 3-Feb-1991 - moved all monitor based functions to monitor.c
Matthew Felton (mattfe) Feb 1994 Added OpenMonitorPort CloseMonitorPort
--*/
#include <precomp.h>
#pragma hdrstop
#include "clusspl.h"
#include "filepool.hxx"
WCHAR *szFilePort = L"FILE:";
VOID
PrintDocumentThruPrintProcessor(
PINIPORT pIniPort,
PPRINTPROCESSOROPENDATA pOpenData
);
// ShutdownPorts
//
// Called when the DLL_PROCESS_DETATCH is called
// Close all portthreads
// Close all monitorports
VOID
ShutdownPorts(
PINISPOOLER pIniSpooler
)
{
PINIPORT pIniPort;
if (!pIniSpooler || (pIniSpooler == INVALID_HANDLE_VALUE))
{
return;
}
EnterSplSem();
SplInSem();
pIniPort = pIniSpooler->pIniPort;
while(pIniPort) {
DestroyPortThread(pIniPort, TRUE);
//
// Don't close monitor port since DLL_ATTACH may have been called
//
// CloseMonitorPort(pIniPort);
RemoveDeviceName(pIniPort);
pIniPort = pIniPort->pNext;
}
LeaveSplSem();
return;
}
BOOL
OpenMonitorPort(
PINIPORT pIniPort,
PINIMONITOR *ppIniLangMonitor,
LPWSTR pszPrinterName,
BOOL bWaitForEvent
)
{
BOOL bRet = TRUE;
SplInSem();
SPLASSERT (pIniPort != NULL || pIniPort->signature == IPO_SIGNATURE);
//
// If going to file or no monitor associated do not have to open
//
if ( (pIniPort->Status & PP_FILE) || !(pIniPort->Status & PP_MONITOR) ) {
return TRUE;
}
//
// If a LM is passed and it does not have an OpenPortEx can't use it
//
if ( *ppIniLangMonitor && !(*ppIniLangMonitor)->Monitor2.pfnOpenPortEx )
*ppIniLangMonitor = NULL;
//
// The port is already open by the correct monitor?
//
if ( *ppIniLangMonitor == pIniPort->pIniLangMonitor && pIniPort->hPort )
return TRUE;
INCPORTREF(pIniPort);
LeaveSplSem();
SplOutSem();
if ( bWaitForEvent &&
WAIT_OBJECT_0 != WaitForSingleObject(pIniPort->hWaitToOpenOrClose,
INFINITE) ) {
DBGMSG(DBG_ERROR,
("OpenMonitorPort: WaitForSingleObject failed with error %d\n",
GetLastError()));
EnterSplSem();
DECPORTREF(pIniPort);
return FALSE;
}
EnterSplSem();
if ( pIniPort->hPort ) {
//
// If the port is already open by the correct monitor return it
//
if ( *ppIniLangMonitor == pIniPort->pIniLangMonitor )
goto Cleanup;
if ( !CloseMonitorPort(pIniPort, FALSE) ) {
DBGMSG(DBG_WARNING,
("CloseMonitorPort failed for %ws -- LastError%d\n",
pIniPort->pName, GetLastError()));
bRet = FALSE;
goto Cleanup;
}
}
SPLASSERT(!pIniPort->hPort);
LeaveSplSem();
SplOutSem();
DBGMSG(DBG_TRACE,
("OpenPort port %ws (IniPort : %x)\n", pIniPort->pName, pIniPort));
//
// If we have a language monitor, then use it. Note that if it's
// downlevel and we have an uplevel port monitor, we can't use
// it because we can't pass in the new function vector.
//
if ( *ppIniLangMonitor ) {
SPLASSERT(pIniPort->pIniMonitor);
if( !(*ppIniLangMonitor)->bUplevel ){
LPWSTR pszPort = pIniPort->pName;
WCHAR szPortNew[MAX_PATH];
if( pIniPort->pIniMonitor->bUplevel ){
//
// Downlevel port monitor; create hack string.
//
DBGMSG( DBG_WARN,
( "Downlevel LM with uplevel PM %ws %ws\n",
(*ppIniLangMonitor)->pName,
pIniPort->pIniMonitor->pName ));
if( !CreateDlName( pIniPort->pName,
pIniPort->pIniMonitor,
szPortNew )){
goto SkipLanguageMonitor;
}
//
// We've created a new port string that has the
// pIniMonitor encoded.
//
pszPort = szPortNew;
}
//
// Downlevel language monitor and port monitor.
//
bRet = (*(*ppIniLangMonitor)->Monitor.pfnOpenPortEx)(
pszPort,
pszPrinterName,
&pIniPort->hPort,
&pIniPort->pIniMonitor->Monitor );
} else {
//
// Both uplevel lang monitor. Either up or downlevel port.
//
bRet = (*(*ppIniLangMonitor)->Monitor2.pfnOpenPortEx)(
(*ppIniLangMonitor)->hMonitor,
pIniPort->pIniMonitor->hMonitor,
pIniPort->pName,
pszPrinterName,
&pIniPort->hPort,
&pIniPort->pIniMonitor->Monitor2 );
}
} else {
SkipLanguageMonitor:
*ppIniLangMonitor = NULL;
bRet = (*pIniPort->pIniMonitor->Monitor2.pfnOpenPort)(
pIniPort->pIniMonitor->hMonitor,
pIniPort->pName,
&pIniPort->hPort );
}
EnterSplSem();
if ( bRet && pIniPort->hPort ) {
if ( *ppIniLangMonitor )
pIniPort->pIniLangMonitor = *ppIniLangMonitor;
DBGMSG(DBG_TRACE, ("OpenPort success for %ws\n", pIniPort->pName));
DBGMSG( DBG_WARN,
( "OpenMonitorPort: IncSpoolerRef %x\n",
pIniPort->pIniSpooler ));
INCSPOOLERREF( pIniPort->pIniSpooler );
} else {
if ( bRet || pIniPort->hPort )
DBGMSG(DBG_WARNING,
("OpenPort: unexpected return %d with hPort %x\n",
bRet, pIniPort->hPort));
bRet = FALSE;
pIniPort->hPort = NULL;
DBGMSG(DBG_WARNING, ("OpenPort failed %ws error %d\n",
pIniPort->pName, GetLastError()));
}
Cleanup:
SplInSem();
if ( bWaitForEvent)
SetEvent(pIniPort->hWaitToOpenOrClose);
if ( !bRet )
DECPORTREF(pIniPort);
return bRet;
}
BOOL
CloseMonitorPort(
PINIPORT pIniPort,
BOOL bWaitForEvent
)
{
BOOL bRet = TRUE;
PINIMONITOR pIniMonitor;
SPLASSERT ( pIniPort != NULL ||
pIniPort->signature == IPO_SIGNATURE );
INCPORTREF(pIniPort);
LeaveSplSem();
SplOutSem();
if ( bWaitForEvent &&
WAIT_OBJECT_0 != WaitForSingleObject(pIniPort->hWaitToOpenOrClose,
INFINITE) ) {
DBGMSG( DBG_ERROR,
( "CloseMonitorPort: WaitForSingleObject failed with error %d\n",
GetLastError()));
EnterSplSem();
DECPORTREF(pIniPort);
return FALSE;
}
EnterSplSem();
DECPORTREF(pIniPort);
//
// If going to file hPort should be NULL
//
SPLASSERT(!(pIniPort->Status & PP_FILE) || !pIniPort->hPort);
if ( !pIniPort->hPort ) {
goto Cleanup;
}
if ( pIniPort->pIniLangMonitor )
pIniMonitor = pIniPort->pIniLangMonitor;
else
pIniMonitor = pIniPort->pIniMonitor;
//
// Only Close the Port Once
//
SPLASSERT ( pIniMonitor && pIniPort->cRef >= 1 );
INCPORTREF(pIniPort);
LeaveSplSem();
SplOutSem();
DBGMSG(DBG_TRACE, ("Close Port %ws -- %d\n", pIniPort->pName, pIniPort->cRef));
bRet = (*pIniMonitor->Monitor2.pfnClosePort)( pIniPort->hPort );
EnterSplSem();
DECPORTREF(pIniPort);
DBGMSG( DBG_WARN,
( "CloseMonitorPort: DecSpoolerRef %x\n",
pIniPort->pIniSpooler ));
DECSPOOLERREF( pIniPort->pIniSpooler );
if ( bRet ) {
pIniPort->hPort = NULL;
DECPORTREF(pIniPort);
if ( pIniMonitor == pIniPort->pIniLangMonitor )
pIniPort->pIniLangMonitor = NULL;
} else {
//
// When net stop spooler is done the monitor could have been
// called to shutdown (hpmon does it)
//
DBGMSG(DBG_WARNING,
("ClosePort failed for %ws -- LastError%d\n", pIniPort->pName, GetLastError()));
}
Cleanup:
SplInSem();
if ( bWaitForEvent )
SetEvent(pIniPort->hWaitToOpenOrClose);
return bRet;
}
BOOL
CreatePortThread(
PINIPORT pIniPort
)
{
DWORD ThreadId;
BOOL bReturnValue = FALSE;
SplInSem();
SPLASSERT (( pIniPort != NULL) &&
( pIniPort->signature == IPO_SIGNATURE));
// Don't bother creating a thread for ports that don't have a monitor:
if (!(pIniPort->Status & PP_MONITOR))
return TRUE;
if ( pIniPort->Status & PP_THREADRUNNING)
return TRUE;
try {
pIniPort->Semaphore = CreateEvent( NULL, FALSE, FALSE, NULL );
if ( pIniPort->Semaphore == NULL )
leave;
pIniPort->Ready = CreateEvent( NULL, FALSE, FALSE, NULL );
if ( pIniPort->Ready == NULL ) {
leave;
}
pIniPort->Status |= PP_RUNTHREAD;
pIniPort->hPortThread = CreateThread(NULL, INITIAL_STACK_COMMIT,
(LPTHREAD_START_ROUTINE)PortThread,
pIniPort,
0, &ThreadId);
if( pIniPort->hPortThread == NULL ) {
pIniPort->Status &= ~PP_RUNTHREAD;
leave;
}
if ( !SetThreadPriority(pIniPort->hPortThread, dwPortThreadPriority) ) {
DBGMSG(DBG_WARNING, ("CreatePortThread - Setting thread priority failed %d\n", GetLastError()));
}
LeaveSplSem();
// Make CreatePortThread Synchronous
WaitForSingleObject( pIniPort->Ready, INFINITE );
EnterSplSem();
SplInSem();
pIniPort->Status |= PP_THREADRUNNING;
bReturnValue = TRUE;
} finally {
if ( !bReturnValue ) {
if ( pIniPort->Semaphore != NULL ) {
CloseHandle( pIniPort->Semaphore );
pIniPort->Semaphore = NULL;
}
if ( pIniPort->Ready != NULL ) {
CloseHandle( pIniPort->Ready );
pIniPort->Ready = NULL;
}
}
}
return bReturnValue;
}
BOOL
DestroyPortThread(
PINIPORT pIniPort,
BOOL bShutdown
)
{
SplInSem();
// PortThread checks for PP_RUNTHREAD
// and exits if it is not set.
pIniPort->Status &= ~PP_RUNTHREAD;
if (pIniPort->Semaphore && !SetEvent(pIniPort->Semaphore)) {
return FALSE;
}
if( pIniPort->hPortThread != NULL) {
INCPORTREF(pIniPort);
LeaveSplSem();
if ( WaitForSingleObject( pIniPort->hPortThread, INFINITE) == WAIT_FAILED ) {
EnterSplSem();
DECPORTREF(pIniPort);
return FALSE;
}
EnterSplSem();
DECPORTREF(pIniPort);
}
if (pIniPort->hPortThread != NULL) {
CloseHandle(pIniPort->hPortThread);
pIniPort->hPortThread = NULL;
}
//
// The port may have been changed while the printer was printing.
// Thus when the port thread finally goes away now is the time to
// close the monitor. However we can't call the monitor during shutdown
// since DLL_DETACH may already have been issued to the monitor dll
//
if ( !pIniPort->cPrinters && !bShutdown)
CloseMonitorPort(pIniPort, TRUE);
return TRUE;
}
VOID
RemoveIniPortFromIniJob(
PINIJOB pIniJob,
PINIPORT pIniPort
)
{
PINISPOOLER pIniSpooler = pIniJob->pIniPrinter->pIniSpooler;
NOTIFYVECTOR NotifyVector;
SplInSem();
//
// Increment the refcount since deleting the job may delete the
// pIniJob, which would delete the pIniSpooler.
//
INCSPOOLERREF( pIniSpooler );
SPLASSERT(pIniJob &&
pIniJob->signature == IJ_SIGNATURE &&
pIniJob->pIniPort);
SPLASSERT( pIniJob->pIniPort == pIniPort );
pIniPort->cJobs--;
pIniJob->pIniPort = NULL;
SPLASSERT( pIniJob->Status & JOB_DESPOOLING );
// Chained Jobs
// For a Chained Master Job do not remove JOB_DESPOOLING
// since we don't want the scheduler to reschedule this
// to another port
if ( pIniPort->pIniJob != pIniJob ) {
// Normal Path
// When NOT a chained job.
pIniJob->Status &= ~JOB_DESPOOLING;
COPYNV(NotifyVector, NVJobStatus);
NotifyVector[JOB_NOTIFY_TYPE] |= BIT(I_JOB_PORT_NAME) |
BIT(I_JOB_PAGES_PRINTED) |
BIT(I_JOB_BYTES_PRINTED);
SetPrinterChange( pIniJob->pIniPrinter,
pIniJob,
NotifyVector,
PRINTER_CHANGE_SET_JOB,
pIniSpooler);
}
// RestartJob() doesn't remove JOB_PRINTED or JOB_BLOCKED_DEVQ
// or JOB_DESPOOLING or JOB_COMPLETE if the despooling bit is on
// this is to avoid problems where we have completed "Printing"
// the job via a print processor and now the port thread is logging
// the job printed and sending an alert message.
if ( pIniJob->Status & JOB_RESTART )
pIniJob->Status &= ~( JOB_PRINTED | JOB_BLOCKED_DEVQ | JOB_COMPLETE);
DeleteJobCheck(pIniJob);
//
// pIniJob may be gone at this point.
//
//
// If we're at zero then set hEventNoPrintingJobs if it exists.
//
if( !pIniSpooler->cFullPrintingJobs &&
pIniSpooler->hEventNoPrintingJobs ){
SetEvent( pIniSpooler->hEventNoPrintingJobs );
}
//
// Matches INCSPOOLERREF at beginning of this function.
//
DECSPOOLERREF( pIniSpooler );
}
DWORD
PortThread(
PINIPORT pIniPort
)
{
DWORD rc;
PRINTPROCESSOROPENDATA OpenData;
PINIJOB pIniJob;
DWORD NextJobId = 0;
DWORD Position;
DWORD dwDevQueryPrint = 0;
DWORD dwJobDirect = 0;
DWORD dwDevQueryPrintStatus = 0;
WCHAR ErrorString[MAX_PATH];
BOOL bRawDatatype;
//
// Power management. While we have port threads, we don't want the
// system to go to sleep. Note that if we have a hung job, we will
// not go to sleep.
//
SetThreadExecutionState( ES_SYSTEM_REQUIRED | ES_CONTINUOUS );
EnterSplSem();
INCSPOOLERREF( pIniPort->pIniSpooler );
SPLASSERT( pIniPort->signature == IPO_SIGNATURE );
if ( pIniPort->Status & PP_MONITOR ) {
if ( pIniPort->Status & PP_FILE ) {
rc = (*pIniPort->pIniMonitor->Monitor2.pfnOpenPort)(
pIniPort->pIniMonitor->hMonitor,
L"FILE:",
&pIniPort->hPort );
DBGMSG(DBG_TRACE, (" After opening the file pseudo monitor port %d\n", rc));
INCPORTREF( pIniPort );
INCSPOOLERREF( pIniPort->pIniSpooler );
} else {
// LPRMON returns NULL ( fails and expect us to open it again
// inside PrintingDirectlyToPort, so for now remove this assert
// since OpenMonitorPort was added to PrintingDirectlyToPort
// SPLASSERT( pIniPort->hPort != NULL );
}
}
while (TRUE) {
SplInSem();
SPLASSERT( pIniPort->signature == IPO_SIGNATURE );
DBGMSG(DBG_TRACE, ("Re-entering the Port Loop -- will blow away any Current Job\n"));
pIniPort->Status |= PP_WAITING;
SetEvent( pIniPort->Ready );
CHECK_SCHEDULER();
DBGMSG( DBG_PORT, ("Port %ws: WaitForSingleObject( %x )\n",
pIniPort->pName, pIniPort->Semaphore ) );
LeaveSplSem();
SplOutSem();
//
// Any modification to the pIniPort structure by other threads
// can be done only at this point.
//
rc = WaitForSingleObject( pIniPort->Semaphore, INFINITE );
EnterSplSem();
SplInSem();
SPLASSERT( pIniPort->signature == IPO_SIGNATURE );
DBGMSG( DBG_PORT, ("Port %ws: WaitForSingleObject( %x ) returned\n",
pIniPort->pName, pIniPort->Semaphore));
if ( !( pIniPort->Status & PP_RUNTHREAD ) ) {
DBGMSG(DBG_TRACE, ("Thread for Port %ws Closing Down\n", pIniPort->pName));
pIniPort->Status &= ~(PP_THREADRUNNING | PP_WAITING);
CloseHandle( pIniPort->Semaphore );
pIniPort->Semaphore = NULL;
CloseHandle( pIniPort->Ready );
pIniPort->Ready = NULL;
if ( pIniPort->Status & PP_FILE ) {
rc = (*pIniPort->pIniMonitor->Monitor2.pfnClosePort)(
pIniPort->hPort );
pIniPort->hPort = NULL;
DBGMSG(DBG_TRACE, (" After closing the file pseudo monitor port\n %d\n"));
DBGMSG( DBG_WARN,
( "PortThread: DecSpoolerRef %x\n",
pIniPort->pIniSpooler ));
DECSPOOLERREF( pIniPort->pIniSpooler );
DECPORTREF( pIniPort );
}
DECSPOOLERREF( pIniPort->pIniSpooler );
LeaveSplSem();
SplOutSem();
//
// Power management. We are done.
//
SetThreadExecutionState(ES_CONTINUOUS);
ExitThread (FALSE);
}
ResetEvent( pIniPort->Ready );
//
// Bad assumption -- that at this point we definitely have a Job
//
if ( ( pIniJob = pIniPort->pIniJob ) &&
pIniPort->pIniJob->pIniPrintProc ) {
SPLASSERT( pIniJob->signature == IJ_SIGNATURE );
SPLASSERT( pIniJob->Status & JOB_DESPOOLING );
//
// WMI Trace Events
//
INCJOBREF(pIniJob);
LeaveSplSem();
LogWmiTraceEvent(pIniJob->JobId, EVENT_TRACE_TYPE_SPL_PRINTJOB, NULL);
EnterSplSem();
DECJOBREF(pIniJob);
DBGMSG(DBG_PORT, ("Port %ws: received job\n", pIniPort->pName));
SPLASSERT(pIniJob->cRef != 0);
DBGMSG(DBG_PORT, ("PortThread(1):cRef = %d\n", pIniJob->cRef));
//
// !! HACK !!
//
// If the datatype is 1.008 but the print proc doesn't support it,
// then change it to 1.003 just for the print proc.
//
// This happens for the lexmark print processor. They support
// NT EMF 1.003, but not 1.008. They just call GdiPlayEMF, so
// they really can support 1.008 since they don't look at the
// data. However, since they don't advertise this, they can't
// print.
//
// We work around this by switching the datatype back to 1.003.
//
if (!_wcsicmp(pIniJob->pDatatype, gszNT5EMF) &&
!CheckDataTypes(pIniJob->pIniPrintProc, gszNT5EMF))
{
OpenData.pDatatype = AllocSplStr(gszNT4EMF);
}
else
{
OpenData.pDatatype = AllocSplStr(pIniJob->pDatatype);
}
OpenData.pDevMode = AllocDevMode(pIniJob->pDevMode);
OpenData.pParameters = AllocSplStr(pIniJob->pParameters);
OpenData.JobId = pIniJob->JobId;
OpenData.pDocumentName = AllocSplStr(pIniJob->pDocument);
OpenData.pOutputFile = AllocSplStr(pIniJob->pOutputFile);
//
// Check if we have RAW Printing
//
bRawDatatype = ValidRawDatatype(pIniJob->pDatatype);
OpenData.pPrinterName = pszGetPrinterName(
pIniJob->pIniPrinter,
pIniPort->pIniSpooler != pLocalIniSpooler,
NULL );
dwDevQueryPrint = pIniJob->pIniPrinter->Attributes & PRINTER_ATTRIBUTE_ENABLE_DEVQ;
if ((pIniJob->Status & JOB_DIRECT) ||
((pIniJob->Status & JOB_DOWNLEVEL) &&
ValidRawDatatype(pIniJob->pDatatype))) {
dwJobDirect = 1;
}
// If we are restarting to print a document
// clear its counters and remove the restart flag
if ( pIniJob->Status & JOB_RESTART ) {
pIniJob->Status &= ~(JOB_RESTART | JOB_INTERRUPTED);
pIniJob->cbPrinted = 0;
pIniJob->cPagesPrinted = 0;
//
// Only use dwReboots if not RAW.
//
if (!bRawDatatype)
{
//
// Solves bug 229913;
// Decrement number of reboots if job is restarted.
// ReadShadowJob checks the number of reboots and delete the job if too many
//
if( pIniJob->dwReboots ){
pIniJob->dwReboots--;
}
}
}
//
// Job is being restarted, so clear all errors?
//
ClearJobError( pIniJob );
pIniJob->dwAlert = 0;
//
// Only use dwReboots if not RAW.
//
if (!bRawDatatype)
{
pIniJob->dwReboots++;
WriteShadowJob(pIniJob, TRUE);
}
LeaveSplSem();
SplOutSem();
if ( ( dwDevQueryPrintStatus = CallDevQueryPrint(OpenData.pPrinterName,
OpenData.pDevMode,
ErrorString,
MAX_PATH,
dwDevQueryPrint,
dwJobDirect) ) ) {
PrintDocumentThruPrintProcessor( pIniPort, &OpenData );
}
SplOutSem();
EnterSplSem();
// Decrement number of EMF jobs rendering and update available memory
RemoveFromJobList(pIniJob, JOB_SCHEDULE_LIST);
SPLASSERT( pIniPort->signature == IPO_SIGNATURE );
SPLASSERT( pIniPort->pIniJob != NULL );
SPLASSERT( pIniJob == pIniPort->pIniJob);
SPLASSERT( pIniJob->signature == IJ_SIGNATURE );
//
// Chained Jobs
// If we have a chain of jobs, we now need to find the next job in the chain
// and make sure its printed to the same port.
//
if (!( pIniJob->Status & ( JOB_PENDING_DELETION | JOB_RESTART )) &&
( pIniJob->pCurrentIniJob != NULL ) &&
( pIniJob->pCurrentIniJob->NextJobId != 0 )) {
// Follow the Chained Job to the Next Job
// Look at scheduler to see where it picks up this job and assigns it back
// to this port thread.
pIniJob->pCurrentIniJob = FindJob( pIniJob->pIniPrinter, pIniJob->pCurrentIniJob->NextJobId, &Position );
if ( pIniJob->pCurrentIniJob == NULL ) {
pIniPort->pIniJob = NULL;
DBGMSG( DBG_WARNING, ("PortThread didn't find NextJob\n"));
} else {
SPLASSERT( pIniJob->pCurrentIniJob->signature == IJ_SIGNATURE );
DBGMSG( DBG_WARNING, ("PortThread completed JobId %d, NextJobId %d\n", pIniJob->JobId,
pIniJob->pCurrentIniJob->JobId ));
}
} else {
//
// Nothing More in Chain
//
pIniJob->pCurrentIniJob = NULL;
pIniPort->pIniJob = NULL;
}
if( !pIniJob->pCurrentIniJob ){
//
// Decrement the pIniSpooler job count. We only decrement
// at the end of a chain since we don't increment in the
// middle of a chained job.
//
--pIniJob->pIniPrinter->pIniSpooler->cFullPrintingJobs;
}
DBGMSG(DBG_PORT, ("PortThread job has now printed - status:0x%0x\n", pIniJob->Status));
FreeDevMode(OpenData.pDevMode);
FreeSplStr(OpenData.pDatatype);
FreeSplStr(OpenData.pParameters);
FreeSplStr(OpenData.pDocumentName);
FreeSplStr(OpenData.pOutputFile);
FreeSplStr(OpenData.pPrinterName);
// SPLASSERT( pIniJob->Time != 0 );
pIniJob->Time = GetTickCount() - pIniJob->Time;
if (!dwDevQueryPrintStatus) {
DBGMSG(DBG_PORT, ("PortThread Job has not printed because of DevQueryPrint failed\n"));
pIniJob->Status |= JOB_BLOCKED_DEVQ;
SPLASSERT( !(pIniJob->Status & JOB_PRINTED));
pIniJob->Time = 0;
FreeSplStr( pIniJob->pStatus );
pIniJob->pStatus = AllocSplStr(ErrorString);
SetPrinterChange(pIniJob->pIniPrinter,
pIniJob,
NVJobStatusAndString,
PRINTER_CHANGE_SET_JOB,
pIniJob->pIniPrinter->pIniSpooler );
} else if ( !( pIniJob->Status & JOB_TIMEOUT ) ) {
//
// Only Log the event and send a popup if the last in the chain
//
if ( !(pIniJob->Status & JOB_RESTART) &&
pIniJob->pCurrentIniJob == NULL ) {
//
// A job can be in JOB_COMPLETE state when it was sent ot printer
// but the last page isn't ejected yet. A job completely sent to printer
// can be either in JOB_COMPLETE or JOB_PRINTED state.
// Monitors that doesn't support TEOJ will set the job as JOB_PRINTED
// right after the job was sent to printer and we don't want to set it on
// JOB_COMPLETE.
// For BIDI Monitors we'll come down here possibly before
// the monitor sets the job as JOB_PRINTED. We set the job as JOB_COMPLETE
// so that the scheduler will ignore it.
//
if (!(pIniJob->Status & (JOB_ERROR | JOB_PAPEROUT | JOB_OFFLINE)) &&
!(pIniJob->Status & JOB_PRINTED))
{
if (pIniJob->cPages == 0 &&
(pIniJob->Size == 0 || pIniJob->dwValidSize == 0) &&
!(pIniJob->Status & JOB_TYPE_ADDJOB))
{
//
// Set empty document to Printed as the monitor won't do it.
// Make exception for job submitted with AddJob. The monitor
// is still in charge for doing it.
//
pIniJob->Status |= JOB_PRINTED;
}
else
{
pIniJob->Status |= JOB_COMPLETE;
}
}
// For Remote NT Jobs cPagesPrinted and cTotalPagesPrinted
// are NOT updated since we are getting RAW data. So we
// use the cPages field instead.
if (pIniJob->cPagesPrinted == 0) {
pIniJob->cPagesPrinted = pIniJob->cPages;
pIniJob->pIniPrinter->cTotalPagesPrinted += pIniJob->cPages;
}
INCJOBREF(pIniJob);
LeaveSplSem();
LogJobPrinted(pIniJob);
EnterSplSem();
DECJOBREF(pIniJob);
}
}
SplInSem();
DBGMSG(DBG_PORT, ("PortThread(2):cRef = %d\n", pIniJob->cRef));
// Hi End Print Shops like to keep around jobs after they have
// completed. They do this so they can print a proof it and then
// print it again for the final run. Spooling the job again may take
// several hours which they want to avoid.
// Even if KEEPPRINTEDJOBS is set they can still manually delete
// the job via printman.
if (( pIniJob->pIniPrinter->Attributes & PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS ) ||
( pIniJob->Status & JOB_TIMEOUT ) ) {
//
// WMI Trace Events.
//
// Treat a keep and restart as a delete and spool new job.
WMI_SPOOL_DATA WmiData;
DWORD CreateInfo;
if (GetFileCreationInfo(pIniJob->hFileItem, &CreateInfo) != S_OK) {
// Assume all file created.
CreateInfo = FP_ALL_FILES_CREATED;
}
SplWmiCopyEndJobData(&WmiData, pIniJob, CreateInfo);
pIniJob->Status &= ~JOB_PENDING_DELETION;
pIniJob->cbPrinted = 0;
//
// Set the job as JOB_COMPLETE if not already set as JOB_PRINTED
// by Monitor.
// Monitors that doesn't support TEOJ will set the job as JOB_PRINTED
// right after the job was sent to printer and we don't want to set it on
// JOB_COMPLETE.
// For BIDI Monitors we'll come down here possibly before
// the monitor sets the job as JOB_PRINTED. We set the job as JOB_COMPLETE
// so that the scheduler will ignore it.
//
if (!(pIniJob->Status & JOB_PRINTED)) {
pIniJob->Status |= JOB_COMPLETE;
}
//
// Only use dwReboots if not RAW.
//
if (!bRawDatatype)
{
--pIniJob->dwReboots;
}
//
// We need to update the shadow file regardless the job type.
// There is the job status that we need to update.
//
INCJOBREF(pIniJob);
//
// WriteShadowJob leaves the CS, So make sure that the ref on the
// pIniJob is kept high.
//
WriteShadowJob(pIniJob, TRUE);
LeaveSplSem();
//
// WMI Trace Events.
//
// The job is done. If it is restarted you get a new spool job event.
LogWmiTraceEvent(pIniJob->JobId, EVENT_TRACE_TYPE_SPL_DELETEJOB,
&WmiData);
EnterSplSem();
DECJOBREF(pIniJob);
SPLASSERT( pIniPort->signature == IPO_SIGNATURE );
SPLASSERT( pIniJob->signature == IJ_SIGNATURE );
}
SplInSem();
SPLASSERT( pIniJob->cRef != 0 );
DECJOBREF(pIniJob);
RemoveIniPortFromIniJob(pIniJob, pIniPort);
//
// N.B. The pIniJob may be gone at this point.
//
} else {
//
// !! VERIFY !!
//
SPLASSERT(pIniJob != NULL);
if (pIniJob != NULL) {
DBGMSG(DBG_PORT, ("Port %ws: deleting job\n", pIniPort->pName));
// SPLASSERT( pIniJob->Time != 0 );
pIniJob->Time = GetTickCount() - pIniJob->Time;
//pIniJob->Status |= JOB_PRINTED;
if ( pIniJob->hFileItem == INVALID_HANDLE_VALUE )
{
CloseHandle( pIniJob->hWriteFile );
}
pIniJob->hWriteFile = INVALID_HANDLE_VALUE;
DBGMSG(DBG_PORT, ("Port %ws - calling DeleteJob because PrintProcessor wasn't available\n"));
RemoveIniPortFromIniJob(pIniJob, pIniPort);
DeleteJob(pIniJob,BROADCAST);
//
// N.B. The pIniJob may be gone at this point.
//
}
}
//SetCurrentSid(NULL);
DBGMSG(DBG_PORT,("Returning back to pickup a new job or to delete the PortThread\n"));
}
SPLASSERT( FALSE );
return 0;
}
VOID
ReportPrintProcError(
IN PINISPOOLER pIniSpooler,
IN PINIJOB pIniJob,
IN DWORD Error
)
{
LPWSTR pszDescription = GetErrorString(Error);
WCHAR szError[40] = {0};
_snwprintf(szError, COUNTOF(szError), L"%u (0x%x)", Error, Error);
SetCurrentSid(pIniJob->hToken);
SplLogEvent(pIniJob->pIniPrinter->pIniSpooler,
LOG_ERROR,
MSG_PRINT_ON_PROC_FAILED,
FALSE,
pIniJob->pDocument,
pIniJob->pUser,
szError,
pszDescription ? pszDescription : L"",
NULL);
SetCurrentSid(NULL);
FreeSplStr(pszDescription);
}
VOID
PrintDocumentThruPrintProcessor(
PINIPORT pIniPort,
PPRINTPROCESSOROPENDATA pOpenData
)
/*++
Routine Description:
Print the document associated with pIniPort on the print
processor.
Status of pIniPort->Status = PP_RUNTHREAD
PP_THREADRUNNING
PP_MONITOR
~PP_WAITING
NOTE: If PrintProc->Open is called and succeeds, PrintProc->Close
must be called to cleanup.
Arguments:
Return Value:
--*/
{
PINIJOB pIniJob = pIniPort->pIniJob;
WCHAR szSpecialPortorPrinterName[MAX_UNC_PRINTER_NAME + MAX_PATH + PRINTER_NAME_SUFFIX_MAX];
BOOL bJobError = FALSE;
NOTIFYVECTOR NotifyVector;
LPTSTR pszModify;
UINT cchLen;
BOOL bFailJob = FALSE;
BOOL bRemoteGuest = FALSE;
BOOL bSpecialCaseDriver = FALSE;
DWORD Error;
//
// Check if printing principal is remote guest. Remote guest does not have enough
// permissions to print EMF. The EMF playback code in GDI32 fails for certain EMF records.
// Because of this, we create an impersonation token based on the process token.
//
if ((bSpecialCaseDriver = IsSpecialDriver(pIniJob->pIniDriver, pIniJob->pIniPrintProc, pIniJob->pIniPrinter->pIniSpooler)) ||
(Error = PrincipalIsRemoteGuest(pIniJob->hToken, &bRemoteGuest)) == ERROR_SUCCESS)
{
if (bRemoteGuest || bSpecialCaseDriver)
{
Error = ImpersonateSelf(SecurityImpersonation) ? ERROR_SUCCESS : GetLastError();
}
else
{
Error = SetCurrentSid(pIniJob->hToken) ? ERROR_SUCCESS : GetLastError();
}
}
if (Error != ERROR_SUCCESS)
{
ReportPrintProcError(pIniJob->pIniPrinter->pIniSpooler, pIniJob, Error);
bFailJob = TRUE;
goto Complete;
}
DBGMSG( DBG_TRACE, ("PrintDocumentThruPrintProcessor pIniPort %x pOpenData %x\n", pIniPort, pOpenData));
COPYNV(NotifyVector, NVJobStatus);
cchLen = lstrlen( pIniJob->pIniPrinter->pIniSpooler->pMachineName );
//
// Do a length check. PRINTER_NAME_SUFFIX_MAX holds the extra 4 separator
// characters and the NULL terminator.
//
if (lstrlen( pIniPort->pName ) +
lstrlen( pIniJob->pIniPrinter->pName ) +
cchLen > COUNTOF( szSpecialPortorPrinterName )) {
//
// We should log an event, but this is a very rare event, only
// in the print api tests.
//
bFailJob = TRUE;
goto Complete;
}
//
// For clustered spoolers, make sure it is fully qualified.
// pszModify points to the string immediately after the server
// name that can be modified.
//
// Always modify the string at pszModify, but pass in
// szSpecialPortorPrinterName.
//
lstrcpy( szSpecialPortorPrinterName,
pIniJob->pIniPrinter->pIniSpooler->pMachineName );
szSpecialPortorPrinterName[cchLen] = '\\';
pszModify = &szSpecialPortorPrinterName[cchLen+1];
//
// \\Server\
// ^---------------------- szSpecialPortorPrinterName
// ^------------- pszModify
//
// Append the rest of the string at pszModify:
//
// \\Server\PortName, Port
// \\Server\PrinterName, Job 33
//
//
// Now create the port name, so that we can do the
// secret open printer. the printer name will be
// "FILE:, Port" and this will open a PRINTER_HANDLE_PORT
// If we fail, then if the app thread may be waiting for
// the pIniJob->StartDocComplete to be set, which would
// ordinarily be done in the StartDocPrinter of the port.
// We will do this little courtesy,
//
wsprintf( pszModify, L"%ws, Port", pIniPort->pName );
DBGMSG( DBG_TRACE, ("PrintDocumentThruPrintProcessor Attempting PrintProcessor Open on %ws\n", szSpecialPortorPrinterName ));
if (!(pIniPort->hProc = (HANDLE)(*pIniJob->pIniPrintProc->Open)
(szSpecialPortorPrinterName, pOpenData))) {
DBGMSG( DBG_WARNING, ("PrintDocumentThruPrintProcessor Failed Open error %d\n", GetLastError() ));
bFailJob = TRUE;
goto Complete;
}
//
// For Jobs, turn this off even if it's not clustered.
//
if( !( pIniJob->pIniPrinter->pIniSpooler->SpoolerFlags & SPL_TYPE_CLUSTER )){
pszModify = szSpecialPortorPrinterName;
//
//
// ^---------------------- szSpecialPortorPrinterName
// ^---------------------- pszModify
//
// PortName, Port
// PrinterName, Job 33
//
}
EnterSplSem();
pIniJob->Status |= JOB_PRINTING;
pIniJob->Time = GetTickCount();
NotifyVector[JOB_NOTIFY_TYPE] |= BIT(I_JOB_PORT_NAME);
SetPrinterChange(pIniJob->pIniPrinter,
pIniJob,
NotifyVector,
PRINTER_CHANGE_SET_JOB,
pIniJob->pIniPrinter->pIniSpooler);
LeaveSplSem();
//
// Create Special Name "PrinterName, Job xxx"
//
wsprintf( pszModify,
L"%ws, Job %d",
pIniJob->pIniPrinter->pName,
pIniJob->JobId );
DBGMSG( DBG_TRACE, ("PrintDocumentThruPrintProcessor calling Print hProc %x file %ws\n",
pIniPort->hProc, szSpecialPortorPrinterName ));
if (!(*pIniJob->pIniPrintProc->Print)(pIniPort->hProc, szSpecialPortorPrinterName)) {
//
// The print function in the print processor sets the last error. For better understaning
// of the underlying problem, we log both the Win32 error code and the description of it.
//
Error = GetLastError();
ReportPrintProcError(pIniJob->pIniPrinter->pIniSpooler, pIniJob, Error);
DBGMSG( DBG_TRACE, ("PrintDocumentThruPrintProcessor Print hProc %x Error %d\n",
pIniPort->hProc, GetLastError() ));
EnterSplSem();
if ( pIniJob->StartDocComplete ) {
SetEvent( pIniJob->StartDocComplete );
}
bJobError = TRUE;
LeaveSplSem();
} else {
DBGMSG( DBG_TRACE, ("PrintDocumentThruPrintProcessor Print hProc %x %ws Success\n",
pIniPort->hProc, szSpecialPortorPrinterName ));
}
//
// Now close the print processor.
//
EnterSplSem();
SPLASSERT( pIniPort->hProc != NULL );
DBGMSG( DBG_TRACE, ("PrintDocumentThruPrintProcessor calling Close hProc %x\n", pIniPort->hProc ));
pIniJob->Status &= ~JOB_PRINTING;
LeaveSplSem();
//
// JOB_PP_CLOSE is used to prevent the print processor from recursively
// calling back into itself. This happens for some third party print processor.
// Race conditions don't apply for this flag since 2 threads don't access it
// simultaneously.
//
if (!(pIniJob->Status & JOB_PP_CLOSE))
{
EnterCriticalSection(&pIniJob->pIniPrintProc->CriticalSection);
pIniJob->Status |= JOB_PP_CLOSE;
if (!(*pIniJob->pIniPrintProc->Close)(pIniPort->hProc))
{
DBGMSG( DBG_WARNING, ("PrintDocumentThruPrintProcessor failed Close hProc %x Error %d\n",
pIniPort->hProc, GetLastError() ));
}
pIniPort->hProc = NULL;
pIniJob->Status &= ~JOB_PP_CLOSE;
LeaveCriticalSection(&pIniJob->pIniPrintProc->CriticalSection);
//
// WMI Trace Events
//
if (pIniJob->pDevMode)
{
WMI_SPOOL_DATA Data;
SplWmiCopyRenderedData(&Data, pIniJob->pDevMode);
LogWmiTraceEvent(pIniJob->JobId, EVENT_TRACE_TYPE_SPL_JOBRENDERED, &Data);
}
}
Complete:
EnterSplSem();
if (bFailJob) {
//
// App might be waiting for the StartDoc to Complete
//
if ( pIniJob->StartDocComplete ) {
SetEvent(pIniJob->StartDocComplete);
}
bJobError = TRUE;
}
//
// If the job had an error, mark it pending deletion. The port monitor
// may not do this if EndDocPort was never called.
//
if ( !(pIniJob->Status & JOB_RESTART) && bJobError ){
pIniJob->Status |= JOB_PENDING_DELETION;
// Release any thread waiting on LocalSetPort
SetPortErrorEvent(pIniJob->pIniPort);
// Release any thread waiting on SeekPrinter
SeekPrinterSetEvent(pIniJob, NULL, TRUE);
}
LeaveSplSem();
//
// RevertToSelf and SetCurrentSid have identical behavior. If one call ImpersonateSelf
// and the SetCurrentSid instead of RevertToSelf, that's still fine.
//
if (bRemoteGuest)
{
RevertToSelf();
}
else
{
SetCurrentSid(NULL);
}
}
VOID
UpdatePortStatusForAllPrinters(
PINIPORT pIniPort
)
/*++
Routine Description:
This routine is called when an IniPorts status changed so that we go
through each printer connected to the port and update their port status
Arguments:
pIniPort - Port whose status chanegd
Return Value:
Nothing
--*/
{
PINIPRINTER pIniPrinter;
PINIPORT pIniPrinterPort;
DWORD dwIndex1, dwIndex2, dwPortStatus, dwSeverity;
for ( dwIndex1 = 0 ; dwIndex1 < pIniPort->cPrinters ; ++dwIndex1 ) {
pIniPrinter = pIniPort->ppIniPrinter[dwIndex1];
dwSeverity = 0;
dwPortStatus = 0;
//
// Pick the most severe status associated with all ports
//
for ( dwIndex2 = 0 ; dwIndex2 < pIniPrinter->cPorts ; ++dwIndex2 ) {
pIniPrinterPort = pIniPrinter->ppIniPorts[dwIndex2];
if ( pIniPrinterPort->Status & PP_ERROR ) {
dwSeverity = PP_ERROR;
dwPortStatus = PortToPrinterStatus(pIniPrinterPort->PrinterStatus);
break; // no need to go thru rest of the ports for this printer
} else if ( pIniPrinterPort->Status & PP_WARNING ) {
if ( dwSeverity != PP_WARNING ) {
dwSeverity = PP_WARNING;
dwPortStatus = PortToPrinterStatus(pIniPrinterPort->PrinterStatus);
}
} else if ( pIniPrinterPort->Status & PP_INFORMATIONAL ) {
if ( dwSeverity == 0 ) {
dwSeverity = PP_INFORMATIONAL;
dwPortStatus = PortToPrinterStatus(pIniPrinterPort->PrinterStatus);
}
}
}
if ( pIniPrinter->PortStatus != dwPortStatus ) {
pIniPrinter->PortStatus = dwPortStatus;
SetPrinterChange(pIniPrinter,
NULL,
NVPrinterStatus,
PRINTER_CHANGE_SET_PRINTER,
pIniPrinter->pIniSpooler);
}
}
}
//
// Table is by port status values in winspool.h
//
DWORD PortToPrinterStatusMappings[] = {
0,
PRINTER_STATUS_OFFLINE,
PRINTER_STATUS_PAPER_JAM,
PRINTER_STATUS_PAPER_OUT,
PRINTER_STATUS_OUTPUT_BIN_FULL,
PRINTER_STATUS_PAPER_PROBLEM,
PRINTER_STATUS_NO_TONER,
PRINTER_STATUS_DOOR_OPEN,
PRINTER_STATUS_USER_INTERVENTION,
PRINTER_STATUS_OUT_OF_MEMORY,
PRINTER_STATUS_TONER_LOW,
PRINTER_STATUS_WARMING_UP,
PRINTER_STATUS_POWER_SAVE,
};
BOOL
LocalSetPort(
LPWSTR pszName,
LPWSTR pszPortName,
DWORD dwLevel,
LPBYTE pPortInfo
)
{
PINIPORT pIniPort;
PPORT_INFO_3 pPortInfo3 = (PPORT_INFO_3) pPortInfo;
DWORD dwLastError = ERROR_SUCCESS;
DWORD dwNewStatus, dwOldStatus;
BOOL bJobStatusChanged = FALSE;
WCHAR szPort[MAX_PATH + 9];
LPWSTR pszComma;
PINISPOOLER pIniSpooler = FindSpoolerByNameIncRef( pszName, NULL );
BOOL SemEntered = FALSE;
if( !pIniSpooler )
{
dwLastError = ERROR_INVALID_NAME;
goto Cleanup;
}
if ( !MyName(pszName, pIniSpooler) ) {
dwLastError = GetLastError();
goto Cleanup;
}
//
// The monitor needs to be able to set or clear the error for the port. The monitor
// is loaded by the spooler. If the monitor doesn't link to winspool.drv, then the
// call to SetPort comes directly, i.e. not via RPC. In this case we do not want
// to check for admin privileges. We allow any user to set the port status.
//
if (!ValidateObjectAccess(SPOOLER_OBJECT_SERVER,
IsCallViaRPC() ? SERVER_ACCESS_ADMINISTER : SERVER_ACCESS_ENUMERATE,
NULL,
NULL,
pIniSpooler )) {
dwLastError = GetLastError();
goto Cleanup;
}
if( !pszPortName ){
dwLastError = ERROR_UNKNOWN_PORT ;
goto Cleanup;
}
//
// Some ports will come in as "port,1234abcd" so truncate the
// suffix.
//
wcsncpy( szPort, pszPortName, COUNTOF( szPort ));
//
// Force NULL terminate the port.
//
szPort[COUNTOF(szPort) - 1] = L'\0';
pszComma = wcschr( szPort, TEXT( ',' ));
if( pszComma ){
*pszComma = 0;
}
SemEntered = TRUE;
EnterSplSem();
pIniPort = FindPort(szPort, pIniSpooler);
if ( !pIniPort ) {
dwLastError = ERROR_UNKNOWN_PORT;
goto Cleanup;
}
if ( dwLevel != 3 ) {
dwLastError = ERROR_INVALID_LEVEL;
goto Cleanup;
}
if ( !pPortInfo ) {
dwLastError = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
switch (pPortInfo3->dwSeverity) {
case 0:
if ( pPortInfo3->dwStatus || pPortInfo3->pszStatus ) {
dwLastError = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
dwNewStatus = 0;
break;
case PORT_STATUS_TYPE_ERROR:
dwNewStatus = PP_ERROR;
break;
case PORT_STATUS_TYPE_WARNING:
dwNewStatus = PP_WARNING;
break;
case PORT_STATUS_TYPE_INFO:
dwNewStatus = PP_INFORMATIONAL;
break;
default:
dwLastError = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
dwOldStatus = pIniPort->Status;
//
// Clear old status
//
pIniPort->PrinterStatus = 0;
pIniPort->Status &= ~(PP_ERROR | PP_WARNING | PP_INFORMATIONAL);
if ( pIniPort->pszStatus ) {
//
// If the job currently has the same status as port free it
//
if ( pIniPort->pIniJob &&
pIniPort->pIniJob->pStatus &&
!wcscmp(pIniPort->pIniJob->pStatus, pIniPort->pszStatus) ) {
FreeSplStr(pIniPort->pIniJob->pStatus);
pIniPort->pIniJob->pStatus = NULL;
bJobStatusChanged = TRUE;
}
FreeSplStr(pIniPort->pszStatus);
pIniPort->pszStatus = NULL;
}
//
// If string field is used for status use it, else look at dwStatus
//
if ( pPortInfo3->pszStatus && *pPortInfo3->pszStatus ) {
pIniPort->pszStatus = AllocSplStr(pPortInfo3->pszStatus);
if ( !pIniPort->pszStatus ) {
dwLastError = GetLastError();
goto Cleanup;
}
if ( pIniPort->pIniJob && !pIniPort->pIniJob->pStatus ) {
pIniPort->pIniJob->pStatus = AllocSplStr(pIniPort->pszStatus);
bJobStatusChanged = TRUE;
}
} else {
//
// If we add new entries to winspool.h they should be added here too
//
if ( pPortInfo3->dwStatus >=
sizeof(PortToPrinterStatusMappings)/sizeof(PortToPrinterStatusMappings[0]) ) {
dwLastError = ERROR_INVALID_PARAMETER;
goto Cleanup;
}
pIniPort->PrinterStatus = pPortInfo3->dwStatus;
}
if( bJobStatusChanged ){
SetPrinterChange( pIniPort->pIniJob->pIniPrinter,
pIniPort->pIniJob,
NVJobStatusString,
PRINTER_CHANGE_SET_JOB,
pIniPort->pIniJob->pIniPrinter->pIniSpooler );
}
pIniPort->Status |= dwNewStatus;
UpdatePortStatusForAllPrinters(pIniPort);
if ( (dwOldStatus & PP_ERROR) &&
!(dwNewStatus & PP_ERROR) ) {
//
// if it is a transition to an non - error state , set event to unlock LocalWritePrinter
//
pIniPort->ErrorTime = 0;
if( pIniPort->hErrorEvent != NULL ){
SetEvent(pIniPort->hErrorEvent);
}
CHECK_SCHEDULER();
}
if ( !(dwOldStatus & PP_ERROR) &&
!(dwNewStatus & PP_ERROR) ) {
//
// when non-error state persists(after two calls with an non - error state) ,
// close the hErrorEvent handle
//
if( pIniPort->hErrorEvent != NULL ){
CloseHandle(pIniPort->hErrorEvent);
pIniPort->hErrorEvent = NULL;
}
}
if ( !(dwOldStatus & PP_ERROR) &&
(dwNewStatus & PP_ERROR) &&
(pIniPort->cJobs) &&
(pIniSpooler->bRestartJobOnPoolEnabled) &&
( pPortInfo3->dwStatus == PORT_STATUS_OFFLINE ||
pPortInfo3->dwStatus == PORT_STATUS_PAPER_JAM ||
pPortInfo3->dwStatus == PORT_STATUS_PAPER_OUT ||
pPortInfo3->dwStatus == PORT_STATUS_DOOR_OPEN ||
pPortInfo3->dwStatus == PORT_STATUS_PAPER_PROBLEM ||
pPortInfo3->dwStatus == PORT_STATUS_NO_TONER)) {
//
// If it is a transition to an error state and port has an job assigned, create event as non-signalled or Reset event it
// LocalWritePrinter will get stuck if the port is in error state and this event is reset
//
if( pIniPort->ErrorTime == 0 ){
pIniPort->ErrorTime = GetTickCount();
if( pIniPort->hErrorEvent == NULL ){
pIniPort->hErrorEvent = CreateEvent(NULL,
EVENT_RESET_MANUAL,
EVENT_INITIAL_STATE_NOT_SIGNALED,
NULL );
}else{
ResetEvent( pIniPort->hErrorEvent );
}
}
}
if ( (dwOldStatus & PP_ERROR) &&
(dwNewStatus & PP_ERROR) &&
(pIniPort->cJobs) &&
(pIniPort->hErrorEvent != NULL) ) {
//
// When error state persists , check the time since error occured.
//
if( (GetTickCount() - pIniPort->ErrorTime) > pIniSpooler->dwRestartJobOnPoolTimeout * 1000 ){
//
// If time out and printer is a pool ( more than one port assigned ),
// clear job error and restart the job.
//
if( (pIniPort->pIniJob) &&
(pIniPort->pIniJob->pIniPrinter) &&
(pIniPort->pIniJob->pIniPrinter->cPorts > 1) ){
//
// Don't restart the job if it is already deleted or restarted.
//
BOOL bWasRestarted = pIniPort->pIniJob->Status & (JOB_PENDING_DELETION | JOB_RESTART);
if( !bWasRestarted ){
ClearJobError( pIniPort->pIniJob );
RestartJob( pIniPort->pIniJob );
}
SetEvent( pIniPort->hErrorEvent );
}
}
}
Cleanup:
if(pIniSpooler)
{
FindSpoolerByNameDecRef( pIniSpooler );
}
if(SemEntered)
{
LeaveSplSem();
SplOutSem();
}
if(dwLastError != ERROR_SUCCESS)
{
SetLastError(dwLastError);
return FALSE;
}
else
{
return TRUE;
}
}
VOID
SetPortErrorEvent(
PINIPORT pIniPort
)
{
SplInSem();
if(pIniPort && pIniPort->hErrorEvent) {
SetEvent(pIniPort->hErrorEvent);
}
}
Reference in a new issue Copy permalink