/*++ 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 #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); } }