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