/*****************************************************************************\
* MODULE: splpjm.c
*
* This module contains the routines to deal with job-mapping list.
*
*
* Copyright (C) 1996-1997 Microsoft Corporation
* Copyright (C) 1996-1997 Hewlett Packard
*
* History:
* 13-Jan-1997 ChrisWil Created.
*
\*****************************************************************************/
#include "precomp.h"
#include "priv.h"
/*****************************************************************************\
* pjm_OldEntry (Local Routine)
*
*
\*****************************************************************************/
_inline BOOL pjm_IsOldEntry(
PJOBMAP pjm)
{
return !pjm->bRemoteJob && !pjmChkState(pjm, PJM_SPOOLING);
}
/*****************************************************************************\
* pjm_IsLocalJob (Local Routine)
*
*
\*****************************************************************************/
_inline BOOL pjm_IsLocalJob(
PJOBMAP pjm)
{
return !pjm->bRemoteJob && pjmChkState(pjm, PJM_SPOOLING);
}
/*****************************************************************************\
* pjm_DelEntry (Local Routine)
*
*
\*****************************************************************************/
_inline VOID pjm_DelEntry(
PJOBMAP pjm)
{
if (pjm->hSplFile)
SplFree(pjm->hSplFile);
if (pjm->lpszUri)
memFreeStr(pjm->lpszUri);
if (pjm->lpszUser)
memFreeStr(pjm->lpszUser);
memFree(pjm, sizeof(JOBMAP));
}
/*****************************************************************************\
* pjmAdd
*
* Add a job-mapping to the list. Access to this list needs ownership of the
* crit-sect.
*
\*****************************************************************************/
PJOBMAP pjmAdd(
PJOBMAP *pjmList,
PCINETMONPORT pIniPort,
LPCTSTR lpszUser,
LPCTSTR lpszDocName)
{
PJOBMAP pjm = NULL;
static DWORD s_idJobLocal = 0;
semCheckCrit();
if (pjmList) {
// Add the new job-entry to the list.
//
if (pjm = (PJOBMAP)memAlloc(sizeof(JOBMAP))) {
// Initialize our job-entry.
//
GetSystemTime (&pjm->SubmitTime);
pjm->dwState = 0;
pjm->pIniPort = pIniPort;
pjm->idJobLocal = ++s_idJobLocal;
pjm->idJobRemote = 0;
pjm->lpszUri = NULL;
pjm->lpszUser = memAllocStr(lpszUser);
pjm->lpszDocName = memAllocStr(lpszDocName);
pjm->hSplFile = NULL;
pjm->dwLocalJobSize = 0;
pjm->dwStatus = JOB_STATUS_SPOOLING;
pjm->pNext = NULL;
// Place it at the end of the list.
//
if (! *pjmList) {
*pjmList = pjm;
}
else {
for (PJOBMAP pjPtr = *pjmList; pjPtr->pNext; pjPtr = pjPtr->pNext);
pjPtr->pNext = pjm;
}
}
}
return pjm;
}
/*****************************************************************************\
* pjmDel
*
* Delete a job-mapping from the list. Access to this list needs owenership
* of the crit-sect.
*
\*****************************************************************************/
VOID pjmDel(
PJOBMAP* pjmList,
PJOBMAP pjm)
{
PJOBMAP pjPtr;
PJOBMAP pjPrv;
DWORD idx;
semCheckCrit();
if (pjmList) {
for (pjPtr = *pjmList, idx = 0; pjPtr && (pjm != pjPtr); ) {
// Reposition.
//
pjPrv = pjPtr;
pjPtr = pjPtr->pNext;
// If we've iterated 1000 jobs in this list, then we've
// either got a very heavily taxed print-system, or we
// may have an infinite loop.
//
if (idx++ >= g_dwJobLimit) {
DBG_MSG(DBG_LEV_ERROR, (TEXT("Error: pjmDel : Looped 1000 jobs, possible infinite loop")));
return;
}
}
// If we found the entry, then delete it.
//
if (pjPtr) {
if (pjPtr == *pjmList) {
*pjmList = pjPtr->pNext;
} else {
pjPrv->pNext = pjPtr->pNext;
}
pjm_DelEntry(pjPtr);
}
}
}
/*****************************************************************************\
* pjmCleanRemoteFlag
*
* Cleanup remote jobid from list. Access to this list needs ownership of the
* crit-sect.
*
\*****************************************************************************/
VOID pjmCleanRemoteFlag(
PJOBMAP* pjmList)
{
PJOBMAP pjPtr = NULL;
semCheckCrit();
if (pjmList) {
for (pjPtr = *pjmList; pjPtr; ) {
pjPtr->bRemoteJob = FALSE;
// Next item.
//
pjPtr = pjPtr->pNext;
}
}
}
/*****************************************************************************\
* pjmGetLocalJobCount
*
* Locate number of job-entries from list. Access to this list needs ownership of the
* crit-sect.
*
\*****************************************************************************/
DWORD pjmGetLocalJobCount(
PJOBMAP* pjmList,
DWORD* pcbItems)
{
PJOBMAP pjPtr = NULL;
DWORD idx = 0;
semCheckCrit();
*pcbItems = 0;
if (pjmList) {
for (pjPtr = *pjmList; pjPtr; ) {
if (pjm_IsLocalJob (pjPtr)) {
idx++;
*pcbItems += sizeof (JOB_INFO_2) +
utlStrSize (pjPtr->lpszDocName) +
utlStrSize (pjPtr->lpszUser);
}
// Next item.
//
pjPtr = pjPtr->pNext;
}
}
return idx;
}
/*****************************************************************************\
* pjmFind
*
* Locate job-entry from list. Access to this list needs ownership of the
* crit-sect. This will lookup either Local/Remote id's and return its
* position.
*
\*****************************************************************************/
PJOBMAP pjmFind(
PJOBMAP* pjmList,
DWORD fType,
DWORD idJob)
{
PJOBMAP pjPtr = NULL;
DWORD idx;
semCheckCrit();
if (pjmList) {
// Search.
//
for (pjPtr = *pjmList, idx = 0; pjPtr && (pjmJobId(pjPtr, fType) != idJob); ) {
// Next item.
//
pjPtr = pjPtr->pNext;
// If we've iterated 1000 jobs in this list, then we've
// either got a very heavily taxed print-system, or we
// may have an infinite loop.
//
if (idx++ >= g_dwJobLimit) {
DBG_MSG(DBG_LEV_ERROR, (TEXT("Error: pjmFind : Looped 1000 jobs, possible infinite loop")));
return NULL;
}
}
if (pjPtr && fType == PJM_REMOTEID) {
pjPtr->bRemoteJob = TRUE;
}
}
return pjPtr;
}
/*****************************************************************************\
* pjmNextLocalJob
*
* Walk the list and look for any expired entries. Access to this list needs
* ownership of the crit-sect.
*
\*****************************************************************************/
PJOBMAP pjmNextLocalJob(
PJOBMAP* pjmList,
PJOB_INFO_2 pJobInfo2,
PBOOL pbFound)
{
PJOBMAP pjPtr = NULL;
DWORD idx;
BOOL bFound = FALSE;
semCheckCrit();
if (pjmList) {
for (pjPtr = *pjmList, idx = 0; pjPtr && !bFound; ) {
// If we're spooling, then we can't be an old-job.
//
if (pjm_IsLocalJob (pjPtr)) {
// It is a new entry
//
ZeroMemory (pJobInfo2, sizeof (JOB_INFO_2));
pJobInfo2->JobId = pjPtr->idJobLocal;
pJobInfo2->pDocument = pjPtr->lpszDocName;
pJobInfo2->pUserName = pjPtr->lpszUser;
pJobInfo2->Size = pjPtr->dwLocalJobSize;
pJobInfo2->Submitted = pjPtr->SubmitTime;
pJobInfo2->Status = pjPtr->dwStatus;
if (pjmChkState (pjPtr, PJM_CANCEL)) {
pJobInfo2->Status |= JOB_STATUS_DELETING;
}
bFound = TRUE;
}
// Next item.
//
pjPtr = pjPtr->pNext;
}
}
*pbFound = bFound;
return pjPtr;
}
/*****************************************************************************\
* pjmRmoveOldEntries
*
* Walk the list and look for any expired entries. Access to this list needs
* ownership of the crit-sect.
*
\*****************************************************************************/
VOID pjmRemoveOldEntries(
PJOBMAP *pjmList)
{
PJOBMAP pjPtr;
PJOBMAP pjDel;
PJOBMAP pjPrv;
DWORD idx;
semCheckCrit();
for (pjPtr = *pjmList, pjPrv = *pjmList, idx = 0; pjPtr; ) {
// If we're an old entry, then delete it.
//
if (pjm_IsOldEntry (pjPtr)) {
// No remote job ID and the state is not spooling
// It is an old entry, delete it
pjDel = pjPtr;
if (pjPtr == *pjmList) {
*pjmList = pjPtr->pNext;
pjPtr = *pjmList;
pjPrv = *pjmList;
} else {
pjPrv->pNext = pjPtr->pNext;
pjPtr = pjPrv->pNext;
}
pjm_DelEntry(pjDel);
} else {
pjPrv = pjPtr;
pjPtr = pjPtr->pNext;
}
// If we've iterated 1000 jobs in this list, then we've
// either got a very heavily taxed print-system, or we
// may have an infinite loop.
//
if (idx++ >= g_dwJobLimit) {
DBG_MSG(DBG_LEV_ERROR, (TEXT("Warn : pjmWalk : Looped 1000 jobs, possible infinite loop")));
return;
}
}
}
/*****************************************************************************\
* pjmDelList
*
*
\*****************************************************************************/
VOID pjmDelList(
PJOBMAP pjmList)
{
PJOBMAP pjPtr;
semCheckCrit();
for (pjPtr = pjmList; pjPtr; ) {
pjmList = pjPtr->pNext;
pjm_DelEntry(pjPtr);
pjPtr = pjmList;
}
}
/*****************************************************************************\
* pjmSetState
*
* Set the state of the job-entry. If we're setting this to spooling-state,
* then we go through the extra-trouble of setting up a spool-file entry as
* well.
*
\*****************************************************************************/
BOOL pjmSetState(
PJOBMAP pjm,
DWORD dwState)
{
DWORD fType;
BOOL bSet = FALSE;
semCheckCrit();
if (pjm) {
// If the caller is setting the job into spooling-state, then
// we need to create a spool-file. If this state is already
// set, then ignore this particular call.
//
if ((dwState & PJM_SPOOLING) && !pjmChkState(pjm, PJM_SPOOLING)) {
// Determine the type of spl-file to open. If PJM_NOOPEN
// is specified, then we will close the file-handle so that
// other processes can obtain exclusive access (i.e. AddJob,
// and ScheduleJob require this).
//
fType = (dwState & PJM_NOOPEN ? SPLFILE_TMP : SPLFILE_SPL);
// Allocate the spool-file, and close if necessary.
//
if (pjm->hSplFile = SplCreate(pjm->idJobLocal, fType)) {
if (dwState & PJM_NOOPEN)
SplClose(pjm->hSplFile);
bSet = TRUE;
} else {
goto EndSet;
}
} else {
bSet = TRUE;
}
// Set the state.
//
pjm->dwState |= dwState;
}
EndSet:
return bSet;
}
/*****************************************************************************\
* pjmClrState
*
* Clear the state specified in the job-entry. If we're turning of spooling,
* then we need to free up the spool-file-object.
*
\*****************************************************************************/
VOID pjmClrState(
PJOBMAP pjm,
DWORD dwState)
{
semCheckCrit();
if (pjm) {
// If the caller is turning off spooling, then we need to
// clean our spool-file resources. If there is no spooling
// going on, then ignore.
//
if ((dwState & PJM_SPOOLING) && pjmChkState(pjm, PJM_SPOOLING)) {
// Clean our spooling-file resources.
//
SplFree(pjm->hSplFile);
pjm->hSplFile = NULL;
}
// Clear the state.
//
pjm->dwState &= ~dwState;
}
}
/*****************************************************************************\
* pjmSetJobRemote
*
* Set the remote-job-id into the job-entry. This is usually called once
* the job-id is obtained from the print-server. We will maintain this for
* local/remote job-mapping.
*
\*****************************************************************************/
VOID pjmSetJobRemote(
PJOBMAP pjm,
DWORD idJobRemote,
LPCTSTR lpszUri)
{
semCheckCrit();
if (pjm) {
// If we had a previous job-url, then we need to free it
// before reseting it with the new.
//
if (pjm->lpszUri)
memFreeStr(pjm->lpszUri);
// Store remote-job information.
//
pjm->idJobRemote = idJobRemote;
pjm->lpszUri = memAllocStr(lpszUri);
pjm->bRemoteJob = TRUE;
}
}
/*****************************************************************************\
* pjmAddJobSize
*
* Add the job size to the local job info. This is usually called by
* PPWritePrinter
*
\*****************************************************************************/
VOID pjmAddJobSize(
PJOBMAP pjm,
DWORD dwSize)
{
semCheckCrit();
if (pjm) {
pjm->dwLocalJobSize += dwSize;
}
}
/*****************************************************************************\
* pjmSplLock
*
* Lock the spool-file for reading. This returns a file-map pointer to the
* caller.
*
\*****************************************************************************/
CFileStream* pjmSplLock(
PJOBMAP pjm)
{
CFileStream *pStream = NULL;
semCheckCrit();
if (pjm) {
// If the state of our spool-object requires that we not
// keep open-handles on the file, then we need to open
// it here. This is closed at pjmSplUnlock().
//
if (pjmChkState(pjm, PJM_NOOPEN))
SplOpen(pjm->hSplFile);
pStream = SplLock(pjm->hSplFile);
}
return pStream;
}
/*****************************************************************************\
* pjmSplUnlock
*
* This unlocks our file-mapped-pointer on the spool-file.
*
\*****************************************************************************/
BOOL pjmSplUnlock(
PJOBMAP pjm)
{
BOOL bRet = FALSE;
semCheckCrit();
// The spool-file must have already been locked in order to proceed
// with this call.
//
if (pjm) {
// Unlock the spool-file.
//
bRet = SplUnlock(pjm->hSplFile);
// If the state of our spool-object requires that
// we keep no open-handles, then we need to close
// the spool-handle.
//
if (pjmChkState(pjm, PJM_NOOPEN))
SplClose(pjm->hSplFile);
}
return bRet;
}
/*****************************************************************************\
* pjmSplWrite
*
* Write out data to the spool-file.
*
\*****************************************************************************/
BOOL pjmSplWrite(
PJOBMAP pjm,
LPVOID lpMem,
DWORD cbMem,
LPDWORD lpcbWr)
{
BOOL bRet = FALSE;
semCheckCrit();
if (pjm) {
if (pjmChkState(pjm, PJM_NOOPEN))
SplOpen(pjm->hSplFile);
bRet = SplWrite(pjm->hSplFile, (LPBYTE) lpMem, cbMem, lpcbWr);
if (pjmChkState(pjm, PJM_NOOPEN))
SplClose(pjm->hSplFile);
}
return bRet;
}
/*****************************************************************************\
* pjmSetState
*
* Set the status of the local job-entry.
*
\*****************************************************************************/
VOID pjmUpdateLocalJobStatus(
PJOBMAP pjm,
DWORD dwStatus)
{
semCheckCrit();
if (pjm) {
pjm->dwStatus = dwStatus;
}
}