main.c File Reference

#include "precomp.h"

Include dependency graph for main.c:

Go to the source code of this file.

Functions
ClosePrintProcessor
Closes a Print Processor Handle that has previously been opened through OpenPrintProcessor. Parameters hPrintProcessor The return value of a previous successful OpenPrintProcessor call. Returns TRUE if the Print Processor Handle was successfully closed, FALSE otherwise. A more specific error code can be obtained through GetLastError.
BOOL WINAPI	ClosePrintProcessor (HANDLE hPrintProcessor)
BOOL WINAPI	ControlPrintProcessor (HANDLE hPrintProcessor, DWORD Command)
EnumPrintProcessorDatatypesW
Obtains an array of all datatypes supported by this Print Processor. Parameters pName Server Name. Ignored here, because every caller of EnumPrintProcessorDatatypesW is interested in this Print Processor's information. pPrintProcessorName Print Processor Name. Ignored here, because every caller of EnumPrintProcessorDatatypesW is interested in this Print Processor's information. Level The level of the structure supplied through pDatatypes. This must be 1. pDatatypes Pointer to the buffer that receives an array of DATATYPES_INFO_1W structures. Can be NULL if you just want to know the required size of the buffer. cbBuf Size of the buffer you supplied for pDatatypes, in bytes. pcbNeeded Pointer to a variable that receives the required size of the buffer for pDatatypes, in bytes. This parameter mustn't be NULL! pcReturned Pointer to a variable that receives the number of elements of the DATATYPES_INFO_1W array. This parameter mustn't be NULL! Returns TRUE if we successfully copied the array into pDatatypes, FALSE otherwise. A more specific error code can be obtained through GetLastError.
BOOL WINAPI	EnumPrintProcessorDatatypesW (PWSTR pName, PWSTR pPrintProcessorName, DWORD Level, PBYTE pDatatypes, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
DWORD WINAPI	GetPrintProcessorCapabilities (PWSTR pValueName, DWORD dwAttributes, PBYTE pData, DWORD nSize, PDWORD pcbNeeded)
OpenPrintProcessor
Prepares this Print Processor for processing a document. Parameters pPrinterName String in the format "\\COMPUTERNAME\Port:, Port" that is passed to OpenPrinterW for writing to the Print Monitor on the specified port. pPrintProcessorOpenData Pointer to a PRINTPROCESSOROPENDATA structure containing details about the print job to be processed. Returns A Print Processor handle on success or NULL in case of a failure. This handle has to be passed to PrintDocumentOnPrintProcessor to do the actual processing. A more specific error code can be obtained through GetLastError.
HANDLE WINAPI	OpenPrintProcessor (PWSTR pPrinterName, PPRINTPROCESSOROPENDATA pPrintProcessorOpenData)
PrintDocumentOnPrintProcessor
Prints a document on this Print Processor after a handle for the document has been opened through OpenPrintProcessor. Parameters hPrintProcessor The return value of a previous successful OpenPrintProcessor call. pDocumentName String in the format "Printer, Job N" describing the spooled job that is to be processed. Returns TRUE if the document was successfully processed by this Print Processor, FALSE otherwise. A more specific error code can be obtained through GetLastError.
BOOL WINAPI	PrintDocumentOnPrintProcessor (HANDLE hPrintProcessor, PWSTR pDocumentName)

Variables
static PCWSTR	_pwszDatatypes []

Function Documentation

ClosePrintProcessor()

BOOL WINAPI ClosePrintProcessor

(

HANDLE

hPrintProcessor

)

Definition at line 30 of file main.c.

{
    DWORD dwErrorCode;
    PWINPRINT_HANDLE pHandle;
 
    TRACE("ClosePrintProcessor(%p)\n", hPrintProcessor);
 
    // Sanity checks
    if (!hPrintProcessor)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pHandle = (PWINPRINT_HANDLE)hPrintProcessor;
 
    // Free all structure fields for which memory has been allocated.
    if (pHandle->pwszDatatype)
        DllFreeSplStr(pHandle->pwszDatatype);
 
    if (pHandle->pwszDocumentName)
        DllFreeSplStr(pHandle->pwszDocumentName);
 
    if (pHandle->pwszOutputFile)
        DllFreeSplStr(pHandle->pwszOutputFile);
 
    if (pHandle->pwszPrinterPort)
        DllFreeSplStr(pHandle->pwszPrinterPort);
 
    // Finally free the WINSPOOL_HANDLE structure itself.
    DllFreeSplMem(pHandle);
    dwErrorCode = ERROR_SUCCESS;
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

ControlPrintProcessor()

BOOL WINAPI ControlPrintProcessor	(	HANDLE	hPrintProcessor,
		DWORD	Command
	)

Definition at line 69 of file main.c.

{
    TRACE("ControlPrintProcessor(%p, %lu)\n", hPrintProcessor, Command);
 
    UNIMPLEMENTED;
    return FALSE;
}

EnumPrintProcessorDatatypesW()

BOOL WINAPI EnumPrintProcessorDatatypesW	(	PWSTR	pName,
		PWSTR	pPrintProcessorName,
		DWORD	Level,
		PBYTE	pDatatypes,
		DWORD	cbBuf,
		PDWORD	pcbNeeded,
		PDWORD	pcReturned
	)

Definition at line 111 of file main.c.

{
    DWORD cbDatatype;
    DWORD dwDatatypeCount = 0;
    DWORD dwOffsets[_countof(_pwszDatatypes)];
    PCWSTR* pCurrentDatatype;
    PDWORD pCurrentOffset = dwOffsets;
 
    TRACE("EnumPrintProcessorDatatypesW(%S, %S, %lu, %p, %lu, %p, %p)\n", pName, pPrintProcessorName, Level, pDatatypes, cbBuf, pcbNeeded, pcReturned);
 
    // Sanity checks
    if (Level != 1 || !pcbNeeded || !pcReturned)
        return FALSE;
 
    // Count the required buffer size and the number of datatypes.
    *pcbNeeded = 0;
    *pcReturned = 0;
 
    for (pCurrentDatatype = _pwszDatatypes; *pCurrentDatatype; pCurrentDatatype++)
    {
        cbDatatype = (wcslen(*pCurrentDatatype) + 1) * sizeof(WCHAR);
        *pcbNeeded += sizeof(DATATYPES_INFO_1W) + cbDatatype;
 
        // Also calculate the offset in the output buffer of the pointer to this datatype string.
        *pCurrentOffset = dwDatatypeCount * sizeof(DATATYPES_INFO_1W) + FIELD_OFFSET(DATATYPES_INFO_1W, pName);
 
        dwDatatypeCount++;
        pCurrentOffset++;
    }
 
    // Check if the supplied buffer is large enough.
    if (cbBuf < *pcbNeeded)
    {
        SetLastError(ERROR_INSUFFICIENT_BUFFER);
        return FALSE;
    }
 
    // Check if a buffer was supplied at all.
    if (!pDatatypes)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    // Copy over all datatypes.
    *pCurrentOffset = MAXDWORD;
    PackStrings(_pwszDatatypes, pDatatypes, dwOffsets, &pDatatypes[*pcbNeeded]);
 
    *pcReturned = dwDatatypeCount;
    return TRUE;
}

GetPrintProcessorCapabilities()

DWORD WINAPI GetPrintProcessorCapabilities	(	PWSTR	pValueName,
		DWORD	dwAttributes,
		PBYTE	pData,
		DWORD	nSize,
		PDWORD	pcbNeeded
	)

Definition at line 165 of file main.c.

{
    TRACE("GetPrintProcessorCapabilities(%S, %lu, %p, %lu, %p)\n", pValueName, dwAttributes, pData, nSize, pcbNeeded);
 
    UNIMPLEMENTED;
    return 0;
}

OpenPrintProcessor()

HANDLE WINAPI OpenPrintProcessor	(	PWSTR	pPrinterName,
		PPRINTPROCESSOROPENDATA	pPrintProcessorOpenData
	)

Definition at line 189 of file main.c.

{
    DWORD dwErrorCode;
    HANDLE hReturnValue = NULL;
    PWINPRINT_HANDLE pHandle = NULL;
 
    TRACE("OpenPrintProcessor(%S, %p)\n", pPrinterName, pPrintProcessorOpenData);
 
    // Sanity checks
    // This time a datatype needs to be given. We can't fall back to a default here.
    if (!pPrintProcessorOpenData || !pPrintProcessorOpenData->pDatatype || !*pPrintProcessorOpenData->pDatatype)
    {
        dwErrorCode = ERROR_INVALID_PARAMETER;
        goto Cleanup;
    }
 
    // Create a new WINPRINT_HANDLE structure and fill the relevant fields.
    pHandle = DllAllocSplMem(sizeof(WINPRINT_HANDLE));
 
    // Check what datatype was given.
    if (_wcsicmp(pPrintProcessorOpenData->pDatatype, L"RAW") == 0)
    {
        pHandle->Datatype = RAW;
    }
    else
    {
        dwErrorCode = ERROR_INVALID_DATATYPE;
        goto Cleanup;
    }
 
    // Fill the relevant fields.
    pHandle->dwJobID = pPrintProcessorOpenData->JobId;
    pHandle->pwszDatatype = AllocSplStr(pPrintProcessorOpenData->pDatatype);
    pHandle->pwszDocumentName = AllocSplStr(pPrintProcessorOpenData->pDocumentName);
    pHandle->pwszOutputFile = AllocSplStr(pPrintProcessorOpenData->pOutputFile);
    pHandle->pwszPrinterPort = AllocSplStr(pPrinterName);
 
    // We were successful! Return the handle and don't let the cleanup routine free it.
    dwErrorCode = ERROR_SUCCESS;
    hReturnValue = pHandle;
    pHandle = NULL;
 
Cleanup:
    if (pHandle)
        DllFreeSplMem(pHandle);
 
    SetLastError(dwErrorCode);
    return hReturnValue;
}

PrintDocumentOnPrintProcessor()

BOOL WINAPI PrintDocumentOnPrintProcessor	(	HANDLE	hPrintProcessor,
		PWSTR	pDocumentName
	)

Definition at line 255 of file main.c.

{
    DWORD dwErrorCode;
    PWINPRINT_HANDLE pHandle;
 
    TRACE("PrintDocumentOnPrintProcessor(%p, %S)\n", hPrintProcessor, pDocumentName);
 
    // Sanity checks
    if (!hPrintProcessor)
    {
        dwErrorCode = ERROR_INVALID_HANDLE;
        goto Cleanup;
    }
 
    pHandle = (PWINPRINT_HANDLE)hPrintProcessor;
 
    // Call the corresponding Print function for the datatype.
    if (pHandle->Datatype == RAW)
        dwErrorCode = PrintRawJob(pHandle, pDocumentName);
 
Cleanup:
    SetLastError(dwErrorCode);
    return (dwErrorCode == ERROR_SUCCESS);
}

Variable Documentation

_pwszDatatypes

PCWSTR _pwszDatatypes[]

static

Initial value:

= {
    L"RAW",
    0
}

Definition at line 11 of file main.c.

Referenced by EnumPrintProcessorDatatypesW().