?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Get rid of the useless "isPBuffer" bitfield in struct wined3d_context.
[wine.git] / dlls / winspool.drv / info.c
blob7dac2b66501cf92f107eca73d2afb95c28879ca6
1 /*
2 * WINSPOOL functions
3 *
4 * Copyright 1996 John Harvey
5 * Copyright 1998 Andreas Mohr
6 * Copyright 1999 Klaas van Gend
7 * Copyright 1999, 2000 Huw D M Davies
8 * Copyright 2001 Marcus Meissner
9 * Copyright 2005-2009 Detlef Riekenberg
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25
26 #include "config.h"
27 #include "wine/port.h"
28
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <ctype.h>
34 #include <stddef.h>
35 #ifdef HAVE_UNISTD_H
36 # include <unistd.h>
37 #endif
38 #include <signal.h>
39 #ifdef HAVE_CUPS_CUPS_H
40 # include <cups/cups.h>
41 #endif
42
43 #define NONAMELESSUNION
44 #define NONAMELESSSTRUCT
45 #include "wine/library.h"
46 #include "windef.h"
47 #include "winbase.h"
48 #include "winuser.h"
49 #include "winerror.h"
50 #include "winreg.h"
51 #include "wingdi.h"
52 #include "winspool.h"
53 #include "winternl.h"
54 #include "wine/windef16.h"
55 #include "wine/unicode.h"
56 #include "wine/debug.h"
57 #include "wine/list.h"
58 #include "winnls.h"
59
60 #include "ddk/winsplp.h"
61 #include "wspool.h"
62
63 WINE_DEFAULT_DEBUG_CHANNEL(winspool);
64
65 /* ############################### */
66
67 static CRITICAL_SECTION printer_handles_cs;
68 static CRITICAL_SECTION_DEBUG printer_handles_cs_debug =
69 {
70 0, 0, &printer_handles_cs,
71 { &printer_handles_cs_debug.ProcessLocksList, &printer_handles_cs_debug.ProcessLocksList },
72 0, 0, { (DWORD_PTR)(__FILE__ ": printer_handles_cs") }
73 };
74 static CRITICAL_SECTION printer_handles_cs = { &printer_handles_cs_debug, -1, 0, 0, 0, 0 };
75
76 /* ############################### */
77
78 typedef struct {
79 DWORD job_id;
80 HANDLE hf;
81 } started_doc_t;
82
83 typedef struct {
84 struct list jobs;
85 LONG ref;
86 } jobqueue_t;
87
88 typedef struct {
89 LPWSTR name;
90 LPWSTR printername;
91 HANDLE backend_printer;
92 jobqueue_t *queue;
93 started_doc_t *doc;
94 } opened_printer_t;
95
96 typedef struct {
97 struct list entry;
98 DWORD job_id;
99 WCHAR *filename;
100 WCHAR *document_title;
101 } job_t;
102
103
104 typedef struct {
105 LPCWSTR envname;
106 LPCWSTR subdir;
107 DWORD driverversion;
108 LPCWSTR versionregpath;
109 LPCWSTR versionsubdir;
110 } printenv_t;
111
112 /* ############################### */
113
114 static opened_printer_t **printer_handles;
115 static UINT nb_printer_handles;
116 static LONG next_job_id = 1;
117
118 static DWORD (WINAPI *GDI_CallDeviceCapabilities16)( LPCSTR lpszDevice, LPCSTR lpszPort,
119 WORD fwCapability, LPSTR lpszOutput,
120 LPDEVMODEA lpdm );
121 static INT (WINAPI *GDI_CallExtDeviceMode16)( HWND hwnd, LPDEVMODEA lpdmOutput,
122 LPSTR lpszDevice, LPSTR lpszPort,
123 LPDEVMODEA lpdmInput, LPSTR lpszProfile,
124 DWORD fwMode );
125
126 static const WCHAR DriversW[] = { 'S','y','s','t','e','m','\\',
127 'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
128 'c','o','n','t','r','o','l','\\',
129 'P','r','i','n','t','\\',
130 'E','n','v','i','r','o','n','m','e','n','t','s','\\',
131 '%','s','\\','D','r','i','v','e','r','s','%','s',0 };
132
133 static const WCHAR PrintersW[] = {'S','y','s','t','e','m','\\',
134 'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
135 'C','o','n','t','r','o','l','\\',
136 'P','r','i','n','t','\\',
137 'P','r','i','n','t','e','r','s',0};
138
139 static const WCHAR LocalPortW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
140
141 static const WCHAR user_default_reg_key[] = { 'S','o','f','t','w','a','r','e','\\',
142 'M','i','c','r','o','s','o','f','t','\\',
143 'W','i','n','d','o','w','s',' ','N','T','\\',
144 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
145 'W','i','n','d','o','w','s',0};
146
147 static const WCHAR user_printers_reg_key[] = { 'S','o','f','t','w','a','r','e','\\',
148 'M','i','c','r','o','s','o','f','t','\\',
149 'W','i','n','d','o','w','s',' ','N','T','\\',
150 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
151 'D','e','v','i','c','e','s',0};
152
153 static const WCHAR WinNT_CV_PortsW[] = {'S','o','f','t','w','a','r','e','\\',
154 'M','i','c','r','o','s','o','f','t','\\',
155 'W','i','n','d','o','w','s',' ','N','T','\\',
156 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
157 'P','o','r','t','s',0};
158
159 static const WCHAR WinNT_CV_PrinterPortsW[] = { 'S','o','f','t','w','a','r','e','\\',
160 'M','i','c','r','o','s','o','f','t','\\',
161 'W','i','n','d','o','w','s',' ','N','T','\\',
162 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
163 'P','r','i','n','t','e','r','P','o','r','t','s',0};
164
165 static const WCHAR DefaultEnvironmentW[] = {'W','i','n','e',0};
166 static const WCHAR envname_win40W[] = {'W','i','n','d','o','w','s',' ','4','.','0',0};
167 static const WCHAR envname_x64W[] = {'W','i','n','d','o','w','s',' ','x','6','4',0};
168 static const WCHAR envname_x86W[] = {'W','i','n','d','o','w','s',' ','N','T',' ','x','8','6',0};
169 static const WCHAR subdir_win40W[] = {'w','i','n','4','0',0};
170 static const WCHAR subdir_x64W[] = {'x','6','4',0};
171 static const WCHAR subdir_x86W[] = {'w','3','2','x','8','6',0};
172 static const WCHAR Version0_RegPathW[] = {'\\','V','e','r','s','i','o','n','-','0',0};
173 static const WCHAR Version0_SubdirW[] = {'\\','0',0};
174 static const WCHAR Version3_RegPathW[] = {'\\','V','e','r','s','i','o','n','-','3',0};
175 static const WCHAR Version3_SubdirW[] = {'\\','3',0};
176
177 static const WCHAR spooldriversW[] = {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\',0};
178 static const WCHAR backslashW[] = {'\\',0};
179 static const WCHAR Configuration_FileW[] = {'C','o','n','f','i','g','u','r','a','t',
180 'i','o','n',' ','F','i','l','e',0};
181 static const WCHAR DatatypeW[] = {'D','a','t','a','t','y','p','e',0};
182 static const WCHAR Data_FileW[] = {'D','a','t','a',' ','F','i','l','e',0};
183 static const WCHAR Default_DevModeW[] = {'D','e','f','a','u','l','t',' ','D','e','v','M','o','d','e',0};
184 static const WCHAR Dependent_FilesW[] = {'D','e','p','e','n','d','e','n','t',' ','F','i','l','e','s',0};
185 static const WCHAR DescriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
186 static const WCHAR DriverW[] = {'D','r','i','v','e','r',0};
187 static const WCHAR HardwareIDW[] = {'H','a','r','d','w','a','r','e','I','D',0};
188 static const WCHAR Help_FileW[] = {'H','e','l','p',' ','F','i','l','e',0};
189 static const WCHAR LocationW[] = {'L','o','c','a','t','i','o','n',0};
190 static const WCHAR ManufacturerW[] = {'M','a','n','u','f','a','c','t','u','r','e','r',0};
191 static const WCHAR MonitorW[] = {'M','o','n','i','t','o','r',0};
192 static const WCHAR NameW[] = {'N','a','m','e',0};
193 static const WCHAR ObjectGUIDW[] = {'O','b','j','e','c','t','G','U','I','D',0};
194 static const WCHAR OEM_UrlW[] = {'O','E','M',' ','U','r','l',0};
195 static const WCHAR ParametersW[] = {'P','a','r','a','m','e','t','e','r','s',0};
196 static const WCHAR PortW[] = {'P','o','r','t',0};
197 static const WCHAR bs_Ports_bsW[] = {'\\','P','o','r','t','s','\\',0};
198 static const WCHAR Previous_NamesW[] = {'P','r','e','v','i','o','u','s',' ','N','a','m','e','s',0};
199 static const WCHAR Print_ProcessorW[] = {'P','r','i','n','t',' ','P','r','o','c','e','s','s','o','r',0};
200 static const WCHAR Printer_DriverW[] = {'P','r','i','n','t','e','r',' ','D','r','i','v','e','r',0};
201 static const WCHAR PrinterDriverDataW[] = {'P','r','i','n','t','e','r','D','r','i','v','e','r','D','a','t','a',0};
202 static const WCHAR PrinterPortsW[] = {'P','r','i','n','t','e','r','P','o','r','t','s',0};
203 static const WCHAR ProviderW[] = {'P','r','o','v','i','d','e','r',0};
204 static const WCHAR Separator_FileW[] = {'S','e','p','a','r','a','t','o','r',' ','F','i','l','e',0};
205 static const WCHAR Share_NameW[] = {'S','h','a','r','e',' ','N','a','m','e',0};
206 static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
207 static const WCHAR WinPrintW[] = {'W','i','n','P','r','i','n','t',0};
208 static const WCHAR deviceW[] = {'d','e','v','i','c','e',0};
209 static const WCHAR devicesW[] = {'d','e','v','i','c','e','s',0};
210 static const WCHAR windowsW[] = {'w','i','n','d','o','w','s',0};
211 static const WCHAR emptyStringW[] = {0};
212
213 static const WCHAR May_Delete_Value[] = {'W','i','n','e','M','a','y','D','e','l','e','t','e','M','e',0};
214
215 static const WCHAR CUPS_Port[] = {'C','U','P','S',':',0};
216 static const WCHAR FILE_Port[] = {'F','I','L','E',':',0};
217 static const WCHAR LPR_Port[] = {'L','P','R',':',0};
218
219 static const WCHAR default_doc_title[] = {'L','o','c','a','l',' ','D','o','w','n','l','e','v','e','l',' ',
220 'D','o','c','u','m','e','n','t',0};
221
222 static const DWORD di_sizeof[] = {0, sizeof(DRIVER_INFO_1W), sizeof(DRIVER_INFO_2W),
223 sizeof(DRIVER_INFO_3W), sizeof(DRIVER_INFO_4W),
224 sizeof(DRIVER_INFO_5W), sizeof(DRIVER_INFO_6W),
225 0, sizeof(DRIVER_INFO_8W)};
226
227
228 static const DWORD pi_sizeof[] = {0, sizeof(PRINTER_INFO_1W), sizeof(PRINTER_INFO_2W),
229 sizeof(PRINTER_INFO_3), sizeof(PRINTER_INFO_4W),
230 sizeof(PRINTER_INFO_5W), sizeof(PRINTER_INFO_6),
231 sizeof(PRINTER_INFO_7W), sizeof(PRINTER_INFO_8W),
232 sizeof(PRINTER_INFO_9W)};
233
234 static const printenv_t env_x64 = {envname_x64W, subdir_x64W, 3, Version3_RegPathW, Version3_SubdirW};
235 static const printenv_t env_x86 = {envname_x86W, subdir_x86W, 3, Version3_RegPathW, Version3_SubdirW};
236 static const printenv_t env_win40 = {envname_win40W, subdir_win40W, 0, Version0_RegPathW, Version0_SubdirW};
237
238 static const printenv_t * const all_printenv[] = {&env_x86, &env_x64, &env_win40};
239
240 /******************************************************************
241 * validate the user-supplied printing-environment [internal]
242 *
243 * PARAMS
244 * env [I] PTR to Environment-String or NULL
245 *
246 * RETURNS
247 * Failure: NULL
248 * Success: PTR to printenv_t
249 *
250 * NOTES
251 * An empty string is handled the same way as NULL.
252 * SetLastEror(ERROR_INVALID_ENVIRONMENT) is called on Failure
253 *
254 */
255
256 static const printenv_t * validate_envW(LPCWSTR env)
257 {
258 const printenv_t *result = NULL;
259 unsigned int i;
260
261 TRACE("testing %s\n", debugstr_w(env));
262 if (env && env[0])
263 {
264 for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
265 {
266 if (lstrcmpiW(env, all_printenv[i]->envname) == 0)
267 {
268 result = all_printenv[i];
269 break;
270 }
271 }
272
273 if (result == NULL) {
274 FIXME("unsupported Environment: %s\n", debugstr_w(env));
275 SetLastError(ERROR_INVALID_ENVIRONMENT);
276 }
277 /* on win9x, only "Windows 4.0" is allowed, but we ignore this */
278 }
279 else
280 {
281 result = (GetVersion() & 0x80000000) ? &env_win40 : &env_x86;
282 }
283 TRACE("using %p: %s\n", result, debugstr_w(result ? result->envname : NULL));
284
285 return result;
286 }
287
288
289 /* RtlCreateUnicodeStringFromAsciiz will return an empty string in the buffer
290 if passed a NULL string. This returns NULLs to the result.
291 */
292 static inline PWSTR asciitounicode( UNICODE_STRING * usBufferPtr, LPCSTR src )
293 {
294 if ( (src) )
295 {
296 RtlCreateUnicodeStringFromAsciiz(usBufferPtr, src);
297 return usBufferPtr->Buffer;
298 }
299 usBufferPtr->Buffer = NULL; /* so that RtlFreeUnicodeString won't barf */
300 return NULL;
301 }
302
303 static LPWSTR strdupW(LPCWSTR p)
304 {
305 LPWSTR ret;
306 DWORD len;
307
308 if(!p) return NULL;
309 len = (strlenW(p) + 1) * sizeof(WCHAR);
310 ret = HeapAlloc(GetProcessHeap(), 0, len);
311 memcpy(ret, p, len);
312 return ret;
313 }
314
315 static LPSTR strdupWtoA( LPCWSTR str )
316 {
317 LPSTR ret;
318 INT len;
319
320 if (!str) return NULL;
321 len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
322 ret = HeapAlloc( GetProcessHeap(), 0, len );
323 if(ret) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
324 return ret;
325 }
326
327 /******************************************************************
328 * Return the number of bytes for an multi_sz string.
329 * The result includes all \0s
330 * (specifically the extra \0, that is needed as multi_sz terminator).
331 */
332 #if 0
333 static int multi_sz_lenW(const WCHAR *str)
334 {
335 const WCHAR *ptr = str;
336 if(!str) return 0;
337 do
338 {
339 ptr += lstrlenW(ptr) + 1;
340 } while(*ptr);
341
342 return (ptr - str + 1) * sizeof(WCHAR);
343 }
344 #endif
345 /* ################################ */
346
347 static int multi_sz_lenA(const char *str)
348 {
349 const char *ptr = str;
350 if(!str) return 0;
351 do
352 {
353 ptr += lstrlenA(ptr) + 1;
354 } while(*ptr);
355
356 return ptr - str + 1;
357 }
358
359 static void
360 WINSPOOL_SetDefaultPrinter(const char *devname, const char *name, BOOL force) {
361 char qbuf[200];
362
363 /* If forcing, or no profile string entry for device yet, set the entry
364 *
365 * The always change entry if not WINEPS yet is discussable.
366 */
367 if (force ||
368 !GetProfileStringA("windows","device","*",qbuf,sizeof(qbuf)) ||
369 !strcmp(qbuf,"*") ||
370 !strstr(qbuf,"WINEPS.DRV")
371 ) {
372 char *buf = HeapAlloc(GetProcessHeap(),0,strlen(name)+strlen(devname)+strlen(",WINEPS.DRV,LPR:")+1);
373 HKEY hkey;
374
375 sprintf(buf,"%s,WINEPS.DRV,LPR:%s",devname,name);
376 WriteProfileStringA("windows","device",buf);
377 if(RegCreateKeyW(HKEY_CURRENT_USER, user_default_reg_key, &hkey) == ERROR_SUCCESS) {
378 RegSetValueExA(hkey, "Device", 0, REG_SZ, (LPBYTE)buf, strlen(buf) + 1);
379 RegCloseKey(hkey);
380 }
381 HeapFree(GetProcessHeap(),0,buf);
382 }
383 }
384
385 static BOOL add_printer_driver(const char *name)
386 {
387 DRIVER_INFO_3A di3a;
388
389 static char driver_9x[] = "wineps16.drv",
390 driver_nt[] = "wineps.drv",
391 env_9x[] = "Windows 4.0",
392 env_nt[] = "Windows NT x86",
393 data_file[] = "generic.ppd",
394 default_data_type[] = "RAW";
395
396 ZeroMemory(&di3a, sizeof(DRIVER_INFO_3A));
397 di3a.cVersion = 3;
398 di3a.pName = (char *)name;
399 di3a.pEnvironment = env_nt;
400 di3a.pDriverPath = driver_nt;
401 di3a.pDataFile = data_file;
402 di3a.pConfigFile = driver_nt;
403 di3a.pDefaultDataType = default_data_type;
404
405 if (AddPrinterDriverA(NULL, 3, (LPBYTE)&di3a) ||
406 (GetLastError() == ERROR_PRINTER_DRIVER_ALREADY_INSTALLED ))
407 {
408 di3a.cVersion = 0;
409 di3a.pEnvironment = env_9x;
410 di3a.pDriverPath = driver_9x;
411 di3a.pConfigFile = driver_9x;
412 if (AddPrinterDriverA(NULL, 3, (LPBYTE)&di3a) ||
413 (GetLastError() == ERROR_PRINTER_DRIVER_ALREADY_INSTALLED ))
414 {
415 return TRUE;
416 }
417 }
418 ERR("Failed adding driver %s (%s): %u\n", debugstr_a(di3a.pDriverPath),
419 debugstr_a(di3a.pEnvironment), GetLastError());
420 return FALSE;
421 }
422
423 #ifdef SONAME_LIBCUPS
424 static typeof(cupsFreeDests) *pcupsFreeDests;
425 static typeof(cupsGetDests) *pcupsGetDests;
426 static typeof(cupsGetPPD) *pcupsGetPPD;
427 static typeof(cupsPrintFile) *pcupsPrintFile;
428 static void *cupshandle;
429
430 static BOOL CUPS_LoadPrinters(void)
431 {
432 int i, nrofdests;
433 BOOL hadprinter = FALSE, haddefault = FALSE;
434 cups_dest_t *dests;
435 PRINTER_INFO_2A pinfo2a;
436 char *port,*devline;
437 HKEY hkeyPrinter, hkeyPrinters, hkey;
438 char loaderror[256];
439
440 cupshandle = wine_dlopen(SONAME_LIBCUPS, RTLD_NOW, loaderror, sizeof(loaderror));
441 if (!cupshandle) {
442 TRACE("%s\n", loaderror);
443 return FALSE;
444 }
445 TRACE("%p: %s loaded\n", cupshandle, SONAME_LIBCUPS);
446
447 #define DYNCUPS(x) \
448 p##x = wine_dlsym(cupshandle, #x, NULL,0); \
449 if (!p##x) return FALSE;
450
451 DYNCUPS(cupsFreeDests);
452 DYNCUPS(cupsGetPPD);
453 DYNCUPS(cupsGetDests);
454 DYNCUPS(cupsPrintFile);
455 #undef DYNCUPS
456
457 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
458 ERROR_SUCCESS) {
459 ERR("Can't create Printers key\n");
460 return FALSE;
461 }
462
463 nrofdests = pcupsGetDests(&dests);
464 TRACE("Found %d CUPS %s:\n", nrofdests, (nrofdests == 1) ? "printer" : "printers");
465 for (i=0;i<nrofdests;i++) {
466 /* FIXME: replace "LPR:" with "CUPS:". Fix printing output first */
467 port = HeapAlloc(GetProcessHeap(), 0, strlen("LPR:") + strlen(dests[i].name)+1);
468 sprintf(port,"LPR:%s", dests[i].name);
469 /* FIXME: remove extension. Fix gdi32/drivers and comdlg32/printdlg first */
470 devline = HeapAlloc(GetProcessHeap(), 0, sizeof("WINEPS.DRV,,15,45") + strlen(port));
471 sprintf(devline, "WINEPS.DRV,%s", port);
472 WriteProfileStringA("devices", dests[i].name, devline);
473 if(RegCreateKeyW(HKEY_CURRENT_USER, user_printers_reg_key, &hkey) == ERROR_SUCCESS) {
474 RegSetValueExA(hkey, dests[i].name, 0, REG_SZ, (LPBYTE)devline, strlen(devline) + 1);
475 RegCloseKey(hkey);
476 }
477
478 lstrcatA(devline, ",15,45");
479 WriteProfileStringA("PrinterPorts", dests[i].name, devline);
480 if(RegCreateKeyW(HKEY_CURRENT_USER, WinNT_CV_PrinterPortsW, &hkey) == ERROR_SUCCESS) {
481 RegSetValueExA(hkey, dests[i].name, 0, REG_SZ, (LPBYTE)devline, strlen(devline) + 1);
482 RegCloseKey(hkey);
483 }
484
485 HeapFree(GetProcessHeap(), 0, devline);
486
487 TRACE("Printer %d: %s\n", i, dests[i].name);
488 if(RegOpenKeyA(hkeyPrinters, dests[i].name, &hkeyPrinter) == ERROR_SUCCESS) {
489 /* Printer already in registry, delete the tag added in WINSPOOL_LoadSystemPrinters
490 and continue */
491 TRACE("Printer already exists\n");
492 RegDeleteValueW(hkeyPrinter, May_Delete_Value);
493 RegCloseKey(hkeyPrinter);
494 } else {
495 static CHAR data_type[] = "RAW",
496 print_proc[] = "WinPrint",
497 comment[] = "WINEPS Printer using CUPS",
498 location[] = "<physical location of printer>",
499 params[] = "<parameters?>",
500 share_name[] = "<share name?>",
501 sep_file[] = "<sep file?>";
502
503 add_printer_driver(dests[i].name);
504
505 memset(&pinfo2a,0,sizeof(pinfo2a));
506 pinfo2a.pPrinterName = dests[i].name;
507 pinfo2a.pDatatype = data_type;
508 pinfo2a.pPrintProcessor = print_proc;
509 pinfo2a.pDriverName = dests[i].name;
510 pinfo2a.pComment = comment;
511 pinfo2a.pLocation = location;
512 pinfo2a.pPortName = port;
513 pinfo2a.pParameters = params;
514 pinfo2a.pShareName = share_name;
515 pinfo2a.pSepFile = sep_file;
516
517 if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
518 if (GetLastError() != ERROR_PRINTER_ALREADY_EXISTS)
519 ERR("printer '%s' not added by AddPrinterA (error %d)\n",dests[i].name,GetLastError());
520 }
521 }
522 HeapFree(GetProcessHeap(),0,port);
523
524 hadprinter = TRUE;
525 if (dests[i].is_default) {
526 WINSPOOL_SetDefaultPrinter(dests[i].name, dests[i].name, TRUE);
527 haddefault = TRUE;
528 }
529 }
530 if (hadprinter & !haddefault)
531 WINSPOOL_SetDefaultPrinter(dests[0].name, dests[0].name, TRUE);
532 pcupsFreeDests(nrofdests, dests);
533 RegCloseKey(hkeyPrinters);
534 return hadprinter;
535 }
536 #endif
537
538 static BOOL
539 PRINTCAP_ParseEntry(const char *pent, BOOL isfirst) {
540 PRINTER_INFO_2A pinfo2a;
541 char *e,*s,*name,*prettyname,*devname;
542 BOOL ret = FALSE, set_default = FALSE;
543 char *port = NULL, *devline,*env_default;
544 HKEY hkeyPrinter, hkeyPrinters, hkey;
545
546 while (isspace(*pent)) pent++;
547 s = strchr(pent,':');
548 if(s) *s='\0';
549 name = HeapAlloc(GetProcessHeap(), 0, strlen(pent) + 1);
550 strcpy(name,pent);
551 if(s) {
552 *s=':';
553 pent = s;
554 } else
555 pent = "";
556
557 TRACE("name=%s entry=%s\n",name, pent);
558
559 if(ispunct(*name)) { /* a tc entry, not a real printer */
560 TRACE("skipping tc entry\n");
561 goto end;
562 }
563
564 if(strstr(pent,":server")) { /* server only version so skip */
565 TRACE("skipping server entry\n");
566 goto end;
567 }
568
569 /* Determine whether this is a postscript printer. */
570
571 ret = TRUE;
572 env_default = getenv("PRINTER");
573 prettyname = name;
574 /* Get longest name, usually the one at the right for later display. */
575 while((s=strchr(prettyname,'|'))) {
576 *s = '\0';
577 e = s;
578 while(isspace(*--e)) *e = '\0';
579 TRACE("\t%s\n", debugstr_a(prettyname));
580 if(env_default && !strcasecmp(prettyname, env_default)) set_default = TRUE;
581 for(prettyname = s+1; isspace(*prettyname); prettyname++)
582 ;
583 }
584 e = prettyname + strlen(prettyname);
585 while(isspace(*--e)) *e = '\0';
586 TRACE("\t%s\n", debugstr_a(prettyname));
587 if(env_default && !strcasecmp(prettyname, env_default)) set_default = TRUE;
588
589 /* prettyname must fit into the dmDeviceName member of DEVMODE struct,
590 * if it is too long, we use it as comment below. */
591 devname = prettyname;
592 if (strlen(devname)>=CCHDEVICENAME-1)
593 devname = name;
594 if (strlen(devname)>=CCHDEVICENAME-1) {
595 ret = FALSE;
596 goto end;
597 }
598
599 port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(name)+1);
600 sprintf(port,"LPR:%s",name);
601
602 /* FIXME: remove extension. Fix gdi32/drivers and comdlg32/printdlg first */
603 devline = HeapAlloc(GetProcessHeap(), 0, sizeof("WINEPS.DRV,,15,45") + strlen(port));
604 sprintf(devline, "WINEPS.DRV,%s", port);
605 WriteProfileStringA("devices", devname, devline);
606 if(RegCreateKeyW(HKEY_CURRENT_USER, user_printers_reg_key, &hkey) == ERROR_SUCCESS) {
607 RegSetValueExA(hkey, devname, 0, REG_SZ, (LPBYTE)devline, strlen(devline) + 1);
608 RegCloseKey(hkey);
609 }
610
611 lstrcatA(devline, ",15,45");
612 WriteProfileStringA("PrinterPorts", devname, devline);
613 if(RegCreateKeyW(HKEY_CURRENT_USER, WinNT_CV_PrinterPortsW, &hkey) == ERROR_SUCCESS) {
614 RegSetValueExA(hkey, devname, 0, REG_SZ, (LPBYTE)devline, strlen(devline) + 1);
615 RegCloseKey(hkey);
616 }
617
618 HeapFree(GetProcessHeap(),0,devline);
619
620 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
621 ERROR_SUCCESS) {
622 ERR("Can't create Printers key\n");
623 ret = FALSE;
624 goto end;
625 }
626 if(RegOpenKeyA(hkeyPrinters, devname, &hkeyPrinter) == ERROR_SUCCESS) {
627 /* Printer already in registry, delete the tag added in WINSPOOL_LoadSystemPrinters
628 and continue */
629 TRACE("Printer already exists\n");
630 RegDeleteValueW(hkeyPrinter, May_Delete_Value);
631 RegCloseKey(hkeyPrinter);
632 } else {
633 static CHAR data_type[] = "RAW",
634 print_proc[] = "WinPrint",
635 comment[] = "WINEPS Printer using LPR",
636 params[] = "<parameters?>",
637 share_name[] = "<share name?>",
638 sep_file[] = "<sep file?>";
639
640 add_printer_driver(devname);
641
642 memset(&pinfo2a,0,sizeof(pinfo2a));
643 pinfo2a.pPrinterName = devname;
644 pinfo2a.pDatatype = data_type;
645 pinfo2a.pPrintProcessor = print_proc;
646 pinfo2a.pDriverName = devname;
647 pinfo2a.pComment = comment;
648 pinfo2a.pLocation = prettyname;
649 pinfo2a.pPortName = port;
650 pinfo2a.pParameters = params;
651 pinfo2a.pShareName = share_name;
652 pinfo2a.pSepFile = sep_file;
653
654 if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
655 if (GetLastError()!=ERROR_PRINTER_ALREADY_EXISTS)
656 ERR("%s not added by AddPrinterA (%d)\n",name,GetLastError());
657 }
658 }
659 RegCloseKey(hkeyPrinters);
660
661 if (isfirst || set_default)
662 WINSPOOL_SetDefaultPrinter(devname,name,TRUE);
663
664 end:
665 HeapFree(GetProcessHeap(), 0, port);
666 HeapFree(GetProcessHeap(), 0, name);
667 return ret;
668 }
669
670 static BOOL
671 PRINTCAP_LoadPrinters(void) {
672 BOOL hadprinter = FALSE;
673 char buf[200];
674 FILE *f;
675 char *pent = NULL;
676 BOOL had_bash = FALSE;
677
678 f = fopen("/etc/printcap","r");
679 if (!f)
680 return FALSE;
681
682 while(fgets(buf,sizeof(buf),f)) {
683 char *start, *end;
684
685 end=strchr(buf,'\n');
686 if (end) *end='\0';
687
688 start = buf;
689 while(isspace(*start)) start++;
690 if(*start == '#' || *start == '\0')
691 continue;
692
693 if(pent && !had_bash && *start != ':' && *start != '|') { /* start of new entry, parse the previous one */
694 hadprinter |= PRINTCAP_ParseEntry(pent,!hadprinter);
695 HeapFree(GetProcessHeap(),0,pent);
696 pent = NULL;
697 }
698
699 if (end && *--end == '\\') {
700 *end = '\0';
701 had_bash = TRUE;
702 } else
703 had_bash = FALSE;
704
705 if (pent) {
706 pent=HeapReAlloc(GetProcessHeap(),0,pent,strlen(pent)+strlen(start)+1);
707 strcat(pent,start);
708 } else {
709 pent=HeapAlloc(GetProcessHeap(),0,strlen(start)+1);
710 strcpy(pent,start);
711 }
712
713 }
714 if(pent) {
715 hadprinter |= PRINTCAP_ParseEntry(pent,!hadprinter);
716 HeapFree(GetProcessHeap(),0,pent);
717 }
718 fclose(f);
719 return hadprinter;
720 }
721
722 static inline DWORD set_reg_szW(HKEY hkey, const WCHAR *keyname, const WCHAR *value)
723 {
724 if (value)
725 return RegSetValueExW(hkey, keyname, 0, REG_SZ, (const BYTE*)value,
726 (lstrlenW(value) + 1) * sizeof(WCHAR));
727 else
728 return ERROR_FILE_NOT_FOUND;
729 }
730
731 /******************************************************************
732 * get_servername_from_name (internal)
733 *
734 * for an external server, a copy of the serverpart from the full name is returned
735 *
736 */
737 static LPWSTR get_servername_from_name(LPCWSTR name)
738 {
739 LPWSTR server;
740 LPWSTR ptr;
741 WCHAR buffer[MAX_PATH];
742 DWORD len;
743
744 if (name == NULL) return NULL;
745 if ((name[0] != '\\') || (name[1] != '\\')) return NULL;
746
747 server = strdupW(&name[2]); /* skip over both backslash */
748 if (server == NULL) return NULL;
749
750 /* strip '\' and the printername */
751 ptr = strchrW(server, '\\');
752 if (ptr) ptr[0] = '\0';
753
754 TRACE("found %s\n", debugstr_w(server));
755
756 len = sizeof(buffer)/sizeof(buffer[0]);
757 if (GetComputerNameW(buffer, &len)) {
758 if (lstrcmpW(buffer, server) == 0) {
759 /* The requested Servername is our computername */
760 HeapFree(GetProcessHeap(), 0, server);
761 return NULL;
762 }
763 }
764 return server;
765 }
766
767 /******************************************************************
768 * get_basename_from_name (internal)
769 *
770 * skip over the serverpart from the full name
771 *
772 */
773 static LPCWSTR get_basename_from_name(LPCWSTR name)
774 {
775 if (name == NULL) return NULL;
776 if ((name[0] == '\\') && (name[1] == '\\')) {
777 /* skip over the servername and search for the following '\' */
778 name = strchrW(&name[2], '\\');
779 if ((name) && (name[1])) {
780 /* found a separator ('\') followed by a name:
781 skip over the separator and return the rest */
782 name++;
783 }
784 else
785 {
786 /* no basename present (we found only a servername) */
787 return NULL;
788 }
789 }
790 return name;
791 }
792
793 /******************************************************************
794 * get_opened_printer_entry
795 * Get the first place empty in the opened printer table
796 *
797 * ToDo:
798 * - pDefault is ignored
799 */
800 static HANDLE get_opened_printer_entry(LPWSTR name, LPPRINTER_DEFAULTSW pDefault)
801 {
802 UINT_PTR handle = nb_printer_handles, i;
803 jobqueue_t *queue = NULL;
804 opened_printer_t *printer = NULL;
805 LPWSTR servername;
806 LPCWSTR printername;
807
808 if ((backend == NULL) && !load_backend()) return NULL;
809
810 servername = get_servername_from_name(name);
811 if (servername) {
812 FIXME("server %s not supported\n", debugstr_w(servername));
813 HeapFree(GetProcessHeap(), 0, servername);
814 SetLastError(ERROR_INVALID_PRINTER_NAME);
815 return NULL;
816 }
817
818 printername = get_basename_from_name(name);
819 if (name != printername) TRACE("converted %s to %s\n", debugstr_w(name), debugstr_w(printername));
820
821 /* an empty printername is invalid */
822 if (printername && (!printername[0])) {
823 SetLastError(ERROR_INVALID_PARAMETER);
824 return NULL;
825 }
826
827 EnterCriticalSection(&printer_handles_cs);
828
829 for (i = 0; i < nb_printer_handles; i++)
830 {
831 if (!printer_handles[i])
832 {
833 if(handle == nb_printer_handles)
834 handle = i;
835 }
836 else
837 {
838 if(!queue && (name) && !lstrcmpW(name, printer_handles[i]->name))
839 queue = printer_handles[i]->queue;
840 }
841 }
842
843 if (handle >= nb_printer_handles)
844 {
845 opened_printer_t **new_array;
846 if (printer_handles)
847 new_array = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, printer_handles,
848 (nb_printer_handles + 16) * sizeof(*new_array) );
849 else
850 new_array = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
851 (nb_printer_handles + 16) * sizeof(*new_array) );
852
853 if (!new_array)
854 {
855 handle = 0;
856 goto end;
857 }
858 printer_handles = new_array;
859 nb_printer_handles += 16;
860 }
861
862 if (!(printer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*printer))))
863 {
864 handle = 0;
865 goto end;
866 }
867
868 /* get a printer handle from the backend */
869 if (! backend->fpOpenPrinter(name, &printer->backend_printer, pDefault)) {
870 handle = 0;
871 goto end;
872 }
873
874 /* clone the base name. This is NULL for the printserver */
875 printer->printername = strdupW(printername);
876
877 /* clone the full name */
878 printer->name = strdupW(name);
879 if (name && (!printer->name)) {
880 handle = 0;
881 goto end;
882 }
883
884 if(queue)
885 printer->queue = queue;
886 else
887 {
888 printer->queue = HeapAlloc(GetProcessHeap(), 0, sizeof(*queue));
889 if (!printer->queue) {
890 handle = 0;
891 goto end;
892 }
893 list_init(&printer->queue->jobs);
894 printer->queue->ref = 0;
895 }
896 InterlockedIncrement(&printer->queue->ref);
897
898 printer_handles[handle] = printer;
899 handle++;
900 end:
901 LeaveCriticalSection(&printer_handles_cs);
902 if (!handle && printer) {
903 /* Something failed: Free all resources */
904 HeapFree(GetProcessHeap(), 0, printer->printername);
905 HeapFree(GetProcessHeap(), 0, printer->name);
906 if (!queue) HeapFree(GetProcessHeap(), 0, printer->queue);
907 HeapFree(GetProcessHeap(), 0, printer);
908 }
909
910 return (HANDLE)handle;
911 }
912
913 /******************************************************************
914 * get_opened_printer
915 * Get the pointer to the opened printer referred by the handle
916 */
917 static opened_printer_t *get_opened_printer(HANDLE hprn)
918 {
919 UINT_PTR idx = (UINT_PTR)hprn;
920 opened_printer_t *ret = NULL;
921
922 EnterCriticalSection(&printer_handles_cs);
923
924 if ((idx > 0) && (idx <= nb_printer_handles)) {
925 ret = printer_handles[idx - 1];
926 }
927 LeaveCriticalSection(&printer_handles_cs);
928 return ret;
929 }
930
931 /******************************************************************
932 * get_opened_printer_name
933 * Get the pointer to the opened printer name referred by the handle
934 */
935 static LPCWSTR get_opened_printer_name(HANDLE hprn)
936 {
937 opened_printer_t *printer = get_opened_printer(hprn);
938 if(!printer) return NULL;
939 return printer->name;
940 }
941
942 /******************************************************************
943 * WINSPOOL_GetOpenedPrinterRegKey
944 *
945 */
946 static DWORD WINSPOOL_GetOpenedPrinterRegKey(HANDLE hPrinter, HKEY *phkey)
947 {
948 LPCWSTR name = get_opened_printer_name(hPrinter);
949 DWORD ret;
950 HKEY hkeyPrinters;
951
952 if(!name) return ERROR_INVALID_HANDLE;
953
954 if((ret = RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters)) !=
955 ERROR_SUCCESS)
956 return ret;
957
958 if(RegOpenKeyW(hkeyPrinters, name, phkey) != ERROR_SUCCESS)
959 {
960 ERR("Can't find opened printer %s in registry\n",
961 debugstr_w(name));
962 RegCloseKey(hkeyPrinters);
963 return ERROR_INVALID_PRINTER_NAME; /* ? */
964 }
965 RegCloseKey(hkeyPrinters);
966 return ERROR_SUCCESS;
967 }
968
969 void WINSPOOL_LoadSystemPrinters(void)
970 {
971 HKEY hkey, hkeyPrinters;
972 HANDLE hprn;
973 DWORD needed, num, i;
974 WCHAR PrinterName[256];
975 BOOL done = FALSE;
976
977 /* This ensures that all printer entries have a valid Name value. If causes
978 problems later if they don't. If one is found to be missed we create one
979 and set it equal to the name of the key */
980 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) == ERROR_SUCCESS) {
981 if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &num, NULL, NULL,
982 NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
983 for(i = 0; i < num; i++) {
984 if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)/sizeof(PrinterName[0])) == ERROR_SUCCESS) {
985 if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkey) == ERROR_SUCCESS) {
986 if(RegQueryValueExW(hkey, NameW, 0, 0, 0, &needed) == ERROR_FILE_NOT_FOUND) {
987 set_reg_szW(hkey, NameW, PrinterName);
988 }
989 RegCloseKey(hkey);
990 }
991 }
992 }
993 }
994 RegCloseKey(hkeyPrinters);
995 }
996
997 /* We want to avoid calling AddPrinter on printers as much as
998 possible, because on cups printers this will (eventually) lead
999 to a call to cupsGetPPD which takes forever, even with non-cups
1000 printers AddPrinter takes a while. So we'll tag all printers that
1001 were automatically added last time around, if they still exist
1002 we'll leave them be otherwise we'll delete them. */
1003 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, NULL, 0, &needed, &num);
1004 if(needed) {
1005 PRINTER_INFO_5A* pi = HeapAlloc(GetProcessHeap(), 0, needed);
1006 if(EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, (LPBYTE)pi, needed, &needed, &num)) {
1007 for(i = 0; i < num; i++) {
1008 if(pi[i].pPortName == NULL || !strncmp(pi[i].pPortName,"CUPS:", 5) || !strncmp(pi[i].pPortName, "LPR:", 4)) {
1009 if(OpenPrinterA(pi[i].pPrinterName, &hprn, NULL)) {
1010 if(WINSPOOL_GetOpenedPrinterRegKey(hprn, &hkey) == ERROR_SUCCESS) {
1011 DWORD dw = 1;
1012 RegSetValueExW(hkey, May_Delete_Value, 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw));
1013 RegCloseKey(hkey);
1014 }
1015 ClosePrinter(hprn);
1016 }
1017 }
1018 }
1019 }
1020 HeapFree(GetProcessHeap(), 0, pi);
1021 }
1022
1023
1024 #ifdef SONAME_LIBCUPS
1025 done = CUPS_LoadPrinters();
1026 #endif
1027
1028 if(!done) /* If we have any CUPS based printers, skip looking for printcap printers */
1029 PRINTCAP_LoadPrinters();
1030
1031 /* Now enumerate the list again and delete any printers that are still tagged */
1032 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, NULL, 0, &needed, &num);
1033 if(needed) {
1034 PRINTER_INFO_5A* pi = HeapAlloc(GetProcessHeap(), 0, needed);
1035 if(EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, (LPBYTE)pi, needed, &needed, &num)) {
1036 for(i = 0; i < num; i++) {
1037 if(pi[i].pPortName == NULL || !strncmp(pi[i].pPortName,"CUPS:", 5) || !strncmp(pi[i].pPortName, "LPR:", 4)) {
1038 if(OpenPrinterA(pi[i].pPrinterName, &hprn, NULL)) {
1039 BOOL delete_driver = FALSE;
1040 if(WINSPOOL_GetOpenedPrinterRegKey(hprn, &hkey) == ERROR_SUCCESS) {
1041 DWORD dw, type, size = sizeof(dw);
1042 if(RegQueryValueExW(hkey, May_Delete_Value, NULL, &type, (LPBYTE)&dw, &size) == ERROR_SUCCESS) {
1043 TRACE("Deleting old printer %s\n", pi[i].pPrinterName);
1044 DeletePrinter(hprn);
1045 delete_driver = TRUE;
1046 }
1047 RegCloseKey(hkey);
1048 }
1049 ClosePrinter(hprn);
1050 if(delete_driver)
1051 DeletePrinterDriverExA(NULL, NULL, pi[i].pPrinterName, 0, 0);
1052 }
1053 }
1054 }
1055 }
1056 HeapFree(GetProcessHeap(), 0, pi);
1057 }
1058
1059 return;
1060
1061 }
1062
1063 /******************************************************************
1064 * get_job
1065 *
1066 * Get the pointer to the specified job.
1067 * Should hold the printer_handles_cs before calling.
1068 */
1069 static job_t *get_job(HANDLE hprn, DWORD JobId)
1070 {
1071 opened_printer_t *printer = get_opened_printer(hprn);
1072 job_t *job;
1073
1074 if(!printer) return NULL;
1075 LIST_FOR_EACH_ENTRY(job, &printer->queue->jobs, job_t, entry)
1076 {
1077 if(job->job_id == JobId)
1078 return job;
1079 }
1080 return NULL;
1081 }
1082
1083 /***********************************************************
1084 * DEVMODEcpyAtoW
1085 */
1086 static LPDEVMODEW DEVMODEcpyAtoW(DEVMODEW *dmW, const DEVMODEA *dmA)
1087 {
1088 BOOL Formname;
1089 ptrdiff_t off_formname = (const char *)dmA->dmFormName - (const char *)dmA;
1090 DWORD size;
1091
1092 Formname = (dmA->dmSize > off_formname);
1093 size = dmA->dmSize + CCHDEVICENAME + (Formname ? CCHFORMNAME : 0);
1094 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)dmA->dmDeviceName, -1,
1095 dmW->dmDeviceName, CCHDEVICENAME);
1096 if(!Formname) {
1097 memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
1098 dmA->dmSize - CCHDEVICENAME);
1099 } else {
1100 memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
1101 off_formname - CCHDEVICENAME);
1102 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)dmA->dmFormName, -1,
1103 dmW->dmFormName, CCHFORMNAME);
1104 memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA->dmSize -
1105 (off_formname + CCHFORMNAME));
1106 }
1107 dmW->dmSize = size;
1108 memcpy((char *)dmW + dmW->dmSize, (const char *)dmA + dmA->dmSize,
1109 dmA->dmDriverExtra);
1110 return dmW;
1111 }
1112
1113 /***********************************************************
1114 * DEVMODEdupWtoA
1115 * Creates an ansi copy of supplied devmode
1116 */
1117 static LPDEVMODEA DEVMODEdupWtoA(const DEVMODEW *dmW)
1118 {
1119 LPDEVMODEA dmA;
1120 DWORD size;
1121
1122 if (!dmW) return NULL;
1123 size = dmW->dmSize - CCHDEVICENAME -
1124 ((dmW->dmSize > FIELD_OFFSET(DEVMODEW, dmFormName)) ? CCHFORMNAME : 0);
1125
1126 dmA = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + dmW->dmDriverExtra);
1127 if (!dmA) return NULL;
1128
1129 WideCharToMultiByte(CP_ACP, 0, dmW->dmDeviceName, -1,
1130 (LPSTR)dmA->dmDeviceName, CCHDEVICENAME, NULL, NULL);
1131
1132 if (FIELD_OFFSET(DEVMODEW, dmFormName) >= dmW->dmSize) {
1133 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
1134 dmW->dmSize - FIELD_OFFSET(DEVMODEW, dmSpecVersion));
1135 }
1136 else
1137 {
1138 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
1139 FIELD_OFFSET(DEVMODEW, dmFormName) - FIELD_OFFSET(DEVMODEW, dmSpecVersion));
1140 WideCharToMultiByte(CP_ACP, 0, dmW->dmFormName, -1,
1141 (LPSTR)dmA->dmFormName, CCHFORMNAME, NULL, NULL);
1142
1143 memcpy(&dmA->dmLogPixels, &dmW->dmLogPixels, dmW->dmSize - FIELD_OFFSET(DEVMODEW, dmLogPixels));
1144 }
1145
1146 dmA->dmSize = size;
1147 memcpy((char *)dmA + dmA->dmSize, (const char *)dmW + dmW->dmSize, dmW->dmDriverExtra);
1148 return dmA;
1149 }
1150
1151 /******************************************************************
1152 * convert_printerinfo_W_to_A [internal]
1153 *
1154 */
1155 static void convert_printerinfo_W_to_A(LPBYTE out, LPBYTE pPrintersW,
1156 DWORD level, DWORD outlen, DWORD numentries)
1157 {
1158 DWORD id = 0;
1159 LPSTR ptr;
1160 INT len;
1161
1162 TRACE("(%p, %p, %d, %u, %u)\n", out, pPrintersW, level, outlen, numentries);
1163
1164 len = pi_sizeof[level] * numentries;
1165 ptr = (LPSTR) out + len;
1166 outlen -= len;
1167
1168 /* copy the numbers of all PRINTER_INFO_* first */
1169 memcpy(out, pPrintersW, len);
1170
1171 while (id < numentries) {
1172 switch (level) {
1173 case 1:
1174 {
1175 PRINTER_INFO_1W * piW = (PRINTER_INFO_1W *) pPrintersW;
1176 PRINTER_INFO_1A * piA = (PRINTER_INFO_1A *) out;
1177
1178 TRACE("(%u) #%u: %s\n", level, id, debugstr_w(piW->pName));
1179 if (piW->pDescription) {
1180 piA->pDescription = ptr;
1181 len = WideCharToMultiByte(CP_ACP, 0, piW->pDescription, -1,
1182 ptr, outlen, NULL, NULL);
1183 ptr += len;
1184 outlen -= len;
1185 }
1186 if (piW->pName) {
1187 piA->pName = ptr;
1188 len = WideCharToMultiByte(CP_ACP, 0, piW->pName, -1,
1189 ptr, outlen, NULL, NULL);
1190 ptr += len;
1191 outlen -= len;
1192 }
1193 if (piW->pComment) {
1194 piA->pComment = ptr;
1195 len = WideCharToMultiByte(CP_ACP, 0, piW->pComment, -1,
1196 ptr, outlen, NULL, NULL);
1197 ptr += len;
1198 outlen -= len;
1199 }
1200 break;
1201 }
1202
1203 case 2:
1204 {
1205 PRINTER_INFO_2W * piW = (PRINTER_INFO_2W *) pPrintersW;
1206 PRINTER_INFO_2A * piA = (PRINTER_INFO_2A *) out;
1207 LPDEVMODEA dmA;
1208
1209 TRACE("(%u) #%u: %s\n", level, id, debugstr_w(piW->pPrinterName));
1210 if (piW->pServerName) {
1211 piA->pServerName = ptr;
1212 len = WideCharToMultiByte(CP_ACP, 0, piW->pServerName, -1,
1213 ptr, outlen, NULL, NULL);
1214 ptr += len;
1215 outlen -= len;
1216 }
1217 if (piW->pPrinterName) {
1218 piA->pPrinterName = ptr;
1219 len = WideCharToMultiByte(CP_ACP, 0, piW->pPrinterName, -1,
1220 ptr, outlen, NULL, NULL);
1221 ptr += len;
1222 outlen -= len;
1223 }
1224 if (piW->pShareName) {
1225 piA->pShareName = ptr;
1226 len = WideCharToMultiByte(CP_ACP, 0, piW->pShareName, -1,
1227 ptr, outlen, NULL, NULL);
1228 ptr += len;
1229 outlen -= len;
1230 }
1231 if (piW->pPortName) {
1232 piA->pPortName = ptr;
1233 len = WideCharToMultiByte(CP_ACP, 0, piW->pPortName, -1,
1234 ptr, outlen, NULL, NULL);
1235 ptr += len;
1236 outlen -= len;
1237 }
1238 if (piW->pDriverName) {
1239 piA->pDriverName = ptr;
1240 len = WideCharToMultiByte(CP_ACP, 0, piW->pDriverName, -1,
1241 ptr, outlen, NULL, NULL);
1242 ptr += len;
1243 outlen -= len;
1244 }
1245 if (piW->pComment) {
1246 piA->pComment = ptr;
1247 len = WideCharToMultiByte(CP_ACP, 0, piW->pComment, -1,
1248 ptr, outlen, NULL, NULL);
1249 ptr += len;
1250 outlen -= len;
1251 }
1252 if (piW->pLocation) {
1253 piA->pLocation = ptr;
1254 len = WideCharToMultiByte(CP_ACP, 0, piW->pLocation, -1,
1255 ptr, outlen, NULL, NULL);
1256 ptr += len;
1257 outlen -= len;
1258 }
1259
1260 dmA = DEVMODEdupWtoA(piW->pDevMode);
1261 if (dmA) {
1262 /* align DEVMODEA to a DWORD boundary */
1263 len = (4 - ( (DWORD_PTR) ptr & 3)) & 3;
1264 ptr += len;
1265 outlen -= len;
1266
1267 piA->pDevMode = (LPDEVMODEA) ptr;
1268 len = dmA->dmSize + dmA->dmDriverExtra;
1269 memcpy(ptr, dmA, len);
1270 HeapFree(GetProcessHeap(), 0, dmA);
1271
1272 ptr += len;
1273 outlen -= len;
1274 }
1275
1276 if (piW->pSepFile) {
1277 piA->pSepFile = ptr;
1278 len = WideCharToMultiByte(CP_ACP, 0, piW->pSepFile, -1,
1279 ptr, outlen, NULL, NULL);
1280 ptr += len;
1281 outlen -= len;
1282 }
1283 if (piW->pPrintProcessor) {
1284 piA->pPrintProcessor = ptr;
1285 len = WideCharToMultiByte(CP_ACP, 0, piW->pPrintProcessor, -1,
1286 ptr, outlen, NULL, NULL);
1287 ptr += len;
1288 outlen -= len;
1289 }
1290 if (piW->pDatatype) {
1291 piA->pDatatype = ptr;
1292 len = WideCharToMultiByte(CP_ACP, 0, piW->pDatatype, -1,
1293 ptr, outlen, NULL, NULL);
1294 ptr += len;
1295 outlen -= len;
1296 }
1297 if (piW->pParameters) {
1298 piA->pParameters = ptr;
1299 len = WideCharToMultiByte(CP_ACP, 0, piW->pParameters, -1,
1300 ptr, outlen, NULL, NULL);
1301 ptr += len;
1302 outlen -= len;
1303 }
1304 if (piW->pSecurityDescriptor) {
1305 piA->pSecurityDescriptor = NULL;
1306 FIXME("pSecurityDescriptor ignored: %s\n", debugstr_w(piW->pPrinterName));
1307 }
1308 break;
1309 }
1310
1311 case 4:
1312 {
1313 PRINTER_INFO_4W * piW = (PRINTER_INFO_4W *) pPrintersW;
1314 PRINTER_INFO_4A * piA = (PRINTER_INFO_4A *) out;
1315
1316 TRACE("(%u) #%u: %s\n", level, id, debugstr_w(piW->pPrinterName));
1317
1318 if (piW->pPrinterName) {
1319 piA->pPrinterName = ptr;
1320 len = WideCharToMultiByte(CP_ACP, 0, piW->pPrinterName, -1,
1321 ptr, outlen, NULL, NULL);
1322 ptr += len;
1323 outlen -= len;
1324 }
1325 if (piW->pServerName) {
1326 piA->pServerName = ptr;
1327 len = WideCharToMultiByte(CP_ACP, 0, piW->pServerName, -1,
1328 ptr, outlen, NULL, NULL);
1329 ptr += len;
1330 outlen -= len;
1331 }
1332 break;
1333 }
1334
1335 case 5:
1336 {
1337 PRINTER_INFO_5W * piW = (PRINTER_INFO_5W *) pPrintersW;
1338 PRINTER_INFO_5A * piA = (PRINTER_INFO_5A *) out;
1339
1340 TRACE("(%u) #%u: %s\n", level, id, debugstr_w(piW->pPrinterName));
1341
1342 if (piW->pPrinterName) {
1343 piA->pPrinterName = ptr;
1344 len = WideCharToMultiByte(CP_ACP, 0, piW->pPrinterName, -1,
1345 ptr, outlen, NULL, NULL);
1346 ptr += len;
1347 outlen -= len;
1348 }
1349 if (piW->pPortName) {
1350 piA->pPortName = ptr;
1351 len = WideCharToMultiByte(CP_ACP, 0, piW->pPortName, -1,
1352 ptr, outlen, NULL, NULL);
1353 ptr += len;
1354 outlen -= len;
1355 }
1356 break;
1357 }
1358
1359 default:
1360 FIXME("for level %u\n", level);
1361 }
1362 pPrintersW += pi_sizeof[level];
1363 out += pi_sizeof[level];
1364 id++;
1365 }
1366 }
1367
1368 /***********************************************************
1369 * PRINTER_INFO_2AtoW
1370 * Creates a unicode copy of PRINTER_INFO_2A on heap
1371 */
1372 static LPPRINTER_INFO_2W PRINTER_INFO_2AtoW(HANDLE heap, LPPRINTER_INFO_2A piA)
1373 {
1374 LPPRINTER_INFO_2W piW;
1375 UNICODE_STRING usBuffer;
1376
1377 if(!piA) return NULL;
1378 piW = HeapAlloc(heap, 0, sizeof(*piW));
1379 memcpy(piW, piA, sizeof(*piW)); /* copy everything first */
1380
1381 piW->pServerName = asciitounicode(&usBuffer,piA->pServerName);
1382 piW->pPrinterName = asciitounicode(&usBuffer,piA->pPrinterName);
1383 piW->pShareName = asciitounicode(&usBuffer,piA->pShareName);
1384 piW->pPortName = asciitounicode(&usBuffer,piA->pPortName);
1385 piW->pDriverName = asciitounicode(&usBuffer,piA->pDriverName);
1386 piW->pComment = asciitounicode(&usBuffer,piA->pComment);
1387 piW->pLocation = asciitounicode(&usBuffer,piA->pLocation);
1388 piW->pDevMode = piA->pDevMode ? GdiConvertToDevmodeW(piA->pDevMode) : NULL;
1389 piW->pSepFile = asciitounicode(&usBuffer,piA->pSepFile);
1390 piW->pPrintProcessor = asciitounicode(&usBuffer,piA->pPrintProcessor);
1391 piW->pDatatype = asciitounicode(&usBuffer,piA->pDatatype);
1392 piW->pParameters = asciitounicode(&usBuffer,piA->pParameters);
1393 return piW;
1394 }
1395
1396 /***********************************************************
1397 * FREE_PRINTER_INFO_2W
1398 * Free PRINTER_INFO_2W and all strings
1399 */
1400 static void FREE_PRINTER_INFO_2W(HANDLE heap, LPPRINTER_INFO_2W piW)
1401 {
1402 if(!piW) return;
1403
1404 HeapFree(heap,0,piW->pServerName);
1405 HeapFree(heap,0,piW->pPrinterName);
1406 HeapFree(heap,0,piW->pShareName);
1407 HeapFree(heap,0,piW->pPortName);
1408 HeapFree(heap,0,piW->pDriverName);
1409 HeapFree(heap,0,piW->pComment);
1410 HeapFree(heap,0,piW->pLocation);
1411 HeapFree(heap,0,piW->pDevMode);
1412 HeapFree(heap,0,piW->pSepFile);
1413 HeapFree(heap,0,piW->pPrintProcessor);
1414 HeapFree(heap,0,piW->pDatatype);
1415 HeapFree(heap,0,piW->pParameters);
1416 HeapFree(heap,0,piW);
1417 return;
1418 }
1419
1420 /******************************************************************
1421 * DeviceCapabilities [WINSPOOL.@]
1422 * DeviceCapabilitiesA [WINSPOOL.@]
1423 *
1424 */
1425 INT WINAPI DeviceCapabilitiesA(LPCSTR pDevice,LPCSTR pPort, WORD cap,
1426 LPSTR pOutput, LPDEVMODEA lpdm)
1427 {
1428 INT ret;
1429
1430 if (!GDI_CallDeviceCapabilities16)
1431 {
1432 GDI_CallDeviceCapabilities16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
1433 (LPCSTR)104 );
1434 if (!GDI_CallDeviceCapabilities16) return -1;
1435 }
1436 ret = GDI_CallDeviceCapabilities16(pDevice, pPort, cap, pOutput, lpdm);
1437
1438 /* If DC_PAPERSIZE map POINT16s to POINTs */
1439 if(ret != -1 && cap == DC_PAPERSIZE && pOutput) {
1440 POINT16 *tmp = HeapAlloc( GetProcessHeap(), 0, ret * sizeof(POINT16) );
1441 POINT *pt = (POINT *)pOutput;
1442 INT i;
1443 memcpy(tmp, pOutput, ret * sizeof(POINT16));
1444 for(i = 0; i < ret; i++, pt++)
1445 {
1446 pt->x = tmp[i].x;
1447 pt->y = tmp[i].y;
1448 }
1449 HeapFree( GetProcessHeap(), 0, tmp );
1450 }
1451 return ret;
1452 }
1453
1454
1455 /*****************************************************************************
1456 * DeviceCapabilitiesW [WINSPOOL.@]
1457 *
1458 * Call DeviceCapabilitiesA since we later call 16bit stuff anyway
1459 *
1460 */
1461 INT WINAPI DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort,
1462 WORD fwCapability, LPWSTR pOutput,
1463 const DEVMODEW *pDevMode)
1464 {
1465 LPDEVMODEA dmA = DEVMODEdupWtoA(pDevMode);
1466 LPSTR pDeviceA = strdupWtoA(pDevice);
1467 LPSTR pPortA = strdupWtoA(pPort);
1468 INT ret;
1469
1470 if(pOutput && (fwCapability == DC_BINNAMES ||
1471 fwCapability == DC_FILEDEPENDENCIES ||
1472 fwCapability == DC_PAPERNAMES)) {
1473 /* These need A -> W translation */
1474 INT size = 0, i;
1475 LPSTR pOutputA;
1476 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, NULL,
1477 dmA);
1478 if(ret == -1)
1479 return ret;
1480 switch(fwCapability) {
1481 case DC_BINNAMES:
1482 size = 24;
1483 break;
1484 case DC_PAPERNAMES:
1485 case DC_FILEDEPENDENCIES:
1486 size = 64;
1487 break;
1488 }
1489 pOutputA = HeapAlloc(GetProcessHeap(), 0, size * ret);
1490 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, pOutputA,
1491 dmA);
1492 for(i = 0; i < ret; i++)
1493 MultiByteToWideChar(CP_ACP, 0, pOutputA + (i * size), -1,
1494 pOutput + (i * size), size);
1495 HeapFree(GetProcessHeap(), 0, pOutputA);
1496 } else {
1497 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability,
1498 (LPSTR)pOutput, dmA);
1499 }
1500 HeapFree(GetProcessHeap(),0,pPortA);
1501 HeapFree(GetProcessHeap(),0,pDeviceA);
1502 HeapFree(GetProcessHeap(),0,dmA);
1503 return ret;
1504 }
1505
1506 /******************************************************************
1507 * DocumentPropertiesA [WINSPOOL.@]
1508 *
1509 * FIXME: implement DocumentPropertiesA via DocumentPropertiesW, not vice versa
1510 */
1511 LONG WINAPI DocumentPropertiesA(HWND hWnd,HANDLE hPrinter,
1512 LPSTR pDeviceName, LPDEVMODEA pDevModeOutput,
1513 LPDEVMODEA pDevModeInput,DWORD fMode )
1514 {
1515 LPSTR lpName = pDeviceName;
1516 static CHAR port[] = "LPT1:";
1517 LONG ret;
1518
1519 TRACE("(%p,%p,%s,%p,%p,%d)\n",
1520 hWnd,hPrinter,pDeviceName,pDevModeOutput,pDevModeInput,fMode
1521 );
1522
1523 if(!pDeviceName) {
1524 LPCWSTR lpNameW = get_opened_printer_name(hPrinter);
1525 if(!lpNameW) {
1526 ERR("no name from hPrinter?\n");
1527 SetLastError(ERROR_INVALID_HANDLE);
1528 return -1;
1529 }
1530 lpName = strdupWtoA(lpNameW);
1531 }
1532
1533 if (!GDI_CallExtDeviceMode16)
1534 {
1535 GDI_CallExtDeviceMode16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
1536 (LPCSTR)102 );
1537 if (!GDI_CallExtDeviceMode16) {
1538 ERR("No CallExtDeviceMode16?\n");
1539 return -1;
1540 }
1541 }
1542 ret = GDI_CallExtDeviceMode16(hWnd, pDevModeOutput, lpName, port,
1543 pDevModeInput, NULL, fMode);
1544
1545 if(!pDeviceName)
1546 HeapFree(GetProcessHeap(),0,lpName);
1547 return ret;
1548 }
1549
1550
1551 /*****************************************************************************
1552 * DocumentPropertiesW (WINSPOOL.@)
1553 *
1554 * FIXME: implement DocumentPropertiesA via DocumentPropertiesW, not vice versa
1555 */
1556 LONG WINAPI DocumentPropertiesW(HWND hWnd, HANDLE hPrinter,
1557 LPWSTR pDeviceName,
1558 LPDEVMODEW pDevModeOutput,
1559 LPDEVMODEW pDevModeInput, DWORD fMode)
1560 {
1561
1562 LPSTR pDeviceNameA = strdupWtoA(pDeviceName);
1563 LPDEVMODEA pDevModeInputA = DEVMODEdupWtoA(pDevModeInput);
1564 LPDEVMODEA pDevModeOutputA = NULL;
1565 LONG ret;
1566
1567 TRACE("(%p,%p,%s,%p,%p,%d)\n",
1568 hWnd,hPrinter,debugstr_w(pDeviceName),pDevModeOutput,pDevModeInput,
1569 fMode);
1570 if(pDevModeOutput) {
1571 ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, NULL, NULL, 0);
1572 if(ret < 0) return ret;
1573 pDevModeOutputA = HeapAlloc(GetProcessHeap(), 0, ret);
1574 }
1575 ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, pDevModeOutputA,
1576 pDevModeInputA, fMode);
1577 if(pDevModeOutput) {
1578 DEVMODEcpyAtoW(pDevModeOutput, pDevModeOutputA);
1579 HeapFree(GetProcessHeap(),0,pDevModeOutputA);
1580 }
1581 if(fMode == 0 && ret > 0)
1582 ret += (CCHDEVICENAME + CCHFORMNAME);
1583 HeapFree(GetProcessHeap(),0,pDevModeInputA);
1584 HeapFree(GetProcessHeap(),0,pDeviceNameA);
1585 return ret;
1586 }
1587
1588 /******************************************************************
1589 * OpenPrinterA [WINSPOOL.@]
1590 *
1591 * See OpenPrinterW.
1592 *
1593 */
1594 BOOL WINAPI OpenPrinterA(LPSTR lpPrinterName,HANDLE *phPrinter,
1595 LPPRINTER_DEFAULTSA pDefault)
1596 {
1597 UNICODE_STRING lpPrinterNameW;
1598 UNICODE_STRING usBuffer;
1599 PRINTER_DEFAULTSW DefaultW, *pDefaultW = NULL;
1600 PWSTR pwstrPrinterNameW;
1601 BOOL ret;
1602
1603 pwstrPrinterNameW = asciitounicode(&lpPrinterNameW,lpPrinterName);
1604
1605 if(pDefault) {
1606 DefaultW.pDatatype = asciitounicode(&usBuffer,pDefault->pDatatype);
1607 DefaultW.pDevMode = pDefault->pDevMode ? GdiConvertToDevmodeW(pDefault->pDevMode) : NULL;
1608 DefaultW.DesiredAccess = pDefault->DesiredAccess;
1609 pDefaultW = &DefaultW;
1610 }
1611 ret = OpenPrinterW(pwstrPrinterNameW, phPrinter, pDefaultW);
1612 if(pDefault) {
1613 RtlFreeUnicodeString(&usBuffer);
1614 HeapFree(GetProcessHeap(), 0, DefaultW.pDevMode);
1615 }
1616 RtlFreeUnicodeString(&lpPrinterNameW);
1617 return ret;
1618 }
1619
1620 /******************************************************************
1621 * OpenPrinterW [WINSPOOL.@]
1622 *
1623 * Open a Printer / Printserver or a Printer-Object
1624 *
1625 * PARAMS
1626 * lpPrinterName [I] Name of Printserver, Printer, or Printer-Object
1627 * phPrinter [O] The resulting Handle is stored here
1628 * pDefault [I] PTR to Default Printer Settings or NULL
1629 *
1630 * RETURNS
1631 * Success: TRUE
1632 * Failure: FALSE
1633 *
1634 * NOTES
1635 * lpPrinterName is one of:
1636 *| Printserver (NT only): "Servername" or NULL for the local Printserver
1637 *| Printer: "PrinterName"
1638 *| Printer-Object: "PrinterName,Job xxx"
1639 *| XcvMonitor: "Servername,XcvMonitor MonitorName"
1640 *| XcvPort: "Servername,XcvPort PortName"
1641 *
1642 * BUGS
1643 *| Printer-Object not supported
1644 *| pDefaults is ignored
1645 *
1646 */
1647 BOOL WINAPI OpenPrinterW(LPWSTR lpPrinterName,HANDLE *phPrinter, LPPRINTER_DEFAULTSW pDefault)
1648 {
1649
1650 TRACE("(%s, %p, %p)\n", debugstr_w(lpPrinterName), phPrinter, pDefault);
1651 if (pDefault) {
1652 FIXME("PRINTER_DEFAULTS ignored => %s,%p,0x%08x\n",
1653 debugstr_w(pDefault->pDatatype), pDefault->pDevMode, pDefault->DesiredAccess);
1654 }
1655
1656 if(!phPrinter) {
1657 /* NT: FALSE with ERROR_INVALID_PARAMETER, 9x: TRUE */
1658 SetLastError(ERROR_INVALID_PARAMETER);
1659 return FALSE;
1660 }
1661
1662 /* Get the unique handle of the printer or Printserver */
1663 *phPrinter = get_opened_printer_entry(lpPrinterName, pDefault);
1664 TRACE("returning %d with %u and %p\n", *phPrinter != NULL, GetLastError(), *phPrinter);
1665 return (*phPrinter != 0);
1666 }
1667
1668 /******************************************************************
1669 * AddMonitorA [WINSPOOL.@]
1670 *
1671 * See AddMonitorW.
1672 *
1673 */
1674 BOOL WINAPI AddMonitorA(LPSTR pName, DWORD Level, LPBYTE pMonitors)
1675 {
1676 LPWSTR nameW = NULL;
1677 INT len;
1678 BOOL res;
1679 LPMONITOR_INFO_2A mi2a;
1680 MONITOR_INFO_2W mi2w;
1681
1682 mi2a = (LPMONITOR_INFO_2A) pMonitors;
1683 TRACE("(%s, %d, %p) : %s %s %s\n", debugstr_a(pName), Level, pMonitors,
1684 debugstr_a(mi2a ? mi2a->pName : NULL),
1685 debugstr_a(mi2a ? mi2a->pEnvironment : NULL),
1686 debugstr_a(mi2a ? mi2a->pDLLName : NULL));
1687
1688 if (Level != 2) {
1689 SetLastError(ERROR_INVALID_LEVEL);
1690 return FALSE;
1691 }
1692
1693 /* XP: unchanged, win9x: ERROR_INVALID_ENVIRONMENT */
1694 if (mi2a == NULL) {
1695 return FALSE;
1696 }
1697
1698 if (pName) {
1699 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
1700 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1701 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
1702 }
1703
1704 memset(&mi2w, 0, sizeof(MONITOR_INFO_2W));
1705 if (mi2a->pName) {
1706 len = MultiByteToWideChar(CP_ACP, 0, mi2a->pName, -1, NULL, 0);
1707 mi2w.pName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1708 MultiByteToWideChar(CP_ACP, 0, mi2a->pName, -1, mi2w.pName, len);
1709 }
1710 if (mi2a->pEnvironment) {
1711 len = MultiByteToWideChar(CP_ACP, 0, mi2a->pEnvironment, -1, NULL, 0);
1712 mi2w.pEnvironment = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1713 MultiByteToWideChar(CP_ACP, 0, mi2a->pEnvironment, -1, mi2w.pEnvironment, len);
1714 }
1715 if (mi2a->pDLLName) {
1716 len = MultiByteToWideChar(CP_ACP, 0, mi2a->pDLLName, -1, NULL, 0);
1717 mi2w.pDLLName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1718 MultiByteToWideChar(CP_ACP, 0, mi2a->pDLLName, -1, mi2w.pDLLName, len);
1719 }
1720
1721 res = AddMonitorW(nameW, Level, (LPBYTE) &mi2w);
1722
1723 HeapFree(GetProcessHeap(), 0, mi2w.pName);
1724 HeapFree(GetProcessHeap(), 0, mi2w.pEnvironment);
1725 HeapFree(GetProcessHeap(), 0, mi2w.pDLLName);
1726
1727 HeapFree(GetProcessHeap(), 0, nameW);
1728 return (res);
1729 }
1730
1731 /******************************************************************************
1732 * AddMonitorW [WINSPOOL.@]
1733 *
1734 * Install a Printmonitor
1735 *
1736 * PARAMS
1737 * pName [I] Servername or NULL (local Computer)
1738 * Level [I] Structure-Level (Must be 2)
1739 * pMonitors [I] PTR to MONITOR_INFO_2
1740 *
1741 * RETURNS
1742 * Success: TRUE
1743 * Failure: FALSE
1744 *
1745 * NOTES
1746 * All Files for the Monitor must already be copied to %winsysdir% ("%SystemRoot%\system32")
1747 *
1748 */
1749 BOOL WINAPI AddMonitorW(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
1750 {
1751 LPMONITOR_INFO_2W mi2w;
1752
1753 mi2w = (LPMONITOR_INFO_2W) pMonitors;
1754 TRACE("(%s, %d, %p) : %s %s %s\n", debugstr_w(pName), Level, pMonitors,
1755 debugstr_w(mi2w ? mi2w->pName : NULL),
1756 debugstr_w(mi2w ? mi2w->pEnvironment : NULL),
1757 debugstr_w(mi2w ? mi2w->pDLLName : NULL));
1758
1759 if ((backend == NULL) && !load_backend()) return FALSE;
1760
1761 if (Level != 2) {
1762 SetLastError(ERROR_INVALID_LEVEL);
1763 return FALSE;
1764 }
1765
1766 /* XP: unchanged, win9x: ERROR_INVALID_ENVIRONMENT */
1767 if (mi2w == NULL) {
1768 return FALSE;
1769 }
1770
1771 return backend->fpAddMonitor(pName, Level, pMonitors);
1772 }
1773
1774 /******************************************************************
1775 * DeletePrinterDriverA [WINSPOOL.@]
1776 *
1777 */
1778 BOOL WINAPI DeletePrinterDriverA (LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName)
1779 {
1780 return DeletePrinterDriverExA(pName, pEnvironment, pDriverName, 0, 0);
1781 }
1782
1783 /******************************************************************
1784 * DeletePrinterDriverW [WINSPOOL.@]
1785 *
1786 */
1787 BOOL WINAPI DeletePrinterDriverW (LPWSTR pName, LPWSTR pEnvironment, LPWSTR pDriverName)
1788 {
1789 return DeletePrinterDriverExW(pName, pEnvironment, pDriverName, 0, 0);
1790 }
1791
1792 /******************************************************************
1793 * DeleteMonitorA [WINSPOOL.@]
1794 *
1795 * See DeleteMonitorW.
1796 *
1797 */
1798 BOOL WINAPI DeleteMonitorA (LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName)
1799 {
1800 LPWSTR nameW = NULL;
1801 LPWSTR EnvironmentW = NULL;
1802 LPWSTR MonitorNameW = NULL;
1803 BOOL res;
1804 INT len;
1805
1806 if (pName) {
1807 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
1808 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1809 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
1810 }
1811
1812 if (pEnvironment) {
1813 len = MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, NULL, 0);
1814 EnvironmentW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1815 MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, EnvironmentW, len);
1816 }
1817 if (pMonitorName) {
1818 len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
1819 MonitorNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1820 MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, MonitorNameW, len);
1821 }
1822
1823 res = DeleteMonitorW(nameW, EnvironmentW, MonitorNameW);
1824
1825 HeapFree(GetProcessHeap(), 0, MonitorNameW);
1826 HeapFree(GetProcessHeap(), 0, EnvironmentW);
1827 HeapFree(GetProcessHeap(), 0, nameW);
1828 return (res);
1829 }
1830
1831 /******************************************************************
1832 * DeleteMonitorW [WINSPOOL.@]
1833 *
1834 * Delete a specific Printmonitor from a Printing-Environment
1835 *
1836 * PARAMS
1837 * pName [I] Servername or NULL (local Computer)
1838 * pEnvironment [I] Printing-Environment of the Monitor or NULL (Default)
1839 * pMonitorName [I] Name of the Monitor, that should be deleted
1840 *
1841 * RETURNS
1842 * Success: TRUE
1843 * Failure: FALSE
1844 *
1845 * NOTES
1846 * pEnvironment is ignored in Windows for the local Computer.
1847 *
1848 */
1849 BOOL WINAPI DeleteMonitorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName)
1850 {
1851
1852 TRACE("(%s, %s, %s)\n",debugstr_w(pName),debugstr_w(pEnvironment),
1853 debugstr_w(pMonitorName));
1854
1855 if ((backend == NULL) && !load_backend()) return FALSE;
1856
1857 return backend->fpDeleteMonitor(pName, pEnvironment, pMonitorName);
1858 }
1859
1860
1861 /******************************************************************
1862 * DeletePortA [WINSPOOL.@]
1863 *
1864 * See DeletePortW.
1865 *
1866 */
1867 BOOL WINAPI DeletePortA (LPSTR pName, HWND hWnd, LPSTR pPortName)
1868 {
1869 LPWSTR nameW = NULL;
1870 LPWSTR portW = NULL;
1871 INT len;
1872 DWORD res;
1873
1874 TRACE("(%s, %p, %s)\n", debugstr_a(pName), hWnd, debugstr_a(pPortName));
1875
1876 /* convert servername to unicode */
1877 if (pName) {
1878 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
1879 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1880 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
1881 }
1882
1883 /* convert portname to unicode */
1884 if (pPortName) {
1885 len = MultiByteToWideChar(CP_ACP, 0, pPortName, -1, NULL, 0);
1886 portW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1887 MultiByteToWideChar(CP_ACP, 0, pPortName, -1, portW, len);
1888 }
1889
1890 res = DeletePortW(nameW, hWnd, portW);
1891 HeapFree(GetProcessHeap(), 0, nameW);
1892 HeapFree(GetProcessHeap(), 0, portW);
1893 return res;
1894 }
1895
1896 /******************************************************************
1897 * DeletePortW [WINSPOOL.@]
1898 *
1899 * Delete a specific Port
1900 *
1901 * PARAMS
1902 * pName [I] Servername or NULL (local Computer)
1903 * hWnd [I] Handle to parent Window for the Dialog-Box
1904 * pPortName [I] Name of the Port, that should be deleted
1905 *
1906 * RETURNS
1907 * Success: TRUE
1908 * Failure: FALSE
1909 *
1910 */
1911 BOOL WINAPI DeletePortW (LPWSTR pName, HWND hWnd, LPWSTR pPortName)
1912 {
1913 TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
1914
1915 if ((backend == NULL) && !load_backend()) return FALSE;
1916
1917 if (!pPortName) {
1918 SetLastError(RPC_X_NULL_REF_POINTER);
1919 return FALSE;
1920 }
1921
1922 return backend->fpDeletePort(pName, hWnd, pPortName);
1923 }
1924
1925 /******************************************************************************
1926 * SetPrinterW [WINSPOOL.@]
1927 */
1928 BOOL WINAPI SetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter, DWORD Command)
1929 {
1930 FIXME("(%p, %d, %p, %d): stub\n", hPrinter, Level, pPrinter, Command);
1931 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1932 return FALSE;
1933 }
1934
1935 /******************************************************************************
1936 * WritePrinter [WINSPOOL.@]
1937 */
1938 BOOL WINAPI WritePrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf, LPDWORD pcWritten)
1939 {
1940 opened_printer_t *printer;
1941 BOOL ret = FALSE;
1942
1943 TRACE("(%p, %p, %d, %p)\n", hPrinter, pBuf, cbBuf, pcWritten);
1944
1945 EnterCriticalSection(&printer_handles_cs);
1946 printer = get_opened_printer(hPrinter);
1947 if(!printer)
1948 {
1949 SetLastError(ERROR_INVALID_HANDLE);
1950 goto end;
1951 }
1952
1953 if(!printer->doc)
1954 {
1955 SetLastError(ERROR_SPL_NO_STARTDOC);
1956 goto end;
1957 }
1958
1959 ret = WriteFile(printer->doc->hf, pBuf, cbBuf, pcWritten, NULL);
1960 end:
1961 LeaveCriticalSection(&printer_handles_cs);
1962 return ret;
1963 }
1964
1965 /*****************************************************************************
1966 * AddFormA [WINSPOOL.@]
1967 */
1968 BOOL WINAPI AddFormA(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
1969 {
1970 FIXME("(%p,%d,%p): stub\n", hPrinter, Level, pForm);
1971 return 1;
1972 }
1973
1974 /*****************************************************************************
1975 * AddFormW [WINSPOOL.@]
1976 */
1977 BOOL WINAPI AddFormW(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
1978 {
1979 FIXME("(%p,%d,%p): stub\n", hPrinter, Level, pForm);
1980 return 1;
1981 }
1982
1983 /*****************************************************************************
1984 * AddJobA [WINSPOOL.@]
1985 */
1986 BOOL WINAPI AddJobA(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf, LPDWORD pcbNeeded)
1987 {
1988 BOOL ret;
1989 BYTE buf[MAX_PATH * sizeof(WCHAR) + sizeof(ADDJOB_INFO_1W)];
1990 DWORD needed;
1991
1992 if(Level != 1) {
1993 SetLastError(ERROR_INVALID_LEVEL);
1994 return FALSE;
1995 }
1996
1997 ret = AddJobW(hPrinter, Level, buf, sizeof(buf), &needed);
1998
1999 if(ret) {
2000 ADDJOB_INFO_1W *addjobW = (ADDJOB_INFO_1W*)buf;
2001 DWORD len = WideCharToMultiByte(CP_ACP, 0, addjobW->Path, -1, NULL, 0, NULL, NULL);
2002 *pcbNeeded = len + sizeof(ADDJOB_INFO_1A);
2003 if(*pcbNeeded > cbBuf) {
2004 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2005 ret = FALSE;
2006 } else {
2007 ADDJOB_INFO_1A *addjobA = (ADDJOB_INFO_1A*)pData;
2008 addjobA->JobId = addjobW->JobId;
2009 addjobA->Path = (char *)(addjobA + 1);
2010 WideCharToMultiByte(CP_ACP, 0, addjobW->Path, -1, addjobA->Path, len, NULL, NULL);
2011 }
2012 }
2013 return ret;
2014 }
2015
2016 /*****************************************************************************
2017 * AddJobW [WINSPOOL.@]
2018 */
2019 BOOL WINAPI AddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf, LPDWORD pcbNeeded)
2020 {
2021 opened_printer_t *printer;
2022 job_t *job;
2023 BOOL ret = FALSE;
2024 static const WCHAR spool_path[] = {'s','p','o','o','l','\\','P','R','I','N','T','E','R','S','\\',0};
2025 static const WCHAR fmtW[] = {'%','s','%','0','5','d','.','S','P','L',0};
2026 WCHAR path[MAX_PATH], filename[MAX_PATH];
2027 DWORD len;
2028 ADDJOB_INFO_1W *addjob;
2029
2030 TRACE("(%p,%d,%p,%d,%p)\n", hPrinter, Level, pData, cbBuf, pcbNeeded);
2031
2032 EnterCriticalSection(&printer_handles_cs);
2033
2034 printer = get_opened_printer(hPrinter);
2035
2036 if(!printer) {
2037 SetLastError(ERROR_INVALID_HANDLE);
2038 goto end;
2039 }
2040
2041 if(Level != 1) {
2042 SetLastError(ERROR_INVALID_LEVEL);
2043 goto end;
2044 }
2045
2046 job = HeapAlloc(GetProcessHeap(), 0, sizeof(*job));
2047 if(!job)
2048 goto end;
2049
2050 job->job_id = InterlockedIncrement(&next_job_id);
2051
2052 len = GetSystemDirectoryW(path, sizeof(path) / sizeof(WCHAR));
2053 if(path[len - 1] != '\\')
2054 path[len++] = '\\';
2055 memcpy(path + len, spool_path, sizeof(spool_path));
2056 sprintfW(filename, fmtW, path, job->job_id);
2057
2058 len = strlenW(filename);
2059 job->filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
2060 memcpy(job->filename, filename, (len + 1) * sizeof(WCHAR));
2061 job->document_title = strdupW(default_doc_title);
2062 list_add_tail(&printer->queue->jobs, &job->entry);
2063
2064 *pcbNeeded = (len + 1) * sizeof(WCHAR) + sizeof(*addjob);
2065 if(*pcbNeeded <= cbBuf) {
2066 addjob = (ADDJOB_INFO_1W*)pData;
2067 addjob->JobId = job->job_id;
2068 addjob->Path = (WCHAR *)(addjob + 1);
2069 memcpy(addjob->Path, filename, (len + 1) * sizeof(WCHAR));
2070 ret = TRUE;
2071 } else
2072 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2073
2074 end:
2075 LeaveCriticalSection(&printer_handles_cs);
2076 return ret;
2077 }
2078
2079 /*****************************************************************************
2080 * GetPrintProcessorDirectoryA [WINSPOOL.@]
2081 *
2082 * Return the PATH for the Print-Processors
2083 *
2084 * See GetPrintProcessorDirectoryW.
2085 *
2086 *
2087 */
2088 BOOL WINAPI GetPrintProcessorDirectoryA(LPSTR server, LPSTR env,
2089 DWORD level, LPBYTE Info,
2090 DWORD cbBuf, LPDWORD pcbNeeded)
2091 {
2092 LPWSTR serverW = NULL;
2093 LPWSTR envW = NULL;
2094 BOOL ret;
2095 INT len;
2096
2097 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_a(server),
2098 debugstr_a(env), level, Info, cbBuf, pcbNeeded);
2099
2100
2101 if (server) {
2102 len = MultiByteToWideChar(CP_ACP, 0, server, -1, NULL, 0);
2103 serverW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2104 MultiByteToWideChar(CP_ACP, 0, server, -1, serverW, len);
2105 }
2106
2107 if (env) {
2108 len = MultiByteToWideChar(CP_ACP, 0, env, -1, NULL, 0);
2109 envW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2110 MultiByteToWideChar(CP_ACP, 0, env, -1, envW, len);
2111 }
2112
2113 /* NT requires the buffersize from GetPrintProcessorDirectoryW also
2114 for GetPrintProcessorDirectoryA and WC2MB is done in-place.
2115 */
2116 ret = GetPrintProcessorDirectoryW(serverW, envW, level, Info,
2117 cbBuf, pcbNeeded);
2118
2119 if (ret) ret = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)Info, -1, (LPSTR)Info,
2120 cbBuf, NULL, NULL) > 0;
2121
2122
2123 TRACE(" required: 0x%x/%d\n", pcbNeeded ? *pcbNeeded : 0, pcbNeeded ? *pcbNeeded : 0);
2124 HeapFree(GetProcessHeap(), 0, envW);
2125 HeapFree(GetProcessHeap(), 0, serverW);
2126 return ret;
2127 }
2128
2129 /*****************************************************************************
2130 * GetPrintProcessorDirectoryW [WINSPOOL.@]
2131 *
2132 * Return the PATH for the Print-Processors
2133 *
2134 * PARAMS
2135 * server [I] Servername (NT only) or NULL (local Computer)
2136 * env [I] Printing-Environment (see below) or NULL (Default)
2137 * level [I] Structure-Level (must be 1)
2138 * Info [O] PTR to Buffer that receives the Result
2139 * cbBuf [I] Size of Buffer at "Info"
2140 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used /
2141 * required for the Buffer at "Info"
2142 *
2143 * RETURNS
2144 * Success: TRUE and in pcbNeeded the Bytes used in Info
2145 * Failure: FALSE and in pcbNeeded the Bytes required for Info,
2146 * if cbBuf is too small
2147 *
2148 * Native Values returned in Info on Success:
2149 *| NT(Windows NT x86): "%winsysdir%\\spool\\PRTPROCS\\w32x86"
2150 *| NT(Windows 4.0): "%winsysdir%\\spool\\PRTPROCS\\win40"
2151 *| win9x(Windows 4.0): "%winsysdir%"
2152 *
2153 * "%winsysdir%" is the Value from GetSystemDirectoryW()
2154 *
2155 * BUGS
2156 * Only NULL or "" is supported for server
2157 *
2158 */
2159 BOOL WINAPI GetPrintProcessorDirectoryW(LPWSTR server, LPWSTR env,
2160 DWORD level, LPBYTE Info,
2161 DWORD cbBuf, LPDWORD pcbNeeded)
2162 {
2163
2164 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(server), debugstr_w(env), level,
2165 Info, cbBuf, pcbNeeded);
2166
2167 if ((backend == NULL) && !load_backend()) return FALSE;
2168
2169 if (level != 1) {
2170 /* (Level != 1) is ignored in win9x */
2171 SetLastError(ERROR_INVALID_LEVEL);
2172 return FALSE;
2173 }
2174
2175 if (pcbNeeded == NULL) {
2176 /* (pcbNeeded == NULL) is ignored in win9x */
2177 SetLastError(RPC_X_NULL_REF_POINTER);
2178 return FALSE;
2179 }
2180
2181 return backend->fpGetPrintProcessorDirectory(server, env, level, Info, cbBuf, pcbNeeded);
2182 }
2183
2184 /*****************************************************************************
2185 * WINSPOOL_OpenDriverReg [internal]
2186 *
2187 * opens the registry for the printer drivers depending on the given input
2188 * variable pEnvironment
2189 *
2190 * RETURNS:
2191 * the opened hkey on success
2192 * NULL on error
2193 */
2194 static HKEY WINSPOOL_OpenDriverReg( LPCVOID pEnvironment, BOOL unicode)
2195 {
2196 HKEY retval = NULL;
2197 LPWSTR buffer;
2198 const printenv_t * env;
2199
2200 TRACE("(%s, %d)\n",
2201 (unicode) ? debugstr_w(pEnvironment) : debugstr_a(pEnvironment), unicode);
2202
2203 if (!pEnvironment || unicode) {
2204 /* pEnvironment was NULL or a Unicode-String: use it direct */
2205 env = validate_envW(pEnvironment);
2206 }
2207 else
2208 {
2209 /* pEnvironment was an ANSI-String: convert to unicode first */
2210 LPWSTR buffer;
2211 INT len = MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, NULL, 0);
2212 buffer = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2213 if (buffer) MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, buffer, len);
2214 env = validate_envW(buffer);
2215 HeapFree(GetProcessHeap(), 0, buffer);
2216 }
2217 if (!env) return NULL;
2218
2219 buffer = HeapAlloc( GetProcessHeap(), 0,
2220 (strlenW(DriversW) + strlenW(env->envname) +
2221 strlenW(env->versionregpath) + 1) * sizeof(WCHAR));
2222 if(buffer) {
2223 wsprintfW(buffer, DriversW, env->envname, env->versionregpath);
2224 RegCreateKeyW(HKEY_LOCAL_MACHINE, buffer, &retval);
2225 HeapFree(GetProcessHeap(), 0, buffer);
2226 }
2227 return retval;
2228 }
2229
2230 /*****************************************************************************
2231 * AddPrinterW [WINSPOOL.@]
2232 */
2233 HANDLE WINAPI AddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter)
2234 {
2235 PRINTER_INFO_2W *pi = (PRINTER_INFO_2W *) pPrinter;
2236 LPDEVMODEA dmA;
2237 LPDEVMODEW dmW;
2238 HANDLE retval;
2239 HKEY hkeyPrinter, hkeyPrinters, hkeyDriver, hkeyDrivers;
2240 LONG size;
2241 static const WCHAR attributesW[] = {'A','t','t','r','i','b','u','t','e','s',0},
2242 default_devmodeW[] = {'D','e','f','a','u','l','t',' ','D','e','v','M','o','d','e',0},
2243 priorityW[] = {'P','r','i','o','r','i','t','y',0},
2244 start_timeW[] = {'S','t','a','r','t','T','i','m','e',0},
2245 statusW[] = {'S','t','a','t','u','s',0},
2246 until_timeW[] = {'U','n','t','i','l','T','i','m','e',0};
2247
2248 TRACE("(%s,%d,%p)\n", debugstr_w(pName), Level, pPrinter);
2249
2250 if(pName != NULL) {
2251 ERR("pName = %s - unsupported\n", debugstr_w(pName));
2252 SetLastError(ERROR_INVALID_PARAMETER);
2253 return 0;
2254 }
2255 if(Level != 2) {
2256 ERR("Level = %d, unsupported!\n", Level);
2257 SetLastError(ERROR_INVALID_LEVEL);
2258 return 0;
2259 }
2260 if(!pPrinter) {
2261 SetLastError(ERROR_INVALID_PARAMETER);
2262 return 0;
2263 }
2264 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
2265 ERROR_SUCCESS) {
2266 ERR("Can't create Printers key\n");
2267 return 0;
2268 }
2269 if(!RegOpenKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter)) {
2270 if (!RegQueryValueW(hkeyPrinter, attributesW, NULL, NULL)) {
2271 SetLastError(ERROR_PRINTER_ALREADY_EXISTS);
2272 RegCloseKey(hkeyPrinter);
2273 RegCloseKey(hkeyPrinters);
2274 return 0;
2275 }
2276 RegCloseKey(hkeyPrinter);
2277 }
2278 hkeyDrivers = WINSPOOL_OpenDriverReg( NULL, TRUE);
2279 if(!hkeyDrivers) {
2280 ERR("Can't create Drivers key\n");
2281 RegCloseKey(hkeyPrinters);
2282 return 0;
2283 }
2284 if(RegOpenKeyW(hkeyDrivers, pi->pDriverName, &hkeyDriver) !=
2285 ERROR_SUCCESS) {
2286 WARN("Can't find driver %s\n", debugstr_w(pi->pDriverName));
2287 RegCloseKey(hkeyPrinters);
2288 RegCloseKey(hkeyDrivers);
2289 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
2290 return 0;
2291 }
2292 RegCloseKey(hkeyDriver);
2293 RegCloseKey(hkeyDrivers);
2294
2295 if(lstrcmpiW(pi->pPrintProcessor, WinPrintW)) { /* FIXME */
2296 FIXME("Can't find processor %s\n", debugstr_w(pi->pPrintProcessor));
2297 SetLastError(ERROR_UNKNOWN_PRINTPROCESSOR);
2298 RegCloseKey(hkeyPrinters);
2299 return 0;
2300 }
2301
2302 if(RegCreateKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter) !=
2303 ERROR_SUCCESS) {
2304 FIXME("Can't create printer %s\n", debugstr_w(pi->pPrinterName));
2305 SetLastError(ERROR_INVALID_PRINTER_NAME);
2306 RegCloseKey(hkeyPrinters);
2307 return 0;
2308 }
2309 RegSetValueExW(hkeyPrinter, attributesW, 0, REG_DWORD,
2310 (LPBYTE)&pi->Attributes, sizeof(DWORD));
2311 set_reg_szW(hkeyPrinter, DatatypeW, pi->pDatatype);
2312
2313 /* See if we can load the driver. We may need the devmode structure anyway
2314 *
2315 * FIXME:
2316 * Note that DocumentPropertiesW will briefly try to open the printer we
2317 * just create to find a DEVMODEA struct (it will use the WINEPS default
2318 * one in case it is not there, so we are ok).
2319 */
2320 size = DocumentPropertiesW(0, 0, pi->pPrinterName, NULL, NULL, 0);
2321
2322 if(size < 0) {
2323 FIXME("DocumentPropertiesW on printer %s fails\n", debugstr_w(pi->pPrinterName));
2324 size = sizeof(DEVMODEW);
2325 }
2326 if(pi->pDevMode)
2327 dmW = pi->pDevMode;
2328 else
2329 {
2330 dmW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2331 dmW->dmSize = size;
2332 if (0>DocumentPropertiesW(0,0,pi->pPrinterName,dmW,NULL,DM_OUT_BUFFER))
2333 {
2334 WARN("DocumentPropertiesW on printer %s failed!\n", debugstr_w(pi->pPrinterName));
2335 HeapFree(GetProcessHeap(),0,dmW);
2336 dmW=NULL;
2337 }
2338 else
2339 {
2340 /* set devmode to printer name */
2341 lstrcpynW(dmW->dmDeviceName, pi->pPrinterName, CCHDEVICENAME);
2342 }
2343 }
2344
2345 /* Write DEVMODEA not DEVMODEW into reg. This is what win9x does
2346 and we support these drivers. NT writes DEVMODEW so somehow
2347 we'll need to distinguish between these when we support NT
2348 drivers */
2349 if (dmW)
2350 {
2351 dmA = DEVMODEdupWtoA(dmW);
2352 RegSetValueExW(hkeyPrinter, default_devmodeW, 0, REG_BINARY,
2353 (LPBYTE)dmA, dmA->dmSize + dmA->dmDriverExtra);
2354 HeapFree(GetProcessHeap(), 0, dmA);
2355 if(!pi->pDevMode)
2356 HeapFree(GetProcessHeap(), 0, dmW);
2357 }
2358 set_reg_szW(hkeyPrinter, DescriptionW, pi->pComment);
2359 set_reg_szW(hkeyPrinter, LocationW, pi->pLocation);
2360 set_reg_szW(hkeyPrinter, NameW, pi->pPrinterName);
2361 set_reg_szW(hkeyPrinter, ParametersW, pi->pParameters);
2362
2363 set_reg_szW(hkeyPrinter, PortW, pi->pPortName);
2364 set_reg_szW(hkeyPrinter, Print_ProcessorW, pi->pPrintProcessor);
2365 set_reg_szW(hkeyPrinter, Printer_DriverW, pi->pDriverName);
2366 RegSetValueExW(hkeyPrinter, priorityW, 0, REG_DWORD,
2367 (LPBYTE)&pi->Priority, sizeof(DWORD));
2368 set_reg_szW(hkeyPrinter, Separator_FileW, pi->pSepFile);
2369 set_reg_szW(hkeyPrinter, Share_NameW, pi->pShareName);
2370 RegSetValueExW(hkeyPrinter, start_timeW, 0, REG_DWORD,
2371 (LPBYTE)&pi->StartTime, sizeof(DWORD));
2372 RegSetValueExW(hkeyPrinter, statusW, 0, REG_DWORD,
2373 (LPBYTE)&pi->Status, sizeof(DWORD));
2374 RegSetValueExW(hkeyPrinter, until_timeW, 0, REG_DWORD,
2375 (LPBYTE)&pi->UntilTime, sizeof(DWORD));
2376
2377 RegCloseKey(hkeyPrinter);
2378 RegCloseKey(hkeyPrinters);
2379 if(!OpenPrinterW(pi->pPrinterName, &retval, NULL)) {
2380 ERR("OpenPrinter failing\n");
2381 return 0;
2382 }
2383 return retval;
2384 }
2385
2386 /*****************************************************************************
2387 * AddPrinterA [WINSPOOL.@]
2388 */
2389 HANDLE WINAPI AddPrinterA(LPSTR pName, DWORD Level, LPBYTE pPrinter)
2390 {
2391 UNICODE_STRING pNameW;
2392 PWSTR pwstrNameW;
2393 PRINTER_INFO_2W *piW;
2394 PRINTER_INFO_2A *piA = (PRINTER_INFO_2A*)pPrinter;
2395 HANDLE ret;
2396
2397 TRACE("(%s,%d,%p): stub\n", debugstr_a(pName), Level, pPrinter);
2398 if(Level != 2) {
2399 ERR("Level = %d, unsupported!\n", Level);
2400 SetLastError(ERROR_INVALID_LEVEL);
2401 return 0;
2402 }
2403 pwstrNameW = asciitounicode(&pNameW,pName);
2404 piW = PRINTER_INFO_2AtoW(GetProcessHeap(), piA);
2405
2406 ret = AddPrinterW(pwstrNameW, Level, (LPBYTE)piW);
2407
2408 FREE_PRINTER_INFO_2W(GetProcessHeap(), piW);
2409 RtlFreeUnicodeString(&pNameW);
2410 return ret;
2411 }
2412
2413
2414 /*****************************************************************************
2415 * ClosePrinter [WINSPOOL.@]
2416 */
2417 BOOL WINAPI ClosePrinter(HANDLE hPrinter)
2418 {
2419 UINT_PTR i = (UINT_PTR)hPrinter;
2420 opened_printer_t *printer = NULL;
2421 BOOL ret = FALSE;
2422
2423 TRACE("(%p)\n", hPrinter);
2424
2425 EnterCriticalSection(&printer_handles_cs);
2426
2427 if ((i > 0) && (i <= nb_printer_handles))
2428 printer = printer_handles[i - 1];
2429
2430
2431 if(printer)
2432 {
2433 struct list *cursor, *cursor2;
2434
2435 TRACE("closing %s (doc: %p)\n", debugstr_w(printer->name), printer->doc);
2436
2437 if (printer->backend_printer) {
2438 backend->fpClosePrinter(printer->backend_printer);
2439 }
2440
2441 if(printer->doc)
2442 EndDocPrinter(hPrinter);
2443
2444 if(InterlockedDecrement(&printer->queue->ref) == 0)
2445 {
2446 LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
2447 {
2448 job_t *job = LIST_ENTRY(cursor, job_t, entry);
2449 ScheduleJob(hPrinter, job->job_id);
2450 }
2451 HeapFree(GetProcessHeap(), 0, printer->queue);
2452 }
2453
2454 HeapFree(GetProcessHeap(), 0, printer->printername);
2455 HeapFree(GetProcessHeap(), 0, printer->name);
2456 HeapFree(GetProcessHeap(), 0, printer);
2457 printer_handles[i - 1] = NULL;
2458 ret = TRUE;
2459 }
2460 LeaveCriticalSection(&printer_handles_cs);
2461 return ret;
2462 }
2463
2464 /*****************************************************************************
2465 * DeleteFormA [WINSPOOL.@]
2466 */
2467 BOOL WINAPI DeleteFormA(HANDLE hPrinter, LPSTR pFormName)
2468 {
2469 FIXME("(%p,%s): stub\n", hPrinter, pFormName);
2470 return 1;
2471 }
2472
2473 /*****************************************************************************
2474 * DeleteFormW [WINSPOOL.@]
2475 */
2476 BOOL WINAPI DeleteFormW(HANDLE hPrinter, LPWSTR pFormName)
2477 {
2478 FIXME("(%p,%s): stub\n", hPrinter, debugstr_w(pFormName));
2479 return 1;
2480 }
2481
2482 /*****************************************************************************
2483 * DeletePrinter [WINSPOOL.@]
2484 */
2485 BOOL WINAPI DeletePrinter(HANDLE hPrinter)
2486 {
2487 LPCWSTR lpNameW = get_opened_printer_name(hPrinter);
2488 HKEY hkeyPrinters, hkey;
2489
2490 if(!lpNameW) {
2491 SetLastError(ERROR_INVALID_HANDLE);
2492 return FALSE;
2493 }
2494 if(RegOpenKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) == ERROR_SUCCESS) {
2495 RegDeleteTreeW(hkeyPrinters, lpNameW);
2496 RegCloseKey(hkeyPrinters);
2497 }
2498 WriteProfileStringW(devicesW, lpNameW, NULL);
2499 WriteProfileStringW(PrinterPortsW, lpNameW, NULL);
2500
2501 if(RegCreateKeyW(HKEY_CURRENT_USER, user_printers_reg_key, &hkey) == ERROR_SUCCESS) {
2502 RegDeleteValueW(hkey, lpNameW);
2503 RegCloseKey(hkey);
2504 }
2505
2506 if(RegCreateKeyW(HKEY_CURRENT_USER, WinNT_CV_PrinterPortsW, &hkey) == ERROR_SUCCESS) {
2507 RegDeleteValueW(hkey, lpNameW);
2508 RegCloseKey(hkey);
2509 }
2510 return TRUE;
2511 }
2512
2513 /*****************************************************************************
2514 * SetPrinterA [WINSPOOL.@]
2515 */
2516 BOOL WINAPI SetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
2517 DWORD Command)
2518 {
2519 FIXME("(%p,%d,%p,%d): stub\n",hPrinter,Level,pPrinter,Command);
2520 return FALSE;
2521 }
2522
2523 /*****************************************************************************
2524 * SetJobA [WINSPOOL.@]
2525 */
2526 BOOL WINAPI SetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level,
2527 LPBYTE pJob, DWORD Command)
2528 {
2529 BOOL ret;
2530 LPBYTE JobW;
2531 UNICODE_STRING usBuffer;
2532
2533 TRACE("(%p, %d, %d, %p, %d)\n",hPrinter, JobId, Level, pJob, Command);
2534
2535 /* JobId, pPrinterName, pMachineName, pDriverName, Size, Submitted, Time and TotalPages
2536 are all ignored by SetJob, so we don't bother copying them */
2537 switch(Level)
2538 {
2539 case 0:
2540 JobW = NULL;
2541 break;
2542 case 1:
2543 {
2544 JOB_INFO_1W *info1W = HeapAlloc(GetProcessHeap(), 0, sizeof(*info1W));
2545 JOB_INFO_1A *info1A = (JOB_INFO_1A*)pJob;
2546
2547 JobW = (LPBYTE)info1W;
2548 info1W->pUserName = asciitounicode(&usBuffer, info1A->pUserName);
2549 info1W->pDocument = asciitounicode(&usBuffer, info1A->pDocument);
2550 info1W->pDatatype = asciitounicode(&usBuffer, info1A->pDatatype);
2551 info1W->pStatus = asciitounicode(&usBuffer, info1A->pStatus);
2552 info1W->Status = info1A->Status;
2553 info1W->Priority = info1A->Priority;
2554 info1W->Position = info1A->Position;
2555 info1W->PagesPrinted = info1A->PagesPrinted;
2556 break;
2557 }
2558 case 2:
2559 {
2560 JOB_INFO_2W *info2W = HeapAlloc(GetProcessHeap(), 0, sizeof(*info2W));
2561 JOB_INFO_2A *info2A = (JOB_INFO_2A*)pJob;
2562
2563 JobW = (LPBYTE)info2W;
2564 info2W->pUserName = asciitounicode(&usBuffer, info2A->pUserName);
2565 info2W->pDocument = asciitounicode(&usBuffer, info2A->pDocument);
2566 info2W->pNotifyName = asciitounicode(&usBuffer, info2A->pNotifyName);
2567 info2W->pDatatype = asciitounicode(&usBuffer, info2A->pDatatype);
2568 info2W->pPrintProcessor = asciitounicode(&usBuffer, info2A->pPrintProcessor);
2569 info2W->pParameters = asciitounicode(&usBuffer, info2A->pParameters);
2570 info2W->pDevMode = info2A->pDevMode ? GdiConvertToDevmodeW(info2A->pDevMode) : NULL;
2571 info2W->pStatus = asciitounicode(&usBuffer, info2A->pStatus);
2572 info2W->pSecurityDescriptor = info2A->pSecurityDescriptor;
2573 info2W->Status = info2A->Status;
2574 info2W->Priority = info2A->Priority;
2575 info2W->Position = info2A->Position;
2576 info2W->StartTime = info2A->StartTime;
2577 info2W->UntilTime = info2A->UntilTime;
2578 info2W->PagesPrinted = info2A->PagesPrinted;
2579 break;
2580 }
2581 case 3:
2582 JobW = HeapAlloc(GetProcessHeap(), 0, sizeof(JOB_INFO_3));
2583 memcpy(JobW, pJob, sizeof(JOB_INFO_3));
2584 break;
2585 default:
2586 SetLastError(ERROR_INVALID_LEVEL);
2587 return FALSE;
2588 }
2589
2590 ret = SetJobW(hPrinter, JobId, Level, JobW, Command);
2591
2592 switch(Level)
2593 {
2594 case 1:
2595 {
2596 JOB_INFO_1W *info1W = (JOB_INFO_1W*)JobW;
2597 HeapFree(GetProcessHeap(), 0, info1W->pUserName);
2598 HeapFree(GetProcessHeap(), 0, info1W->pDocument);
2599 HeapFree(GetProcessHeap(), 0, info1W->pDatatype);
2600 HeapFree(GetProcessHeap(), 0, info1W->pStatus);
2601 break;
2602 }
2603 case 2:
2604 {
2605 JOB_INFO_2W *info2W = (JOB_INFO_2W*)JobW;
2606 HeapFree(GetProcessHeap(), 0, info2W->pUserName);
2607 HeapFree(GetProcessHeap(), 0, info2W->pDocument);
2608 HeapFree(GetProcessHeap(), 0, info2W->pNotifyName);
2609 HeapFree(GetProcessHeap(), 0, info2W->pDatatype);
2610 HeapFree(GetProcessHeap(), 0, info2W->pPrintProcessor);
2611 HeapFree(GetProcessHeap(), 0, info2W->pParameters);
2612 HeapFree(GetProcessHeap(), 0, info2W->pDevMode);
2613 HeapFree(GetProcessHeap(), 0, info2W->pStatus);
2614 break;
2615 }
2616 }
2617 HeapFree(GetProcessHeap(), 0, JobW);
2618
2619 return ret;
2620 }
2621
2622 /*****************************************************************************
2623 * SetJobW [WINSPOOL.@]
2624 */
2625 BOOL WINAPI SetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level,
2626 LPBYTE pJob, DWORD Command)
2627 {
2628 BOOL ret = FALSE;
2629 job_t *job;
2630
2631 TRACE("(%p, %d, %d, %p, %d)\n", hPrinter, JobId, Level, pJob, Command);
2632 FIXME("Ignoring everything other than document title\n");
2633
2634 EnterCriticalSection(&printer_handles_cs);
2635 job = get_job(hPrinter, JobId);
2636 if(!job)
2637 goto end;
2638
2639 switch(Level)
2640 {
2641 case 0:
2642 break;
2643 case 1:
2644 {
2645 JOB_INFO_1W *info1 = (JOB_INFO_1W*)pJob;
2646 HeapFree(GetProcessHeap(), 0, job->document_title);
2647 job->document_title = strdupW(info1->pDocument);
2648 break;
2649 }
2650 case 2:
2651 {
2652 JOB_INFO_2W *info2 = (JOB_INFO_2W*)pJob;
2653 HeapFree(GetProcessHeap(), 0, job->document_title);
2654 job->document_title = strdupW(info2->pDocument);
2655 break;
2656 }
2657 case 3:
2658 break;
2659 default:
2660 SetLastError(ERROR_INVALID_LEVEL);
2661 goto end;
2662 }
2663 ret = TRUE;
2664 end:
2665 LeaveCriticalSection(&printer_handles_cs);
2666 return ret;
2667 }
2668
2669 /*****************************************************************************
2670 * EndDocPrinter [WINSPOOL.@]
2671 */
2672 BOOL WINAPI EndDocPrinter(HANDLE hPrinter)
2673 {
2674 opened_printer_t *printer;
2675 BOOL ret = FALSE;
2676 TRACE("(%p)\n", hPrinter);
2677
2678 EnterCriticalSection(&printer_handles_cs);
2679
2680 printer = get_opened_printer(hPrinter);
2681 if(!printer)
2682 {
2683 SetLastError(ERROR_INVALID_HANDLE);
2684 goto end;
2685 }
2686
2687 if(!printer->doc)
2688 {
2689 SetLastError(ERROR_SPL_NO_STARTDOC);
2690 goto end;
2691 }
2692
2693 CloseHandle(printer->doc->hf);
2694 ScheduleJob(hPrinter, printer->doc->job_id);
2695 HeapFree(GetProcessHeap(), 0, printer->doc);
2696 printer->doc = NULL;
2697 ret = TRUE;
2698 end:
2699 LeaveCriticalSection(&printer_handles_cs);
2700 return ret;
2701 }
2702
2703 /*****************************************************************************
2704 * EndPagePrinter [WINSPOOL.@]
2705 */
2706 BOOL WINAPI EndPagePrinter(HANDLE hPrinter)
2707 {
2708 FIXME("(%p): stub\n", hPrinter);
2709 return TRUE;
2710 }
2711
2712 /*****************************************************************************
2713 * StartDocPrinterA [WINSPOOL.@]
2714 */
2715 DWORD WINAPI StartDocPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)
2716 {
2717 UNICODE_STRING usBuffer;
2718 DOC_INFO_2W doc2W;
2719 DOC_INFO_2A *doc2 = (DOC_INFO_2A*)pDocInfo;
2720 DWORD ret;
2721
2722 /* DOC_INFO_1, 2 and 3 all have the strings in the same place with either two (DOC_INFO_2)
2723 or one (DOC_INFO_3) extra DWORDs */
2724
2725 switch(Level) {
2726 case 2:
2727 doc2W.JobId = doc2->JobId;
2728 /* fall through */
2729 case 3:
2730 doc2W.dwMode = doc2->dwMode;
2731 /* fall through */
2732 case 1:
2733 doc2W.pDocName = asciitounicode(&usBuffer, doc2->pDocName);
2734 doc2W.pOutputFile = asciitounicode(&usBuffer, doc2->pOutputFile);
2735 doc2W.pDatatype = asciitounicode(&usBuffer, doc2->pDatatype);
2736 break;
2737
2738 default:
2739 SetLastError(ERROR_INVALID_LEVEL);
2740 return FALSE;
2741 }
2742
2743 ret = StartDocPrinterW(hPrinter, Level, (LPBYTE)&doc2W);
2744
2745 HeapFree(GetProcessHeap(), 0, doc2W.pDatatype);
2746 HeapFree(GetProcessHeap(), 0, doc2W.pOutputFile);
2747 HeapFree(GetProcessHeap(), 0, doc2W.pDocName);
2748
2749 return ret;
2750 }
2751
2752 /*****************************************************************************
2753 * StartDocPrinterW [WINSPOOL.@]
2754 */
2755 DWORD WINAPI StartDocPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)
2756 {
2757 DOC_INFO_2W *doc = (DOC_INFO_2W *)pDocInfo;
2758 opened_printer_t *printer;
2759 BYTE addjob_buf[MAX_PATH * sizeof(WCHAR) + sizeof(ADDJOB_INFO_1W)];
2760 ADDJOB_INFO_1W *addjob = (ADDJOB_INFO_1W*) addjob_buf;
2761 JOB_INFO_1W job_info;
2762 DWORD needed, ret = 0;
2763 HANDLE hf;
2764 WCHAR *filename;
2765
2766 TRACE("(hPrinter = %p, Level = %d, pDocInfo = %p {pDocName = %s, pOutputFile = %s, pDatatype = %s}):\n",
2767 hPrinter, Level, doc, debugstr_w(doc->pDocName), debugstr_w(doc->pOutputFile),
2768 debugstr_w(doc->pDatatype));
2769
2770 if(Level < 1 || Level > 3)
2771 {
2772 SetLastError(ERROR_INVALID_LEVEL);
2773 return 0;
2774 }
2775
2776 EnterCriticalSection(&printer_handles_cs);
2777 printer = get_opened_printer(hPrinter);
2778 if(!printer)
2779 {
2780 SetLastError(ERROR_INVALID_HANDLE);
2781 goto end;
2782 }
2783
2784 if(printer->doc)
2785 {
2786 SetLastError(ERROR_INVALID_PRINTER_STATE);
2787 goto end;
2788 }
2789
2790 /* Even if we're printing to a file we still add a print job, we'll
2791 just ignore the spool file name */
2792
2793 if(!AddJobW(hPrinter, 1, addjob_buf, sizeof(addjob_buf), &needed))
2794 {
2795 ERR("AddJob failed gle %u\n", GetLastError());
2796 goto end;
2797 }
2798
2799 if(doc->pOutputFile)
2800 filename = doc->pOutputFile;
2801 else
2802 filename = addjob->Path;
2803
2804 hf = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2805 if(hf == INVALID_HANDLE_VALUE)
2806 goto end;
2807
2808 memset(&job_info, 0, sizeof(job_info));
2809 job_info.pDocument = doc->pDocName;
2810 SetJobW(hPrinter, addjob->JobId, 1, (LPBYTE)&job_info, 0);
2811
2812 printer->doc = HeapAlloc(GetProcessHeap(), 0, sizeof(*printer->doc));
2813 printer->doc->hf = hf;
2814 ret = printer->doc->job_id = addjob->JobId;
2815 end:
2816 LeaveCriticalSection(&printer_handles_cs);
2817
2818 return ret;
2819 }
2820
2821 /*****************************************************************************
2822 * StartPagePrinter [WINSPOOL.@]
2823 */
2824 BOOL WINAPI StartPagePrinter(HANDLE hPrinter)
2825 {
2826 FIXME("(%p): stub\n", hPrinter);
2827 return TRUE;
2828 }
2829
2830 /*****************************************************************************
2831 * GetFormA [WINSPOOL.@]
2832 */
2833 BOOL WINAPI GetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
2834 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
2835 {
2836 FIXME("(%p,%s,%d,%p,%d,%p): stub\n",hPrinter,pFormName,
2837 Level,pForm,cbBuf,pcbNeeded);
2838 return FALSE;
2839 }
2840
2841 /*****************************************************************************
2842 * GetFormW [WINSPOOL.@]
2843 */
2844 BOOL WINAPI GetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
2845 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
2846 {
2847 FIXME("(%p,%s,%d,%p,%d,%p): stub\n",hPrinter,
2848 debugstr_w(pFormName),Level,pForm,cbBuf,pcbNeeded);
2849 return FALSE;
2850 }
2851
2852 /*****************************************************************************
2853 * SetFormA [WINSPOOL.@]
2854 */
2855 BOOL WINAPI SetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
2856 LPBYTE pForm)
2857 {
2858 FIXME("(%p,%s,%d,%p): stub\n",hPrinter,pFormName,Level,pForm);
2859 return FALSE;
2860 }
2861
2862 /*****************************************************************************
2863 * SetFormW [WINSPOOL.@]
2864 */
2865 BOOL WINAPI SetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
2866 LPBYTE pForm)
2867 {
2868 FIXME("(%p,%p,%d,%p): stub\n",hPrinter,pFormName,Level,pForm);
2869 return FALSE;
2870 }
2871
2872 /*****************************************************************************
2873 * ReadPrinter [WINSPOOL.@]
2874 */
2875 BOOL WINAPI ReadPrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf,
2876 LPDWORD pNoBytesRead)
2877 {
2878 FIXME("(%p,%p,%d,%p): stub\n",hPrinter,pBuf,cbBuf,pNoBytesRead);
2879 return FALSE;
2880 }
2881
2882 /*****************************************************************************
2883 * ResetPrinterA [WINSPOOL.@]
2884 */
2885 BOOL WINAPI ResetPrinterA(HANDLE hPrinter, LPPRINTER_DEFAULTSA pDefault)
2886 {
2887 FIXME("(%p, %p): stub\n", hPrinter, pDefault);
2888 return FALSE;
2889 }
2890
2891 /*****************************************************************************
2892 * ResetPrinterW [WINSPOOL.@]
2893 */
2894 BOOL WINAPI ResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault)
2895 {
2896 FIXME("(%p, %p): stub\n", hPrinter, pDefault);
2897 return FALSE;
2898 }
2899
2900 /*****************************************************************************
2901 * WINSPOOL_GetDWORDFromReg
2902 *
2903 * Return DWORD associated with ValueName from hkey.
2904 */
2905 static DWORD WINSPOOL_GetDWORDFromReg(HKEY hkey, LPCSTR ValueName)
2906 {
2907 DWORD sz = sizeof(DWORD), type, value = 0;
2908 LONG ret;
2909
2910 ret = RegQueryValueExA(hkey, ValueName, 0, &type, (LPBYTE)&value, &sz);
2911
2912 if(ret != ERROR_SUCCESS) {
2913 WARN("Got ret = %d on name %s\n", ret, ValueName);
2914 return 0;
2915 }
2916 if(type != REG_DWORD) {
2917 ERR("Got type %d\n", type);
2918 return 0;
2919 }
2920 return value;
2921 }
2922
2923
2924 /*****************************************************************************
2925 * get_filename_from_reg [internal]
2926 *
2927 * Get ValueName from hkey storing result in out
2928 * when the Value in the registry has only a filename, use driverdir as prefix
2929 * outlen is space left in out
2930 * String is stored either as unicode or ascii
2931 *
2932 */
2933
2934 static BOOL get_filename_from_reg(HKEY hkey, LPCWSTR driverdir, DWORD dirlen, LPCWSTR ValueName,
2935 LPBYTE out, DWORD outlen, LPDWORD needed, BOOL unicode)
2936 {
2937 WCHAR filename[MAX_PATH];
2938 DWORD size;
2939 DWORD type;
2940 LONG ret;
2941 LPWSTR buffer = filename;
2942 LPWSTR ptr;
2943
2944 *needed = 0;
2945 size = sizeof(filename);
2946 buffer[0] = '\0';
2947 ret = RegQueryValueExW(hkey, ValueName, NULL, &type, (LPBYTE) buffer, &size);
2948 if (ret == ERROR_MORE_DATA) {
2949 TRACE("need dynamic buffer: %u\n", size);
2950 buffer = HeapAlloc(GetProcessHeap(), 0, size);
2951 if (!buffer) {
2952 /* No Memory is bad */
2953 return FALSE;
2954 }
2955 buffer[0] = '\0';
2956 ret = RegQueryValueExW(hkey, ValueName, NULL, &type, (LPBYTE) buffer, &size);
2957 }
2958
2959 if ((ret != ERROR_SUCCESS) || (!buffer[0])) {
2960 if (buffer != filename) HeapFree(GetProcessHeap(), 0, buffer);
2961 return FALSE;
2962 }
2963
2964 ptr = buffer;
2965 while (ptr) {
2966 /* do we have a full path ? */
2967 ret = (((buffer[0] == '\\') && (buffer[1] == '\\')) ||
2968 (buffer[0] && (buffer[1] == ':') && (buffer[2] == '\\')) );
2969
2970 if (!ret) {
2971 /* we must build the full Path */
2972 *needed += dirlen;
2973 if ((out) && (outlen > dirlen)) {
2974 if (unicode) {
2975 lstrcpyW((LPWSTR)out, driverdir);
2976 }
2977 else
2978 {
2979 WideCharToMultiByte(CP_ACP, 0, driverdir, -1, (LPSTR)out, outlen, NULL, NULL);
2980 }
2981 out += dirlen;
2982 outlen -= dirlen;
2983 }
2984 else
2985 out = NULL;
2986 }
2987
2988 /* write the filename */
2989 if (unicode) {
2990 size = (lstrlenW(ptr) + 1) * sizeof(WCHAR);
2991 if ((out) && (outlen >= size)) {
2992 lstrcpyW((LPWSTR)out, ptr);
2993 out += size;
2994 outlen -= size;
2995 }
2996 else
2997 out = NULL;
2998 }
2999 else
3000 {
3001 size = WideCharToMultiByte(CP_ACP, 0, ptr, -1, NULL, 0, NULL, NULL);
3002 if ((out) && (outlen >= size)) {
3003 WideCharToMultiByte(CP_ACP, 0, ptr, -1, (LPSTR)out, outlen, NULL, NULL);
3004 out += size;
3005 outlen -= size;
3006 }
3007 else
3008 out = NULL;
3009 }
3010 *needed += size;
3011 ptr += lstrlenW(ptr)+1;
3012 if ((type != REG_MULTI_SZ) || (!ptr[0])) ptr = NULL;
3013 }
3014
3015 if (buffer != filename) HeapFree(GetProcessHeap(), 0, buffer);
3016
3017 /* write the multisz-termination */
3018 if (type == REG_MULTI_SZ) {
3019 size = (unicode) ? sizeof(WCHAR) : 1;
3020
3021 *needed += size;
3022 if (out && (outlen >= size)) {
3023 memset (out, 0, size);
3024 }
3025 }
3026 return TRUE;
3027 }
3028
3029 /*****************************************************************************
3030 * WINSPOOL_GetStringFromReg
3031 *
3032 * Get ValueName from hkey storing result in ptr. buflen is space left in ptr
3033 * String is stored either as unicode or ascii.
3034 * Bit of a hack here to get the ValueName if we want ascii.
3035 */
3036 static BOOL WINSPOOL_GetStringFromReg(HKEY hkey, LPCWSTR ValueName, LPBYTE ptr,
3037 DWORD buflen, DWORD *needed,
3038 BOOL unicode)
3039 {
3040 DWORD sz = buflen, type;
3041 LONG ret;
3042
3043 if(unicode)
3044 ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
3045 else {
3046 LPSTR ValueNameA = strdupWtoA(ValueName);
3047 ret = RegQueryValueExA(hkey, ValueNameA, 0, &type, ptr, &sz);
3048 HeapFree(GetProcessHeap(),0,ValueNameA);
3049 }
3050 if(ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
3051 WARN("Got ret = %d\n", ret);
3052 *needed = 0;
3053 return FALSE;
3054 }
3055 /* add space for terminating '\0' */
3056 sz += unicode ? sizeof(WCHAR) : 1;
3057 *needed = sz;
3058
3059 if (ptr)
3060 TRACE("%s: %s\n", debugstr_w(ValueName), unicode ? debugstr_w((LPCWSTR)ptr) : debugstr_a((LPCSTR)ptr));
3061
3062 return TRUE;
3063 }
3064
3065 /*****************************************************************************
3066 * WINSPOOL_GetDefaultDevMode
3067 *
3068 * Get a default DevMode values for wineps.
3069 * FIXME - use ppd.
3070 */
3071
3072 static void WINSPOOL_GetDefaultDevMode(
3073 LPBYTE ptr,
3074 DWORD buflen, DWORD *needed,
3075 BOOL unicode)
3076 {
3077 DEVMODEA dm;
3078 static const char szwps[] = "wineps.drv";
3079
3080 /* fill default DEVMODE - should be read from ppd... */
3081 ZeroMemory( &dm, sizeof(dm) );
3082 memcpy(dm.dmDeviceName,szwps,sizeof szwps);
3083 dm.dmSpecVersion = DM_SPECVERSION;
3084 dm.dmDriverVersion = 1;
3085 dm.dmSize = sizeof(DEVMODEA);
3086 dm.dmDriverExtra = 0;
3087 dm.dmFields =
3088 DM_ORIENTATION | DM_PAPERSIZE |
3089 DM_PAPERLENGTH | DM_PAPERWIDTH |
3090 DM_SCALE |
3091 DM_COPIES |
3092 DM_DEFAULTSOURCE | DM_PRINTQUALITY |
3093 DM_YRESOLUTION | DM_TTOPTION;
3094
3095 dm.u1.s1.dmOrientation = DMORIENT_PORTRAIT;
3096 dm.u1.s1.dmPaperSize = DMPAPER_A4;
3097 dm.u1.s1.dmPaperLength = 2970;
3098 dm.u1.s1.dmPaperWidth = 2100;
3099
3100 dm.u1.s1.dmScale = 100;
3101 dm.u1.s1.dmCopies = 1;
3102 dm.u1.s1.dmDefaultSource = DMBIN_AUTO;
3103 dm.u1.s1.dmPrintQuality = DMRES_MEDIUM;
3104 /* dm.dmColor */
3105 /* dm.dmDuplex */
3106 dm.dmYResolution = 300; /* 300dpi */
3107 dm.dmTTOption = DMTT_BITMAP;
3108 /* dm.dmCollate */
3109 /* dm.dmFormName */
3110 /* dm.dmLogPixels */
3111 /* dm.dmBitsPerPel */
3112 /* dm.dmPelsWidth */
3113 /* dm.dmPelsHeight */
3114 /* dm.u2.dmDisplayFlags */
3115 /* dm.dmDisplayFrequency */
3116 /* dm.dmICMMethod */
3117 /* dm.dmICMIntent */
3118 /* dm.dmMediaType */
3119 /* dm.dmDitherType */
3120 /* dm.dmReserved1 */
3121 /* dm.dmReserved2 */
3122 /* dm.dmPanningWidth */
3123 /* dm.dmPanningHeight */
3124
3125 if(unicode) {
3126 if(buflen >= sizeof(DEVMODEW)) {
3127 DEVMODEW *pdmW = GdiConvertToDevmodeW(&dm);
3128 memcpy(ptr, pdmW, sizeof(DEVMODEW));
3129 HeapFree(GetProcessHeap(),0,pdmW);
3130 }
3131 *needed = sizeof(DEVMODEW);
3132 }
3133 else
3134 {
3135 if(buflen >= sizeof(DEVMODEA)) {
3136 memcpy(ptr, &dm, sizeof(DEVMODEA));
3137 }
3138 *needed = sizeof(DEVMODEA);
3139 }
3140 }
3141
3142 /*****************************************************************************
3143 * WINSPOOL_GetDevModeFromReg
3144 *
3145 * Get ValueName from hkey storing result in ptr. buflen is space left in ptr
3146 * DevMode is stored either as unicode or ascii.
3147 */
3148 static BOOL WINSPOOL_GetDevModeFromReg(HKEY hkey, LPCWSTR ValueName,
3149 LPBYTE ptr,
3150 DWORD buflen, DWORD *needed,
3151 BOOL unicode)
3152 {
3153 DWORD sz = buflen, type;
3154 LONG ret;
3155
3156 if (ptr && buflen>=sizeof(DEVMODEA)) memset(ptr, 0, sizeof(DEVMODEA));
3157 ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
3158 if ((ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)) sz = 0;
3159 if (sz < sizeof(DEVMODEA))
3160 {
3161 TRACE("corrupted registry for %s ( size %d)\n",debugstr_w(ValueName),sz);
3162 return FALSE;
3163 }
3164 /* ensures that dmSize is not erratically bogus if registry is invalid */
3165 if (ptr && ((DEVMODEA*)ptr)->dmSize < sizeof(DEVMODEA))
3166 ((DEVMODEA*)ptr)->dmSize = sizeof(DEVMODEA);
3167 if(unicode) {
3168 sz += (CCHDEVICENAME + CCHFORMNAME);
3169 if(buflen >= sz) {
3170 DEVMODEW *dmW = GdiConvertToDevmodeW((DEVMODEA*)ptr);
3171 memcpy(ptr, dmW, sz);
3172 HeapFree(GetProcessHeap(),0,dmW);
3173 }
3174 }
3175 *needed = sz;
3176 return TRUE;
3177 }
3178
3179 /*********************************************************************
3180 * WINSPOOL_GetPrinter_1
3181 *
3182 * Fills out a PRINTER_INFO_1A|W struct storing the strings in buf.
3183 * The strings are either stored as unicode or ascii.
3184 */
3185 static BOOL WINSPOOL_GetPrinter_1(HKEY hkeyPrinter, PRINTER_INFO_1W *pi1,
3186 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3187 BOOL unicode)
3188 {
3189 DWORD size, left = cbBuf;
3190 BOOL space = (cbBuf > 0);
3191 LPBYTE ptr = buf;
3192
3193 *pcbNeeded = 0;
3194
3195 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3196 unicode)) {
3197 if(space && size <= left) {
3198 pi1->pName = (LPWSTR)ptr;
3199 ptr += size;
3200 left -= size;
3201 } else
3202 space = FALSE;
3203 *pcbNeeded += size;
3204 }
3205
3206 /* FIXME: pDescription should be something like "Name,Driver_Name,". */
3207 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3208 unicode)) {
3209 if(space && size <= left) {
3210 pi1->pDescription = (LPWSTR)ptr;
3211 ptr += size;
3212 left -= size;
3213 } else
3214 space = FALSE;
3215 *pcbNeeded += size;
3216 }
3217
3218 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DescriptionW, ptr, left, &size,
3219 unicode)) {
3220 if(space && size <= left) {
3221 pi1->pComment = (LPWSTR)ptr;
3222 ptr += size;
3223 left -= size;
3224 } else
3225 space = FALSE;
3226 *pcbNeeded += size;
3227 }
3228
3229 if(pi1) pi1->Flags = PRINTER_ENUM_ICON8; /* We're a printer */
3230
3231 if(!space && pi1) /* zero out pi1 if we can't completely fill buf */
3232 memset(pi1, 0, sizeof(*pi1));
3233
3234 return space;
3235 }
3236 /*********************************************************************
3237 * WINSPOOL_GetPrinter_2
3238 *
3239 * Fills out a PRINTER_INFO_2A|W struct storing the strings in buf.
3240 * The strings are either stored as unicode or ascii.
3241 */
3242 static BOOL WINSPOOL_GetPrinter_2(HKEY hkeyPrinter, PRINTER_INFO_2W *pi2,
3243 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3244 BOOL unicode)
3245 {
3246 DWORD size, left = cbBuf;
3247 BOOL space = (cbBuf > 0);
3248 LPBYTE ptr = buf;
3249
3250 *pcbNeeded = 0;
3251
3252 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3253 unicode)) {
3254 if(space && size <= left) {
3255 pi2->pPrinterName = (LPWSTR)ptr;
3256 ptr += size;
3257 left -= size;
3258 } else
3259 space = FALSE;
3260 *pcbNeeded += size;
3261 }
3262 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Share_NameW, ptr, left, &size,
3263 unicode)) {
3264 if(space && size <= left) {
3265 pi2->pShareName = (LPWSTR)ptr;
3266 ptr += size;
3267 left -= size;
3268 } else
3269 space = FALSE;
3270 *pcbNeeded += size;
3271 }
3272 if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
3273 unicode)) {
3274 if(space && size <= left) {
3275 pi2->pPortName = (LPWSTR)ptr;
3276 ptr += size;
3277 left -= size;
3278 } else
3279 space = FALSE;
3280 *pcbNeeded += size;
3281 }
3282 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Printer_DriverW, ptr, left,
3283 &size, unicode)) {
3284 if(space && size <= left) {
3285 pi2->pDriverName = (LPWSTR)ptr;
3286 ptr += size;
3287 left -= size;
3288 } else
3289 space = FALSE;
3290 *pcbNeeded += size;
3291 }
3292 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DescriptionW, ptr, left, &size,
3293 unicode)) {
3294 if(space && size <= left) {
3295 pi2->pComment = (LPWSTR)ptr;
3296 ptr += size;
3297 left -= size;
3298 } else
3299 space = FALSE;
3300 *pcbNeeded += size;
3301 }
3302 if(WINSPOOL_GetStringFromReg(hkeyPrinter, LocationW, ptr, left, &size,
3303 unicode)) {
3304 if(space && size <= left) {
3305 pi2->pLocation = (LPWSTR)ptr;
3306 ptr += size;
3307 left -= size;
3308 } else
3309 space = FALSE;
3310 *pcbNeeded += size;
3311 }
3312 if(WINSPOOL_GetDevModeFromReg(hkeyPrinter, Default_DevModeW, ptr, left,
3313 &size, unicode)) {
3314 if(space && size <= left) {
3315 pi2->pDevMode = (LPDEVMODEW)ptr;
3316 ptr += size;
3317 left -= size;
3318 } else
3319 space = FALSE;
3320 *pcbNeeded += size;
3321 }
3322 else
3323 {
3324 WINSPOOL_GetDefaultDevMode(ptr, left, &size, unicode);
3325 if(space && size <= left) {
3326 pi2->pDevMode = (LPDEVMODEW)ptr;
3327 ptr += size;
3328 left -= size;
3329 } else
3330 space = FALSE;
3331 *pcbNeeded += size;
3332 }
3333 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Separator_FileW, ptr, left,
3334 &size, unicode)) {
3335 if(space && size <= left) {
3336 pi2->pSepFile = (LPWSTR)ptr;
3337 ptr += size;
3338 left -= size;
3339 } else
3340 space = FALSE;
3341 *pcbNeeded += size;
3342 }
3343 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Print_ProcessorW, ptr, left,
3344 &size, unicode)) {
3345 if(space && size <= left) {
3346 pi2->pPrintProcessor = (LPWSTR)ptr;
3347 ptr += size;
3348 left -= size;
3349 } else
3350 space = FALSE;
3351 *pcbNeeded += size;
3352 }
3353 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DatatypeW, ptr, left,
3354 &size, unicode)) {
3355 if(space && size <= left) {
3356 pi2->pDatatype = (LPWSTR)ptr;
3357 ptr += size;
3358 left -= size;
3359 } else
3360 space = FALSE;
3361 *pcbNeeded += size;
3362 }
3363 if(WINSPOOL_GetStringFromReg(hkeyPrinter, ParametersW, ptr, left,
3364 &size, unicode)) {
3365 if(space && size <= left) {
3366 pi2->pParameters = (LPWSTR)ptr;
3367 ptr += size;
3368 left -= size;
3369 } else
3370 space = FALSE;
3371 *pcbNeeded += size;
3372 }
3373 if(pi2) {
3374 pi2->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
3375 pi2->Priority = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Priority");
3376 pi2->DefaultPriority = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
3377 "Default Priority");
3378 pi2->StartTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "StartTime");
3379 pi2->UntilTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "UntilTime");
3380 }
3381
3382 if(!space && pi2) /* zero out pi2 if we can't completely fill buf */
3383 memset(pi2, 0, sizeof(*pi2));
3384
3385 return space;
3386 }
3387
3388 /*********************************************************************
3389 * WINSPOOL_GetPrinter_4
3390 *
3391 * Fills out a PRINTER_INFO_4 struct storing the strings in buf.
3392 */
3393 static BOOL WINSPOOL_GetPrinter_4(HKEY hkeyPrinter, PRINTER_INFO_4W *pi4,
3394 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3395 BOOL unicode)
3396 {
3397 DWORD size, left = cbBuf;
3398 BOOL space = (cbBuf > 0);
3399 LPBYTE ptr = buf;
3400
3401 *pcbNeeded = 0;
3402
3403 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3404 unicode)) {
3405 if(space && size <= left) {
3406 pi4->pPrinterName = (LPWSTR)ptr;
3407 ptr += size;
3408 left -= size;
3409 } else
3410 space = FALSE;
3411 *pcbNeeded += size;
3412 }
3413 if(pi4) {
3414 pi4->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
3415 }
3416
3417 if(!space && pi4) /* zero out pi4 if we can't completely fill buf */
3418 memset(pi4, 0, sizeof(*pi4));
3419
3420 return space;
3421 }
3422
3423 /*********************************************************************
3424 * WINSPOOL_GetPrinter_5
3425 *
3426 * Fills out a PRINTER_INFO_5 struct storing the strings in buf.
3427 */
3428 static BOOL WINSPOOL_GetPrinter_5(HKEY hkeyPrinter, PRINTER_INFO_5W *pi5,
3429 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
3430 BOOL unicode)
3431 {
3432 DWORD size, left = cbBuf;
3433 BOOL space = (cbBuf > 0);
3434 LPBYTE ptr = buf;
3435
3436 *pcbNeeded = 0;
3437
3438 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
3439 unicode)) {
3440 if(space && size <= left) {
3441 pi5->pPrinterName = (LPWSTR)ptr;
3442 ptr += size;
3443 left -= size;
3444 } else
3445 space = FALSE;
3446 *pcbNeeded += size;
3447 }
3448 if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
3449 unicode)) {
3450 if(space && size <= left) {
3451 pi5->pPortName = (LPWSTR)ptr;
3452 ptr += size;
3453 left -= size;
3454 } else
3455 space = FALSE;
3456 *pcbNeeded += size;
3457 }
3458 if(pi5) {
3459 pi5->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
3460 pi5->DeviceNotSelectedTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
3461 "dnsTimeout");
3462 pi5->TransmissionRetryTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
3463 "txTimeout");
3464 }
3465
3466 if(!space && pi5) /* zero out pi5 if we can't completely fill buf */
3467 memset(pi5, 0, sizeof(*pi5));
3468
3469 return space;
3470 }
3471
3472 /*********************************************************************
3473 * WINSPOOL_GetPrinter_7
3474 *
3475 * Fills out a PRINTER_INFO_7 struct storing the strings in buf.
3476 */
3477 static BOOL WINSPOOL_GetPrinter_7(HKEY hkeyPrinter, PRINTER_INFO_7W *pi7, LPBYTE buf,
3478 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
3479 {
3480 DWORD size, left = cbBuf;
3481 BOOL space = (cbBuf > 0);
3482 LPBYTE ptr = buf;
3483
3484 *pcbNeeded = 0;
3485
3486 if (WINSPOOL_GetStringFromReg(hkeyPrinter, ObjectGUIDW, ptr, left, &size, unicode))
3487 {
3488 if (space && size <= left) {
3489 pi7->pszObjectGUID = (LPWSTR)ptr;
3490 ptr += size;
3491 left -= size;
3492 } else
3493 space = FALSE;
3494 *pcbNeeded += size;
3495 }
3496 if (pi7) {
3497 /* We do not have a Directory Service */
3498 pi7->dwAction = DSPRINT_UNPUBLISH;
3499 }
3500
3501 if (!space && pi7) /* zero out pi7 if we can't completely fill buf */
3502 memset(pi7, 0, sizeof(*pi7));
3503
3504 return space;
3505 }
3506
3507 /*********************************************************************
3508 * WINSPOOL_GetPrinter_9
3509 *
3510 * Fills out a PRINTER_INFO_9A|W struct storing the strings in buf.
3511 * The strings are either stored as unicode or ascii.
3512 */
3513 static BOOL WINSPOOL_GetPrinter_9(HKEY hkeyPrinter, PRINTER_INFO_9W *pi9, LPBYTE buf,
3514 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
3515 {
3516 DWORD size;
3517 BOOL space = (cbBuf > 0);
3518
3519 *pcbNeeded = 0;
3520
3521 if(WINSPOOL_GetDevModeFromReg(hkeyPrinter, Default_DevModeW, buf, cbBuf, &size, unicode)) {
3522 if(space && size <= cbBuf) {
3523 pi9->pDevMode = (LPDEVMODEW)buf;
3524 } else
3525 space = FALSE;
3526 *pcbNeeded += size;
3527 }
3528 else
3529 {
3530 WINSPOOL_GetDefaultDevMode(buf, cbBuf, &size, unicode);
3531 if(space && size <= cbBuf) {
3532 pi9->pDevMode = (LPDEVMODEW)buf;
3533 } else
3534 space = FALSE;
3535 *pcbNeeded += size;
3536 }
3537
3538 if(!space && pi9) /* zero out pi9 if we can't completely fill buf */
3539 memset(pi9, 0, sizeof(*pi9));
3540
3541 return space;
3542 }
3543
3544 /*****************************************************************************
3545 * WINSPOOL_GetPrinter
3546 *
3547 * Implementation of GetPrinterA|W. Relies on PRINTER_INFO_*W being
3548 * essentially the same as PRINTER_INFO_*A. i.e. the structure itself is
3549 * just a collection of pointers to strings.
3550 */
3551 static BOOL WINSPOOL_GetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
3552 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
3553 {
3554 LPCWSTR name;
3555 DWORD size, needed = 0;
3556 LPBYTE ptr = NULL;
3557 HKEY hkeyPrinter, hkeyPrinters;
3558 BOOL ret;
3559
3560 TRACE("(%p,%d,%p,%d,%p)\n",hPrinter,Level,pPrinter,cbBuf, pcbNeeded);
3561
3562 if (!(name = get_opened_printer_name(hPrinter))) {
3563 SetLastError(ERROR_INVALID_HANDLE);
3564 return FALSE;
3565 }
3566
3567 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
3568 ERROR_SUCCESS) {
3569 ERR("Can't create Printers key\n");
3570 return FALSE;
3571 }
3572 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter) != ERROR_SUCCESS)
3573 {
3574 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
3575 RegCloseKey(hkeyPrinters);
3576 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
3577 return FALSE;
3578 }
3579
3580 switch(Level) {
3581 case 2:
3582 {
3583 PRINTER_INFO_2W *pi2 = (PRINTER_INFO_2W *)pPrinter;
3584
3585 size = sizeof(PRINTER_INFO_2W);
3586 if(size <= cbBuf) {
3587 ptr = pPrinter + size;
3588 cbBuf -= size;
3589 memset(pPrinter, 0, size);
3590 } else {
3591 pi2 = NULL;
3592 cbBuf = 0;
3593 }
3594 ret = WINSPOOL_GetPrinter_2(hkeyPrinter, pi2, ptr, cbBuf, &needed,
3595 unicode);
3596 needed += size;
3597 break;
3598 }
3599
3600 case 4:
3601 {
3602 PRINTER_INFO_4W *pi4 = (PRINTER_INFO_4W *)pPrinter;
3603
3604 size = sizeof(PRINTER_INFO_4W);
3605 if(size <= cbBuf) {
3606 ptr = pPrinter + size;
3607 cbBuf -= size;
3608 memset(pPrinter, 0, size);
3609 } else {
3610 pi4 = NULL;
3611 cbBuf = 0;
3612 }
3613 ret = WINSPOOL_GetPrinter_4(hkeyPrinter, pi4, ptr, cbBuf, &needed,
3614 unicode);
3615 needed += size;
3616 break;
3617 }
3618
3619
3620 case 5:
3621 {
3622 PRINTER_INFO_5W *pi5 = (PRINTER_INFO_5W *)pPrinter;
3623
3624 size = sizeof(PRINTER_INFO_5W);
3625 if(size <= cbBuf) {
3626 ptr = pPrinter + size;
3627 cbBuf -= size;
3628 memset(pPrinter, 0, size);
3629 } else {
3630 pi5 = NULL;
3631 cbBuf = 0;
3632 }
3633
3634 ret = WINSPOOL_GetPrinter_5(hkeyPrinter, pi5, ptr, cbBuf, &needed,
3635 unicode);
3636 needed += size;
3637 break;
3638 }
3639
3640
3641 case 6:
3642 {
3643 PRINTER_INFO_6 *pi6 = (PRINTER_INFO_6 *) pPrinter;
3644
3645 size = sizeof(PRINTER_INFO_6);
3646 if (size <= cbBuf) {
3647 /* FIXME: We do not update the status yet */
3648 pi6->dwStatus = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Status");
3649 ret = TRUE;
3650 } else {
3651 ret = FALSE;
3652 }
3653
3654 needed += size;
3655 break;
3656 }
3657
3658 case 7:
3659 {
3660 PRINTER_INFO_7W *pi7 = (PRINTER_INFO_7W *) pPrinter;
3661
3662 size = sizeof(PRINTER_INFO_7W);
3663 if (size <= cbBuf) {
3664 ptr = pPrinter + size;
3665 cbBuf -= size;
3666 memset(pPrinter, 0, size);
3667 } else {
3668 pi7 = NULL;
3669 cbBuf = 0;
3670 }
3671
3672 ret = WINSPOOL_GetPrinter_7(hkeyPrinter, pi7, ptr, cbBuf, &needed, unicode);
3673 needed += size;
3674 break;
3675 }
3676
3677
3678 case 9:
3679 {
3680 PRINTER_INFO_9W *pi9 = (PRINTER_INFO_9W *)pPrinter;
3681
3682 size = sizeof(PRINTER_INFO_9W);
3683 if(size <= cbBuf) {
3684 ptr = pPrinter + size;
3685 cbBuf -= size;
3686 memset(pPrinter, 0, size);
3687 } else {
3688 pi9 = NULL;
3689 cbBuf = 0;
3690 }
3691
3692 ret = WINSPOOL_GetPrinter_9(hkeyPrinter, pi9, ptr, cbBuf, &needed, unicode);
3693 needed += size;
3694 break;
3695 }
3696
3697
3698 default:
3699 FIXME("Unimplemented level %d\n", Level);
3700 SetLastError(ERROR_INVALID_LEVEL);
3701 RegCloseKey(hkeyPrinters);
3702 RegCloseKey(hkeyPrinter);
3703 return FALSE;
3704 }
3705
3706 RegCloseKey(hkeyPrinter);
3707 RegCloseKey(hkeyPrinters);
3708
3709 TRACE("returning %d needed = %d\n", ret, needed);
3710 if(pcbNeeded) *pcbNeeded = needed;
3711 if(!ret)
3712 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3713 return ret;
3714 }
3715
3716 /*****************************************************************************
3717 * GetPrinterW [WINSPOOL.@]
3718 */
3719 BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
3720 DWORD cbBuf, LPDWORD pcbNeeded)
3721 {
3722 return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
3723 TRUE);
3724 }
3725
3726 /*****************************************************************************
3727 * GetPrinterA [WINSPOOL.@]
3728 */
3729 BOOL WINAPI GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
3730 DWORD cbBuf, LPDWORD pcbNeeded)
3731 {
3732 return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
3733 FALSE);
3734 }
3735
3736 /*****************************************************************************
3737 * WINSPOOL_EnumPrinters
3738 *
3739 * Implementation of EnumPrintersA|W
3740 */
3741 static BOOL WINSPOOL_EnumPrinters(DWORD dwType, LPWSTR lpszName,
3742 DWORD dwLevel, LPBYTE lpbPrinters,
3743 DWORD cbBuf, LPDWORD lpdwNeeded,
3744 LPDWORD lpdwReturned, BOOL unicode)
3745
3746 {
3747 HKEY hkeyPrinters, hkeyPrinter;
3748 WCHAR PrinterName[255];
3749 DWORD needed = 0, number = 0;
3750 DWORD used, i, left;
3751 PBYTE pi, buf;
3752
3753 if(lpbPrinters)
3754 memset(lpbPrinters, 0, cbBuf);
3755 if(lpdwReturned)
3756 *lpdwReturned = 0;
3757 if(lpdwNeeded)
3758 *lpdwNeeded = 0;
3759
3760 /* PRINTER_ENUM_DEFAULT is only supported under win9x, we behave like NT */
3761 if(dwType == PRINTER_ENUM_DEFAULT)
3762 return TRUE;
3763
3764 if (dwType & PRINTER_ENUM_CONNECTIONS) {
3765 TRACE("ignoring PRINTER_ENUM_CONNECTIONS\n");
3766 dwType &= ~PRINTER_ENUM_CONNECTIONS; /* we don't handle that */
3767 if (!dwType) {
3768 FIXME("We don't handle PRINTER_ENUM_CONNECTIONS\n");
3769 *lpdwNeeded = 0;
3770 *lpdwReturned = 0;
3771 return TRUE;
3772 }
3773
3774 }
3775
3776 if (!((dwType & PRINTER_ENUM_LOCAL) || (dwType & PRINTER_ENUM_NAME))) {
3777 FIXME("dwType = %08x\n", dwType);
3778 SetLastError(ERROR_INVALID_FLAGS);
3779 return FALSE;
3780 }
3781
3782 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
3783 ERROR_SUCCESS) {
3784 ERR("Can't create Printers key\n");
3785 return FALSE;
3786 }
3787
3788 if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &number, NULL, NULL,
3789 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
3790 RegCloseKey(hkeyPrinters);
3791 ERR("Can't query Printers key\n");
3792 return FALSE;
3793 }
3794 TRACE("Found %d printers\n", number);
3795
3796 switch(dwLevel) {
3797 case 1:
3798 used = number * sizeof(PRINTER_INFO_1W);
3799 break;
3800 case 2:
3801 used = number * sizeof(PRINTER_INFO_2W);
3802 break;
3803 case 4:
3804 used = number * sizeof(PRINTER_INFO_4W);
3805 break;
3806 case 5:
3807 used = number * sizeof(PRINTER_INFO_5W);
3808 break;
3809
3810 default:
3811 SetLastError(ERROR_INVALID_LEVEL);
3812 RegCloseKey(hkeyPrinters);
3813 return FALSE;
3814 }
3815 pi = (used <= cbBuf) ? lpbPrinters : NULL;
3816
3817 for(i = 0; i < number; i++) {
3818 if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)/sizeof(PrinterName[0])) !=
3819 ERROR_SUCCESS) {
3820 ERR("Can't enum key number %d\n", i);
3821 RegCloseKey(hkeyPrinters);
3822 return FALSE;
3823 }
3824 TRACE("Printer %d is %s\n", i, debugstr_w(PrinterName));
3825 if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkeyPrinter) !=
3826 ERROR_SUCCESS) {
3827 ERR("Can't open key %s\n", debugstr_w(PrinterName));
3828 RegCloseKey(hkeyPrinters);
3829 return FALSE;
3830 }
3831
3832 if(cbBuf > used) {
3833 buf = lpbPrinters + used;
3834 left = cbBuf - used;
3835 } else {
3836 buf = NULL;
3837 left = 0;
3838 }
3839
3840 switch(dwLevel) {
3841 case 1:
3842 WINSPOOL_GetPrinter_1(hkeyPrinter, (PRINTER_INFO_1W *)pi, buf,
3843 left, &needed, unicode);
3844 used += needed;
3845 if(pi) pi += sizeof(PRINTER_INFO_1W);
3846 break;
3847 case 2:
3848 WINSPOOL_GetPrinter_2(hkeyPrinter, (PRINTER_INFO_2W *)pi, buf,
3849 left, &needed, unicode);
3850 used += needed;
3851 if(pi) pi += sizeof(PRINTER_INFO_2W);
3852 break;
3853 case 4:
3854 WINSPOOL_GetPrinter_4(hkeyPrinter, (PRINTER_INFO_4W *)pi, buf,
3855 left, &needed, unicode);
3856 used += needed;
3857 if(pi) pi += sizeof(PRINTER_INFO_4W);
3858 break;
3859 case 5:
3860 WINSPOOL_GetPrinter_5(hkeyPrinter, (PRINTER_INFO_5W *)pi, buf,
3861 left, &needed, unicode);
3862 used += needed;
3863 if(pi) pi += sizeof(PRINTER_INFO_5W);
3864 break;
3865 default:
3866 ERR("Shouldn't be here!\n");
3867 RegCloseKey(hkeyPrinter);
3868 RegCloseKey(hkeyPrinters);
3869 return FALSE;
3870 }
3871 RegCloseKey(hkeyPrinter);
3872 }
3873 RegCloseKey(hkeyPrinters);
3874
3875 if(lpdwNeeded)
3876 *lpdwNeeded = used;
3877
3878 if(used > cbBuf) {
3879 if(lpbPrinters)
3880 memset(lpbPrinters, 0, cbBuf);
3881 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3882 return FALSE;
3883 }
3884 if(lpdwReturned)
3885 *lpdwReturned = number;
3886 SetLastError(ERROR_SUCCESS);
3887 return TRUE;
3888 }
3889
3890
3891 /******************************************************************
3892 * EnumPrintersW [WINSPOOL.@]
3893 *
3894 * Enumerates the available printers, print servers and print
3895 * providers, depending on the specified flags, name and level.
3896 *
3897 * RETURNS:
3898 *
3899 * If level is set to 1:
3900 * Returns an array of PRINTER_INFO_1 data structures in the
3901 * lpbPrinters buffer.
3902 *
3903 * If level is set to 2:
3904 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
3905 * Returns an array of PRINTER_INFO_2 data structures in the
3906 * lpbPrinters buffer. Note that according to MSDN also an
3907 * OpenPrinter should be performed on every remote printer.
3908 *
3909 * If level is set to 4 (officially WinNT only):
3910 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
3911 * Fast: Only the registry is queried to retrieve printer names,
3912 * no connection to the driver is made.
3913 * Returns an array of PRINTER_INFO_4 data structures in the
3914 * lpbPrinters buffer.
3915 *
3916 * If level is set to 5 (officially WinNT4/Win9x only):
3917 * Fast: Only the registry is queried to retrieve printer names,
3918 * no connection to the driver is made.
3919 * Returns an array of PRINTER_INFO_5 data structures in the
3920 * lpbPrinters buffer.
3921 *
3922 * If level set to 3 or 6+:
3923 * returns zero (failure!)
3924 *
3925 * Returns nonzero (TRUE) on success, or zero on failure, use GetLastError
3926 * for information.
3927 *
3928 * BUGS:
3929 * - Only PRINTER_ENUM_LOCAL and PRINTER_ENUM_NAME are implemented.
3930 * - Only levels 2, 4 and 5 are implemented at the moment.
3931 * - 16-bit printer drivers are not enumerated.
3932 * - Returned amount of bytes used/needed does not match the real Windoze
3933 * implementation (as in this implementation, all strings are part
3934 * of the buffer, whereas Win32 keeps them somewhere else)
3935 * - At level 2, EnumPrinters should also call OpenPrinter for remote printers.
3936 *
3937 * NOTE:
3938 * - In a regular Wine installation, no registry settings for printers
3939 * exist, which makes this function return an empty list.
3940 */
3941 BOOL WINAPI EnumPrintersW(
3942 DWORD dwType, /* [in] Types of print objects to enumerate */
3943 LPWSTR lpszName, /* [in] name of objects to enumerate */
3944 DWORD dwLevel, /* [in] type of printer info structure */
3945 LPBYTE lpbPrinters, /* [out] buffer which receives info */
3946 DWORD cbBuf, /* [in] max size of buffer in bytes */
3947 LPDWORD lpdwNeeded, /* [out] pointer to var: # bytes used/needed */
3948 LPDWORD lpdwReturned /* [out] number of entries returned */
3949 )
3950 {
3951 return WINSPOOL_EnumPrinters(dwType, lpszName, dwLevel, lpbPrinters, cbBuf,
3952 lpdwNeeded, lpdwReturned, TRUE);
3953 }
3954
3955 /******************************************************************
3956 * EnumPrintersA [WINSPOOL.@]
3957 *
3958 * See EnumPrintersW
3959 *
3960 */
3961 BOOL WINAPI EnumPrintersA(DWORD flags, LPSTR pName, DWORD level, LPBYTE pPrinters,
3962 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
3963 {
3964 BOOL ret;
3965 UNICODE_STRING pNameU;
3966 LPWSTR pNameW;
3967 LPBYTE pPrintersW;
3968
3969 TRACE("(0x%x, %s, %u, %p, %d, %p, %p)\n", flags, debugstr_a(pName), level,
3970 pPrinters, cbBuf, pcbNeeded, pcReturned);
3971
3972 pNameW = asciitounicode(&pNameU, pName);
3973
3974 /* Request a buffer with a size, that is big enough for EnumPrintersW.
3975 MS Office need this */
3976 pPrintersW = (pPrinters && cbBuf) ? HeapAlloc(GetProcessHeap(), 0, cbBuf) : NULL;
3977
3978 ret = EnumPrintersW(flags, pNameW, level, pPrintersW, cbBuf, pcbNeeded, pcReturned);
3979
3980 RtlFreeUnicodeString(&pNameU);
3981 if (ret) {
3982 convert_printerinfo_W_to_A(pPrinters, pPrintersW, level, *pcbNeeded, *pcReturned);
3983 }
3984 HeapFree(GetProcessHeap(), 0, pPrintersW);
3985 return ret;
3986 }
3987
3988 /*****************************************************************************
3989 * WINSPOOL_GetDriverInfoFromReg [internal]
3990 *
3991 * Enters the information from the registry into the DRIVER_INFO struct
3992 *
3993 * RETURNS
3994 * zero if the printer driver does not exist in the registry
3995 * (only if Level > 1) otherwise nonzero
3996 */
3997 static BOOL WINSPOOL_GetDriverInfoFromReg(
3998 HKEY hkeyDrivers,
3999 LPWSTR DriverName,
4000 const printenv_t * env,
4001 DWORD Level,
4002 LPBYTE ptr, /* DRIVER_INFO */
4003 LPBYTE pDriverStrings, /* strings buffer */
4004 DWORD cbBuf, /* size of string buffer */
4005 LPDWORD pcbNeeded, /* space needed for str. */
4006 BOOL unicode) /* type of strings */
4007 {
4008 DWORD size, tmp;
4009 HKEY hkeyDriver;
4010 WCHAR driverdir[MAX_PATH];
4011 DWORD dirlen;
4012 LPBYTE strPtr = pDriverStrings;
4013 LPDRIVER_INFO_8W di = (LPDRIVER_INFO_8W) ptr;
4014
4015 TRACE("(%p, %s, %p, %d, %p, %p, %d, %d)\n", hkeyDrivers,
4016 debugstr_w(DriverName), env,
4017 Level, di, pDriverStrings, cbBuf, unicode);
4018
4019 if (di) ZeroMemory(di, di_sizeof[Level]);
4020
4021 if (unicode) {
4022 *pcbNeeded = (lstrlenW(DriverName) + 1) * sizeof(WCHAR);
4023 if (*pcbNeeded <= cbBuf)
4024 strcpyW((LPWSTR)strPtr, DriverName);
4025 }
4026 else
4027 {
4028 *pcbNeeded = WideCharToMultiByte(CP_ACP, 0, DriverName, -1, NULL, 0, NULL, NULL);
4029 if (*pcbNeeded <= cbBuf)
4030 WideCharToMultiByte(CP_ACP, 0, DriverName, -1, (LPSTR)strPtr, *pcbNeeded, NULL, NULL);
4031 }
4032
4033 /* pName for level 1 has a different offset! */
4034 if (Level == 1) {
4035 if (di) ((LPDRIVER_INFO_1W) di)->pName = (LPWSTR) strPtr;
4036 return TRUE;
4037 }
4038
4039 /* .cVersion and .pName for level > 1 */
4040 if (di) {
4041 di->cVersion = env->driverversion;
4042 di->pName = (LPWSTR) strPtr;
4043 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
4044 }
4045
4046 /* Reserve Space for the largest subdir and a Backslash*/
4047 size = sizeof(driverdir) - sizeof(Version3_SubdirW) - sizeof(WCHAR);
4048 if (!GetPrinterDriverDirectoryW(NULL, (LPWSTR) env->envname, 1, (LPBYTE) driverdir, size, &size)) {
4049 /* Should never Fail */
4050 return FALSE;
4051 }
4052 lstrcatW(driverdir, env->versionsubdir);
4053 lstrcatW(driverdir, backslashW);
4054
4055 /* dirlen must not include the terminating zero */
4056 dirlen = (unicode) ? lstrlenW(driverdir) * sizeof(WCHAR) :
4057 WideCharToMultiByte(CP_ACP, 0, driverdir, -1, NULL, 0, NULL, NULL) -1;
4058
4059 if (!DriverName[0] || RegOpenKeyW(hkeyDrivers, DriverName, &hkeyDriver) != ERROR_SUCCESS) {
4060 ERR("Can't find driver %s in registry\n", debugstr_w(DriverName));
4061 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER); /* ? */
4062 return FALSE;
4063 }
4064
4065 /* pEnvironment */
4066 if (unicode)
4067 size = (lstrlenW(env->envname) + 1) * sizeof(WCHAR);
4068 else
4069 size = WideCharToMultiByte(CP_ACP, 0, env->envname, -1, NULL, 0, NULL, NULL);
4070
4071 *pcbNeeded += size;
4072 if (*pcbNeeded <= cbBuf) {
4073 if (unicode) {
4074 lstrcpyW((LPWSTR)strPtr, env->envname);
4075 }
4076 else
4077 {
4078 WideCharToMultiByte(CP_ACP, 0, env->envname, -1, (LPSTR)strPtr, size, NULL, NULL);
4079 }
4080 if (di) di->pEnvironment = (LPWSTR)strPtr;
4081 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
4082 }
4083
4084 /* .pDriverPath is the Graphics rendering engine.
4085 The full Path is required to avoid a crash in some apps */
4086 if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, DriverW, strPtr, 0, &size, unicode)) {
4087 *pcbNeeded += size;
4088 if (*pcbNeeded <= cbBuf)
4089 get_filename_from_reg(hkeyDriver, driverdir, dirlen, DriverW, strPtr, size, &tmp, unicode);
4090
4091 if (di) di->pDriverPath = (LPWSTR)strPtr;
4092 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
4093 }
4094
4095 /* .pDataFile: For postscript-drivers, this is the ppd-file */
4096 if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Data_FileW, strPtr, 0, &size, unicode)) {
4097 *pcbNeeded += size;
4098 if (*pcbNeeded <= cbBuf)
4099 get_filename_from_reg(hkeyDriver, driverdir, dirlen, Data_FileW, strPtr, size, &size, unicode);
4100
4101 if (di) di->pDataFile = (LPWSTR)strPtr;
4102 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4103 }
4104
4105 /* .pConfigFile is the Driver user Interface */
4106 if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Configuration_FileW, strPtr, 0, &size, unicode)) {
4107 *pcbNeeded += size;
4108 if (*pcbNeeded <= cbBuf)
4109 get_filename_from_reg(hkeyDriver, driverdir, dirlen, Configuration_FileW, strPtr, size, &size, unicode);
4110
4111 if (di) di->pConfigFile = (LPWSTR)strPtr;
4112 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4113 }
4114
4115 if (Level == 2 ) {
4116 RegCloseKey(hkeyDriver);
4117 TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4118 return TRUE;
4119 }
4120
4121 if (Level == 5 ) {
4122 RegCloseKey(hkeyDriver);
4123 FIXME("level 5: incomplete\n");
4124 return TRUE;
4125 }
4126
4127 /* .pHelpFile */
4128 if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Help_FileW, strPtr, 0, &size, unicode)) {
4129 *pcbNeeded += size;
4130 if (*pcbNeeded <= cbBuf)
4131 get_filename_from_reg(hkeyDriver, driverdir, dirlen, Help_FileW, strPtr, size, &size, unicode);
4132
4133 if (di) di->pHelpFile = (LPWSTR)strPtr;
4134 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4135 }
4136
4137 /* .pDependentFiles */
4138 if (get_filename_from_reg(hkeyDriver, driverdir, dirlen, Dependent_FilesW, strPtr, 0, &size, unicode)) {
4139 *pcbNeeded += size;
4140 if (*pcbNeeded <= cbBuf)
4141 get_filename_from_reg(hkeyDriver, driverdir, dirlen, Dependent_FilesW, strPtr, size, &size, unicode);
4142
4143 if (di) di->pDependentFiles = (LPWSTR)strPtr;
4144 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4145 }
4146 else if (GetVersion() & 0x80000000) {
4147 /* PowerPoint XP expects that pDependentFiles is always valid on win9x */
4148 size = 2 * ((unicode) ? sizeof(WCHAR) : 1);
4149 *pcbNeeded += size;
4150 if ((*pcbNeeded <= cbBuf) && strPtr) ZeroMemory(strPtr, size);
4151
4152 if (di) di->pDependentFiles = (LPWSTR)strPtr;
4153 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4154 }
4155
4156 /* .pMonitorName is the optional Language Monitor */
4157 if (WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr, 0, &size, unicode)) {
4158 *pcbNeeded += size;
4159 if (*pcbNeeded <= cbBuf)
4160 WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr, size, &size, unicode);
4161
4162 if (di) di->pMonitorName = (LPWSTR)strPtr;
4163 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4164 }
4165
4166 /* .pDefaultDataType */
4167 if (WINSPOOL_GetStringFromReg(hkeyDriver, DatatypeW, strPtr, 0, &size, unicode)) {
4168 *pcbNeeded += size;
4169 if(*pcbNeeded <= cbBuf)
4170 WINSPOOL_GetStringFromReg(hkeyDriver, DatatypeW, strPtr, size, &size, unicode);
4171
4172 if (di) di->pDefaultDataType = (LPWSTR)strPtr;
4173 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4174 }
4175
4176 if (Level == 3 ) {
4177 RegCloseKey(hkeyDriver);
4178 TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4179 return TRUE;
4180 }
4181
4182 /* .pszzPreviousNames */
4183 if (WINSPOOL_GetStringFromReg(hkeyDriver, Previous_NamesW, strPtr, 0, &size, unicode)) {
4184 *pcbNeeded += size;
4185 if(*pcbNeeded <= cbBuf)
4186 WINSPOOL_GetStringFromReg(hkeyDriver, Previous_NamesW, strPtr, size, &size, unicode);
4187
4188 if (di) di->pszzPreviousNames = (LPWSTR)strPtr;
4189 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4190 }
4191
4192 if (Level == 4 ) {
4193 RegCloseKey(hkeyDriver);
4194 TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4195 return TRUE;
4196 }
4197
4198 /* support is missing, but not important enough for a FIXME */
4199 TRACE("%s: DriverDate + DriverVersion not supported\n", debugstr_w(DriverName));
4200
4201 /* .pszMfgName */
4202 if (WINSPOOL_GetStringFromReg(hkeyDriver, ManufacturerW, strPtr, 0, &size, unicode)) {
4203 *pcbNeeded += size;
4204 if(*pcbNeeded <= cbBuf)
4205 WINSPOOL_GetStringFromReg(hkeyDriver, ManufacturerW, strPtr, size, &size, unicode);
4206
4207 if (di) di->pszMfgName = (LPWSTR)strPtr;
4208 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4209 }
4210
4211 /* .pszOEMUrl */
4212 if (WINSPOOL_GetStringFromReg(hkeyDriver, OEM_UrlW, strPtr, 0, &size, unicode)) {
4213 *pcbNeeded += size;
4214 if(*pcbNeeded <= cbBuf)
4215 WINSPOOL_GetStringFromReg(hkeyDriver, OEM_UrlW, strPtr, size, &size, unicode);
4216
4217 if (di) di->pszOEMUrl = (LPWSTR)strPtr;
4218 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4219 }
4220
4221 /* .pszHardwareID */
4222 if (WINSPOOL_GetStringFromReg(hkeyDriver, HardwareIDW, strPtr, 0, &size, unicode)) {
4223 *pcbNeeded += size;
4224 if(*pcbNeeded <= cbBuf)
4225 WINSPOOL_GetStringFromReg(hkeyDriver, HardwareIDW, strPtr, size, &size, unicode);
4226
4227 if (di) di->pszHardwareID = (LPWSTR)strPtr;
4228 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4229 }
4230
4231 /* .pszProvider */
4232 if (WINSPOOL_GetStringFromReg(hkeyDriver, ProviderW, strPtr, 0, &size, unicode)) {
4233 *pcbNeeded += size;
4234 if(*pcbNeeded <= cbBuf)
4235 WINSPOOL_GetStringFromReg(hkeyDriver, ProviderW, strPtr, size, &size, unicode);
4236
4237 if (di) di->pszProvider = (LPWSTR)strPtr;
4238 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
4239 }
4240
4241 if (Level == 6 ) {
4242 RegCloseKey(hkeyDriver);
4243 return TRUE;
4244 }
4245
4246 /* support is missing, but not important enough for a FIXME */
4247 TRACE("level 8: incomplete\n");
4248
4249 TRACE("buffer space %d required %d\n", cbBuf, *pcbNeeded);
4250 RegCloseKey(hkeyDriver);
4251 return TRUE;
4252 }
4253
4254 /*****************************************************************************
4255 * WINSPOOL_GetPrinterDriver
4256 */
4257 static BOOL WINSPOOL_GetPrinterDriver(HANDLE hPrinter, LPCWSTR pEnvironment,
4258 DWORD Level, LPBYTE pDriverInfo,
4259 DWORD cbBuf, LPDWORD pcbNeeded,
4260 BOOL unicode)
4261 {
4262 LPCWSTR name;
4263 WCHAR DriverName[100];
4264 DWORD ret, type, size, needed = 0;
4265 LPBYTE ptr = NULL;
4266 HKEY hkeyPrinter, hkeyPrinters, hkeyDrivers;
4267 const printenv_t * env;
4268
4269 TRACE("(%p,%s,%d,%p,%d,%p)\n",hPrinter,debugstr_w(pEnvironment),
4270 Level,pDriverInfo,cbBuf, pcbNeeded);
4271
4272
4273 if (!(name = get_opened_printer_name(hPrinter))) {
4274 SetLastError(ERROR_INVALID_HANDLE);
4275 return FALSE;
4276 }
4277
4278 if (Level < 1 || Level == 7 || Level > 8) {
4279 SetLastError(ERROR_INVALID_LEVEL);
4280 return FALSE;
4281 }
4282
4283 env = validate_envW(pEnvironment);
4284 if (!env) return FALSE; /* SetLastError() is in validate_envW */
4285
4286 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
4287 ERROR_SUCCESS) {
4288 ERR("Can't create Printers key\n");
4289 return FALSE;
4290 }
4291 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter)
4292 != ERROR_SUCCESS) {
4293 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
4294 RegCloseKey(hkeyPrinters);
4295 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
4296 return FALSE;
4297 }
4298 size = sizeof(DriverName);
4299 DriverName[0] = 0;
4300 ret = RegQueryValueExW(hkeyPrinter, Printer_DriverW, 0, &type,
4301 (LPBYTE)DriverName, &size);
4302 RegCloseKey(hkeyPrinter);
4303 RegCloseKey(hkeyPrinters);
4304 if(ret != ERROR_SUCCESS) {
4305 ERR("Can't get DriverName for printer %s\n", debugstr_w(name));
4306 return FALSE;
4307 }
4308
4309 hkeyDrivers = WINSPOOL_OpenDriverReg( pEnvironment, TRUE);
4310 if(!hkeyDrivers) {
4311 ERR("Can't create Drivers key\n");
4312 return FALSE;
4313 }
4314
4315 size = di_sizeof[Level];
4316 if ((size <= cbBuf) && pDriverInfo)
4317 ptr = pDriverInfo + size;
4318
4319 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverName,
4320 env, Level, pDriverInfo, ptr,
4321 (cbBuf < size) ? 0 : cbBuf - size,
4322 &needed, unicode)) {
4323 RegCloseKey(hkeyDrivers);
4324 return FALSE;
4325 }
4326
4327 RegCloseKey(hkeyDrivers);
4328
4329 if(pcbNeeded) *pcbNeeded = size + needed;
4330 TRACE("buffer space %d required %d\n", cbBuf, size + needed);
4331 if(cbBuf >= needed) return TRUE;
4332 SetLastError(ERROR_INSUFFICIENT_BUFFER);
4333 return FALSE;
4334 }
4335
4336 /*****************************************************************************
4337 * GetPrinterDriverA [WINSPOOL.@]
4338 */
4339 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
4340 DWORD Level, LPBYTE pDriverInfo,
4341 DWORD cbBuf, LPDWORD pcbNeeded)
4342 {
4343 BOOL ret;
4344 UNICODE_STRING pEnvW;
4345 PWSTR pwstrEnvW;
4346
4347 pwstrEnvW = asciitounicode(&pEnvW, pEnvironment);
4348 ret = WINSPOOL_GetPrinterDriver(hPrinter, pwstrEnvW, Level, pDriverInfo,
4349 cbBuf, pcbNeeded, FALSE);
4350 RtlFreeUnicodeString(&pEnvW);
4351 return ret;
4352 }
4353 /*****************************************************************************
4354 * GetPrinterDriverW [WINSPOOL.@]
4355 */
4356 BOOL WINAPI GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment,
4357 DWORD Level, LPBYTE pDriverInfo,
4358 DWORD cbBuf, LPDWORD pcbNeeded)
4359 {
4360 return WINSPOOL_GetPrinterDriver(hPrinter, pEnvironment, Level,
4361 pDriverInfo, cbBuf, pcbNeeded, TRUE);
4362 }
4363
4364 /*****************************************************************************
4365 * GetPrinterDriverDirectoryW [WINSPOOL.@]
4366 *
4367 * Return the PATH for the Printer-Drivers (UNICODE)
4368 *
4369 * PARAMS
4370 * pName [I] Servername (NT only) or NULL (local Computer)
4371 * pEnvironment [I] Printing-Environment (see below) or NULL (Default)
4372 * Level [I] Structure-Level (must be 1)
4373 * pDriverDirectory [O] PTR to Buffer that receives the Result
4374 * cbBuf [I] Size of Buffer at pDriverDirectory
4375 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used /
4376 * required for pDriverDirectory
4377 *
4378 * RETURNS
4379 * Success: TRUE and in pcbNeeded the Bytes used in pDriverDirectory
4380 * Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
4381 * if cbBuf is too small
4382 *
4383 * Native Values returned in pDriverDirectory on Success:
4384 *| NT(Windows NT x86): "%winsysdir%\\spool\\DRIVERS\\w32x86"
4385 *| NT(Windows 4.0): "%winsysdir%\\spool\\DRIVERS\\win40"
4386 *| win9x(Windows 4.0): "%winsysdir%"
4387 *
4388 * "%winsysdir%" is the Value from GetSystemDirectoryW()
4389 *
4390 * FIXME
4391 *- Only NULL or "" is supported for pName
4392 *
4393 */
4394 BOOL WINAPI GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment,
4395 DWORD Level, LPBYTE pDriverDirectory,
4396 DWORD cbBuf, LPDWORD pcbNeeded)
4397 {
4398 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName),
4399 debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
4400
4401 if ((backend == NULL) && !load_backend()) return FALSE;
4402
4403 if (Level != 1) {
4404 /* (Level != 1) is ignored in win9x */
4405 SetLastError(ERROR_INVALID_LEVEL);
4406 return FALSE;
4407 }
4408 if (pcbNeeded == NULL) {
4409 /* (pcbNeeded == NULL) is ignored in win9x */
4410 SetLastError(RPC_X_NULL_REF_POINTER);
4411 return FALSE;
4412 }
4413
4414 return backend->fpGetPrinterDriverDirectory(pName, pEnvironment, Level,
4415 pDriverDirectory, cbBuf, pcbNeeded);
4416
4417 }
4418
4419
4420 /*****************************************************************************
4421 * GetPrinterDriverDirectoryA [WINSPOOL.@]
4422 *
4423 * Return the PATH for the Printer-Drivers (ANSI)
4424 *
4425 * See GetPrinterDriverDirectoryW.
4426 *
4427 * NOTES
4428 * On NT, pDriverDirectory need the same Size as the Unicode-Version
4429 *
4430 */
4431 BOOL WINAPI GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment,
4432 DWORD Level, LPBYTE pDriverDirectory,
4433 DWORD cbBuf, LPDWORD pcbNeeded)
4434 {
4435 UNICODE_STRING nameW, environmentW;
4436 BOOL ret;
4437 DWORD pcbNeededW;
4438 INT len = cbBuf * sizeof(WCHAR)/sizeof(CHAR);
4439 WCHAR *driverDirectoryW = NULL;
4440
4441 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_a(pName),
4442 debugstr_a(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
4443
4444 if (len) driverDirectoryW = HeapAlloc( GetProcessHeap(), 0, len );
4445
4446 if(pName) RtlCreateUnicodeStringFromAsciiz(&nameW, pName);
4447 else nameW.Buffer = NULL;
4448 if(pEnvironment) RtlCreateUnicodeStringFromAsciiz(&environmentW, pEnvironment);
4449 else environmentW.Buffer = NULL;
4450
4451 ret = GetPrinterDriverDirectoryW( nameW.Buffer, environmentW.Buffer, Level,
4452 (LPBYTE)driverDirectoryW, len, &pcbNeededW );
4453 if (ret) {
4454 DWORD needed;
4455 needed = WideCharToMultiByte( CP_ACP, 0, driverDirectoryW, -1,
4456 (LPSTR)pDriverDirectory, cbBuf, NULL, NULL);
4457 if(pcbNeeded)
4458 *pcbNeeded = needed;
4459 ret = (needed <= cbBuf) ? TRUE : FALSE;
4460 } else
4461 if(pcbNeeded) *pcbNeeded = pcbNeededW * sizeof(CHAR)/sizeof(WCHAR);
4462
4463 TRACE("required: 0x%x/%d\n", pcbNeeded ? *pcbNeeded : 0, pcbNeeded ? *pcbNeeded : 0);
4464
4465 HeapFree( GetProcessHeap(), 0, driverDirectoryW );
4466 RtlFreeUnicodeString(&environmentW);
4467 RtlFreeUnicodeString(&nameW);
4468
4469 return ret;
4470 }
4471
4472 /*****************************************************************************
4473 * AddPrinterDriverA [WINSPOOL.@]
4474 *
4475 * See AddPrinterDriverW.
4476 *
4477 */
4478 BOOL WINAPI AddPrinterDriverA(LPSTR pName, DWORD level, LPBYTE pDriverInfo)
4479 {
4480 TRACE("(%s, %d, %p)\n", debugstr_a(pName), level, pDriverInfo);
4481 return AddPrinterDriverExA(pName, level, pDriverInfo, APD_COPY_NEW_FILES);
4482 }
4483
4484 /******************************************************************************
4485 * AddPrinterDriverW (WINSPOOL.@)
4486 *
4487 * Install a Printer Driver
4488 *
4489 * PARAMS
4490 * pName [I] Servername or NULL (local Computer)
4491 * level [I] Level for the supplied DRIVER_INFO_*W struct
4492 * pDriverInfo [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
4493 *
4494 * RESULTS
4495 * Success: TRUE
4496 * Failure: FALSE
4497 *
4498 */
4499 BOOL WINAPI AddPrinterDriverW(LPWSTR pName, DWORD level, LPBYTE pDriverInfo)
4500 {
4501 TRACE("(%s, %d, %p)\n", debugstr_w(pName), level, pDriverInfo);
4502 return AddPrinterDriverExW(pName, level, pDriverInfo, APD_COPY_NEW_FILES);
4503 }
4504
4505 /*****************************************************************************
4506 * AddPrintProcessorA [WINSPOOL.@]
4507 */
4508 BOOL WINAPI AddPrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPathName,
4509 LPSTR pPrintProcessorName)
4510 {
4511 FIXME("(%s,%s,%s,%s): stub\n", debugstr_a(pName), debugstr_a(pEnvironment),
4512 debugstr_a(pPathName), debugstr_a(pPrintProcessorName));
4513 return FALSE;
4514 }
4515
4516 /*****************************************************************************
4517 * AddPrintProcessorW [WINSPOOL.@]
4518 */
4519 BOOL WINAPI AddPrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPathName,
4520 LPWSTR pPrintProcessorName)
4521 {
4522 FIXME("(%s,%s,%s,%s): stub\n", debugstr_w(pName), debugstr_w(pEnvironment),
4523 debugstr_w(pPathName), debugstr_w(pPrintProcessorName));
4524 return FALSE;
4525 }
4526
4527 /*****************************************************************************
4528 * AddPrintProvidorA [WINSPOOL.@]
4529 */
4530 BOOL WINAPI AddPrintProvidorA(LPSTR pName, DWORD Level, LPBYTE pProviderInfo)
4531 {
4532 FIXME("(%s,0x%08x,%p): stub\n", debugstr_a(pName), Level, pProviderInfo);
4533 return FALSE;
4534 }
4535
4536 /*****************************************************************************
4537 * AddPrintProvidorW [WINSPOOL.@]
4538 */
4539 BOOL WINAPI AddPrintProvidorW(LPWSTR pName, DWORD Level, LPBYTE pProviderInfo)
4540 {
4541 FIXME("(%s,0x%08x,%p): stub\n", debugstr_w(pName), Level, pProviderInfo);
4542 return FALSE;
4543 }
4544
4545 /*****************************************************************************
4546 * AdvancedDocumentPropertiesA [WINSPOOL.@]
4547 */
4548 LONG WINAPI AdvancedDocumentPropertiesA(HWND hWnd, HANDLE hPrinter, LPSTR pDeviceName,
4549 PDEVMODEA pDevModeOutput, PDEVMODEA pDevModeInput)
4550 {
4551 FIXME("(%p,%p,%s,%p,%p): stub\n", hWnd, hPrinter, debugstr_a(pDeviceName),
4552 pDevModeOutput, pDevModeInput);
4553 return 0;
4554 }
4555
4556 /*****************************************************************************
4557 * AdvancedDocumentPropertiesW [WINSPOOL.@]
4558 */
4559 LONG WINAPI AdvancedDocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName,
4560 PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput)
4561 {
4562 FIXME("(%p,%p,%s,%p,%p): stub\n", hWnd, hPrinter, debugstr_w(pDeviceName),
4563 pDevModeOutput, pDevModeInput);
4564 return 0;
4565 }
4566
4567 /*****************************************************************************
4568 * PrinterProperties [WINSPOOL.@]
4569 *
4570 * Displays a dialog to set the properties of the printer.
4571 *
4572 * RETURNS
4573 * nonzero on success or zero on failure
4574 *
4575 * BUGS
4576 * implemented as stub only
4577 */
4578 BOOL WINAPI PrinterProperties(HWND hWnd, /* [in] handle to parent window */
4579 HANDLE hPrinter /* [in] handle to printer object */
4580 ){
4581 FIXME("(%p,%p): stub\n", hWnd, hPrinter);
4582 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4583 return FALSE;
4584 }
4585
4586 /*****************************************************************************
4587 * EnumJobsA [WINSPOOL.@]
4588 *
4589 */
4590 BOOL WINAPI EnumJobsA(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
4591 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
4592 LPDWORD pcReturned)
4593 {
4594 FIXME("(%p,first=%d,no=%d,level=%d,job=%p,cb=%d,%p,%p), stub!\n",
4595 hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
4596 );
4597 if(pcbNeeded) *pcbNeeded = 0;
4598 if(pcReturned) *pcReturned = 0;
4599 return FALSE;
4600 }
4601
4602
4603 /*****************************************************************************
4604 * EnumJobsW [WINSPOOL.@]
4605 *
4606 */
4607 BOOL WINAPI EnumJobsW(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
4608 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
4609 LPDWORD pcReturned)
4610 {
4611 FIXME("(%p,first=%d,no=%d,level=%d,job=%p,cb=%d,%p,%p), stub!\n",
4612 hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
4613 );
4614 if(pcbNeeded) *pcbNeeded = 0;
4615 if(pcReturned) *pcReturned = 0;
4616 return FALSE;
4617 }
4618
4619 /*****************************************************************************
4620 * WINSPOOL_EnumPrinterDrivers [internal]
4621 *
4622 * Delivers information about all printer drivers installed on the
4623 * localhost or a given server
4624 *
4625 * RETURNS
4626 * nonzero on success or zero on failure. If the buffer for the returned
4627 * information is too small the function will return an error
4628 *
4629 * BUGS
4630 * - only implemented for localhost, foreign hosts will return an error
4631 */
4632 static BOOL WINSPOOL_EnumPrinterDrivers(LPWSTR pName, LPCWSTR pEnvironment,
4633 DWORD Level, LPBYTE pDriverInfo,
4634 DWORD cbBuf, LPDWORD pcbNeeded,
4635 LPDWORD pcReturned, BOOL unicode)
4636
4637 { HKEY hkeyDrivers;
4638 DWORD i, needed, number = 0, size = 0;
4639 WCHAR DriverNameW[255];
4640 PBYTE ptr;
4641 const printenv_t * env;
4642
4643 TRACE("%s,%s,%d,%p,%d,%d\n",
4644 debugstr_w(pName), debugstr_w(pEnvironment),
4645 Level, pDriverInfo, cbBuf, unicode);
4646
4647 /* check for local drivers */
4648 if((pName) && (pName[0])) {
4649 FIXME("remote drivers (%s) not supported!\n", debugstr_w(pName));
4650 SetLastError(ERROR_ACCESS_DENIED);
4651 return FALSE;
4652 }
4653
4654 env = validate_envW(pEnvironment);
4655 if (!env) return FALSE; /* SetLastError() is in validate_envW */
4656
4657 /* check input parameter */
4658 if ((Level < 1) || (Level == 7) || (Level > 8)) {
4659 SetLastError(ERROR_INVALID_LEVEL);
4660 return FALSE;
4661 }
4662
4663 if ((pcbNeeded == NULL) || (pcReturned == NULL)) {
4664 SetLastError(RPC_X_NULL_REF_POINTER);
4665 return FALSE;
4666 }
4667
4668 /* initialize return values */
4669 if(pDriverInfo)
4670 memset( pDriverInfo, 0, cbBuf);
4671 *pcbNeeded = 0;
4672 *pcReturned = 0;
4673
4674 hkeyDrivers = WINSPOOL_OpenDriverReg(pEnvironment, TRUE);
4675 if(!hkeyDrivers) {
4676 ERR("Can't open Drivers key\n");
4677 return FALSE;
4678 }
4679
4680 if(RegQueryInfoKeyA(hkeyDrivers, NULL, NULL, NULL, &number, NULL, NULL,
4681 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
4682 RegCloseKey(hkeyDrivers);
4683 ERR("Can't query Drivers key\n");
4684 return FALSE;
4685 }
4686 TRACE("Found %d Drivers\n", number);
4687
4688 /* get size of single struct
4689 * unicode and ascii structure have the same size
4690 */
4691 size = di_sizeof[Level];
4692
4693 /* calculate required buffer size */
4694 *pcbNeeded = size * number;
4695
4696 for( i = 0, ptr = (pDriverInfo && (cbBuf >= size)) ? pDriverInfo : NULL ;
4697 i < number;
4698 i++, ptr = (ptr && (cbBuf >= size * i)) ? ptr + size : NULL) {
4699 if(RegEnumKeyW(hkeyDrivers, i, DriverNameW, sizeof(DriverNameW)/sizeof(DriverNameW[0]))
4700 != ERROR_SUCCESS) {
4701 ERR("Can't enum key number %d\n", i);
4702 RegCloseKey(hkeyDrivers);
4703 return FALSE;
4704 }
4705 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverNameW,
4706 env, Level, ptr,
4707 (cbBuf < *pcbNeeded) ? NULL : pDriverInfo + *pcbNeeded,
4708 (cbBuf < *pcbNeeded) ? 0 : cbBuf - *pcbNeeded,
4709 &needed, unicode)) {
4710 RegCloseKey(hkeyDrivers);
4711 return FALSE;
4712 }
4713 *pcbNeeded += needed;
4714 }
4715
4716 RegCloseKey(hkeyDrivers);
4717
4718 if(cbBuf < *pcbNeeded){
4719 SetLastError(ERROR_INSUFFICIENT_BUFFER);
4720 return FALSE;
4721 }
4722
4723 *pcReturned = number;
4724 return TRUE;
4725 }
4726
4727 /*****************************************************************************
4728 * EnumPrinterDriversW [WINSPOOL.@]
4729 *
4730 * see function EnumPrinterDrivers for RETURNS, BUGS
4731 */
4732 BOOL WINAPI EnumPrinterDriversW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
4733 LPBYTE pDriverInfo, DWORD cbBuf,
4734 LPDWORD pcbNeeded, LPDWORD pcReturned)
4735 {
4736 static const WCHAR allW[] = {'a','l','l',0};
4737
4738 if (pEnvironment && !strcmpW(pEnvironment, allW))
4739 {
4740 BOOL ret;
4741 DWORD i, needed, returned, bufsize = cbBuf;
4742
4743 for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
4744 {
4745 needed = returned = 0;
4746 ret = WINSPOOL_EnumPrinterDrivers(pName, all_printenv[i]->envname, Level,
4747 pDriverInfo, bufsize, &needed, &returned, TRUE);
4748 if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
4749 else if (ret)
4750 {
4751 bufsize -= needed;
4752 if (pDriverInfo) pDriverInfo += needed;
4753 if (pcReturned) *pcReturned += returned;
4754 }
4755 if (pcbNeeded) *pcbNeeded += needed;
4756 }
4757 return ret;
4758 }
4759 return WINSPOOL_EnumPrinterDrivers(pName, pEnvironment, Level, pDriverInfo,
4760 cbBuf, pcbNeeded, pcReturned, TRUE);
4761 }
4762
4763 /*****************************************************************************
4764 * EnumPrinterDriversA [WINSPOOL.@]
4765 *
4766 * see function EnumPrinterDrivers for RETURNS, BUGS
4767 */
4768 BOOL WINAPI EnumPrinterDriversA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
4769 LPBYTE pDriverInfo, DWORD cbBuf,
4770 LPDWORD pcbNeeded, LPDWORD pcReturned)
4771 {
4772 BOOL ret;
4773 UNICODE_STRING pNameW, pEnvironmentW;
4774 PWSTR pwstrNameW, pwstrEnvironmentW;
4775
4776 pwstrNameW = asciitounicode(&pNameW, pName);
4777 pwstrEnvironmentW = asciitounicode(&pEnvironmentW, pEnvironment);
4778
4779 if (pEnvironment && !strcmp(pEnvironment, "all"))
4780 {
4781 DWORD i, needed, returned, bufsize = cbBuf;
4782
4783 for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
4784 {
4785 needed = returned = 0;
4786 ret = WINSPOOL_EnumPrinterDrivers(pwstrNameW, all_printenv[i]->envname, Level,
4787 pDriverInfo, bufsize, &needed, &returned, FALSE);
4788 if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) break;
4789 else if (ret)
4790 {
4791 bufsize -= needed;
4792 if (pDriverInfo) pDriverInfo += needed;
4793 if (pcReturned) *pcReturned += returned;
4794 }
4795 if (pcbNeeded) *pcbNeeded += needed;
4796 }
4797 }
4798 else ret = WINSPOOL_EnumPrinterDrivers(pwstrNameW, pwstrEnvironmentW,
4799 Level, pDriverInfo, cbBuf, pcbNeeded,
4800 pcReturned, FALSE);
4801 RtlFreeUnicodeString(&pNameW);
4802 RtlFreeUnicodeString(&pEnvironmentW);
4803
4804 return ret;
4805 }
4806
4807 /******************************************************************************
4808 * EnumPortsA (WINSPOOL.@)
4809 *
4810 * See EnumPortsW.
4811 *
4812 */
4813 BOOL WINAPI EnumPortsA( LPSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf,
4814 LPDWORD pcbNeeded, LPDWORD pcReturned)
4815 {
4816 BOOL res;
4817 LPBYTE bufferW = NULL;
4818 LPWSTR nameW = NULL;
4819 DWORD needed = 0;
4820 DWORD numentries = 0;
4821 INT len;
4822
4823 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), Level, pPorts,
4824 cbBuf, pcbNeeded, pcReturned);
4825
4826 /* convert servername to unicode */
4827 if (pName) {
4828 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
4829 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
4830 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
4831 }
4832 /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the Ports */
4833 needed = cbBuf * sizeof(WCHAR);
4834 if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
4835 res = EnumPortsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
4836
4837 if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
4838 if (pcbNeeded) needed = *pcbNeeded;
4839 /* HeapReAlloc return NULL, when bufferW was NULL */
4840 bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
4841 HeapAlloc(GetProcessHeap(), 0, needed);
4842
4843 /* Try again with the large Buffer */
4844 res = EnumPortsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
4845 }
4846 needed = pcbNeeded ? *pcbNeeded : 0;
4847 numentries = pcReturned ? *pcReturned : 0;
4848
4849 /*
4850 W2k require the buffersize from EnumPortsW also for EnumPortsA.
4851 We use the smaller Ansi-Size to avoid conflicts with fixed Buffers of old Apps.
4852 */
4853 if (res) {
4854 /* EnumPortsW collected all Data. Parse them to calculate ANSI-Size */
4855 DWORD entrysize = 0;
4856 DWORD index;
4857 LPSTR ptr;
4858 LPPORT_INFO_2W pi2w;
4859 LPPORT_INFO_2A pi2a;
4860
4861 needed = 0;
4862 entrysize = (Level == 1) ? sizeof(PORT_INFO_1A) : sizeof(PORT_INFO_2A);
4863
4864 /* First pass: calculate the size for all Entries */
4865 pi2w = (LPPORT_INFO_2W) bufferW;
4866 pi2a = (LPPORT_INFO_2A) pPorts;
4867 index = 0;
4868 while (index < numentries) {
4869 index++;
4870 needed += entrysize; /* PORT_INFO_?A */
4871 TRACE("%p: parsing #%d (%s)\n", pi2w, index, debugstr_w(pi2w->pPortName));
4872
4873 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pPortName, -1,
4874 NULL, 0, NULL, NULL);
4875 if (Level > 1) {
4876 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pMonitorName, -1,
4877 NULL, 0, NULL, NULL);
4878 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pDescription, -1,
4879 NULL, 0, NULL, NULL);
4880 }
4881 /* use LPBYTE with entrysize to avoid double code (PORT_INFO_1 + PORT_INFO_2) */
4882 pi2w = (LPPORT_INFO_2W) (((LPBYTE)pi2w) + entrysize);
4883 pi2a = (LPPORT_INFO_2A) (((LPBYTE)pi2a) + entrysize);
4884 }
4885
4886 /* check for errors and quit on failure */
4887 if (cbBuf < needed) {
4888 SetLastError(ERROR_INSUFFICIENT_BUFFER);
4889 res = FALSE;
4890 goto cleanup;
4891 }
4892 len = entrysize * numentries; /* room for all PORT_INFO_?A */
4893 ptr = (LPSTR) &pPorts[len]; /* room for strings */
4894 cbBuf -= len ; /* free Bytes in the user-Buffer */
4895 pi2w = (LPPORT_INFO_2W) bufferW;
4896 pi2a = (LPPORT_INFO_2A) pPorts;
4897 index = 0;
4898 /* Second Pass: Fill the User Buffer (if we have one) */
4899 while ((index < numentries) && pPorts) {
4900 index++;
4901 TRACE("%p: writing PORT_INFO_%dA #%d\n", pi2a, Level, index);
4902 pi2a->pPortName = ptr;
4903 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pPortName, -1,
4904 ptr, cbBuf , NULL, NULL);
4905 ptr += len;
4906 cbBuf -= len;
4907 if (Level > 1) {
4908 pi2a->pMonitorName = ptr;
4909 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pMonitorName, -1,
4910 ptr, cbBuf, NULL, NULL);
4911 ptr += len;
4912 cbBuf -= len;
4913
4914 pi2a->pDescription = ptr;
4915 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pDescription, -1,
4916 ptr, cbBuf, NULL, NULL);
4917 ptr += len;
4918 cbBuf -= len;
4919
4920 pi2a->fPortType = pi2w->fPortType;
4921 pi2a->Reserved = 0; /* documented: "must be zero" */
4922
4923 }
4924 /* use LPBYTE with entrysize to avoid double code (PORT_INFO_1 + PORT_INFO_2) */
4925 pi2w = (LPPORT_INFO_2W) (((LPBYTE)pi2w) + entrysize);
4926 pi2a = (LPPORT_INFO_2A) (((LPBYTE)pi2a) + entrysize);
4927 }
4928 }
4929
4930 cleanup:
4931 if (pcbNeeded) *pcbNeeded = needed;
4932 if (pcReturned) *pcReturned = (res) ? numentries : 0;
4933
4934 HeapFree(GetProcessHeap(), 0, nameW);
4935 HeapFree(GetProcessHeap(), 0, bufferW);
4936
4937 TRACE("returning %d with %d (%d byte for %d of %d entries)\n",
4938 (res), GetLastError(), needed, (res)? numentries : 0, numentries);
4939
4940 return (res);
4941
4942 }
4943
4944 /******************************************************************************
4945 * EnumPortsW (WINSPOOL.@)
4946 *
4947 * Enumerate available Ports
4948 *
4949 * PARAMS
4950 * pName [I] Servername or NULL (local Computer)
4951 * Level [I] Structure-Level (1 or 2)
4952 * pPorts [O] PTR to Buffer that receives the Result
4953 * cbBuf [I] Size of Buffer at pPorts
4954 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPorts
4955 * pcReturned [O] PTR to DWORD that receives the number of Ports in pPorts
4956 *
4957 * RETURNS
4958 * Success: TRUE
4959 * Failure: FALSE and in pcbNeeded the Bytes required for pPorts, if cbBuf is too small
4960 *
4961 */
4962 BOOL WINAPI EnumPortsW(LPWSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
4963 {
4964
4965 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pPorts,
4966 cbBuf, pcbNeeded, pcReturned);
4967
4968 if ((backend == NULL) && !load_backend()) return FALSE;
4969
4970 /* Level is not checked in win9x */
4971 if (!Level || (Level > 2)) {
4972 WARN("level (%d) is ignored in win9x\n", Level);
4973 SetLastError(ERROR_INVALID_LEVEL);
4974 return FALSE;
4975 }
4976 if (!pcbNeeded || (!pPorts && (cbBuf > 0))) {
4977 SetLastError(RPC_X_NULL_REF_POINTER);
4978 return FALSE;
4979 }
4980
4981 return backend->fpEnumPorts(pName, Level, pPorts, cbBuf, pcbNeeded, pcReturned);
4982 }
4983
4984 /******************************************************************************
4985 * GetDefaultPrinterW (WINSPOOL.@)
4986 *
4987 * FIXME
4988 * This function must read the value from data 'device' of key
4989 * HCU\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows
4990 */
4991 BOOL WINAPI GetDefaultPrinterW(LPWSTR name, LPDWORD namesize)
4992 {
4993 BOOL retval = TRUE;
4994 DWORD insize, len;
4995 WCHAR *buffer, *ptr;
4996
4997 if (!namesize)
4998 {
4999 SetLastError(ERROR_INVALID_PARAMETER);
5000 return FALSE;
5001 }
5002
5003 /* make the buffer big enough for the stuff from the profile/registry,
5004 * the content must fit into the local buffer to compute the correct
5005 * size even if the extern buffer is too small or not given.
5006 * (20 for ,driver,port) */
5007 insize = *namesize;
5008 len = max(100, (insize + 20));
5009 buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR));
5010
5011 if (!GetProfileStringW(windowsW, deviceW, emptyStringW, buffer, len))
5012 {
5013 SetLastError (ERROR_FILE_NOT_FOUND);
5014 retval = FALSE;
5015 goto end;
5016 }
5017 TRACE("%s\n", debugstr_w(buffer));
5018
5019 if ((ptr = strchrW(buffer, ',')) == NULL)
5020 {
5021 SetLastError(ERROR_INVALID_NAME);
5022 retval = FALSE;
5023 goto end;
5024 }
5025
5026 *ptr = 0;
5027 *namesize = strlenW(buffer) + 1;
5028 if(!name || (*namesize > insize))
5029 {
5030 SetLastError(ERROR_INSUFFICIENT_BUFFER);
5031 retval = FALSE;
5032 goto end;
5033 }
5034 strcpyW(name, buffer);
5035
5036 end:
5037 HeapFree( GetProcessHeap(), 0, buffer);
5038 return retval;
5039 }
5040
5041
5042 /******************************************************************************
5043 * GetDefaultPrinterA (WINSPOOL.@)
5044 */
5045 BOOL WINAPI GetDefaultPrinterA(LPSTR name, LPDWORD namesize)
5046 {
5047 BOOL retval = TRUE;
5048 DWORD insize = 0;
5049 WCHAR *bufferW = NULL;
5050
5051 if (!namesize)
5052 {
5053 SetLastError(ERROR_INVALID_PARAMETER);
5054 return FALSE;
5055 }
5056
5057 if(name && *namesize) {
5058 insize = *namesize;
5059 bufferW = HeapAlloc( GetProcessHeap(), 0, insize * sizeof(WCHAR));
5060 }
5061
5062 if(!GetDefaultPrinterW( bufferW, namesize)) {
5063 retval = FALSE;
5064 goto end;
5065 }
5066
5067 *namesize = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, name, insize,
5068 NULL, NULL);
5069 if (!*namesize)
5070 {
5071 *namesize = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
5072 retval = FALSE;
5073 }
5074 TRACE("0x%08x/0x%08x:%s\n", *namesize, insize, debugstr_w(bufferW));
5075
5076 end:
5077 HeapFree( GetProcessHeap(), 0, bufferW);
5078 return retval;
5079 }
5080
5081
5082 /******************************************************************************
5083 * SetDefaultPrinterW (WINSPOOL.204)
5084 *
5085 * Set the Name of the Default Printer
5086 *
5087 * PARAMS
5088 * pszPrinter [I] Name of the Printer or NULL
5089 *
5090 * RETURNS
5091 * Success: True
5092 * Failure: FALSE
5093 *
5094 * NOTES
5095 * When the Parameter is NULL or points to an Empty String and
5096 * a Default Printer was already present, then this Function changes nothing.
5097 * Without a Default Printer and NULL (or an Empty String) as Parameter,
5098 * the First enumerated local Printer is used.
5099 *
5100 */
5101 BOOL WINAPI SetDefaultPrinterW(LPCWSTR pszPrinter)
5102 {
5103
5104 TRACE("(%s)\n", debugstr_w(pszPrinter));
5105
5106 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5107 return FALSE;
5108 }
5109
5110 /******************************************************************************
5111 * SetDefaultPrinterA (WINSPOOL.202)
5112 *
5113 * See SetDefaultPrinterW.
5114 *
5115 */
5116 BOOL WINAPI SetDefaultPrinterA(LPCSTR pszPrinter)
5117 {
5118
5119 TRACE("(%s)\n", debugstr_a(pszPrinter));
5120
5121 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5122 return FALSE;
5123 }
5124
5125
5126 /******************************************************************************
5127 * SetPrinterDataExA (WINSPOOL.@)
5128 */
5129 DWORD WINAPI SetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5130 LPCSTR pValueName, DWORD Type,
5131 LPBYTE pData, DWORD cbData)
5132 {
5133 HKEY hkeyPrinter, hkeySubkey;
5134 DWORD ret;
5135
5136 TRACE("(%p, %s, %s %08x, %p, %08x)\n", hPrinter, debugstr_a(pKeyName),
5137 debugstr_a(pValueName), Type, pData, cbData);
5138
5139 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5140 != ERROR_SUCCESS)
5141 return ret;
5142
5143 if((ret = RegCreateKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
5144 != ERROR_SUCCESS) {
5145 ERR("Can't create subkey %s\n", debugstr_a(pKeyName));
5146 RegCloseKey(hkeyPrinter);
5147 return ret;
5148 }
5149 ret = RegSetValueExA(hkeySubkey, pValueName, 0, Type, pData, cbData);
5150 RegCloseKey(hkeySubkey);
5151 RegCloseKey(hkeyPrinter);
5152 return ret;
5153 }
5154
5155 /******************************************************************************
5156 * SetPrinterDataExW (WINSPOOL.@)
5157 */
5158 DWORD WINAPI SetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5159 LPCWSTR pValueName, DWORD Type,
5160 LPBYTE pData, DWORD cbData)
5161 {
5162 HKEY hkeyPrinter, hkeySubkey;
5163 DWORD ret;
5164
5165 TRACE("(%p, %s, %s %08x, %p, %08x)\n", hPrinter, debugstr_w(pKeyName),
5166 debugstr_w(pValueName), Type, pData, cbData);
5167
5168 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5169 != ERROR_SUCCESS)
5170 return ret;
5171
5172 if((ret = RegCreateKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
5173 != ERROR_SUCCESS) {
5174 ERR("Can't create subkey %s\n", debugstr_w(pKeyName));
5175 RegCloseKey(hkeyPrinter);
5176 return ret;
5177 }
5178 ret = RegSetValueExW(hkeySubkey, pValueName, 0, Type, pData, cbData);
5179 RegCloseKey(hkeySubkey);
5180 RegCloseKey(hkeyPrinter);
5181 return ret;
5182 }
5183
5184 /******************************************************************************
5185 * SetPrinterDataA (WINSPOOL.@)
5186 */
5187 DWORD WINAPI SetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, DWORD Type,
5188 LPBYTE pData, DWORD cbData)
5189 {
5190 return SetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, Type,
5191 pData, cbData);
5192 }
5193
5194 /******************************************************************************
5195 * SetPrinterDataW (WINSPOOL.@)
5196 */
5197 DWORD WINAPI SetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, DWORD Type,
5198 LPBYTE pData, DWORD cbData)
5199 {
5200 return SetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, Type,
5201 pData, cbData);
5202 }
5203
5204 /******************************************************************************
5205 * GetPrinterDataExA (WINSPOOL.@)
5206 */
5207 DWORD WINAPI GetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5208 LPCSTR pValueName, LPDWORD pType,
5209 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5210 {
5211 HKEY hkeyPrinter, hkeySubkey;
5212 DWORD ret;
5213
5214 TRACE("(%p, %s, %s %p, %p, %08x, %p)\n", hPrinter,
5215 debugstr_a(pKeyName), debugstr_a(pValueName), pType, pData, nSize,
5216 pcbNeeded);
5217
5218 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5219 != ERROR_SUCCESS)
5220 return ret;
5221
5222 if((ret = RegOpenKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
5223 != ERROR_SUCCESS) {
5224 WARN("Can't open subkey %s\n", debugstr_a(pKeyName));
5225 RegCloseKey(hkeyPrinter);
5226 return ret;
5227 }
5228 *pcbNeeded = nSize;
5229 ret = RegQueryValueExA(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
5230 RegCloseKey(hkeySubkey);
5231 RegCloseKey(hkeyPrinter);
5232 return ret;
5233 }
5234
5235 /******************************************************************************
5236 * GetPrinterDataExW (WINSPOOL.@)
5237 */
5238 DWORD WINAPI GetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5239 LPCWSTR pValueName, LPDWORD pType,
5240 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5241 {
5242 HKEY hkeyPrinter, hkeySubkey;
5243 DWORD ret;
5244
5245 TRACE("(%p, %s, %s %p, %p, %08x, %p)\n", hPrinter,
5246 debugstr_w(pKeyName), debugstr_w(pValueName), pType, pData, nSize,
5247 pcbNeeded);
5248
5249 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5250 != ERROR_SUCCESS)
5251 return ret;
5252
5253 if((ret = RegOpenKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
5254 != ERROR_SUCCESS) {
5255 WARN("Can't open subkey %s\n", debugstr_w(pKeyName));
5256 RegCloseKey(hkeyPrinter);
5257 return ret;
5258 }
5259 *pcbNeeded = nSize;
5260 ret = RegQueryValueExW(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
5261 RegCloseKey(hkeySubkey);
5262 RegCloseKey(hkeyPrinter);
5263 return ret;
5264 }
5265
5266 /******************************************************************************
5267 * GetPrinterDataA (WINSPOOL.@)
5268 */
5269 DWORD WINAPI GetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, LPDWORD pType,
5270 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5271 {
5272 return GetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, pType,
5273 pData, nSize, pcbNeeded);
5274 }
5275
5276 /******************************************************************************
5277 * GetPrinterDataW (WINSPOOL.@)
5278 */
5279 DWORD WINAPI GetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, LPDWORD pType,
5280 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5281 {
5282 return GetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, pType,
5283 pData, nSize, pcbNeeded);
5284 }
5285
5286 /*******************************************************************************
5287 * EnumPrinterDataExW [WINSPOOL.@]
5288 */
5289 DWORD WINAPI EnumPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5290 LPBYTE pEnumValues, DWORD cbEnumValues,
5291 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
5292 {
5293 HKEY hkPrinter, hkSubKey;
5294 DWORD r, ret, dwIndex, cValues, cbMaxValueNameLen,
5295 cbValueNameLen, cbMaxValueLen, cbValueLen,
5296 cbBufSize, dwType;
5297 LPWSTR lpValueName;
5298 HANDLE hHeap;
5299 PBYTE lpValue;
5300 PPRINTER_ENUM_VALUESW ppev;
5301
5302 TRACE ("%p %s\n", hPrinter, debugstr_w (pKeyName));
5303
5304 if (pKeyName == NULL || *pKeyName == 0)
5305 return ERROR_INVALID_PARAMETER;
5306
5307 ret = WINSPOOL_GetOpenedPrinterRegKey (hPrinter, &hkPrinter);
5308 if (ret != ERROR_SUCCESS)
5309 {
5310 TRACE ("WINSPOOL_GetOpenedPrinterRegKey (%p) returned %i\n",
5311 hPrinter, ret);
5312 return ret;
5313 }
5314
5315 ret = RegOpenKeyExW (hkPrinter, pKeyName, 0, KEY_READ, &hkSubKey);
5316 if (ret != ERROR_SUCCESS)
5317 {
5318 r = RegCloseKey (hkPrinter);
5319 if (r != ERROR_SUCCESS)
5320 WARN ("RegCloseKey returned %i\n", r);
5321 TRACE ("RegOpenKeyExW (%p, %s) returned %i\n", hPrinter,
5322 debugstr_w (pKeyName), ret);
5323 return ret;
5324 }
5325
5326 ret = RegCloseKey (hkPrinter);
5327 if (ret != ERROR_SUCCESS)
5328 {
5329 ERR ("RegCloseKey returned %i\n", ret);
5330 r = RegCloseKey (hkSubKey);
5331 if (r != ERROR_SUCCESS)
5332 WARN ("RegCloseKey returned %i\n", r);
5333 return ret;
5334 }
5335
5336 ret = RegQueryInfoKeyW (hkSubKey, NULL, NULL, NULL, NULL, NULL, NULL,
5337 &cValues, &cbMaxValueNameLen, &cbMaxValueLen, NULL, NULL);
5338 if (ret != ERROR_SUCCESS)
5339 {
5340 r = RegCloseKey (hkSubKey);
5341 if (r != ERROR_SUCCESS)
5342 WARN ("RegCloseKey returned %i\n", r);
5343 TRACE ("RegQueryInfoKeyW (%p) returned %i\n", hkSubKey, ret);
5344 return ret;
5345 }
5346
5347 TRACE ("RegQueryInfoKeyW returned cValues = %i, cbMaxValueNameLen = %i, "
5348 "cbMaxValueLen = %i\n", cValues, cbMaxValueNameLen, cbMaxValueLen);
5349
5350 if (cValues == 0) /* empty key */
5351 {
5352 r = RegCloseKey (hkSubKey);
5353 if (r != ERROR_SUCCESS)
5354 WARN ("RegCloseKey returned %i\n", r);
5355 *pcbEnumValues = *pnEnumValues = 0;
5356 return ERROR_SUCCESS;
5357 }
5358
5359 ++cbMaxValueNameLen; /* allow for trailing '\0' */
5360
5361 hHeap = GetProcessHeap ();
5362 if (hHeap == NULL)
5363 {
5364 ERR ("GetProcessHeap failed\n");
5365 r = RegCloseKey (hkSubKey);
5366 if (r != ERROR_SUCCESS)
5367 WARN ("RegCloseKey returned %i\n", r);
5368 return ERROR_OUTOFMEMORY;
5369 }
5370
5371 lpValueName = HeapAlloc (hHeap, 0, cbMaxValueNameLen * sizeof (WCHAR));
5372 if (lpValueName == NULL)
5373 {
5374 ERR ("Failed to allocate %i WCHARs from process heap\n", cbMaxValueNameLen);
5375 r = RegCloseKey (hkSubKey);
5376 if (r != ERROR_SUCCESS)
5377 WARN ("RegCloseKey returned %i\n", r);
5378 return ERROR_OUTOFMEMORY;
5379 }
5380
5381 lpValue = HeapAlloc (hHeap, 0, cbMaxValueLen);
5382 if (lpValue == NULL)
5383 {
5384 ERR ("Failed to allocate %i bytes from process heap\n", cbMaxValueLen);
5385 if (HeapFree (hHeap, 0, lpValueName) == 0)
5386 WARN ("HeapFree failed with code %i\n", GetLastError ());
5387 r = RegCloseKey (hkSubKey);
5388 if (r != ERROR_SUCCESS)
5389 WARN ("RegCloseKey returned %i\n", r);
5390 return ERROR_OUTOFMEMORY;
5391 }
5392
5393 TRACE ("pass 1: calculating buffer required for all names and values\n");
5394
5395 cbBufSize = cValues * sizeof (PRINTER_ENUM_VALUESW);
5396
5397 TRACE ("%i bytes required for %i headers\n", cbBufSize, cValues);
5398
5399 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
5400 {
5401 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
5402 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
5403 NULL, NULL, lpValue, &cbValueLen);
5404 if (ret != ERROR_SUCCESS)
5405 {
5406 if (HeapFree (hHeap, 0, lpValue) == 0)
5407 WARN ("HeapFree failed with code %i\n", GetLastError ());
5408 if (HeapFree (hHeap, 0, lpValueName) == 0)
5409 WARN ("HeapFree failed with code %i\n", GetLastError ());
5410 r = RegCloseKey (hkSubKey);
5411 if (r != ERROR_SUCCESS)
5412 WARN ("RegCloseKey returned %i\n", r);
5413 TRACE ("RegEnumValueW (%i) returned %i\n", dwIndex, ret);
5414 return ret;
5415 }
5416
5417 TRACE ("%s [%i]: name needs %i WCHARs, data needs %i bytes\n",
5418 debugstr_w (lpValueName), dwIndex,
5419 cbValueNameLen + 1, cbValueLen);
5420
5421 cbBufSize += (cbValueNameLen + 1) * sizeof (WCHAR);
5422 cbBufSize += cbValueLen;
5423 }
5424
5425 TRACE ("%i bytes required for all %i values\n", cbBufSize, cValues);
5426
5427 *pcbEnumValues = cbBufSize;
5428 *pnEnumValues = cValues;
5429
5430 if (cbEnumValues < cbBufSize) /* buffer too small */
5431 {
5432 if (HeapFree (hHeap, 0, lpValue) == 0)
5433 WARN ("HeapFree failed with code %i\n", GetLastError ());
5434 if (HeapFree (hHeap, 0, lpValueName) == 0)
5435 WARN ("HeapFree failed with code %i\n", GetLastError ());
5436 r = RegCloseKey (hkSubKey);
5437 if (r != ERROR_SUCCESS)
5438 WARN ("RegCloseKey returned %i\n", r);
5439 TRACE ("%i byte buffer is not large enough\n", cbEnumValues);
5440 return ERROR_MORE_DATA;
5441 }
5442
5443 TRACE ("pass 2: copying all names and values to buffer\n");
5444
5445 ppev = (PPRINTER_ENUM_VALUESW) pEnumValues; /* array of structs */
5446 pEnumValues += cValues * sizeof (PRINTER_ENUM_VALUESW);
5447
5448 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
5449 {
5450 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
5451 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
5452 NULL, &dwType, lpValue, &cbValueLen);
5453 if (ret != ERROR_SUCCESS)
5454 {
5455 if (HeapFree (hHeap, 0, lpValue) == 0)
5456 WARN ("HeapFree failed with code %i\n", GetLastError ());
5457 if (HeapFree (hHeap, 0, lpValueName) == 0)
5458 WARN ("HeapFree failed with code %i\n", GetLastError ());
5459 r = RegCloseKey (hkSubKey);
5460 if (r != ERROR_SUCCESS)
5461 WARN ("RegCloseKey returned %i\n", r);
5462 TRACE ("RegEnumValueW (%i) returned %i\n", dwIndex, ret);
5463 return ret;
5464 }
5465
5466 cbValueNameLen = (cbValueNameLen + 1) * sizeof (WCHAR);
5467 memcpy (pEnumValues, lpValueName, cbValueNameLen);
5468 ppev[dwIndex].pValueName = (LPWSTR) pEnumValues;
5469 pEnumValues += cbValueNameLen;
5470
5471 /* return # of *bytes* (including trailing \0), not # of chars */
5472 ppev[dwIndex].cbValueName = cbValueNameLen;
5473
5474 ppev[dwIndex].dwType = dwType;
5475
5476 memcpy (pEnumValues, lpValue, cbValueLen);
5477 ppev[dwIndex].pData = pEnumValues;
5478 pEnumValues += cbValueLen;
5479
5480 ppev[dwIndex].cbData = cbValueLen;
5481
5482 TRACE ("%s [%i]: copied name (%i bytes) and data (%i bytes)\n",
5483 debugstr_w (lpValueName), dwIndex, cbValueNameLen, cbValueLen);
5484 }
5485
5486 if (HeapFree (hHeap, 0, lpValue) == 0)
5487 {
5488 ret = GetLastError ();
5489 ERR ("HeapFree failed with code %i\n", ret);
5490 if (HeapFree (hHeap, 0, lpValueName) == 0)
5491 WARN ("HeapFree failed with code %i\n", GetLastError ());
5492 r = RegCloseKey (hkSubKey);
5493 if (r != ERROR_SUCCESS)
5494 WARN ("RegCloseKey returned %i\n", r);
5495 return ret;
5496 }
5497
5498 if (HeapFree (hHeap, 0, lpValueName) == 0)
5499 {
5500 ret = GetLastError ();
5501 ERR ("HeapFree failed with code %i\n", ret);
5502 r = RegCloseKey (hkSubKey);
5503 if (r != ERROR_SUCCESS)
5504 WARN ("RegCloseKey returned %i\n", r);
5505 return ret;
5506 }
5507
5508 ret = RegCloseKey (hkSubKey);
5509 if (ret != ERROR_SUCCESS)
5510 {
5511 ERR ("RegCloseKey returned %i\n", ret);
5512 return ret;
5513 }
5514
5515 return ERROR_SUCCESS;
5516 }
5517
5518 /*******************************************************************************
5519 * EnumPrinterDataExA [WINSPOOL.@]
5520 *
5521 * This functions returns value names and REG_SZ, REG_EXPAND_SZ, and
5522 * REG_MULTI_SZ values as ASCII strings in Unicode-sized buffers. This is
5523 * what Windows 2000 SP1 does.
5524 *
5525 */
5526 DWORD WINAPI EnumPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5527 LPBYTE pEnumValues, DWORD cbEnumValues,
5528 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
5529 {
5530 INT len;
5531 LPWSTR pKeyNameW;
5532 DWORD ret, dwIndex, dwBufSize;
5533 HANDLE hHeap;
5534 LPSTR pBuffer;
5535
5536 TRACE ("%p %s\n", hPrinter, pKeyName);
5537
5538 if (pKeyName == NULL || *pKeyName == 0)
5539 return ERROR_INVALID_PARAMETER;
5540
5541 len = MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, NULL, 0);
5542 if (len == 0)
5543 {
5544 ret = GetLastError ();
5545 ERR ("MultiByteToWideChar failed with code %i\n", ret);
5546 return ret;
5547 }
5548
5549 hHeap = GetProcessHeap ();
5550 if (hHeap == NULL)
5551 {
5552 ERR ("GetProcessHeap failed\n");
5553 return ERROR_OUTOFMEMORY;
5554 }
5555
5556 pKeyNameW = HeapAlloc (hHeap, 0, len * sizeof (WCHAR));
5557 if (pKeyNameW == NULL)
5558 {
5559 ERR ("Failed to allocate %i bytes from process heap\n",
5560 (LONG)(len * sizeof (WCHAR)));
5561 return ERROR_OUTOFMEMORY;
5562 }
5563
5564 if (MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, pKeyNameW, len) == 0)
5565 {
5566 ret = GetLastError ();
5567 ERR ("MultiByteToWideChar failed with code %i\n", ret);
5568 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
5569 WARN ("HeapFree failed with code %i\n", GetLastError ());
5570 return ret;
5571 }
5572
5573 ret = EnumPrinterDataExW (hPrinter, pKeyNameW, pEnumValues, cbEnumValues,
5574 pcbEnumValues, pnEnumValues);
5575 if (ret != ERROR_SUCCESS)
5576 {
5577 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
5578 WARN ("HeapFree failed with code %i\n", GetLastError ());
5579 TRACE ("EnumPrinterDataExW returned %i\n", ret);
5580 return ret;
5581 }
5582
5583 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
5584 {
5585 ret = GetLastError ();
5586 ERR ("HeapFree failed with code %i\n", ret);
5587 return ret;
5588 }
5589
5590 if (*pnEnumValues == 0) /* empty key */
5591 return ERROR_SUCCESS;
5592
5593 dwBufSize = 0;
5594 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
5595 {
5596 PPRINTER_ENUM_VALUESW ppev =
5597 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
5598
5599 if (dwBufSize < ppev->cbValueName)
5600 dwBufSize = ppev->cbValueName;
5601
5602 if (dwBufSize < ppev->cbData && (ppev->dwType == REG_SZ ||
5603 ppev->dwType == REG_EXPAND_SZ || ppev->dwType == REG_MULTI_SZ))
5604 dwBufSize = ppev->cbData;
5605 }
5606
5607 TRACE ("Largest Unicode name or value is %i bytes\n", dwBufSize);
5608
5609 pBuffer = HeapAlloc (hHeap, 0, dwBufSize);
5610 if (pBuffer == NULL)
5611 {
5612 ERR ("Failed to allocate %i bytes from process heap\n", dwBufSize);
5613 return ERROR_OUTOFMEMORY;
5614 }
5615
5616 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
5617 {
5618 PPRINTER_ENUM_VALUESW ppev =
5619 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
5620
5621 len = WideCharToMultiByte (CP_ACP, 0, ppev->pValueName,
5622 ppev->cbValueName / sizeof (WCHAR), pBuffer, dwBufSize, NULL,
5623 NULL);
5624 if (len == 0)
5625 {
5626 ret = GetLastError ();
5627 ERR ("WideCharToMultiByte failed with code %i\n", ret);
5628 if (HeapFree (hHeap, 0, pBuffer) == 0)
5629 WARN ("HeapFree failed with code %i\n", GetLastError ());
5630 return ret;
5631 }
5632
5633 memcpy (ppev->pValueName, pBuffer, len);
5634
5635 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
5636
5637 if (ppev->dwType != REG_SZ && ppev->dwType != REG_EXPAND_SZ &&
5638 ppev->dwType != REG_MULTI_SZ)
5639 continue;
5640
5641 len = WideCharToMultiByte (CP_ACP, 0, (LPWSTR) ppev->pData,
5642 ppev->cbData / sizeof (WCHAR), pBuffer, dwBufSize, NULL, NULL);
5643 if (len == 0)
5644 {
5645 ret = GetLastError ();
5646 ERR ("WideCharToMultiByte failed with code %i\n", ret);
5647 if (HeapFree (hHeap, 0, pBuffer) == 0)
5648 WARN ("HeapFree failed with code %i\n", GetLastError ());
5649 return ret;
5650 }
5651
5652 memcpy (ppev->pData, pBuffer, len);
5653
5654 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
5655 TRACE (" (only first string of REG_MULTI_SZ printed)\n");
5656 }
5657
5658 if (HeapFree (hHeap, 0, pBuffer) == 0)
5659 {
5660 ret = GetLastError ();
5661 ERR ("HeapFree failed with code %i\n", ret);
5662 return ret;
5663 }
5664
5665 return ERROR_SUCCESS;
5666 }
5667
5668 /******************************************************************************
5669 * AbortPrinter (WINSPOOL.@)
5670 */
5671 BOOL WINAPI AbortPrinter( HANDLE hPrinter )
5672 {
5673 FIXME("(%p), stub!\n", hPrinter);
5674 return TRUE;
5675 }
5676
5677 /******************************************************************************
5678 * AddPortA (WINSPOOL.@)
5679 *
5680 * See AddPortW.
5681 *
5682 */
5683 BOOL WINAPI AddPortA(LPSTR pName, HWND hWnd, LPSTR pMonitorName)
5684 {
5685 LPWSTR nameW = NULL;
5686 LPWSTR monitorW = NULL;
5687 DWORD len;
5688 BOOL res;
5689
5690 TRACE("(%s, %p, %s)\n",debugstr_a(pName), hWnd, debugstr_a(pMonitorName));
5691
5692 if (pName) {
5693 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
5694 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5695 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
5696 }
5697
5698 if (pMonitorName) {
5699 len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
5700 monitorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5701 MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, monitorW, len);
5702 }
5703 res = AddPortW(nameW, hWnd, monitorW);
5704 HeapFree(GetProcessHeap(), 0, nameW);
5705 HeapFree(GetProcessHeap(), 0, monitorW);
5706 return res;
5707 }
5708
5709 /******************************************************************************
5710 * AddPortW (WINSPOOL.@)
5711 *
5712 * Add a Port for a specific Monitor
5713 *
5714 * PARAMS
5715 * pName [I] Servername or NULL (local Computer)
5716 * hWnd [I] Handle to parent Window for the Dialog-Box
5717 * pMonitorName [I] Name of the Monitor that manage the Port
5718 *
5719 * RETURNS
5720 * Success: TRUE
5721 * Failure: FALSE
5722 *
5723 */
5724 BOOL WINAPI AddPortW(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
5725 {
5726 TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pMonitorName));
5727
5728 if ((backend == NULL) && !load_backend()) return FALSE;
5729
5730 if (!pMonitorName) {
5731 SetLastError(RPC_X_NULL_REF_POINTER);
5732 return FALSE;
5733 }
5734
5735 return backend->fpAddPort(pName, hWnd, pMonitorName);
5736 }
5737
5738 /******************************************************************************
5739 * AddPortExA (WINSPOOL.@)
5740 *
5741 * See AddPortExW.
5742 *
5743 */
5744 BOOL WINAPI AddPortExA(LPSTR pName, DWORD level, LPBYTE pBuffer, LPSTR pMonitorName)
5745 {
5746 PORT_INFO_2W pi2W;
5747 PORT_INFO_2A * pi2A;
5748 LPWSTR nameW = NULL;
5749 LPWSTR monitorW = NULL;
5750 DWORD len;
5751 BOOL res;
5752
5753 pi2A = (PORT_INFO_2A *) pBuffer;
5754
5755 TRACE("(%s, %d, %p, %s): %s\n", debugstr_a(pName), level, pBuffer,
5756 debugstr_a(pMonitorName), debugstr_a(pi2A ? pi2A->pPortName : NULL));
5757
5758 if ((level < 1) || (level > 2)) {
5759 SetLastError(ERROR_INVALID_LEVEL);
5760 return FALSE;
5761 }
5762
5763 if (!pi2A) {
5764 SetLastError(ERROR_INVALID_PARAMETER);
5765 return FALSE;
5766 }
5767
5768 if (pName) {
5769 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
5770 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5771 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
5772 }
5773
5774 if (pMonitorName) {
5775 len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
5776 monitorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5777 MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, monitorW, len);
5778 }
5779
5780 ZeroMemory(&pi2W, sizeof(PORT_INFO_2W));
5781
5782 if (pi2A->pPortName) {
5783 len = MultiByteToWideChar(CP_ACP, 0, pi2A->pPortName, -1, NULL, 0);
5784 pi2W.pPortName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5785 MultiByteToWideChar(CP_ACP, 0, pi2A->pPortName, -1, pi2W.pPortName, len);
5786 }
5787
5788 if (level > 1) {
5789 if (pi2A->pMonitorName) {
5790 len = MultiByteToWideChar(CP_ACP, 0, pi2A->pMonitorName, -1, NULL, 0);
5791 pi2W.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5792 MultiByteToWideChar(CP_ACP, 0, pi2A->pMonitorName, -1, pi2W.pMonitorName, len);
5793 }
5794
5795 if (pi2A->pDescription) {
5796 len = MultiByteToWideChar(CP_ACP, 0, pi2A->pDescription, -1, NULL, 0);
5797 pi2W.pDescription = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5798 MultiByteToWideChar(CP_ACP, 0, pi2A->pDescription, -1, pi2W.pDescription, len);
5799 }
5800 pi2W.fPortType = pi2A->fPortType;
5801 pi2W.Reserved = pi2A->Reserved;
5802 }
5803
5804 res = AddPortExW(nameW, level, (LPBYTE) &pi2W, monitorW);
5805
5806 HeapFree(GetProcessHeap(), 0, nameW);
5807 HeapFree(GetProcessHeap(), 0, monitorW);
5808 HeapFree(GetProcessHeap(), 0, pi2W.pPortName);
5809 HeapFree(GetProcessHeap(), 0, pi2W.pMonitorName);
5810 HeapFree(GetProcessHeap(), 0, pi2W.pDescription);
5811 return res;
5812
5813 }
5814
5815 /******************************************************************************
5816 * AddPortExW (WINSPOOL.@)
5817 *
5818 * Add a Port for a specific Monitor, without presenting a user interface
5819 *
5820 * PARAMS
5821 * pName [I] Servername or NULL (local Computer)
5822 * level [I] Structure-Level (1 or 2) for pBuffer
5823 * pBuffer [I] PTR to: PORT_INFO_1 or PORT_INFO_2
5824 * pMonitorName [I] Name of the Monitor that manage the Port
5825 *
5826 * RETURNS
5827 * Success: TRUE
5828 * Failure: FALSE
5829 *
5830 */
5831 BOOL WINAPI AddPortExW(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
5832 {
5833 PORT_INFO_2W * pi2;
5834
5835 pi2 = (PORT_INFO_2W *) pBuffer;
5836
5837 TRACE("(%s, %d, %p, %s): %s %s %s\n", debugstr_w(pName), level, pBuffer,
5838 debugstr_w(pMonitorName), debugstr_w(pi2 ? pi2->pPortName : NULL),
5839 debugstr_w(((level > 1) && pi2) ? pi2->pMonitorName : NULL),
5840 debugstr_w(((level > 1) && pi2) ? pi2->pDescription : NULL));
5841
5842 if ((backend == NULL) && !load_backend()) return FALSE;
5843
5844 if ((!pi2) || (!pMonitorName) || (!pMonitorName[0])) {
5845 SetLastError(ERROR_INVALID_PARAMETER);
5846 return FALSE;
5847 }
5848
5849 return backend->fpAddPortEx(pName, level, pBuffer, pMonitorName);
5850 }
5851
5852 /******************************************************************************
5853 * AddPrinterConnectionA (WINSPOOL.@)
5854 */
5855 BOOL WINAPI AddPrinterConnectionA( LPSTR pName )
5856 {
5857 FIXME("%s\n", debugstr_a(pName));
5858 return FALSE;
5859 }
5860
5861 /******************************************************************************
5862 * AddPrinterConnectionW (WINSPOOL.@)
5863 */
5864 BOOL WINAPI AddPrinterConnectionW( LPWSTR pName )
5865 {
5866 FIXME("%s\n", debugstr_w(pName));
5867 return FALSE;
5868 }
5869
5870 /******************************************************************************
5871 * AddPrinterDriverExW (WINSPOOL.@)
5872 *
5873 * Install a Printer Driver with the Option to upgrade / downgrade the Files
5874 *
5875 * PARAMS
5876 * pName [I] Servername or NULL (local Computer)
5877 * level [I] Level for the supplied DRIVER_INFO_*W struct
5878 * pDriverInfo [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
5879 * dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
5880 *
5881 * RESULTS
5882 * Success: TRUE
5883 * Failure: FALSE
5884 *
5885 */
5886 BOOL WINAPI AddPrinterDriverExW( LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
5887 {
5888 TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
5889
5890 if ((backend == NULL) && !load_backend()) return FALSE;
5891
5892 if (level < 2 || level == 5 || level == 7 || level > 8) {
5893 SetLastError(ERROR_INVALID_LEVEL);
5894 return FALSE;
5895 }
5896
5897 if (!pDriverInfo) {
5898 SetLastError(ERROR_INVALID_PARAMETER);
5899 return FALSE;
5900 }
5901
5902 return backend->fpAddPrinterDriverEx(pName, level, pDriverInfo, dwFileCopyFlags);
5903 }
5904
5905 /******************************************************************************
5906 * AddPrinterDriverExA (WINSPOOL.@)
5907 *
5908 * See AddPrinterDriverExW.
5909 *
5910 */
5911 BOOL WINAPI AddPrinterDriverExA(LPSTR pName, DWORD Level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
5912 {
5913 DRIVER_INFO_8A *diA;
5914 DRIVER_INFO_8W diW;
5915 LPWSTR nameW = NULL;
5916 DWORD lenA;
5917 DWORD len;
5918 DWORD res = FALSE;
5919
5920 TRACE("(%s, %d, %p, 0x%x)\n", debugstr_a(pName), Level, pDriverInfo, dwFileCopyFlags);
5921
5922 diA = (DRIVER_INFO_8A *) pDriverInfo;
5923 ZeroMemory(&diW, sizeof(diW));
5924
5925 if (Level < 2 || Level == 5 || Level == 7 || Level > 8) {
5926 SetLastError(ERROR_INVALID_LEVEL);
5927 return FALSE;
5928 }
5929
5930 if (diA == NULL) {
5931 SetLastError(ERROR_INVALID_PARAMETER);
5932 return FALSE;
5933 }
5934
5935 /* convert servername to unicode */
5936 if (pName) {
5937 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
5938 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5939 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
5940 }
5941
5942 /* common fields */
5943 diW.cVersion = diA->cVersion;
5944
5945 if (diA->pName) {
5946 len = MultiByteToWideChar(CP_ACP, 0, diA->pName, -1, NULL, 0);
5947 diW.pName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5948 MultiByteToWideChar(CP_ACP, 0, diA->pName, -1, diW.pName, len);
5949 }
5950
5951 if (diA->pEnvironment) {
5952 len = MultiByteToWideChar(CP_ACP, 0, diA->pEnvironment, -1, NULL, 0);
5953 diW.pEnvironment = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5954 MultiByteToWideChar(CP_ACP, 0, diA->pEnvironment, -1, diW.pEnvironment, len);
5955 }
5956
5957 if (diA->pDriverPath) {
5958 len = MultiByteToWideChar(CP_ACP, 0, diA->pDriverPath, -1, NULL, 0);
5959 diW.pDriverPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5960 MultiByteToWideChar(CP_ACP, 0, diA->pDriverPath, -1, diW.pDriverPath, len);
5961 }
5962
5963 if (diA->pDataFile) {
5964 len = MultiByteToWideChar(CP_ACP, 0, diA->pDataFile, -1, NULL, 0);
5965 diW.pDataFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5966 MultiByteToWideChar(CP_ACP, 0, diA->pDataFile, -1, diW.pDataFile, len);
5967 }
5968
5969 if (diA->pConfigFile) {
5970 len = MultiByteToWideChar(CP_ACP, 0, diA->pConfigFile, -1, NULL, 0);
5971 diW.pConfigFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5972 MultiByteToWideChar(CP_ACP, 0, diA->pConfigFile, -1, diW.pConfigFile, len);
5973 }
5974
5975 if ((Level > 2) && diA->pDependentFiles) {
5976 lenA = multi_sz_lenA(diA->pDependentFiles);
5977 len = MultiByteToWideChar(CP_ACP, 0, diA->pDependentFiles, lenA, NULL, 0);
5978 diW.pDependentFiles = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5979 MultiByteToWideChar(CP_ACP, 0, diA->pDependentFiles, lenA, diW.pDependentFiles, len);
5980 }
5981
5982 if ((Level > 2) && diA->pMonitorName) {
5983 len = MultiByteToWideChar(CP_ACP, 0, diA->pMonitorName, -1, NULL, 0);
5984 diW.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5985 MultiByteToWideChar(CP_ACP, 0, diA->pMonitorName, -1, diW.pMonitorName, len);
5986 }
5987
5988 if ((Level > 3) && diA->pDefaultDataType) {
5989 len = MultiByteToWideChar(CP_ACP, 0, diA->pDefaultDataType, -1, NULL, 0);
5990 diW.pDefaultDataType = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5991 MultiByteToWideChar(CP_ACP, 0, diA->pDefaultDataType, -1, diW.pDefaultDataType, len);
5992 }
5993
5994 if ((Level > 3) && diA->pszzPreviousNames) {
5995 lenA = multi_sz_lenA(diA->pszzPreviousNames);
5996 len = MultiByteToWideChar(CP_ACP, 0, diA->pszzPreviousNames, lenA, NULL, 0);
5997 diW.pszzPreviousNames = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5998 MultiByteToWideChar(CP_ACP, 0, diA->pszzPreviousNames, lenA, diW.pszzPreviousNames, len);
5999 }
6000
6001 if ((Level > 5) && diA->pszMfgName) {
6002 len = MultiByteToWideChar(CP_ACP, 0, diA->pszMfgName, -1, NULL, 0);
6003 diW.pszMfgName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6004 MultiByteToWideChar(CP_ACP, 0, diA->pszMfgName, -1, diW.pszMfgName, len);
6005 }
6006
6007 if ((Level > 5) && diA->pszOEMUrl) {
6008 len = MultiByteToWideChar(CP_ACP, 0, diA->pszOEMUrl, -1, NULL, 0);
6009 diW.pszOEMUrl = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6010 MultiByteToWideChar(CP_ACP, 0, diA->pszOEMUrl, -1, diW.pszOEMUrl, len);
6011 }
6012
6013 if ((Level > 5) && diA->pszHardwareID) {
6014 len = MultiByteToWideChar(CP_ACP, 0, diA->pszHardwareID, -1, NULL, 0);
6015 diW.pszHardwareID = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6016 MultiByteToWideChar(CP_ACP, 0, diA->pszHardwareID, -1, diW.pszHardwareID, len);
6017 }
6018
6019 if ((Level > 5) && diA->pszProvider) {
6020 len = MultiByteToWideChar(CP_ACP, 0, diA->pszProvider, -1, NULL, 0);
6021 diW.pszProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6022 MultiByteToWideChar(CP_ACP, 0, diA->pszProvider, -1, diW.pszProvider, len);
6023 }
6024
6025 if (Level > 7) {
6026 FIXME("level %u is incomplete\n", Level);
6027 }
6028
6029 res = AddPrinterDriverExW(nameW, Level, (LPBYTE) &diW, dwFileCopyFlags);
6030 TRACE("got %u with %u\n", res, GetLastError());
6031 HeapFree(GetProcessHeap(), 0, nameW);
6032 HeapFree(GetProcessHeap(), 0, diW.pName);
6033 HeapFree(GetProcessHeap(), 0, diW.pEnvironment);
6034 HeapFree(GetProcessHeap(), 0, diW.pDriverPath);
6035 HeapFree(GetProcessHeap(), 0, diW.pDataFile);
6036 HeapFree(GetProcessHeap(), 0, diW.pConfigFile);
6037 HeapFree(GetProcessHeap(), 0, diW.pDependentFiles);
6038 HeapFree(GetProcessHeap(), 0, diW.pMonitorName);
6039 HeapFree(GetProcessHeap(), 0, diW.pDefaultDataType);
6040 HeapFree(GetProcessHeap(), 0, diW.pszzPreviousNames);
6041 HeapFree(GetProcessHeap(), 0, diW.pszMfgName);
6042 HeapFree(GetProcessHeap(), 0, diW.pszOEMUrl);
6043 HeapFree(GetProcessHeap(), 0, diW.pszHardwareID);
6044 HeapFree(GetProcessHeap(), 0, diW.pszProvider);
6045
6046 TRACE("=> %u with %u\n", res, GetLastError());
6047 return res;
6048 }
6049
6050 /******************************************************************************
6051 * ConfigurePortA (WINSPOOL.@)
6052 *
6053 * See ConfigurePortW.
6054 *
6055 */
6056 BOOL WINAPI ConfigurePortA(LPSTR pName, HWND hWnd, LPSTR pPortName)
6057 {
6058 LPWSTR nameW = NULL;
6059 LPWSTR portW = NULL;
6060 INT len;
6061 DWORD res;
6062
6063 TRACE("(%s, %p, %s)\n", debugstr_a(pName), hWnd, debugstr_a(pPortName));
6064
6065 /* convert servername to unicode */
6066 if (pName) {
6067 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6068 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6069 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6070 }
6071
6072 /* convert portname to unicode */
6073 if (pPortName) {
6074 len = MultiByteToWideChar(CP_ACP, 0, pPortName, -1, NULL, 0);
6075 portW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6076 MultiByteToWideChar(CP_ACP, 0, pPortName, -1, portW, len);
6077 }
6078
6079 res = ConfigurePortW(nameW, hWnd, portW);
6080 HeapFree(GetProcessHeap(), 0, nameW);
6081 HeapFree(GetProcessHeap(), 0, portW);
6082 return res;
6083 }
6084
6085 /******************************************************************************
6086 * ConfigurePortW (WINSPOOL.@)
6087 *
6088 * Display the Configuration-Dialog for a specific Port
6089 *
6090 * PARAMS
6091 * pName [I] Servername or NULL (local Computer)
6092 * hWnd [I] Handle to parent Window for the Dialog-Box
6093 * pPortName [I] Name of the Port, that should be configured
6094 *
6095 * RETURNS
6096 * Success: TRUE
6097 * Failure: FALSE
6098 *
6099 */
6100 BOOL WINAPI ConfigurePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
6101 {
6102
6103 TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
6104
6105 if ((backend == NULL) && !load_backend()) return FALSE;
6106
6107 if (!pPortName) {
6108 SetLastError(RPC_X_NULL_REF_POINTER);
6109 return FALSE;
6110 }
6111
6112 return backend->fpConfigurePort(pName, hWnd, pPortName);
6113 }
6114
6115 /******************************************************************************
6116 * ConnectToPrinterDlg (WINSPOOL.@)
6117 */
6118 HANDLE WINAPI ConnectToPrinterDlg( HWND hWnd, DWORD Flags )
6119 {
6120 FIXME("%p %x\n", hWnd, Flags);
6121 return NULL;
6122 }
6123
6124 /******************************************************************************
6125 * DeletePrinterConnectionA (WINSPOOL.@)
6126 */
6127 BOOL WINAPI DeletePrinterConnectionA( LPSTR pName )
6128 {
6129 FIXME("%s\n", debugstr_a(pName));
6130 return TRUE;
6131 }
6132
6133 /******************************************************************************
6134 * DeletePrinterConnectionW (WINSPOOL.@)
6135 */
6136 BOOL WINAPI DeletePrinterConnectionW( LPWSTR pName )
6137 {
6138 FIXME("%s\n", debugstr_w(pName));
6139 return TRUE;
6140 }
6141
6142 /******************************************************************************
6143 * DeletePrinterDriverExW (WINSPOOL.@)
6144 */
6145 BOOL WINAPI DeletePrinterDriverExW( LPWSTR pName, LPWSTR pEnvironment,
6146 LPWSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
6147 {
6148 HKEY hkey_drivers;
6149 BOOL ret = FALSE;
6150
6151 TRACE("%s %s %s %x %x\n", debugstr_w(pName), debugstr_w(pEnvironment),
6152 debugstr_w(pDriverName), dwDeleteFlag, dwVersionFlag);
6153
6154 if(pName && pName[0])
6155 {
6156 FIXME("pName = %s - unsupported\n", debugstr_w(pName));
6157 SetLastError(ERROR_INVALID_PARAMETER);
6158 return FALSE;
6159 }
6160
6161 if(dwDeleteFlag)
6162 {
6163 FIXME("dwDeleteFlag = %x - unsupported\n", dwDeleteFlag);
6164 SetLastError(ERROR_INVALID_PARAMETER);
6165 return FALSE;
6166 }
6167
6168 hkey_drivers = WINSPOOL_OpenDriverReg(pEnvironment, TRUE);
6169
6170 if(!hkey_drivers)
6171 {
6172 ERR("Can't open drivers key\n");
6173 return FALSE;
6174 }
6175
6176 if(RegDeleteTreeW(hkey_drivers, pDriverName) == ERROR_SUCCESS)
6177 ret = TRUE;
6178
6179 RegCloseKey(hkey_drivers);
6180
6181 return ret;
6182 }
6183
6184 /******************************************************************************
6185 * DeletePrinterDriverExA (WINSPOOL.@)
6186 */
6187 BOOL WINAPI DeletePrinterDriverExA( LPSTR pName, LPSTR pEnvironment,
6188 LPSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
6189 {
6190 UNICODE_STRING NameW, EnvW, DriverW;
6191 BOOL ret;
6192
6193 asciitounicode(&NameW, pName);
6194 asciitounicode(&EnvW, pEnvironment);
6195 asciitounicode(&DriverW, pDriverName);
6196
6197 ret = DeletePrinterDriverExW(NameW.Buffer, EnvW.Buffer, DriverW.Buffer, dwDeleteFlag, dwVersionFlag);
6198
6199 RtlFreeUnicodeString(&DriverW);
6200 RtlFreeUnicodeString(&EnvW);
6201 RtlFreeUnicodeString(&NameW);
6202
6203 return ret;
6204 }
6205
6206 /******************************************************************************
6207 * DeletePrinterDataExW (WINSPOOL.@)
6208 */
6209 DWORD WINAPI DeletePrinterDataExW( HANDLE hPrinter, LPCWSTR pKeyName,
6210 LPCWSTR pValueName)
6211 {
6212 FIXME("%p %s %s\n", hPrinter,
6213 debugstr_w(pKeyName), debugstr_w(pValueName));
6214 return ERROR_INVALID_PARAMETER;
6215 }
6216
6217 /******************************************************************************
6218 * DeletePrinterDataExA (WINSPOOL.@)
6219 */
6220 DWORD WINAPI DeletePrinterDataExA( HANDLE hPrinter, LPCSTR pKeyName,
6221 LPCSTR pValueName)
6222 {
6223 FIXME("%p %s %s\n", hPrinter,
6224 debugstr_a(pKeyName), debugstr_a(pValueName));
6225 return ERROR_INVALID_PARAMETER;
6226 }
6227
6228 /******************************************************************************
6229 * DeletePrintProcessorA (WINSPOOL.@)
6230 */
6231 BOOL WINAPI DeletePrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProcessorName)
6232 {
6233 FIXME("%s %s %s\n", debugstr_a(pName), debugstr_a(pEnvironment),
6234 debugstr_a(pPrintProcessorName));
6235 return TRUE;
6236 }
6237
6238 /******************************************************************************
6239 * DeletePrintProcessorW (WINSPOOL.@)
6240 */
6241 BOOL WINAPI DeletePrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProcessorName)
6242 {
6243 FIXME("%s %s %s\n", debugstr_w(pName), debugstr_w(pEnvironment),
6244 debugstr_w(pPrintProcessorName));
6245 return TRUE;
6246 }
6247
6248 /******************************************************************************
6249 * DeletePrintProvidorA (WINSPOOL.@)
6250 */
6251 BOOL WINAPI DeletePrintProvidorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProviderName)
6252 {
6253 FIXME("%s %s %s\n", debugstr_a(pName), debugstr_a(pEnvironment),
6254 debugstr_a(pPrintProviderName));
6255 return TRUE;
6256 }
6257
6258 /******************************************************************************
6259 * DeletePrintProvidorW (WINSPOOL.@)
6260 */
6261 BOOL WINAPI DeletePrintProvidorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProviderName)
6262 {
6263 FIXME("%s %s %s\n", debugstr_w(pName), debugstr_w(pEnvironment),
6264 debugstr_w(pPrintProviderName));
6265 return TRUE;
6266 }
6267
6268 /******************************************************************************
6269 * EnumFormsA (WINSPOOL.@)
6270 */
6271 BOOL WINAPI EnumFormsA( HANDLE hPrinter, DWORD Level, LPBYTE pForm,
6272 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned )
6273 {
6274 FIXME("%p %x %p %x %p %p\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
6275 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6276 return FALSE;
6277 }
6278
6279 /******************************************************************************
6280 * EnumFormsW (WINSPOOL.@)
6281 */
6282 BOOL WINAPI EnumFormsW( HANDLE hPrinter, DWORD Level, LPBYTE pForm,
6283 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned )
6284 {
6285 FIXME("%p %x %p %x %p %p\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
6286 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6287 return FALSE;
6288 }
6289
6290 /*****************************************************************************
6291 * EnumMonitorsA [WINSPOOL.@]
6292 *
6293 * See EnumMonitorsW.
6294 *
6295 */
6296 BOOL WINAPI EnumMonitorsA(LPSTR pName, DWORD Level, LPBYTE pMonitors,
6297 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6298 {
6299 BOOL res;
6300 LPBYTE bufferW = NULL;
6301 LPWSTR nameW = NULL;
6302 DWORD needed = 0;
6303 DWORD numentries = 0;
6304 INT len;
6305
6306 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), Level, pMonitors,
6307 cbBuf, pcbNeeded, pcReturned);
6308
6309 /* convert servername to unicode */
6310 if (pName) {
6311 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6312 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6313 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6314 }
6315 /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the monitors */
6316 needed = cbBuf * sizeof(WCHAR);
6317 if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
6318 res = EnumMonitorsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
6319
6320 if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
6321 if (pcbNeeded) needed = *pcbNeeded;
6322 /* HeapReAlloc return NULL, when bufferW was NULL */
6323 bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
6324 HeapAlloc(GetProcessHeap(), 0, needed);
6325
6326 /* Try again with the large Buffer */
6327 res = EnumMonitorsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
6328 }
6329 numentries = pcReturned ? *pcReturned : 0;
6330 needed = 0;
6331 /*
6332 W2k require the buffersize from EnumMonitorsW also for EnumMonitorsA.
6333 We use the smaller Ansi-Size to avoid conflicts with fixed Buffers of old Apps.
6334 */
6335 if (res) {
6336 /* EnumMonitorsW collected all Data. Parse them to calculate ANSI-Size */
6337 DWORD entrysize = 0;
6338 DWORD index;
6339 LPSTR ptr;
6340 LPMONITOR_INFO_2W mi2w;
6341 LPMONITOR_INFO_2A mi2a;
6342
6343 /* MONITOR_INFO_*W and MONITOR_INFO_*A have the same size */
6344 entrysize = (Level == 1) ? sizeof(MONITOR_INFO_1A) : sizeof(MONITOR_INFO_2A);
6345
6346 /* First pass: calculate the size for all Entries */
6347 mi2w = (LPMONITOR_INFO_2W) bufferW;
6348 mi2a = (LPMONITOR_INFO_2A) pMonitors;
6349 index = 0;
6350 while (index < numentries) {
6351 index++;
6352 needed += entrysize; /* MONITOR_INFO_?A */
6353 TRACE("%p: parsing #%d (%s)\n", mi2w, index, debugstr_w(mi2w->pName));
6354
6355 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pName, -1,
6356 NULL, 0, NULL, NULL);
6357 if (Level > 1) {
6358 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pEnvironment, -1,
6359 NULL, 0, NULL, NULL);
6360 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pDLLName, -1,
6361 NULL, 0, NULL, NULL);
6362 }
6363 /* use LPBYTE with entrysize to avoid double code (MONITOR_INFO_1 + MONITOR_INFO_2) */
6364 mi2w = (LPMONITOR_INFO_2W) (((LPBYTE)mi2w) + entrysize);
6365 mi2a = (LPMONITOR_INFO_2A) (((LPBYTE)mi2a) + entrysize);
6366 }
6367
6368 /* check for errors and quit on failure */
6369 if (cbBuf < needed) {
6370 SetLastError(ERROR_INSUFFICIENT_BUFFER);
6371 res = FALSE;
6372 goto emA_cleanup;
6373 }
6374 len = entrysize * numentries; /* room for all MONITOR_INFO_?A */
6375 ptr = (LPSTR) &pMonitors[len]; /* room for strings */
6376 cbBuf -= len ; /* free Bytes in the user-Buffer */
6377 mi2w = (LPMONITOR_INFO_2W) bufferW;
6378 mi2a = (LPMONITOR_INFO_2A) pMonitors;
6379 index = 0;
6380 /* Second Pass: Fill the User Buffer (if we have one) */
6381 while ((index < numentries) && pMonitors) {
6382 index++;
6383 TRACE("%p: writing MONITOR_INFO_%dA #%d\n", mi2a, Level, index);
6384 mi2a->pName = ptr;
6385 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pName, -1,
6386 ptr, cbBuf , NULL, NULL);
6387 ptr += len;
6388 cbBuf -= len;
6389 if (Level > 1) {
6390 mi2a->pEnvironment = ptr;
6391 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pEnvironment, -1,
6392 ptr, cbBuf, NULL, NULL);
6393 ptr += len;
6394 cbBuf -= len;
6395
6396 mi2a->pDLLName = ptr;
6397 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pDLLName, -1,
6398 ptr, cbBuf, NULL, NULL);
6399 ptr += len;
6400 cbBuf -= len;
6401 }
6402 /* use LPBYTE with entrysize to avoid double code (MONITOR_INFO_1 + MONITOR_INFO_2) */
6403 mi2w = (LPMONITOR_INFO_2W) (((LPBYTE)mi2w) + entrysize);
6404 mi2a = (LPMONITOR_INFO_2A) (((LPBYTE)mi2a) + entrysize);
6405 }
6406 }
6407 emA_cleanup:
6408 if (pcbNeeded) *pcbNeeded = needed;
6409 if (pcReturned) *pcReturned = (res) ? numentries : 0;
6410
6411 HeapFree(GetProcessHeap(), 0, nameW);
6412 HeapFree(GetProcessHeap(), 0, bufferW);
6413
6414 TRACE("returning %d with %d (%d byte for %d entries)\n",
6415 (res), GetLastError(), needed, numentries);
6416
6417 return (res);
6418
6419 }
6420
6421 /*****************************************************************************
6422 * EnumMonitorsW [WINSPOOL.@]
6423 *
6424 * Enumerate available Port-Monitors
6425 *
6426 * PARAMS
6427 * pName [I] Servername or NULL (local Computer)
6428 * Level [I] Structure-Level (1:Win9x+NT or 2:NT only)
6429 * pMonitors [O] PTR to Buffer that receives the Result
6430 * cbBuf [I] Size of Buffer at pMonitors
6431 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
6432 * pcReturned [O] PTR to DWORD that receives the number of Monitors in pMonitors
6433 *
6434 * RETURNS
6435 * Success: TRUE
6436 * Failure: FALSE and in pcbNeeded the Bytes required for buffer, if cbBuf is too small
6437 *
6438 */
6439 BOOL WINAPI EnumMonitorsW(LPWSTR pName, DWORD Level, LPBYTE pMonitors,
6440 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6441 {
6442
6443 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pMonitors,
6444 cbBuf, pcbNeeded, pcReturned);
6445
6446 if ((backend == NULL) && !load_backend()) return FALSE;
6447
6448 if (!pcbNeeded || !pcReturned || (!pMonitors && (cbBuf > 0))) {
6449 SetLastError(RPC_X_NULL_REF_POINTER);
6450 return FALSE;
6451 }
6452
6453 return backend->fpEnumMonitors(pName, Level, pMonitors, cbBuf, pcbNeeded, pcReturned);
6454 }
6455
6456 /******************************************************************************
6457 * SpoolerInit (WINSPOOL.@)
6458 *
6459 * Initialize the Spooler
6460 *
6461 * RETURNS
6462 * Success: TRUE
6463 * Failure: FALSE
6464 *
6465 * NOTES
6466 * The function fails on windows, when the spooler service is not running
6467 *
6468 */
6469 BOOL WINAPI SpoolerInit(void)
6470 {
6471
6472 if ((backend == NULL) && !load_backend()) return FALSE;
6473 return TRUE;
6474 }
6475
6476 /******************************************************************************
6477 * XcvDataW (WINSPOOL.@)
6478 *
6479 * Execute commands in the Printmonitor DLL
6480 *
6481 * PARAMS
6482 * hXcv [i] Handle from OpenPrinter (with XcvMonitor or XcvPort)
6483 * pszDataName [i] Name of the command to execute
6484 * pInputData [i] Buffer for extra Input Data (needed only for some commands)
6485 * cbInputData [i] Size in Bytes of Buffer at pInputData
6486 * pOutputData [o] Buffer to receive additional Data (needed only for some commands)
6487 * cbOutputData [i] Size in Bytes of Buffer at pOutputData
6488 * pcbOutputNeeded [o] PTR to receive the minimal Size in Bytes of the Buffer at pOutputData
6489 * pdwStatus [o] PTR to receive the win32 error code from the Printmonitor DLL
6490 *
6491 * RETURNS
6492 * Success: TRUE
6493 * Failure: FALSE
6494 *
6495 * NOTES
6496 * Returning "TRUE" does mean, that the Printmonitor DLL was called successful.
6497 * The execution of the command can still fail (check pdwStatus for ERROR_SUCCESS).
6498 *
6499 * Minimal List of commands, that a Printmonitor DLL should support:
6500 *
6501 *| "MonitorUI" : Return the Name of the Userinterface-DLL as WSTR in pOutputData
6502 *| "AddPort" : Add a Port
6503 *| "DeletePort": Delete a Port
6504 *
6505 * Many Printmonitors support additional commands. Examples for localspl.dll:
6506 * "GetDefaultCommConfig", "SetDefaultCommConfig",
6507 * "GetTransmissionRetryTimeout", "ConfigureLPTPortCommandOK"
6508 *
6509 */
6510 BOOL WINAPI XcvDataW( HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData,
6511 DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData,
6512 PDWORD pcbOutputNeeded, PDWORD pdwStatus)
6513 {
6514 opened_printer_t *printer;
6515
6516 TRACE("(%p, %s, %p, %d, %p, %d, %p, %p)\n", hXcv, debugstr_w(pszDataName),
6517 pInputData, cbInputData, pOutputData,
6518 cbOutputData, pcbOutputNeeded, pdwStatus);
6519
6520 if ((backend == NULL) && !load_backend()) return FALSE;
6521
6522 printer = get_opened_printer(hXcv);
6523 if (!printer || (!printer->backend_printer)) {
6524 SetLastError(ERROR_INVALID_HANDLE);
6525 return FALSE;
6526 }
6527
6528 if (!pcbOutputNeeded) {
6529 SetLastError(ERROR_INVALID_PARAMETER);
6530 return FALSE;
6531 }
6532
6533 if (!pszDataName || !pdwStatus || (!pOutputData && (cbOutputData > 0))) {
6534 SetLastError(RPC_X_NULL_REF_POINTER);
6535 return FALSE;
6536 }
6537
6538 *pcbOutputNeeded = 0;
6539
6540 return backend->fpXcvData(printer->backend_printer, pszDataName, pInputData,
6541 cbInputData, pOutputData, cbOutputData, pcbOutputNeeded, pdwStatus);
6542
6543 }
6544
6545 /*****************************************************************************
6546 * EnumPrinterDataA [WINSPOOL.@]
6547 *
6548 */
6549 DWORD WINAPI EnumPrinterDataA( HANDLE hPrinter, DWORD dwIndex, LPSTR pValueName,
6550 DWORD cbValueName, LPDWORD pcbValueName, LPDWORD pType, LPBYTE pData,
6551 DWORD cbData, LPDWORD pcbData )
6552 {
6553 FIXME("%p %x %p %x %p %p %p %x %p\n", hPrinter, dwIndex, pValueName,
6554 cbValueName, pcbValueName, pType, pData, cbData, pcbData);
6555 return ERROR_NO_MORE_ITEMS;
6556 }
6557
6558 /*****************************************************************************
6559 * EnumPrinterDataW [WINSPOOL.@]
6560 *
6561 */
6562 DWORD WINAPI EnumPrinterDataW( HANDLE hPrinter, DWORD dwIndex, LPWSTR pValueName,
6563 DWORD cbValueName, LPDWORD pcbValueName, LPDWORD pType, LPBYTE pData,
6564 DWORD cbData, LPDWORD pcbData )
6565 {
6566 FIXME("%p %x %p %x %p %p %p %x %p\n", hPrinter, dwIndex, pValueName,
6567 cbValueName, pcbValueName, pType, pData, cbData, pcbData);
6568 return ERROR_NO_MORE_ITEMS;
6569 }
6570
6571 /*****************************************************************************
6572 * EnumPrintProcessorDatatypesA [WINSPOOL.@]
6573 *
6574 */
6575 BOOL WINAPI EnumPrintProcessorDatatypesA(LPSTR pName, LPSTR pPrintProcessorName,
6576 DWORD Level, LPBYTE pDatatypes, DWORD cbBuf,
6577 LPDWORD pcbNeeded, LPDWORD pcReturned)
6578 {
6579 FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_a(pName),
6580 debugstr_a(pPrintProcessorName), Level, pDatatypes, cbBuf,
6581 pcbNeeded, pcReturned);
6582 return FALSE;
6583 }
6584
6585 /*****************************************************************************
6586 * EnumPrintProcessorDatatypesW [WINSPOOL.@]
6587 *
6588 */
6589 BOOL WINAPI EnumPrintProcessorDatatypesW(LPWSTR pName, LPWSTR pPrintProcessorName,
6590 DWORD Level, LPBYTE pDatatypes, DWORD cbBuf,
6591 LPDWORD pcbNeeded, LPDWORD pcReturned)
6592 {
6593 FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_w(pName),
6594 debugstr_w(pPrintProcessorName), Level, pDatatypes, cbBuf,
6595 pcbNeeded, pcReturned);
6596 return FALSE;
6597 }
6598
6599 /*****************************************************************************
6600 * EnumPrintProcessorsA [WINSPOOL.@]
6601 *
6602 * See EnumPrintProcessorsW.
6603 *
6604 */
6605 BOOL WINAPI EnumPrintProcessorsA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
6606 LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6607 {
6608 BOOL res;
6609 LPBYTE bufferW = NULL;
6610 LPWSTR nameW = NULL;
6611 LPWSTR envW = NULL;
6612 DWORD needed = 0;
6613 DWORD numentries = 0;
6614 INT len;
6615
6616 TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), debugstr_a(pEnvironment),
6617 Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
6618
6619 /* convert names to unicode */
6620 if (pName) {
6621 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6622 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6623 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6624 }
6625 if (pEnvironment) {
6626 len = MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, NULL, 0);
6627 envW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6628 MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, envW, len);
6629 }
6630
6631 /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the monitors */
6632 needed = cbBuf * sizeof(WCHAR);
6633 if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
6634 res = EnumPrintProcessorsW(nameW, envW, Level, bufferW, needed, pcbNeeded, pcReturned);
6635
6636 if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
6637 if (pcbNeeded) needed = *pcbNeeded;
6638 /* HeapReAlloc return NULL, when bufferW was NULL */
6639 bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
6640 HeapAlloc(GetProcessHeap(), 0, needed);
6641
6642 /* Try again with the large Buffer */
6643 res = EnumPrintProcessorsW(nameW, envW, Level, bufferW, needed, pcbNeeded, pcReturned);
6644 }
6645 numentries = pcReturned ? *pcReturned : 0;
6646 needed = 0;
6647
6648 if (res) {
6649 /* EnumPrintProcessorsW collected all Data. Parse them to calculate ANSI-Size */
6650 DWORD index;
6651 LPSTR ptr;
6652 PPRINTPROCESSOR_INFO_1W ppiw;
6653 PPRINTPROCESSOR_INFO_1A ppia;
6654
6655 /* First pass: calculate the size for all Entries */
6656 ppiw = (PPRINTPROCESSOR_INFO_1W) bufferW;
6657 ppia = (PPRINTPROCESSOR_INFO_1A) pPPInfo;
6658 index = 0;
6659 while (index < numentries) {
6660 index++;
6661 needed += sizeof(PRINTPROCESSOR_INFO_1A);
6662 TRACE("%p: parsing #%d (%s)\n", ppiw, index, debugstr_w(ppiw->pName));
6663
6664 needed += WideCharToMultiByte(CP_ACP, 0, ppiw->pName, -1,
6665 NULL, 0, NULL, NULL);
6666
6667 ppiw = (PPRINTPROCESSOR_INFO_1W) (((LPBYTE)ppiw) + sizeof(PRINTPROCESSOR_INFO_1W));
6668 ppia = (PPRINTPROCESSOR_INFO_1A) (((LPBYTE)ppia) + sizeof(PRINTPROCESSOR_INFO_1A));
6669 }
6670
6671 /* check for errors and quit on failure */
6672 if (cbBuf < needed) {
6673 SetLastError(ERROR_INSUFFICIENT_BUFFER);
6674 res = FALSE;
6675 goto epp_cleanup;
6676 }
6677
6678 len = numentries * sizeof(PRINTPROCESSOR_INFO_1A); /* room for structs */
6679 ptr = (LPSTR) &pPPInfo[len]; /* start of strings */
6680 cbBuf -= len ; /* free Bytes in the user-Buffer */
6681 ppiw = (PPRINTPROCESSOR_INFO_1W) bufferW;
6682 ppia = (PPRINTPROCESSOR_INFO_1A) pPPInfo;
6683 index = 0;
6684 /* Second Pass: Fill the User Buffer (if we have one) */
6685 while ((index < numentries) && pPPInfo) {
6686 index++;
6687 TRACE("%p: writing PRINTPROCESSOR_INFO_1A #%d\n", ppia, index);
6688 ppia->pName = ptr;
6689 len = WideCharToMultiByte(CP_ACP, 0, ppiw->pName, -1,
6690 ptr, cbBuf , NULL, NULL);
6691 ptr += len;
6692 cbBuf -= len;
6693
6694 ppiw = (PPRINTPROCESSOR_INFO_1W) (((LPBYTE)ppiw) + sizeof(PRINTPROCESSOR_INFO_1W));
6695 ppia = (PPRINTPROCESSOR_INFO_1A) (((LPBYTE)ppia) + sizeof(PRINTPROCESSOR_INFO_1A));
6696
6697 }
6698 }
6699 epp_cleanup:
6700 if (pcbNeeded) *pcbNeeded = needed;
6701 if (pcReturned) *pcReturned = (res) ? numentries : 0;
6702
6703 HeapFree(GetProcessHeap(), 0, nameW);
6704 HeapFree(GetProcessHeap(), 0, envW);
6705 HeapFree(GetProcessHeap(), 0, bufferW);
6706
6707 TRACE("returning %d with %d (%d byte for %d entries)\n",
6708 (res), GetLastError(), needed, numentries);
6709
6710 return (res);
6711 }
6712
6713 /*****************************************************************************
6714 * EnumPrintProcessorsW [WINSPOOL.@]
6715 *
6716 * Enumerate available Print Processors
6717 *
6718 * PARAMS
6719 * pName [I] Servername or NULL (local Computer)
6720 * pEnvironment [I] Printing-Environment or NULL (Default)
6721 * Level [I] Structure-Level (Only 1 is allowed)
6722 * pPPInfo [O] PTR to Buffer that receives the Result
6723 * cbBuf [I] Size of Buffer at pPPInfo
6724 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
6725 * pcReturned [O] PTR to DWORD that receives the number of Print Processors in pPPInfo
6726 *
6727 * RETURNS
6728 * Success: TRUE
6729 * Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
6730 *
6731 */
6732 BOOL WINAPI EnumPrintProcessorsW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
6733 LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6734 {
6735
6736 TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
6737 Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
6738
6739 if ((backend == NULL) && !load_backend()) return FALSE;
6740
6741 if (!pcbNeeded || !pcReturned) {
6742 SetLastError(RPC_X_NULL_REF_POINTER);
6743 return FALSE;
6744 }
6745
6746 if (!pPPInfo && (cbBuf > 0)) {
6747 SetLastError(ERROR_INVALID_USER_BUFFER);
6748 return FALSE;
6749 }
6750
6751 return backend->fpEnumPrintProcessors(pName, pEnvironment, Level, pPPInfo,
6752 cbBuf, pcbNeeded, pcReturned);
6753 }
6754
6755 /*****************************************************************************
6756 * ExtDeviceMode [WINSPOOL.@]
6757 *
6758 */
6759 LONG WINAPI ExtDeviceMode( HWND hWnd, HANDLE hInst, LPDEVMODEA pDevModeOutput,
6760 LPSTR pDeviceName, LPSTR pPort, LPDEVMODEA pDevModeInput, LPSTR pProfile,
6761 DWORD fMode)
6762 {
6763 FIXME("Stub: %p %p %p %s %s %p %s %x\n", hWnd, hInst, pDevModeOutput,
6764 debugstr_a(pDeviceName), debugstr_a(pPort), pDevModeInput,
6765 debugstr_a(pProfile), fMode);
6766 return -1;
6767 }
6768
6769 /*****************************************************************************
6770 * FindClosePrinterChangeNotification [WINSPOOL.@]
6771 *
6772 */
6773 BOOL WINAPI FindClosePrinterChangeNotification( HANDLE hChange )
6774 {
6775 FIXME("Stub: %p\n", hChange);
6776 return TRUE;
6777 }
6778
6779 /*****************************************************************************
6780 * FindFirstPrinterChangeNotification [WINSPOOL.@]
6781 *
6782 */
6783 HANDLE WINAPI FindFirstPrinterChangeNotification( HANDLE hPrinter,
6784 DWORD fdwFlags, DWORD fdwOptions, LPVOID pPrinterNotifyOptions )
6785 {
6786 FIXME("Stub: %p %x %x %p\n",
6787 hPrinter, fdwFlags, fdwOptions, pPrinterNotifyOptions);
6788 return INVALID_HANDLE_VALUE;
6789 }
6790
6791 /*****************************************************************************
6792 * FindNextPrinterChangeNotification [WINSPOOL.@]
6793 *
6794 */
6795 BOOL WINAPI FindNextPrinterChangeNotification( HANDLE hChange, PDWORD pdwChange,
6796 LPVOID pPrinterNotifyOptions, LPVOID *ppPrinterNotifyInfo )
6797 {
6798 FIXME("Stub: %p %p %p %p\n",
6799 hChange, pdwChange, pPrinterNotifyOptions, ppPrinterNotifyInfo);
6800 return FALSE;
6801 }
6802
6803 /*****************************************************************************
6804 * FreePrinterNotifyInfo [WINSPOOL.@]
6805 *
6806 */
6807 BOOL WINAPI FreePrinterNotifyInfo( PPRINTER_NOTIFY_INFO pPrinterNotifyInfo )
6808 {
6809 FIXME("Stub: %p\n", pPrinterNotifyInfo);
6810 return TRUE;
6811 }
6812
6813 /*****************************************************************************
6814 * string_to_buf
6815 *
6816 * Copies a unicode string into a buffer. The buffer will either contain unicode or
6817 * ansi depending on the unicode parameter.
6818 */
6819 static BOOL string_to_buf(LPCWSTR str, LPBYTE ptr, DWORD cb, DWORD *size, BOOL unicode)
6820 {
6821 if(!str)
6822 {
6823 *size = 0;
6824 return TRUE;
6825 }
6826
6827 if(unicode)
6828 {
6829 *size = (strlenW(str) + 1) * sizeof(WCHAR);
6830 if(*size <= cb)
6831 {
6832 memcpy(ptr, str, *size);
6833 return TRUE;
6834 }
6835 return FALSE;
6836 }
6837 else
6838 {
6839 *size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
6840 if(*size <= cb)
6841 {
6842 WideCharToMultiByte(CP_ACP, 0, str, -1, (LPSTR)ptr, *size, NULL, NULL);
6843 return TRUE;
6844 }
6845 return FALSE;
6846 }
6847 }
6848
6849 /*****************************************************************************
6850 * get_job_info_1
6851 */
6852 static BOOL get_job_info_1(job_t *job, JOB_INFO_1W *ji1, LPBYTE buf, DWORD cbBuf,
6853 LPDWORD pcbNeeded, BOOL unicode)
6854 {
6855 DWORD size, left = cbBuf;
6856 BOOL space = (cbBuf > 0);
6857 LPBYTE ptr = buf;
6858
6859 *pcbNeeded = 0;
6860
6861 if(space)
6862 {
6863 ji1->JobId = job->job_id;
6864 }
6865
6866 string_to_buf(job->document_title, ptr, left, &size, unicode);
6867 if(space && size <= left)
6868 {
6869 ji1->pDocument = (LPWSTR)ptr;
6870 ptr += size;
6871 left -= size;
6872 }
6873 else
6874 space = FALSE;
6875 *pcbNeeded += size;
6876
6877 return space;
6878 }
6879
6880 /*****************************************************************************
6881 * get_job_info_2
6882 */
6883 static BOOL get_job_info_2(job_t *job, JOB_INFO_2W *ji2, LPBYTE buf, DWORD cbBuf,
6884 LPDWORD pcbNeeded, BOOL unicode)
6885 {
6886 DWORD size, left = cbBuf;
6887 BOOL space = (cbBuf > 0);
6888 LPBYTE ptr = buf;
6889
6890 *pcbNeeded = 0;
6891
6892 if(space)
6893 {
6894 ji2->JobId = job->job_id;
6895 }
6896
6897 string_to_buf(job->document_title, ptr, left, &size, unicode);
6898 if(space && size <= left)
6899 {
6900 ji2->pDocument = (LPWSTR)ptr;
6901 ptr += size;
6902 left -= size;
6903 }
6904 else
6905 space = FALSE;
6906 *pcbNeeded += size;
6907
6908 return space;
6909 }
6910
6911 /*****************************************************************************
6912 * get_job_info
6913 */
6914 static BOOL get_job_info(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
6915 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
6916 {
6917 BOOL ret = FALSE;
6918 DWORD needed = 0, size;
6919 job_t *job;
6920 LPBYTE ptr = pJob;
6921
6922 TRACE("%p %d %d %p %d %p\n", hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded);
6923
6924 EnterCriticalSection(&printer_handles_cs);
6925 job = get_job(hPrinter, JobId);
6926 if(!job)
6927 goto end;
6928
6929 switch(Level)
6930 {
6931 case 1:
6932 size = sizeof(JOB_INFO_1W);
6933 if(cbBuf >= size)
6934 {
6935 cbBuf -= size;
6936 ptr += size;
6937 memset(pJob, 0, size);
6938 }
6939 else
6940 cbBuf = 0;
6941 ret = get_job_info_1(job, (JOB_INFO_1W *)pJob, ptr, cbBuf, &needed, unicode);
6942 needed += size;
6943 break;
6944
6945 case 2:
6946 size = sizeof(JOB_INFO_2W);
6947 if(cbBuf >= size)
6948 {
6949 cbBuf -= size;
6950 ptr += size;
6951 memset(pJob, 0, size);
6952 }
6953 else
6954 cbBuf = 0;
6955 ret = get_job_info_2(job, (JOB_INFO_2W *)pJob, ptr, cbBuf, &needed, unicode);
6956 needed += size;
6957 break;
6958
6959 case 3:
6960 size = sizeof(JOB_INFO_3);
6961 if(cbBuf >= size)
6962 {
6963 cbBuf -= size;
6964 memset(pJob, 0, size);
6965 ret = TRUE;
6966 }
6967 else
6968 cbBuf = 0;
6969 needed = size;
6970 break;
6971
6972 default:
6973 SetLastError(ERROR_INVALID_LEVEL);
6974 goto end;
6975 }
6976 if(pcbNeeded)
6977 *pcbNeeded = needed;
6978 end:
6979 LeaveCriticalSection(&printer_handles_cs);
6980 return ret;
6981 }
6982
6983 /*****************************************************************************
6984 * GetJobA [WINSPOOL.@]
6985 *
6986 */
6987 BOOL WINAPI GetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
6988 DWORD cbBuf, LPDWORD pcbNeeded)
6989 {
6990 return get_job_info(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded, FALSE);
6991 }
6992
6993 /*****************************************************************************
6994 * GetJobW [WINSPOOL.@]
6995 *
6996 */
6997 BOOL WINAPI GetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
6998 DWORD cbBuf, LPDWORD pcbNeeded)
6999 {
7000 return get_job_info(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded, TRUE);
7001 }
7002
7003 /*****************************************************************************
7004 * schedule_lpr
7005 */
7006 static BOOL schedule_lpr(LPCWSTR printer_name, LPCWSTR filename)
7007 {
7008 char *unixname, *queue, *cmd;
7009 char fmt[] = "lpr -P%s %s";
7010 DWORD len;
7011 int r;
7012
7013 if(!(unixname = wine_get_unix_file_name(filename)))
7014 return FALSE;
7015
7016 len = WideCharToMultiByte(CP_ACP, 0, printer_name, -1, NULL, 0, NULL, NULL);
7017 queue = HeapAlloc(GetProcessHeap(), 0, len);
7018 WideCharToMultiByte(CP_ACP, 0, printer_name, -1, queue, len, NULL, NULL);
7019
7020 cmd = HeapAlloc(GetProcessHeap(), 0, strlen(unixname) + len + sizeof(fmt) - 5);
7021 sprintf(cmd, fmt, queue, unixname);
7022
7023 TRACE("printing with: %s\n", cmd);
7024 r = system(cmd);
7025
7026 HeapFree(GetProcessHeap(), 0, cmd);
7027 HeapFree(GetProcessHeap(), 0, queue);
7028 HeapFree(GetProcessHeap(), 0, unixname);
7029 return (r == 0);
7030 }
7031
7032 /*****************************************************************************
7033 * schedule_cups
7034 */
7035 static BOOL schedule_cups(LPCWSTR printer_name, LPCWSTR filename, LPCWSTR document_title)
7036 {
7037 #ifdef SONAME_LIBCUPS
7038 if(pcupsPrintFile)
7039 {
7040 char *unixname, *queue, *unix_doc_title;
7041 DWORD len;
7042 BOOL ret;
7043
7044 if(!(unixname = wine_get_unix_file_name(filename)))
7045 return FALSE;
7046
7047 len = WideCharToMultiByte(CP_UNIXCP, 0, printer_name, -1, NULL, 0, NULL, NULL);
7048 queue = HeapAlloc(GetProcessHeap(), 0, len);
7049 WideCharToMultiByte(CP_UNIXCP, 0, printer_name, -1, queue, len, NULL, NULL);
7050
7051 len = WideCharToMultiByte(CP_UNIXCP, 0, document_title, -1, NULL, 0, NULL, NULL);
7052 unix_doc_title = HeapAlloc(GetProcessHeap(), 0, len);
7053 WideCharToMultiByte(CP_UNIXCP, 0, document_title, -1, unix_doc_title, len, NULL, NULL);
7054
7055 TRACE("printing via cups\n");
7056 ret = pcupsPrintFile(queue, unixname, unix_doc_title, 0, NULL);
7057 HeapFree(GetProcessHeap(), 0, unix_doc_title);
7058 HeapFree(GetProcessHeap(), 0, queue);
7059 HeapFree(GetProcessHeap(), 0, unixname);
7060 return ret;
7061 }
7062 else
7063 #endif
7064 {
7065 return schedule_lpr(printer_name, filename);
7066 }
7067 }
7068
7069 static INT_PTR CALLBACK file_dlg_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
7070 {
7071 LPWSTR filename;
7072
7073 switch(msg)
7074 {
7075 case WM_INITDIALOG:
7076 SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
7077 return TRUE;
7078
7079 case WM_COMMAND:
7080 if(HIWORD(wparam) == BN_CLICKED)
7081 {
7082 if(LOWORD(wparam) == IDOK)
7083 {
7084 HANDLE hf;
7085 DWORD len = SendDlgItemMessageW(hwnd, EDITBOX, WM_GETTEXTLENGTH, 0, 0);
7086 LPWSTR *output;
7087
7088 filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
7089 GetDlgItemTextW(hwnd, EDITBOX, filename, len + 1);
7090
7091 if(GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
7092 {
7093 WCHAR caption[200], message[200];
7094 int mb_ret;
7095
7096 LoadStringW(WINSPOOL_hInstance, IDS_CAPTION, caption, sizeof(caption) / sizeof(WCHAR));
7097 LoadStringW(WINSPOOL_hInstance, IDS_FILE_EXISTS, message, sizeof(message) / sizeof(WCHAR));
7098 mb_ret = MessageBoxW(hwnd, message, caption, MB_OKCANCEL | MB_ICONEXCLAMATION);
7099 if(mb_ret == IDCANCEL)
7100 {
7101 HeapFree(GetProcessHeap(), 0, filename);
7102 return TRUE;
7103 }
7104 }
7105 hf = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
7106 if(hf == INVALID_HANDLE_VALUE)
7107 {
7108 WCHAR caption[200], message[200];
7109
7110 LoadStringW(WINSPOOL_hInstance, IDS_CAPTION, caption, sizeof(caption) / sizeof(WCHAR));
7111 LoadStringW(WINSPOOL_hInstance, IDS_CANNOT_OPEN, message, sizeof(message) / sizeof(WCHAR));
7112 MessageBoxW(hwnd, message, caption, MB_OK | MB_ICONEXCLAMATION);
7113 HeapFree(GetProcessHeap(), 0, filename);
7114 return TRUE;
7115 }
7116 CloseHandle(hf);
7117 DeleteFileW(filename);
7118 output = (LPWSTR *)GetWindowLongPtrW(hwnd, DWLP_USER);
7119 *output = filename;
7120 EndDialog(hwnd, IDOK);
7121 return TRUE;
7122 }
7123 if(LOWORD(wparam) == IDCANCEL)
7124 {
7125 EndDialog(hwnd, IDCANCEL);
7126 return TRUE;
7127 }
7128 }
7129 return FALSE;
7130 }
7131 return FALSE;
7132 }
7133
7134 /*****************************************************************************
7135 * get_filename
7136 */
7137 static BOOL get_filename(LPWSTR *filename)
7138 {
7139 return DialogBoxParamW(WINSPOOL_hInstance, MAKEINTRESOURCEW(FILENAME_DIALOG), GetForegroundWindow(),
7140 file_dlg_proc, (LPARAM)filename) == IDOK;
7141 }
7142
7143 /*****************************************************************************
7144 * schedule_file
7145 */
7146 static BOOL schedule_file(LPCWSTR filename)
7147 {
7148 LPWSTR output = NULL;
7149
7150 if(get_filename(&output))
7151 {
7152 BOOL r;
7153 TRACE("copy to %s\n", debugstr_w(output));
7154 r = CopyFileW(filename, output, FALSE);
7155 HeapFree(GetProcessHeap(), 0, output);
7156 return r;
7157 }
7158 return FALSE;
7159 }
7160
7161 /*****************************************************************************
7162 * schedule_pipe
7163 */
7164 static BOOL schedule_pipe(LPCWSTR cmd, LPCWSTR filename)
7165 {
7166 #ifdef HAVE_FORK
7167 char *unixname, *cmdA;
7168 DWORD len;
7169 int fds[2] = {-1, -1}, file_fd = -1, no_read;
7170 BOOL ret = FALSE;
7171 char buf[1024];
7172
7173 if(!(unixname = wine_get_unix_file_name(filename)))
7174 return FALSE;
7175
7176 len = WideCharToMultiByte(CP_UNIXCP, 0, cmd, -1, NULL, 0, NULL, NULL);
7177 cmdA = HeapAlloc(GetProcessHeap(), 0, len);
7178 WideCharToMultiByte(CP_UNIXCP, 0, cmd, -1, cmdA, len, NULL, NULL);
7179
7180 TRACE("printing with: %s\n", cmdA);
7181
7182 if((file_fd = open(unixname, O_RDONLY)) == -1)
7183 goto end;
7184
7185 if (pipe(fds))
7186 {
7187 ERR("pipe() failed!\n");
7188 goto end;
7189 }
7190
7191 if (fork() == 0)
7192 {
7193 close(0);
7194 dup2(fds[0], 0);
7195 close(fds[1]);
7196
7197 /* reset signals that we previously set to SIG_IGN */
7198 signal(SIGPIPE, SIG_DFL);
7199 signal(SIGCHLD, SIG_DFL);
7200
7201 execl("/bin/sh", "/bin/sh", "-c", cmdA, NULL);
7202 _exit(1);
7203 }
7204
7205 while((no_read = read(file_fd, buf, sizeof(buf))) > 0)
7206 write(fds[1], buf, no_read);
7207
7208 ret = TRUE;
7209
7210 end:
7211 if(file_fd != -1) close(file_fd);
7212 if(fds[0] != -1) close(fds[0]);
7213 if(fds[1] != -1) close(fds[1]);
7214
7215 HeapFree(GetProcessHeap(), 0, cmdA);
7216 HeapFree(GetProcessHeap(), 0, unixname);
7217 return ret;
7218 #else
7219 return FALSE;
7220 #endif
7221 }
7222
7223 /*****************************************************************************
7224 * schedule_unixfile
7225 */
7226 static BOOL schedule_unixfile(LPCWSTR output, LPCWSTR filename)
7227 {
7228 int in_fd, out_fd, no_read;
7229 char buf[1024];
7230 BOOL ret = FALSE;
7231 char *unixname, *outputA;
7232 DWORD len;
7233
7234 if(!(unixname = wine_get_unix_file_name(filename)))
7235 return FALSE;
7236
7237 len = WideCharToMultiByte(CP_UNIXCP, 0, output, -1, NULL, 0, NULL, NULL);
7238 outputA = HeapAlloc(GetProcessHeap(), 0, len);
7239 WideCharToMultiByte(CP_UNIXCP, 0, output, -1, outputA, len, NULL, NULL);
7240
7241 out_fd = open(outputA, O_CREAT | O_TRUNC | O_WRONLY, 0666);
7242 in_fd = open(unixname, O_RDONLY);
7243 if(out_fd == -1 || in_fd == -1)
7244 goto end;
7245
7246 while((no_read = read(in_fd, buf, sizeof(buf))) > 0)
7247 write(out_fd, buf, no_read);
7248
7249 ret = TRUE;
7250 end:
7251 if(in_fd != -1) close(in_fd);
7252 if(out_fd != -1) close(out_fd);
7253 HeapFree(GetProcessHeap(), 0, outputA);
7254 HeapFree(GetProcessHeap(), 0, unixname);
7255 return ret;
7256 }
7257
7258 /*****************************************************************************
7259 * ScheduleJob [WINSPOOL.@]
7260 *
7261 */
7262 BOOL WINAPI ScheduleJob( HANDLE hPrinter, DWORD dwJobID )
7263 {
7264 opened_printer_t *printer;
7265 BOOL ret = FALSE;
7266 struct list *cursor, *cursor2;
7267
7268 TRACE("(%p, %x)\n", hPrinter, dwJobID);
7269 EnterCriticalSection(&printer_handles_cs);
7270 printer = get_opened_printer(hPrinter);
7271 if(!printer)
7272 goto end;
7273
7274 LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
7275 {
7276 job_t *job = LIST_ENTRY(cursor, job_t, entry);
7277 HANDLE hf;
7278
7279 if(job->job_id != dwJobID) continue;
7280
7281 hf = CreateFileW(job->filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
7282 if(hf != INVALID_HANDLE_VALUE)
7283 {
7284 PRINTER_INFO_5W *pi5;
7285 DWORD needed;
7286 HKEY hkey;
7287 WCHAR output[1024];
7288 static const WCHAR spooler_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
7289 'P','r','i','n','t','i','n','g','\\','S','p','o','o','l','e','r',0};
7290
7291 GetPrinterW(hPrinter, 5, NULL, 0, &needed);
7292 pi5 = HeapAlloc(GetProcessHeap(), 0, needed);
7293 GetPrinterW(hPrinter, 5, (LPBYTE)pi5, needed, &needed);
7294 TRACE("need to schedule job %d filename %s to port %s\n", job->job_id, debugstr_w(job->filename),
7295 debugstr_w(pi5->pPortName));
7296
7297 output[0] = 0;
7298
7299 /* @@ Wine registry key: HKCU\Software\Wine\Printing\Spooler */
7300 if(RegOpenKeyW(HKEY_CURRENT_USER, spooler_key, &hkey) == ERROR_SUCCESS)
7301 {
7302 DWORD type, count = sizeof(output);
7303 RegQueryValueExW(hkey, pi5->pPortName, NULL, &type, (LPBYTE)output, &count);
7304 RegCloseKey(hkey);
7305 }
7306 if(output[0] == '|')
7307 {
7308 ret = schedule_pipe(output + 1, job->filename);
7309 }
7310 else if(output[0])
7311 {
7312 ret = schedule_unixfile(output, job->filename);
7313 }
7314 else if(!strncmpW(pi5->pPortName, LPR_Port, strlenW(LPR_Port)))
7315 {
7316 ret = schedule_lpr(pi5->pPortName + strlenW(LPR_Port), job->filename);
7317 }
7318 else if(!strncmpW(pi5->pPortName, CUPS_Port, strlenW(CUPS_Port)))
7319 {
7320 ret = schedule_cups(pi5->pPortName + strlenW(CUPS_Port), job->filename, job->document_title);
7321 }
7322 else if(!strncmpW(pi5->pPortName, FILE_Port, strlenW(FILE_Port)))
7323 {
7324 ret = schedule_file(job->filename);
7325 }
7326 else
7327 {
7328 FIXME("can't schedule to port %s\n", debugstr_w(pi5->pPortName));
7329 }
7330 HeapFree(GetProcessHeap(), 0, pi5);
7331 CloseHandle(hf);
7332 DeleteFileW(job->filename);
7333 }
7334 list_remove(cursor);
7335 HeapFree(GetProcessHeap(), 0, job->document_title);
7336 HeapFree(GetProcessHeap(), 0, job->filename);
7337 HeapFree(GetProcessHeap(), 0, job);
7338 break;
7339 }
7340 end:
7341 LeaveCriticalSection(&printer_handles_cs);
7342 return ret;
7343 }
7344
7345 /*****************************************************************************
7346 * StartDocDlgA [WINSPOOL.@]
7347 */
7348 LPSTR WINAPI StartDocDlgA( HANDLE hPrinter, DOCINFOA *doc )
7349 {
7350 UNICODE_STRING usBuffer;
7351 DOCINFOW docW;
7352 LPWSTR retW;
7353 LPWSTR docnameW = NULL, outputW = NULL, datatypeW = NULL;
7354 LPSTR ret = NULL;
7355
7356 docW.cbSize = sizeof(docW);
7357 if (doc->lpszDocName)
7358 {
7359 docnameW = asciitounicode(&usBuffer, doc->lpszDocName);
7360 if (!(docW.lpszDocName = docnameW)) return NULL;
7361 }
7362 if (doc->lpszOutput)
7363 {
7364 outputW = asciitounicode(&usBuffer, doc->lpszOutput);
7365 if (!(docW.lpszOutput = outputW)) return NULL;
7366 }
7367 if (doc->lpszDatatype)
7368 {
7369 datatypeW = asciitounicode(&usBuffer, doc->lpszDatatype);
7370 if (!(docW.lpszDatatype = datatypeW)) return NULL;
7371 }
7372 docW.fwType = doc->fwType;
7373
7374 retW = StartDocDlgW(hPrinter, &docW);
7375
7376 if(retW)
7377 {
7378 DWORD len = WideCharToMultiByte(CP_ACP, 0, retW, -1, NULL, 0, NULL, NULL);
7379 ret = HeapAlloc(GetProcessHeap(), 0, len);
7380 WideCharToMultiByte(CP_ACP, 0, retW, -1, ret, len, NULL, NULL);
7381 HeapFree(GetProcessHeap(), 0, retW);
7382 }
7383
7384 HeapFree(GetProcessHeap(), 0, datatypeW);
7385 HeapFree(GetProcessHeap(), 0, outputW);
7386 HeapFree(GetProcessHeap(), 0, docnameW);
7387
7388 return ret;
7389 }
7390
7391 /*****************************************************************************
7392 * StartDocDlgW [WINSPOOL.@]
7393 *
7394 * Undocumented: Apparently used by gdi32:StartDocW() to popup the file dialog
7395 * when lpszOutput is "FILE:" or if lpszOutput is NULL and the default printer
7396 * port is "FILE:". Also returns the full path if passed a relative path.
7397 *
7398 * The caller should free the returned string from the process heap.
7399 */
7400 LPWSTR WINAPI StartDocDlgW( HANDLE hPrinter, DOCINFOW *doc )
7401 {
7402 LPWSTR ret = NULL;
7403 DWORD len, attr;
7404
7405 if(doc->lpszOutput == NULL) /* Check whether default port is FILE: */
7406 {
7407 PRINTER_INFO_5W *pi5;
7408 GetPrinterW(hPrinter, 5, NULL, 0, &len);
7409 if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
7410 return NULL;
7411 pi5 = HeapAlloc(GetProcessHeap(), 0, len);
7412 GetPrinterW(hPrinter, 5, (LPBYTE)pi5, len, &len);
7413 if(!pi5->pPortName || strcmpW(pi5->pPortName, FILE_Port))
7414 {
7415 HeapFree(GetProcessHeap(), 0, pi5);
7416 return NULL;
7417 }
7418 HeapFree(GetProcessHeap(), 0, pi5);
7419 }
7420
7421 if(doc->lpszOutput == NULL || !strcmpW(doc->lpszOutput, FILE_Port))
7422 {
7423 LPWSTR name;
7424
7425 if (get_filename(&name))
7426 {
7427 if(!(len = GetFullPathNameW(name, 0, NULL, NULL)))
7428 {
7429 HeapFree(GetProcessHeap(), 0, name);
7430 return NULL;
7431 }
7432 ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
7433 GetFullPathNameW(name, len, ret, NULL);
7434 HeapFree(GetProcessHeap(), 0, name);
7435 }
7436 return ret;
7437 }
7438
7439 if(!(len = GetFullPathNameW(doc->lpszOutput, 0, NULL, NULL)))
7440 return NULL;
7441
7442 ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
7443 GetFullPathNameW(doc->lpszOutput, len, ret, NULL);
7444
7445 attr = GetFileAttributesW(ret);
7446 if(attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
7447 {
7448 HeapFree(GetProcessHeap(), 0, ret);
7449 ret = NULL;
7450 }
7451 return ret;
7452 }
Windows API implementation