[INCLUDE/REACTOS][LOCALMON][LOCALSPL][SPOOLSS] Add some missing VOIDs. CORE-11799...
[reactos.git] / win32ss / printing / providers / localspl / printers.c
1 /*
2 * PROJECT: ReactOS Local Spooler
3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
4 * PURPOSE: Functions related to Printers and printing
5 * COPYRIGHT: Copyright 2015-2017 Colin Finck (colin@reactos.org)
6 */
7
8 #include "precomp.h"
9
10 // Global Variables
11 SKIPLIST PrinterList;
12
13 // Forward Declarations
14 static void _LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
15 static void _LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
16 static void _LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
17 static void _LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
18 static void _LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
19 static void _LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
20 static void _LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
21 static void _LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
22 static void _LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
23 static void _LocalGetPrinterLevel9(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_9W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName);
24
25 // Local Constants
26 typedef void (*PLocalGetPrinterLevelFunc)(PLOCAL_PRINTER, PVOID, PBYTE*, PDWORD, DWORD, PWSTR);
27
28 static const PLocalGetPrinterLevelFunc pfnGetPrinterLevels[] = {
29 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel0,
30 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel1,
31 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel2,
32 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel3,
33 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel4,
34 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel5,
35 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel6,
36 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel7,
37 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel8,
38 (PLocalGetPrinterLevelFunc)&_LocalGetPrinterLevel9
39 };
40
41 static DWORD dwPrinterInfo0Offsets[] = {
42 FIELD_OFFSET(PRINTER_INFO_STRESS, pPrinterName),
43 MAXDWORD
44 };
45
46 static DWORD dwPrinterInfo1Offsets[] = {
47 FIELD_OFFSET(PRINTER_INFO_1W, pName),
48 FIELD_OFFSET(PRINTER_INFO_1W, pComment),
49 FIELD_OFFSET(PRINTER_INFO_1W, pDescription),
50 MAXDWORD
51 };
52
53 static DWORD dwPrinterInfo2Offsets[] = {
54 FIELD_OFFSET(PRINTER_INFO_2W, pPrinterName),
55 FIELD_OFFSET(PRINTER_INFO_2W, pShareName),
56 FIELD_OFFSET(PRINTER_INFO_2W, pPortName),
57 FIELD_OFFSET(PRINTER_INFO_2W, pDriverName),
58 FIELD_OFFSET(PRINTER_INFO_2W, pComment),
59 FIELD_OFFSET(PRINTER_INFO_2W, pLocation),
60 FIELD_OFFSET(PRINTER_INFO_2W, pSepFile),
61 FIELD_OFFSET(PRINTER_INFO_2W, pPrintProcessor),
62 FIELD_OFFSET(PRINTER_INFO_2W, pDatatype),
63 FIELD_OFFSET(PRINTER_INFO_2W, pParameters),
64 MAXDWORD
65 };
66
67 static DWORD dwPrinterInfo4Offsets[] = {
68 FIELD_OFFSET(PRINTER_INFO_4W, pPrinterName),
69 MAXDWORD
70 };
71
72 static DWORD dwPrinterInfo5Offsets[] = {
73 FIELD_OFFSET(PRINTER_INFO_5W, pPrinterName),
74 FIELD_OFFSET(PRINTER_INFO_5W, pPortName),
75 MAXDWORD
76 };
77
78 /** These values serve no purpose anymore, but are still used in PRINTER_INFO_5 and
79 HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\PrinterPorts */
80 static const DWORD dwDeviceNotSelectedTimeout = 15000;
81 static const DWORD dwTransmissionRetryTimeout = 45000;
82
83
84 /**
85 * @name _PrinterListCompareRoutine
86 *
87 * SKIPLIST_COMPARE_ROUTINE for the Printer List.
88 * Does a case-insensitive comparison, because e.g. LocalOpenPrinter doesn't match the case when looking for Printers.
89 */
90 static int WINAPI
91 _PrinterListCompareRoutine(PVOID FirstStruct, PVOID SecondStruct)
92 {
93 PLOCAL_PRINTER A = (PLOCAL_PRINTER)FirstStruct;
94 PLOCAL_PRINTER B = (PLOCAL_PRINTER)SecondStruct;
95
96 return wcsicmp(A->pwszPrinterName, B->pwszPrinterName);
97 }
98
99 /**
100 * @name InitializePrinterList
101 *
102 * Initializes a list of locally available Printers.
103 * The list is searchable by name and returns information about the printers, including their job queues.
104 * During this process, the job queues are also initialized.
105 */
106 BOOL
107 InitializePrinterList(VOID)
108 {
109 DWORD cbData;
110 DWORD cchPrinterName;
111 DWORD dwErrorCode;
112 DWORD dwSubKeys;
113 DWORD i;
114 HKEY hSubKey = NULL;
115 PLOCAL_PORT pPort;
116 PLOCAL_PRINTER pPrinter = NULL;
117 PLOCAL_PRINT_PROCESSOR pPrintProcessor;
118 PWSTR pwszPort = NULL;
119 PWSTR pwszPrintProcessor = NULL;
120 WCHAR wszPrinterName[MAX_PRINTER_NAME + 1];
121
122 TRACE("InitializePrinterList()\n");
123
124 // Initialize an empty list for our printers.
125 InitializeSkiplist(&PrinterList, DllAllocSplMem, _PrinterListCompareRoutine, (PSKIPLIST_FREE_ROUTINE)DllFreeSplMem);
126
127 // Get the number of subkeys of the printers registry key. Each subkey is a local printer there.
128 dwErrorCode = (DWORD)RegQueryInfoKeyW(hPrintersKey, NULL, NULL, NULL, &dwSubKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
129 if (dwErrorCode != ERROR_SUCCESS)
130 {
131 ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
132 goto Cleanup;
133 }
134
135 // Loop through all available local printers.
136 for (i = 0; i < dwSubKeys; i++)
137 {
138 // Cleanup tasks from the previous run
139 if (hSubKey)
140 {
141 RegCloseKey(hSubKey);
142 hSubKey = NULL;
143 }
144
145 if (pPrinter)
146 {
147 if (pPrinter->pDefaultDevMode)
148 DllFreeSplMem(pPrinter->pDefaultDevMode);
149
150 if (pPrinter->pwszDefaultDatatype)
151 DllFreeSplStr(pPrinter->pwszDefaultDatatype);
152
153 if (pPrinter->pwszDescription)
154 DllFreeSplStr(pPrinter->pwszDescription);
155
156 if (pPrinter->pwszPrinterDriver)
157 DllFreeSplStr(pPrinter->pwszPrinterDriver);
158
159 if (pPrinter->pwszPrinterName)
160 DllFreeSplStr(pPrinter->pwszPrinterName);
161
162 DllFreeSplMem(pPrinter);
163 pPrinter = NULL;
164 }
165
166 if (pwszPrintProcessor)
167 {
168 DllFreeSplStr(pwszPrintProcessor);
169 pwszPrintProcessor = NULL;
170 }
171
172 // Get the name of this printer.
173 cchPrinterName = _countof(wszPrinterName);
174 dwErrorCode = (DWORD)RegEnumKeyExW(hPrintersKey, i, wszPrinterName, &cchPrinterName, NULL, NULL, NULL, NULL);
175 if (dwErrorCode == ERROR_MORE_DATA)
176 {
177 // This printer name exceeds the maximum length and is invalid.
178 continue;
179 }
180 else if (dwErrorCode != ERROR_SUCCESS)
181 {
182 ERR("RegEnumKeyExW failed for iteration %lu with status %lu!\n", i, dwErrorCode);
183 continue;
184 }
185
186 // Open this Printer's registry key.
187 dwErrorCode = (DWORD)RegOpenKeyExW(hPrintersKey, wszPrinterName, 0, KEY_READ, &hSubKey);
188 if (dwErrorCode != ERROR_SUCCESS)
189 {
190 ERR("RegOpenKeyExW failed for Printer \"%S\" with status %lu!\n", wszPrinterName, dwErrorCode);
191 continue;
192 }
193
194 // Get the Print Processor.
195 pwszPrintProcessor = AllocAndRegQueryWSZ(hSubKey, L"Print Processor");
196 if (!pwszPrintProcessor)
197 continue;
198
199 // Try to find it in the Print Processor List.
200 pPrintProcessor = FindPrintProcessor(pwszPrintProcessor);
201 if (!pPrintProcessor)
202 {
203 ERR("Invalid Print Processor \"%S\" for Printer \"%S\"!\n", pwszPrintProcessor, wszPrinterName);
204 continue;
205 }
206
207 // Get the Port.
208 pwszPort = AllocAndRegQueryWSZ(hSubKey, L"Port");
209 if (!pwszPort)
210 continue;
211
212 // Try to find it in the Port List.
213 pPort = FindPort(pwszPort);
214 if (!pPort)
215 {
216 ERR("Invalid Port \"%S\" for Printer \"%S\"!\n", pwszPort, wszPrinterName);
217 continue;
218 }
219
220 // Create a new LOCAL_PRINTER structure for it.
221 pPrinter = DllAllocSplMem(sizeof(LOCAL_PRINTER));
222 if (!pPrinter)
223 {
224 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
225 ERR("DllAllocSplMem failed!\n");
226 goto Cleanup;
227 }
228
229 pPrinter->pwszPrinterName = AllocSplStr(wszPrinterName);
230 pPrinter->pPrintProcessor = pPrintProcessor;
231 pPrinter->pPort = pPort;
232 InitializePrinterJobList(pPrinter);
233
234 // Get the location.
235 pPrinter->pwszLocation = AllocAndRegQueryWSZ(hSubKey, L"Location");
236 if (!pPrinter->pwszLocation)
237 continue;
238
239 // Get the printer driver.
240 pPrinter->pwszPrinterDriver = AllocAndRegQueryWSZ(hSubKey, L"Printer Driver");
241 if (!pPrinter->pwszPrinterDriver)
242 continue;
243
244 // Get the description.
245 pPrinter->pwszDescription = AllocAndRegQueryWSZ(hSubKey, L"Description");
246 if (!pPrinter->pwszDescription)
247 continue;
248
249 // Get the default datatype.
250 pPrinter->pwszDefaultDatatype = AllocAndRegQueryWSZ(hSubKey, L"Datatype");
251 if (!pPrinter->pwszDefaultDatatype)
252 continue;
253
254 // Verify that it's valid.
255 if (!FindDatatype(pPrintProcessor, pPrinter->pwszDefaultDatatype))
256 {
257 ERR("Invalid default datatype \"%S\" for Printer \"%S\"!\n", pPrinter->pwszDefaultDatatype, wszPrinterName);
258 continue;
259 }
260
261 // Determine the size of the DevMode.
262 dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Default DevMode", NULL, NULL, NULL, &cbData);
263 if (dwErrorCode != ERROR_SUCCESS)
264 {
265 ERR("Couldn't query the size of the DevMode for Printer \"%S\", status is %lu, cbData is %lu!\n", wszPrinterName, dwErrorCode, cbData);
266 continue;
267 }
268
269 // Allocate enough memory for the DevMode.
270 pPrinter->pDefaultDevMode = DllAllocSplMem(cbData);
271 if (!pPrinter->pDefaultDevMode)
272 {
273 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
274 ERR("DllAllocSplMem failed!\n");
275 goto Cleanup;
276 }
277
278 // Get the default DevMode.
279 dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Default DevMode", NULL, NULL, (PBYTE)pPrinter->pDefaultDevMode, &cbData);
280 if (dwErrorCode != ERROR_SUCCESS)
281 {
282 ERR("Couldn't query a DevMode for Printer \"%S\", status is %lu, cbData is %lu!\n", wszPrinterName, dwErrorCode, cbData);
283 continue;
284 }
285
286 // Get the Attributes.
287 cbData = sizeof(DWORD);
288 dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Attributes", NULL, NULL, (PBYTE)&pPrinter->dwAttributes, &cbData);
289 if (dwErrorCode != ERROR_SUCCESS)
290 {
291 ERR("Couldn't query Attributes for Printer \"%S\", status is %lu!\n", wszPrinterName, dwErrorCode);
292 continue;
293 }
294
295 // Get the Status.
296 cbData = sizeof(DWORD);
297 dwErrorCode = (DWORD)RegQueryValueExW(hSubKey, L"Status", NULL, NULL, (PBYTE)&pPrinter->dwStatus, &cbData);
298 if (dwErrorCode != ERROR_SUCCESS)
299 {
300 ERR("Couldn't query Status for Printer \"%S\", status is %lu!\n", wszPrinterName, dwErrorCode);
301 continue;
302 }
303
304 // Add this printer to the printer list.
305 if (!InsertElementSkiplist(&PrinterList, pPrinter))
306 {
307 ERR("InsertElementSkiplist failed for Printer \"%S\"!\n", pPrinter->pwszPrinterName);
308 goto Cleanup;
309 }
310
311 // Don't let the cleanup routines free this.
312 pPrinter = NULL;
313 }
314
315 dwErrorCode = ERROR_SUCCESS;
316
317 Cleanup:
318 // Inside the loop
319 if (hSubKey)
320 RegCloseKey(hSubKey);
321
322 if (pPrinter)
323 {
324 if (pPrinter->pDefaultDevMode)
325 DllFreeSplMem(pPrinter->pDefaultDevMode);
326
327 if (pPrinter->pwszDefaultDatatype)
328 DllFreeSplStr(pPrinter->pwszDefaultDatatype);
329
330 if (pPrinter->pwszDescription)
331 DllFreeSplStr(pPrinter->pwszDescription);
332
333 if (pPrinter->pwszPrinterDriver)
334 DllFreeSplStr(pPrinter->pwszPrinterDriver);
335
336 if (pPrinter->pwszPrinterName)
337 DllFreeSplStr(pPrinter->pwszPrinterName);
338
339 DllFreeSplMem(pPrinter);
340 }
341
342 if (pwszPrintProcessor)
343 DllFreeSplStr(pwszPrintProcessor);
344
345 SetLastError(dwErrorCode);
346 return (dwErrorCode == ERROR_SUCCESS);
347 }
348
349 /**
350 * @name _LocalEnumPrintersCheckName
351 *
352 * Checks the Name parameter supplied to a call to EnumPrinters.
353 *
354 * @param Flags
355 * Flags parameter of EnumPrinters.
356 *
357 * @param Name
358 * Name parameter of EnumPrinters to check.
359 *
360 * @param pwszComputerName
361 * Pointer to a string able to hold 2 + MAX_COMPUTERNAME_LENGTH + 1 + 1 characters.
362 * On return, it may contain a computer name to prepend in EnumPrinters depending on the case.
363 *
364 * @param pcchComputerName
365 * If a string to prepend is returned, this pointer receives its length in characters.
366 *
367 * @return
368 * ERROR_SUCCESS if processing in EnumPrinters can be continued.
369 * ERROR_INVALID_NAME if the Name parameter is invalid for the given flags and this Print Provider.
370 * Any other error code if GetComputerNameW fails. Error codes indicating failure should then be returned by EnumPrinters.
371 */
372 static DWORD
373 _LocalEnumPrintersCheckName(DWORD Flags, PCWSTR Name, PWSTR pwszComputerName, PDWORD pcchComputerName)
374 {
375 PCWSTR pName;
376 PCWSTR pComputerName;
377
378 // If there is no Name parameter to check, we can just continue in EnumPrinters.
379 if (!Name)
380 return ERROR_SUCCESS;
381
382 // Check if Name does not begin with two backslashes (required for specifying Computer Names).
383 if (Name[0] != L'\\' || Name[1] != L'\\')
384 {
385 if (Flags & PRINTER_ENUM_NAME)
386 {
387 // If PRINTER_ENUM_NAME is specified, any given Name parameter may only contain the
388 // Print Provider Name or the local Computer Name.
389
390 // Compare with the Print Provider Name.
391 if (wcsicmp(Name, wszPrintProviderInfo[0]) == 0)
392 return ERROR_SUCCESS;
393
394 // Dismiss anything else.
395 return ERROR_INVALID_NAME;
396 }
397 else
398 {
399 // If PRINTER_ENUM_NAME is not specified, we just ignore anything that is not a Computer Name.
400 return ERROR_SUCCESS;
401 }
402 }
403
404 // Prepend the backslashes to the output computer name.
405 pwszComputerName[0] = L'\\';
406 pwszComputerName[1] = L'\\';
407
408 // Get the local computer name for comparison.
409 *pcchComputerName = MAX_COMPUTERNAME_LENGTH + 1;
410 if (!GetComputerNameW(&pwszComputerName[2], pcchComputerName))
411 {
412 ERR("GetComputerNameW failed with error %lu!\n", GetLastError());
413 return GetLastError();
414 }
415
416 // Add the leading slashes to the total length.
417 *pcchComputerName += 2;
418
419 // Compare both names.
420 pComputerName = &pwszComputerName[2];
421 pName = &Name[2];
422 for (;;)
423 {
424 // Are we at the end of the local Computer Name string?
425 if (!*pComputerName)
426 {
427 // Are we also at the end of the supplied Name parameter?
428 // A terminating NUL character and a backslash are both treated as the end, but they are treated differently.
429 if (!*pName)
430 {
431 // If both names match and Name ends with a NUL character, the computer name will be prepended in EnumPrinters.
432 // Add a trailing backslash for that.
433 pwszComputerName[(*pcchComputerName)++] = L'\\';
434 pwszComputerName[*pcchComputerName] = 0;
435 return ERROR_SUCCESS;
436 }
437 else if (*pName == L'\\')
438 {
439 if (Flags & PRINTER_ENUM_NAME)
440 {
441 // If PRINTER_ENUM_NAME is specified and a Name parameter is given, it must be exactly the local
442 // Computer Name with two backslashes prepended. Anything else (like "\\COMPUTERNAME\") is dismissed.
443 return ERROR_INVALID_NAME;
444 }
445 else
446 {
447 // If PRINTER_ENUM_NAME is not specified and a Name parameter is given, it may also end with a backslash.
448 // Only the Computer Name between the backslashes is checked then.
449 // This is largely undocumented, but verified by tests (see winspool_apitest).
450 // In this case, no computer name is prepended in EnumPrinters though.
451 *pwszComputerName = 0;
452 *pcchComputerName = 0;
453 return ERROR_SUCCESS;
454 }
455 }
456 }
457
458 // Compare both Computer Names case-insensitively and reject with ERROR_INVALID_NAME if they don't match.
459 if (towlower(*pName) != towlower(*pComputerName))
460 return ERROR_INVALID_NAME;
461
462 pName++;
463 pComputerName++;
464 }
465 }
466
467 static DWORD
468 _DumpLevel1PrintProviderInformation(PBYTE pPrinterEnum, DWORD cbBuf, PDWORD pcbNeeded, PDWORD pcReturned)
469 {
470 int i;
471
472 // Count the needed bytes for Print Provider information.
473 *pcbNeeded = sizeof(PRINTER_INFO_1W);
474
475 for (i = 0; i < 3; i++)
476 *pcbNeeded += (wcslen(wszPrintProviderInfo[i]) + 1) * sizeof(WCHAR);
477
478 // Check if the supplied buffer is large enough.
479 if (cbBuf < *pcbNeeded)
480 return ERROR_INSUFFICIENT_BUFFER;
481
482 // Copy over the Print Provider information.
483 ((PPRINTER_INFO_1W)pPrinterEnum)->Flags = 0;
484 PackStrings(wszPrintProviderInfo, pPrinterEnum, dwPrinterInfo1Offsets, &pPrinterEnum[*pcbNeeded]);
485 *pcReturned = 1;
486
487 return ERROR_SUCCESS;
488 }
489
490 static void
491 _LocalGetPrinterLevel0(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_STRESS* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
492 {
493 size_t cbName;
494 PWSTR p;
495 PWSTR pwszStrings[1];
496 SYSTEM_INFO SystemInfo;
497
498 // Calculate the string lengths.
499 cbName = (cchComputerName + wcslen(pPrinter->pwszPrinterName) + 1) * sizeof(WCHAR);
500
501 if (!ppPrinterInfo)
502 {
503 *pcbNeeded += sizeof(PRINTER_INFO_STRESS) + cbName;
504 return;
505 }
506
507 // Set the general fields.
508 ZeroMemory(*ppPrinterInfo, sizeof(PRINTER_INFO_STRESS));
509 (*ppPrinterInfo)->cJobs = pPrinter->JobList.NodeCount;
510 (*ppPrinterInfo)->dwGetVersion = GetVersion();
511 (*ppPrinterInfo)->Status = pPrinter->dwStatus;
512
513 #if !defined(DBG)
514 (*ppPrinterInfo)->fFreeBuild = 1;
515 #endif
516
517 GetSystemInfo(&SystemInfo);
518 (*ppPrinterInfo)->dwNumberOfProcessors = SystemInfo.dwNumberOfProcessors;
519 (*ppPrinterInfo)->dwProcessorType = SystemInfo.dwProcessorType;
520 (*ppPrinterInfo)->wProcessorArchitecture = SystemInfo.wProcessorArchitecture;
521 (*ppPrinterInfo)->wProcessorLevel = SystemInfo.wProcessorLevel;
522
523 // Copy the Printer Name.
524 pwszStrings[0] = DllAllocSplMem(cbName);
525 p = pwszStrings[0];
526 StringCbCopyExW(p, cbName, wszComputerName, &p, &cbName, 0);
527 StringCbCopyExW(p, cbName, pPrinter->pwszPrinterName, &p, &cbName, 0);
528
529 // Finally copy the structure and advance to the next one in the output buffer.
530 *ppPrinterInfoEnd = PackStrings(pwszStrings, (PBYTE)(*ppPrinterInfo), dwPrinterInfo0Offsets, *ppPrinterInfoEnd);
531 (*ppPrinterInfo)++;
532
533 // Free the memory for temporary strings.
534 DllFreeSplMem(pwszStrings[0]);
535 }
536
537 static void
538 _LocalGetPrinterLevel1(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_1W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
539 {
540 const WCHAR wszComma[] = L",";
541
542 size_t cbName;
543 size_t cbComment;
544 size_t cbDescription;
545 PWSTR p;
546 PWSTR pwszStrings[3];
547
548 // Calculate the string lengths.
549 // Attention: pComment equals the "Description" registry value while pDescription is concatenated out of several strings.
550 // On top of this, the computer name is prepended to the printer name if the user supplied the local computer name during the query.
551 cbName = (cchComputerName + wcslen(pPrinter->pwszPrinterName) + 1) * sizeof(WCHAR);
552 cbComment = (wcslen(pPrinter->pwszDescription) + 1) * sizeof(WCHAR);
553 cbDescription = cbName + (wcslen(pPrinter->pwszPrinterDriver) + 1 + wcslen(pPrinter->pwszLocation) + 1) * sizeof(WCHAR);
554
555 if (!ppPrinterInfo)
556 {
557 *pcbNeeded += sizeof(PRINTER_INFO_1W) + cbName + cbComment + cbDescription;
558 return;
559 }
560
561 // Indicate that this is a Printer.
562 (*ppPrinterInfo)->Flags = PRINTER_ENUM_ICON8;
563
564 // Copy the Printer Name.
565 pwszStrings[0] = DllAllocSplMem(cbName);
566 p = pwszStrings[0];
567 StringCbCopyExW(p, cbName, wszComputerName, &p, &cbName, 0);
568 StringCbCopyExW(p, cbName, pPrinter->pwszPrinterName, &p, &cbName, 0);
569
570 // Copy the Printer comment (equals the "Description" registry value).
571 pwszStrings[1] = pPrinter->pwszDescription;
572
573 // Copy the description, which for PRINTER_INFO_1W has the form "Name,Printer Driver,Location"
574 pwszStrings[2] = DllAllocSplMem(cbDescription);
575 p = pwszStrings[2];
576 StringCbCopyExW(p, cbDescription, wszComputerName, &p, &cbDescription, 0);
577 StringCbCopyExW(p, cbDescription, pPrinter->pwszPrinterName, &p, &cbDescription, 0);
578 StringCbCopyExW(p, cbDescription, wszComma, &p, &cbDescription, 0);
579 StringCbCopyExW(p, cbDescription, pPrinter->pwszPrinterDriver, &p, &cbDescription, 0);
580 StringCbCopyExW(p, cbDescription, wszComma, &p, &cbDescription, 0);
581 StringCbCopyExW(p, cbDescription, pPrinter->pwszLocation, &p, &cbDescription, 0);
582
583 // Finally copy the structure and advance to the next one in the output buffer.
584 *ppPrinterInfoEnd = PackStrings(pwszStrings, (PBYTE)(*ppPrinterInfo), dwPrinterInfo1Offsets, *ppPrinterInfoEnd);
585 (*ppPrinterInfo)++;
586
587 // Free the memory for temporary strings.
588 DllFreeSplMem(pwszStrings[0]);
589 DllFreeSplMem(pwszStrings[2]);
590 }
591
592 static void
593 _LocalGetPrinterLevel2(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_2W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
594 {
595 WCHAR wszEmpty[] = L"";
596
597 size_t cbDevMode;
598 size_t cbPrinterName;
599 size_t cbShareName;
600 size_t cbPortName;
601 size_t cbDriverName;
602 size_t cbComment;
603 size_t cbLocation;
604 size_t cbSepFile;
605 size_t cbPrintProcessor;
606 size_t cbDatatype;
607 size_t cbParameters;
608 PWSTR p;
609 PWSTR pwszStrings[10];
610
611 // Calculate the string lengths.
612 cbDevMode = pPrinter->pDefaultDevMode->dmSize + pPrinter->pDefaultDevMode->dmDriverExtra;
613 cbPrinterName = (cchComputerName + wcslen(pPrinter->pwszPrinterName) + 1) * sizeof(WCHAR);
614
615 if (!ppPrinterInfo)
616 {
617 // Attention: pComment equals the "Description" registry value.
618 cbShareName = sizeof(wszEmpty);
619 cbPortName = (wcslen(pPrinter->pPort->pwszName) + 1) * sizeof(WCHAR);
620 cbDriverName = (wcslen(pPrinter->pwszPrinterDriver) + 1) * sizeof(WCHAR);
621 cbComment = (wcslen(pPrinter->pwszDescription) + 1) * sizeof(WCHAR);
622 cbLocation = (wcslen(pPrinter->pwszLocation) + 1) * sizeof(WCHAR);
623 cbSepFile = sizeof(wszEmpty);
624 cbPrintProcessor = (wcslen(pPrinter->pPrintProcessor->pwszName) + 1) * sizeof(WCHAR);
625 cbDatatype = (wcslen(pPrinter->pwszDefaultDatatype) + 1) * sizeof(WCHAR);
626 cbParameters = sizeof(wszEmpty);
627
628 *pcbNeeded += sizeof(PRINTER_INFO_2W) + cbDevMode + cbPrinterName + cbShareName + cbPortName + cbDriverName + cbComment + cbLocation + cbSepFile + cbPrintProcessor + cbDatatype + cbParameters;
629 return;
630 }
631
632 // Set the general fields.
633 ZeroMemory(*ppPrinterInfo, sizeof(PRINTER_INFO_2W));
634 (*ppPrinterInfo)->Attributes = pPrinter->dwAttributes;
635 (*ppPrinterInfo)->cJobs = pPrinter->JobList.NodeCount;
636 (*ppPrinterInfo)->Status = pPrinter->dwStatus;
637
638 // Set the pDevMode field (and copy the DevMode).
639 *ppPrinterInfoEnd -= cbDevMode;
640 CopyMemory(*ppPrinterInfoEnd, pPrinter->pDefaultDevMode, cbDevMode);
641 (*ppPrinterInfo)->pDevMode = (PDEVMODEW)(*ppPrinterInfoEnd);
642
643 // Set the pPrinterName field.
644 pwszStrings[0] = DllAllocSplMem(cbPrinterName);
645 p = pwszStrings[0];
646 StringCbCopyExW(p, cbPrinterName, wszComputerName, &p, &cbPrinterName, 0);
647 StringCbCopyExW(p, cbPrinterName, pPrinter->pwszPrinterName, &p, &cbPrinterName, 0);
648
649 // Set the pShareName field.
650 pwszStrings[1] = wszEmpty;
651
652 // Set the pPortName field.
653 pwszStrings[2] = pPrinter->pPort->pwszName;
654
655 // Set the pDriverName field.
656 pwszStrings[3] = pPrinter->pwszPrinterDriver;
657
658 // Set the pComment field ((equals the "Description" registry value).
659 pwszStrings[4] = pPrinter->pwszDescription;
660
661 // Set the pLocation field.
662 pwszStrings[5] = pPrinter->pwszLocation;
663
664 // Set the pSepFile field.
665 pwszStrings[6] = wszEmpty;
666
667 // Set the pPrintProcessor field.
668 pwszStrings[7] = pPrinter->pPrintProcessor->pwszName;
669
670 // Set the pDatatype field.
671 pwszStrings[8] = pPrinter->pwszDefaultDatatype;
672
673 // Set the pParameters field.
674 pwszStrings[9] = wszEmpty;
675
676 // Finally copy the structure and advance to the next one in the output buffer.
677 *ppPrinterInfoEnd = PackStrings(pwszStrings, (PBYTE)(*ppPrinterInfo), dwPrinterInfo2Offsets, *ppPrinterInfoEnd);
678 (*ppPrinterInfo)++;
679
680 // Free the memory for temporary strings.
681 DllFreeSplMem(pwszStrings[0]);
682 }
683
684 static void
685 _LocalGetPrinterLevel3(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_3* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
686 {
687 SECURITY_DESCRIPTOR SecurityDescriptor = { 0 };
688
689 if (!ppPrinterInfo)
690 {
691 *pcbNeeded += sizeof(PRINTER_INFO_3) + sizeof(SECURITY_DESCRIPTOR);
692 return;
693 }
694
695 FIXME("Return a valid security descriptor for PRINTER_INFO_3\n");
696
697 // Set the pSecurityDescriptor field (and copy the Security Descriptor).
698 *ppPrinterInfoEnd -= sizeof(SECURITY_DESCRIPTOR);
699 CopyMemory(*ppPrinterInfoEnd, &SecurityDescriptor, sizeof(SECURITY_DESCRIPTOR));
700 (*ppPrinterInfo)->pSecurityDescriptor = (PSECURITY_DESCRIPTOR)(*ppPrinterInfoEnd);
701
702 // Advance to the next structure.
703 (*ppPrinterInfo)++;
704 }
705
706 static void
707 _LocalGetPrinterLevel4(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_4W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
708 {
709 size_t cbPrinterName;
710 PWSTR p;
711 PWSTR pwszStrings[1];
712
713 // Calculate the string lengths.
714 cbPrinterName = (cchComputerName + wcslen(pPrinter->pwszPrinterName) + 1) * sizeof(WCHAR);
715
716 if (!ppPrinterInfo)
717 {
718 *pcbNeeded += sizeof(PRINTER_INFO_4W) + cbPrinterName;
719 return;
720 }
721
722 // Set the general fields.
723 (*ppPrinterInfo)->pServerName = NULL;
724 (*ppPrinterInfo)->Attributes = pPrinter->dwAttributes;
725
726 // Set the pPrinterName field.
727 pwszStrings[0] = DllAllocSplMem(cbPrinterName);
728 p = pwszStrings[0];
729 StringCbCopyExW(p, cbPrinterName, wszComputerName, &p, &cbPrinterName, 0);
730 StringCbCopyExW(p, cbPrinterName, pPrinter->pwszPrinterName, &p, &cbPrinterName, 0);
731
732 // Finally copy the structure and advance to the next one in the output buffer.
733 *ppPrinterInfoEnd = PackStrings(pwszStrings, (PBYTE)(*ppPrinterInfo), dwPrinterInfo4Offsets, *ppPrinterInfoEnd);
734 (*ppPrinterInfo)++;
735
736 // Free the memory for temporary strings.
737 DllFreeSplMem(pwszStrings[0]);
738 }
739
740 static void
741 _LocalGetPrinterLevel5(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_5W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
742 {
743 size_t cbPrinterName;
744 size_t cbPortName;
745 PWSTR p;
746 PWSTR pwszStrings[2];
747
748 // Calculate the string lengths.
749 cbPrinterName = (cchComputerName + wcslen(pPrinter->pwszPrinterName) + 1) * sizeof(WCHAR);
750
751 if (!ppPrinterInfo)
752 {
753 cbPortName = (wcslen(pPrinter->pPort->pwszName) + 1) * sizeof(WCHAR);
754
755 *pcbNeeded += sizeof(PRINTER_INFO_5W) + cbPrinterName + cbPortName;
756 return;
757 }
758
759 // Set the general fields.
760 (*ppPrinterInfo)->Attributes = pPrinter->dwAttributes;
761 (*ppPrinterInfo)->DeviceNotSelectedTimeout = dwDeviceNotSelectedTimeout;
762 (*ppPrinterInfo)->TransmissionRetryTimeout = dwTransmissionRetryTimeout;
763
764 // Set the pPrinterName field.
765 pwszStrings[0] = DllAllocSplMem(cbPrinterName);
766 p = pwszStrings[0];
767 StringCbCopyExW(p, cbPrinterName, wszComputerName, &p, &cbPrinterName, 0);
768 StringCbCopyExW(p, cbPrinterName, pPrinter->pwszPrinterName, &p, &cbPrinterName, 0);
769
770 // Set the pPortName field.
771 pwszStrings[1] = pPrinter->pPort->pwszName;
772
773 // Finally copy the structure and advance to the next one in the output buffer.
774 *ppPrinterInfoEnd = PackStrings(pwszStrings, (PBYTE)(*ppPrinterInfo), dwPrinterInfo5Offsets, *ppPrinterInfoEnd);
775 (*ppPrinterInfo)++;
776
777 // Free the memory for temporary strings.
778 DllFreeSplMem(pwszStrings[0]);
779 }
780
781 static void
782 _LocalGetPrinterLevel6(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_6* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
783 {
784 if (!ppPrinterInfo)
785 {
786 *pcbNeeded += sizeof(PRINTER_INFO_6);
787 return;
788 }
789
790 // Set the general fields.
791 (*ppPrinterInfo)->dwStatus = pPrinter->dwStatus;
792
793 // Advance to the next structure.
794 (*ppPrinterInfo)++;
795 }
796
797 static void
798 _LocalGetPrinterLevel7(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_7W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
799 {
800 if (!ppPrinterInfo)
801 {
802 *pcbNeeded += sizeof(PRINTER_INFO_7W);
803 return;
804 }
805
806 FIXME("No Directory Support, returning DSPRINT_UNPUBLISH for PRINTER_INFO_7 all the time!\n");
807
808 // Set the general fields.
809 (*ppPrinterInfo)->dwAction = DSPRINT_UNPUBLISH;
810 (*ppPrinterInfo)->pszObjectGUID = NULL;
811
812 // Advance to the next structure.
813 (*ppPrinterInfo)++;
814 }
815
816 static void
817 _LocalGetPrinterLevel8(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_8W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
818 {
819 DWORD cbDevMode;
820
821 // Calculate the string lengths.
822 cbDevMode = pPrinter->pDefaultDevMode->dmSize + pPrinter->pDefaultDevMode->dmDriverExtra;
823
824 if (!ppPrinterInfo)
825 {
826 *pcbNeeded += sizeof(PRINTER_INFO_8W) + cbDevMode;
827 return;
828 }
829
830 // Set the pDevMode field (and copy the DevMode).
831 *ppPrinterInfoEnd -= cbDevMode;
832 CopyMemory(*ppPrinterInfoEnd, pPrinter->pDefaultDevMode, cbDevMode);
833 (*ppPrinterInfo)->pDevMode = (PDEVMODEW)(*ppPrinterInfoEnd);
834
835 // Advance to the next structure.
836 (*ppPrinterInfo)++;
837 }
838
839 static void
840 _LocalGetPrinterLevel9(PLOCAL_PRINTER pPrinter, PPRINTER_INFO_9W* ppPrinterInfo, PBYTE* ppPrinterInfoEnd, PDWORD pcbNeeded, DWORD cchComputerName, PWSTR wszComputerName)
841 {
842 DWORD cbDevMode;
843
844 // Calculate the string lengths.
845 cbDevMode = pPrinter->pDefaultDevMode->dmSize + pPrinter->pDefaultDevMode->dmDriverExtra;
846
847 if (!ppPrinterInfo)
848 {
849 *pcbNeeded += sizeof(PRINTER_INFO_9W) + cbDevMode;
850 return;
851 }
852
853 FIXME("Per-user settings are not yet implemented, returning the global DevMode for PRINTER_INFO_9!\n");
854
855 // Set the pDevMode field (and copy the DevMode).
856 *ppPrinterInfoEnd -= cbDevMode;
857 CopyMemory(*ppPrinterInfoEnd, pPrinter->pDefaultDevMode, cbDevMode);
858 (*ppPrinterInfo)->pDevMode = (PDEVMODEW)(*ppPrinterInfoEnd);
859
860 // Advance to the next structure.
861 (*ppPrinterInfo)++;
862 }
863
864 BOOL WINAPI
865 LocalEnumPrinters(DWORD Flags, LPWSTR Name, DWORD Level, LPBYTE pPrinterEnum, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
866 {
867 DWORD cchComputerName = 0;
868 DWORD dwErrorCode;
869 PBYTE pPrinterInfoEnd;
870 PSKIPLIST_NODE pNode;
871 WCHAR wszComputerName[2 + MAX_COMPUTERNAME_LENGTH + 1 + 1] = { 0 };
872 PLOCAL_PRINTER pPrinter;
873
874 TRACE("LocalEnumPrinters(%lu, %S, %lu, %p, %lu, %p, %p)\n", Flags, Name, Level, pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
875
876 // Do no sanity checks or assertions for pcbNeeded and pcReturned here.
877 // This is verified and required by localspl_apitest!
878
879 // Begin counting.
880 *pcbNeeded = 0;
881 *pcReturned = 0;
882
883 if (Flags & PRINTER_ENUM_CONNECTIONS || Flags & PRINTER_ENUM_REMOTE || Flags & PRINTER_ENUM_NETWORK)
884 {
885 // If the flags for the Network Print Provider are given, bail out with ERROR_INVALID_NAME.
886 // This is the internal way for a Print Provider to signal that it doesn't handle this request.
887 dwErrorCode = ERROR_INVALID_NAME;
888 goto Cleanup;
889 }
890
891 if (!(Flags & PRINTER_ENUM_LOCAL || Flags & PRINTER_ENUM_NAME))
892 {
893 // The Local Print Provider is the right destination for the request, but without any of these flags,
894 // there is no information that can be returned.
895 // So just signal a successful request.
896 dwErrorCode = ERROR_SUCCESS;
897 goto Cleanup;
898 }
899
900 if (Level == 3 || Level > 5)
901 {
902 // The caller supplied an invalid level for EnumPrinters.
903 dwErrorCode = ERROR_INVALID_LEVEL;
904 goto Cleanup;
905 }
906
907 if (Level == 1 && Flags & PRINTER_ENUM_NAME && !Name)
908 {
909 // The caller wants information about this Print Provider.
910 // spoolss packs this into an array of information about all Print Providers.
911 dwErrorCode = _DumpLevel1PrintProviderInformation(pPrinterEnum, cbBuf, pcbNeeded, pcReturned);
912 goto Cleanup;
913 }
914
915 // Check the supplied Name parameter (if any).
916 // This may return a Computer Name string we later prepend to the output.
917 dwErrorCode = _LocalEnumPrintersCheckName(Flags, Name, wszComputerName, &cchComputerName);
918 if (dwErrorCode != ERROR_SUCCESS)
919 goto Cleanup;
920
921 // Count the required buffer size and the number of printers.
922 for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
923 {
924 pPrinter = (PLOCAL_PRINTER)pNode->Element;
925
926 // TODO: If PRINTER_ENUM_SHARED is given, add this Printer if it's shared instead of just ignoring it.
927 if (Flags & PRINTER_ENUM_SHARED)
928 {
929 FIXME("Printer Sharing is not supported yet, returning no printers!\n");
930 continue;
931 }
932
933 pfnGetPrinterLevels[Level](pPrinter, NULL, NULL, pcbNeeded, cchComputerName, wszComputerName);
934 }
935
936 // Check if the supplied buffer is large enough.
937 if (cbBuf < *pcbNeeded)
938 {
939 dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
940 goto Cleanup;
941 }
942
943 // Copy over the Printer information.
944 pPrinterInfoEnd = &pPrinterEnum[*pcbNeeded];
945
946 for (pNode = PrinterList.Head.Next[0]; pNode; pNode = pNode->Next[0])
947 {
948 pPrinter = (PLOCAL_PRINTER)pNode->Element;
949
950 // TODO: If PRINTER_ENUM_SHARED is given, add this Printer if it's shared instead of just ignoring it.
951 if (Flags & PRINTER_ENUM_SHARED)
952 continue;
953
954 pfnGetPrinterLevels[Level](pPrinter, &pPrinterEnum, &pPrinterInfoEnd, NULL, cchComputerName, wszComputerName);
955 (*pcReturned)++;
956 }
957
958 dwErrorCode = ERROR_SUCCESS;
959
960 Cleanup:
961 SetLastError(dwErrorCode);
962 return (dwErrorCode == ERROR_SUCCESS);
963 }
964
965 BOOL WINAPI
966 LocalGetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD cbBuf, LPDWORD pcbNeeded)
967 {
968 DWORD dwErrorCode;
969 PBYTE pPrinterEnd;
970 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
971 PLOCAL_PRINTER_HANDLE pPrinterHandle;
972
973 TRACE("LocalGetPrinter(%p, %lu, %p, %lu, %p)\n", hPrinter, Level, pPrinter, cbBuf, pcbNeeded);
974
975 // Sanity checks.
976 if (!pHandle)
977 {
978 dwErrorCode = ERROR_INVALID_HANDLE;
979 goto Cleanup;
980 }
981
982 // Check if this is a printer handle.
983 if (pHandle->HandleType != HandleType_Printer)
984 {
985 dwErrorCode = ERROR_INVALID_HANDLE;
986 goto Cleanup;
987 }
988
989 pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
990
991 if (Level > 9)
992 {
993 // The caller supplied an invalid level for GetPrinter.
994 dwErrorCode = ERROR_INVALID_LEVEL;
995 goto Cleanup;
996 }
997
998 // Count the required buffer size.
999 *pcbNeeded = 0;
1000 pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, NULL, NULL, pcbNeeded, 0, NULL);
1001
1002 // Check if the supplied buffer is large enough.
1003 if (cbBuf < *pcbNeeded)
1004 {
1005 dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
1006 goto Cleanup;
1007 }
1008
1009 // Copy over the Printer information.
1010 pPrinterEnd = &pPrinter[*pcbNeeded];
1011 pfnGetPrinterLevels[Level](pPrinterHandle->pPrinter, &pPrinter, &pPrinterEnd, NULL, 0, NULL);
1012 dwErrorCode = ERROR_SUCCESS;
1013
1014 Cleanup:
1015 SetLastError(dwErrorCode);
1016 return (dwErrorCode == ERROR_SUCCESS);
1017 }
1018
1019 static DWORD
1020 _LocalOpenPortHandle(PWSTR pwszPortName, PHANDLE phPrinter)
1021 {
1022 BOOL bReturnValue;
1023 DWORD dwErrorCode;
1024 HANDLE hPort;
1025 PLOCAL_HANDLE pHandle = NULL;
1026 PLOCAL_PORT pPort;
1027 PLOCAL_PORT_HANDLE pPortHandle = NULL;
1028 PLOCAL_PRINT_MONITOR pPrintMonitor;
1029
1030 // Look for this port in our Print Monitor Port list.
1031 pPort = FindPort(pwszPortName);
1032 if (!pPort)
1033 {
1034 // The supplied port is unknown to all our Print Monitors.
1035 dwErrorCode = ERROR_INVALID_NAME;
1036 goto Failure;
1037 }
1038
1039 pPrintMonitor = pPort->pPrintMonitor;
1040
1041 // Call the monitor's OpenPort function.
1042 if (pPrintMonitor->bIsLevel2)
1043 bReturnValue = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnOpenPort(pPrintMonitor->hMonitor, pwszPortName, &hPort);
1044 else
1045 bReturnValue = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnOpenPort(pwszPortName, &hPort);
1046
1047 if (!bReturnValue)
1048 {
1049 // The OpenPort function failed. Return its last error.
1050 dwErrorCode = GetLastError();
1051 goto Failure;
1052 }
1053
1054 // Create a new generic handle.
1055 pHandle = DllAllocSplMem(sizeof(LOCAL_HANDLE));
1056 if (!pHandle)
1057 {
1058 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1059 ERR("DllAllocSplMem failed!\n");
1060 goto Failure;
1061 }
1062
1063 // Create a new LOCAL_PORT_HANDLE.
1064 pPortHandle = DllAllocSplMem(sizeof(LOCAL_PORT_HANDLE));
1065 if (!pPortHandle)
1066 {
1067 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1068 ERR("DllAllocSplMem failed!\n");
1069 goto Failure;
1070 }
1071
1072 pPortHandle->hPort = hPort;
1073 pPortHandle->pPort = pPort;
1074
1075 // Make the generic handle a Port handle.
1076 pHandle->HandleType = HandleType_Port;
1077 pHandle->pSpecificHandle = pPortHandle;
1078
1079 // Return it.
1080 *phPrinter = (HANDLE)pHandle;
1081 return ERROR_SUCCESS;
1082
1083 Failure:
1084 if (pHandle)
1085 DllFreeSplMem(pHandle);
1086
1087 if (pPortHandle)
1088 DllFreeSplMem(pPortHandle);
1089
1090 return dwErrorCode;
1091 }
1092
1093 static DWORD
1094 _LocalOpenPrinterHandle(PWSTR pwszPrinterName, PWSTR pwszJobParameter, PHANDLE phPrinter, PPRINTER_DEFAULTSW pDefault)
1095 {
1096 DWORD dwErrorCode;
1097 DWORD dwJobID;
1098 PLOCAL_HANDLE pHandle = NULL;
1099 PLOCAL_JOB pJob;
1100 PLOCAL_PRINTER pPrinter;
1101 PLOCAL_PRINTER_HANDLE pPrinterHandle = NULL;
1102 WCHAR wszFullPath[MAX_PATH];
1103
1104 // Retrieve the printer from the list.
1105 pPrinter = LookupElementSkiplist(&PrinterList, &pwszPrinterName, NULL);
1106 if (!pPrinter)
1107 {
1108 // The printer does not exist.
1109 dwErrorCode = ERROR_INVALID_NAME;
1110 goto Failure;
1111 }
1112
1113 // Create a new generic handle.
1114 pHandle = DllAllocSplMem(sizeof(LOCAL_HANDLE));
1115 if (!pHandle)
1116 {
1117 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1118 ERR("DllAllocSplMem failed!\n");
1119 goto Failure;
1120 }
1121
1122 // Create a new LOCAL_PRINTER_HANDLE.
1123 pPrinterHandle = DllAllocSplMem(sizeof(LOCAL_PRINTER_HANDLE));
1124 if (!pPrinterHandle)
1125 {
1126 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1127 ERR("DllAllocSplMem failed!\n");
1128 goto Failure;
1129 }
1130
1131 pPrinterHandle->hSPLFile = INVALID_HANDLE_VALUE;
1132 pPrinterHandle->pPrinter = pPrinter;
1133
1134 // Check if a datatype was given.
1135 if (pDefault && pDefault->pDatatype)
1136 {
1137 // Use the datatype if it's valid.
1138 if (!FindDatatype(pPrinter->pPrintProcessor, pDefault->pDatatype))
1139 {
1140 dwErrorCode = ERROR_INVALID_DATATYPE;
1141 goto Failure;
1142 }
1143
1144 pPrinterHandle->pwszDatatype = AllocSplStr(pDefault->pDatatype);
1145 }
1146 else
1147 {
1148 // Use the default datatype.
1149 pPrinterHandle->pwszDatatype = AllocSplStr(pPrinter->pwszDefaultDatatype);
1150 }
1151
1152 // Check if a DevMode was given, otherwise use the default.
1153 if (pDefault && pDefault->pDevMode)
1154 pPrinterHandle->pDevMode = DuplicateDevMode(pDefault->pDevMode);
1155 else
1156 pPrinterHandle->pDevMode = DuplicateDevMode(pPrinter->pDefaultDevMode);
1157
1158 // Check if the caller wants a handle to an existing Print Job.
1159 if (pwszJobParameter)
1160 {
1161 // The "Job " string has to follow now.
1162 if (wcsncmp(pwszJobParameter, L"Job ", 4) != 0)
1163 {
1164 dwErrorCode = ERROR_INVALID_NAME;
1165 goto Failure;
1166 }
1167
1168 // Skip the "Job " string.
1169 pwszJobParameter += 4;
1170
1171 // Skip even more whitespace.
1172 while (*pwszJobParameter == ' ')
1173 ++pwszJobParameter;
1174
1175 // Finally extract the desired Job ID.
1176 dwJobID = wcstoul(pwszJobParameter, NULL, 10);
1177 if (!IS_VALID_JOB_ID(dwJobID))
1178 {
1179 // The user supplied an invalid Job ID.
1180 dwErrorCode = ERROR_INVALID_NAME;
1181 goto Failure;
1182 }
1183
1184 // Look for this job in the Global Job List.
1185 pJob = LookupElementSkiplist(&GlobalJobList, &dwJobID, NULL);
1186 if (!pJob || pJob->pPrinter != pPrinter)
1187 {
1188 // The user supplied a non-existing Job ID or the Job ID does not belong to the supplied printer name.
1189 dwErrorCode = ERROR_INVALID_PRINTER_NAME;
1190 goto Failure;
1191 }
1192
1193 // Try to open its SPL file.
1194 GetJobFilePath(L"SPL", dwJobID, wszFullPath);
1195 pPrinterHandle->hSPLFile = CreateFileW(wszFullPath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
1196 if (pPrinterHandle->hSPLFile == INVALID_HANDLE_VALUE)
1197 {
1198 dwErrorCode = GetLastError();
1199 ERR("CreateFileW failed with error %lu for \"%S\"!", dwErrorCode, wszFullPath);
1200 goto Failure;
1201 }
1202
1203 // Associate the job to our Printer Handle, but don't set bStartedDoc.
1204 // This prevents the caller from doing further StartDocPrinter, WritePrinter, etc. calls on it.
1205 pPrinterHandle->pJob = pJob;
1206 }
1207
1208 // Make the generic handle a Printer handle.
1209 pHandle->HandleType = HandleType_Printer;
1210 pHandle->pSpecificHandle = pPrinterHandle;
1211
1212 // Return it.
1213 *phPrinter = (HANDLE)pHandle;
1214 return ERROR_SUCCESS;
1215
1216 Failure:
1217 if (pHandle)
1218 DllFreeSplMem(pHandle);
1219
1220 if (pPrinterHandle)
1221 {
1222 if (pPrinterHandle->pwszDatatype)
1223 DllFreeSplStr(pPrinterHandle->pwszDatatype);
1224
1225 if (pPrinterHandle->pDevMode)
1226 DllFreeSplMem(pPrinterHandle->pDevMode);
1227
1228 DllFreeSplMem(pPrinterHandle);
1229 }
1230
1231 return dwErrorCode;
1232 }
1233
1234 static DWORD
1235 _LocalOpenPrintServerHandle(PHANDLE phPrinter)
1236 {
1237 PLOCAL_HANDLE pHandle;
1238
1239 // Create a new generic handle.
1240 pHandle = DllAllocSplMem(sizeof(LOCAL_HANDLE));
1241 if (!pHandle)
1242 {
1243 ERR("DllAllocSplMem failed!\n");
1244 return ERROR_NOT_ENOUGH_MEMORY;
1245 }
1246
1247 // Make the generic handle a Print Server handle.
1248 pHandle->HandleType = HandleType_PrintServer;
1249 pHandle->pSpecificHandle = NULL;
1250
1251 // Return it.
1252 *phPrinter = (HANDLE)pHandle;
1253 return ERROR_SUCCESS;
1254 }
1255
1256 static DWORD
1257 _LocalOpenXcvHandle(PWSTR pwszParameter, PHANDLE phPrinter)
1258 {
1259 BOOL bReturnValue;
1260 DWORD dwErrorCode;
1261 HANDLE hXcv;
1262 PLOCAL_HANDLE pHandle = NULL;
1263 PLOCAL_PORT pPort;
1264 PLOCAL_PRINT_MONITOR pPrintMonitor;
1265 PLOCAL_XCV_HANDLE pXcvHandle = NULL;
1266
1267 // Skip the "Xcv" string.
1268 pwszParameter += 3;
1269
1270 // Is XcvMonitor or XcvPort requested?
1271 if (wcsncmp(pwszParameter, L"Monitor ", 8) == 0)
1272 {
1273 // Skip the "Monitor " string.
1274 pwszParameter += 8;
1275
1276 // Look for this monitor in our Print Monitor list.
1277 pPrintMonitor = FindPrintMonitor(pwszParameter);
1278 if (!pPrintMonitor)
1279 {
1280 // The caller supplied a non-existing Monitor name.
1281 dwErrorCode = ERROR_INVALID_NAME;
1282 goto Failure;
1283 }
1284 }
1285 else if (wcsncmp(pwszParameter, L"Port ", 5) == 0)
1286 {
1287 // Skip the "Port " string.
1288 pwszParameter += 5;
1289
1290 // Look for this port in our Print Monitor Port list.
1291 pPort = FindPort(pwszParameter);
1292 if (!pPort)
1293 {
1294 // The supplied port is unknown to all our Print Monitors.
1295 dwErrorCode = ERROR_INVALID_NAME;
1296 goto Failure;
1297 }
1298
1299 pPrintMonitor = pPort->pPrintMonitor;
1300 }
1301 else
1302 {
1303 dwErrorCode = ERROR_INVALID_NAME;
1304 goto Failure;
1305 }
1306
1307 // Call the monitor's XcvOpenPort function.
1308 if (pPrintMonitor->bIsLevel2)
1309 bReturnValue = ((PMONITOR2)pPrintMonitor->pMonitor)->pfnXcvOpenPort(pPrintMonitor->hMonitor, pwszParameter, SERVER_EXECUTE, &hXcv);
1310 else
1311 bReturnValue = ((LPMONITOREX)pPrintMonitor->pMonitor)->Monitor.pfnXcvOpenPort(pwszParameter, SERVER_EXECUTE, &hXcv);
1312
1313 if (!bReturnValue)
1314 {
1315 // The XcvOpenPort function failed. Return its last error.
1316 dwErrorCode = GetLastError();
1317 goto Failure;
1318 }
1319
1320 // Create a new generic handle.
1321 pHandle = DllAllocSplMem(sizeof(LOCAL_HANDLE));
1322 if (!pHandle)
1323 {
1324 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1325 ERR("DllAllocSplMem failed!\n");
1326 goto Failure;
1327 }
1328
1329 // Create a new LOCAL_XCV_HANDLE.
1330 pXcvHandle = DllAllocSplMem(sizeof(LOCAL_XCV_HANDLE));
1331 if (!pXcvHandle)
1332 {
1333 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1334 ERR("DllAllocSplMem failed!\n");
1335 goto Failure;
1336 }
1337
1338 pXcvHandle->hXcv = hXcv;
1339 pXcvHandle->pPrintMonitor = pPrintMonitor;
1340
1341 // Make the generic handle a Xcv handle.
1342 pHandle->HandleType = HandleType_Xcv;
1343 pHandle->pSpecificHandle = pXcvHandle;
1344
1345 // Return it.
1346 *phPrinter = (HANDLE)pHandle;
1347 return ERROR_SUCCESS;
1348
1349 Failure:
1350 if (pHandle)
1351 DllFreeSplMem(pHandle);
1352
1353 if (pXcvHandle)
1354 DllFreeSplMem(pXcvHandle);
1355
1356 return dwErrorCode;
1357 }
1358
1359 BOOL WINAPI
1360 LocalOpenPrinter(PWSTR lpPrinterName, HANDLE* phPrinter, PPRINTER_DEFAULTSW pDefault)
1361 {
1362 DWORD cchComputerName;
1363 DWORD cchFirstParameter;
1364 DWORD dwErrorCode;
1365 PWSTR p = lpPrinterName;
1366 PWSTR pwszFirstParameter = NULL;
1367 PWSTR pwszSecondParameter;
1368 WCHAR wszComputerName[MAX_COMPUTERNAME_LENGTH + 1];
1369
1370 TRACE("LocalOpenPrinter(%S, %p, %p)\n", lpPrinterName, phPrinter, pDefault);
1371
1372 ASSERT(phPrinter);
1373 *phPrinter = NULL;
1374
1375 if (!lpPrinterName)
1376 {
1377 // The caller wants a Print Server handle and provided a NULL string.
1378 dwErrorCode = _LocalOpenPrintServerHandle(phPrinter);
1379 goto Cleanup;
1380 }
1381
1382 // Skip any server name in the first parameter.
1383 // Does lpPrinterName begin with two backslashes to indicate a server name?
1384 if (lpPrinterName[0] == L'\\' && lpPrinterName[1] == L'\\')
1385 {
1386 // Skip these two backslashes.
1387 lpPrinterName += 2;
1388
1389 // Look for the terminating null character or closing backslash.
1390 p = lpPrinterName;
1391 while (*p != L'\0' && *p != L'\\')
1392 p++;
1393
1394 // Get the local computer name for comparison.
1395 cchComputerName = _countof(wszComputerName);
1396 if (!GetComputerNameW(wszComputerName, &cchComputerName))
1397 {
1398 dwErrorCode = GetLastError();
1399 ERR("GetComputerNameW failed with error %lu!\n", dwErrorCode);
1400 goto Cleanup;
1401 }
1402
1403 // Now compare this string excerpt with the local computer name.
1404 // The input parameter may not be writable, so we can't null-terminate the input string at this point.
1405 // This print provider only supports local printers, so both strings have to match.
1406 if (p - lpPrinterName != cchComputerName || _wcsnicmp(lpPrinterName, wszComputerName, cchComputerName) != 0)
1407 {
1408 dwErrorCode = ERROR_INVALID_NAME;
1409 goto Cleanup;
1410 }
1411
1412 // If lpPrinterName is only "\\COMPUTERNAME" with nothing more, the caller wants a handle to the local Print Server.
1413 if (!*p)
1414 {
1415 // The caller wants a Print Server handle and provided a string like:
1416 // "\\COMPUTERNAME"
1417 dwErrorCode = _LocalOpenPrintServerHandle(phPrinter);
1418 goto Cleanup;
1419 }
1420
1421 // We have checked the server name and don't need it anymore.
1422 lpPrinterName = p + 1;
1423 }
1424
1425 // Look for a comma. If it exists, it indicates the end of the first parameter.
1426 pwszSecondParameter = wcschr(lpPrinterName, L',');
1427 if (pwszSecondParameter)
1428 cchFirstParameter = pwszSecondParameter - p;
1429 else
1430 cchFirstParameter = wcslen(lpPrinterName);
1431
1432 // We must have at least one parameter.
1433 if (!cchFirstParameter && !pwszSecondParameter)
1434 {
1435 dwErrorCode = ERROR_INVALID_NAME;
1436 goto Cleanup;
1437 }
1438
1439 // Do we have a first parameter?
1440 if (cchFirstParameter)
1441 {
1442 // Yes, extract it.
1443 // No null-termination is necessary here, because DllAllocSplMem returns a zero-initialized buffer.
1444 pwszFirstParameter = DllAllocSplMem((cchFirstParameter + 1) * sizeof(WCHAR));
1445 CopyMemory(pwszFirstParameter, lpPrinterName, cchFirstParameter * sizeof(WCHAR));
1446 }
1447
1448 // Do we have a second parameter?
1449 if (pwszSecondParameter)
1450 {
1451 // Yes, skip the comma at the beginning.
1452 ++pwszSecondParameter;
1453
1454 // Skip whitespace as well.
1455 while (*pwszSecondParameter == L' ')
1456 ++pwszSecondParameter;
1457 }
1458
1459 // Now we can finally check the type of handle actually requested.
1460 if (pwszFirstParameter && pwszSecondParameter && wcsncmp(pwszSecondParameter, L"Port", 4) == 0)
1461 {
1462 // The caller wants a port handle and provided a string like:
1463 // "LPT1:, Port"
1464 // "\\COMPUTERNAME\LPT1:, Port"
1465 dwErrorCode = _LocalOpenPortHandle(pwszFirstParameter, phPrinter);
1466 }
1467 else if (!pwszFirstParameter && pwszSecondParameter && wcsncmp(pwszSecondParameter, L"Xcv", 3) == 0)
1468 {
1469 // The caller wants an Xcv handle and provided a string like:
1470 // ", XcvMonitor Local Port"
1471 // "\\COMPUTERNAME\, XcvMonitor Local Port"
1472 // ", XcvPort LPT1:"
1473 // "\\COMPUTERNAME\, XcvPort LPT1:"
1474 dwErrorCode = _LocalOpenXcvHandle(pwszSecondParameter, phPrinter);
1475 }
1476 else
1477 {
1478 // The caller wants a Printer or Printer Job handle and provided a string like:
1479 // "HP DeskJet"
1480 // "\\COMPUTERNAME\HP DeskJet"
1481 // "HP DeskJet, Job 5"
1482 // "\\COMPUTERNAME\HP DeskJet, Job 5"
1483 dwErrorCode = _LocalOpenPrinterHandle(pwszFirstParameter, pwszSecondParameter, phPrinter, pDefault);
1484 }
1485
1486 Cleanup:
1487 if (pwszFirstParameter)
1488 DllFreeSplMem(pwszFirstParameter);
1489
1490 SetLastError(dwErrorCode);
1491 return (dwErrorCode == ERROR_SUCCESS);
1492 }
1493
1494 BOOL WINAPI
1495 LocalReadPrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pNoBytesRead)
1496 {
1497 BOOL bReturnValue;
1498 DWORD dwErrorCode;
1499 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1500 PLOCAL_PORT_HANDLE pPortHandle;
1501 PLOCAL_PRINTER_HANDLE pPrinterHandle;
1502
1503 TRACE("LocalReadPrinter(%p, %p, %lu, %p)\n", hPrinter, pBuf, cbBuf, pNoBytesRead);
1504
1505 // Sanity checks.
1506 if (!pHandle)
1507 {
1508 dwErrorCode = ERROR_INVALID_HANDLE;
1509 goto Cleanup;
1510 }
1511
1512 // Port handles are an entirely different thing.
1513 if (pHandle->HandleType == HandleType_Port)
1514 {
1515 pPortHandle = (PLOCAL_PORT_HANDLE)pHandle->pSpecificHandle;
1516
1517 // Call the monitor's ReadPort function.
1518 if (pPortHandle->pPort->pPrintMonitor->bIsLevel2)
1519 bReturnValue = ((PMONITOR2)pPortHandle->pPort->pPrintMonitor->pMonitor)->pfnReadPort(pPortHandle->hPort, pBuf, cbBuf, pNoBytesRead);
1520 else
1521 bReturnValue = ((LPMONITOREX)pPortHandle->pPort->pPrintMonitor->pMonitor)->Monitor.pfnReadPort(pPortHandle->hPort, pBuf, cbBuf, pNoBytesRead);
1522
1523 if (!bReturnValue)
1524 {
1525 // The ReadPort function failed. Return its last error.
1526 dwErrorCode = GetLastError();
1527 goto Cleanup;
1528 }
1529
1530 // We were successful!
1531 dwErrorCode = ERROR_SUCCESS;
1532 goto Cleanup;
1533 }
1534
1535 // The remaining function deals with Printer handles only.
1536 if (pHandle->HandleType != HandleType_Printer)
1537 {
1538 dwErrorCode = ERROR_INVALID_HANDLE;
1539 goto Cleanup;
1540 }
1541
1542 pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
1543
1544 // ReadPrinter needs an opened SPL file to work.
1545 // This only works if a Printer Job Handle was requested in OpenPrinter.
1546 if (pPrinterHandle->hSPLFile == INVALID_HANDLE_VALUE)
1547 {
1548 dwErrorCode = ERROR_INVALID_HANDLE;
1549 goto Cleanup;
1550 }
1551
1552 // Pass the parameters to ReadFile.
1553 if (!ReadFile(pPrinterHandle->hSPLFile, pBuf, cbBuf, pNoBytesRead, NULL))
1554 {
1555 dwErrorCode = GetLastError();
1556 ERR("ReadFile failed with error %lu!\n", dwErrorCode);
1557 goto Cleanup;
1558 }
1559
1560 dwErrorCode = ERROR_SUCCESS;
1561
1562 Cleanup:
1563 SetLastError(dwErrorCode);
1564 return (dwErrorCode == ERROR_SUCCESS);
1565 }
1566
1567 DWORD WINAPI
1568 LocalStartDocPrinter(HANDLE hPrinter, DWORD Level, PBYTE pDocInfo)
1569 {
1570 BOOL bReturnValue;
1571 DWORD dwErrorCode;
1572 DWORD dwReturnValue = 0;
1573 PDOC_INFO_1W pDocInfo1 = (PDOC_INFO_1W)pDocInfo;
1574 PLOCAL_JOB pJob;
1575 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1576 PLOCAL_PORT_HANDLE pPortHandle;
1577 PLOCAL_PRINTER_HANDLE pPrinterHandle;
1578
1579 TRACE("LocalStartDocPrinter(%p, %lu, %p)\n", hPrinter, Level, pDocInfo);
1580
1581 // Sanity checks.
1582 if (!pHandle)
1583 {
1584 dwErrorCode = ERROR_INVALID_HANDLE;
1585 goto Cleanup;
1586 }
1587
1588 // Port handles are an entirely different thing.
1589 if (pHandle->HandleType == HandleType_Port)
1590 {
1591 pPortHandle = (PLOCAL_PORT_HANDLE)pHandle->pSpecificHandle;
1592
1593 // This call should come from a Print Processor and the job this port is going to print was assigned to us before opening the Print Processor.
1594 // Claim it exclusively for this port handle.
1595 pJob = pPortHandle->pPort->pNextJobToProcess;
1596 pPortHandle->pPort->pNextJobToProcess = NULL;
1597 ASSERT(pJob);
1598
1599 // Call the monitor's StartDocPort function.
1600 if (pPortHandle->pPort->pPrintMonitor->bIsLevel2)
1601 bReturnValue = ((PMONITOR2)pPortHandle->pPort->pPrintMonitor->pMonitor)->pfnStartDocPort(pPortHandle->hPort, pJob->pPrinter->pwszPrinterName, pJob->dwJobID, Level, pDocInfo);
1602 else
1603 bReturnValue = ((LPMONITOREX)pPortHandle->pPort->pPrintMonitor->pMonitor)->Monitor.pfnStartDocPort(pPortHandle->hPort, pJob->pPrinter->pwszPrinterName, pJob->dwJobID, Level, pDocInfo);
1604
1605 if (!bReturnValue)
1606 {
1607 // The StartDocPort function failed. Return its last error.
1608 dwErrorCode = GetLastError();
1609 goto Cleanup;
1610 }
1611
1612 // We were successful!
1613 dwErrorCode = ERROR_SUCCESS;
1614 dwReturnValue = pJob->dwJobID;
1615 goto Cleanup;
1616 }
1617
1618 // The remaining function deals with Printer handles only.
1619 if (pHandle->HandleType != HandleType_Printer)
1620 {
1621 dwErrorCode = ERROR_INVALID_HANDLE;
1622 goto Cleanup;
1623 }
1624
1625 if (!pDocInfo1)
1626 {
1627 dwErrorCode = ERROR_INVALID_PARAMETER;
1628 goto Cleanup;
1629 }
1630
1631 pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
1632
1633 // pJob may already be occupied if this is a Print Job handle. In this case, StartDocPrinter has to fail.
1634 if (pPrinterHandle->pJob)
1635 {
1636 dwErrorCode = ERROR_INVALID_PARAMETER;
1637 goto Cleanup;
1638 }
1639
1640 // Check the validity of the datatype if we got one.
1641 if (pDocInfo1->pDatatype && !FindDatatype(pPrinterHandle->pJob->pPrintProcessor, pDocInfo1->pDatatype))
1642 {
1643 dwErrorCode = ERROR_INVALID_DATATYPE;
1644 goto Cleanup;
1645 }
1646
1647 // Check if this is the right document information level.
1648 if (Level != 1)
1649 {
1650 dwErrorCode = ERROR_INVALID_LEVEL;
1651 goto Cleanup;
1652 }
1653
1654 // All requirements are met - create a new job.
1655 dwErrorCode = CreateJob(pPrinterHandle);
1656 if (dwErrorCode != ERROR_SUCCESS)
1657 goto Cleanup;
1658
1659 // Use any given datatype.
1660 if (pDocInfo1->pDatatype && !ReallocSplStr(&pPrinterHandle->pJob->pwszDatatype, pDocInfo1->pDatatype))
1661 {
1662 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1663 ERR("ReallocSplStr failed, last error is %lu!\n", GetLastError());
1664 goto Cleanup;
1665 }
1666
1667 // Use any given document name.
1668 if (pDocInfo1->pDocName && !ReallocSplStr(&pPrinterHandle->pJob->pwszDocumentName, pDocInfo1->pDocName))
1669 {
1670 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
1671 ERR("ReallocSplStr failed, last error is %lu!\n", GetLastError());
1672 goto Cleanup;
1673 }
1674
1675 // We were successful!
1676 dwErrorCode = ERROR_SUCCESS;
1677 dwReturnValue = pPrinterHandle->pJob->dwJobID;
1678
1679 Cleanup:
1680 SetLastError(dwErrorCode);
1681 return dwReturnValue;
1682 }
1683
1684 BOOL WINAPI
1685 LocalStartPagePrinter(HANDLE hPrinter)
1686 {
1687 DWORD dwErrorCode;
1688 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1689 PLOCAL_PRINTER_HANDLE pPrinterHandle;
1690
1691 TRACE("LocalStartPagePrinter(%p)\n", hPrinter);
1692
1693 // Sanity checks.
1694 if (!pHandle || pHandle->HandleType != HandleType_Printer)
1695 {
1696 dwErrorCode = ERROR_INVALID_HANDLE;
1697 goto Cleanup;
1698 }
1699
1700 pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
1701
1702 // We require StartDocPrinter or AddJob to be called first.
1703 if (!pPrinterHandle->bStartedDoc)
1704 {
1705 dwErrorCode = ERROR_SPL_NO_STARTDOC;
1706 goto Cleanup;
1707 }
1708
1709 // Increase the page count.
1710 ++pPrinterHandle->pJob->dwTotalPages;
1711 dwErrorCode = ERROR_SUCCESS;
1712
1713 Cleanup:
1714 SetLastError(dwErrorCode);
1715 return (dwErrorCode == ERROR_SUCCESS);
1716 }
1717
1718 BOOL WINAPI
1719 LocalWritePrinter(HANDLE hPrinter, PVOID pBuf, DWORD cbBuf, PDWORD pcWritten)
1720 {
1721 BOOL bReturnValue;
1722 DWORD dwErrorCode;
1723 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1724 PLOCAL_PORT_HANDLE pPortHandle;
1725 PLOCAL_PRINTER_HANDLE pPrinterHandle;
1726
1727 TRACE("LocalWritePrinter(%p, %p, %lu, %p)\n", hPrinter, pBuf, cbBuf, pcWritten);
1728
1729 // Sanity checks.
1730 if (!pHandle)
1731 {
1732 dwErrorCode = ERROR_INVALID_HANDLE;
1733 goto Cleanup;
1734 }
1735
1736 // Port handles are an entirely different thing.
1737 if (pHandle->HandleType == HandleType_Port)
1738 {
1739 pPortHandle = (PLOCAL_PORT_HANDLE)pHandle->pSpecificHandle;
1740
1741 // Call the monitor's WritePort function.
1742 if (pPortHandle->pPort->pPrintMonitor->bIsLevel2)
1743 bReturnValue = ((PMONITOR2)pPortHandle->pPort->pPrintMonitor->pMonitor)->pfnWritePort(pPortHandle->hPort, pBuf, cbBuf, pcWritten);
1744 else
1745 bReturnValue = ((LPMONITOREX)pPortHandle->pPort->pPrintMonitor->pMonitor)->Monitor.pfnWritePort(pPortHandle->hPort, pBuf, cbBuf, pcWritten);
1746
1747 if (!bReturnValue)
1748 {
1749 // The WritePort function failed. Return its last error.
1750 dwErrorCode = GetLastError();
1751 goto Cleanup;
1752 }
1753
1754 // We were successful!
1755 dwErrorCode = ERROR_SUCCESS;
1756 goto Cleanup;
1757 }
1758
1759 // The remaining function deals with Printer handles only.
1760 if (pHandle->HandleType != HandleType_Printer)
1761 {
1762 dwErrorCode = ERROR_INVALID_HANDLE;
1763 goto Cleanup;
1764 }
1765
1766 pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
1767
1768 // We require StartDocPrinter or AddJob to be called first.
1769 if (!pPrinterHandle->bStartedDoc)
1770 {
1771 dwErrorCode = ERROR_SPL_NO_STARTDOC;
1772 goto Cleanup;
1773 }
1774
1775 // TODO: This function is only called when doing non-spooled printing.
1776 // This needs to be investigated further. We can't just use pPrinterHandle->hSPLFile here, because that's currently reserved for Printer Job handles (see LocalReadPrinter).
1777 #if 0
1778 // Pass the parameters to WriteFile.
1779 if (!WriteFile(SOME_SPOOL_FILE_HANDLE, pBuf, cbBuf, pcWritten, NULL))
1780 {
1781 dwErrorCode = GetLastError();
1782 ERR("WriteFile failed with error %lu!\n", GetLastError());
1783 goto Cleanup;
1784 }
1785 #endif
1786
1787 dwErrorCode = ERROR_SUCCESS;
1788
1789 Cleanup:
1790 SetLastError(dwErrorCode);
1791 return (dwErrorCode == ERROR_SUCCESS);
1792 }
1793
1794 BOOL WINAPI
1795 LocalEndPagePrinter(HANDLE hPrinter)
1796 {
1797 DWORD dwErrorCode;
1798 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1799
1800 TRACE("LocalEndPagePrinter(%p)\n", hPrinter);
1801
1802 // Sanity checks.
1803 if (!pHandle || pHandle->HandleType != HandleType_Printer)
1804 {
1805 dwErrorCode = ERROR_INVALID_HANDLE;
1806 goto Cleanup;
1807 }
1808
1809 // This function doesn't do anything else for now.
1810 dwErrorCode = ERROR_SUCCESS;
1811
1812 Cleanup:
1813 SetLastError(dwErrorCode);
1814 return (dwErrorCode == ERROR_SUCCESS);
1815 }
1816
1817 BOOL WINAPI
1818 LocalEndDocPrinter(HANDLE hPrinter)
1819 {
1820 BOOL bReturnValue;
1821 DWORD dwErrorCode;
1822 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1823 PLOCAL_PORT_HANDLE pPortHandle;
1824 PLOCAL_PRINTER_HANDLE pPrinterHandle;
1825
1826 TRACE("LocalEndDocPrinter(%p)\n", hPrinter);
1827
1828 // Sanity checks.
1829 if (!pHandle)
1830 {
1831 dwErrorCode = ERROR_INVALID_HANDLE;
1832 goto Cleanup;
1833 }
1834
1835 // Port handles are an entirely different thing.
1836 if (pHandle->HandleType == HandleType_Port)
1837 {
1838 pPortHandle = (PLOCAL_PORT_HANDLE)pHandle->pSpecificHandle;
1839
1840 // Call the monitor's EndDocPort function.
1841 if (pPortHandle->pPort->pPrintMonitor->bIsLevel2)
1842 bReturnValue = ((PMONITOR2)pPortHandle->pPort->pPrintMonitor->pMonitor)->pfnEndDocPort(pPortHandle->hPort);
1843 else
1844 bReturnValue = ((LPMONITOREX)pPortHandle->pPort->pPrintMonitor->pMonitor)->Monitor.pfnEndDocPort(pPortHandle->hPort);
1845
1846 if (!bReturnValue)
1847 {
1848 // The EndDocPort function failed. Return its last error.
1849 dwErrorCode = GetLastError();
1850 goto Cleanup;
1851 }
1852
1853 // We were successful!
1854 dwErrorCode = ERROR_SUCCESS;
1855 goto Cleanup;
1856 }
1857
1858 // The remaining function deals with Printer handles only.
1859 if (pHandle->HandleType != HandleType_Printer)
1860 {
1861 dwErrorCode = ERROR_INVALID_HANDLE;
1862 goto Cleanup;
1863 }
1864
1865 pPrinterHandle = (PLOCAL_PRINTER_HANDLE)pHandle->pSpecificHandle;
1866
1867 // We require StartDocPrinter or AddJob to be called first.
1868 if (!pPrinterHandle->bStartedDoc)
1869 {
1870 dwErrorCode = ERROR_SPL_NO_STARTDOC;
1871 goto Cleanup;
1872 }
1873
1874 // TODO: Something like ScheduleJob
1875
1876 // Finish the job.
1877 pPrinterHandle->bStartedDoc = FALSE;
1878 pPrinterHandle->pJob = NULL;
1879 dwErrorCode = ERROR_SUCCESS;
1880
1881 Cleanup:
1882 SetLastError(dwErrorCode);
1883 return (dwErrorCode == ERROR_SUCCESS);
1884 }
1885
1886 static void
1887 _LocalClosePortHandle(PLOCAL_PORT_HANDLE pPortHandle)
1888 {
1889 // Call the monitor's ClosePort function.
1890 if (pPortHandle->pPort->pPrintMonitor->bIsLevel2)
1891 ((PMONITOR2)pPortHandle->pPort->pPrintMonitor->pMonitor)->pfnClosePort(pPortHandle->hPort);
1892 else
1893 ((LPMONITOREX)pPortHandle->pPort->pPrintMonitor->pMonitor)->Monitor.pfnClosePort(pPortHandle->hPort);
1894 }
1895
1896 static void
1897 _LocalClosePrinterHandle(PLOCAL_PRINTER_HANDLE pPrinterHandle)
1898 {
1899 // Terminate any started job.
1900 if (pPrinterHandle->pJob)
1901 FreeJob(pPrinterHandle->pJob);
1902
1903 // Free memory for the fields.
1904 DllFreeSplMem(pPrinterHandle->pDevMode);
1905 DllFreeSplStr(pPrinterHandle->pwszDatatype);
1906 }
1907
1908 static void
1909 _LocalCloseXcvHandle(PLOCAL_XCV_HANDLE pXcvHandle)
1910 {
1911 // Call the monitor's XcvClosePort function.
1912 if (pXcvHandle->pPrintMonitor->bIsLevel2)
1913 ((PMONITOR2)pXcvHandle->pPrintMonitor->pMonitor)->pfnXcvClosePort(pXcvHandle->hXcv);
1914 else
1915 ((LPMONITOREX)pXcvHandle->pPrintMonitor->pMonitor)->Monitor.pfnXcvClosePort(pXcvHandle->hXcv);
1916 }
1917
1918 BOOL WINAPI
1919 LocalClosePrinter(HANDLE hPrinter)
1920 {
1921 PLOCAL_HANDLE pHandle = (PLOCAL_HANDLE)hPrinter;
1922
1923 TRACE("LocalClosePrinter(%p)\n", hPrinter);
1924
1925 if (!pHandle)
1926 {
1927 SetLastError(ERROR_INVALID_HANDLE);
1928 return FALSE;
1929 }
1930
1931 if (pHandle->HandleType == HandleType_Port)
1932 {
1933 _LocalClosePortHandle(pHandle->pSpecificHandle);
1934 }
1935 else if (pHandle->HandleType == HandleType_Printer)
1936 {
1937 _LocalClosePrinterHandle(pHandle->pSpecificHandle);
1938 }
1939 else if (pHandle->HandleType == HandleType_PrintServer)
1940 {
1941 // Nothing to do.
1942 }
1943 else if (pHandle->HandleType == HandleType_Xcv)
1944 {
1945 _LocalCloseXcvHandle(pHandle->pSpecificHandle);
1946 }
1947
1948 // Free memory for the handle and the specific handle (if any).
1949 if (pHandle->pSpecificHandle)
1950 DllFreeSplMem(pHandle->pSpecificHandle);
1951
1952 DllFreeSplMem(pHandle);
1953
1954 return TRUE;
1955 }