2 * Routing for Spooler-Service helper DLL
4 * Copyright 2006-2009 Detlef Riekenberg
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include <ddk/winsplp.h>
29 /* ################################ */
34 /* PRINTPROVIDOR functions */
35 DWORD (WINAPI
*fpOpenPrinter
)(LPWSTR
, HANDLE
*, LPPRINTER_DEFAULTSW
);
36 DWORD (WINAPI
*fpSetJob
)(HANDLE
, DWORD
, DWORD
, LPBYTE
, DWORD
);
37 DWORD (WINAPI
*fpGetJob
)(HANDLE
, DWORD
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
38 DWORD (WINAPI
*fpEnumJobs
)(HANDLE
, DWORD
, DWORD
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
39 HANDLE (WINAPI
*fpAddPrinter
)(LPWSTR
, DWORD
, LPBYTE
);
40 DWORD (WINAPI
*fpDeletePrinter
)(HANDLE
);
41 DWORD (WINAPI
*fpSetPrinter
)(HANDLE
, DWORD
, LPBYTE
, DWORD
);
42 DWORD (WINAPI
*fpGetPrinter
)(HANDLE
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
43 DWORD (WINAPI
*fpEnumPrinters
)(DWORD
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
44 DWORD (WINAPI
*fpAddPrinterDriver
)(LPWSTR
, DWORD
, LPBYTE
);
45 DWORD (WINAPI
*fpEnumPrinterDrivers
)(LPWSTR
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
46 DWORD (WINAPI
*fpGetPrinterDriver
)(HANDLE
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
47 DWORD (WINAPI
*fpGetPrinterDriverDirectory
)(LPWSTR
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
48 DWORD (WINAPI
*fpDeletePrinterDriver
)(LPWSTR
, LPWSTR
, LPWSTR
);
49 DWORD (WINAPI
*fpAddPrintProcessor
)(LPWSTR
, LPWSTR
, LPWSTR
, LPWSTR
);
50 DWORD (WINAPI
*fpEnumPrintProcessors
)(LPWSTR
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
51 DWORD (WINAPI
*fpGetPrintProcessorDirectory
)(LPWSTR
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
52 DWORD (WINAPI
*fpDeletePrintProcessor
)(LPWSTR
, LPWSTR
, LPWSTR
);
53 DWORD (WINAPI
*fpEnumPrintProcessorDatatypes
)(LPWSTR
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
54 DWORD (WINAPI
*fpStartDocPrinter
)(HANDLE
, DWORD
, LPBYTE
);
55 DWORD (WINAPI
*fpStartPagePrinter
)(HANDLE
);
56 DWORD (WINAPI
*fpWritePrinter
)(HANDLE
, LPVOID
, DWORD
, LPDWORD
);
57 DWORD (WINAPI
*fpEndPagePrinter
)(HANDLE
);
58 DWORD (WINAPI
*fpAbortPrinter
)(HANDLE
);
59 DWORD (WINAPI
*fpReadPrinter
)(HANDLE
, LPVOID
, DWORD
, LPDWORD
);
60 DWORD (WINAPI
*fpEndDocPrinter
)(HANDLE
);
61 DWORD (WINAPI
*fpAddJob
)(HANDLE
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
62 DWORD (WINAPI
*fpScheduleJob
)(HANDLE
, DWORD
);
63 DWORD (WINAPI
*fpGetPrinterData
)(HANDLE
, LPWSTR
, LPDWORD
, LPBYTE
, DWORD
, LPDWORD
);
64 DWORD (WINAPI
*fpSetPrinterData
)(HANDLE
, LPWSTR
, DWORD
, LPBYTE
, DWORD
);
65 DWORD (WINAPI
*fpWaitForPrinterChange
)(HANDLE
, DWORD
);
66 DWORD (WINAPI
*fpClosePrinter
)(HANDLE
);
67 DWORD (WINAPI
*fpAddForm
)(HANDLE
, DWORD
, LPBYTE
);
68 DWORD (WINAPI
*fpDeleteForm
)(HANDLE
, LPWSTR
);
69 DWORD (WINAPI
*fpGetForm
)(HANDLE
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
);
70 DWORD (WINAPI
*fpSetForm
)(HANDLE
, LPWSTR
, DWORD
, LPBYTE
);
71 DWORD (WINAPI
*fpEnumForms
)(HANDLE
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
72 DWORD (WINAPI
*fpEnumMonitors
)(LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
73 DWORD (WINAPI
*fpEnumPorts
)(LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
74 DWORD (WINAPI
*fpAddPort
)(LPWSTR
, HWND
, LPWSTR
);
75 DWORD (WINAPI
*fpConfigurePort
)(LPWSTR
, HWND
, LPWSTR
);
76 DWORD (WINAPI
*fpDeletePort
)(LPWSTR
, HWND
, LPWSTR
);
77 HANDLE (WINAPI
*fpCreatePrinterIC
)(HANDLE
, LPDEVMODEW
);
78 DWORD (WINAPI
*fpPlayGdiScriptOnPrinterIC
)(HANDLE
, LPBYTE
, DWORD
, LPBYTE
, DWORD
, DWORD
);
79 DWORD (WINAPI
*fpDeletePrinterIC
)(HANDLE
);
80 DWORD (WINAPI
*fpAddPrinterConnection
)(LPWSTR
);
81 DWORD (WINAPI
*fpDeletePrinterConnection
)(LPWSTR
);
82 DWORD (WINAPI
*fpPrinterMessageBox
)(HANDLE
, DWORD
, HWND
, LPWSTR
, LPWSTR
, DWORD
);
83 DWORD (WINAPI
*fpAddMonitor
)(LPWSTR
, DWORD
, LPBYTE
);
84 DWORD (WINAPI
*fpDeleteMonitor
)(LPWSTR
, LPWSTR
, LPWSTR
);
85 DWORD (WINAPI
*fpResetPrinter
)(HANDLE
, LPPRINTER_DEFAULTSW
);
86 DWORD (WINAPI
*fpGetPrinterDriverEx
)(HANDLE
, LPWSTR
, DWORD
, LPBYTE
, DWORD
, LPDWORD
, DWORD
, DWORD
, PDWORD
, PDWORD
);
87 HANDLE (WINAPI
*fpFindFirstPrinterChangeNotification
)(HANDLE
, DWORD
, DWORD
, LPVOID
);
88 DWORD (WINAPI
*fpFindClosePrinterChangeNotification
)(HANDLE
);
89 DWORD (WINAPI
*fpAddPortEx
)(HANDLE
, LPWSTR
, DWORD
, LPBYTE
, LPWSTR
);
90 DWORD (WINAPI
*fpShutDown
)(LPVOID
);
91 DWORD (WINAPI
*fpRefreshPrinterChangeNotification
)(HANDLE
, DWORD
, PVOID
, PVOID
);
92 DWORD (WINAPI
*fpOpenPrinterEx
)(LPWSTR
, LPHANDLE
, LPPRINTER_DEFAULTSW
, LPBYTE
, DWORD
);
93 HANDLE (WINAPI
*fpAddPrinterEx
)(LPWSTR
, DWORD
, LPBYTE
, LPBYTE
, DWORD
);
94 DWORD (WINAPI
*fpSetPort
)(LPWSTR
, LPWSTR
, DWORD
, LPBYTE
);
95 DWORD (WINAPI
*fpEnumPrinterData
)(HANDLE
, DWORD
, LPWSTR
, DWORD
, LPDWORD
, LPDWORD
, LPBYTE
, DWORD
, LPDWORD
);
96 DWORD (WINAPI
*fpDeletePrinterData
)(HANDLE
, LPWSTR
);
97 DWORD (WINAPI
*fpClusterSplOpen
)(LPCWSTR
, LPCWSTR
, PHANDLE
, LPCWSTR
, LPCWSTR
);
98 DWORD (WINAPI
*fpClusterSplClose
)(HANDLE
);
99 DWORD (WINAPI
*fpClusterSplIsAlive
)(HANDLE
);
100 DWORD (WINAPI
*fpSetPrinterDataEx
)(HANDLE
, LPCWSTR
, LPCWSTR
, DWORD
, LPBYTE
, DWORD
);
101 DWORD (WINAPI
*fpGetPrinterDataEx
)(HANDLE
, LPCWSTR
, LPCWSTR
, LPDWORD
, LPBYTE
, DWORD
, LPDWORD
);
102 DWORD (WINAPI
*fpEnumPrinterDataEx
)(HANDLE
, LPCWSTR
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
103 DWORD (WINAPI
*fpEnumPrinterKey
)(HANDLE
, LPCWSTR
, LPWSTR
, DWORD
, LPDWORD
);
104 DWORD (WINAPI
*fpDeletePrinterDataEx
)(HANDLE
, LPCWSTR
, LPCWSTR
);
105 DWORD (WINAPI
*fpDeletePrinterKey
)(HANDLE hPrinter
, LPCWSTR pKeyName
);
106 DWORD (WINAPI
*fpSeekPrinter
)(HANDLE
, LARGE_INTEGER
, PLARGE_INTEGER
, DWORD
, BOOL
);
107 DWORD (WINAPI
*fpDeletePrinterDriverEx
)(LPWSTR
, LPWSTR
, LPWSTR
, DWORD
, DWORD
);
108 DWORD (WINAPI
*fpAddPerMachineConnection
)(LPCWSTR
, LPCWSTR
, LPCWSTR
, LPCWSTR
);
109 DWORD (WINAPI
*fpDeletePerMachineConnection
)(LPCWSTR
, LPCWSTR
);
110 DWORD (WINAPI
*fpEnumPerMachineConnections
)(LPCWSTR
, LPBYTE
, DWORD
, LPDWORD
, LPDWORD
);
111 DWORD (WINAPI
*fpXcvData
)(HANDLE
, LPCWSTR
, PBYTE
, DWORD
, PBYTE
, DWORD
, PDWORD
, PDWORD
);
112 DWORD (WINAPI
*fpAddPrinterDriverEx
)(LPWSTR
, DWORD
, LPBYTE
, DWORD
);
113 DWORD (WINAPI
*fpSplReadPrinter
)(HANDLE
, LPBYTE
*, DWORD
);
114 DWORD (WINAPI
*fpDriverUnloadComplete
)(LPWSTR
);
115 DWORD (WINAPI
*fpGetSpoolFileInfo
)(HANDLE
, LPWSTR
*, LPHANDLE
, HANDLE
, HANDLE
);
116 DWORD (WINAPI
*fpCommitSpoolData
)(HANDLE
, DWORD
);
117 DWORD (WINAPI
*fpCloseSpoolFileHandle
)(HANDLE
);
118 DWORD (WINAPI
*fpFlushPrinter
)(HANDLE
, LPBYTE
, DWORD
, LPDWORD
, DWORD
);
119 DWORD (WINAPI
*fpSendRecvBidiData
)(HANDLE
, LPCWSTR
, LPBIDI_REQUEST_CONTAINER
, LPBIDI_RESPONSE_CONTAINER
*);
120 DWORD (WINAPI
*fpAddDriverCatalog
)(HANDLE
, DWORD
, VOID
*, DWORD
);
129 /* ################################ */
131 static backend_t
*backend
[MAX_BACKEND
];
132 static DWORD used_backends
= 0;
134 static CRITICAL_SECTION backend_cs
;
135 static CRITICAL_SECTION_DEBUG backend_cs_debug
=
138 { &backend_cs_debug
.ProcessLocksList
, &backend_cs_debug
.ProcessLocksList
},
139 0, 0, { (DWORD_PTR
)(__FILE__
": backend_cs") }
141 static CRITICAL_SECTION backend_cs
= { &backend_cs_debug
, -1, 0, 0, 0, 0 };
143 /* ################################ */
145 static WCHAR localsplW
[] = {'l','o','c','a','l','s','p','l','.','d','l','l',0};
147 /******************************************************************
150 * create a copy of a unicode-string
154 static LPWSTR
strdupW(LPCWSTR p
)
160 len
= (lstrlenW(p
) + 1) * sizeof(WCHAR
);
161 ret
= heap_alloc(len
);
166 /******************************************************************
167 * backend_unload_all [internal]
169 * unload all backends
171 void backend_unload_all(void)
173 EnterCriticalSection(&backend_cs
);
174 while (used_backends
> 0) {
176 FreeLibrary(backend
[used_backends
]->dll
);
177 heap_free(backend
[used_backends
]->dllname
);
178 heap_free(backend
[used_backends
]->name
);
179 heap_free(backend
[used_backends
]->regroot
);
180 heap_free(backend
[used_backends
]);
181 backend
[used_backends
] = NULL
;
183 LeaveCriticalSection(&backend_cs
);
186 /******************************************************************************
187 * backend_load [internal]
189 * load and init a backend
192 * name [I] Printprovider to use for the backend. NULL for the local print provider
195 * Success: PTR to the backend
199 static backend_t
* backend_load(LPWSTR dllname
, LPWSTR name
, LPWSTR regroot
)
202 BOOL (WINAPI
*pInitializePrintProvidor
)(LPPRINTPROVIDOR
, DWORD
, LPWSTR
);
206 TRACE("(%s, %s, %s)\n", debugstr_w(dllname
), debugstr_w(name
), debugstr_w(regroot
));
208 EnterCriticalSection(&backend_cs
);
211 backend
[id
] = heap_alloc_zero(sizeof(backend_t
));
213 LeaveCriticalSection(&backend_cs
);
217 backend
[id
]->dllname
= strdupW(dllname
);
218 backend
[id
]->name
= strdupW(name
);
219 backend
[id
]->regroot
= strdupW(regroot
);
221 backend
[id
]->dll
= LoadLibraryW(dllname
);
222 if (backend
[id
]->dll
) {
223 pInitializePrintProvidor
= (void *) GetProcAddress(backend
[id
]->dll
, "InitializePrintProvidor");
224 if (pInitializePrintProvidor
) {
226 /* native localspl does not clear unused entries */
227 res
= pInitializePrintProvidor((PRINTPROVIDOR
*) backend
[id
], sizeof(PRINTPROVIDOR
), regroot
);
230 backend
[id
]->index
= used_backends
;
231 LeaveCriticalSection(&backend_cs
);
232 TRACE("--> backend #%d: %p (%s)\n", id
, backend
[id
], debugstr_w(dllname
));
236 FreeLibrary(backend
[id
]->dll
);
238 heap_free(backend
[id
]->dllname
);
239 heap_free(backend
[id
]->name
);
240 heap_free(backend
[id
]->regroot
);
241 heap_free(backend
[id
]);
243 LeaveCriticalSection(&backend_cs
);
244 WARN("failed to init %s: %u\n", debugstr_w(dllname
), GetLastError());
248 /******************************************************************************
249 * backend_load_all [internal]
251 * load and init all backends
258 BOOL
backend_load_all(void)
260 static BOOL failed
= FALSE
;
262 EnterCriticalSection(&backend_cs
);
264 /* if we failed before, don't try again */
265 if (!failed
&& (used_backends
== 0)) {
266 backend_load(localsplW
, NULL
, NULL
);
268 /* ToDo: parse the registry and load all other backends */
270 failed
= (used_backends
== 0);
272 LeaveCriticalSection(&backend_cs
);
273 TRACE("-> %d\n", !failed
);
277 /******************************************************************************
278 * backend_first [internal]
280 * find the first usable backend
283 * Success: PTR to the backend
287 static backend_t
* backend_first(LPWSTR name
)
290 EnterCriticalSection(&backend_cs
);
291 /* Load all backends, when not done yet */
292 if (used_backends
|| backend_load_all()) {
294 /* test for the local system first */
295 if (!name
|| !name
[0]) {
296 LeaveCriticalSection(&backend_cs
);
301 FIXME("server %s not supported in %d backends\n", debugstr_w(name
), used_backends
);
302 LeaveCriticalSection(&backend_cs
);
306 /******************************************************************
307 * AddMonitorW (spoolss.@)
309 * Install a Printmonitor
312 * pName [I] Servername or NULL (local Computer)
313 * Level [I] Structure-Level (Must be 2)
314 * pMonitors [I] PTR to MONITOR_INFO_2
321 * All Files for the Monitor must already be copied to %winsysdir% ("%SystemRoot%\system32")
324 BOOL WINAPI
AddMonitorW(LPWSTR pName
, DWORD Level
, LPBYTE pMonitors
)
327 DWORD res
= ROUTER_UNKNOWN
;
329 TRACE("(%s, %d, %p)\n", debugstr_w(pName
), Level
, pMonitors
);
332 SetLastError(ERROR_INVALID_LEVEL
);
336 pb
= backend_first(pName
);
337 if (pb
&& pb
->fpAddMonitor
)
338 res
= pb
->fpAddMonitor(pName
, Level
, pMonitors
);
341 SetLastError(ERROR_PROC_NOT_FOUND
);
344 TRACE("got %u with %u\n", res
, GetLastError());
345 return (res
== ROUTER_SUCCESS
);
348 /******************************************************************
349 * AddPrinterDriverExW (spoolss.@)
351 * Install a Printer Driver with the Option to upgrade / downgrade the Files
354 * pName [I] Servername or NULL (local Computer)
355 * level [I] Level for the supplied DRIVER_INFO_*W struct
356 * pDriverInfo [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
357 * dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
364 BOOL WINAPI
AddPrinterDriverExW(LPWSTR pName
, DWORD level
, LPBYTE pDriverInfo
, DWORD dwFileCopyFlags
)
367 DWORD res
= ROUTER_UNKNOWN
;
369 TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName
), level
, pDriverInfo
, dwFileCopyFlags
);
372 SetLastError(ERROR_INVALID_PARAMETER
);
376 pb
= backend_first(pName
);
377 if (pb
&& pb
->fpAddPrinterDriverEx
)
378 res
= pb
->fpAddPrinterDriverEx(pName
, level
, pDriverInfo
, dwFileCopyFlags
);
381 SetLastError(ERROR_PROC_NOT_FOUND
);
384 TRACE("got %u with %u\n", res
, GetLastError());
385 return (res
== ROUTER_SUCCESS
);
388 /******************************************************************
389 * DeleteMonitorW (spoolss.@)
391 * Delete a specific Printmonitor from a Printing-Environment
394 * pName [I] Servername or NULL (local Computer)
395 * pEnvironment [I] Printing-Environment of the Monitor or NULL (Default)
396 * pMonitorName [I] Name of the Monitor, that should be deleted
403 BOOL WINAPI
DeleteMonitorW(LPWSTR pName
, LPWSTR pEnvironment
, LPWSTR pMonitorName
)
406 DWORD res
= ROUTER_UNKNOWN
;
408 TRACE("(%s, %s, %s)\n", debugstr_w(pName
), debugstr_w(pEnvironment
), debugstr_w(pMonitorName
));
410 pb
= backend_first(pName
);
411 if (pb
&& pb
->fpDeleteMonitor
)
412 res
= pb
->fpDeleteMonitor(pName
, pEnvironment
, pMonitorName
);
415 SetLastError(ERROR_PROC_NOT_FOUND
);
418 TRACE("got %u with %u\n", res
, GetLastError());
419 return (res
== ROUTER_SUCCESS
);
422 /******************************************************************
423 * EnumMonitorsW (spoolss.@)
425 * Enumerate available Port-Monitors
428 * pName [I] Servername or NULL (local Computer)
429 * Level [I] Structure-Level
430 * pMonitors [O] PTR to Buffer that receives the Result
431 * cbBuf [I] Size of Buffer at pMonitors
432 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
433 * pcReturned [O] PTR to DWORD that receives the number of Monitors in pMonitors
437 * Failure: FALSE and in pcbNeeded the Bytes required for pMonitors, if cbBuf is too small
440 BOOL WINAPI
EnumMonitorsW(LPWSTR pName
, DWORD Level
, LPBYTE pMonitors
, DWORD cbBuf
,
441 LPDWORD pcbNeeded
, LPDWORD pcReturned
)
444 DWORD res
= ROUTER_UNKNOWN
;
446 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName
), Level
, pMonitors
,
447 cbBuf
, pcbNeeded
, pcReturned
);
449 if (pcbNeeded
) *pcbNeeded
= 0;
450 if (pcReturned
) *pcReturned
= 0;
452 pb
= backend_first(pName
);
453 if (pb
&& pb
->fpEnumMonitors
)
454 res
= pb
->fpEnumMonitors(pName
, Level
, pMonitors
, cbBuf
, pcbNeeded
, pcReturned
);
457 SetLastError(ERROR_PROC_NOT_FOUND
);
460 TRACE("got %u with %u (%u byte for %u entries)\n\n", res
, GetLastError(),
461 pcbNeeded
? *pcbNeeded
: 0, pcReturned
? *pcReturned
: 0);
463 return (res
== ROUTER_SUCCESS
);
466 /******************************************************************
467 * EnumPortsW (spoolss.@)
469 * Enumerate available Ports
472 * pName [I] Servername or NULL (local Computer)
473 * Level [I] Structure-Level (1 or 2)
474 * pPorts [O] PTR to Buffer that receives the Result
475 * cbBuf [I] Size of Buffer at pPorts
476 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPorts
477 * pcReturned [O] PTR to DWORD that receives the number of Ports in pPorts
481 * Failure: FALSE and in pcbNeeded the Bytes required for pPorts, if cbBuf is too small
484 BOOL WINAPI
EnumPortsW(LPWSTR pName
, DWORD Level
, LPBYTE pPorts
, DWORD cbBuf
,
485 LPDWORD pcbNeeded
, LPDWORD pcReturned
)
488 DWORD res
= ROUTER_UNKNOWN
;
490 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName
), Level
, pPorts
, cbBuf
,
491 pcbNeeded
, pcReturned
);
493 if (pcbNeeded
) *pcbNeeded
= 0;
494 if (pcReturned
) *pcReturned
= 0;
496 pb
= backend_first(pName
);
497 if (pb
&& pb
->fpEnumPorts
)
498 res
= pb
->fpEnumPorts(pName
, Level
, pPorts
, cbBuf
, pcbNeeded
, pcReturned
);
501 SetLastError(ERROR_PROC_NOT_FOUND
);
504 TRACE("got %u with %u (%u byte for %u entries)\n", res
, GetLastError(),
505 pcbNeeded
? *pcbNeeded
: 0, pcReturned
? *pcReturned
: 0);
507 return (res
== ROUTER_SUCCESS
);
510 /******************************************************************
511 * GetPrinterDriverDirectoryW (spoolss.@)
513 * Return the PATH for the Printer-Drivers
516 * pName [I] Servername or NULL (local Computer)
517 * pEnvironment [I] Printing-Environment or NULL (Default)
518 * Level [I] Structure-Level (must be 1)
519 * pDriverDirectory [O] PTR to Buffer that receives the Result
520 * cbBuf [I] Size of Buffer at pDriverDirectory
521 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used /
522 * required for pDriverDirectory
525 * Success: TRUE and in pcbNeeded the Bytes used in pDriverDirectory
526 * Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
527 * if cbBuf is too small
529 * Native Values returned in pDriverDirectory on Success:
530 *| NT(Windows NT x86): "%winsysdir%\\spool\\DRIVERS\\w32x86"
531 *| NT(Windows x64): "%winsysdir%\\spool\\DRIVERS\\x64"
532 *| NT(Windows 4.0): "%winsysdir%\\spool\\DRIVERS\\win40"
533 *| win9x(Windows 4.0): "%winsysdir%"
535 * "%winsysdir%" is the Value from GetSystemDirectoryW()
538 BOOL WINAPI
GetPrinterDriverDirectoryW(LPWSTR pName
, LPWSTR pEnvironment
,
539 DWORD Level
, LPBYTE pDriverDirectory
, DWORD cbBuf
, LPDWORD pcbNeeded
)
542 DWORD res
= ROUTER_UNKNOWN
;
544 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName
),
545 debugstr_w(pEnvironment
), Level
, pDriverDirectory
, cbBuf
, pcbNeeded
);
547 if (pcbNeeded
) *pcbNeeded
= 0;
549 pb
= backend_first(pName
);
550 if (pb
&& pb
->fpGetPrinterDriverDirectory
)
551 res
= pb
->fpGetPrinterDriverDirectory(pName
, pEnvironment
, Level
,
552 pDriverDirectory
, cbBuf
, pcbNeeded
);
555 SetLastError(ERROR_PROC_NOT_FOUND
);
558 TRACE("got %u with %u (%u byte)\n",
559 res
, GetLastError(), pcbNeeded
? *pcbNeeded
: 0);
561 return (res
== ROUTER_SUCCESS
);