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