You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
525 lines
17 KiB
525 lines
17 KiB
/*************************************************************************
|
|
* Microsoft Windows NT *
|
|
* *
|
|
* Copyright(c) Microsoft Corp., 1994-1997. *
|
|
* *
|
|
* Revision History: *
|
|
* *
|
|
* Jan. 24,94 Koti Created *
|
|
* 03-May-97 MohsinA Performance Thread Pooling *
|
|
* Description: *
|
|
* *
|
|
* This file contains functions that process requests from LPR clients *
|
|
* *
|
|
*************************************************************************/
|
|
|
|
|
|
|
|
#include "lpd.h"
|
|
|
|
VOID CleanupConn( PSOCKCONN pscConn);
|
|
|
|
// ========================================================================
|
|
//
|
|
// SYNOPSIS: Thread Pooling Performance Fix.
|
|
// AUTHOR: MohsinA, 25-Apr-97.
|
|
// HISTORY: Boeing needs scalable lpd servers.
|
|
//
|
|
// Notes:
|
|
// This is a worker thread
|
|
// that pulls pscConn from the global queue and services them.
|
|
// It is created from LoopOnAccept when there are many jobs and
|
|
// too few WorkerThread(s).
|
|
// WorkerThread dies when there are too many idle threads or
|
|
// when shutting down.
|
|
//
|
|
|
|
DWORD WorkerThread( PSOCKCONN pscConn )
|
|
{
|
|
DWORD threadid = GetCurrentThreadId();
|
|
int stayalive = 1; // bool, loop break in cs.
|
|
int fIamLastThread= 0;
|
|
|
|
int SLEEP_TIME = 4000; // in ms, constant per thread.
|
|
int time_slept = 0; // in ms, sum.
|
|
int num_jobs = 0; // ordinal sum.
|
|
|
|
COMMON_LPD local_common;
|
|
|
|
#ifdef PROFILING
|
|
time_t time_start = time(NULL);
|
|
time_t time_done = 0;
|
|
#endif
|
|
|
|
// We randomize the sleep time, as we don't want all the
|
|
// threads to wake up together. srand must be seeded for each thread.
|
|
|
|
#ifdef PROFILING
|
|
srand( time_start );
|
|
#endif
|
|
SLEEP_TIME = 2000 + (rand() & 0x7ff); // 2000 to 4000.
|
|
|
|
|
|
// We can't use this pscConn as another thread could have pulled it out.
|
|
// Instead we go and pull another pscConn from the queue.
|
|
|
|
pscConn = NULL;
|
|
|
|
while( stayalive ){
|
|
|
|
//
|
|
// Shutdown after emptying the queue below.
|
|
// fShuttingDownGLB will clean the job in ServiceTheClient.
|
|
//
|
|
|
|
EnterCriticalSection( &csConnSemGLB );
|
|
{
|
|
if( scConnHeadGLB.pNext ){
|
|
|
|
// == Remove one from the head.
|
|
|
|
pscConn = scConnHeadGLB.pNext;
|
|
scConnHeadGLB.pNext = pscConn->pNext;
|
|
|
|
pscConn->pNext = NULL;
|
|
Common.QueueLength--;
|
|
|
|
// == Remove one from the tail.
|
|
// PSOCKCONN x = &scConnHeadGLB;
|
|
// int count = Common.QueueLength;
|
|
//
|
|
// while( x->pNext->pNext ){
|
|
// x = x->pNext;
|
|
// --count;
|
|
// assert( 0 < count );
|
|
// }
|
|
// pscConn = x->pNext;
|
|
// Common.QueueLength--;
|
|
// x->pNext = NULL;
|
|
}else{
|
|
|
|
//
|
|
// One thread dies after 16 idle SLEEP_TIME.
|
|
//
|
|
|
|
if( fShuttingDownGLB || ( Common.IdleCounter > 32 ) ){
|
|
Common.IdleCounter /= 2;
|
|
stayalive = 0;
|
|
}else{
|
|
Common.IdleCounter++;
|
|
}
|
|
pscConn = NULL;
|
|
}
|
|
assert( Common.AliveThreads >= 0 );
|
|
assert( Common.QueueLength >= 0 );
|
|
local_common = Common; // struct copy, for readonly.
|
|
}
|
|
LeaveCriticalSection( &csConnSemGLB );
|
|
|
|
if( pscConn )
|
|
{
|
|
num_jobs++;
|
|
ServiceTheClient( pscConn );
|
|
}
|
|
else if( stayalive )
|
|
{
|
|
// LOGIT(( "PROFILING: thread %3d sleeping %d, IdleCounter=%d\n",
|
|
// threadid, SLEEP_TIME, local_common.IdleCounter ));
|
|
Sleep( SLEEP_TIME );
|
|
time_slept += SLEEP_TIME;
|
|
}
|
|
|
|
} // while stayalive.
|
|
|
|
// ====================================================================
|
|
|
|
#ifdef PROFILING
|
|
time_done = time(NULL);
|
|
LOGIT(("PROFILING: thread %3d ends, jobs=%d, life=%d, slept=%d,\n"
|
|
" AliveThreads=%d -1, MaxThreads=%d,\n"
|
|
" TotalAccepts=%d, TotalErrors=%d, IdleCounter=%d\n"
|
|
" Time now is %s"
|
|
,
|
|
threadid, num_jobs, time_done - time_start, time_slept/1000,
|
|
local_common.AliveThreads, local_common.MaxThreads,
|
|
local_common.TotalAccepts, local_common.TotalErrors,
|
|
local_common.IdleCounter,
|
|
ctime(&time_done)
|
|
));
|
|
#else
|
|
LOGIT(("WorkerThread: thread %3d ends.\n", threadid ));
|
|
#endif
|
|
|
|
EnterCriticalSection( &csConnSemGLB );
|
|
{
|
|
Common.AliveThreads--;
|
|
|
|
fIamLastThread = (Common.AliveThreads < 1 );
|
|
}
|
|
LeaveCriticalSection( &csConnSemGLB );
|
|
|
|
|
|
if( fIamLastThread && fShuttingDownGLB ){
|
|
LOGIT(("WorkerThread: Last worker thread exiting\n"));
|
|
SetEvent( hEventLastThreadGLB );
|
|
}
|
|
|
|
return NO_ERROR; // Thread Ends.
|
|
}
|
|
|
|
|
|
/*
|
|
****************************************************************************
|
|
* *
|
|
* ServiceTheClient(): *
|
|
* This function reads and interprets the request from the LPR client and *
|
|
* takes appropriate action. In that sense, this routine is the heart of *
|
|
* LPD service. *
|
|
* *
|
|
* Returns: *
|
|
* NO_ERROR (always) *
|
|
* *
|
|
* Parameters: *
|
|
* pscConn (IN-OUT): pointer to SOCKCONN structure for this connection *
|
|
* *
|
|
* History: *
|
|
* Jan.24, 94 Koti Created *
|
|
* *
|
|
****************************************************************************
|
|
*/
|
|
|
|
|
|
|
|
DWORD ServiceTheClient( PSOCKCONN pscConn )
|
|
{
|
|
|
|
DWORD dwErrcode;
|
|
DWORD dwResponse;
|
|
CHAR chCmdCode;
|
|
DWORD threadid = GetCurrentThreadId();
|
|
|
|
|
|
pscConn->fLogGenericEvent = TRUE;
|
|
pscConn->dwThread = threadid;
|
|
pscConn->hPrinter = (HANDLE)INVALID_HANDLE_VALUE;
|
|
|
|
#ifdef PROFILING
|
|
pscConn->time_start = time(NULL);
|
|
#endif
|
|
|
|
if ( fShuttingDownGLB ){
|
|
LOGIT(("ServiceTheClient: Thread %3d shutting down.\n", threadid ));
|
|
goto ServiceTheClient_BAIL;
|
|
}
|
|
|
|
// who are we connected to?
|
|
|
|
GetClientInfo( pscConn );
|
|
|
|
//
|
|
// get server ip address, since print clustering allows one
|
|
// node to have multiple ip addresses. Depending on the ip
|
|
// address, we'll go to different sets of print queues on the node.
|
|
//
|
|
// Albert Ting cluster change, MohsinA, 07-Mar-97.
|
|
//
|
|
|
|
GetServerInfo( pscConn );
|
|
|
|
// get command from the client
|
|
// ----------------- command 02 => "Receive Job"
|
|
// | 02 | Queue LF | Queue => Queue or Printer to print on
|
|
// -----------------
|
|
|
|
if ( GetCmdFromClient( pscConn ) != NO_ERROR )
|
|
{
|
|
// didn't get a command from client: it's bad news!
|
|
|
|
LPD_DEBUG( "GetCmdFromClient() failed in ServiceTheClient()!\n" );
|
|
|
|
goto ServiceTheClient_BAIL;
|
|
}
|
|
|
|
|
|
// get name of the queue (printer) from the command. If it's not
|
|
// formatted properly, quit!
|
|
|
|
if ( !ParseQueueName( pscConn ) )
|
|
{
|
|
PCHAR aszStrings[2]={ pscConn->szIPAddr, NULL };
|
|
|
|
LpdReportEvent( LPDLOG_BAD_FORMAT, 1, aszStrings, 0 );
|
|
|
|
pscConn->fLogGenericEvent = FALSE;
|
|
|
|
LPD_DEBUG( "ParseQueueName() failed in ServiceTheClient()!\n" );
|
|
|
|
goto ServiceTheClient_BAIL;
|
|
}
|
|
|
|
|
|
// ====================================================================
|
|
|
|
chCmdCode = pscConn->pchCommand[0];
|
|
|
|
switch( chCmdCode )
|
|
{
|
|
case LPDC_RECEIVE_JOB:
|
|
|
|
pscConn->wState = LPDS_RECEIVE_JOB;
|
|
|
|
ProcessJob( pscConn );
|
|
CleanupConn( pscConn );
|
|
|
|
if ( pscConn->wState != LPDS_ALL_WENT_WELL )
|
|
{
|
|
AbortThisJob( pscConn );
|
|
|
|
if ( pscConn->fLogGenericEvent )
|
|
{
|
|
PCHAR aszStrings[2]={ pscConn->szIPAddr, NULL };
|
|
|
|
LpdReportEvent( LPDLOG_DIDNT_WORK, 1, aszStrings, 0 );
|
|
}
|
|
}
|
|
|
|
if (pscConn->fMustFreeLicense)
|
|
{
|
|
NtLSFreeHandle(pscConn->LicenseHandle);
|
|
}
|
|
break;
|
|
|
|
|
|
case LPDC_RESUME_PRINTING:
|
|
|
|
pscConn->wState = LPDS_RESUME_PRINTING;
|
|
|
|
if ( fAllowPrintResumeGLB )
|
|
{
|
|
dwResponse = ( ResumePrinting( pscConn ) == NO_ERROR ) ?
|
|
LPD_ACK : LPD_NAK;
|
|
}
|
|
else
|
|
{
|
|
dwResponse = LPD_NAK;
|
|
}
|
|
|
|
dwErrcode = ReplyToClient( pscConn, (WORD)dwResponse );
|
|
|
|
break;
|
|
|
|
|
|
case LPDC_SEND_SHORTQ:
|
|
|
|
case LPDC_SEND_LONGQ:
|
|
|
|
pscConn->wState = LPDS_SEND_LONGQ;
|
|
|
|
if ( ParseQueueRequest( pscConn, FALSE ) != NO_ERROR )
|
|
{
|
|
LPD_DEBUG( "ServiceTheClient(): ParseQueueRequest() failed\n" );
|
|
|
|
break;
|
|
}
|
|
|
|
SendQueueStatus( pscConn, LPD_LONG );
|
|
|
|
break;
|
|
|
|
|
|
case LPDC_REMOVE_JOBS:
|
|
|
|
if ( !fJobRemovalEnabledGLB )
|
|
{
|
|
break;
|
|
}
|
|
|
|
pscConn->wState = LPDS_REMOVE_JOBS;
|
|
|
|
if ( ParseQueueRequest( pscConn, TRUE ) != NO_ERROR )
|
|
{
|
|
LPD_DEBUG( "ServiceTheClient(): ParseQueueRequest() failed\n" );
|
|
|
|
break;
|
|
}
|
|
|
|
if ( RemoveJobs( pscConn ) == NO_ERROR )
|
|
{
|
|
ReplyToClient( pscConn, LPD_ACK );
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
}
|
|
|
|
// ====================================================================
|
|
|
|
if ( pscConn->wState != LPDS_ALL_WENT_WELL ){
|
|
goto ServiceTheClient_BAIL;
|
|
}
|
|
|
|
#ifdef PROFILING
|
|
pscConn->time_done = time(NULL);
|
|
LOGIT(("PROFILING: ok, thread %3d, time_queued %s"
|
|
" wait=%d, work=%d\n",
|
|
threadid,
|
|
ctime(&pscConn->time_queued),
|
|
pscConn->time_start - pscConn->time_queued,
|
|
pscConn->time_done - pscConn->time_start
|
|
));
|
|
#endif
|
|
|
|
// close the connection down and terminate the thread
|
|
|
|
TerminateConnection( pscConn );
|
|
pscConn = NULL;
|
|
|
|
return NO_ERROR;
|
|
|
|
// ====================================================================
|
|
// if we reached here, then a non-recoverable error occured somewhere:
|
|
// try to inform the client (by sending a NAK) and terminate the thread
|
|
|
|
ServiceTheClient_BAIL:
|
|
|
|
#ifdef PROFILING
|
|
pscConn->time_done = time(NULL);
|
|
LOGIT(("PROFILING: bail, thread %3d, job times %8d, wait=%d work=%d\n",
|
|
threadid,
|
|
pscConn->time_queued,
|
|
pscConn->time_start - pscConn->time_queued,
|
|
pscConn->time_done - pscConn->time_start
|
|
));
|
|
#endif
|
|
|
|
LPD_DEBUG( "Reached ServiceTheClient_BAIL.\n" );
|
|
ReplyToClient( pscConn, LPD_NAK );
|
|
TerminateConnection( pscConn );
|
|
pscConn = NULL;
|
|
|
|
return NO_ERROR;
|
|
|
|
} // end ServiceTheClient()
|
|
|
|
|
|
/*****************************************************************************
|
|
* *
|
|
* TerminateConnection(): *
|
|
* This function releases all the memory that was allocated while *
|
|
* processing the client's requests, closes the printer, closes the *
|
|
* socket connection, removes its structure (pscConn) from the global *
|
|
* linked list and frees the memory allocated for pscConn itself. *
|
|
* Also, if the main thread is waiting on this thread for shutdown then *
|
|
* this function sets hEventLastThreadGLB event to tell the main thread *
|
|
* that this thread is done. *
|
|
* *
|
|
* Returns: *
|
|
* Nothing *
|
|
* *
|
|
* Parameters: *
|
|
* pscConn (IN-OUT): pointer to SOCKCONN structure for this connection *
|
|
* *
|
|
* History: *
|
|
* Jan.24, 94 Koti Created *
|
|
* *
|
|
*****************************************************************************/
|
|
|
|
VOID TerminateConnection( PSOCKCONN pscConn )
|
|
{
|
|
|
|
// PSOCKCONN pscCurrent;
|
|
// BOOL fIamLastThread=FALSE;
|
|
|
|
// it should never be NULL at this point! But check it anyway!
|
|
|
|
if ( pscConn == (PSOCKCONN) NULL )
|
|
{
|
|
LPD_DEBUG( "TerminateConnection(): pscConn NULL at entry\n" );
|
|
return;
|
|
}
|
|
|
|
ShutdownPrinter( pscConn );
|
|
|
|
if ( pscConn->hPrinter != (HANDLE)INVALID_HANDLE_VALUE )
|
|
{
|
|
LPD_DEBUG( "TerminateConnection: hPrinter not closed\n" );
|
|
}
|
|
|
|
// close the socket
|
|
|
|
if ( pscConn->sSock != INVALID_SOCKET )
|
|
{
|
|
SureCloseSocket( pscConn->sSock );
|
|
}
|
|
|
|
//
|
|
// release memory in every field of the structure
|
|
//
|
|
|
|
if ( pscConn->pchCommand != NULL )
|
|
LocalFree( pscConn->pchCommand );
|
|
|
|
if ( pscConn->pchPrinterName != NULL )
|
|
LocalFree( pscConn->pchPrinterName );
|
|
|
|
//
|
|
// no memory was allocated for ppchUsers[] and adwJobIds[]. They just
|
|
// pointed to parts of what's freed by ( pscConn->pchCommand ) above.
|
|
//
|
|
|
|
if ( pscConn->pqStatus != NULL )
|
|
LocalFree( pscConn->pqStatus );
|
|
|
|
// EnterCriticalSection( &csConnSemGLB );
|
|
// {
|
|
//
|
|
// if( Common.AliveThreads <= 1 ){
|
|
// fIamLastThread = TRUE;
|
|
// }
|
|
//
|
|
// //
|
|
// // // remove this structure from the link
|
|
// //
|
|
// // pscCurrent = &scConnHeadGLB;
|
|
// //
|
|
// // while( pscCurrent ){
|
|
// // if (pscConn == pscCurrent->pNext)
|
|
// // break;
|
|
// // pscCurrent = pscCurrent->pNext;
|
|
// //
|
|
// // // what if we can't find our pscConn in the list at all?
|
|
// // // this should NEVER ever happen, but good to check!
|
|
// //
|
|
// // if( pscCurrent == NULL)
|
|
// // {
|
|
// // LocalFree( pscConn );
|
|
// // LPD_DEBUG( "TerminateConnection(): "
|
|
// // "couldn't find pscConn "
|
|
// // " in the list!\n" );
|
|
// // LeaveCriticalSection( &csConnSemGLB );
|
|
// // return;
|
|
// // }
|
|
// // }
|
|
// // pscCurrent->pNext = pscConn->pNext;
|
|
// }
|
|
// LeaveCriticalSection( &csConnSemGLB );
|
|
|
|
memset( pscConn, 0, sizeof( SOCKCONN ) );
|
|
|
|
LocalFree( pscConn );
|
|
|
|
// //
|
|
// // if shutdown is in progress and we are the last active thread, tell
|
|
// // the poor main thread (blocked for us to finish) that we're done!
|
|
// //
|
|
//
|
|
// if( fIamLastThread && fShuttingDownGLB ){
|
|
// LOGIT(("TerminateConnection: Last worker thread exiting\n"));
|
|
// SetEvent( hEventLastThreadGLB );
|
|
// }
|
|
|
|
return;
|
|
}
|