|
|
/*************************************************************************
* Microsoft Windows NT * * * * Copyright(c) Microsoft Corp., 1994 * * * * Revision History: * * * * Jan. 24,94 Koti Created * * Jan. 29,96 JBallard Modified * * * * Description: * * * * This file contains functions for carrying out LPD printing * * * *************************************************************************/
#include "lpd.h"
extern FILE * pErrFile; // Debug output log file.
BOOL GetSpoolFileName( HANDLE hPrinter, PSOCKCONN pscConn, PCHAR *ppwchSpoolPath);
VOID CleanupConn( PSOCKCONN pscConn);
/*****************************************************************************
* * * ProcessJob(): * * This function receives the subcommand from the client to expect the * * control file, then accepts the control file, then the subcommand to * * expect the data file, then accepts the data and then hands it over to * * the spooler to print. * * If the very first subcommand was to abort the job, we just return. * * * * Returns: * * Nothing * * * * Parameters: * * pscConn (IN-OUT): pointer to SOCKCONN structure for this connection * * * * History: * * Jan.24 94 Koti Created * * * *****************************************************************************/
VOID ProcessJob( PSOCKCONN pscConn ){
// the main functionality of LPD implemented in this function!
CHAR chSubCmdCode; DWORD cbTotalDataLen; DWORD cbBytesSpooled; DWORD cbBytesToRead; DWORD cbDataBufLen; DWORD cbBytesRemaining; DWORD dwErrcode; CHAR chAck; HANDLE hDFile; PDFILE_ENTRY pDFile; PCHAR lpFileName; PCHAR pchDataBuf;
DWORD ClientCmd; // initialize the printer that the client wants to use
#ifdef DBG
if( !pscConn || !pscConn->pchPrinterName || strstr( pscConn->pchPrinterName, "debug" ) ){ print__sockconn( "ProcessJob: entered", pscConn ); }#endif
if ( InitializePrinter( pscConn ) != NO_ERROR ) { PCHAR aszStrings[2];
aszStrings[0] = pscConn->pchPrinterName; aszStrings[1] = pscConn->szIPAddr;
LpdReportEvent( LPDLOG_NONEXISTENT_PRINTER, 2, aszStrings, 0 );
pscConn->fLogGenericEvent = FALSE;
return; // fatal error: exit
}
// thank the client for the command. If we couldn't send, quit
if ( ReplyToClient( pscConn, LPD_ACK ) != NO_ERROR ) { LPD_DEBUG( "ProcessJob(): couldn't ACK to \"receive job\"\n" );
return; }
// 2 subcommands expected: "receive control file" and "receive data file"
// They can come in any order. (One of the two subcommands can also be
// "abort this job" in which case we abort the job and return).
for ( ; ; ) {
// don't need the previous one (in fact, pchCommand field is reused)
if ( pscConn->pchCommand != NULL ) { LocalFree( pscConn->pchCommand );
pscConn->pchCommand = NULL; }
// get the first subcommand from the client
// ------------------------------ N = 02, 03, or 01
// | N | Count | SP | Name | LF | Count => control file length
// ------------------------------ Name => controlfile name
ClientCmd = GetCmdFromClient( pscConn ); switch ( ClientCmd ) { case CONNECTION_CLOSED:
// performance enhancement: close the socket here and then start
// printing: printing could take several seconds,
// so don't tie up client
if ( pscConn->sSock != INVALID_SOCKET ) { SureCloseSocket( pscConn->sSock ); pscConn->sSock = INVALID_SOCKET; }
// if we came this far, everything went as planned.
// tell spooler that we are done spooling: go ahead and print!
PrintData( pscConn ); pscConn->wState = LPDS_ALL_WENT_WELL; return;
case NO_ERROR:
// Not yet done, back to outer loop.
break;
case SOCKET_ERROR:
default:
// If we didn't get a subcommand from client, it's bad news!
// client died or something catastophic like that!
LOGIT(("ProcessJob:GetCmdFromClient %d failed %d.\n", ClientCmd, GetLastError() ));
return; // the thread exits without doing anything
}
chSubCmdCode = pscConn->pchCommand[0];
switch (chSubCmdCode) {
case LPDCS_RECV_CFILE: // N = 02 ("receive control file")
// client is going to give us a control file: prepare for it
pscConn->wState = LPDSS_RECVD_CFILENAME;
// get the controlfile name, file size out of the command
if ( ParseSubCommand( pscConn, &cbTotalDataLen, &lpFileName ) != NO_ERROR ) { PCHAR aszStrings[2]={ pscConn->szIPAddr, NULL };
LpdReportEvent( LPDLOG_BAD_FORMAT, 1, aszStrings, 0 );
pscConn->fLogGenericEvent = FALSE;
return; // fatal error: exit
}
// tell client we got the name of the controlfile ok
if ( ReplyToClient( pscConn, LPD_ACK ) != NO_ERROR ) { return; // fatal error: exit
}
// Get the control file (we already know how big it is)
if ( GetControlFileFromClient( pscConn, cbTotalDataLen, lpFileName ) != NO_ERROR ) { LPD_DEBUG( "GetControlFileFromClient() failed in ProcessJob()\n" );
return; }
pscConn->wState = LPDSS_RECVD_CFILE;
// tell client we got the controlfile and things look good so far!
if ( ReplyToClient( pscConn, LPD_ACK ) != NO_ERROR ) { LOGIT(("ProcessJob:%d: ReplyToClient failed %d\n", __LINE__, GetLastError() ));
return; // fatal error: exit
}
break;
case LPDCS_RECV_DFILE: // N = 03 ("receive data file")
pscConn->wState = LPDSS_RECVD_DFILENAME;
// tell client we got the name of the datafile ok
if ( ReplyToClient( pscConn, LPD_ACK ) != NO_ERROR ) { LOGIT(("ProcessJob:%d: ReplyToClient failed %d\n", __LINE__, GetLastError() ));
return; // fatal error: exit
}
// get the datafile name, data size out of the command
if ( ParseSubCommand( pscConn, &cbTotalDataLen, &lpFileName ) != NO_ERROR ) {
PCHAR aszStrings[2]={ pscConn->szIPAddr, NULL };
LpdReportEvent( LPDLOG_BAD_FORMAT, 1, aszStrings, 0 );
pscConn->fLogGenericEvent = FALSE;
LOGIT(("ProcessJob:%d: ParseSubCommand failed %d\n", __LINE__, GetLastError() ));
return; // fatal error: exit
}
// at this point, we know exactly how much data is coming.
// Allocate buffer to hold the data. If data is more than
// LPD_BIGBUFSIZE, keep reading and spooling several times
// over until data is done
pscConn->wState = LPDSS_SPOOLING;
pDFile = LocalAlloc( LMEM_FIXED, sizeof(DFILE_ENTRY) );
if (pDFile == NULL) { LocalFree( lpFileName );
LOGIT(("ProcessJob:%d: LocalAlloc failed %d\n", __LINE__, GetLastError() ));
return; // Fatal Error
}
pDFile->cbDFileLen = cbTotalDataLen; pDFile->pchDFileName = lpFileName;
if ( !GetSpoolFileName( pscConn->hPrinter, pscConn, &lpFileName ) ) { LPD_DEBUG( "ERROR: GetSpoolFileName() failed in ProcessJob\n" ); LocalFree( pDFile->pchDFileName ); LocalFree( pDFile ); return; }
//
// GetTempFileName has already created this file, so use OPEN_ALWAYS.
// Also, use FILE_ATTRIBUTE_TEMPORARY so that it will be faster
// FILE_FLAG_SEQUENTIAL_SCAN, ntbug 79854, MohsinA, 03-Jun-97.
//
pDFile->hDataFile = CreateFile( lpFileName, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL |FILE_ATTRIBUTE_TEMPORARY |FILE_FLAG_DELETE_ON_CLOSE |FILE_FLAG_SEQUENTIAL_SCAN , NULL );
LocalFree( lpFileName );
if ( pDFile->hDataFile == INVALID_HANDLE_VALUE ) { LPD_DEBUG( "ERROR: CreatFile() failed in ProcessJob \n" ); LocalFree( pDFile->pchDFileName ); LocalFree( pDFile ); return; }
cbBytesToRead = (cbTotalDataLen > LPD_BIGBUFSIZE ) ? LPD_BIGBUFSIZE : cbTotalDataLen;
pchDataBuf = LocalAlloc( LMEM_FIXED, cbBytesToRead );
if ( pchDataBuf == NULL ) { LOGIT(("ProcessJob:%d: LocalAlloc failed %d\n", __LINE__, GetLastError() ));
CloseHandle(pDFile->hDataFile); pDFile->hDataFile = INVALID_HANDLE_VALUE; LocalFree( pDFile->pchDFileName ); LocalFree( pDFile ); return; // fatal error: exit
}
cbBytesSpooled = 0;
cbBytesRemaining = cbTotalDataLen;
// keep receiving until we have all the data client said it
// would send
while( cbBytesSpooled < cbTotalDataLen ) { if ( ReadData( pscConn->sSock, pchDataBuf, cbBytesToRead ) != NO_ERROR ) { LPD_DEBUG( "ProcessJob:ReadData failed, job aborted)\n" );
LocalFree( pchDataBuf ); CloseHandle(pDFile->hDataFile); pDFile->hDataFile = INVALID_HANDLE_VALUE; LocalFree( pDFile->pchDFileName ); LocalFree( pDFile ); return; // fatal error: exit
}
cbDataBufLen = cbBytesToRead;
if ( SpoolData( pDFile->hDataFile, pchDataBuf, cbDataBufLen ) != NO_ERROR ) { LPD_DEBUG( "SpoolData() failed in ProcessJob(): job aborted)\n" );
LocalFree( pchDataBuf ); CloseHandle(pDFile->hDataFile); pDFile->hDataFile = INVALID_HANDLE_VALUE; LocalFree( pDFile->pchDFileName ); LocalFree( pDFile ); return; // fatal error: exit
}
cbBytesSpooled += cbBytesToRead;
cbBytesRemaining -= cbBytesToRead;
cbBytesToRead = (cbBytesRemaining > LPD_BIGBUFSIZE ) ? LPD_BIGBUFSIZE : cbBytesRemaining;
}
LocalFree( pchDataBuf );
InsertTailList( &pscConn->DFile_List, &pDFile->Link );
// LPR client sends one byte (of 0 bits) after sending data
dwErrcode = ReadData( pscConn->sSock, &chAck, 1 );
if ( ( dwErrcode != NO_ERROR ) || (chAck != LPD_ACK ) ) { return; }
// tell client we got the data and things look good so far!
if ( ReplyToClient( pscConn, LPD_ACK ) != NO_ERROR ) {
LOGIT(("ProcessJob:%d: ReplyToClient failed %d\n", __LINE__, GetLastError() ));
return; // fatal error: exit
} break;
case LPDCS_ABORT_JOB: // N = 01 ("abort this job")
// client asked us to abort the job: tell him "ok" and quit!
ReplyToClient( pscConn, LPD_ACK );
pscConn->wState = LPDS_ALL_WENT_WELL; // we did what client wanted
return;
// unknown subcommand: log the event and quit
default: { PCHAR aszStrings[2]={ pscConn->szIPAddr, NULL };
LpdReportEvent( LPDLOG_MISBEHAVED_CLIENT, 1, aszStrings, 0 );
pscConn->fLogGenericEvent = FALSE;
LPD_DEBUG( "ProcessJob(): invalid subcommand, request rejected\n" );
return; }
}
} // done processing both subcommands
} // end ProcessJob()
/*****************************************************************************
* * * GetControlFileFromClient(): * * This function receives the control file from the client. In the * * previsous subcommand, the client told us how many bytes there are in * * the control file. * * Also,after reading all the bytes, we read the 1 byte "ack" from client * * * * Returns: * * NO_ERROR if everything went well * * ErrorCode if something went wrong somewhere * * * * Parameters: * * pscConn (IN-OUT): pointer to SOCKCONN structure for this connection * * * * History: * * Jan.24, 94 Koti Created * * * *****************************************************************************/
DWORDGetControlFileFromClient( PSOCKCONN pscConn, DWORD FileSize, PCHAR FileName ){
PCHAR pchAllocBuf; DWORD cbBytesToRead; PCFILE_ENTRY pCFile;
if (FileSize > LPD_MAX_CONTROL_FILE_LEN) { return( (DWORD)LPDERR_NOBUFS ); }
pCFile = LocalAlloc( LMEM_FIXED, sizeof(CFILE_ENTRY) ); if (pCFile == NULL) { return( (DWORD)LPDERR_NOBUFS ); }
pCFile->cbCFileLen = FileSize; pCFile->pchCFileName = FileName;
// we know how big the control file is going to be: alloc space for it
// Client sends one byte after sending the control file: read it along
// with the rest of the data
cbBytesToRead = FileSize + 1;
pchAllocBuf = LocalAlloc( LMEM_FIXED, cbBytesToRead );
if (pchAllocBuf == NULL) { LocalFree( pCFile );
return( (DWORD)LPDERR_NOBUFS ); }
// now read the data (and the trailing byte) into this allocated buffer
if ( ReadData( pscConn->sSock, pchAllocBuf, cbBytesToRead ) != NO_ERROR ) { LocalFree( pCFile );
LocalFree( pchAllocBuf );
return( LPDERR_NORESPONSE ); }
// if the trailing byte is not zero, treat it as job aborted (though
// we don't expect this to happen really)
if ( pchAllocBuf[cbBytesToRead-1] != 0 ) { LocalFree( pchAllocBuf );
LocalFree( pCFile );
LPD_DEBUG( "GetControlFileFromClient: got data followed by a NAK!\n");
return( LPDERR_JOBABORTED ); }
pCFile->pchCFile = pchAllocBuf; InsertTailList( &pscConn->CFile_List, &pCFile->Link );
return( NO_ERROR );
} // end GetControlFileFromClient()
/*****************************************************************************
* * * GetSpoolFileName(): * * This function figures out where to put the spool file. * * * * Returns: * * TRUE if spool location found. * * FALSE if no spool location available. * * * * Parameters: * * hPrinter (IN): Handle to printer for which we are spooling * * pscConn (IN-OUT): pointer to SOCKCONN structure for this connection * * ppchSpoolPath (IN-OUT): Address of pointer which will receive the * * spool path. * * * * History: * * Nov.21, 94 JBallard * * * *****************************************************************************/BOOLGetSpoolFileName( HANDLE hPrinter, PSOCKCONN pscConn, PCHAR *ppchSpoolPath)/*++
Routine Description:
This function comes up with a name for a spool file that we should be able to write to.
Note: The file name returned has already been created.
Arguments:
hPrinter - handle to the printer that we want a spool file for.
ppchSpoolFileName: pointer that will receive an allocated buffer containing the file name to spool to. CALLER MUST FREE. Use LocalFree().
Return Value:
TRUE if everything goes as expected. FALSE if anything goes wrong.
--*/{ PBYTE pBuffer = NULL; DWORD dwAllocSize; DWORD dwNeeded; PCHAR pchSpoolPath = NULL; DWORD dwRetval;
pchSpoolPath = LocalAlloc( LMEM_FIXED, 2 * MAX_PATH + 1 );
if ( pchSpoolPath == NULL ) { goto Failure; }
//
// In order to find out where the spooler's directory is, we add
// call GetPrinterData with DefaultSpoolDirectory.
//
dwAllocSize = WCS_LEN( MAX_PATH + 1 );
for (;;) { pBuffer = LocalAlloc( LMEM_FIXED, dwAllocSize );
if ( pBuffer == NULL ) { goto Failure; }
if ( GetPrinterData( hPrinter, SPLREG_DEFAULT_SPOOL_DIRECTORY, NULL, pBuffer, dwAllocSize, &dwNeeded ) == ERROR_SUCCESS ) { break; }
if ( ( dwNeeded < dwAllocSize ) ||( GetLastError() != ERROR_MORE_DATA )) { goto Failure; }
//
// Free the current buffer and increase the size that we try to allocate
// next time around.
//
LocalFree( pBuffer );
dwAllocSize = dwNeeded; }
if( !GetTempFileName( (LPSTR)pBuffer, "LprSpl", 0, pchSpoolPath )) { goto Failure; }
//
// At this point, the spool file name should be done. Free the structure
// we used to get the spooler temp dir and return.
//
LocalFree( pBuffer );
*ppchSpoolPath = pchSpoolPath;
return( TRUE );
Failure:
//
// Clean up and fail.
//
if ( pBuffer != NULL ) { LocalFree( pBuffer ); }
if ( pchSpoolPath != NULL ) { LocalFree( pchSpoolPath ); }
return( FALSE );}
VOID CleanupCFile( PCFILE_ENTRY pCFile ){ if (pCFile->pchCFileName != NULL) { LocalFree( pCFile->pchCFileName ); pCFile->pchCFileName = NULL; } if (pCFile->pchCFile != NULL) { LocalFree( pCFile->pchCFile ); pCFile->pchCFile = NULL; } LocalFree( pCFile );}
VOID CleanupDFile( PDFILE_ENTRY pDFile ){ if (pDFile->pchDFileName != NULL) { LocalFree( pDFile->pchDFileName ); pDFile->pchDFileName = NULL; } if (pDFile->hDataFile != INVALID_HANDLE_VALUE) { CloseHandle(pDFile->hDataFile); } LocalFree( pDFile );}
VOID CleanupConn( PSOCKCONN pscConn){ LIST_ENTRY *pTmpList; CFILE_ENTRY *pCFile; DFILE_ENTRY *pDFile;
while ( !IsListEmpty( &pscConn->CFile_List ) ) { pTmpList = RemoveHeadList( &pscConn->CFile_List ); pCFile = CONTAINING_RECORD( pTmpList, CFILE_ENTRY, Link ); CleanupCFile( pCFile ); }
while ( !IsListEmpty( &pscConn->DFile_List ) ) { pTmpList = RemoveHeadList( &pscConn->DFile_List ); pDFile = CONTAINING_RECORD( pTmpList, DFILE_ENTRY, Link ); CleanupDFile( pDFile ); }
return;}
|
