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