able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/print/spooler/inetpp2/server/ppjobs.cxx

2078 lines
54 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*****************************************************************************\
* MODULE: ppjobs.c
*
* This module contains the print-job manipulating routines.
*
*
* Copyright (C) 1996-1997 Microsoft Corporation
* Copyright (C) 1996-1997 Hewlett Packard
*
* History:
* 07-Oct-1996 HWP-Guys Initiated port from win95 to winNT
*
\*****************************************************************************/
#include "precomp.h"
#include "priv.h"
#ifdef WINNT32
BOOL
_ppprn_end_docprinter_async (
PCINETMONPORT pIniPort,
PJOBMAP pjmJob);
#endif
typedef struct _ADDJOB_INFO_2W {
LPWSTR pData;
DWORD JobId;
} ADDJOB_INFO_2W, *PADDJOB_INFO_2W, *LPADDJOB_INFO_2W;
DWORD
ppjob_GetOneSize (
DWORD dwLevel)
{
DWORD cbIdx;
switch (dwLevel) {
case PRINT_LEVEL_1:
cbIdx = sizeof(JOB_INFO_1);
break;
case PRINT_LEVEL_2:
cbIdx = sizeof(JOB_INFO_2);
break;
case PRINT_LEVEL_3:
cbIdx = sizeof(JOB_INFO_3);
break;
}
return cbIdx;
}
/*****************************************************************************\
* ppjob_IppPrtRsp (Local Routine)
*
* Retrieves a get response from the IPP server. Our (pjmJob) in the
* parameter list references a job-entry.
*
\*****************************************************************************/
BOOL CALLBACK ppjob_IppPrtRsp(
CAnyConnection *pConnection,
HINTERNET hJobReq,
PCINETMONPORT pIniPort,
PJOBMAP pjmJob)
{
HANDLE hIpp;
DWORD dwRet;
DWORD cbRd;
LPBYTE lpDta;
DWORD cbDta;
LPIPPRET_JOB lpRsp;
DWORD cbRsp;
BYTE bBuf[MAX_IPP_BUFFER];
BOOL bRet = FALSE;
if (hIpp = WebIppRcvOpen(IPP_RET_PRINTJOB)) {
while (TRUE) {
cbRd = 0;
if (pIniPort->ReadFile ( pConnection, hJobReq, (LPVOID)bBuf, sizeof(bBuf), &cbRd) && cbRd) {
dwRet = WebIppRcvData(hIpp, bBuf, cbRd, (LPBYTE*)&lpRsp, &cbRsp, &lpDta, &cbDta);
switch (dwRet) {
case WEBIPP_OK:
if (bRet = lpRsp->bRet) {
// Set the remote-job-id to the job-entry. This
// entry was added at the time the spool-job-file
// was created.
//
semEnterCrit();
pjmSetJobRemote(pjmJob, lpRsp->ji.ji2.JobId, lpRsp->ji.ipp.pJobUri);
semLeaveCrit();
} else {
// If the job failed to open on the server, then
// we will set the last-error from the server
// response.
//
SetLastError(lpRsp->dwLastError);
}
WebIppFreeMem(lpRsp);
goto EndPrtRsp;
case WEBIPP_MOREDATA:
// Need to do another read to fullfill our header-response.
//
break;
default:
DBG_MSG(DBG_LEV_ERROR, (TEXT("ppjob_IppPrtRsp : Receive Data Error")));
SetLastError(ERROR_INVALID_DATA);
goto EndPrtRsp;
}
} else {
goto EndPrtRsp;
}
}
EndPrtRsp:
WebIppRcvClose(hIpp);
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
return bRet;
}
/*****************************************************************************\
* ppjob_GetJobSize (Local Routine)
*
* Returns the size necessary to hold the jobinfo.
*
\*****************************************************************************/
DWORD ppjob_GetJobSize(
LPJOB_INFO_2 pji2,
DWORD dwLevel)
{
DWORD cbSize;
switch (dwLevel) {
case PRINT_LEVEL_1:
cbSize = sizeof(JOB_INFO_1) +
utlStrSize(pji2->pPrinterName) +
utlStrSize(pji2->pMachineName) +
utlStrSize(pji2->pUserName) +
utlStrSize(pji2->pDocument) +
utlStrSize(pji2->pDatatype) +
utlStrSize(pji2->pStatus);
break;
case PRINT_LEVEL_2:
cbSize = sizeof(JOB_INFO_2) +
utlStrSize(pji2->pPrinterName) +
utlStrSize(pji2->pMachineName) +
utlStrSize(pji2->pUserName) +
utlStrSize(pji2->pDocument) +
utlStrSize(pji2->pNotifyName) +
utlStrSize(pji2->pDatatype) +
utlStrSize(pji2->pPrintProcessor) +
utlStrSize(pji2->pParameters) +
utlStrSize(pji2->pDriverName) +
utlStrSize(pji2->pStatus);
if (pji2->pDevMode)
cbSize += (pji2->pDevMode->dmSize + pji2->pDevMode->dmDriverExtra);
cbSize = (cbSize + sizeof(DWORD)-1) & ~(sizeof(DWORD)-1);
break;
case PRINT_LEVEL_3:
cbSize = sizeof(JOB_INFO_3);
break;
default:
cbSize = 0;
break;
}
return cbSize;
}
/*****************************************************************************\
* ppjob_CopyJob (Local Routine)
*
* Copies a job-info structure to another.
*
\*****************************************************************************/
LPBYTE ppjob_CopyJob(
LPBYTE pbJobDst,
DWORD dwLevel,
LPJOB_INFO_2 pji2Src,
LPBYTE pbEnd)
{
LPJOB_INFO_1 pji1Dst;
LPJOB_INFO_2 pji2Dst;
LPJOB_INFO_3 pji3Dst;
LPJOBMAP pjm;
LPDWORD pOffsets;
DWORD cbDM;
LPTSTR* lpszSrc;
LPTSTR aszSrc[(sizeof(JOB_INFO_2) / sizeof(LPTSTR))];
static DWORD s_JI1Offsets[] = {
offsetof(LPJOB_INFO_1, pPrinterName),
offsetof(LPJOB_INFO_1, pMachineName),
offsetof(LPJOB_INFO_1, pUserName),
offsetof(LPJOB_INFO_1, pDocument),
offsetof(LPJOB_INFO_1, pDatatype),
offsetof(LPJOB_INFO_1, pStatus),
0xFFFFFFFF
};
static DWORD s_JI2Offsets[] = {
offsetof(LPJOB_INFO_2, pPrinterName),
offsetof(LPJOB_INFO_2, pMachineName),
offsetof(LPJOB_INFO_2, pUserName),
offsetof(LPJOB_INFO_2, pDocument),
offsetof(LPJOB_INFO_2, pNotifyName),
offsetof(LPJOB_INFO_2, pDatatype),
offsetof(LPJOB_INFO_2, pPrintProcessor),
offsetof(LPJOB_INFO_2, pParameters),
offsetof(LPJOB_INFO_2, pDriverName),
offsetof(LPJOB_INFO_2, pDevMode),
offsetof(LPJOB_INFO_2, pStatus),
offsetof(LPJOB_INFO_2, pSecurityDescriptor),
0xFFFFFFFF
};
static DWORD s_JI3Offsets[]={0xFFFFFFFF};
// Set the start of the string-buffer.
//
ZeroMemory((PVOID)aszSrc, sizeof(aszSrc));
lpszSrc = aszSrc;
// Process the appropriate structure.
//
switch (dwLevel) {
case PRINT_LEVEL_1:
pji1Dst = (LPJOB_INFO_1)pbJobDst;
pOffsets = s_JI1Offsets;
// Copy fixed values.
//
pji1Dst->JobId = pji2Src->JobId;
pji1Dst->Status = pji2Src->Status;
pji1Dst->Priority = pji2Src->Priority;
pji1Dst->Position = pji2Src->Position;
pji1Dst->TotalPages = pji2Src->TotalPages;
pji1Dst->PagesPrinted = pji2Src->PagesPrinted;
pji1Dst->Submitted = pji2Src->Submitted;
// Copy strings.
//
*lpszSrc++ = pji2Src->pPrinterName;
*lpszSrc++ = pji2Src->pMachineName;
*lpszSrc++ = pji2Src->pUserName;
*lpszSrc++ = pji2Src->pDocument;
*lpszSrc++ = pji2Src->pDatatype;
*lpszSrc++ = pji2Src->pStatus;
break;
case PRINT_LEVEL_2:
pji2Dst = (LPJOB_INFO_2)pbJobDst;
pOffsets = s_JI2Offsets;
// Copy fixed values.
//
pji2Dst->JobId = pji2Src->JobId;
pji2Dst->Status = pji2Src->Status;
pji2Dst->Priority = pji2Src->Priority;
pji2Dst->Position = pji2Src->Position;
pji2Dst->StartTime = pji2Src->StartTime;
pji2Dst->UntilTime = pji2Src->UntilTime;
pji2Dst->TotalPages = pji2Src->TotalPages;
pji2Dst->Size = pji2Src->Size;
pji2Dst->Submitted = pji2Src->Submitted;
pji2Dst->Time = pji2Src->Time;
pji2Dst->PagesPrinted = pji2Src->PagesPrinted;
pji2Dst->pSecurityDescriptor = NULL;
pji2Dst->pDevMode = NULL;
// Copy strings.
//
*lpszSrc++ = pji2Src->pPrinterName;
*lpszSrc++ = pji2Src->pMachineName;
*lpszSrc++ = pji2Src->pUserName;
*lpszSrc++ = pji2Src->pDocument;
*lpszSrc++ = pji2Src->pNotifyName;
*lpszSrc++ = pji2Src->pDatatype;
*lpszSrc++ = pji2Src->pPrintProcessor;
*lpszSrc++ = pji2Src->pParameters;
*lpszSrc++ = pji2Src->pDriverName;
*lpszSrc++ = NULL;
*lpszSrc++ = pji2Src->pStatus;
*lpszSrc++ = NULL;
if (pji2Src->pDevMode) {
cbDM = pji2Src->pDevMode->dmSize + pji2Src->pDevMode->dmDriverExtra;
pbEnd -= cbDM;
pbEnd = (LPBYTE)((UINT_PTR)pbEnd & ~((UINT_PTR)sizeof(UINT_PTR) - 1));
pji2Dst->pDevMode = (LPDEVMODE)pbEnd;
CopyMemory(pji2Dst->pDevMode, pji2Src->pDevMode, cbDM);
}
break;
case PRINT_LEVEL_3:
pji3Dst = (LPJOB_INFO_3)pbJobDst;
pOffsets = s_JI3Offsets;
pji3Dst->JobId = pji2Src->JobId;
break;
}
return utlPackStrings(aszSrc, (LPBYTE)pbJobDst, pOffsets, pbEnd);
}
BOOL ppjob_CalcAndCopyJob(
LPBYTE pbJob,
DWORD cbJob,
PDWORD pcbNeed,
PJOB_INFO_2 pji2,
DWORD dwLevel)
{
BOOL bRet = FALSE;
LPBYTE pbEnd;
// Fill in what we need.
//
*pcbNeed = ppjob_GetJobSize(pji2, dwLevel);
// If our buffer is big-enough, then
// proceed to fill in the info.
//
if (cbJob >= *pcbNeed) {
pbEnd = pbJob + cbJob;
ppjob_CopyJob(pbJob, dwLevel, pji2, pbEnd);
bRet = TRUE;
} else {
SetLastError (ERROR_INSUFFICIENT_BUFFER);
}
return bRet;
}
/*****************************************************************************\
* ppjob_IppEnuRsp (Local Callback Routine)
*
* Retrieves a get response from the IPP server. Our (lParam) in the
* parameter list references a LPPPJOB_ENUM pointer which we are to fill
* in from the enumeration.
*
\*****************************************************************************/
BOOL CALLBACK ppjob_IppEnuRsp(
CAnyConnection *pConnection,
HINTERNET hReq,
PCINETMONPORT pIniPort,
LPARAM lParam)
{
HANDLE hIpp;
DWORD dwRet;
DWORD cbRd;
LPBYTE pbEnd;
DWORD idx;
DWORD idx2;
LPBYTE lpDta;
DWORD cbDta;
LPIPPRET_ENUJOB lpRsp;
DWORD cbRsp;
LPPPJOB_ENUM pje;
LPIPPJI2 pji2;
LPJOBMAP pjm;
PDWORD pidJob;
DWORD cbSize;
PJOBMAP* pjmList;
BYTE bBuf[MAX_IPP_BUFFER];
BOOL bRet = FALSE;
time_t dwPrinterT0;
if (hIpp = WebIppRcvOpen(IPP_RET_ENUJOB)) {
while (TRUE) {
cbRd = 0;
if (pIniPort->ReadFile ( pConnection, hReq, (LPVOID)bBuf, sizeof(bBuf), &cbRd) && cbRd) {
dwRet = WebIppRcvData(hIpp, bBuf, cbRd, (LPBYTE*)&lpRsp, &cbRsp, &lpDta, &cbDta);
switch (dwRet) {
case WEBIPP_OK:
if (bRet = lpRsp->bRet) {
if (lpRsp->cItems && lpRsp->cbItems) {
semEnterCrit();
pjmList = pIniPort->GetPJMList();
pjmCleanRemoteFlag(pjmList);
pji2 = lpRsp->pItems;
// We go over the IPP response and put them into PJM list
// At the mean time, we convert the remote job ID to
// local job id and store them into the IPP response
// data structure.
//
for (idx = 0; idx < lpRsp->cItems; idx++) {
// Fixup the job-id to the local id we
// can deal with.
//
pidJob = & (pji2[idx].ji2.JobId);
if (pjm = pjmFind(pjmList, PJM_REMOTEID, *pidJob)) {
*pidJob = pjmJobId(pjm, PJM_LOCALID);
} else {
if (pjm = pjmAdd(pjmList, pIniPort, NULL, NULL))
pjmSetJobRemote(pjm, *pidJob, pji2[idx].ipp.pJobUri);
*pidJob = pjmJobId(pjm, PJM_LOCALID);
}
}
// Call our routine to clean our client-list
// of jobs. This will remove any entries
// that no longer exist on the server.
//
cbSize = sizeof(PPJOB_ENUM) + lpRsp->cbItems;
// Allocate storage for enumeration.
//
if (pje = (LPPPJOB_ENUM)memAlloc(cbSize)) {
dwPrinterT0 = pIniPort->GetPowerUpTime();
// This now containts the powerup time for the printer in
// our time
pje->cItems = lpRsp->cItems;
pje->cbSize = lpRsp->cbItems;
pji2 = lpRsp->pItems;
pbEnd = ((LPBYTE)pje->ji2) + pje->cbSize;
for (idx = 0; idx < lpRsp->cItems; idx++) {
pbEnd = ppjob_CopyJob((LPBYTE)&pje->ji2[idx],
2,
&pji2[idx].ji2,
pbEnd);
WebIppConvertSystemTime(&pje->ji2[idx].ji2.Submitted, dwPrinterT0);
}
pjmRemoveOldEntries(pjmList);
semLeaveCrit();
*((LPPPJOB_ENUM *)lParam) = pje;
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
}
else {
//
// This is the case where the job count is 0 on the server
// We still need to allocate the structure so that the client
// enum-job function can merge the localjobs.
//
cbSize = sizeof(PPJOB_ENUM);
// Allocate storage for enumeration.
//
if (pje = (LPPPJOB_ENUM)memAlloc(cbSize)) {
pje->cItems = 0;
pje->cbSize = 0;
*((LPPPJOB_ENUM *)lParam) = pje;
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
}
} else {
SetLastError(lpRsp->dwLastError);
}
WebIppFreeMem(lpRsp);
goto EndEnuRsp;
case WEBIPP_MOREDATA:
// Need to do another read to fullfill our header-response.
//
break;
default:
DBG_MSG(DBG_LEV_ERROR, (TEXT("ppjob_IppEnuRsp : Receive Data Error")));
SetLastError(ERROR_INVALID_DATA);
goto EndEnuRsp;
}
} else {
goto EndEnuRsp;
}
}
EndEnuRsp:
WebIppRcvClose(hIpp);
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
return bRet;
}
/*****************************************************************************\
* ppjob_IppSetRsp (Local Callback Routine)
*
* Retrieves a SetJob response from the IPP server
*
\*****************************************************************************/
BOOL CALLBACK ppjob_IppSetRsp(
CAnyConnection *pConnection,
HINTERNET hReq,
PCINETMONPORT pIniPort,
LPARAM lParam)
{
HANDLE hIpp;
DWORD dwRet;
DWORD cbRd;
LPBYTE lpDta;
DWORD cbDta;
LPIPPRET_JOB lpRsp;
DWORD cbRsp;
BYTE bBuf[MAX_IPP_BUFFER];
BOOL bRet = FALSE;
if (hIpp = WebIppRcvOpen((WORD)(LPARAM)lParam)) {
while (TRUE) {
cbRd = 0;
if (pIniPort->ReadFile (pConnection, hReq, (LPVOID)bBuf, sizeof(bBuf), &cbRd) && cbRd) {
dwRet = WebIppRcvData(hIpp, bBuf, cbRd, (LPBYTE*)&lpRsp, &cbRsp, &lpDta, &cbDta);
switch (dwRet) {
case WEBIPP_OK:
if ((bRet = lpRsp->bRet) == FALSE)
SetLastError(lpRsp->dwLastError);
WebIppFreeMem(lpRsp);
goto EndSetRsp;
case WEBIPP_MOREDATA:
// Need to do another read to fullfill our header-response.
//
break;
default:
DBG_MSG(DBG_LEV_ERROR, (TEXT("ppjob_IppSetRsp : Receive Data Error")));
SetLastError(ERROR_INVALID_DATA);
goto EndSetRsp;
}
} else {
goto EndSetRsp;
}
}
EndSetRsp:
WebIppRcvClose(hIpp);
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
return bRet;
}
/*****************************************************************************\
* ppjob_IppGetRsp (Local Callback Routine)
*
* Retrieves a get response from the IPP server. Our (lParam) in the
* parameter list references a JOB_INFO_2 pointer which we are to fill
* in from the call.
*
\*****************************************************************************/
BOOL CALLBACK ppjob_IppGetRsp(
CAnyConnection *pConnection,
HINTERNET hReq,
PCINETMONPORT pIniPort,
LPARAM lParam)
{
HANDLE hIpp;
DWORD dwRet;
DWORD cbRd;
LPBYTE pbEnd;
DWORD idx;
LPBYTE lpDta;
DWORD cbDta;
LPIPPRET_JOB lpRsp;
DWORD cbRsp;
LPJOB_INFO_2 pji2;
LPJOBMAP pjm;
DWORD cbSize;
BYTE bBuf[MAX_IPP_BUFFER];
PJOBMAP* pjmList;
BOOL bRet = FALSE;
if (hIpp = WebIppRcvOpen(IPP_RET_GETJOB)) {
while (TRUE) {
cbRd = 0;
if (pIniPort->ReadFile ( pConnection, hReq, (LPVOID)bBuf, sizeof(bBuf), &cbRd) && cbRd) {
dwRet = WebIppRcvData(hIpp, bBuf, cbRd, (LPBYTE*)&lpRsp, &cbRsp, &lpDta, &cbDta);
switch (dwRet) {
case WEBIPP_OK:
if (bRet = lpRsp->bRet) {
cbSize = ppjob_GetJobSize(&lpRsp->ji.ji2, 2);
// Allocate storage for enumeration.
//
if (pji2 = (LPJOB_INFO_2)memAlloc(cbSize)) {
pbEnd = ((LPBYTE)pji2) + cbSize;
ppjob_CopyJob((LPBYTE)pji2, 2, &lpRsp->ji.ji2, pbEnd);
semEnterCrit();
pjmList = pIniPort->GetPJMList();
// Fixup the job-id to the local id we
// can deal with.
//
if (pjm = pjmFind(pjmList, PJM_REMOTEID, pji2->JobId)) {
pji2->JobId = pjmJobId(pjm, PJM_LOCALID);
} else {
if (pjm = pjmAdd(pjmList, pIniPort, NULL, NULL))
pjmSetJobRemote(pjm, pji2->JobId, lpRsp->ji.ipp.pJobUri);
pji2->JobId = pjmJobId(pjm, PJM_LOCALID);
}
semLeaveCrit();
*((LPJOB_INFO_2 *)lParam) = pji2;
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
} else {
SetLastError(lpRsp->dwLastError);
}
WebIppFreeMem(lpRsp);
goto EndGetRsp;
case WEBIPP_MOREDATA:
// Need to do another read to fullfill our header-response.
//
break;
default:
DBG_MSG(DBG_LEV_ERROR, (TEXT("ppjob_IppGetRsp - Err : Receive Data Error (dwRet=%d, LE=%d)"),
dwRet, WebIppGetError(hIpp)));
SetLastError(ERROR_INVALID_DATA);
goto EndGetRsp;
}
} else {
goto EndGetRsp;
}
}
EndGetRsp:
WebIppRcvClose(hIpp);
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
return bRet;
}
/*****************************************************************************\
* ppjob_Set (Local Routine)
*
* Sets a job command in the queue.
*
\*****************************************************************************/
BOOL ppjob_Set(
PCINETMONPORT pIniPort,
DWORD idJob,
DWORD dwCmd)
{
PIPPREQ_SETJOB psj;
PJOBMAP pjm;
WORD wReq;
REQINFO ri;
DWORD dwRet;
LPBYTE lpIpp;
DWORD cbIpp;
PJOBMAP* pjmList;
BOOL bRet = FALSE;
// Make sure we have a JobMap entry which we can
// obtain the remote information.
//
pjmList = pIniPort->GetPJMList();
if (pjm = pjmFind(pjmList, PJM_LOCALID, idJob)) {
// If we're still spooling, then we haven't yet
// hit the server. Otherwise, we've performed the EndDoc()
// and the job is being processed remotely.
//
if (pjmChkState(pjm, PJM_SPOOLING)) {
switch (dwCmd) {
case JOB_CONTROL_CANCEL:
case JOB_CONTROL_DELETE:
pjmSetState(pjm, PJM_CANCEL);
#ifdef WINNT32
//
// If the async thread is on, we let that thread to clean the job queue
//
if (!pjmChkState(pjm, PJM_ASYNCON))
{
//
// Otherwise, we delete the job here.
//
pjmClrState (pjm, PJM_SPOOLING);
}
#endif
break;
case JOB_CONTROL_PAUSE:
pjmSetState(pjm, PJM_PAUSE);
break;
case JOB_CONTROL_RESUME:
pjmClrState(pjm, PJM_PAUSE);
break;
case JOB_CONTROL_RESTART:
#ifdef WINNT32
pjmUpdateLocalJobStatus (pjm, JOB_STATUS_RESTART);
if (!pjmChkState(pjm, PJM_ASYNCON))
{
_ppprn_end_docprinter_async (pIniPort, pjm);
}
#else
pjmClrState(pjm, PJM_PAUSE);
#endif
break;
}
bRet = TRUE;
} else {
// Look through list to get local/remote job mappings.
//
psj = WebIppCreateSetJobReq(pjmJobId(pjm, PJM_REMOTEID),
dwCmd,
pIniPort->GetPortName());
if (psj) {
switch (dwCmd) {
case JOB_CONTROL_CANCEL:
case JOB_CONTROL_DELETE:
wReq = IPP_REQ_CANCELJOB;
break;
case JOB_CONTROL_PAUSE:
wReq = IPP_REQ_PAUSEJOB;
break;
case JOB_CONTROL_RESUME:
wReq = IPP_REQ_RESUMEJOB;
break;
case JOB_CONTROL_RESTART:
wReq = IPP_REQ_RESTARTJOB;
break;
default:
wReq = 0;
break;
}
// Convert the reqest to IPP, and perform the
// post.
//
ZeroMemory(&ri, sizeof(REQINFO));
ri.cpReq = CP_UTF8;
ri.idReq = wReq;
ri.fReq[0] = IPP_REQALL;
ri.fReq[1] = IPP_REQALL;
dwRet = WebIppSndData(wReq,
&ri,
(LPBYTE)psj,
psj->cbSize,
&lpIpp,
&cbIpp);
// The request-structure has been converted to IPP format,
// so it is ready to go to the server.
//
if (dwRet == WEBIPP_OK) {
bRet = pIniPort->SendReq(lpIpp,
cbIpp,
ppjob_IppSetRsp,
(LPARAM)(wReq | IPP_RESPONSE),
TRUE);
WebIppFreeMem(lpIpp);
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
// Once we've verified the request for cancel, then
// we should remove the job from our list.
//
// NOTE: Should this be deleted always? Or should
// we make this dependent on the success of
// the server-call?
//
// 06-Jan-1998 <chriswil> Will Revisit.
//
if (dwCmd == JOB_CONTROL_CANCEL)
pjmDel(pjmList, pjm);
WebIppFreeMem(psj);
} else {
SetLastError(ERROR_OUTOFMEMORY);
}
}
} else {
SetLastError(ERROR_INVALID_PARAMETER);
}
return bRet;
}
/*****************************************************************************\
* ppjob_Enum (Local Routine)
*
* Enumerates jobs. IPP has the ENUJOB request which can be used for both
* specific jobs, or enumerated-jobs. We will distinguish whether we're
* enumerating by a (IPP_GETJOB_ALL) job-id.
*
\*****************************************************************************/
BOOL ppjob_Enum(
PCINETMONPORT pIniPort,
DWORD nJobStart,
DWORD cJobs,
DWORD dwLevel,
LPBYTE pbJob,
DWORD cbJob,
LPDWORD pcbNeed,
LPDWORD pcItems)
{
PIPPREQ_ENUJOB pgj;
REQINFO ri;
DWORD dwRet;
LPBYTE lpIpp;
DWORD cbIpp;
DWORD idx;
DWORD cbSize;
DWORD cbIdx;
DWORD dwLastError = ERROR_INVALID_DATA;
LPBYTE pbEnd;
LPPPJOB_ENUM pje = NULL;
BOOL bRet = FALSE;
DWORD curIdx = 0;
DWORD dwLocalJobCount = 0;
DWORD cbLocalJobSize = 0;
PJOBMAP* pjmList;
PJOBMAP pjmTmpList;
JOB_INFO_2 JobInfo2;
BOOL bFound;
// Specifying (IPP_GETJOB_ALL) will enumerate all jobs.
//
pjmList = pIniPort->GetPJMList ();
pbEnd = pbJob + cbJob;
cbIdx = ppjob_GetOneSize (dwLevel);
if (pIniPort->BeginReadEnumJobsCache (&pje)) {
bRet = TRUE;
dwLastError = GetLastError();
// Upon return, our (pje) pointer contains an
// enumeration structure of JOB_INFO_2 items.
//
// Based upon the level passed in, we need to either
// return these items or a converted JOB_INFO_1.
//
if (pje) {
// Calculate the size we'll need to store the
// enumerated items.
//
for (idx = 0, cbSize = 0; idx < pje->cItems; idx++)
cbSize += ppjob_GetJobSize(&pje->ji2[idx].ji2, dwLevel);
dwLocalJobCount = pjmGetLocalJobCount(pjmList, &cbLocalJobSize);
if (dwLocalJobCount > 0) {
cbSize += cbLocalJobSize;
}
// Fill in the return-value indicating
// the buffer necessary to hold the items.
//
*pcbNeed = cbSize;
// If the user buffer is of sufficient size,
// then copy/convert the items.
//
if (cbJob >= cbSize) {
*pcItems = pje->cItems + dwLocalJobCount;
for (idx = 0; idx < pje->cItems && cJobs; idx++) {
if ((idx >= nJobStart)) {
pbEnd = ppjob_CopyJob(pbJob,
dwLevel,
&pje->ji2[idx].ji2,
pbEnd);
pbJob += cbIdx;
cJobs--;
}
}
curIdx = idx;
} else {
bRet = FALSE;
dwLastError = ERROR_INSUFFICIENT_BUFFER;
}
}
}
else {
dwLocalJobCount = pjmGetLocalJobCount(pjmList, &cbLocalJobSize);
if (dwLocalJobCount > 0) {
cbSize = cbLocalJobSize;
// Fill in the return-value indicating
// the buffer necessary to hold the items.
//
*pcbNeed = cbSize;
// If the user buffer is of sufficient size,
// then copy/convert the items.
//
if (cbJob >= cbSize) {
*pcItems = dwLocalJobCount;
bRet = TRUE;
} else {
bRet = FALSE;
dwLastError = ERROR_INSUFFICIENT_BUFFER;
}
}
else {
dwLastError = GetLastError();
}
}
if (bRet) {
pjmTmpList = *pjmList;
for (idx = curIdx; idx < curIdx + dwLocalJobCount && cJobs; idx++) {
pjmTmpList = pjmNextLocalJob (&pjmTmpList, &JobInfo2, &bFound);
if ((idx >= nJobStart)) {
if (bFound) {
DBG_ASSERT( ((pbJob < pbEnd)?TRUE:FALSE),
(TEXT("ppjob_Enum: idx = %d, cbIdx = %d, cJobs = %d dwLocalJobCount = %d dwLocalSize=%d, pjd=%p\n"),
idx, cbIdx, cJobs, dwLocalJobCount, dwLocalJobCount, pje));
pbEnd = ppjob_CopyJob(pbJob,
dwLevel,
&JobInfo2,
pbEnd);
pbJob += cbIdx;
cJobs--;
}
else {
bRet = FALSE;
dwLastError = ERROR_INVALID_PARAMETER;
break;
}
}
}
}
// This function has to be called to release the critical section
//
pIniPort->EndReadEnumJobsCache ();
if (!bRet) {
SetLastError(dwLastError);
}
return bRet;
}
/*****************************************************************************\
* ppjob_EnumForCache (Local Routine)
*
* Enumerates jobs. IPP has the ENUJOB request which can be used for both
* specific jobs, or enumerated-jobs. We will distinguish whether we're
* enumerating by a (IPP_GETJOB_ALL) job-id.
*
* Upon return, ppbJob stores a pointer to the cache
*
\*****************************************************************************/
BOOL ppjob_EnumForCache(
PCINETMONPORT pIniPort,
LPPPJOB_ENUM *ppje)
{
PIPPREQ_ENUJOB pgj;
REQINFO ri;
DWORD dwRet;
LPBYTE lpIpp;
DWORD cbIpp;
DWORD idx;
DWORD cbSize;
DWORD cbIdx;
DWORD dwLastError = ERROR_INVALID_DATA;
LPBYTE pbEnd;
LPPPJOB_ENUM pje = NULL;
BOOL bRet = FALSE;
// Specifying (IPP_GETJOB_ALL) will enumerate all jobs.
//
pgj = WebIppCreateEnuJobReq(IPP_GETJOB_ALL, pIniPort->GetPortName());
if (pgj) {
// Convert the reqest to IPP, and perform the
// post.
//
ZeroMemory(&ri, sizeof(REQINFO));
ri.cpReq = CP_UTF8;
ri.idReq = IPP_REQ_ENUJOB;
ri.fReq[0] = IPP_REQALL;
ri.fReq[1] = IPP_REQALL;
dwRet = WebIppSndData(IPP_REQ_ENUJOB,
&ri,
(LPBYTE)pgj,
pgj->cbSize,
&lpIpp,
&cbIpp);
// The request-structure has been converted to IPP format,
// so it is ready to go to the server.
//
if (dwRet == WEBIPP_OK) {
// This routine returns with a LastError set to that
// which the response-routine sets.
//
if (pIniPort->SendReq(lpIpp,
cbIpp,
ppjob_IppEnuRsp,
(LPARAM)&pje,
TRUE)) {
dwLastError = GetLastError();
bRet = TRUE;
*ppje = pje;
} else {
dwLastError = GetLastError();
}
WebIppFreeMem(lpIpp);
} else {
dwLastError = ERROR_OUTOFMEMORY;
}
WebIppFreeMem(pgj);
} else {
dwLastError = ERROR_OUTOFMEMORY;
}
if (!bRet) {
SetLastError(dwLastError);
}
return bRet;
}
/*****************************************************************************\
* ppjob_Get (Local Routine)
*
* Returns information regarding a job.
*
\*****************************************************************************/
BOOL ppjob_Get(
PCINETMONPORT pIniPort,
DWORD idJob,
DWORD dwLevel,
LPBYTE pbJob,
DWORD cbJob,
LPDWORD pcbNeed)
{
PJOBMAP pjm;
PIPPREQ_GETJOB pgj;
REQINFO ri;
LPBYTE lpIpp;
DWORD cbIpp;
DWORD dwRet;
LPBYTE pbEnd;
PJOBMAP* pjmList;
LPJOB_INFO_2 pji2 = NULL;
BOOL bRet = FALSE;
DWORD dwLastError = ERROR_INVALID_DATA;
// Look in our JobMap list for the local-job-id. If we see
// one, the we can get the job-information.
//
pjmList = pIniPort->GetPJMList();
if (pjm = pjmFind(pjmList, PJM_LOCALID, idJob)) {
if (pjm->bRemoteJob) {
// Build a request-structure that we will pass into
// the IPP layer for processing.
//
pgj = WebIppCreateGetJobReq(pjmJobId(pjm, PJM_REMOTEID), pIniPort->GetPortName());
if (pgj) {
// Convert the reqest to IPP that is suitible for
// our post.
//
ZeroMemory(&ri, sizeof(REQINFO));
ri.cpReq = CP_UTF8;
ri.idReq = IPP_REQ_GETJOB;
ri.fReq[0] = IPP_REQALL;
ri.fReq[1] = IPP_REQALL;
dwRet = WebIppSndData(IPP_REQ_GETJOB,
&ri,
(LPBYTE)pgj,
pgj->cbSize,
&lpIpp,
&cbIpp);
// The request-structure has been converted to IPP format,
// so it is ready to go to the server. We set a callback
// to the function that will receive our data.
//
if (dwRet == WEBIPP_OK) {
pIniPort->SendReq(lpIpp,
cbIpp,
ppjob_IppGetRsp,
(LPARAM)&pji2,
TRUE);
// Upon return, our (pji2) contains the JOB_INFO_2
// structure.
//
if (pji2) {
bRet = ppjob_CalcAndCopyJob(pbJob, cbJob, pcbNeed, pji2, dwLevel);
if (!bRet) {
dwLastError = GetLastError ();
}
memFree(pji2, memGetSize(pji2));
}
WebIppFreeMem(lpIpp);
} else {
dwLastError = ERROR_OUTOFMEMORY;
}
WebIppFreeMem(pgj);
} else {
dwLastError = ERROR_OUTOFMEMORY;
}
}
else {
//
// This is a local job
//
if (pjm = pjmFind(pjmList, PJM_LOCALID, idJob)) {
JOB_INFO_2 JobInfo2;
BOOL bFound;
pjmNextLocalJob(&pjm, &JobInfo2, &bFound);
if (bFound) {
bRet = ppjob_CalcAndCopyJob(pbJob, cbJob, pcbNeed, &JobInfo2, dwLevel);
if (!bRet) {
dwLastError = GetLastError ();
}
}
else
dwLastError = ERROR_INVALID_PARAMETER;
} else {
dwLastError = ERROR_INVALID_PARAMETER;
}
}
} else {
dwLastError = ERROR_INVALID_PARAMETER;
}
// Set the lasterror if failure.
//
if (!bRet) {
SetLastError(dwLastError);
}
return bRet;
}
#ifdef WINNT32
/*****************************************************************************\
* ppjob_Add (Local Routine)
*
* Returns information for an addjob call.
*
\*****************************************************************************/
BOOL ppjob_Add(
HANDLE hPrinter,
PCINETMONPORT pIniPort,
DWORD dwLevel,
LPCTSTR lpszName,
LPBYTE pbData,
DWORD cbBuf,
LPDWORD pcbNeeded)
{
PJOBMAP pjm;
LPCTSTR lpszSplFile;
LPTSTR* lpszSrc;
LPBYTE pbEnd;
PJOBMAP* pjmList;
LPTSTR aszSrc[(sizeof(ADDJOB_INFO_1) / sizeof(LPTSTR))];
BOOL bRet = FALSE;
static DWORD s_AJI1Offsets[] = {
offsetof(LPADDJOB_INFO_1, Path),
0xFFFFFFFF
};
// Create a spool-file and job that we will use
// for this AddJob() call.
//
pjmList = pIniPort->GetPJMList();
if (pjm = pjmAdd(pjmList, pIniPort, lpszName, NULL)) {
// Set the job into spooling-state. This internally
// creates the spool-file. By specifying PJM_NOOPEN,
// we indicate that no open-handles are to be maintained
// on the spool-file.
//
if (pjmSetState(pjm, PJM_SPOOLING | PJM_NOOPEN)) {
// Get the spool-file.
//
lpszSplFile = pjmSplFile(pjm);
// If a return-size is provided, then set it.
//
if (pcbNeeded)
*pcbNeeded = sizeof(ADDJOB_INFO_1) + utlStrSize(lpszSplFile);
// If the buffer is capable of holding the
// return-structure, then proceed.
//
if (pbData && (cbBuf >= *pcbNeeded)) {
// Clean out the string-array and setup
// for building the structure.
//
ZeroMemory((PVOID)aszSrc, sizeof(aszSrc));
lpszSrc = aszSrc;
// Initialize fixed values.
//
((LPADDJOB_INFO_1)pbData)->JobId = pjmJobId(pjm, PJM_LOCALID);
// Pack the file-name into the return-structure.
//
pbEnd = pbData + cbBuf;
*lpszSrc++ = (LPTSTR)lpszSplFile;
utlPackStrings(aszSrc, pbData, s_AJI1Offsets, pbEnd);
// Mark this printer to indicate it's in a
// addjob.
//
// NOTE: do we really need to consume the printer
// for an AddJob(). LocalSpl does this and
// sets the job into the printer. I don't
// see why this is necessary.
//
PP_SetStatus(hPrinter, PP_ADDJOB);
bRet = TRUE;
} else {
SetLastError(ERROR_INSUFFICIENT_BUFFER);
}
} else {
SetLastError(ERROR_FILE_NOT_FOUND);
}
} else {
SetLastError(ERROR_INVALID_HANDLE);
}
return bRet;
}
#endif
#ifdef WINNT32
/*****************************************************************************\
* ppjob_Schedule (Local Routine)
*
* Prints the scheduled job.
*
\*****************************************************************************/
BOOL ppjob_Schedule(
HANDLE hPrinter,
PCINETMONPORT pIniPort,
PJOBMAP pjm)
{
HANDLE hOut;
BOOL bRemote;
LPCTSTR lpszUser;
PIPPREQ_PRTJOB ppj;
REQINFO ri;
LPBYTE pbOut;
LPBYTE pbIpp;
LPBYTE pbSpl;
DWORD cbOut;
DWORD cbIpp;
DWORD cbSpl;
DWORD dwRet;
DWORD cbWr;
PJOBMAP* pjmList;
DWORD dwLE = ERROR_INVALID_HANDLE;
CFileStream *pStream = NULL;
CFileStream *pSplStream = NULL;
BOOL bRet = FALSE;
// Lock the file so we can obtain the spool-data.
//
pjmList = pIniPort->GetPJMList();
if (pSplStream = pjmSplLock(pjm)) {
// Check to determine if this is a remote-call.
//
bRemote = TRUE;
// Get the user-name if one was specified in AddJob().
//
lpszUser = pjmSplUser(pjm);
// Create the print-job-request that we'll be using.
//
ppj = WebIppCreatePrtJobReq(FALSE,
(lpszUser ? lpszUser : TEXT("Unknown")),
(bRemote ? g_szDocRemote: g_szDocLocal),
pIniPort->GetPortName());
if (ppj) {
ZeroMemory(&ri, sizeof(REQINFO));
ri.cpReq = CP_UTF8;
ri.idReq = IPP_REQ_PRINTJOB;
ri.fReq[0] = IPP_REQALL;
ri.fReq[1] = IPP_REQALL;
dwRet = WebIppSndData(IPP_REQ_PRINTJOB,
&ri,
(LPBYTE)ppj,
ppj->cbSize,
&pbIpp,
&cbIpp);
// Make sure we were able to get the ipp-header.
//
if (dwRet == WEBIPP_OK) {
// Create the outputfile that will be used to
// contain both the ipp-header as well as the
// spool-data.
//
if (hOut = SplCreate(pjmJobId(pjm, PJM_LOCALID), SPLFILE_SPL)) {
// Output the header and data.
//
if (SplWrite(hOut, pbIpp, cbIpp, &cbWr) &&
SplWrite(hOut, pSplStream) &&
// Output the request.
//
(pStream = SplLock(hOut))) {
bRet = pIniPort->SendReq(pStream,
(IPPRSPPROC)ppjob_IppPrtRsp,
(LPARAM)pjm,
TRUE);
if (bRet == FALSE)
dwLE = GetLastError();
SplUnlock(hOut);
} else {
dwLE = GetLastError();
}
// Free up the spool-output-file.
//
SplFree(hOut);
} else {
dwLE = GetLastError();
}
WebIppFreeMem(pbIpp);
} else {
dwLE = ERROR_OUTOFMEMORY;
}
WebIppFreeMem(ppj);
} else {
dwLE = ERROR_OUTOFMEMORY;
}
pjmSplUnlock(pjm);
} else {
dwLE = GetLastError();
}
// Clear out our spooling-status. This will close
// and delete the spool-file as the job is now in the
// hands of spooler.
//
pjmClrState(pjm, PJM_SPOOLING);
// If a cancel was set on this job, then delete it's entry from
// our list.
//
if (pjmChkState(pjm, PJM_CANCEL) && pjmList != NULL)
pjmDel(pjmList, pjm);
// Set lasterror if problem occured.
//
if (bRet == FALSE)
SetLastError(dwLE);
return bRet;
}
#endif
/*****************************************************************************\
* PPEnumJobs
*
* Retrives the information about a specified set of print jobs for a
* specified printer. Returns TRUE if successful. Otherwise, it returns
* FALSE.
*
\*****************************************************************************/
BOOL PPEnumJobs(
HANDLE hPrinter,
DWORD nJobStart,
DWORD cJobs,
DWORD dwLevel,
LPBYTE pbJob,
DWORD cbJob,
LPDWORD pcbNeeded,
LPDWORD pcItems)
{
PCINETMONPORT pIniPort;
BOOL bRet = FALSE;
DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPEnumJobs: Printer(%08lX) dwLevel(%d)"), hPrinter, dwLevel));
semEnterCrit();
*pcbNeeded = 0;
*pcItems = 0;
// Make sure we have a valid printer handle.
//
if (pIniPort = utlValidatePrinterHandle(hPrinter)) {
// Attempt to get a list of jobs from the ipp print spooler.
// Format the job information to the requested information level.
//
switch (dwLevel) {
case PRINT_LEVEL_1:
case PRINT_LEVEL_2:
bRet = ppjob_Enum(pIniPort,
nJobStart,
cJobs,
dwLevel,
pbJob,
cbJob,
pcbNeeded,
pcItems);
break;
default:
DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPEnumJobs: Invalid Level (%d)"), dwLevel));
SetLastError(ERROR_INVALID_LEVEL);
break;
}
}
semLeaveCrit();
return bRet;
}
/*****************************************************************************\
* PPGetJob
*
* Retrieves information about a print job on a specified printer. Returns
* TRUE if successful. Otherwise, it returns FASLSE.
*
\*****************************************************************************/
BOOL PPGetJob(
HANDLE hPrinter,
DWORD idJob,
DWORD dwLevel,
LPBYTE pbJob,
DWORD cbJob,
LPDWORD pcbNeed)
{
PCINETMONPORT pIniPort;
BOOL bRet = FALSE;
DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPGetJob: Printer(%08lX) dwLevel(%d)"), hPrinter, dwLevel));
semEnterCrit();
*pcbNeed = 0;
// Make sure we're looking at a valid printer handle.
//
if (pIniPort = utlValidatePrinterHandle(hPrinter)) {
// Switch on print-level.
//
switch (dwLevel) {
case PRINT_LEVEL_1:
case PRINT_LEVEL_2:
bRet = ppjob_Get(pIniPort, idJob, dwLevel, pbJob, cbJob, pcbNeed);
break;
default:
DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPGetJob: Invalid Level (%d)"), dwLevel));
SetLastError(ERROR_INVALID_LEVEL);
break;
}
}
semLeaveCrit();
return bRet;
}
/*****************************************************************************\
* PPSetJob
*
* Sets information for and issues commands to a print job. Returns TRUE
* if successful. Otherwise, it returns FALSE.
*
\*****************************************************************************/
BOOL PPSetJob(
HANDLE hPrinter,
DWORD dwJobId,
DWORD dwLevel,
LPBYTE pbJob,
DWORD dwCmd)
{
PCINETMONPORT pIniPort;
BOOL bResult = FALSE;
DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPSetJob: Printer(%08lX) dwLevel(%d)"), hPrinter, dwLevel));
semEnterCrit();
// Make sure we've got a valid printer handle.
//
if (pIniPort = utlValidatePrinterHandle(hPrinter)) {
#ifdef WINNT32
// Set job parameters.
//
switch (dwLevel) {
case PRINT_LEVEL_0:
// Do not set parameters. (0) represents "no-command".
//
switch (dwCmd) {
case JOB_CONTROL_CANCEL:
case JOB_CONTROL_DELETE:
case JOB_CONTROL_PAUSE:
case JOB_CONTROL_RESUME:
case JOB_CONTROL_RESTART:
bResult = ppjob_Set(pIniPort, dwJobId, dwCmd);
if (bResult) {
// Invalidate has to occur before notfication refresh, otherwise, you
// get an outdated result
//
pIniPort->InvalidateEnumJobsCache ();
pIniPort->InvalidateGetPrinterCache ();
RefreshNotification((LPINET_HPRINTER)hPrinter);
}
break;
case 0:
bResult = TRUE;
break;
}
break;
default:
DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPSetJob: Invalid Level (%d)"), dwLevel));
SetLastError(ERROR_INVALID_LEVEL);
break;
}
#else
if (dwCmd) {
// Do not set parameters. (0) represents "no-command".
//
switch (dwCmd) {
case JOB_CONTROL_CANCEL:
case JOB_CONTROL_DELETE:
case JOB_CONTROL_PAUSE:
case JOB_CONTROL_RESUME:
case JOB_CONTROL_RESTART:
bResult = ppjob_Set(pIniPort, dwJobId, dwCmd);
break;
}
} else {
switch (dwLevel) {
case PRINT_LEVEL_1:
case PRINT_LEVEL_2:
case PRINT_LEVEL_0:
default:
DBG_MSG(DBG_LEV_WARN, (TEXT("Warn: PPSetJob: Invalid Level (%d)"), dwLevel));
SetLastError(ERROR_INVALID_LEVEL);
break;
}
}
#endif
}
semLeaveCrit();
return bResult;
}
/*****************************************************************************\
* PPAddJob
*
* Sets up for a local-spooled job. Since we are truly a remote-printer, we
* need to fail this call and signify the correct error-code.
*
\*****************************************************************************/
BOOL PPAddJob(
HANDLE hPrinter,
DWORD dwLevel,
LPBYTE pbData,
DWORD cbBuf,
LPDWORD pcbNeeded)
{
#ifdef WINNT32
PCINETMONPORT pIniPort;
LPTSTR lpszName;
BOOL bRet = FALSE;
DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPAddJob: Printer(%08lX) dwLevel(%d)"), hPrinter, dwLevel));
// Zero out the return-parameters.
//
*pcbNeeded = 0;
semEnterCrit();
if (pIniPort = utlValidatePrinterHandle(hPrinter)) {
if (pbData && pcbNeeded) {
switch (dwLevel) {
case PRINT_LEVEL_2:
lpszName = (LPTSTR)(pbData + (ULONG_PTR)((LPADDJOB_INFO_2W)pbData)->pData);
// Make sure this string-address does not extend past the
// end of available buffer specified.
//
if (lpszName > (LPTSTR)(pbData + cbBuf)) {
SetLastError(ERROR_INVALID_LEVEL);
goto EndAdd;
}
// Ensure NULL termination.
//
*(PTCHAR)(((ULONG_PTR)(pbData + cbBuf - sizeof(TCHAR))&~1)) = 0;
break;
case PRINT_LEVEL_1:
lpszName = NULL;
break;
default:
SetLastError(ERROR_INVALID_LEVEL);
goto EndAdd;
}
// Do the add.
//
bRet = ppjob_Add(hPrinter,
pIniPort,
dwLevel,
lpszName,
pbData,
cbBuf,
pcbNeeded);
} else {
SetLastError(ERROR_INVALID_PARAMETER);
}
}
EndAdd:
semLeaveCrit();
return bRet;
#else
DBG_MSG(DBG_LEV_ERROR, (TEXT("Err : PPAddJob: Not Supported")));
SetLastError(ERROR_INVALID_NAME);
return FALSE;
#endif
}
/*****************************************************************************\
* PPScheduleJob
*
* This schedules the job. Since we don't support the PPAddJob(), this call
* must fail.
*
\*****************************************************************************/
BOOL PPScheduleJob(
HANDLE hPrinter,
DWORD idJob)
{
#ifdef WINNT32
PCINETMONPORT pIniPort;
PJOBMAP pjm;
PJOBMAP* pjmList;
BOOL bRet = FALSE;
DBG_MSG(DBG_LEV_CALLTREE, (TEXT("Call: PPScheduleJob: Printer(%08lX) idJob(%d)"), hPrinter, idJob));
semEnterCrit();
if (pIniPort = utlValidatePrinterHandle(hPrinter)) {
pjmList = pIniPort->GetPJMList();
if (pjm = pjmFind(pjmList, PJM_LOCALID, idJob)) {
if (pjmChkState(pjm, PJM_SPOOLING)) {
bRet = ppjob_Schedule(hPrinter, pIniPort, pjm);
} else {
SetLastError(ERROR_SPL_NO_ADDJOB);
}
} else {
SetLastError(ERROR_INVALID_PARAMETER);
}
PP_ClrStatus(hPrinter, PP_ADDJOB);
}
semLeaveCrit();
return bRet;
#else
DBG_MSG(DBG_LEV_ERROR, (TEXT("Err : PPScheduleJob: Not Supported")));
SetLastError(ERROR_SPL_NO_ADDJOB);
return FALSE;
#endif
}
Reference in a new issue Copy permalink