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