?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Changes from running autconf after previous patch.
[wine/hacks.git] / dlls / winspool.drv / info.c
blob885b8df0b563b5c074cbfeeab68abf875801bfb2
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 if (cbBuf > 0)
4392 ZeroMemory(pDriverInfo, cbBuf);
4393
4394 if (!(name = get_opened_printer_name(hPrinter))) {
4395 SetLastError(ERROR_INVALID_HANDLE);
4396 return FALSE;
4397 }
4398
4399 if (Level < 1 || Level == 7 || Level > 8) {
4400 SetLastError(ERROR_INVALID_LEVEL);
4401 return FALSE;
4402 }
4403
4404 env = validate_envW(pEnvironment);
4405 if (!env) return FALSE; /* SetLastError() is in validate_envW */
4406
4407 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters) !=
4408 ERROR_SUCCESS) {
4409 ERR("Can't create Printers key\n");
4410 return FALSE;
4411 }
4412 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter)
4413 != ERROR_SUCCESS) {
4414 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
4415 RegCloseKey(hkeyPrinters);
4416 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
4417 return FALSE;
4418 }
4419 size = sizeof(DriverName);
4420 DriverName[0] = 0;
4421 ret = RegQueryValueExW(hkeyPrinter, Printer_DriverW, 0, &type,
4422 (LPBYTE)DriverName, &size);
4423 RegCloseKey(hkeyPrinter);
4424 RegCloseKey(hkeyPrinters);
4425 if(ret != ERROR_SUCCESS) {
4426 ERR("Can't get DriverName for printer %s\n", debugstr_w(name));
4427 return FALSE;
4428 }
4429
4430 hkeyDrivers = WINSPOOL_OpenDriverReg(pEnvironment);
4431 if(!hkeyDrivers) {
4432 ERR("Can't create Drivers key\n");
4433 return FALSE;
4434 }
4435
4436 size = di_sizeof[Level];
4437 if ((size <= cbBuf) && pDriverInfo)
4438 ptr = pDriverInfo + size;
4439
4440 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverName,
4441 env, Level, pDriverInfo, ptr,
4442 (cbBuf < size) ? 0 : cbBuf - size,
4443 &needed)) {
4444 RegCloseKey(hkeyDrivers);
4445 return FALSE;
4446 }
4447
4448 RegCloseKey(hkeyDrivers);
4449
4450 if(pcbNeeded) *pcbNeeded = size + needed;
4451 TRACE("buffer space %d required %d\n", cbBuf, size + needed);
4452 if(cbBuf >= size + needed) return TRUE;
4453 SetLastError(ERROR_INSUFFICIENT_BUFFER);
4454 return FALSE;
4455 }
4456
4457 /*****************************************************************************
4458 * GetPrinterDriverA [WINSPOOL.@]
4459 */
4460 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
4461 DWORD Level, LPBYTE pDriverInfo,
4462 DWORD cbBuf, LPDWORD pcbNeeded)
4463 {
4464 BOOL ret;
4465 UNICODE_STRING pEnvW;
4466 PWSTR pwstrEnvW;
4467 LPBYTE buf = NULL;
4468
4469 if (cbBuf)
4470 {
4471 ZeroMemory(pDriverInfo, cbBuf);
4472 buf = HeapAlloc(GetProcessHeap(), 0, cbBuf);
4473 }
4474
4475 pwstrEnvW = asciitounicode(&pEnvW, pEnvironment);
4476 ret = GetPrinterDriverW(hPrinter, pwstrEnvW, Level, buf,
4477 cbBuf, pcbNeeded);
4478 if (ret)
4479 convert_driverinfo_W_to_A(pDriverInfo, buf, Level, cbBuf, 1);
4480
4481 HeapFree(GetProcessHeap(), 0, buf);
4482
4483 RtlFreeUnicodeString(&pEnvW);
4484 return ret;
4485 }
4486
4487 /*****************************************************************************
4488 * GetPrinterDriverDirectoryW [WINSPOOL.@]
4489 *
4490 * Return the PATH for the Printer-Drivers (UNICODE)
4491 *
4492 * PARAMS
4493 * pName [I] Servername (NT only) or NULL (local Computer)
4494 * pEnvironment [I] Printing-Environment (see below) or NULL (Default)
4495 * Level [I] Structure-Level (must be 1)
4496 * pDriverDirectory [O] PTR to Buffer that receives the Result
4497 * cbBuf [I] Size of Buffer at pDriverDirectory
4498 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used /
4499 * required for pDriverDirectory
4500 *
4501 * RETURNS
4502 * Success: TRUE and in pcbNeeded the Bytes used in pDriverDirectory
4503 * Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
4504 * if cbBuf is too small
4505 *
4506 * Native Values returned in pDriverDirectory on Success:
4507 *| NT(Windows NT x86): "%winsysdir%\\spool\\DRIVERS\\w32x86"
4508 *| NT(Windows 4.0): "%winsysdir%\\spool\\DRIVERS\\win40"
4509 *| win9x(Windows 4.0): "%winsysdir%"
4510 *
4511 * "%winsysdir%" is the Value from GetSystemDirectoryW()
4512 *
4513 * FIXME
4514 *- Only NULL or "" is supported for pName
4515 *
4516 */
4517 BOOL WINAPI GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment,
4518 DWORD Level, LPBYTE pDriverDirectory,
4519 DWORD cbBuf, LPDWORD pcbNeeded)
4520 {
4521 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName),
4522 debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
4523
4524 if ((backend == NULL) && !load_backend()) return FALSE;
4525
4526 if (Level != 1) {
4527 /* (Level != 1) is ignored in win9x */
4528 SetLastError(ERROR_INVALID_LEVEL);
4529 return FALSE;
4530 }
4531 if (pcbNeeded == NULL) {
4532 /* (pcbNeeded == NULL) is ignored in win9x */
4533 SetLastError(RPC_X_NULL_REF_POINTER);
4534 return FALSE;
4535 }
4536
4537 return backend->fpGetPrinterDriverDirectory(pName, pEnvironment, Level,
4538 pDriverDirectory, cbBuf, pcbNeeded);
4539
4540 }
4541
4542
4543 /*****************************************************************************
4544 * GetPrinterDriverDirectoryA [WINSPOOL.@]
4545 *
4546 * Return the PATH for the Printer-Drivers (ANSI)
4547 *
4548 * See GetPrinterDriverDirectoryW.
4549 *
4550 * NOTES
4551 * On NT, pDriverDirectory need the same Size as the Unicode-Version
4552 *
4553 */
4554 BOOL WINAPI GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment,
4555 DWORD Level, LPBYTE pDriverDirectory,
4556 DWORD cbBuf, LPDWORD pcbNeeded)
4557 {
4558 UNICODE_STRING nameW, environmentW;
4559 BOOL ret;
4560 DWORD pcbNeededW;
4561 INT len = cbBuf * sizeof(WCHAR)/sizeof(CHAR);
4562 WCHAR *driverDirectoryW = NULL;
4563
4564 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_a(pName),
4565 debugstr_a(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
4566
4567 if (len) driverDirectoryW = HeapAlloc( GetProcessHeap(), 0, len );
4568
4569 if(pName) RtlCreateUnicodeStringFromAsciiz(&nameW, pName);
4570 else nameW.Buffer = NULL;
4571 if(pEnvironment) RtlCreateUnicodeStringFromAsciiz(&environmentW, pEnvironment);
4572 else environmentW.Buffer = NULL;
4573
4574 ret = GetPrinterDriverDirectoryW( nameW.Buffer, environmentW.Buffer, Level,
4575 (LPBYTE)driverDirectoryW, len, &pcbNeededW );
4576 if (ret) {
4577 DWORD needed;
4578 needed = WideCharToMultiByte( CP_ACP, 0, driverDirectoryW, -1,
4579 (LPSTR)pDriverDirectory, cbBuf, NULL, NULL);
4580 if(pcbNeeded)
4581 *pcbNeeded = needed;
4582 ret = (needed <= cbBuf) ? TRUE : FALSE;
4583 } else
4584 if(pcbNeeded) *pcbNeeded = pcbNeededW * sizeof(CHAR)/sizeof(WCHAR);
4585
4586 TRACE("required: 0x%x/%d\n", pcbNeeded ? *pcbNeeded : 0, pcbNeeded ? *pcbNeeded : 0);
4587
4588 HeapFree( GetProcessHeap(), 0, driverDirectoryW );
4589 RtlFreeUnicodeString(&environmentW);
4590 RtlFreeUnicodeString(&nameW);
4591
4592 return ret;
4593 }
4594
4595 /*****************************************************************************
4596 * AddPrinterDriverA [WINSPOOL.@]
4597 *
4598 * See AddPrinterDriverW.
4599 *
4600 */
4601 BOOL WINAPI AddPrinterDriverA(LPSTR pName, DWORD level, LPBYTE pDriverInfo)
4602 {
4603 TRACE("(%s, %d, %p)\n", debugstr_a(pName), level, pDriverInfo);
4604 return AddPrinterDriverExA(pName, level, pDriverInfo, APD_COPY_NEW_FILES);
4605 }
4606
4607 /******************************************************************************
4608 * AddPrinterDriverW (WINSPOOL.@)
4609 *
4610 * Install a Printer Driver
4611 *
4612 * PARAMS
4613 * pName [I] Servername or NULL (local Computer)
4614 * level [I] Level for the supplied DRIVER_INFO_*W struct
4615 * pDriverInfo [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
4616 *
4617 * RESULTS
4618 * Success: TRUE
4619 * Failure: FALSE
4620 *
4621 */
4622 BOOL WINAPI AddPrinterDriverW(LPWSTR pName, DWORD level, LPBYTE pDriverInfo)
4623 {
4624 TRACE("(%s, %d, %p)\n", debugstr_w(pName), level, pDriverInfo);
4625 return AddPrinterDriverExW(pName, level, pDriverInfo, APD_COPY_NEW_FILES);
4626 }
4627
4628 /*****************************************************************************
4629 * AddPrintProcessorA [WINSPOOL.@]
4630 */
4631 BOOL WINAPI AddPrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPathName,
4632 LPSTR pPrintProcessorName)
4633 {
4634 FIXME("(%s,%s,%s,%s): stub\n", debugstr_a(pName), debugstr_a(pEnvironment),
4635 debugstr_a(pPathName), debugstr_a(pPrintProcessorName));
4636 return FALSE;
4637 }
4638
4639 /*****************************************************************************
4640 * AddPrintProcessorW [WINSPOOL.@]
4641 */
4642 BOOL WINAPI AddPrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPathName,
4643 LPWSTR pPrintProcessorName)
4644 {
4645 FIXME("(%s,%s,%s,%s): stub\n", debugstr_w(pName), debugstr_w(pEnvironment),
4646 debugstr_w(pPathName), debugstr_w(pPrintProcessorName));
4647 return FALSE;
4648 }
4649
4650 /*****************************************************************************
4651 * AddPrintProvidorA [WINSPOOL.@]
4652 */
4653 BOOL WINAPI AddPrintProvidorA(LPSTR pName, DWORD Level, LPBYTE pProviderInfo)
4654 {
4655 FIXME("(%s,0x%08x,%p): stub\n", debugstr_a(pName), Level, pProviderInfo);
4656 return FALSE;
4657 }
4658
4659 /*****************************************************************************
4660 * AddPrintProvidorW [WINSPOOL.@]
4661 */
4662 BOOL WINAPI AddPrintProvidorW(LPWSTR pName, DWORD Level, LPBYTE pProviderInfo)
4663 {
4664 FIXME("(%s,0x%08x,%p): stub\n", debugstr_w(pName), Level, pProviderInfo);
4665 return FALSE;
4666 }
4667
4668 /*****************************************************************************
4669 * AdvancedDocumentPropertiesA [WINSPOOL.@]
4670 */
4671 LONG WINAPI AdvancedDocumentPropertiesA(HWND hWnd, HANDLE hPrinter, LPSTR pDeviceName,
4672 PDEVMODEA pDevModeOutput, PDEVMODEA pDevModeInput)
4673 {
4674 FIXME("(%p,%p,%s,%p,%p): stub\n", hWnd, hPrinter, debugstr_a(pDeviceName),
4675 pDevModeOutput, pDevModeInput);
4676 return 0;
4677 }
4678
4679 /*****************************************************************************
4680 * AdvancedDocumentPropertiesW [WINSPOOL.@]
4681 */
4682 LONG WINAPI AdvancedDocumentPropertiesW(HWND hWnd, HANDLE hPrinter, LPWSTR pDeviceName,
4683 PDEVMODEW pDevModeOutput, PDEVMODEW pDevModeInput)
4684 {
4685 FIXME("(%p,%p,%s,%p,%p): stub\n", hWnd, hPrinter, debugstr_w(pDeviceName),
4686 pDevModeOutput, pDevModeInput);
4687 return 0;
4688 }
4689
4690 /*****************************************************************************
4691 * PrinterProperties [WINSPOOL.@]
4692 *
4693 * Displays a dialog to set the properties of the printer.
4694 *
4695 * RETURNS
4696 * nonzero on success or zero on failure
4697 *
4698 * BUGS
4699 * implemented as stub only
4700 */
4701 BOOL WINAPI PrinterProperties(HWND hWnd, /* [in] handle to parent window */
4702 HANDLE hPrinter /* [in] handle to printer object */
4703 ){
4704 FIXME("(%p,%p): stub\n", hWnd, hPrinter);
4705 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4706 return FALSE;
4707 }
4708
4709 /*****************************************************************************
4710 * EnumJobsA [WINSPOOL.@]
4711 *
4712 */
4713 BOOL WINAPI EnumJobsA(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
4714 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
4715 LPDWORD pcReturned)
4716 {
4717 FIXME("(%p,first=%d,no=%d,level=%d,job=%p,cb=%d,%p,%p), stub!\n",
4718 hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
4719 );
4720 if(pcbNeeded) *pcbNeeded = 0;
4721 if(pcReturned) *pcReturned = 0;
4722 return FALSE;
4723 }
4724
4725
4726 /*****************************************************************************
4727 * EnumJobsW [WINSPOOL.@]
4728 *
4729 */
4730 BOOL WINAPI EnumJobsW(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
4731 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
4732 LPDWORD pcReturned)
4733 {
4734 FIXME("(%p,first=%d,no=%d,level=%d,job=%p,cb=%d,%p,%p), stub!\n",
4735 hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
4736 );
4737 if(pcbNeeded) *pcbNeeded = 0;
4738 if(pcReturned) *pcReturned = 0;
4739 return FALSE;
4740 }
4741
4742 /*****************************************************************************
4743 * WINSPOOL_EnumPrinterDrivers [internal]
4744 *
4745 * Delivers information about all printer drivers installed on the
4746 * localhost or a given server
4747 *
4748 * RETURNS
4749 * nonzero on success or zero on failure. If the buffer for the returned
4750 * information is too small the function will return an error
4751 *
4752 * BUGS
4753 * - only implemented for localhost, foreign hosts will return an error
4754 */
4755 static BOOL WINSPOOL_EnumPrinterDrivers(LPWSTR pName, LPCWSTR pEnvironment,
4756 DWORD Level, LPBYTE pDriverInfo,
4757 DWORD driver_index,
4758 DWORD cbBuf, LPDWORD pcbNeeded,
4759 LPDWORD pcFound, DWORD data_offset)
4760
4761 { HKEY hkeyDrivers;
4762 DWORD i, size = 0;
4763 const printenv_t * env;
4764
4765 TRACE("%s,%s,%d,%p,%d,%d,%d\n",
4766 debugstr_w(pName), debugstr_w(pEnvironment),
4767 Level, pDriverInfo, driver_index, cbBuf, data_offset);
4768
4769 env = validate_envW(pEnvironment);
4770 if (!env) return FALSE; /* SetLastError() is in validate_envW */
4771
4772 *pcFound = 0;
4773
4774 hkeyDrivers = WINSPOOL_OpenDriverReg(pEnvironment);
4775 if(!hkeyDrivers) {
4776 ERR("Can't open Drivers key\n");
4777 return FALSE;
4778 }
4779
4780 if(RegQueryInfoKeyA(hkeyDrivers, NULL, NULL, NULL, pcFound, NULL, NULL,
4781 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
4782 RegCloseKey(hkeyDrivers);
4783 ERR("Can't query Drivers key\n");
4784 return FALSE;
4785 }
4786 TRACE("Found %d Drivers\n", *pcFound);
4787
4788 /* get size of single struct
4789 * unicode and ascii structure have the same size
4790 */
4791 size = di_sizeof[Level];
4792
4793 if (data_offset == 0)
4794 data_offset = size * (*pcFound);
4795 *pcbNeeded = data_offset;
4796
4797 for( i = 0; i < *pcFound; i++) {
4798 WCHAR DriverNameW[255];
4799 PBYTE table_ptr = NULL;
4800 PBYTE data_ptr = NULL;
4801 DWORD needed = 0;
4802
4803 if(RegEnumKeyW(hkeyDrivers, i, DriverNameW, sizeof(DriverNameW)/sizeof(DriverNameW[0]))
4804 != ERROR_SUCCESS) {
4805 ERR("Can't enum key number %d\n", i);
4806 RegCloseKey(hkeyDrivers);
4807 return FALSE;
4808 }
4809
4810 if (pDriverInfo && ((driver_index + i + 1) * size) <= cbBuf)
4811 table_ptr = pDriverInfo + (driver_index + i) * size;
4812 if (pDriverInfo && *pcbNeeded <= cbBuf)
4813 data_ptr = pDriverInfo + *pcbNeeded;
4814
4815 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverNameW,
4816 env, Level, table_ptr, data_ptr,
4817 (cbBuf < *pcbNeeded) ? 0 : cbBuf - *pcbNeeded,
4818 &needed)) {
4819 RegCloseKey(hkeyDrivers);
4820 return FALSE;
4821 }
4822
4823 *pcbNeeded += needed;
4824 }
4825
4826 RegCloseKey(hkeyDrivers);
4827
4828 if(cbBuf < *pcbNeeded){
4829 SetLastError(ERROR_INSUFFICIENT_BUFFER);
4830 return FALSE;
4831 }
4832
4833 return TRUE;
4834 }
4835
4836 /*****************************************************************************
4837 * EnumPrinterDriversW [WINSPOOL.@]
4838 *
4839 * see function EnumPrinterDrivers for RETURNS, BUGS
4840 */
4841 BOOL WINAPI EnumPrinterDriversW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
4842 LPBYTE pDriverInfo, DWORD cbBuf,
4843 LPDWORD pcbNeeded, LPDWORD pcReturned)
4844 {
4845 static const WCHAR allW[] = {'a','l','l',0};
4846 BOOL ret;
4847 DWORD found;
4848
4849 if ((pcbNeeded == NULL) || (pcReturned == NULL))
4850 {
4851 SetLastError(RPC_X_NULL_REF_POINTER);
4852 return FALSE;
4853 }
4854
4855 /* check for local drivers */
4856 if((pName) && (pName[0])) {
4857 FIXME("remote drivers (%s) not supported!\n", debugstr_w(pName));
4858 SetLastError(ERROR_ACCESS_DENIED);
4859 return FALSE;
4860 }
4861
4862 /* check input parameter */
4863 if ((Level < 1) || (Level == 7) || (Level > 8)) {
4864 SetLastError(ERROR_INVALID_LEVEL);
4865 return FALSE;
4866 }
4867
4868 if(pDriverInfo && cbBuf > 0)
4869 memset( pDriverInfo, 0, cbBuf);
4870
4871 /* Exception: pull all printers */
4872 if (pEnvironment && !strcmpW(pEnvironment, allW))
4873 {
4874 DWORD i, needed, bufsize = cbBuf;
4875 DWORD total_needed = 0;
4876 DWORD total_found = 0;
4877 DWORD data_offset;
4878
4879 /* Precompute the overall total; we need this to know
4880 where pointers end and data begins (i.e. data_offset) */
4881 for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
4882 {
4883 needed = found = 0;
4884 ret = WINSPOOL_EnumPrinterDrivers(pName, all_printenv[i]->envname, Level,
4885 NULL, 0, 0, &needed, &found, 0);
4886 if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
4887 total_needed += needed;
4888 total_found += found;
4889 }
4890
4891 data_offset = di_sizeof[Level] * total_found;
4892
4893 *pcReturned = 0;
4894 *pcbNeeded = 0;
4895 total_found = 0;
4896 for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
4897 {
4898 needed = found = 0;
4899 ret = WINSPOOL_EnumPrinterDrivers(pName, all_printenv[i]->envname, Level,
4900 pDriverInfo, total_found, bufsize, &needed, &found, data_offset);
4901 if (!ret && GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
4902 else if (ret)
4903 *pcReturned += found;
4904 *pcbNeeded = needed;
4905 data_offset = needed;
4906 total_found += found;
4907 }
4908 return ret;
4909 }
4910
4911 /* Normal behavior */
4912 ret = WINSPOOL_EnumPrinterDrivers(pName, pEnvironment, Level, pDriverInfo,
4913 0, cbBuf, pcbNeeded, &found, 0);
4914 if (ret)
4915 *pcReturned = found;
4916
4917 return ret;
4918 }
4919
4920 /*****************************************************************************
4921 * EnumPrinterDriversA [WINSPOOL.@]
4922 *
4923 * see function EnumPrinterDrivers for RETURNS, BUGS
4924 */
4925 BOOL WINAPI EnumPrinterDriversA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
4926 LPBYTE pDriverInfo, DWORD cbBuf,
4927 LPDWORD pcbNeeded, LPDWORD pcReturned)
4928 {
4929 BOOL ret;
4930 UNICODE_STRING pNameW, pEnvironmentW;
4931 PWSTR pwstrNameW, pwstrEnvironmentW;
4932 LPBYTE buf = NULL;
4933
4934 if (cbBuf)
4935 buf = HeapAlloc(GetProcessHeap(), 0, cbBuf);
4936
4937 pwstrNameW = asciitounicode(&pNameW, pName);
4938 pwstrEnvironmentW = asciitounicode(&pEnvironmentW, pEnvironment);
4939
4940 ret = EnumPrinterDriversW(pwstrNameW, pwstrEnvironmentW, Level,
4941 buf, cbBuf, pcbNeeded, pcReturned);
4942 if (ret)
4943 convert_driverinfo_W_to_A(pDriverInfo, buf, Level, cbBuf, *pcReturned);
4944
4945 HeapFree(GetProcessHeap(), 0, buf);
4946
4947 RtlFreeUnicodeString(&pNameW);
4948 RtlFreeUnicodeString(&pEnvironmentW);
4949
4950 return ret;
4951 }
4952
4953 /******************************************************************************
4954 * EnumPortsA (WINSPOOL.@)
4955 *
4956 * See EnumPortsW.
4957 *
4958 */
4959 BOOL WINAPI EnumPortsA( LPSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf,
4960 LPDWORD pcbNeeded, LPDWORD pcReturned)
4961 {
4962 BOOL res;
4963 LPBYTE bufferW = NULL;
4964 LPWSTR nameW = NULL;
4965 DWORD needed = 0;
4966 DWORD numentries = 0;
4967 INT len;
4968
4969 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), Level, pPorts,
4970 cbBuf, pcbNeeded, pcReturned);
4971
4972 /* convert servername to unicode */
4973 if (pName) {
4974 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
4975 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
4976 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
4977 }
4978 /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the Ports */
4979 needed = cbBuf * sizeof(WCHAR);
4980 if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
4981 res = EnumPortsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
4982
4983 if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
4984 if (pcbNeeded) needed = *pcbNeeded;
4985 /* HeapReAlloc return NULL, when bufferW was NULL */
4986 bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
4987 HeapAlloc(GetProcessHeap(), 0, needed);
4988
4989 /* Try again with the large Buffer */
4990 res = EnumPortsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
4991 }
4992 needed = pcbNeeded ? *pcbNeeded : 0;
4993 numentries = pcReturned ? *pcReturned : 0;
4994
4995 /*
4996 W2k require the buffersize from EnumPortsW also for EnumPortsA.
4997 We use the smaller Ansi-Size to avoid conflicts with fixed Buffers of old Apps.
4998 */
4999 if (res) {
5000 /* EnumPortsW collected all Data. Parse them to calculate ANSI-Size */
5001 DWORD entrysize = 0;
5002 DWORD index;
5003 LPSTR ptr;
5004 LPPORT_INFO_2W pi2w;
5005 LPPORT_INFO_2A pi2a;
5006
5007 needed = 0;
5008 entrysize = (Level == 1) ? sizeof(PORT_INFO_1A) : sizeof(PORT_INFO_2A);
5009
5010 /* First pass: calculate the size for all Entries */
5011 pi2w = (LPPORT_INFO_2W) bufferW;
5012 pi2a = (LPPORT_INFO_2A) pPorts;
5013 index = 0;
5014 while (index < numentries) {
5015 index++;
5016 needed += entrysize; /* PORT_INFO_?A */
5017 TRACE("%p: parsing #%d (%s)\n", pi2w, index, debugstr_w(pi2w->pPortName));
5018
5019 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pPortName, -1,
5020 NULL, 0, NULL, NULL);
5021 if (Level > 1) {
5022 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pMonitorName, -1,
5023 NULL, 0, NULL, NULL);
5024 needed += WideCharToMultiByte(CP_ACP, 0, pi2w->pDescription, -1,
5025 NULL, 0, NULL, NULL);
5026 }
5027 /* use LPBYTE with entrysize to avoid double code (PORT_INFO_1 + PORT_INFO_2) */
5028 pi2w = (LPPORT_INFO_2W) (((LPBYTE)pi2w) + entrysize);
5029 pi2a = (LPPORT_INFO_2A) (((LPBYTE)pi2a) + entrysize);
5030 }
5031
5032 /* check for errors and quit on failure */
5033 if (cbBuf < needed) {
5034 SetLastError(ERROR_INSUFFICIENT_BUFFER);
5035 res = FALSE;
5036 goto cleanup;
5037 }
5038 len = entrysize * numentries; /* room for all PORT_INFO_?A */
5039 ptr = (LPSTR) &pPorts[len]; /* room for strings */
5040 cbBuf -= len ; /* free Bytes in the user-Buffer */
5041 pi2w = (LPPORT_INFO_2W) bufferW;
5042 pi2a = (LPPORT_INFO_2A) pPorts;
5043 index = 0;
5044 /* Second Pass: Fill the User Buffer (if we have one) */
5045 while ((index < numentries) && pPorts) {
5046 index++;
5047 TRACE("%p: writing PORT_INFO_%dA #%d\n", pi2a, Level, index);
5048 pi2a->pPortName = ptr;
5049 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pPortName, -1,
5050 ptr, cbBuf , NULL, NULL);
5051 ptr += len;
5052 cbBuf -= len;
5053 if (Level > 1) {
5054 pi2a->pMonitorName = ptr;
5055 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pMonitorName, -1,
5056 ptr, cbBuf, NULL, NULL);
5057 ptr += len;
5058 cbBuf -= len;
5059
5060 pi2a->pDescription = ptr;
5061 len = WideCharToMultiByte(CP_ACP, 0, pi2w->pDescription, -1,
5062 ptr, cbBuf, NULL, NULL);
5063 ptr += len;
5064 cbBuf -= len;
5065
5066 pi2a->fPortType = pi2w->fPortType;
5067 pi2a->Reserved = 0; /* documented: "must be zero" */
5068
5069 }
5070 /* use LPBYTE with entrysize to avoid double code (PORT_INFO_1 + PORT_INFO_2) */
5071 pi2w = (LPPORT_INFO_2W) (((LPBYTE)pi2w) + entrysize);
5072 pi2a = (LPPORT_INFO_2A) (((LPBYTE)pi2a) + entrysize);
5073 }
5074 }
5075
5076 cleanup:
5077 if (pcbNeeded) *pcbNeeded = needed;
5078 if (pcReturned) *pcReturned = (res) ? numentries : 0;
5079
5080 HeapFree(GetProcessHeap(), 0, nameW);
5081 HeapFree(GetProcessHeap(), 0, bufferW);
5082
5083 TRACE("returning %d with %d (%d byte for %d of %d entries)\n",
5084 (res), GetLastError(), needed, (res)? numentries : 0, numentries);
5085
5086 return (res);
5087
5088 }
5089
5090 /******************************************************************************
5091 * EnumPortsW (WINSPOOL.@)
5092 *
5093 * Enumerate available Ports
5094 *
5095 * PARAMS
5096 * pName [I] Servername or NULL (local Computer)
5097 * Level [I] Structure-Level (1 or 2)
5098 * pPorts [O] PTR to Buffer that receives the Result
5099 * cbBuf [I] Size of Buffer at pPorts
5100 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPorts
5101 * pcReturned [O] PTR to DWORD that receives the number of Ports in pPorts
5102 *
5103 * RETURNS
5104 * Success: TRUE
5105 * Failure: FALSE and in pcbNeeded the Bytes required for pPorts, if cbBuf is too small
5106 *
5107 */
5108 BOOL WINAPI EnumPortsW(LPWSTR pName, DWORD Level, LPBYTE pPorts, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
5109 {
5110
5111 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pPorts,
5112 cbBuf, pcbNeeded, pcReturned);
5113
5114 if ((backend == NULL) && !load_backend()) return FALSE;
5115
5116 /* Level is not checked in win9x */
5117 if (!Level || (Level > 2)) {
5118 WARN("level (%d) is ignored in win9x\n", Level);
5119 SetLastError(ERROR_INVALID_LEVEL);
5120 return FALSE;
5121 }
5122 if (!pcbNeeded || (!pPorts && (cbBuf > 0))) {
5123 SetLastError(RPC_X_NULL_REF_POINTER);
5124 return FALSE;
5125 }
5126
5127 return backend->fpEnumPorts(pName, Level, pPorts, cbBuf, pcbNeeded, pcReturned);
5128 }
5129
5130 /******************************************************************************
5131 * GetDefaultPrinterW (WINSPOOL.@)
5132 *
5133 * FIXME
5134 * This function must read the value from data 'device' of key
5135 * HCU\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows
5136 */
5137 BOOL WINAPI GetDefaultPrinterW(LPWSTR name, LPDWORD namesize)
5138 {
5139 BOOL retval = TRUE;
5140 DWORD insize, len;
5141 WCHAR *buffer, *ptr;
5142
5143 if (!namesize)
5144 {
5145 SetLastError(ERROR_INVALID_PARAMETER);
5146 return FALSE;
5147 }
5148
5149 /* make the buffer big enough for the stuff from the profile/registry,
5150 * the content must fit into the local buffer to compute the correct
5151 * size even if the extern buffer is too small or not given.
5152 * (20 for ,driver,port) */
5153 insize = *namesize;
5154 len = max(100, (insize + 20));
5155 buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR));
5156
5157 if (!GetProfileStringW(windowsW, deviceW, emptyStringW, buffer, len))
5158 {
5159 SetLastError (ERROR_FILE_NOT_FOUND);
5160 retval = FALSE;
5161 goto end;
5162 }
5163 TRACE("%s\n", debugstr_w(buffer));
5164
5165 if ((ptr = strchrW(buffer, ',')) == NULL)
5166 {
5167 SetLastError(ERROR_INVALID_NAME);
5168 retval = FALSE;
5169 goto end;
5170 }
5171
5172 *ptr = 0;
5173 *namesize = strlenW(buffer) + 1;
5174 if(!name || (*namesize > insize))
5175 {
5176 SetLastError(ERROR_INSUFFICIENT_BUFFER);
5177 retval = FALSE;
5178 goto end;
5179 }
5180 strcpyW(name, buffer);
5181
5182 end:
5183 HeapFree( GetProcessHeap(), 0, buffer);
5184 return retval;
5185 }
5186
5187
5188 /******************************************************************************
5189 * GetDefaultPrinterA (WINSPOOL.@)
5190 */
5191 BOOL WINAPI GetDefaultPrinterA(LPSTR name, LPDWORD namesize)
5192 {
5193 BOOL retval = TRUE;
5194 DWORD insize = 0;
5195 WCHAR *bufferW = NULL;
5196
5197 if (!namesize)
5198 {
5199 SetLastError(ERROR_INVALID_PARAMETER);
5200 return FALSE;
5201 }
5202
5203 if(name && *namesize) {
5204 insize = *namesize;
5205 bufferW = HeapAlloc( GetProcessHeap(), 0, insize * sizeof(WCHAR));
5206 }
5207
5208 if(!GetDefaultPrinterW( bufferW, namesize)) {
5209 retval = FALSE;
5210 goto end;
5211 }
5212
5213 *namesize = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, name, insize,
5214 NULL, NULL);
5215 if (!*namesize)
5216 {
5217 *namesize = WideCharToMultiByte(CP_ACP, 0, bufferW, -1, NULL, 0, NULL, NULL);
5218 retval = FALSE;
5219 }
5220 TRACE("0x%08x/0x%08x:%s\n", *namesize, insize, debugstr_w(bufferW));
5221
5222 end:
5223 HeapFree( GetProcessHeap(), 0, bufferW);
5224 return retval;
5225 }
5226
5227
5228 /******************************************************************************
5229 * SetDefaultPrinterW (WINSPOOL.204)
5230 *
5231 * Set the Name of the Default Printer
5232 *
5233 * PARAMS
5234 * pszPrinter [I] Name of the Printer or NULL
5235 *
5236 * RETURNS
5237 * Success: True
5238 * Failure: FALSE
5239 *
5240 * NOTES
5241 * When the Parameter is NULL or points to an Empty String and
5242 * a Default Printer was already present, then this Function changes nothing.
5243 * Without a Default Printer and NULL (or an Empty String) as Parameter,
5244 * the First enumerated local Printer is used.
5245 *
5246 */
5247 BOOL WINAPI SetDefaultPrinterW(LPCWSTR pszPrinter)
5248 {
5249
5250 TRACE("(%s)\n", debugstr_w(pszPrinter));
5251
5252 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5253 return FALSE;
5254 }
5255
5256 /******************************************************************************
5257 * SetDefaultPrinterA (WINSPOOL.202)
5258 *
5259 * See SetDefaultPrinterW.
5260 *
5261 */
5262 BOOL WINAPI SetDefaultPrinterA(LPCSTR pszPrinter)
5263 {
5264
5265 TRACE("(%s)\n", debugstr_a(pszPrinter));
5266
5267 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5268 return FALSE;
5269 }
5270
5271
5272 /******************************************************************************
5273 * SetPrinterDataExA (WINSPOOL.@)
5274 */
5275 DWORD WINAPI SetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5276 LPCSTR pValueName, DWORD Type,
5277 LPBYTE pData, DWORD cbData)
5278 {
5279 HKEY hkeyPrinter, hkeySubkey;
5280 DWORD ret;
5281
5282 TRACE("(%p, %s, %s %08x, %p, %08x)\n", hPrinter, debugstr_a(pKeyName),
5283 debugstr_a(pValueName), Type, pData, cbData);
5284
5285 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5286 != ERROR_SUCCESS)
5287 return ret;
5288
5289 if((ret = RegCreateKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
5290 != ERROR_SUCCESS) {
5291 ERR("Can't create subkey %s\n", debugstr_a(pKeyName));
5292 RegCloseKey(hkeyPrinter);
5293 return ret;
5294 }
5295 ret = RegSetValueExA(hkeySubkey, pValueName, 0, Type, pData, cbData);
5296 RegCloseKey(hkeySubkey);
5297 RegCloseKey(hkeyPrinter);
5298 return ret;
5299 }
5300
5301 /******************************************************************************
5302 * SetPrinterDataExW (WINSPOOL.@)
5303 */
5304 DWORD WINAPI SetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5305 LPCWSTR pValueName, DWORD Type,
5306 LPBYTE pData, DWORD cbData)
5307 {
5308 HKEY hkeyPrinter, hkeySubkey;
5309 DWORD ret;
5310
5311 TRACE("(%p, %s, %s %08x, %p, %08x)\n", hPrinter, debugstr_w(pKeyName),
5312 debugstr_w(pValueName), Type, pData, cbData);
5313
5314 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
5315 != ERROR_SUCCESS)
5316 return ret;
5317
5318 if((ret = RegCreateKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
5319 != ERROR_SUCCESS) {
5320 ERR("Can't create subkey %s\n", debugstr_w(pKeyName));
5321 RegCloseKey(hkeyPrinter);
5322 return ret;
5323 }
5324 ret = RegSetValueExW(hkeySubkey, pValueName, 0, Type, pData, cbData);
5325 RegCloseKey(hkeySubkey);
5326 RegCloseKey(hkeyPrinter);
5327 return ret;
5328 }
5329
5330 /******************************************************************************
5331 * SetPrinterDataA (WINSPOOL.@)
5332 */
5333 DWORD WINAPI SetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, DWORD Type,
5334 LPBYTE pData, DWORD cbData)
5335 {
5336 return SetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, Type,
5337 pData, cbData);
5338 }
5339
5340 /******************************************************************************
5341 * SetPrinterDataW (WINSPOOL.@)
5342 */
5343 DWORD WINAPI SetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, DWORD Type,
5344 LPBYTE pData, DWORD cbData)
5345 {
5346 return SetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, Type,
5347 pData, cbData);
5348 }
5349
5350 /******************************************************************************
5351 * GetPrinterDataExA (WINSPOOL.@)
5352 */
5353 DWORD WINAPI GetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5354 LPCSTR pValueName, LPDWORD pType,
5355 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5356 {
5357 opened_printer_t *printer;
5358 HKEY hkeyPrinters, hkeyPrinter = 0, hkeySubkey = 0;
5359 DWORD ret;
5360
5361 TRACE("(%p, %s, %s, %p, %p, %u, %p)\n", hPrinter, debugstr_a(pKeyName),
5362 debugstr_a(pValueName), pType, pData, nSize, pcbNeeded);
5363
5364 printer = get_opened_printer(hPrinter);
5365 if(!printer) return ERROR_INVALID_HANDLE;
5366
5367 ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters);
5368 if (ret) return ret;
5369
5370 TRACE("printer->name: %s\n", debugstr_w(printer->name));
5371
5372 if (printer->name) {
5373
5374 ret = RegOpenKeyW(hkeyPrinters, printer->name, &hkeyPrinter);
5375 if (ret) {
5376 RegCloseKey(hkeyPrinters);
5377 return ret;
5378 }
5379 if((ret = RegOpenKeyA(hkeyPrinter, pKeyName, &hkeySubkey)) != ERROR_SUCCESS) {
5380 WARN("Can't open subkey %s: %d\n", debugstr_a(pKeyName), ret);
5381 RegCloseKey(hkeyPrinter);
5382 RegCloseKey(hkeyPrinters);
5383 return ret;
5384 }
5385 }
5386 *pcbNeeded = nSize;
5387 ret = RegQueryValueExA(printer->name ? hkeySubkey : hkeyPrinters, pValueName,
5388 0, pType, pData, pcbNeeded);
5389
5390 if (!ret && !pData) ret = ERROR_MORE_DATA;
5391
5392 RegCloseKey(hkeySubkey);
5393 RegCloseKey(hkeyPrinter);
5394 RegCloseKey(hkeyPrinters);
5395
5396 TRACE("--> %d\n", ret);
5397 return ret;
5398 }
5399
5400 /******************************************************************************
5401 * GetPrinterDataExW (WINSPOOL.@)
5402 */
5403 DWORD WINAPI GetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5404 LPCWSTR pValueName, LPDWORD pType,
5405 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5406 {
5407 opened_printer_t *printer;
5408 HKEY hkeyPrinters, hkeyPrinter = 0, hkeySubkey = 0;
5409 DWORD ret;
5410
5411 TRACE("(%p, %s, %s, %p, %p, %u, %p)\n", hPrinter, debugstr_w(pKeyName),
5412 debugstr_w(pValueName), pType, pData, nSize, pcbNeeded);
5413
5414 printer = get_opened_printer(hPrinter);
5415 if(!printer) return ERROR_INVALID_HANDLE;
5416
5417 ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, PrintersW, &hkeyPrinters);
5418 if (ret) return ret;
5419
5420 TRACE("printer->name: %s\n", debugstr_w(printer->name));
5421
5422 if (printer->name) {
5423
5424 ret = RegOpenKeyW(hkeyPrinters, printer->name, &hkeyPrinter);
5425 if (ret) {
5426 RegCloseKey(hkeyPrinters);
5427 return ret;
5428 }
5429 if((ret = RegOpenKeyW(hkeyPrinter, pKeyName, &hkeySubkey)) != ERROR_SUCCESS) {
5430 WARN("Can't open subkey %s: %d\n", debugstr_w(pKeyName), ret);
5431 RegCloseKey(hkeyPrinter);
5432 RegCloseKey(hkeyPrinters);
5433 return ret;
5434 }
5435 }
5436 *pcbNeeded = nSize;
5437 ret = RegQueryValueExW(printer->name ? hkeySubkey : hkeyPrinters, pValueName,
5438 0, pType, pData, pcbNeeded);
5439
5440 if (!ret && !pData) ret = ERROR_MORE_DATA;
5441
5442 RegCloseKey(hkeySubkey);
5443 RegCloseKey(hkeyPrinter);
5444 RegCloseKey(hkeyPrinters);
5445
5446 TRACE("--> %d\n", ret);
5447 return ret;
5448 }
5449
5450 /******************************************************************************
5451 * GetPrinterDataA (WINSPOOL.@)
5452 */
5453 DWORD WINAPI GetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, LPDWORD pType,
5454 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5455 {
5456 return GetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, pType,
5457 pData, nSize, pcbNeeded);
5458 }
5459
5460 /******************************************************************************
5461 * GetPrinterDataW (WINSPOOL.@)
5462 */
5463 DWORD WINAPI GetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, LPDWORD pType,
5464 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
5465 {
5466 return GetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, pType,
5467 pData, nSize, pcbNeeded);
5468 }
5469
5470 /*******************************************************************************
5471 * EnumPrinterDataExW [WINSPOOL.@]
5472 */
5473 DWORD WINAPI EnumPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
5474 LPBYTE pEnumValues, DWORD cbEnumValues,
5475 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
5476 {
5477 HKEY hkPrinter, hkSubKey;
5478 DWORD r, ret, dwIndex, cValues, cbMaxValueNameLen,
5479 cbValueNameLen, cbMaxValueLen, cbValueLen,
5480 cbBufSize, dwType;
5481 LPWSTR lpValueName;
5482 HANDLE hHeap;
5483 PBYTE lpValue;
5484 PPRINTER_ENUM_VALUESW ppev;
5485
5486 TRACE ("%p %s\n", hPrinter, debugstr_w (pKeyName));
5487
5488 if (pKeyName == NULL || *pKeyName == 0)
5489 return ERROR_INVALID_PARAMETER;
5490
5491 ret = WINSPOOL_GetOpenedPrinterRegKey (hPrinter, &hkPrinter);
5492 if (ret != ERROR_SUCCESS)
5493 {
5494 TRACE ("WINSPOOL_GetOpenedPrinterRegKey (%p) returned %i\n",
5495 hPrinter, ret);
5496 return ret;
5497 }
5498
5499 ret = RegOpenKeyExW (hkPrinter, pKeyName, 0, KEY_READ, &hkSubKey);
5500 if (ret != ERROR_SUCCESS)
5501 {
5502 r = RegCloseKey (hkPrinter);
5503 if (r != ERROR_SUCCESS)
5504 WARN ("RegCloseKey returned %i\n", r);
5505 TRACE ("RegOpenKeyExW (%p, %s) returned %i\n", hPrinter,
5506 debugstr_w (pKeyName), ret);
5507 return ret;
5508 }
5509
5510 ret = RegCloseKey (hkPrinter);
5511 if (ret != ERROR_SUCCESS)
5512 {
5513 ERR ("RegCloseKey returned %i\n", ret);
5514 r = RegCloseKey (hkSubKey);
5515 if (r != ERROR_SUCCESS)
5516 WARN ("RegCloseKey returned %i\n", r);
5517 return ret;
5518 }
5519
5520 ret = RegQueryInfoKeyW (hkSubKey, NULL, NULL, NULL, NULL, NULL, NULL,
5521 &cValues, &cbMaxValueNameLen, &cbMaxValueLen, NULL, NULL);
5522 if (ret != ERROR_SUCCESS)
5523 {
5524 r = RegCloseKey (hkSubKey);
5525 if (r != ERROR_SUCCESS)
5526 WARN ("RegCloseKey returned %i\n", r);
5527 TRACE ("RegQueryInfoKeyW (%p) returned %i\n", hkSubKey, ret);
5528 return ret;
5529 }
5530
5531 TRACE ("RegQueryInfoKeyW returned cValues = %i, cbMaxValueNameLen = %i, "
5532 "cbMaxValueLen = %i\n", cValues, cbMaxValueNameLen, cbMaxValueLen);
5533
5534 if (cValues == 0) /* empty key */
5535 {
5536 r = RegCloseKey (hkSubKey);
5537 if (r != ERROR_SUCCESS)
5538 WARN ("RegCloseKey returned %i\n", r);
5539 *pcbEnumValues = *pnEnumValues = 0;
5540 return ERROR_SUCCESS;
5541 }
5542
5543 ++cbMaxValueNameLen; /* allow for trailing '\0' */
5544
5545 hHeap = GetProcessHeap ();
5546 if (hHeap == NULL)
5547 {
5548 ERR ("GetProcessHeap failed\n");
5549 r = RegCloseKey (hkSubKey);
5550 if (r != ERROR_SUCCESS)
5551 WARN ("RegCloseKey returned %i\n", r);
5552 return ERROR_OUTOFMEMORY;
5553 }
5554
5555 lpValueName = HeapAlloc (hHeap, 0, cbMaxValueNameLen * sizeof (WCHAR));
5556 if (lpValueName == NULL)
5557 {
5558 ERR ("Failed to allocate %i WCHARs from process heap\n", cbMaxValueNameLen);
5559 r = RegCloseKey (hkSubKey);
5560 if (r != ERROR_SUCCESS)
5561 WARN ("RegCloseKey returned %i\n", r);
5562 return ERROR_OUTOFMEMORY;
5563 }
5564
5565 lpValue = HeapAlloc (hHeap, 0, cbMaxValueLen);
5566 if (lpValue == NULL)
5567 {
5568 ERR ("Failed to allocate %i bytes from process heap\n", cbMaxValueLen);
5569 if (HeapFree (hHeap, 0, lpValueName) == 0)
5570 WARN ("HeapFree failed with code %i\n", GetLastError ());
5571 r = RegCloseKey (hkSubKey);
5572 if (r != ERROR_SUCCESS)
5573 WARN ("RegCloseKey returned %i\n", r);
5574 return ERROR_OUTOFMEMORY;
5575 }
5576
5577 TRACE ("pass 1: calculating buffer required for all names and values\n");
5578
5579 cbBufSize = cValues * sizeof (PRINTER_ENUM_VALUESW);
5580
5581 TRACE ("%i bytes required for %i headers\n", cbBufSize, cValues);
5582
5583 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
5584 {
5585 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
5586 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
5587 NULL, NULL, lpValue, &cbValueLen);
5588 if (ret != ERROR_SUCCESS)
5589 {
5590 if (HeapFree (hHeap, 0, lpValue) == 0)
5591 WARN ("HeapFree failed with code %i\n", GetLastError ());
5592 if (HeapFree (hHeap, 0, lpValueName) == 0)
5593 WARN ("HeapFree failed with code %i\n", GetLastError ());
5594 r = RegCloseKey (hkSubKey);
5595 if (r != ERROR_SUCCESS)
5596 WARN ("RegCloseKey returned %i\n", r);
5597 TRACE ("RegEnumValueW (%i) returned %i\n", dwIndex, ret);
5598 return ret;
5599 }
5600
5601 TRACE ("%s [%i]: name needs %i WCHARs, data needs %i bytes\n",
5602 debugstr_w (lpValueName), dwIndex,
5603 cbValueNameLen + 1, cbValueLen);
5604
5605 cbBufSize += (cbValueNameLen + 1) * sizeof (WCHAR);
5606 cbBufSize += cbValueLen;
5607 }
5608
5609 TRACE ("%i bytes required for all %i values\n", cbBufSize, cValues);
5610
5611 *pcbEnumValues = cbBufSize;
5612 *pnEnumValues = cValues;
5613
5614 if (cbEnumValues < cbBufSize) /* buffer too small */
5615 {
5616 if (HeapFree (hHeap, 0, lpValue) == 0)
5617 WARN ("HeapFree failed with code %i\n", GetLastError ());
5618 if (HeapFree (hHeap, 0, lpValueName) == 0)
5619 WARN ("HeapFree failed with code %i\n", GetLastError ());
5620 r = RegCloseKey (hkSubKey);
5621 if (r != ERROR_SUCCESS)
5622 WARN ("RegCloseKey returned %i\n", r);
5623 TRACE ("%i byte buffer is not large enough\n", cbEnumValues);
5624 return ERROR_MORE_DATA;
5625 }
5626
5627 TRACE ("pass 2: copying all names and values to buffer\n");
5628
5629 ppev = (PPRINTER_ENUM_VALUESW) pEnumValues; /* array of structs */
5630 pEnumValues += cValues * sizeof (PRINTER_ENUM_VALUESW);
5631
5632 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
5633 {
5634 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
5635 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
5636 NULL, &dwType, lpValue, &cbValueLen);
5637 if (ret != ERROR_SUCCESS)
5638 {
5639 if (HeapFree (hHeap, 0, lpValue) == 0)
5640 WARN ("HeapFree failed with code %i\n", GetLastError ());
5641 if (HeapFree (hHeap, 0, lpValueName) == 0)
5642 WARN ("HeapFree failed with code %i\n", GetLastError ());
5643 r = RegCloseKey (hkSubKey);
5644 if (r != ERROR_SUCCESS)
5645 WARN ("RegCloseKey returned %i\n", r);
5646 TRACE ("RegEnumValueW (%i) returned %i\n", dwIndex, ret);
5647 return ret;
5648 }
5649
5650 cbValueNameLen = (cbValueNameLen + 1) * sizeof (WCHAR);
5651 memcpy (pEnumValues, lpValueName, cbValueNameLen);
5652 ppev[dwIndex].pValueName = (LPWSTR) pEnumValues;
5653 pEnumValues += cbValueNameLen;
5654
5655 /* return # of *bytes* (including trailing \0), not # of chars */
5656 ppev[dwIndex].cbValueName = cbValueNameLen;
5657
5658 ppev[dwIndex].dwType = dwType;
5659
5660 memcpy (pEnumValues, lpValue, cbValueLen);
5661 ppev[dwIndex].pData = pEnumValues;
5662 pEnumValues += cbValueLen;
5663
5664 ppev[dwIndex].cbData = cbValueLen;
5665
5666 TRACE ("%s [%i]: copied name (%i bytes) and data (%i bytes)\n",
5667 debugstr_w (lpValueName), dwIndex, cbValueNameLen, cbValueLen);
5668 }
5669
5670 if (HeapFree (hHeap, 0, lpValue) == 0)
5671 {
5672 ret = GetLastError ();
5673 ERR ("HeapFree failed with code %i\n", ret);
5674 if (HeapFree (hHeap, 0, lpValueName) == 0)
5675 WARN ("HeapFree failed with code %i\n", GetLastError ());
5676 r = RegCloseKey (hkSubKey);
5677 if (r != ERROR_SUCCESS)
5678 WARN ("RegCloseKey returned %i\n", r);
5679 return ret;
5680 }
5681
5682 if (HeapFree (hHeap, 0, lpValueName) == 0)
5683 {
5684 ret = GetLastError ();
5685 ERR ("HeapFree failed with code %i\n", ret);
5686 r = RegCloseKey (hkSubKey);
5687 if (r != ERROR_SUCCESS)
5688 WARN ("RegCloseKey returned %i\n", r);
5689 return ret;
5690 }
5691
5692 ret = RegCloseKey (hkSubKey);
5693 if (ret != ERROR_SUCCESS)
5694 {
5695 ERR ("RegCloseKey returned %i\n", ret);
5696 return ret;
5697 }
5698
5699 return ERROR_SUCCESS;
5700 }
5701
5702 /*******************************************************************************
5703 * EnumPrinterDataExA [WINSPOOL.@]
5704 *
5705 * This functions returns value names and REG_SZ, REG_EXPAND_SZ, and
5706 * REG_MULTI_SZ values as ASCII strings in Unicode-sized buffers. This is
5707 * what Windows 2000 SP1 does.
5708 *
5709 */
5710 DWORD WINAPI EnumPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
5711 LPBYTE pEnumValues, DWORD cbEnumValues,
5712 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
5713 {
5714 INT len;
5715 LPWSTR pKeyNameW;
5716 DWORD ret, dwIndex, dwBufSize;
5717 HANDLE hHeap;
5718 LPSTR pBuffer;
5719
5720 TRACE ("%p %s\n", hPrinter, pKeyName);
5721
5722 if (pKeyName == NULL || *pKeyName == 0)
5723 return ERROR_INVALID_PARAMETER;
5724
5725 len = MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, NULL, 0);
5726 if (len == 0)
5727 {
5728 ret = GetLastError ();
5729 ERR ("MultiByteToWideChar failed with code %i\n", ret);
5730 return ret;
5731 }
5732
5733 hHeap = GetProcessHeap ();
5734 if (hHeap == NULL)
5735 {
5736 ERR ("GetProcessHeap failed\n");
5737 return ERROR_OUTOFMEMORY;
5738 }
5739
5740 pKeyNameW = HeapAlloc (hHeap, 0, len * sizeof (WCHAR));
5741 if (pKeyNameW == NULL)
5742 {
5743 ERR ("Failed to allocate %i bytes from process heap\n",
5744 (LONG)(len * sizeof (WCHAR)));
5745 return ERROR_OUTOFMEMORY;
5746 }
5747
5748 if (MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, pKeyNameW, len) == 0)
5749 {
5750 ret = GetLastError ();
5751 ERR ("MultiByteToWideChar failed with code %i\n", ret);
5752 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
5753 WARN ("HeapFree failed with code %i\n", GetLastError ());
5754 return ret;
5755 }
5756
5757 ret = EnumPrinterDataExW (hPrinter, pKeyNameW, pEnumValues, cbEnumValues,
5758 pcbEnumValues, pnEnumValues);
5759 if (ret != ERROR_SUCCESS)
5760 {
5761 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
5762 WARN ("HeapFree failed with code %i\n", GetLastError ());
5763 TRACE ("EnumPrinterDataExW returned %i\n", ret);
5764 return ret;
5765 }
5766
5767 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
5768 {
5769 ret = GetLastError ();
5770 ERR ("HeapFree failed with code %i\n", ret);
5771 return ret;
5772 }
5773
5774 if (*pnEnumValues == 0) /* empty key */
5775 return ERROR_SUCCESS;
5776
5777 dwBufSize = 0;
5778 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
5779 {
5780 PPRINTER_ENUM_VALUESW ppev =
5781 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
5782
5783 if (dwBufSize < ppev->cbValueName)
5784 dwBufSize = ppev->cbValueName;
5785
5786 if (dwBufSize < ppev->cbData && (ppev->dwType == REG_SZ ||
5787 ppev->dwType == REG_EXPAND_SZ || ppev->dwType == REG_MULTI_SZ))
5788 dwBufSize = ppev->cbData;
5789 }
5790
5791 TRACE ("Largest Unicode name or value is %i bytes\n", dwBufSize);
5792
5793 pBuffer = HeapAlloc (hHeap, 0, dwBufSize);
5794 if (pBuffer == NULL)
5795 {
5796 ERR ("Failed to allocate %i bytes from process heap\n", dwBufSize);
5797 return ERROR_OUTOFMEMORY;
5798 }
5799
5800 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
5801 {
5802 PPRINTER_ENUM_VALUESW ppev =
5803 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
5804
5805 len = WideCharToMultiByte (CP_ACP, 0, ppev->pValueName,
5806 ppev->cbValueName / sizeof (WCHAR), pBuffer, dwBufSize, NULL,
5807 NULL);
5808 if (len == 0)
5809 {
5810 ret = GetLastError ();
5811 ERR ("WideCharToMultiByte failed with code %i\n", ret);
5812 if (HeapFree (hHeap, 0, pBuffer) == 0)
5813 WARN ("HeapFree failed with code %i\n", GetLastError ());
5814 return ret;
5815 }
5816
5817 memcpy (ppev->pValueName, pBuffer, len);
5818
5819 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
5820
5821 if (ppev->dwType != REG_SZ && ppev->dwType != REG_EXPAND_SZ &&
5822 ppev->dwType != REG_MULTI_SZ)
5823 continue;
5824
5825 len = WideCharToMultiByte (CP_ACP, 0, (LPWSTR) ppev->pData,
5826 ppev->cbData / sizeof (WCHAR), pBuffer, dwBufSize, NULL, NULL);
5827 if (len == 0)
5828 {
5829 ret = GetLastError ();
5830 ERR ("WideCharToMultiByte failed with code %i\n", ret);
5831 if (HeapFree (hHeap, 0, pBuffer) == 0)
5832 WARN ("HeapFree failed with code %i\n", GetLastError ());
5833 return ret;
5834 }
5835
5836 memcpy (ppev->pData, pBuffer, len);
5837
5838 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
5839 TRACE (" (only first string of REG_MULTI_SZ printed)\n");
5840 }
5841
5842 if (HeapFree (hHeap, 0, pBuffer) == 0)
5843 {
5844 ret = GetLastError ();
5845 ERR ("HeapFree failed with code %i\n", ret);
5846 return ret;
5847 }
5848
5849 return ERROR_SUCCESS;
5850 }
5851
5852 /******************************************************************************
5853 * AbortPrinter (WINSPOOL.@)
5854 */
5855 BOOL WINAPI AbortPrinter( HANDLE hPrinter )
5856 {
5857 FIXME("(%p), stub!\n", hPrinter);
5858 return TRUE;
5859 }
5860
5861 /******************************************************************************
5862 * AddPortA (WINSPOOL.@)
5863 *
5864 * See AddPortW.
5865 *
5866 */
5867 BOOL WINAPI AddPortA(LPSTR pName, HWND hWnd, LPSTR pMonitorName)
5868 {
5869 LPWSTR nameW = NULL;
5870 LPWSTR monitorW = NULL;
5871 DWORD len;
5872 BOOL res;
5873
5874 TRACE("(%s, %p, %s)\n",debugstr_a(pName), hWnd, debugstr_a(pMonitorName));
5875
5876 if (pName) {
5877 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
5878 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5879 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
5880 }
5881
5882 if (pMonitorName) {
5883 len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
5884 monitorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5885 MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, monitorW, len);
5886 }
5887 res = AddPortW(nameW, hWnd, monitorW);
5888 HeapFree(GetProcessHeap(), 0, nameW);
5889 HeapFree(GetProcessHeap(), 0, monitorW);
5890 return res;
5891 }
5892
5893 /******************************************************************************
5894 * AddPortW (WINSPOOL.@)
5895 *
5896 * Add a Port for a specific Monitor
5897 *
5898 * PARAMS
5899 * pName [I] Servername or NULL (local Computer)
5900 * hWnd [I] Handle to parent Window for the Dialog-Box
5901 * pMonitorName [I] Name of the Monitor that manage the Port
5902 *
5903 * RETURNS
5904 * Success: TRUE
5905 * Failure: FALSE
5906 *
5907 */
5908 BOOL WINAPI AddPortW(LPWSTR pName, HWND hWnd, LPWSTR pMonitorName)
5909 {
5910 TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pMonitorName));
5911
5912 if ((backend == NULL) && !load_backend()) return FALSE;
5913
5914 if (!pMonitorName) {
5915 SetLastError(RPC_X_NULL_REF_POINTER);
5916 return FALSE;
5917 }
5918
5919 return backend->fpAddPort(pName, hWnd, pMonitorName);
5920 }
5921
5922 /******************************************************************************
5923 * AddPortExA (WINSPOOL.@)
5924 *
5925 * See AddPortExW.
5926 *
5927 */
5928 BOOL WINAPI AddPortExA(LPSTR pName, DWORD level, LPBYTE pBuffer, LPSTR pMonitorName)
5929 {
5930 PORT_INFO_2W pi2W;
5931 PORT_INFO_2A * pi2A;
5932 LPWSTR nameW = NULL;
5933 LPWSTR monitorW = NULL;
5934 DWORD len;
5935 BOOL res;
5936
5937 pi2A = (PORT_INFO_2A *) pBuffer;
5938
5939 TRACE("(%s, %d, %p, %s): %s\n", debugstr_a(pName), level, pBuffer,
5940 debugstr_a(pMonitorName), debugstr_a(pi2A ? pi2A->pPortName : NULL));
5941
5942 if ((level < 1) || (level > 2)) {
5943 SetLastError(ERROR_INVALID_LEVEL);
5944 return FALSE;
5945 }
5946
5947 if (!pi2A) {
5948 SetLastError(ERROR_INVALID_PARAMETER);
5949 return FALSE;
5950 }
5951
5952 if (pName) {
5953 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
5954 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5955 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
5956 }
5957
5958 if (pMonitorName) {
5959 len = MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, NULL, 0);
5960 monitorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5961 MultiByteToWideChar(CP_ACP, 0, pMonitorName, -1, monitorW, len);
5962 }
5963
5964 ZeroMemory(&pi2W, sizeof(PORT_INFO_2W));
5965
5966 if (pi2A->pPortName) {
5967 len = MultiByteToWideChar(CP_ACP, 0, pi2A->pPortName, -1, NULL, 0);
5968 pi2W.pPortName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5969 MultiByteToWideChar(CP_ACP, 0, pi2A->pPortName, -1, pi2W.pPortName, len);
5970 }
5971
5972 if (level > 1) {
5973 if (pi2A->pMonitorName) {
5974 len = MultiByteToWideChar(CP_ACP, 0, pi2A->pMonitorName, -1, NULL, 0);
5975 pi2W.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5976 MultiByteToWideChar(CP_ACP, 0, pi2A->pMonitorName, -1, pi2W.pMonitorName, len);
5977 }
5978
5979 if (pi2A->pDescription) {
5980 len = MultiByteToWideChar(CP_ACP, 0, pi2A->pDescription, -1, NULL, 0);
5981 pi2W.pDescription = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
5982 MultiByteToWideChar(CP_ACP, 0, pi2A->pDescription, -1, pi2W.pDescription, len);
5983 }
5984 pi2W.fPortType = pi2A->fPortType;
5985 pi2W.Reserved = pi2A->Reserved;
5986 }
5987
5988 res = AddPortExW(nameW, level, (LPBYTE) &pi2W, monitorW);
5989
5990 HeapFree(GetProcessHeap(), 0, nameW);
5991 HeapFree(GetProcessHeap(), 0, monitorW);
5992 HeapFree(GetProcessHeap(), 0, pi2W.pPortName);
5993 HeapFree(GetProcessHeap(), 0, pi2W.pMonitorName);
5994 HeapFree(GetProcessHeap(), 0, pi2W.pDescription);
5995 return res;
5996
5997 }
5998
5999 /******************************************************************************
6000 * AddPortExW (WINSPOOL.@)
6001 *
6002 * Add a Port for a specific Monitor, without presenting a user interface
6003 *
6004 * PARAMS
6005 * pName [I] Servername or NULL (local Computer)
6006 * level [I] Structure-Level (1 or 2) for pBuffer
6007 * pBuffer [I] PTR to: PORT_INFO_1 or PORT_INFO_2
6008 * pMonitorName [I] Name of the Monitor that manage the Port
6009 *
6010 * RETURNS
6011 * Success: TRUE
6012 * Failure: FALSE
6013 *
6014 */
6015 BOOL WINAPI AddPortExW(LPWSTR pName, DWORD level, LPBYTE pBuffer, LPWSTR pMonitorName)
6016 {
6017 PORT_INFO_2W * pi2;
6018
6019 pi2 = (PORT_INFO_2W *) pBuffer;
6020
6021 TRACE("(%s, %d, %p, %s): %s %s %s\n", debugstr_w(pName), level, pBuffer,
6022 debugstr_w(pMonitorName), debugstr_w(pi2 ? pi2->pPortName : NULL),
6023 debugstr_w(((level > 1) && pi2) ? pi2->pMonitorName : NULL),
6024 debugstr_w(((level > 1) && pi2) ? pi2->pDescription : NULL));
6025
6026 if ((backend == NULL) && !load_backend()) return FALSE;
6027
6028 if ((!pi2) || (!pMonitorName) || (!pMonitorName[0])) {
6029 SetLastError(ERROR_INVALID_PARAMETER);
6030 return FALSE;
6031 }
6032
6033 return backend->fpAddPortEx(pName, level, pBuffer, pMonitorName);
6034 }
6035
6036 /******************************************************************************
6037 * AddPrinterConnectionA (WINSPOOL.@)
6038 */
6039 BOOL WINAPI AddPrinterConnectionA( LPSTR pName )
6040 {
6041 FIXME("%s\n", debugstr_a(pName));
6042 return FALSE;
6043 }
6044
6045 /******************************************************************************
6046 * AddPrinterConnectionW (WINSPOOL.@)
6047 */
6048 BOOL WINAPI AddPrinterConnectionW( LPWSTR pName )
6049 {
6050 FIXME("%s\n", debugstr_w(pName));
6051 return FALSE;
6052 }
6053
6054 /******************************************************************************
6055 * AddPrinterDriverExW (WINSPOOL.@)
6056 *
6057 * Install a Printer Driver with the Option to upgrade / downgrade the Files
6058 *
6059 * PARAMS
6060 * pName [I] Servername or NULL (local Computer)
6061 * level [I] Level for the supplied DRIVER_INFO_*W struct
6062 * pDriverInfo [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
6063 * dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
6064 *
6065 * RESULTS
6066 * Success: TRUE
6067 * Failure: FALSE
6068 *
6069 */
6070 BOOL WINAPI AddPrinterDriverExW( LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
6071 {
6072 TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
6073
6074 if ((backend == NULL) && !load_backend()) return FALSE;
6075
6076 if (level < 2 || level == 5 || level == 7 || level > 8) {
6077 SetLastError(ERROR_INVALID_LEVEL);
6078 return FALSE;
6079 }
6080
6081 if (!pDriverInfo) {
6082 SetLastError(ERROR_INVALID_PARAMETER);
6083 return FALSE;
6084 }
6085
6086 return backend->fpAddPrinterDriverEx(pName, level, pDriverInfo, dwFileCopyFlags);
6087 }
6088
6089 /******************************************************************************
6090 * AddPrinterDriverExA (WINSPOOL.@)
6091 *
6092 * See AddPrinterDriverExW.
6093 *
6094 */
6095 BOOL WINAPI AddPrinterDriverExA(LPSTR pName, DWORD Level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
6096 {
6097 DRIVER_INFO_8A *diA;
6098 DRIVER_INFO_8W diW;
6099 LPWSTR nameW = NULL;
6100 DWORD lenA;
6101 DWORD len;
6102 DWORD res = FALSE;
6103
6104 TRACE("(%s, %d, %p, 0x%x)\n", debugstr_a(pName), Level, pDriverInfo, dwFileCopyFlags);
6105
6106 diA = (DRIVER_INFO_8A *) pDriverInfo;
6107 ZeroMemory(&diW, sizeof(diW));
6108
6109 if (Level < 2 || Level == 5 || Level == 7 || Level > 8) {
6110 SetLastError(ERROR_INVALID_LEVEL);
6111 return FALSE;
6112 }
6113
6114 if (diA == NULL) {
6115 SetLastError(ERROR_INVALID_PARAMETER);
6116 return FALSE;
6117 }
6118
6119 /* convert servername to unicode */
6120 if (pName) {
6121 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6122 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6123 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6124 }
6125
6126 /* common fields */
6127 diW.cVersion = diA->cVersion;
6128
6129 if (diA->pName) {
6130 len = MultiByteToWideChar(CP_ACP, 0, diA->pName, -1, NULL, 0);
6131 diW.pName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6132 MultiByteToWideChar(CP_ACP, 0, diA->pName, -1, diW.pName, len);
6133 }
6134
6135 if (diA->pEnvironment) {
6136 len = MultiByteToWideChar(CP_ACP, 0, diA->pEnvironment, -1, NULL, 0);
6137 diW.pEnvironment = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6138 MultiByteToWideChar(CP_ACP, 0, diA->pEnvironment, -1, diW.pEnvironment, len);
6139 }
6140
6141 if (diA->pDriverPath) {
6142 len = MultiByteToWideChar(CP_ACP, 0, diA->pDriverPath, -1, NULL, 0);
6143 diW.pDriverPath = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6144 MultiByteToWideChar(CP_ACP, 0, diA->pDriverPath, -1, diW.pDriverPath, len);
6145 }
6146
6147 if (diA->pDataFile) {
6148 len = MultiByteToWideChar(CP_ACP, 0, diA->pDataFile, -1, NULL, 0);
6149 diW.pDataFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6150 MultiByteToWideChar(CP_ACP, 0, diA->pDataFile, -1, diW.pDataFile, len);
6151 }
6152
6153 if (diA->pConfigFile) {
6154 len = MultiByteToWideChar(CP_ACP, 0, diA->pConfigFile, -1, NULL, 0);
6155 diW.pConfigFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6156 MultiByteToWideChar(CP_ACP, 0, diA->pConfigFile, -1, diW.pConfigFile, len);
6157 }
6158
6159 if ((Level > 2) && diA->pDependentFiles) {
6160 lenA = multi_sz_lenA(diA->pDependentFiles);
6161 len = MultiByteToWideChar(CP_ACP, 0, diA->pDependentFiles, lenA, NULL, 0);
6162 diW.pDependentFiles = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6163 MultiByteToWideChar(CP_ACP, 0, diA->pDependentFiles, lenA, diW.pDependentFiles, len);
6164 }
6165
6166 if ((Level > 2) && diA->pMonitorName) {
6167 len = MultiByteToWideChar(CP_ACP, 0, diA->pMonitorName, -1, NULL, 0);
6168 diW.pMonitorName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6169 MultiByteToWideChar(CP_ACP, 0, diA->pMonitorName, -1, diW.pMonitorName, len);
6170 }
6171
6172 if ((Level > 3) && diA->pDefaultDataType) {
6173 len = MultiByteToWideChar(CP_ACP, 0, diA->pDefaultDataType, -1, NULL, 0);
6174 diW.pDefaultDataType = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6175 MultiByteToWideChar(CP_ACP, 0, diA->pDefaultDataType, -1, diW.pDefaultDataType, len);
6176 }
6177
6178 if ((Level > 3) && diA->pszzPreviousNames) {
6179 lenA = multi_sz_lenA(diA->pszzPreviousNames);
6180 len = MultiByteToWideChar(CP_ACP, 0, diA->pszzPreviousNames, lenA, NULL, 0);
6181 diW.pszzPreviousNames = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6182 MultiByteToWideChar(CP_ACP, 0, diA->pszzPreviousNames, lenA, diW.pszzPreviousNames, len);
6183 }
6184
6185 if ((Level > 5) && diA->pszMfgName) {
6186 len = MultiByteToWideChar(CP_ACP, 0, diA->pszMfgName, -1, NULL, 0);
6187 diW.pszMfgName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6188 MultiByteToWideChar(CP_ACP, 0, diA->pszMfgName, -1, diW.pszMfgName, len);
6189 }
6190
6191 if ((Level > 5) && diA->pszOEMUrl) {
6192 len = MultiByteToWideChar(CP_ACP, 0, diA->pszOEMUrl, -1, NULL, 0);
6193 diW.pszOEMUrl = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6194 MultiByteToWideChar(CP_ACP, 0, diA->pszOEMUrl, -1, diW.pszOEMUrl, len);
6195 }
6196
6197 if ((Level > 5) && diA->pszHardwareID) {
6198 len = MultiByteToWideChar(CP_ACP, 0, diA->pszHardwareID, -1, NULL, 0);
6199 diW.pszHardwareID = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6200 MultiByteToWideChar(CP_ACP, 0, diA->pszHardwareID, -1, diW.pszHardwareID, len);
6201 }
6202
6203 if ((Level > 5) && diA->pszProvider) {
6204 len = MultiByteToWideChar(CP_ACP, 0, diA->pszProvider, -1, NULL, 0);
6205 diW.pszProvider = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6206 MultiByteToWideChar(CP_ACP, 0, diA->pszProvider, -1, diW.pszProvider, len);
6207 }
6208
6209 if (Level > 7) {
6210 FIXME("level %u is incomplete\n", Level);
6211 }
6212
6213 res = AddPrinterDriverExW(nameW, Level, (LPBYTE) &diW, dwFileCopyFlags);
6214 TRACE("got %u with %u\n", res, GetLastError());
6215 HeapFree(GetProcessHeap(), 0, nameW);
6216 HeapFree(GetProcessHeap(), 0, diW.pName);
6217 HeapFree(GetProcessHeap(), 0, diW.pEnvironment);
6218 HeapFree(GetProcessHeap(), 0, diW.pDriverPath);
6219 HeapFree(GetProcessHeap(), 0, diW.pDataFile);
6220 HeapFree(GetProcessHeap(), 0, diW.pConfigFile);
6221 HeapFree(GetProcessHeap(), 0, diW.pDependentFiles);
6222 HeapFree(GetProcessHeap(), 0, diW.pMonitorName);
6223 HeapFree(GetProcessHeap(), 0, diW.pDefaultDataType);
6224 HeapFree(GetProcessHeap(), 0, diW.pszzPreviousNames);
6225 HeapFree(GetProcessHeap(), 0, diW.pszMfgName);
6226 HeapFree(GetProcessHeap(), 0, diW.pszOEMUrl);
6227 HeapFree(GetProcessHeap(), 0, diW.pszHardwareID);
6228 HeapFree(GetProcessHeap(), 0, diW.pszProvider);
6229
6230 TRACE("=> %u with %u\n", res, GetLastError());
6231 return res;
6232 }
6233
6234 /******************************************************************************
6235 * ConfigurePortA (WINSPOOL.@)
6236 *
6237 * See ConfigurePortW.
6238 *
6239 */
6240 BOOL WINAPI ConfigurePortA(LPSTR pName, HWND hWnd, LPSTR pPortName)
6241 {
6242 LPWSTR nameW = NULL;
6243 LPWSTR portW = NULL;
6244 INT len;
6245 DWORD res;
6246
6247 TRACE("(%s, %p, %s)\n", debugstr_a(pName), hWnd, debugstr_a(pPortName));
6248
6249 /* convert servername to unicode */
6250 if (pName) {
6251 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6252 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6253 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6254 }
6255
6256 /* convert portname to unicode */
6257 if (pPortName) {
6258 len = MultiByteToWideChar(CP_ACP, 0, pPortName, -1, NULL, 0);
6259 portW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6260 MultiByteToWideChar(CP_ACP, 0, pPortName, -1, portW, len);
6261 }
6262
6263 res = ConfigurePortW(nameW, hWnd, portW);
6264 HeapFree(GetProcessHeap(), 0, nameW);
6265 HeapFree(GetProcessHeap(), 0, portW);
6266 return res;
6267 }
6268
6269 /******************************************************************************
6270 * ConfigurePortW (WINSPOOL.@)
6271 *
6272 * Display the Configuration-Dialog for a specific Port
6273 *
6274 * PARAMS
6275 * pName [I] Servername or NULL (local Computer)
6276 * hWnd [I] Handle to parent Window for the Dialog-Box
6277 * pPortName [I] Name of the Port, that should be configured
6278 *
6279 * RETURNS
6280 * Success: TRUE
6281 * Failure: FALSE
6282 *
6283 */
6284 BOOL WINAPI ConfigurePortW(LPWSTR pName, HWND hWnd, LPWSTR pPortName)
6285 {
6286
6287 TRACE("(%s, %p, %s)\n", debugstr_w(pName), hWnd, debugstr_w(pPortName));
6288
6289 if ((backend == NULL) && !load_backend()) return FALSE;
6290
6291 if (!pPortName) {
6292 SetLastError(RPC_X_NULL_REF_POINTER);
6293 return FALSE;
6294 }
6295
6296 return backend->fpConfigurePort(pName, hWnd, pPortName);
6297 }
6298
6299 /******************************************************************************
6300 * ConnectToPrinterDlg (WINSPOOL.@)
6301 */
6302 HANDLE WINAPI ConnectToPrinterDlg( HWND hWnd, DWORD Flags )
6303 {
6304 FIXME("%p %x\n", hWnd, Flags);
6305 return NULL;
6306 }
6307
6308 /******************************************************************************
6309 * DeletePrinterConnectionA (WINSPOOL.@)
6310 */
6311 BOOL WINAPI DeletePrinterConnectionA( LPSTR pName )
6312 {
6313 FIXME("%s\n", debugstr_a(pName));
6314 return TRUE;
6315 }
6316
6317 /******************************************************************************
6318 * DeletePrinterConnectionW (WINSPOOL.@)
6319 */
6320 BOOL WINAPI DeletePrinterConnectionW( LPWSTR pName )
6321 {
6322 FIXME("%s\n", debugstr_w(pName));
6323 return TRUE;
6324 }
6325
6326 /******************************************************************************
6327 * DeletePrinterDriverExW (WINSPOOL.@)
6328 */
6329 BOOL WINAPI DeletePrinterDriverExW( LPWSTR pName, LPWSTR pEnvironment,
6330 LPWSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
6331 {
6332 HKEY hkey_drivers;
6333 BOOL ret = FALSE;
6334
6335 TRACE("%s %s %s %x %x\n", debugstr_w(pName), debugstr_w(pEnvironment),
6336 debugstr_w(pDriverName), dwDeleteFlag, dwVersionFlag);
6337
6338 if(pName && pName[0])
6339 {
6340 FIXME("pName = %s - unsupported\n", debugstr_w(pName));
6341 SetLastError(ERROR_INVALID_PARAMETER);
6342 return FALSE;
6343 }
6344
6345 if(dwDeleteFlag)
6346 {
6347 FIXME("dwDeleteFlag = %x - unsupported\n", dwDeleteFlag);
6348 SetLastError(ERROR_INVALID_PARAMETER);
6349 return FALSE;
6350 }
6351
6352 hkey_drivers = WINSPOOL_OpenDriverReg(pEnvironment);
6353
6354 if(!hkey_drivers)
6355 {
6356 ERR("Can't open drivers key\n");
6357 return FALSE;
6358 }
6359
6360 if(RegDeleteTreeW(hkey_drivers, pDriverName) == ERROR_SUCCESS)
6361 ret = TRUE;
6362
6363 RegCloseKey(hkey_drivers);
6364
6365 return ret;
6366 }
6367
6368 /******************************************************************************
6369 * DeletePrinterDriverExA (WINSPOOL.@)
6370 */
6371 BOOL WINAPI DeletePrinterDriverExA( LPSTR pName, LPSTR pEnvironment,
6372 LPSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
6373 {
6374 UNICODE_STRING NameW, EnvW, DriverW;
6375 BOOL ret;
6376
6377 asciitounicode(&NameW, pName);
6378 asciitounicode(&EnvW, pEnvironment);
6379 asciitounicode(&DriverW, pDriverName);
6380
6381 ret = DeletePrinterDriverExW(NameW.Buffer, EnvW.Buffer, DriverW.Buffer, dwDeleteFlag, dwVersionFlag);
6382
6383 RtlFreeUnicodeString(&DriverW);
6384 RtlFreeUnicodeString(&EnvW);
6385 RtlFreeUnicodeString(&NameW);
6386
6387 return ret;
6388 }
6389
6390 /******************************************************************************
6391 * DeletePrinterDataExW (WINSPOOL.@)
6392 */
6393 DWORD WINAPI DeletePrinterDataExW( HANDLE hPrinter, LPCWSTR pKeyName,
6394 LPCWSTR pValueName)
6395 {
6396 FIXME("%p %s %s\n", hPrinter,
6397 debugstr_w(pKeyName), debugstr_w(pValueName));
6398 return ERROR_INVALID_PARAMETER;
6399 }
6400
6401 /******************************************************************************
6402 * DeletePrinterDataExA (WINSPOOL.@)
6403 */
6404 DWORD WINAPI DeletePrinterDataExA( HANDLE hPrinter, LPCSTR pKeyName,
6405 LPCSTR pValueName)
6406 {
6407 FIXME("%p %s %s\n", hPrinter,
6408 debugstr_a(pKeyName), debugstr_a(pValueName));
6409 return ERROR_INVALID_PARAMETER;
6410 }
6411
6412 /******************************************************************************
6413 * DeletePrintProcessorA (WINSPOOL.@)
6414 */
6415 BOOL WINAPI DeletePrintProcessorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProcessorName)
6416 {
6417 FIXME("%s %s %s\n", debugstr_a(pName), debugstr_a(pEnvironment),
6418 debugstr_a(pPrintProcessorName));
6419 return TRUE;
6420 }
6421
6422 /******************************************************************************
6423 * DeletePrintProcessorW (WINSPOOL.@)
6424 */
6425 BOOL WINAPI DeletePrintProcessorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProcessorName)
6426 {
6427 FIXME("%s %s %s\n", debugstr_w(pName), debugstr_w(pEnvironment),
6428 debugstr_w(pPrintProcessorName));
6429 return TRUE;
6430 }
6431
6432 /******************************************************************************
6433 * DeletePrintProvidorA (WINSPOOL.@)
6434 */
6435 BOOL WINAPI DeletePrintProvidorA(LPSTR pName, LPSTR pEnvironment, LPSTR pPrintProviderName)
6436 {
6437 FIXME("%s %s %s\n", debugstr_a(pName), debugstr_a(pEnvironment),
6438 debugstr_a(pPrintProviderName));
6439 return TRUE;
6440 }
6441
6442 /******************************************************************************
6443 * DeletePrintProvidorW (WINSPOOL.@)
6444 */
6445 BOOL WINAPI DeletePrintProvidorW(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pPrintProviderName)
6446 {
6447 FIXME("%s %s %s\n", debugstr_w(pName), debugstr_w(pEnvironment),
6448 debugstr_w(pPrintProviderName));
6449 return TRUE;
6450 }
6451
6452 /******************************************************************************
6453 * EnumFormsA (WINSPOOL.@)
6454 */
6455 BOOL WINAPI EnumFormsA( HANDLE hPrinter, DWORD Level, LPBYTE pForm,
6456 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned )
6457 {
6458 FIXME("%p %x %p %x %p %p\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
6459 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6460 return FALSE;
6461 }
6462
6463 /******************************************************************************
6464 * EnumFormsW (WINSPOOL.@)
6465 */
6466 BOOL WINAPI EnumFormsW( HANDLE hPrinter, DWORD Level, LPBYTE pForm,
6467 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned )
6468 {
6469 FIXME("%p %x %p %x %p %p\n", hPrinter, Level, pForm, cbBuf, pcbNeeded, pcReturned);
6470 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
6471 return FALSE;
6472 }
6473
6474 /*****************************************************************************
6475 * EnumMonitorsA [WINSPOOL.@]
6476 *
6477 * See EnumMonitorsW.
6478 *
6479 */
6480 BOOL WINAPI EnumMonitorsA(LPSTR pName, DWORD Level, LPBYTE pMonitors,
6481 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6482 {
6483 BOOL res;
6484 LPBYTE bufferW = NULL;
6485 LPWSTR nameW = NULL;
6486 DWORD needed = 0;
6487 DWORD numentries = 0;
6488 INT len;
6489
6490 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), Level, pMonitors,
6491 cbBuf, pcbNeeded, pcReturned);
6492
6493 /* convert servername to unicode */
6494 if (pName) {
6495 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6496 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6497 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6498 }
6499 /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the monitors */
6500 needed = cbBuf * sizeof(WCHAR);
6501 if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
6502 res = EnumMonitorsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
6503
6504 if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
6505 if (pcbNeeded) needed = *pcbNeeded;
6506 /* HeapReAlloc return NULL, when bufferW was NULL */
6507 bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
6508 HeapAlloc(GetProcessHeap(), 0, needed);
6509
6510 /* Try again with the large Buffer */
6511 res = EnumMonitorsW(nameW, Level, bufferW, needed, pcbNeeded, pcReturned);
6512 }
6513 numentries = pcReturned ? *pcReturned : 0;
6514 needed = 0;
6515 /*
6516 W2k require the buffersize from EnumMonitorsW also for EnumMonitorsA.
6517 We use the smaller Ansi-Size to avoid conflicts with fixed Buffers of old Apps.
6518 */
6519 if (res) {
6520 /* EnumMonitorsW collected all Data. Parse them to calculate ANSI-Size */
6521 DWORD entrysize = 0;
6522 DWORD index;
6523 LPSTR ptr;
6524 LPMONITOR_INFO_2W mi2w;
6525 LPMONITOR_INFO_2A mi2a;
6526
6527 /* MONITOR_INFO_*W and MONITOR_INFO_*A have the same size */
6528 entrysize = (Level == 1) ? sizeof(MONITOR_INFO_1A) : sizeof(MONITOR_INFO_2A);
6529
6530 /* First pass: calculate the size for all Entries */
6531 mi2w = (LPMONITOR_INFO_2W) bufferW;
6532 mi2a = (LPMONITOR_INFO_2A) pMonitors;
6533 index = 0;
6534 while (index < numentries) {
6535 index++;
6536 needed += entrysize; /* MONITOR_INFO_?A */
6537 TRACE("%p: parsing #%d (%s)\n", mi2w, index, debugstr_w(mi2w->pName));
6538
6539 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pName, -1,
6540 NULL, 0, NULL, NULL);
6541 if (Level > 1) {
6542 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pEnvironment, -1,
6543 NULL, 0, NULL, NULL);
6544 needed += WideCharToMultiByte(CP_ACP, 0, mi2w->pDLLName, -1,
6545 NULL, 0, NULL, NULL);
6546 }
6547 /* use LPBYTE with entrysize to avoid double code (MONITOR_INFO_1 + MONITOR_INFO_2) */
6548 mi2w = (LPMONITOR_INFO_2W) (((LPBYTE)mi2w) + entrysize);
6549 mi2a = (LPMONITOR_INFO_2A) (((LPBYTE)mi2a) + entrysize);
6550 }
6551
6552 /* check for errors and quit on failure */
6553 if (cbBuf < needed) {
6554 SetLastError(ERROR_INSUFFICIENT_BUFFER);
6555 res = FALSE;
6556 goto emA_cleanup;
6557 }
6558 len = entrysize * numentries; /* room for all MONITOR_INFO_?A */
6559 ptr = (LPSTR) &pMonitors[len]; /* room for strings */
6560 cbBuf -= len ; /* free Bytes in the user-Buffer */
6561 mi2w = (LPMONITOR_INFO_2W) bufferW;
6562 mi2a = (LPMONITOR_INFO_2A) pMonitors;
6563 index = 0;
6564 /* Second Pass: Fill the User Buffer (if we have one) */
6565 while ((index < numentries) && pMonitors) {
6566 index++;
6567 TRACE("%p: writing MONITOR_INFO_%dA #%d\n", mi2a, Level, index);
6568 mi2a->pName = ptr;
6569 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pName, -1,
6570 ptr, cbBuf , NULL, NULL);
6571 ptr += len;
6572 cbBuf -= len;
6573 if (Level > 1) {
6574 mi2a->pEnvironment = ptr;
6575 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pEnvironment, -1,
6576 ptr, cbBuf, NULL, NULL);
6577 ptr += len;
6578 cbBuf -= len;
6579
6580 mi2a->pDLLName = ptr;
6581 len = WideCharToMultiByte(CP_ACP, 0, mi2w->pDLLName, -1,
6582 ptr, cbBuf, NULL, NULL);
6583 ptr += len;
6584 cbBuf -= len;
6585 }
6586 /* use LPBYTE with entrysize to avoid double code (MONITOR_INFO_1 + MONITOR_INFO_2) */
6587 mi2w = (LPMONITOR_INFO_2W) (((LPBYTE)mi2w) + entrysize);
6588 mi2a = (LPMONITOR_INFO_2A) (((LPBYTE)mi2a) + entrysize);
6589 }
6590 }
6591 emA_cleanup:
6592 if (pcbNeeded) *pcbNeeded = needed;
6593 if (pcReturned) *pcReturned = (res) ? numentries : 0;
6594
6595 HeapFree(GetProcessHeap(), 0, nameW);
6596 HeapFree(GetProcessHeap(), 0, bufferW);
6597
6598 TRACE("returning %d with %d (%d byte for %d entries)\n",
6599 (res), GetLastError(), needed, numentries);
6600
6601 return (res);
6602
6603 }
6604
6605 /*****************************************************************************
6606 * EnumMonitorsW [WINSPOOL.@]
6607 *
6608 * Enumerate available Port-Monitors
6609 *
6610 * PARAMS
6611 * pName [I] Servername or NULL (local Computer)
6612 * Level [I] Structure-Level (1:Win9x+NT or 2:NT only)
6613 * pMonitors [O] PTR to Buffer that receives the Result
6614 * cbBuf [I] Size of Buffer at pMonitors
6615 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
6616 * pcReturned [O] PTR to DWORD that receives the number of Monitors in pMonitors
6617 *
6618 * RETURNS
6619 * Success: TRUE
6620 * Failure: FALSE and in pcbNeeded the Bytes required for buffer, if cbBuf is too small
6621 *
6622 */
6623 BOOL WINAPI EnumMonitorsW(LPWSTR pName, DWORD Level, LPBYTE pMonitors,
6624 DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6625 {
6626
6627 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pMonitors,
6628 cbBuf, pcbNeeded, pcReturned);
6629
6630 if ((backend == NULL) && !load_backend()) return FALSE;
6631
6632 if (!pcbNeeded || !pcReturned || (!pMonitors && (cbBuf > 0))) {
6633 SetLastError(RPC_X_NULL_REF_POINTER);
6634 return FALSE;
6635 }
6636
6637 return backend->fpEnumMonitors(pName, Level, pMonitors, cbBuf, pcbNeeded, pcReturned);
6638 }
6639
6640 /******************************************************************************
6641 * SpoolerInit (WINSPOOL.@)
6642 *
6643 * Initialize the Spooler
6644 *
6645 * RETURNS
6646 * Success: TRUE
6647 * Failure: FALSE
6648 *
6649 * NOTES
6650 * The function fails on windows, when the spooler service is not running
6651 *
6652 */
6653 BOOL WINAPI SpoolerInit(void)
6654 {
6655
6656 if ((backend == NULL) && !load_backend()) return FALSE;
6657 return TRUE;
6658 }
6659
6660 /******************************************************************************
6661 * XcvDataW (WINSPOOL.@)
6662 *
6663 * Execute commands in the Printmonitor DLL
6664 *
6665 * PARAMS
6666 * hXcv [i] Handle from OpenPrinter (with XcvMonitor or XcvPort)
6667 * pszDataName [i] Name of the command to execute
6668 * pInputData [i] Buffer for extra Input Data (needed only for some commands)
6669 * cbInputData [i] Size in Bytes of Buffer at pInputData
6670 * pOutputData [o] Buffer to receive additional Data (needed only for some commands)
6671 * cbOutputData [i] Size in Bytes of Buffer at pOutputData
6672 * pcbOutputNeeded [o] PTR to receive the minimal Size in Bytes of the Buffer at pOutputData
6673 * pdwStatus [o] PTR to receive the win32 error code from the Printmonitor DLL
6674 *
6675 * RETURNS
6676 * Success: TRUE
6677 * Failure: FALSE
6678 *
6679 * NOTES
6680 * Returning "TRUE" does mean, that the Printmonitor DLL was called successful.
6681 * The execution of the command can still fail (check pdwStatus for ERROR_SUCCESS).
6682 *
6683 * Minimal List of commands, that a Printmonitor DLL should support:
6684 *
6685 *| "MonitorUI" : Return the Name of the Userinterface-DLL as WSTR in pOutputData
6686 *| "AddPort" : Add a Port
6687 *| "DeletePort": Delete a Port
6688 *
6689 * Many Printmonitors support additional commands. Examples for localspl.dll:
6690 * "GetDefaultCommConfig", "SetDefaultCommConfig",
6691 * "GetTransmissionRetryTimeout", "ConfigureLPTPortCommandOK"
6692 *
6693 */
6694 BOOL WINAPI XcvDataW( HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData,
6695 DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData,
6696 PDWORD pcbOutputNeeded, PDWORD pdwStatus)
6697 {
6698 opened_printer_t *printer;
6699
6700 TRACE("(%p, %s, %p, %d, %p, %d, %p, %p)\n", hXcv, debugstr_w(pszDataName),
6701 pInputData, cbInputData, pOutputData,
6702 cbOutputData, pcbOutputNeeded, pdwStatus);
6703
6704 if ((backend == NULL) && !load_backend()) return FALSE;
6705
6706 printer = get_opened_printer(hXcv);
6707 if (!printer || (!printer->backend_printer)) {
6708 SetLastError(ERROR_INVALID_HANDLE);
6709 return FALSE;
6710 }
6711
6712 if (!pcbOutputNeeded) {
6713 SetLastError(ERROR_INVALID_PARAMETER);
6714 return FALSE;
6715 }
6716
6717 if (!pszDataName || !pdwStatus || (!pOutputData && (cbOutputData > 0))) {
6718 SetLastError(RPC_X_NULL_REF_POINTER);
6719 return FALSE;
6720 }
6721
6722 *pcbOutputNeeded = 0;
6723
6724 return backend->fpXcvData(printer->backend_printer, pszDataName, pInputData,
6725 cbInputData, pOutputData, cbOutputData, pcbOutputNeeded, pdwStatus);
6726
6727 }
6728
6729 /*****************************************************************************
6730 * EnumPrinterDataA [WINSPOOL.@]
6731 *
6732 */
6733 DWORD WINAPI EnumPrinterDataA( HANDLE hPrinter, DWORD dwIndex, LPSTR pValueName,
6734 DWORD cbValueName, LPDWORD pcbValueName, LPDWORD pType, LPBYTE pData,
6735 DWORD cbData, LPDWORD pcbData )
6736 {
6737 FIXME("%p %x %p %x %p %p %p %x %p\n", hPrinter, dwIndex, pValueName,
6738 cbValueName, pcbValueName, pType, pData, cbData, pcbData);
6739 return ERROR_NO_MORE_ITEMS;
6740 }
6741
6742 /*****************************************************************************
6743 * EnumPrinterDataW [WINSPOOL.@]
6744 *
6745 */
6746 DWORD WINAPI EnumPrinterDataW( HANDLE hPrinter, DWORD dwIndex, LPWSTR pValueName,
6747 DWORD cbValueName, LPDWORD pcbValueName, LPDWORD pType, LPBYTE pData,
6748 DWORD cbData, LPDWORD pcbData )
6749 {
6750 FIXME("%p %x %p %x %p %p %p %x %p\n", hPrinter, dwIndex, pValueName,
6751 cbValueName, pcbValueName, pType, pData, cbData, pcbData);
6752 return ERROR_NO_MORE_ITEMS;
6753 }
6754
6755 /*****************************************************************************
6756 * EnumPrintProcessorDatatypesA [WINSPOOL.@]
6757 *
6758 */
6759 BOOL WINAPI EnumPrintProcessorDatatypesA(LPSTR pName, LPSTR pPrintProcessorName,
6760 DWORD Level, LPBYTE pDatatypes, DWORD cbBuf,
6761 LPDWORD pcbNeeded, LPDWORD pcReturned)
6762 {
6763 FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_a(pName),
6764 debugstr_a(pPrintProcessorName), Level, pDatatypes, cbBuf,
6765 pcbNeeded, pcReturned);
6766 return FALSE;
6767 }
6768
6769 /*****************************************************************************
6770 * EnumPrintProcessorDatatypesW [WINSPOOL.@]
6771 *
6772 */
6773 BOOL WINAPI EnumPrintProcessorDatatypesW(LPWSTR pName, LPWSTR pPrintProcessorName,
6774 DWORD Level, LPBYTE pDatatypes, DWORD cbBuf,
6775 LPDWORD pcbNeeded, LPDWORD pcReturned)
6776 {
6777 FIXME("Stub: %s %s %d %p %d %p %p\n", debugstr_w(pName),
6778 debugstr_w(pPrintProcessorName), Level, pDatatypes, cbBuf,
6779 pcbNeeded, pcReturned);
6780 return FALSE;
6781 }
6782
6783 /*****************************************************************************
6784 * EnumPrintProcessorsA [WINSPOOL.@]
6785 *
6786 * See EnumPrintProcessorsW.
6787 *
6788 */
6789 BOOL WINAPI EnumPrintProcessorsA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
6790 LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6791 {
6792 BOOL res;
6793 LPBYTE bufferW = NULL;
6794 LPWSTR nameW = NULL;
6795 LPWSTR envW = NULL;
6796 DWORD needed = 0;
6797 DWORD numentries = 0;
6798 INT len;
6799
6800 TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_a(pName), debugstr_a(pEnvironment),
6801 Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
6802
6803 /* convert names to unicode */
6804 if (pName) {
6805 len = MultiByteToWideChar(CP_ACP, 0, pName, -1, NULL, 0);
6806 nameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6807 MultiByteToWideChar(CP_ACP, 0, pName, -1, nameW, len);
6808 }
6809 if (pEnvironment) {
6810 len = MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, NULL, 0);
6811 envW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
6812 MultiByteToWideChar(CP_ACP, 0, pEnvironment, -1, envW, len);
6813 }
6814
6815 /* alloc (userbuffersize*sizeof(WCHAR) and try to enum the monitors */
6816 needed = cbBuf * sizeof(WCHAR);
6817 if (needed) bufferW = HeapAlloc(GetProcessHeap(), 0, needed);
6818 res = EnumPrintProcessorsW(nameW, envW, Level, bufferW, needed, pcbNeeded, pcReturned);
6819
6820 if(!res && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
6821 if (pcbNeeded) needed = *pcbNeeded;
6822 /* HeapReAlloc return NULL, when bufferW was NULL */
6823 bufferW = (bufferW) ? HeapReAlloc(GetProcessHeap(), 0, bufferW, needed) :
6824 HeapAlloc(GetProcessHeap(), 0, needed);
6825
6826 /* Try again with the large Buffer */
6827 res = EnumPrintProcessorsW(nameW, envW, Level, bufferW, needed, pcbNeeded, pcReturned);
6828 }
6829 numentries = pcReturned ? *pcReturned : 0;
6830 needed = 0;
6831
6832 if (res) {
6833 /* EnumPrintProcessorsW collected all Data. Parse them to calculate ANSI-Size */
6834 DWORD index;
6835 LPSTR ptr;
6836 PPRINTPROCESSOR_INFO_1W ppiw;
6837 PPRINTPROCESSOR_INFO_1A ppia;
6838
6839 /* First pass: calculate the size for all Entries */
6840 ppiw = (PPRINTPROCESSOR_INFO_1W) bufferW;
6841 ppia = (PPRINTPROCESSOR_INFO_1A) pPPInfo;
6842 index = 0;
6843 while (index < numentries) {
6844 index++;
6845 needed += sizeof(PRINTPROCESSOR_INFO_1A);
6846 TRACE("%p: parsing #%d (%s)\n", ppiw, index, debugstr_w(ppiw->pName));
6847
6848 needed += WideCharToMultiByte(CP_ACP, 0, ppiw->pName, -1,
6849 NULL, 0, NULL, NULL);
6850
6851 ppiw = (PPRINTPROCESSOR_INFO_1W) (((LPBYTE)ppiw) + sizeof(PRINTPROCESSOR_INFO_1W));
6852 ppia = (PPRINTPROCESSOR_INFO_1A) (((LPBYTE)ppia) + sizeof(PRINTPROCESSOR_INFO_1A));
6853 }
6854
6855 /* check for errors and quit on failure */
6856 if (cbBuf < needed) {
6857 SetLastError(ERROR_INSUFFICIENT_BUFFER);
6858 res = FALSE;
6859 goto epp_cleanup;
6860 }
6861
6862 len = numentries * sizeof(PRINTPROCESSOR_INFO_1A); /* room for structs */
6863 ptr = (LPSTR) &pPPInfo[len]; /* start of strings */
6864 cbBuf -= len ; /* free Bytes in the user-Buffer */
6865 ppiw = (PPRINTPROCESSOR_INFO_1W) bufferW;
6866 ppia = (PPRINTPROCESSOR_INFO_1A) pPPInfo;
6867 index = 0;
6868 /* Second Pass: Fill the User Buffer (if we have one) */
6869 while ((index < numentries) && pPPInfo) {
6870 index++;
6871 TRACE("%p: writing PRINTPROCESSOR_INFO_1A #%d\n", ppia, index);
6872 ppia->pName = ptr;
6873 len = WideCharToMultiByte(CP_ACP, 0, ppiw->pName, -1,
6874 ptr, cbBuf , NULL, NULL);
6875 ptr += len;
6876 cbBuf -= len;
6877
6878 ppiw = (PPRINTPROCESSOR_INFO_1W) (((LPBYTE)ppiw) + sizeof(PRINTPROCESSOR_INFO_1W));
6879 ppia = (PPRINTPROCESSOR_INFO_1A) (((LPBYTE)ppia) + sizeof(PRINTPROCESSOR_INFO_1A));
6880
6881 }
6882 }
6883 epp_cleanup:
6884 if (pcbNeeded) *pcbNeeded = needed;
6885 if (pcReturned) *pcReturned = (res) ? numentries : 0;
6886
6887 HeapFree(GetProcessHeap(), 0, nameW);
6888 HeapFree(GetProcessHeap(), 0, envW);
6889 HeapFree(GetProcessHeap(), 0, bufferW);
6890
6891 TRACE("returning %d with %d (%d byte for %d entries)\n",
6892 (res), GetLastError(), needed, numentries);
6893
6894 return (res);
6895 }
6896
6897 /*****************************************************************************
6898 * EnumPrintProcessorsW [WINSPOOL.@]
6899 *
6900 * Enumerate available Print Processors
6901 *
6902 * PARAMS
6903 * pName [I] Servername or NULL (local Computer)
6904 * pEnvironment [I] Printing-Environment or NULL (Default)
6905 * Level [I] Structure-Level (Only 1 is allowed)
6906 * pPPInfo [O] PTR to Buffer that receives the Result
6907 * cbBuf [I] Size of Buffer at pPPInfo
6908 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pPPInfo
6909 * pcReturned [O] PTR to DWORD that receives the number of Print Processors in pPPInfo
6910 *
6911 * RETURNS
6912 * Success: TRUE
6913 * Failure: FALSE and in pcbNeeded the Bytes required for pPPInfo, if cbBuf is too small
6914 *
6915 */
6916 BOOL WINAPI EnumPrintProcessorsW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
6917 LPBYTE pPPInfo, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned)
6918 {
6919
6920 TRACE("(%s, %s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), debugstr_w(pEnvironment),
6921 Level, pPPInfo, cbBuf, pcbNeeded, pcReturned);
6922
6923 if ((backend == NULL) && !load_backend()) return FALSE;
6924
6925 if (!pcbNeeded || !pcReturned) {
6926 SetLastError(RPC_X_NULL_REF_POINTER);
6927 return FALSE;
6928 }
6929
6930 if (!pPPInfo && (cbBuf > 0)) {
6931 SetLastError(ERROR_INVALID_USER_BUFFER);
6932 return FALSE;
6933 }
6934
6935 return backend->fpEnumPrintProcessors(pName, pEnvironment, Level, pPPInfo,
6936 cbBuf, pcbNeeded, pcReturned);
6937 }
6938
6939 /*****************************************************************************
6940 * ExtDeviceMode [WINSPOOL.@]
6941 *
6942 */
6943 LONG WINAPI ExtDeviceMode( HWND hWnd, HANDLE hInst, LPDEVMODEA pDevModeOutput,
6944 LPSTR pDeviceName, LPSTR pPort, LPDEVMODEA pDevModeInput, LPSTR pProfile,
6945 DWORD fMode)
6946 {
6947 FIXME("Stub: %p %p %p %s %s %p %s %x\n", hWnd, hInst, pDevModeOutput,
6948 debugstr_a(pDeviceName), debugstr_a(pPort), pDevModeInput,
6949 debugstr_a(pProfile), fMode);
6950 return -1;
6951 }
6952
6953 /*****************************************************************************
6954 * FindClosePrinterChangeNotification [WINSPOOL.@]
6955 *
6956 */
6957 BOOL WINAPI FindClosePrinterChangeNotification( HANDLE hChange )
6958 {
6959 FIXME("Stub: %p\n", hChange);
6960 return TRUE;
6961 }
6962
6963 /*****************************************************************************
6964 * FindFirstPrinterChangeNotification [WINSPOOL.@]
6965 *
6966 */
6967 HANDLE WINAPI FindFirstPrinterChangeNotification( HANDLE hPrinter,
6968 DWORD fdwFlags, DWORD fdwOptions, LPVOID pPrinterNotifyOptions )
6969 {
6970 FIXME("Stub: %p %x %x %p\n",
6971 hPrinter, fdwFlags, fdwOptions, pPrinterNotifyOptions);
6972 return INVALID_HANDLE_VALUE;
6973 }
6974
6975 /*****************************************************************************
6976 * FindNextPrinterChangeNotification [WINSPOOL.@]
6977 *
6978 */
6979 BOOL WINAPI FindNextPrinterChangeNotification( HANDLE hChange, PDWORD pdwChange,
6980 LPVOID pPrinterNotifyOptions, LPVOID *ppPrinterNotifyInfo )
6981 {
6982 FIXME("Stub: %p %p %p %p\n",
6983 hChange, pdwChange, pPrinterNotifyOptions, ppPrinterNotifyInfo);
6984 return FALSE;
6985 }
6986
6987 /*****************************************************************************
6988 * FreePrinterNotifyInfo [WINSPOOL.@]
6989 *
6990 */
6991 BOOL WINAPI FreePrinterNotifyInfo( PPRINTER_NOTIFY_INFO pPrinterNotifyInfo )
6992 {
6993 FIXME("Stub: %p\n", pPrinterNotifyInfo);
6994 return TRUE;
6995 }
6996
6997 /*****************************************************************************
6998 * string_to_buf
6999 *
7000 * Copies a unicode string into a buffer. The buffer will either contain unicode or
7001 * ansi depending on the unicode parameter.
7002 */
7003 static BOOL string_to_buf(LPCWSTR str, LPBYTE ptr, DWORD cb, DWORD *size, BOOL unicode)
7004 {
7005 if(!str)
7006 {
7007 *size = 0;
7008 return TRUE;
7009 }
7010
7011 if(unicode)
7012 {
7013 *size = (strlenW(str) + 1) * sizeof(WCHAR);
7014 if(*size <= cb)
7015 {
7016 memcpy(ptr, str, *size);
7017 return TRUE;
7018 }
7019 return FALSE;
7020 }
7021 else
7022 {
7023 *size = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL);
7024 if(*size <= cb)
7025 {
7026 WideCharToMultiByte(CP_ACP, 0, str, -1, (LPSTR)ptr, *size, NULL, NULL);
7027 return TRUE;
7028 }
7029 return FALSE;
7030 }
7031 }
7032
7033 /*****************************************************************************
7034 * get_job_info_1
7035 */
7036 static BOOL get_job_info_1(job_t *job, JOB_INFO_1W *ji1, LPBYTE buf, DWORD cbBuf,
7037 LPDWORD pcbNeeded, BOOL unicode)
7038 {
7039 DWORD size, left = cbBuf;
7040 BOOL space = (cbBuf > 0);
7041 LPBYTE ptr = buf;
7042
7043 *pcbNeeded = 0;
7044
7045 if(space)
7046 {
7047 ji1->JobId = job->job_id;
7048 }
7049
7050 string_to_buf(job->document_title, ptr, left, &size, unicode);
7051 if(space && size <= left)
7052 {
7053 ji1->pDocument = (LPWSTR)ptr;
7054 ptr += size;
7055 left -= size;
7056 }
7057 else
7058 space = FALSE;
7059 *pcbNeeded += size;
7060
7061 return space;
7062 }
7063
7064 /*****************************************************************************
7065 * get_job_info_2
7066 */
7067 static BOOL get_job_info_2(job_t *job, JOB_INFO_2W *ji2, LPBYTE buf, DWORD cbBuf,
7068 LPDWORD pcbNeeded, BOOL unicode)
7069 {
7070 DWORD size, left = cbBuf;
7071 BOOL space = (cbBuf > 0);
7072 LPBYTE ptr = buf;
7073
7074 *pcbNeeded = 0;
7075
7076 if(space)
7077 {
7078 ji2->JobId = job->job_id;
7079 }
7080
7081 string_to_buf(job->document_title, ptr, left, &size, unicode);
7082 if(space && size <= left)
7083 {
7084 ji2->pDocument = (LPWSTR)ptr;
7085 ptr += size;
7086 left -= size;
7087 }
7088 else
7089 space = FALSE;
7090 *pcbNeeded += size;
7091
7092 return space;
7093 }
7094
7095 /*****************************************************************************
7096 * get_job_info
7097 */
7098 static BOOL get_job_info(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
7099 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
7100 {
7101 BOOL ret = FALSE;
7102 DWORD needed = 0, size;
7103 job_t *job;
7104 LPBYTE ptr = pJob;
7105
7106 TRACE("%p %d %d %p %d %p\n", hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded);
7107
7108 EnterCriticalSection(&printer_handles_cs);
7109 job = get_job(hPrinter, JobId);
7110 if(!job)
7111 goto end;
7112
7113 switch(Level)
7114 {
7115 case 1:
7116 size = sizeof(JOB_INFO_1W);
7117 if(cbBuf >= size)
7118 {
7119 cbBuf -= size;
7120 ptr += size;
7121 memset(pJob, 0, size);
7122 }
7123 else
7124 cbBuf = 0;
7125 ret = get_job_info_1(job, (JOB_INFO_1W *)pJob, ptr, cbBuf, &needed, unicode);
7126 needed += size;
7127 break;
7128
7129 case 2:
7130 size = sizeof(JOB_INFO_2W);
7131 if(cbBuf >= size)
7132 {
7133 cbBuf -= size;
7134 ptr += size;
7135 memset(pJob, 0, size);
7136 }
7137 else
7138 cbBuf = 0;
7139 ret = get_job_info_2(job, (JOB_INFO_2W *)pJob, ptr, cbBuf, &needed, unicode);
7140 needed += size;
7141 break;
7142
7143 case 3:
7144 size = sizeof(JOB_INFO_3);
7145 if(cbBuf >= size)
7146 {
7147 cbBuf -= size;
7148 memset(pJob, 0, size);
7149 ret = TRUE;
7150 }
7151 else
7152 cbBuf = 0;
7153 needed = size;
7154 break;
7155
7156 default:
7157 SetLastError(ERROR_INVALID_LEVEL);
7158 goto end;
7159 }
7160 if(pcbNeeded)
7161 *pcbNeeded = needed;
7162 end:
7163 LeaveCriticalSection(&printer_handles_cs);
7164 return ret;
7165 }
7166
7167 /*****************************************************************************
7168 * GetJobA [WINSPOOL.@]
7169 *
7170 */
7171 BOOL WINAPI GetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
7172 DWORD cbBuf, LPDWORD pcbNeeded)
7173 {
7174 return get_job_info(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded, FALSE);
7175 }
7176
7177 /*****************************************************************************
7178 * GetJobW [WINSPOOL.@]
7179 *
7180 */
7181 BOOL WINAPI GetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level, LPBYTE pJob,
7182 DWORD cbBuf, LPDWORD pcbNeeded)
7183 {
7184 return get_job_info(hPrinter, JobId, Level, pJob, cbBuf, pcbNeeded, TRUE);
7185 }
7186
7187 /*****************************************************************************
7188 * schedule_lpr
7189 */
7190 static BOOL schedule_lpr(LPCWSTR printer_name, LPCWSTR filename)
7191 {
7192 char *unixname, *queue, *cmd;
7193 char fmt[] = "lpr -P%s %s";
7194 DWORD len;
7195 int r;
7196
7197 if(!(unixname = wine_get_unix_file_name(filename)))
7198 return FALSE;
7199
7200 len = WideCharToMultiByte(CP_ACP, 0, printer_name, -1, NULL, 0, NULL, NULL);
7201 queue = HeapAlloc(GetProcessHeap(), 0, len);
7202 WideCharToMultiByte(CP_ACP, 0, printer_name, -1, queue, len, NULL, NULL);
7203
7204 cmd = HeapAlloc(GetProcessHeap(), 0, strlen(unixname) + len + sizeof(fmt) - 5);
7205 sprintf(cmd, fmt, queue, unixname);
7206
7207 TRACE("printing with: %s\n", cmd);
7208 r = system(cmd);
7209
7210 HeapFree(GetProcessHeap(), 0, cmd);
7211 HeapFree(GetProcessHeap(), 0, queue);
7212 HeapFree(GetProcessHeap(), 0, unixname);
7213 return (r == 0);
7214 }
7215
7216 /*****************************************************************************
7217 * schedule_cups
7218 */
7219 static BOOL schedule_cups(LPCWSTR printer_name, LPCWSTR filename, LPCWSTR document_title)
7220 {
7221 #ifdef SONAME_LIBCUPS
7222 if(pcupsPrintFile)
7223 {
7224 char *unixname, *queue, *unix_doc_title;
7225 DWORD len;
7226 BOOL ret;
7227
7228 if(!(unixname = wine_get_unix_file_name(filename)))
7229 return FALSE;
7230
7231 len = WideCharToMultiByte(CP_UNIXCP, 0, printer_name, -1, NULL, 0, NULL, NULL);
7232 queue = HeapAlloc(GetProcessHeap(), 0, len);
7233 WideCharToMultiByte(CP_UNIXCP, 0, printer_name, -1, queue, len, NULL, NULL);
7234
7235 len = WideCharToMultiByte(CP_UNIXCP, 0, document_title, -1, NULL, 0, NULL, NULL);
7236 unix_doc_title = HeapAlloc(GetProcessHeap(), 0, len);
7237 WideCharToMultiByte(CP_UNIXCP, 0, document_title, -1, unix_doc_title, len, NULL, NULL);
7238
7239 TRACE("printing via cups\n");
7240 ret = pcupsPrintFile(queue, unixname, unix_doc_title, 0, NULL);
7241 HeapFree(GetProcessHeap(), 0, unix_doc_title);
7242 HeapFree(GetProcessHeap(), 0, queue);
7243 HeapFree(GetProcessHeap(), 0, unixname);
7244 return ret;
7245 }
7246 else
7247 #endif
7248 {
7249 return schedule_lpr(printer_name, filename);
7250 }
7251 }
7252
7253 static INT_PTR CALLBACK file_dlg_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
7254 {
7255 LPWSTR filename;
7256
7257 switch(msg)
7258 {
7259 case WM_INITDIALOG:
7260 SetWindowLongPtrW(hwnd, DWLP_USER, lparam);
7261 return TRUE;
7262
7263 case WM_COMMAND:
7264 if(HIWORD(wparam) == BN_CLICKED)
7265 {
7266 if(LOWORD(wparam) == IDOK)
7267 {
7268 HANDLE hf;
7269 DWORD len = SendDlgItemMessageW(hwnd, EDITBOX, WM_GETTEXTLENGTH, 0, 0);
7270 LPWSTR *output;
7271
7272 filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
7273 GetDlgItemTextW(hwnd, EDITBOX, filename, len + 1);
7274
7275 if(GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES)
7276 {
7277 WCHAR caption[200], message[200];
7278 int mb_ret;
7279
7280 LoadStringW(WINSPOOL_hInstance, IDS_CAPTION, caption, sizeof(caption) / sizeof(WCHAR));
7281 LoadStringW(WINSPOOL_hInstance, IDS_FILE_EXISTS, message, sizeof(message) / sizeof(WCHAR));
7282 mb_ret = MessageBoxW(hwnd, message, caption, MB_OKCANCEL | MB_ICONEXCLAMATION);
7283 if(mb_ret == IDCANCEL)
7284 {
7285 HeapFree(GetProcessHeap(), 0, filename);
7286 return TRUE;
7287 }
7288 }
7289 hf = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
7290 if(hf == INVALID_HANDLE_VALUE)
7291 {
7292 WCHAR caption[200], message[200];
7293
7294 LoadStringW(WINSPOOL_hInstance, IDS_CAPTION, caption, sizeof(caption) / sizeof(WCHAR));
7295 LoadStringW(WINSPOOL_hInstance, IDS_CANNOT_OPEN, message, sizeof(message) / sizeof(WCHAR));
7296 MessageBoxW(hwnd, message, caption, MB_OK | MB_ICONEXCLAMATION);
7297 HeapFree(GetProcessHeap(), 0, filename);
7298 return TRUE;
7299 }
7300 CloseHandle(hf);
7301 DeleteFileW(filename);
7302 output = (LPWSTR *)GetWindowLongPtrW(hwnd, DWLP_USER);
7303 *output = filename;
7304 EndDialog(hwnd, IDOK);
7305 return TRUE;
7306 }
7307 if(LOWORD(wparam) == IDCANCEL)
7308 {
7309 EndDialog(hwnd, IDCANCEL);
7310 return TRUE;
7311 }
7312 }
7313 return FALSE;
7314 }
7315 return FALSE;
7316 }
7317
7318 /*****************************************************************************
7319 * get_filename
7320 */
7321 static BOOL get_filename(LPWSTR *filename)
7322 {
7323 return DialogBoxParamW(WINSPOOL_hInstance, MAKEINTRESOURCEW(FILENAME_DIALOG), GetForegroundWindow(),
7324 file_dlg_proc, (LPARAM)filename) == IDOK;
7325 }
7326
7327 /*****************************************************************************
7328 * schedule_file
7329 */
7330 static BOOL schedule_file(LPCWSTR filename)
7331 {
7332 LPWSTR output = NULL;
7333
7334 if(get_filename(&output))
7335 {
7336 BOOL r;
7337 TRACE("copy to %s\n", debugstr_w(output));
7338 r = CopyFileW(filename, output, FALSE);
7339 HeapFree(GetProcessHeap(), 0, output);
7340 return r;
7341 }
7342 return FALSE;
7343 }
7344
7345 /*****************************************************************************
7346 * schedule_pipe
7347 */
7348 static BOOL schedule_pipe(LPCWSTR cmd, LPCWSTR filename)
7349 {
7350 #ifdef HAVE_FORK
7351 char *unixname, *cmdA;
7352 DWORD len;
7353 int fds[2] = {-1, -1}, file_fd = -1, no_read;
7354 BOOL ret = FALSE;
7355 char buf[1024];
7356
7357 if(!(unixname = wine_get_unix_file_name(filename)))
7358 return FALSE;
7359
7360 len = WideCharToMultiByte(CP_UNIXCP, 0, cmd, -1, NULL, 0, NULL, NULL);
7361 cmdA = HeapAlloc(GetProcessHeap(), 0, len);
7362 WideCharToMultiByte(CP_UNIXCP, 0, cmd, -1, cmdA, len, NULL, NULL);
7363
7364 TRACE("printing with: %s\n", cmdA);
7365
7366 if((file_fd = open(unixname, O_RDONLY)) == -1)
7367 goto end;
7368
7369 if (pipe(fds))
7370 {
7371 ERR("pipe() failed!\n");
7372 goto end;
7373 }
7374
7375 if (fork() == 0)
7376 {
7377 close(0);
7378 dup2(fds[0], 0);
7379 close(fds[1]);
7380
7381 /* reset signals that we previously set to SIG_IGN */
7382 signal(SIGPIPE, SIG_DFL);
7383 signal(SIGCHLD, SIG_DFL);
7384
7385 execl("/bin/sh", "/bin/sh", "-c", cmdA, NULL);
7386 _exit(1);
7387 }
7388
7389 while((no_read = read(file_fd, buf, sizeof(buf))) > 0)
7390 write(fds[1], buf, no_read);
7391
7392 ret = TRUE;
7393
7394 end:
7395 if(file_fd != -1) close(file_fd);
7396 if(fds[0] != -1) close(fds[0]);
7397 if(fds[1] != -1) close(fds[1]);
7398
7399 HeapFree(GetProcessHeap(), 0, cmdA);
7400 HeapFree(GetProcessHeap(), 0, unixname);
7401 return ret;
7402 #else
7403 return FALSE;
7404 #endif
7405 }
7406
7407 /*****************************************************************************
7408 * schedule_unixfile
7409 */
7410 static BOOL schedule_unixfile(LPCWSTR output, LPCWSTR filename)
7411 {
7412 int in_fd, out_fd, no_read;
7413 char buf[1024];
7414 BOOL ret = FALSE;
7415 char *unixname, *outputA;
7416 DWORD len;
7417
7418 if(!(unixname = wine_get_unix_file_name(filename)))
7419 return FALSE;
7420
7421 len = WideCharToMultiByte(CP_UNIXCP, 0, output, -1, NULL, 0, NULL, NULL);
7422 outputA = HeapAlloc(GetProcessHeap(), 0, len);
7423 WideCharToMultiByte(CP_UNIXCP, 0, output, -1, outputA, len, NULL, NULL);
7424
7425 out_fd = open(outputA, O_CREAT | O_TRUNC | O_WRONLY, 0666);
7426 in_fd = open(unixname, O_RDONLY);
7427 if(out_fd == -1 || in_fd == -1)
7428 goto end;
7429
7430 while((no_read = read(in_fd, buf, sizeof(buf))) > 0)
7431 write(out_fd, buf, no_read);
7432
7433 ret = TRUE;
7434 end:
7435 if(in_fd != -1) close(in_fd);
7436 if(out_fd != -1) close(out_fd);
7437 HeapFree(GetProcessHeap(), 0, outputA);
7438 HeapFree(GetProcessHeap(), 0, unixname);
7439 return ret;
7440 }
7441
7442 /*****************************************************************************
7443 * ScheduleJob [WINSPOOL.@]
7444 *
7445 */
7446 BOOL WINAPI ScheduleJob( HANDLE hPrinter, DWORD dwJobID )
7447 {
7448 opened_printer_t *printer;
7449 BOOL ret = FALSE;
7450 struct list *cursor, *cursor2;
7451
7452 TRACE("(%p, %x)\n", hPrinter, dwJobID);
7453 EnterCriticalSection(&printer_handles_cs);
7454 printer = get_opened_printer(hPrinter);
7455 if(!printer)
7456 goto end;
7457
7458 LIST_FOR_EACH_SAFE(cursor, cursor2, &printer->queue->jobs)
7459 {
7460 job_t *job = LIST_ENTRY(cursor, job_t, entry);
7461 HANDLE hf;
7462
7463 if(job->job_id != dwJobID) continue;
7464
7465 hf = CreateFileW(job->filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
7466 if(hf != INVALID_HANDLE_VALUE)
7467 {
7468 PRINTER_INFO_5W *pi5;
7469 DWORD needed;
7470 HKEY hkey;
7471 WCHAR output[1024];
7472 static const WCHAR spooler_key[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\',
7473 'P','r','i','n','t','i','n','g','\\','S','p','o','o','l','e','r',0};
7474
7475 GetPrinterW(hPrinter, 5, NULL, 0, &needed);
7476 pi5 = HeapAlloc(GetProcessHeap(), 0, needed);
7477 GetPrinterW(hPrinter, 5, (LPBYTE)pi5, needed, &needed);
7478 TRACE("need to schedule job %d filename %s to port %s\n", job->job_id, debugstr_w(job->filename),
7479 debugstr_w(pi5->pPortName));
7480
7481 output[0] = 0;
7482
7483 /* @@ Wine registry key: HKCU\Software\Wine\Printing\Spooler */
7484 if(RegOpenKeyW(HKEY_CURRENT_USER, spooler_key, &hkey) == ERROR_SUCCESS)
7485 {
7486 DWORD type, count = sizeof(output);
7487 RegQueryValueExW(hkey, pi5->pPortName, NULL, &type, (LPBYTE)output, &count);
7488 RegCloseKey(hkey);
7489 }
7490 if(output[0] == '|')
7491 {
7492 ret = schedule_pipe(output + 1, job->filename);
7493 }
7494 else if(output[0])
7495 {
7496 ret = schedule_unixfile(output, job->filename);
7497 }
7498 else if(!strncmpW(pi5->pPortName, LPR_Port, strlenW(LPR_Port)))
7499 {
7500 ret = schedule_lpr(pi5->pPortName + strlenW(LPR_Port), job->filename);
7501 }
7502 else if(!strncmpW(pi5->pPortName, CUPS_Port, strlenW(CUPS_Port)))
7503 {
7504 ret = schedule_cups(pi5->pPortName + strlenW(CUPS_Port), job->filename, job->document_title);
7505 }
7506 else if(!strncmpW(pi5->pPortName, FILE_Port, strlenW(FILE_Port)))
7507 {
7508 ret = schedule_file(job->filename);
7509 }
7510 else
7511 {
7512 FIXME("can't schedule to port %s\n", debugstr_w(pi5->pPortName));
7513 }
7514 HeapFree(GetProcessHeap(), 0, pi5);
7515 CloseHandle(hf);
7516 DeleteFileW(job->filename);
7517 }
7518 list_remove(cursor);
7519 HeapFree(GetProcessHeap(), 0, job->document_title);
7520 HeapFree(GetProcessHeap(), 0, job->filename);
7521 HeapFree(GetProcessHeap(), 0, job);
7522 break;
7523 }
7524 end:
7525 LeaveCriticalSection(&printer_handles_cs);
7526 return ret;
7527 }
7528
7529 /*****************************************************************************
7530 * StartDocDlgA [WINSPOOL.@]
7531 */
7532 LPSTR WINAPI StartDocDlgA( HANDLE hPrinter, DOCINFOA *doc )
7533 {
7534 UNICODE_STRING usBuffer;
7535 DOCINFOW docW;
7536 LPWSTR retW;
7537 LPWSTR docnameW = NULL, outputW = NULL, datatypeW = NULL;
7538 LPSTR ret = NULL;
7539
7540 docW.cbSize = sizeof(docW);
7541 if (doc->lpszDocName)
7542 {
7543 docnameW = asciitounicode(&usBuffer, doc->lpszDocName);
7544 if (!(docW.lpszDocName = docnameW)) return NULL;
7545 }
7546 if (doc->lpszOutput)
7547 {
7548 outputW = asciitounicode(&usBuffer, doc->lpszOutput);
7549 if (!(docW.lpszOutput = outputW)) return NULL;
7550 }
7551 if (doc->lpszDatatype)
7552 {
7553 datatypeW = asciitounicode(&usBuffer, doc->lpszDatatype);
7554 if (!(docW.lpszDatatype = datatypeW)) return NULL;
7555 }
7556 docW.fwType = doc->fwType;
7557
7558 retW = StartDocDlgW(hPrinter, &docW);
7559
7560 if(retW)
7561 {
7562 DWORD len = WideCharToMultiByte(CP_ACP, 0, retW, -1, NULL, 0, NULL, NULL);
7563 ret = HeapAlloc(GetProcessHeap(), 0, len);
7564 WideCharToMultiByte(CP_ACP, 0, retW, -1, ret, len, NULL, NULL);
7565 HeapFree(GetProcessHeap(), 0, retW);
7566 }
7567
7568 HeapFree(GetProcessHeap(), 0, datatypeW);
7569 HeapFree(GetProcessHeap(), 0, outputW);
7570 HeapFree(GetProcessHeap(), 0, docnameW);
7571
7572 return ret;
7573 }
7574
7575 /*****************************************************************************
7576 * StartDocDlgW [WINSPOOL.@]
7577 *
7578 * Undocumented: Apparently used by gdi32:StartDocW() to popup the file dialog
7579 * when lpszOutput is "FILE:" or if lpszOutput is NULL and the default printer
7580 * port is "FILE:". Also returns the full path if passed a relative path.
7581 *
7582 * The caller should free the returned string from the process heap.
7583 */
7584 LPWSTR WINAPI StartDocDlgW( HANDLE hPrinter, DOCINFOW *doc )
7585 {
7586 LPWSTR ret = NULL;
7587 DWORD len, attr;
7588
7589 if(doc->lpszOutput == NULL) /* Check whether default port is FILE: */
7590 {
7591 PRINTER_INFO_5W *pi5;
7592 GetPrinterW(hPrinter, 5, NULL, 0, &len);
7593 if(GetLastError() != ERROR_INSUFFICIENT_BUFFER)
7594 return NULL;
7595 pi5 = HeapAlloc(GetProcessHeap(), 0, len);
7596 GetPrinterW(hPrinter, 5, (LPBYTE)pi5, len, &len);
7597 if(!pi5->pPortName || strcmpW(pi5->pPortName, FILE_Port))
7598 {
7599 HeapFree(GetProcessHeap(), 0, pi5);
7600 return NULL;
7601 }
7602 HeapFree(GetProcessHeap(), 0, pi5);
7603 }
7604
7605 if(doc->lpszOutput == NULL || !strcmpW(doc->lpszOutput, FILE_Port))
7606 {
7607 LPWSTR name;
7608
7609 if (get_filename(&name))
7610 {
7611 if(!(len = GetFullPathNameW(name, 0, NULL, NULL)))
7612 {
7613 HeapFree(GetProcessHeap(), 0, name);
7614 return NULL;
7615 }
7616 ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
7617 GetFullPathNameW(name, len, ret, NULL);
7618 HeapFree(GetProcessHeap(), 0, name);
7619 }
7620 return ret;
7621 }
7622
7623 if(!(len = GetFullPathNameW(doc->lpszOutput, 0, NULL, NULL)))
7624 return NULL;
7625
7626 ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
7627 GetFullPathNameW(doc->lpszOutput, len, ret, NULL);
7628
7629 attr = GetFileAttributesW(ret);
7630 if(attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY))
7631 {
7632 HeapFree(GetProcessHeap(), 0, ret);
7633 ret = NULL;
7634 }
7635 return ret;
7636 }
useful hacks and other patches not (yet) suitable for mainline