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