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