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