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