[PRINTING]
[reactos.git] / reactos / win32ss / printing / processors / winprint / main.c
1 /*
2 * PROJECT: ReactOS Standard Print Processor
3 * LICENSE: GNU LGPL v2.1 or any later version as published by the Free Software Foundation
4 * PURPOSE: Main functions
5 * COPYRIGHT: Copyright 2015-2017 Colin Finck <colin@reactos.org>
6 */
7
8 #include "precomp.h"
9
10 // Local Constants
11 static PWSTR _pwszDatatypes[] = {
12 L"RAW",
13 0
14 };
15
16
17 /**
18 * @name ClosePrintProcessor
19 *
20 * Closes a Print Processor Handle that has previously been opened through OpenPrintProcessor.
21 *
22 * @param hPrintProcessor
23 * The return value of a previous successful OpenPrintProcessor call.
24 *
25 * @return
26 * TRUE if the Print Processor Handle was successfully closed, FALSE otherwise.
27 * A more specific error code can be obtained through GetLastError.
28 */
29 BOOL WINAPI
30 ClosePrintProcessor(HANDLE hPrintProcessor)
31 {
32 DWORD dwErrorCode;
33 PWINPRINT_HANDLE pHandle;
34
35 TRACE("ClosePrintProcessor(%p)\n", hPrintProcessor);
36
37 // Sanity checks
38 if (!hPrintProcessor)
39 {
40 dwErrorCode = ERROR_INVALID_HANDLE;
41 goto Cleanup;
42 }
43
44 pHandle = (PWINPRINT_HANDLE)hPrintProcessor;
45
46 // Free all structure fields for which memory has been allocated.
47 if (pHandle->pwszDatatype)
48 DllFreeSplStr(pHandle->pwszDatatype);
49
50 if (pHandle->pwszDocumentName)
51 DllFreeSplStr(pHandle->pwszDocumentName);
52
53 if (pHandle->pwszOutputFile)
54 DllFreeSplStr(pHandle->pwszOutputFile);
55
56 if (pHandle->pwszPrinterPort)
57 DllFreeSplStr(pHandle->pwszPrinterPort);
58
59 // Finally free the WINSPOOL_HANDLE structure itself.
60 DllFreeSplMem(pHandle);
61 dwErrorCode = ERROR_SUCCESS;
62
63 Cleanup:
64 SetLastError(dwErrorCode);
65 return (dwErrorCode == ERROR_SUCCESS);
66 }
67
68 BOOL WINAPI
69 ControlPrintProcessor(HANDLE hPrintProcessor, DWORD Command)
70 {
71 TRACE("ControlPrintProcessor(%p, %lu)\n", hPrintProcessor, Command);
72
73 UNIMPLEMENTED;
74 return FALSE;
75 }
76
77 /**
78 * @name EnumPrintProcessorDatatypesW
79 *
80 * Obtains an array of all datatypes supported by this Print Processor.
81 *
82 * @param pName
83 * Server Name. Ignored here, because every caller of EnumPrintProcessorDatatypesW is interested in this Print Processor's information.
84 *
85 * @param pPrintProcessorName
86 * Print Processor Name. Ignored here, because every caller of EnumPrintProcessorDatatypesW is interested in this Print Processor's information.
87 *
88 * @param Level
89 * The level of the structure supplied through pDatatypes. This must be 1.
90 *
91 * @param pDatatypes
92 * Pointer to the buffer that receives an array of DATATYPES_INFO_1W structures.
93 * Can be NULL if you just want to know the required size of the buffer.
94 *
95 * @param cbBuf
96 * Size of the buffer you supplied for pDatatypes, in bytes.
97 *
98 * @param pcbNeeded
99 * Pointer to a variable that receives the required size of the buffer for pDatatypes, in bytes.
100 * This parameter mustn't be NULL!
101 *
102 * @param pcReturned
103 * Pointer to a variable that receives the number of elements of the DATATYPES_INFO_1W array.
104 * This parameter mustn't be NULL!
105 *
106 * @return
107 * TRUE if we successfully copied the array into pDatatypes, FALSE otherwise.
108 * A more specific error code can be obtained through GetLastError.
109 */
110 BOOL WINAPI
111 EnumPrintProcessorDatatypesW(PWSTR pName, PWSTR pPrintProcessorName, DWORD Level, PBYTE pDatatypes, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
112 {
113 DWORD cbDatatype;
114 DWORD dwDatatypeCount = 0;
115 DWORD dwOffsets[_countof(_pwszDatatypes)];
116 PWSTR* pCurrentDatatype;
117 PDWORD pCurrentOffset = dwOffsets;
118
119 TRACE("EnumPrintProcessorDatatypesW(%S, %S, %lu, %p, %lu, %p, %p)\n", pName, pPrintProcessorName, Level, pDatatypes, cbBuf, pcbNeeded, pcReturned);
120
121 // Sanity checks
122 if (Level != 1 || !pcbNeeded || !pcReturned)
123 return FALSE;
124
125 // Count the required buffer size and the number of datatypes.
126 *pcbNeeded = 0;
127 *pcReturned = 0;
128
129 for (pCurrentDatatype = _pwszDatatypes; *pCurrentDatatype; pCurrentDatatype++)
130 {
131 cbDatatype = (wcslen(*pCurrentDatatype) + 1) * sizeof(WCHAR);
132 *pcbNeeded += sizeof(DATATYPES_INFO_1W) + cbDatatype;
133
134 // Also calculate the offset in the output buffer of the pointer to this datatype string.
135 *pCurrentOffset = dwDatatypeCount * sizeof(DATATYPES_INFO_1W) + FIELD_OFFSET(DATATYPES_INFO_1W, pName);
136
137 dwDatatypeCount++;
138 pCurrentOffset++;
139 }
140
141 // Check if the supplied buffer is large enough.
142 if (cbBuf < *pcbNeeded)
143 {
144 SetLastError(ERROR_INSUFFICIENT_BUFFER);
145 return FALSE;
146 }
147
148 // Check if a buffer was supplied at all.
149 if (!pDatatypes)
150 {
151 SetLastError(ERROR_INVALID_PARAMETER);
152 return FALSE;
153 }
154
155 // Copy over all datatypes.
156 *pCurrentOffset = MAXDWORD;
157 PackStrings(_pwszDatatypes, pDatatypes, dwOffsets, &pDatatypes[*pcbNeeded]);
158
159 *pcReturned = dwDatatypeCount;
160 return TRUE;
161 }
162
163
164 DWORD WINAPI
165 GetPrintProcessorCapabilities(PWSTR pValueName, DWORD dwAttributes, PBYTE pData, DWORD nSize, PDWORD pcbNeeded)
166 {
167 TRACE("GetPrintProcessorCapabilities(%S, %lu, %p, %lu, %p)\n", pValueName, dwAttributes, pData, nSize, pcbNeeded);
168
169 UNIMPLEMENTED;
170 return 0;
171 }
172
173 /**
174 * @name OpenPrintProcessor
175 *
176 * Prepares this Print Processor for processing a document.
177 *
178 * @param pPrinterName
179 * String in the format "\\COMPUTERNAME\Port:, Port" that is passed to OpenPrinterW for writing to the Print Monitor on the specified port.
180 *
181 * @param pPrintProcessorOpenData
182 * Pointer to a PRINTPROCESSOROPENDATA structure containing details about the print job to be processed.
183 *
184 * @return
185 * 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.
186 * A more specific error code can be obtained through GetLastError.
187 */
188 HANDLE WINAPI
189 OpenPrintProcessor(PWSTR pPrinterName, PPRINTPROCESSOROPENDATA pPrintProcessorOpenData)
190 {
191 DWORD dwErrorCode;
192 HANDLE hReturnValue = NULL;
193 PWINPRINT_HANDLE pHandle = NULL;
194
195 TRACE("OpenPrintProcessor(%S, %p)\n", pPrinterName, pPrintProcessorOpenData);
196
197 // Sanity checks
198 // This time a datatype needs to be given. We can't fall back to a default here.
199 if (!pPrintProcessorOpenData || !pPrintProcessorOpenData->pDatatype || !*pPrintProcessorOpenData->pDatatype)
200 {
201 dwErrorCode = ERROR_INVALID_PARAMETER;
202 goto Cleanup;
203 }
204
205 // Create a new WINPRINT_HANDLE structure and fill the relevant fields.
206 pHandle = DllAllocSplMem(sizeof(WINPRINT_HANDLE));
207
208 // Check what datatype was given.
209 if (wcsicmp(pPrintProcessorOpenData->pDatatype, L"RAW") == 0)
210 {
211 pHandle->Datatype = RAW;
212 }
213 else
214 {
215 dwErrorCode = ERROR_INVALID_DATATYPE;
216 goto Cleanup;
217 }
218
219 // Fill the relevant fields.
220 pHandle->dwJobID = pPrintProcessorOpenData->JobId;
221 pHandle->pwszDatatype = AllocSplStr(pPrintProcessorOpenData->pDatatype);
222 pHandle->pwszDocumentName = AllocSplStr(pPrintProcessorOpenData->pDocumentName);
223 pHandle->pwszOutputFile = AllocSplStr(pPrintProcessorOpenData->pOutputFile);
224 pHandle->pwszPrinterPort = AllocSplStr(pPrinterName);
225
226 // We were successful! Return the handle and don't let the cleanup routine free it.
227 dwErrorCode = ERROR_SUCCESS;
228 hReturnValue = pHandle;
229 pHandle = NULL;
230
231 Cleanup:
232 if (pHandle)
233 DllFreeSplMem(pHandle);
234
235 SetLastError(dwErrorCode);
236 return hReturnValue;
237 }
238
239 /**
240 * @name PrintDocumentOnPrintProcessor
241 *
242 * Prints a document on this Print Processor after a handle for the document has been opened through OpenPrintProcessor.
243 *
244 * @param hPrintProcessor
245 * The return value of a previous successful OpenPrintProcessor call.
246 *
247 * @param pDocumentName
248 * String in the format "Printer, Job N" describing the spooled job that is to be processed.
249 *
250 * @return
251 * TRUE if the document was successfully processed by this Print Processor, FALSE otherwise.
252 * A more specific error code can be obtained through GetLastError.
253 */
254 BOOL WINAPI
255 PrintDocumentOnPrintProcessor(HANDLE hPrintProcessor, PWSTR pDocumentName)
256 {
257 DWORD dwErrorCode;
258 PWINPRINT_HANDLE pHandle;
259
260 TRACE("PrintDocumentOnPrintProcessor(%p, %S)\n", hPrintProcessor, pDocumentName);
261
262 // Sanity checks
263 if (!hPrintProcessor)
264 {
265 dwErrorCode = ERROR_INVALID_HANDLE;
266 goto Cleanup;
267 }
268
269 pHandle = (PWINPRINT_HANDLE)hPrintProcessor;
270
271 // Call the corresponding Print function for the datatype.
272 if (pHandle->Datatype == RAW)
273 dwErrorCode = PrintRawJob(pHandle, pDocumentName);
274
275 Cleanup:
276 SetLastError(dwErrorCode);
277 return (dwErrorCode == ERROR_SUCCESS);
278 }