d26175ee301690fbfd2b728b0464884c83c55a2b
[reactos.git] / reactos / win32ss / printing / providers / localspl / printprocessors.c
1 /*
2 * PROJECT: ReactOS Local Spooler
3 * LICENSE: GNU LGPL v2.1 or any later version as published by the Free Software Foundation
4 * PURPOSE: Functions related to Print Processors
5 * COPYRIGHT: Copyright 2015 Colin Finck <colin@reactos.org>
6 */
7
8 #include "precomp.h"
9
10
11 // Local Variables
12 static LIST_ENTRY _PrintProcessorList;
13
14 /**
15 * @name _OpenEnvironment
16 *
17 * Checks a supplied pEnvironment variable for validity and opens its registry key.
18 *
19 * @param pEnvironment
20 * The pEnvironment variable to check. Can be NULL to use the current environment.
21 *
22 * @param hKey
23 * On success, this variable will contain a HKEY to the opened registry key of the environment.
24 * You can use it for further tasks and have to close it with RegCloseKey.
25 *
26 * @return
27 * A Windows Error Code indicating success or failure.
28 */
29 static DWORD
30 _OpenEnvironment(PCWSTR pEnvironment, PHKEY hKey)
31 {
32 const WCHAR wszEnvironmentsKey[] = L"SYSTEM\\CurrentControlSet\\Control\\Print\\Environments\\";
33 const DWORD cchEnvironmentsKey = _countof(wszEnvironmentsKey) - 1;
34
35 DWORD cchEnvironment;
36 DWORD dwErrorCode;
37 PWSTR pwszEnvironmentKey = NULL;
38
39 // Use the current environment if none was supplied.
40 if (!pEnvironment)
41 pEnvironment = wszCurrentEnvironment;
42
43 // Construct the registry key of the demanded environment.
44 cchEnvironment = wcslen(pEnvironment);
45 pwszEnvironmentKey = DllAllocSplMem((cchEnvironmentsKey + cchEnvironment + 1) * sizeof(WCHAR));
46 if (!pwszEnvironmentKey)
47 {
48 ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
49 goto Cleanup;
50 }
51
52 CopyMemory(pwszEnvironmentKey, wszEnvironmentsKey, cchEnvironmentsKey * sizeof(WCHAR));
53 CopyMemory(&pwszEnvironmentKey[cchEnvironmentsKey], pEnvironment, (cchEnvironment + 1) * sizeof(WCHAR));
54
55 // Open the registry key.
56 dwErrorCode = (DWORD)RegOpenKeyExW(HKEY_LOCAL_MACHINE, pwszEnvironmentKey, 0, KEY_READ, hKey);
57 if (dwErrorCode == ERROR_FILE_NOT_FOUND)
58 {
59 dwErrorCode = ERROR_INVALID_ENVIRONMENT;
60 goto Cleanup;
61 }
62 else if (dwErrorCode != ERROR_SUCCESS)
63 {
64 ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
65 goto Cleanup;
66 }
67
68 Cleanup:
69 if (pwszEnvironmentKey)
70 DllFreeSplMem(pwszEnvironmentKey);
71
72 return dwErrorCode;
73 }
74
75 BOOL
76 FindDatatype(const PLOCAL_PRINT_PROCESSOR pPrintProcessor, PCWSTR pwszDatatype)
77 {
78 DWORD i;
79 PDATATYPES_INFO_1W pCurrentDatatype = pPrintProcessor->pDatatypesInfo1;
80
81 for (i = 0; i < pPrintProcessor->dwDatatypeCount; i++)
82 {
83 if (wcsicmp(pCurrentDatatype->pName, pwszDatatype) == 0)
84 return TRUE;
85
86 ++pCurrentDatatype;
87 }
88
89 return FALSE;
90 }
91
92 PLOCAL_PRINT_PROCESSOR
93 FindPrintProcessor(PCWSTR pwszName)
94 {
95 PLIST_ENTRY pEntry;
96 PLOCAL_PRINT_PROCESSOR pPrintProcessor;
97
98 for (pEntry = _PrintProcessorList.Flink; pEntry != &_PrintProcessorList; pEntry = pEntry->Flink)
99 {
100 pPrintProcessor = CONTAINING_RECORD(pEntry, LOCAL_PRINT_PROCESSOR, Entry);
101
102 if (wcsicmp(pPrintProcessor->pwszName, pwszName) == 0)
103 return pPrintProcessor;
104 }
105
106 return NULL;
107 }
108
109 /**
110 * @name InitializePrintProcessorList
111 *
112 * Initializes a singly linked list of locally available Print Processors.
113 */
114 BOOL
115 InitializePrintProcessorList()
116 {
117 DWORD cbDatatypes;
118 DWORD cbFileName;
119 DWORD cchPrintProcessorPath;
120 DWORD cchMaxSubKey;
121 DWORD cchPrintProcessorName;
122 DWORD dwErrorCode;
123 DWORD dwSubKeys;
124 DWORD i;
125 HINSTANCE hinstPrintProcessor;
126 HKEY hKey = NULL;
127 HKEY hSubKey = NULL;
128 HKEY hSubSubKey = NULL;
129 PLOCAL_PRINT_PROCESSOR pPrintProcessor = NULL;
130 WCHAR wszFileName[MAX_PATH];
131 WCHAR wszPrintProcessorPath[MAX_PATH];
132
133 // Initialize an empty list for our Print Processors.
134 InitializeListHead(&_PrintProcessorList);
135
136 // Prepare the path to the Print Processor directory.
137 if (!LocalGetPrintProcessorDirectory(NULL, NULL, 1, (PBYTE)wszPrintProcessorPath, sizeof(wszPrintProcessorPath), &cchPrintProcessorPath))
138 {
139 dwErrorCode = GetLastError();
140 goto Cleanup;
141 }
142
143 cchPrintProcessorPath /= sizeof(WCHAR);
144 wszPrintProcessorPath[cchPrintProcessorPath++] = L'\\';
145
146 // Open the environment registry key.
147 dwErrorCode = _OpenEnvironment(NULL, &hKey);
148 if (dwErrorCode != ERROR_SUCCESS)
149 {
150 ERR("_OpenEnvironment failed with error %lu!\n", dwErrorCode);
151 goto Cleanup;
152 }
153
154 // Open the "Print Processors" subkey.
155 dwErrorCode = (DWORD)RegOpenKeyExW(hKey, L"Print Processors", 0, KEY_READ, &hSubKey);
156 if (dwErrorCode != ERROR_SUCCESS)
157 {
158 ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
159 goto Cleanup;
160 }
161
162 // Get the number of Print Processors and maximum sub key length.
163 dwErrorCode = (DWORD)RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwSubKeys, &cchMaxSubKey, NULL, NULL, NULL, NULL, NULL, NULL);
164 if (dwErrorCode != ERROR_SUCCESS)
165 {
166 ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
167 goto Cleanup;
168 }
169
170 // Loop through all available local Print Processors.
171 for (i = 0; i < dwSubKeys; i++)
172 {
173 // Cleanup tasks from the previous run
174 if (hSubSubKey)
175 {
176 RegCloseKey(hSubSubKey);
177 hSubSubKey = NULL;
178 }
179
180 if (pPrintProcessor)
181 {
182 if (pPrintProcessor->pwszName)
183 DllFreeSplStr(pPrintProcessor->pwszName);
184
185 if (pPrintProcessor->pDatatypesInfo1)
186 DllFreeSplMem(pPrintProcessor->pDatatypesInfo1);
187
188 DllFreeSplMem(pPrintProcessor);
189 pPrintProcessor = NULL;
190 }
191
192 // Create a new LOCAL_PRINT_PROCESSOR structure for it.
193 pPrintProcessor = DllAllocSplMem(sizeof(LOCAL_PRINT_PROCESSOR));
194 if (!pPrintProcessor)
195 {
196 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
197 ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
198 goto Cleanup;
199 }
200
201 // Allocate memory for the Print Monitor Name.
202 pPrintProcessor->pwszName = DllAllocSplMem((cchMaxSubKey + 1) * sizeof(WCHAR));
203 if (!pPrintProcessor->pwszName)
204 {
205 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
206 ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
207 goto Cleanup;
208 }
209
210 // Get the name of this Print Processor.
211 cchPrintProcessorName = cchMaxSubKey + 1;
212 dwErrorCode = (DWORD)RegEnumKeyExW(hSubKey, i, pPrintProcessor->pwszName, &cchPrintProcessorName, NULL, NULL, NULL, NULL);
213 if (dwErrorCode != ERROR_SUCCESS)
214 {
215 ERR("RegEnumKeyExW failed with status %ld!\n", dwErrorCode);
216 continue;
217 }
218
219 // Open this Print Processor's registry key.
220 dwErrorCode = (DWORD)RegOpenKeyExW(hSubKey, pPrintProcessor->pwszName, 0, KEY_READ, &hSubSubKey);
221 if (dwErrorCode != ERROR_SUCCESS)
222 {
223 ERR("RegOpenKeyExW failed for Print Processor \"%S\" with status %lu!\n", pPrintProcessor->pwszName, dwErrorCode);
224 continue;
225 }
226
227 // Get the file name of the Print Processor.
228 cbFileName = sizeof(wszFileName);
229 dwErrorCode = (DWORD)RegQueryValueExW(hSubSubKey, L"Driver", NULL, NULL, (PBYTE)wszFileName, &cbFileName);
230 if (dwErrorCode != ERROR_SUCCESS)
231 {
232 ERR("RegQueryValueExW failed for Print Processor \"%S\" with status %lu!\n", pPrintProcessor->pwszName, dwErrorCode);
233 continue;
234 }
235
236 // Verify that our buffer is large enough.
237 if (cchPrintProcessorPath + cbFileName / sizeof(WCHAR) > MAX_PATH)
238 {
239 ERR("Print Processor directory \"%S\" for Print Processor \"%S\" is too long!\n", wszFileName, pPrintProcessor->pwszName);
240 continue;
241 }
242
243 // Construct the full path to the Print Processor.
244 CopyMemory(&wszPrintProcessorPath[cchPrintProcessorPath], wszFileName, cbFileName);
245
246 // Try to load it.
247 hinstPrintProcessor = LoadLibraryW(wszPrintProcessorPath);
248 if (!hinstPrintProcessor)
249 {
250 ERR("LoadLibraryW failed for \"%S\" with error %lu!\n", wszPrintProcessorPath, GetLastError());
251 continue;
252 }
253
254 // Get and verify all its function pointers.
255 pPrintProcessor->pfnClosePrintProcessor = (PClosePrintProcessor)GetProcAddress(hinstPrintProcessor, "ClosePrintProcessor");
256 if (!pPrintProcessor->pfnClosePrintProcessor)
257 {
258 ERR("Print Processor \"%S\" exports no ClosePrintProcessor!\n", wszPrintProcessorPath);
259 continue;
260 }
261
262 pPrintProcessor->pfnControlPrintProcessor = (PControlPrintProcessor)GetProcAddress(hinstPrintProcessor, "ControlPrintProcessor");
263 if (!pPrintProcessor->pfnControlPrintProcessor)
264 {
265 ERR("Print Processor \"%S\" exports no ControlPrintProcessor!\n", wszPrintProcessorPath);
266 continue;
267 }
268
269 pPrintProcessor->pfnEnumPrintProcessorDatatypesW = (PEnumPrintProcessorDatatypesW)GetProcAddress(hinstPrintProcessor, "EnumPrintProcessorDatatypesW");
270 if (!pPrintProcessor->pfnEnumPrintProcessorDatatypesW)
271 {
272 ERR("Print Processor \"%S\" exports no EnumPrintProcessorDatatypesW!\n", wszPrintProcessorPath);
273 continue;
274 }
275
276 pPrintProcessor->pfnGetPrintProcessorCapabilities = (PGetPrintProcessorCapabilities)GetProcAddress(hinstPrintProcessor, "GetPrintProcessorCapabilities");
277 if (!pPrintProcessor->pfnGetPrintProcessorCapabilities)
278 {
279 ERR("Print Processor \"%S\" exports no GetPrintProcessorCapabilities!\n", wszPrintProcessorPath);
280 continue;
281 }
282
283 pPrintProcessor->pfnOpenPrintProcessor = (POpenPrintProcessor)GetProcAddress(hinstPrintProcessor, "OpenPrintProcessor");
284 if (!pPrintProcessor->pfnOpenPrintProcessor)
285 {
286 ERR("Print Processor \"%S\" exports no OpenPrintProcessor!\n", wszPrintProcessorPath);
287 continue;
288 }
289
290 pPrintProcessor->pfnPrintDocumentOnPrintProcessor = (PPrintDocumentOnPrintProcessor)GetProcAddress(hinstPrintProcessor, "PrintDocumentOnPrintProcessor");
291 if (!pPrintProcessor->pfnPrintDocumentOnPrintProcessor)
292 {
293 ERR("Print Processor \"%S\" exports no PrintDocumentOnPrintProcessor!\n", wszPrintProcessorPath);
294 continue;
295 }
296
297 // Get all supported datatypes.
298 pPrintProcessor->pfnEnumPrintProcessorDatatypesW(NULL, NULL, 1, NULL, 0, &cbDatatypes, &pPrintProcessor->dwDatatypeCount);
299 pPrintProcessor->pDatatypesInfo1 = DllAllocSplMem(cbDatatypes);
300 if (!pPrintProcessor->pDatatypesInfo1)
301 {
302 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
303 ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
304 goto Cleanup;
305 }
306
307 if (!pPrintProcessor->pfnEnumPrintProcessorDatatypesW(NULL, NULL, 1, (PBYTE)pPrintProcessor->pDatatypesInfo1, cbDatatypes, &cbDatatypes, &pPrintProcessor->dwDatatypeCount))
308 {
309 ERR("EnumPrintProcessorDatatypesW failed for Print Processor \"%S\" with error %lu!\n", wszPrintProcessorPath, GetLastError());
310 continue;
311 }
312
313 // Add the Print Processor to the list.
314 InsertTailList(&_PrintProcessorList, &pPrintProcessor->Entry);
315
316 // Don't let the cleanup routines free this.
317 pPrintProcessor = NULL;
318 }
319
320 dwErrorCode = ERROR_SUCCESS;
321
322 Cleanup:
323 // Inside the loop
324 if (hSubSubKey)
325 RegCloseKey(hSubSubKey);
326
327 if (pPrintProcessor)
328 {
329 if (pPrintProcessor->pwszName)
330 DllFreeSplStr(pPrintProcessor->pwszName);
331
332 if (pPrintProcessor->pDatatypesInfo1)
333 DllFreeSplMem(pPrintProcessor->pDatatypesInfo1);
334
335 DllFreeSplMem(pPrintProcessor);
336 }
337
338 // Outside the loop
339 if (hSubKey)
340 RegCloseKey(hSubKey);
341
342 if (hKey)
343 RegCloseKey(hKey);
344
345 SetLastError(dwErrorCode);
346 return (dwErrorCode == ERROR_SUCCESS);
347 }
348
349 /**
350 * @name LocalEnumPrintProcessorDatatypes
351 *
352 * Obtains an array of all datatypes supported by a particular Print Processor.
353 * Print Provider function for EnumPrintProcessorDatatypesA/EnumPrintProcessorDatatypesW.
354 *
355 * @param pName
356 * Server Name. Ignored here, because every caller of LocalEnumPrintProcessorDatatypes is interested in the local directory.
357 *
358 * @param pPrintProcessorName
359 * The (case-insensitive) name of the Print Processor to query.
360 *
361 * @param Level
362 * The level of the structure supplied through pDatatypes. This must be 1.
363 *
364 * @param pDatatypes
365 * Pointer to the buffer that receives an array of DATATYPES_INFO_1W structures.
366 * Can be NULL if you just want to know the required size of the buffer.
367 *
368 * @param cbBuf
369 * Size of the buffer you supplied for pDatatypes, in bytes.
370 *
371 * @param pcbNeeded
372 * Pointer to a variable that receives the required size of the buffer for pDatatypes, in bytes.
373 * This parameter mustn't be NULL!
374 *
375 * @param pcReturned
376 * Pointer to a variable that receives the number of elements of the DATATYPES_INFO_1W array.
377 * This parameter mustn't be NULL!
378 *
379 * @return
380 * TRUE if we successfully copied the array into pDatatypes, FALSE otherwise.
381 * A more specific error code can be obtained through GetLastError.
382 */
383 BOOL WINAPI
384 LocalEnumPrintProcessorDatatypes(LPWSTR pName, LPWSTR pPrintProcessorName, DWORD Level, LPBYTE pDatatypes, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
385 {
386 DWORD dwErrorCode;
387 PLOCAL_PRINT_PROCESSOR pPrintProcessor;
388
389 // Sanity checks
390 if (Level != 1)
391 {
392 dwErrorCode = ERROR_INVALID_LEVEL;
393 goto Cleanup;
394 }
395
396 // Try to find the Print Processor.
397 pPrintProcessor = FindPrintProcessor(pPrintProcessorName);
398 if (!pPrintProcessor)
399 {
400 dwErrorCode = ERROR_UNKNOWN_PRINTPROCESSOR;
401 goto Cleanup;
402 }
403
404 // Call its EnumPrintProcessorDatatypesW function.
405 if (pPrintProcessor->pfnEnumPrintProcessorDatatypesW(pName, pPrintProcessorName, Level, pDatatypes, cbBuf, pcbNeeded, pcReturned))
406 dwErrorCode = ERROR_SUCCESS;
407 else
408 dwErrorCode = GetLastError();
409
410 Cleanup:
411 SetLastError(dwErrorCode);
412 return (dwErrorCode == ERROR_SUCCESS);
413 }
414
415 /**
416 * @name LocalEnumPrintProcessors
417 *
418 * Obtains an array of all available Print Processors on this computer.
419 * Print Provider function for EnumPrintProcessorsA/EnumPrintProcessorsW.
420 *
421 * @param pName
422 * Server Name. Ignored here, because every caller of LocalEnumPrintProcessors is interested in the local directory.
423 *
424 * @param pEnvironment
425 * One of the predefined operating system and architecture "environment" strings (like "Windows NT x86").
426 * Alternatively, NULL to output the Print Processor directory of the current environment.
427 *
428 * @param Level
429 * The level of the structure supplied through pPrintProcessorInfo. This must be 1.
430 *
431 * @param pPrintProcessorInfo
432 * Pointer to the buffer that receives an array of PRINTPROCESSOR_INFO_1W structures.
433 * Can be NULL if you just want to know the required size of the buffer.
434 *
435 * @param cbBuf
436 * Size of the buffer you supplied for pPrintProcessorInfo, in bytes.
437 *
438 * @param pcbNeeded
439 * Pointer to a variable that receives the required size of the buffer for pPrintProcessorInfo, in bytes.
440 * This parameter mustn't be NULL!
441 *
442 * @param pcReturned
443 * Pointer to a variable that receives the number of elements of the PRINTPROCESSOR_INFO_1W array.
444 * This parameter mustn't be NULL!
445 *
446 * @return
447 * TRUE if we successfully copied the array into pPrintProcessorInfo, FALSE otherwise.
448 * A more specific error code can be obtained through GetLastError.
449 */
450 BOOL WINAPI
451 LocalEnumPrintProcessors(LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
452 {
453 DWORD cchMaxSubKey;
454 DWORD cchPrintProcessor;
455 DWORD dwErrorCode;
456 DWORD dwPrintProcessorCount;
457 DWORD i;
458 HKEY hKey = NULL;
459 HKEY hSubKey = NULL;
460 PBYTE pCurrentOutputPrintProcessor;
461 PBYTE pCurrentOutputPrintProcessorInfo;
462 PRINTPROCESSOR_INFO_1W PrintProcessorInfo1;
463 PWSTR pwszTemp = NULL;
464
465 // Sanity checks
466 if (Level != 1)
467 {
468 dwErrorCode = ERROR_INVALID_LEVEL;
469 goto Cleanup;
470 }
471
472 if (!pcbNeeded || !pcReturned)
473 {
474 // This error is also caught by RPC and returned as RPC_X_NULL_REF_POINTER.
475 dwErrorCode = ERROR_INVALID_PARAMETER;
476 goto Cleanup;
477 }
478
479 // Verify pEnvironment and open its registry key.
480 // We use the registry and not the PrintProcessorList here, because the caller may request information about a different environment.
481 dwErrorCode = _OpenEnvironment(pEnvironment, &hKey);
482 if (dwErrorCode != ERROR_SUCCESS)
483 {
484 ERR("_OpenEnvironment failed with error %lu!\n", dwErrorCode);
485 goto Cleanup;
486 }
487
488 // Open the "Print Processors" subkey.
489 dwErrorCode = (DWORD)RegOpenKeyExW(hKey, L"Print Processors", 0, KEY_READ, &hSubKey);
490 if (dwErrorCode != ERROR_SUCCESS)
491 {
492 ERR("RegOpenKeyExW failed with status %lu!\n", dwErrorCode);
493 goto Cleanup;
494 }
495
496 // Get the number of Print Processors and maximum sub key length.
497 dwErrorCode = (DWORD)RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwPrintProcessorCount, &cchMaxSubKey, NULL, NULL, NULL, NULL, NULL, NULL);
498 if (dwErrorCode != ERROR_SUCCESS)
499 {
500 ERR("RegQueryInfoKeyW failed with status %lu!\n", dwErrorCode);
501 goto Cleanup;
502 }
503
504 // Allocate a temporary buffer to let RegEnumKeyExW succeed.
505 pwszTemp = DllAllocSplMem((cchMaxSubKey + 1) * sizeof(WCHAR));
506 if (!pwszTemp)
507 {
508 dwErrorCode = ERROR_NOT_ENOUGH_MEMORY;
509 ERR("DllAllocSplMem failed with error %lu!\n", GetLastError());
510 goto Cleanup;
511 }
512
513 // Determine the required size of the output buffer.
514 *pcbNeeded = 0;
515
516 for (i = 0; i < dwPrintProcessorCount; i++)
517 {
518 // RegEnumKeyExW sucks! Unlike similar API functions, it only returns the actual numbers of characters copied when you supply a buffer large enough.
519 // So use pwszTemp with its size cchMaxSubKey for this.
520 cchPrintProcessor = cchMaxSubKey + 1;
521 dwErrorCode = (DWORD)RegEnumKeyExW(hSubKey, i, pwszTemp, &cchPrintProcessor, NULL, NULL, NULL, NULL);
522 if (dwErrorCode != ERROR_SUCCESS)
523 {
524 ERR("RegEnumKeyExW failed with status %lu!\n", dwErrorCode);
525 goto Cleanup;
526 }
527
528 *pcbNeeded += sizeof(PRINTPROCESSOR_INFO_1W) + (cchPrintProcessor + 1) * sizeof(WCHAR);
529 }
530
531 // Check if the supplied buffer is large enough.
532 if (cbBuf < *pcbNeeded)
533 {
534 dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
535 goto Cleanup;
536 }
537
538 // Put the Print Processor strings right after the last PRINTPROCESSOR_INFO_1W structure.
539 pCurrentOutputPrintProcessorInfo = pPrintProcessorInfo;
540 pCurrentOutputPrintProcessor = pPrintProcessorInfo + dwPrintProcessorCount * sizeof(PRINTPROCESSOR_INFO_1W);
541
542 // Copy over all Print Processors.
543 for (i = 0; i < dwPrintProcessorCount; i++)
544 {
545 // This isn't really correct, but doesn't cause any harm, because we've extensively checked the size of the supplied buffer above.
546 cchPrintProcessor = cchMaxSubKey + 1;
547
548 // Copy the Print Processor name.
549 dwErrorCode = (DWORD)RegEnumKeyExW(hSubKey, i, (PWSTR)pCurrentOutputPrintProcessor, &cchPrintProcessor, NULL, NULL, NULL, NULL);
550 if (dwErrorCode != ERROR_SUCCESS)
551 {
552 ERR("RegEnumKeyExW failed with status %lu!\n", dwErrorCode);
553 goto Cleanup;
554 }
555
556 // Fill and copy the PRINTPROCESSOR_INFO_1W structure belonging to this Print Processor.
557 PrintProcessorInfo1.pName = (PWSTR)pCurrentOutputPrintProcessor;
558 CopyMemory(pCurrentOutputPrintProcessorInfo, &PrintProcessorInfo1, sizeof(PRINTPROCESSOR_INFO_1W));
559
560 // Advance to the next PRINTPROCESSOR_INFO_1W location and string location in the output buffer.
561 pCurrentOutputPrintProcessor += (cchPrintProcessor + 1) * sizeof(WCHAR);
562 pCurrentOutputPrintProcessorInfo += sizeof(PRINTPROCESSOR_INFO_1W);
563 }
564
565 // We've finished successfully!
566 *pcReturned = dwPrintProcessorCount;
567 dwErrorCode = ERROR_SUCCESS;
568
569 Cleanup:
570 if (pwszTemp)
571 DllFreeSplMem(pwszTemp);
572
573 if (hSubKey)
574 RegCloseKey(hSubKey);
575
576 if (hKey)
577 RegCloseKey(hKey);
578
579 SetLastError(dwErrorCode);
580 return (dwErrorCode == ERROR_SUCCESS);
581 }
582
583 /**
584 * @name LocalGetPrintProcessorDirectory
585 *
586 * Obtains the path to the local Print Processor directory.
587 * Print Provider function for GetPrintProcessorDirectoryA/GetPrintProcessorDirectoryW.
588 *
589 * @param pName
590 * Server Name. Ignored here, because every caller of LocalGetPrintProcessorDirectory is interested in the local directory.
591 *
592 * @param pEnvironment
593 * One of the predefined operating system and architecture "environment" strings (like "Windows NT x86").
594 * Alternatively, NULL to output the Print Processor directory of the current environment.
595 *
596 * @param Level
597 * The level of the (non-existing) structure supplied through pPrintProcessorInfo. This must be 1.
598 *
599 * @param pPrintProcessorInfo
600 * Pointer to the buffer that receives the full path to the Print Processor directory.
601 * Can be NULL if you just want to know the required size of the buffer.
602 *
603 * @param cbBuf
604 * Size of the buffer you supplied for pPrintProcessorInfo, in bytes.
605 *
606 * @param pcbNeeded
607 * Pointer to a variable that receives the required size of the buffer for pPrintProcessorInfo, in bytes.
608 * This parameter mustn't be NULL!
609 *
610 * @return
611 * TRUE if we successfully copied the directory into pPrintProcessorInfo, FALSE otherwise.
612 * A more specific error code can be obtained through GetLastError.
613 */
614 BOOL WINAPI
615 LocalGetPrintProcessorDirectory(LPWSTR pName, LPWSTR pEnvironment, DWORD Level, LPBYTE pPrintProcessorInfo, DWORD cbBuf, LPDWORD pcbNeeded)
616 {
617 const WCHAR wszPath[] = L"\\PRTPROCS\\";
618 const DWORD cchPath = _countof(wszPath) - 1;
619
620 DWORD cbDataWritten;
621 DWORD dwErrorCode;
622 HKEY hKey = NULL;
623
624 // Sanity checks
625 if (Level != 1)
626 {
627 dwErrorCode = ERROR_INVALID_LEVEL;
628 goto Cleanup;
629 }
630
631 if (!pcbNeeded)
632 {
633 // This error is also caught by RPC and returned as RPC_X_NULL_REF_POINTER.
634 dwErrorCode = ERROR_INVALID_PARAMETER;
635 goto Cleanup;
636 }
637
638 // Verify pEnvironment and open its registry key.
639 dwErrorCode = _OpenEnvironment(pEnvironment, &hKey);
640 if (dwErrorCode != ERROR_SUCCESS)
641 {
642 ERR("_OpenEnvironment failed with error %lu!\n", dwErrorCode);
643 goto Cleanup;
644 }
645
646 // Determine the size of the required buffer.
647 dwErrorCode = (DWORD)RegQueryValueExW(hKey, L"Directory", NULL, NULL, NULL, pcbNeeded);
648 if (dwErrorCode != ERROR_SUCCESS)
649 {
650 ERR("RegQueryValueExW failed with status %lu!\n", dwErrorCode);
651 goto Cleanup;
652 }
653
654 *pcbNeeded += cchSpoolDirectory;
655 *pcbNeeded += cchPath;
656
657 // Is the supplied buffer large enough?
658 if (cbBuf < *pcbNeeded)
659 {
660 dwErrorCode = ERROR_INSUFFICIENT_BUFFER;
661 goto Cleanup;
662 }
663
664 // Copy the path to the "prtprocs" directory into pPrintProcessorInfo
665 CopyMemory(pPrintProcessorInfo, wszSpoolDirectory, cchSpoolDirectory * sizeof(WCHAR));
666 CopyMemory(&pPrintProcessorInfo[cchSpoolDirectory], wszPath, cchPath * sizeof(WCHAR));
667
668 // Get the directory name from the registry.
669 dwErrorCode = (DWORD)RegQueryValueExW(hKey, L"Directory", NULL, NULL, &pPrintProcessorInfo[cchSpoolDirectory + cchPath], &cbDataWritten);
670 if (dwErrorCode != ERROR_SUCCESS)
671 {
672 ERR("RegQueryValueExW failed with status %lu!\n", dwErrorCode);
673 goto Cleanup;
674 }
675
676 // We've finished successfully!
677 dwErrorCode = ERROR_SUCCESS;
678
679 Cleanup:
680 if (hKey)
681 RegCloseKey(hKey);
682
683 SetLastError(dwErrorCode);
684 return (dwErrorCode == ERROR_SUCCESS);
685 }