?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add a missing return.
[wine.git] / dlls / winspool / info.c
blob5dd9645fb326a7fc23ca9e6caba5c1336c27c9dc
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 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ctype.h>
33 #include <stddef.h>
34 #ifdef HAVE_CUPS_CUPS_H
35 # include <cups/cups.h>
36 # ifndef SONAME_LIBCUPS
37 # define SONAME_LIBCUPS "libcups.so"
38 # endif
39 #endif
40
41 #define NONAMELESSUNION
42 #define NONAMELESSSTRUCT
43 #include "wine/library.h"
44 #include "windef.h"
45 #include "winbase.h"
46 #include "winuser.h"
47 #include "winerror.h"
48 #include "winreg.h"
49 #include "wingdi.h"
50 #include "winspool.h"
51 #include "winternl.h"
52 #include "wine/windef16.h"
53 #include "wine/unicode.h"
54 #include "wine/debug.h"
55 #include "heap.h"
56 #include "winnls.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(winspool);
59
60 static LPWSTR *printer_array;
61 static int nb_printers;
62
63 static DWORD (WINAPI *GDI_CallDeviceCapabilities16)( LPCSTR lpszDevice, LPCSTR lpszPort,
64 WORD fwCapability, LPSTR lpszOutput,
65 LPDEVMODEA lpdm );
66 static INT (WINAPI *GDI_CallExtDeviceMode16)( HWND hwnd, LPDEVMODEA lpdmOutput,
67 LPSTR lpszDevice, LPSTR lpszPort,
68 LPDEVMODEA lpdmInput, LPSTR lpszProfile,
69 DWORD fwMode );
70
71 static const char Printers[] =
72 "System\\CurrentControlSet\\control\\Print\\Printers\\";
73 static const char Drivers[] =
74 "System\\CurrentControlSet\\control\\Print\\Environments\\%s\\Drivers\\";
75
76 static const WCHAR DefaultEnvironmentW[] = {'W','i','n','e',0};
77
78 static const WCHAR Configuration_FileW[] = {'C','o','n','f','i','g','u','r','a','t',
79 'i','o','n',' ','F','i','l','e',0};
80 static const WCHAR DatatypeW[] = {'D','a','t','a','t','y','p','e',0};
81 static const WCHAR Data_FileW[] = {'D','a','t','a',' ','F','i','l','e',0};
82 static const WCHAR Default_DevModeW[] = {'D','e','f','a','u','l','t',' ','D','e','v',
83 'M','o','d','e',0};
84 static const WCHAR Dependent_FilesW[] = {'D','e','p','e','n','d','e','n','t',' ','F',
85 'i','l','e','s',0};
86 static const WCHAR DescriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
87 static const WCHAR DriverW[] = {'D','r','i','v','e','r',0};
88 static const WCHAR Help_FileW[] = {'H','e','l','p',' ','F','i','l','e',0};
89 static const WCHAR LocationW[] = {'L','o','c','a','t','i','o','n',0};
90 static const WCHAR MonitorW[] = {'M','o','n','i','t','o','r',0};
91 static const WCHAR NameW[] = {'N','a','m','e',0};
92 static const WCHAR ParametersW[] = {'P','a','r','a','m','e','t','e','r','s',0};
93 static const WCHAR PortW[] = {'P','o','r','t',0};
94 static const WCHAR Print_ProcessorW[] = {'P','r','i','n','t',' ','P','r','o','c','e',
95 's','s','o','r',0};
96 static const WCHAR Printer_DriverW[] = {'P','r','i','n','t','e','r',' ','D','r','i',
97 'v','e','r',0};
98 static const WCHAR PrinterDriverDataW[] = {'P','r','i','n','t','e','r','D','r','i',
99 'v','e','r','D','a','t','a',0};
100 static const WCHAR Separator_FileW[] = {'S','e','p','a','r','a','t','o','r',' ','F',
101 'i','l','e',0};
102 static const WCHAR Share_NameW[] = {'S','h','a','r','e',' ','N','a','m','e',0};
103 static const WCHAR WinPrintW[] = {'W','i','n','P','r','i','n','t',0};
104 static const WCHAR devicesW[] = {'d','e','v','i','c','e','s',0};
105
106 static const WCHAR May_Delete_Value[] = {'W','i','n','e','M','a','y','D','e','l','e','t','e','M','e',0};
107
108 static HKEY WINSPOOL_OpenDriverReg( LPVOID pEnvironment, BOOL unicode);
109 static BOOL WINSPOOL_GetPrinterDriver(HANDLE hPrinter, LPWSTR pEnvironment,
110 DWORD Level, LPBYTE pDriverInfo,
111 DWORD cbBuf, LPDWORD pcbNeeded,
112 BOOL unicode);
113 static DWORD WINSPOOL_GetOpenedPrinterRegKey(HANDLE hPrinter, HKEY *phkey);
114
115 /* RtlCreateUnicodeStringFromAsciiz will return an empty string in the buffer
116 if passed a NULL string. This returns NULLs to the result.
117 */
118 static inline PWSTR asciitounicode( UNICODE_STRING * usBufferPtr, LPCSTR src )
119 {
120 if ( (src) )
121 {
122 RtlCreateUnicodeStringFromAsciiz(usBufferPtr, src);
123 return usBufferPtr->Buffer;
124 }
125 usBufferPtr->Buffer = NULL; /* so that RtlFreeUnicodeString won't barf */
126 return NULL;
127 }
128
129 static void
130 WINSPOOL_SetDefaultPrinter(const char *devname, const char *name,BOOL force) {
131 char qbuf[200];
132
133 /* If forcing, or no profile string entry for device yet, set the entry
134 *
135 * The always change entry if not WINEPS yet is discussable.
136 */
137 if (force ||
138 !GetProfileStringA("windows","device","*",qbuf,sizeof(qbuf)) ||
139 !strcmp(qbuf,"*") ||
140 !strstr(qbuf,"WINEPS")
141 ) {
142 char *buf = HeapAlloc(GetProcessHeap(),0,strlen(name)+strlen(devname)+strlen(",WINEPS,LPR:")+1);
143
144 sprintf(buf,"%s,WINEPS,LPR:%s",devname,name);
145 WriteProfileStringA("windows","device",buf);
146 HeapFree(GetProcessHeap(),0,buf);
147 }
148 }
149
150 #ifdef HAVE_CUPS_CUPS_H
151 static BOOL CUPS_LoadPrinters(void)
152 {
153 typeof(cupsGetDests) *pcupsGetDests = NULL;
154 typeof(cupsGetPPD) *pcupsGetPPD = NULL;
155 int i, nrofdests;
156 BOOL hadprinter = FALSE;
157 cups_dest_t *dests;
158 PRINTER_INFO_2A pinfo2a;
159 void *cupshandle = NULL;
160 char *port,*devline;
161 HKEY hkeyPrinter, hkeyPrinters;
162
163 cupshandle = wine_dlopen(SONAME_LIBCUPS, RTLD_NOW, NULL, 0);
164 if (!cupshandle)
165 return FALSE;
166 TRACE("loaded %s\n", SONAME_LIBCUPS);
167
168 #define DYNCUPS(x) \
169 p##x = wine_dlsym(cupshandle, #x, NULL,0); \
170 if (!p##x) return FALSE;
171
172 DYNCUPS(cupsGetPPD);
173 DYNCUPS(cupsGetDests);
174 #undef DYNCUPS
175
176 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
177 ERROR_SUCCESS) {
178 ERR("Can't create Printers key\n");
179 return FALSE;
180 }
181
182 nrofdests = pcupsGetDests(&dests);
183 TRACE("Found %d CUPS %s:\n", nrofdests, (nrofdests == 1) ? "printer" : "printers");
184 for (i=0;i<nrofdests;i++) {
185 port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(dests[i].name)+1);
186 sprintf(port,"LPR:%s",dests[i].name);
187 devline=HeapAlloc(GetProcessHeap(),0,strlen("WINEPS,")+strlen(port)+1);
188 sprintf(devline,"WINEPS,%s",port);
189 WriteProfileStringA("devices",dests[i].name,devline);
190 HeapFree(GetProcessHeap(),0,devline);
191
192 TRACE("Printer %d: %s\n", i, dests[i].name);
193 if(RegOpenKeyA(hkeyPrinters, dests[i].name, &hkeyPrinter) == ERROR_SUCCESS) {
194 /* Printer already in registry, delete the tag added in WINSPOOL_LoadSystemPrinters
195 and continue */
196 TRACE("Printer already exists\n");
197 RegDeleteValueW(hkeyPrinter, May_Delete_Value);
198 RegCloseKey(hkeyPrinter);
199 } else {
200 memset(&pinfo2a,0,sizeof(pinfo2a));
201 pinfo2a.pPrinterName = dests[i].name;
202 pinfo2a.pDatatype = "RAW";
203 pinfo2a.pPrintProcessor = "WinPrint";
204 pinfo2a.pDriverName = "PS Driver";
205 pinfo2a.pComment = "WINEPS Printer using CUPS";
206 pinfo2a.pLocation = "<physical location of printer>";
207 pinfo2a.pPortName = port;
208 pinfo2a.pParameters = "<parameters?>";
209 pinfo2a.pShareName = "<share name?>";
210 pinfo2a.pSepFile = "<sep file?>";
211
212 if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
213 if (GetLastError() != ERROR_PRINTER_ALREADY_EXISTS)
214 ERR("printer '%s' not added by AddPrinterA (error %ld)\n",dests[i].name,GetLastError());
215 }
216 }
217 HeapFree(GetProcessHeap(),0,port);
218
219 hadprinter = TRUE;
220 if (dests[i].is_default)
221 WINSPOOL_SetDefaultPrinter(dests[i].name, dests[i].name, TRUE);
222 }
223 RegCloseKey(hkeyPrinters);
224 wine_dlclose(cupshandle, NULL, 0);
225 return hadprinter;
226 }
227 #endif
228
229 static BOOL
230 PRINTCAP_ParseEntry(char *pent,BOOL isfirst) {
231 PRINTER_INFO_2A pinfo2a;
232 char *e,*s,*name,*prettyname,*devname;
233 BOOL ret = FALSE, set_default = FALSE;
234 char *port,*devline,*env_default;
235 HKEY hkeyPrinter, hkeyPrinters;
236
237 while (isspace(*pent)) pent++;
238 s = strchr(pent,':');
239 if(s) *s='\0';
240 name = HeapAlloc(GetProcessHeap(), 0, strlen(pent) + 1);
241 strcpy(name,pent);
242 if(s) {
243 *s=':';
244 pent = s;
245 } else
246 pent = "";
247
248 TRACE("name=%s entry=%s\n",name, pent);
249
250 if(ispunct(*name)) { /* a tc entry, not a real printer */
251 TRACE("skipping tc entry\n");
252 goto end;
253 }
254
255 if(strstr(pent,":server")) { /* server only version so skip */
256 TRACE("skipping server entry\n");
257 goto end;
258 }
259
260 /* Determine whether this is a postscript printer. */
261
262 ret = TRUE;
263 env_default = getenv("PRINTER");
264 prettyname = name;
265 /* Get longest name, usually the one at the right for later display. */
266 while((s=strchr(prettyname,'|'))) {
267 *s = '\0';
268 e = s;
269 while(isspace(*--e)) *e = '\0';
270 TRACE("\t%s\n", debugstr_a(prettyname));
271 if(env_default && !strcasecmp(prettyname, env_default)) set_default = TRUE;
272 for(prettyname = s+1; isspace(*prettyname); prettyname++)
273 ;
274 }
275 e = prettyname + strlen(prettyname);
276 while(isspace(*--e)) *e = '\0';
277 TRACE("\t%s\n", debugstr_a(prettyname));
278 if(env_default && !strcasecmp(prettyname, env_default)) set_default = TRUE;
279
280 /* prettyname must fit into the dmDeviceName member of DEVMODE struct,
281 * if it is too long, we use it as comment below. */
282 devname = prettyname;
283 if (strlen(devname)>=CCHDEVICENAME-1)
284 devname = name;
285 if (strlen(devname)>=CCHDEVICENAME-1) {
286 ret = FALSE;
287 goto end;
288 }
289
290 port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(name)+1);
291 sprintf(port,"LPR:%s",name);
292
293 devline=HeapAlloc(GetProcessHeap(),0,strlen("WINEPS,")+strlen(port)+1);
294 sprintf(devline,"WINEPS,%s",port);
295 WriteProfileStringA("devices",devname,devline);
296 HeapFree(GetProcessHeap(),0,devline);
297
298 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
299 ERROR_SUCCESS) {
300 ERR("Can't create Printers key\n");
301 ret = FALSE;
302 goto end;
303 }
304 if(RegOpenKeyA(hkeyPrinters, devname, &hkeyPrinter) == ERROR_SUCCESS) {
305 /* Printer already in registry, delete the tag added in WINSPOOL_LoadSystemPrinters
306 and continue */
307 TRACE("Printer already exists\n");
308 RegDeleteValueW(hkeyPrinter, May_Delete_Value);
309 RegCloseKey(hkeyPrinter);
310 } else {
311 memset(&pinfo2a,0,sizeof(pinfo2a));
312 pinfo2a.pPrinterName = devname;
313 pinfo2a.pDatatype = "RAW";
314 pinfo2a.pPrintProcessor = "WinPrint";
315 pinfo2a.pDriverName = "PS Driver";
316 pinfo2a.pComment = "WINEPS Printer using LPR";
317 pinfo2a.pLocation = prettyname;
318 pinfo2a.pPortName = port;
319 pinfo2a.pParameters = "<parameters?>";
320 pinfo2a.pShareName = "<share name?>";
321 pinfo2a.pSepFile = "<sep file?>";
322
323 if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
324 if (GetLastError()!=ERROR_PRINTER_ALREADY_EXISTS)
325 ERR("%s not added by AddPrinterA (%ld)\n",name,GetLastError());
326 }
327 }
328 RegCloseKey(hkeyPrinters);
329
330 if (isfirst || set_default)
331 WINSPOOL_SetDefaultPrinter(devname,name,TRUE);
332
333 HeapFree(GetProcessHeap(), 0, port);
334 end:
335 HeapFree(GetProcessHeap(), 0, name);
336 return ret;
337 }
338
339 static BOOL
340 PRINTCAP_LoadPrinters(void) {
341 BOOL hadprinter = FALSE;
342 char buf[200];
343 FILE *f;
344 char *pent = NULL;
345 BOOL had_bash = FALSE;
346
347 f = fopen("/etc/printcap","r");
348 if (!f)
349 return FALSE;
350
351 while(fgets(buf,sizeof(buf),f)) {
352 char *start, *end;
353
354 end=strchr(buf,'\n');
355 if (end) *end='\0';
356
357 start = buf;
358 while(isspace(*start)) start++;
359 if(*start == '#' || *start == '\0')
360 continue;
361
362 if(pent && !had_bash && *start != ':' && *start != '|') { /* start of new entry, parse the previous one */
363 hadprinter |= PRINTCAP_ParseEntry(pent,!hadprinter);
364 HeapFree(GetProcessHeap(),0,pent);
365 pent = NULL;
366 }
367
368 if (end && *--end == '\\') {
369 *end = '\0';
370 had_bash = TRUE;
371 } else
372 had_bash = FALSE;
373
374 if (pent) {
375 pent=HeapReAlloc(GetProcessHeap(),0,pent,strlen(pent)+strlen(start)+1);
376 strcat(pent,start);
377 } else {
378 pent=HeapAlloc(GetProcessHeap(),0,strlen(start)+1);
379 strcpy(pent,start);
380 }
381
382 }
383 if(pent) {
384 hadprinter |= PRINTCAP_ParseEntry(pent,!hadprinter);
385 HeapFree(GetProcessHeap(),0,pent);
386 }
387 fclose(f);
388 return hadprinter;
389 }
390
391 static inline DWORD set_reg_szW(HKEY hkey, const WCHAR *keyname, const WCHAR *value)
392 {
393 if (value)
394 return RegSetValueExW(hkey, keyname, 0, REG_SZ, (LPBYTE)value,
395 lstrlenW(value) * sizeof(WCHAR));
396 else
397 return ERROR_FILE_NOT_FOUND;
398 }
399
400 void WINSPOOL_LoadSystemPrinters(void)
401 {
402 HKEY hkey, hkeyPrinters;
403 DRIVER_INFO_3A di3a;
404 HANDLE hprn;
405 DWORD needed, num, i;
406 WCHAR PrinterName[256];
407 BOOL done = FALSE;
408
409 di3a.cVersion = 0x400;
410 di3a.pName = "PS Driver";
411 di3a.pEnvironment = NULL; /* NULL means auto */
412 di3a.pDriverPath = "wineps16";
413 di3a.pDataFile = "<datafile?>";
414 di3a.pConfigFile = "wineps16";
415 di3a.pHelpFile = "<helpfile?>";
416 di3a.pDependentFiles = "<dependend files?>";
417 di3a.pMonitorName = "<monitor name?>";
418 di3a.pDefaultDataType = "RAW";
419
420 if (!AddPrinterDriverA(NULL,3,(LPBYTE)&di3a)) {
421 ERR("Failed adding PS Driver (%ld)\n",GetLastError());
422 return;
423 }
424
425 /* This ensures that all printer entries have a valid Name value. If causes
426 problems later if they don't. If one is found to be missed we create one
427 and set it equal to the name of the key */
428 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) == ERROR_SUCCESS) {
429 if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &num, NULL, NULL,
430 NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
431 for(i = 0; i < num; i++) {
432 if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)) == ERROR_SUCCESS) {
433 if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkey) == ERROR_SUCCESS) {
434 if(RegQueryValueExW(hkey, NameW, 0, 0, 0, &needed) == ERROR_FILE_NOT_FOUND) {
435 set_reg_szW(hkey, NameW, PrinterName);
436 }
437 RegCloseKey(hkey);
438 }
439 }
440 }
441 }
442 RegCloseKey(hkeyPrinters);
443 }
444
445 /* We want to avoid calling AddPrinter on printers as much as
446 possible, because on cups printers this will (eventually) lead
447 to a call to cupsGetPPD which takes forever, even with non-cups
448 printers AddPrinter takes a while. So we'll tag all printers that
449 were automatically added last time around, if they still exist
450 we'll leave them be otherwise we'll delete them. */
451 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, NULL, 0, &needed, &num);
452 if(needed) {
453 PRINTER_INFO_5A* pi = HeapAlloc(GetProcessHeap(), 0, needed);
454 if(EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, (LPBYTE)pi, needed, &needed, &num)) {
455 for(i = 0; i < num; i++) {
456 if(pi[i].pPortName == NULL || !strncmp(pi[i].pPortName,"CUPS:", 5) || !strncmp(pi[i].pPortName, "LPR:", 4)) {
457 if(OpenPrinterA(pi[i].pPrinterName, &hprn, NULL)) {
458 if(WINSPOOL_GetOpenedPrinterRegKey(hprn, &hkey) == ERROR_SUCCESS) {
459 DWORD dw = 1;
460 RegSetValueExW(hkey, May_Delete_Value, 0, REG_DWORD, (LPBYTE)&dw, sizeof(dw));
461 RegCloseKey(hkey);
462 }
463 ClosePrinter(hprn);
464 }
465 }
466 }
467 }
468 HeapFree(GetProcessHeap(), 0, pi);
469 }
470
471
472 #ifdef HAVE_CUPS_CUPS_H
473 done = CUPS_LoadPrinters();
474 #endif
475
476 if(!done) { /* If we have any CUPS based printers, skip looking for printcap printers */
477 /* Check for [ppd] section in config file before parsing /etc/printcap */
478 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\ppd",
479 &hkey) == ERROR_SUCCESS) {
480 RegCloseKey(hkey);
481 PRINTCAP_LoadPrinters();
482 }
483 }
484
485 /* Now enumerate the list again and delete any printers that a still tagged */
486 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, NULL, 0, &needed, &num);
487 if(needed) {
488 PRINTER_INFO_5A* pi = HeapAlloc(GetProcessHeap(), 0, needed);
489 if(EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 5, (LPBYTE)pi, needed, &needed, &num)) {
490 for(i = 0; i < num; i++) {
491 if(pi[i].pPortName == NULL || !strncmp(pi[i].pPortName,"CUPS:", 5) || !strncmp(pi[i].pPortName, "LPR:", 4)) {
492 if(OpenPrinterA(pi[i].pPrinterName, &hprn, NULL)) {
493 if(WINSPOOL_GetOpenedPrinterRegKey(hprn, &hkey) == ERROR_SUCCESS) {
494 DWORD dw, type, size = sizeof(dw);
495 if(RegQueryValueExW(hkey, May_Delete_Value, NULL, &type, (LPBYTE)&dw, &size) == ERROR_SUCCESS) {
496 TRACE("Deleting old printer %s\n", pi[i].pPrinterName);
497 DeletePrinter(hprn);
498 }
499 RegCloseKey(hkey);
500 }
501 ClosePrinter(hprn);
502 }
503 }
504 }
505 }
506 HeapFree(GetProcessHeap(), 0, pi);
507 }
508
509 return;
510
511 }
512
513
514 /******************************************************************
515 * WINSPOOL_GetOpenedPrinterEntry
516 * Get the first place empty in the opened printer table
517 */
518 static HANDLE WINSPOOL_GetOpenedPrinterEntry( LPCWSTR name )
519 {
520 int i;
521
522 for (i = 0; i < nb_printers; i++) if (!printer_array[i]) break;
523
524 if (i >= nb_printers)
525 {
526 LPWSTR *new_array;
527 if (printer_array)
528 new_array = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, printer_array,
529 (nb_printers + 16) * sizeof(*new_array) );
530 else
531 new_array = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
532 (nb_printers + 16) * sizeof(*new_array) );
533
534 if (!new_array) return 0;
535 printer_array = new_array;
536 nb_printers += 16;
537 }
538
539 if ((printer_array[i] = HeapAlloc( GetProcessHeap(), 0, (strlenW(name)+1)*sizeof(WCHAR) )))
540 {
541 strcpyW( printer_array[i], name );
542 return (HANDLE)(i + 1);
543 }
544 return 0;
545 }
546
547 /******************************************************************
548 * WINSPOOL_GetOpenedPrinter
549 * Get the pointer to the opened printer referred by the handle
550 */
551 static LPCWSTR WINSPOOL_GetOpenedPrinter(HANDLE printerHandle)
552 {
553 int idx = (int)printerHandle;
554 if ((idx <= 0) || (idx > nb_printers))
555 {
556 SetLastError(ERROR_INVALID_HANDLE);
557 return NULL;
558 }
559 return printer_array[idx - 1];
560 }
561
562 /******************************************************************
563 * WINSPOOL_GetOpenedPrinterRegKey
564 *
565 */
566 static DWORD WINSPOOL_GetOpenedPrinterRegKey(HANDLE hPrinter, HKEY *phkey)
567 {
568 LPCWSTR name = WINSPOOL_GetOpenedPrinter(hPrinter);
569 DWORD ret;
570 HKEY hkeyPrinters;
571
572 if(!name) return ERROR_INVALID_HANDLE;
573
574 if((ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters)) !=
575 ERROR_SUCCESS)
576 return ret;
577
578 if(RegOpenKeyW(hkeyPrinters, name, phkey) != ERROR_SUCCESS)
579 {
580 ERR("Can't find opened printer %s in registry\n",
581 debugstr_w(name));
582 RegCloseKey(hkeyPrinters);
583 return ERROR_INVALID_PRINTER_NAME; /* ? */
584 }
585 RegCloseKey(hkeyPrinters);
586 return ERROR_SUCCESS;
587 }
588
589 /***********************************************************
590 * DEVMODEcpyAtoW
591 */
592 static LPDEVMODEW DEVMODEcpyAtoW(DEVMODEW *dmW, const DEVMODEA *dmA)
593 {
594 BOOL Formname;
595 ptrdiff_t off_formname = (char *)dmA->dmFormName - (char *)dmA;
596 DWORD size;
597
598 Formname = (dmA->dmSize > off_formname);
599 size = dmA->dmSize + CCHDEVICENAME + (Formname ? CCHFORMNAME : 0);
600 MultiByteToWideChar(CP_ACP, 0, dmA->dmDeviceName, -1, dmW->dmDeviceName,
601 CCHDEVICENAME);
602 if(!Formname) {
603 memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
604 dmA->dmSize - CCHDEVICENAME);
605 } else {
606 memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
607 off_formname - CCHDEVICENAME);
608 MultiByteToWideChar(CP_ACP, 0, dmA->dmFormName, -1, dmW->dmFormName,
609 CCHFORMNAME);
610 memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA->dmSize -
611 (off_formname + CCHFORMNAME));
612 }
613 dmW->dmSize = size;
614 memcpy((char *)dmW + dmW->dmSize, (char *)dmA + dmA->dmSize,
615 dmA->dmDriverExtra);
616 return dmW;
617 }
618
619 /***********************************************************
620 * DEVMODEdupWtoA
621 * Creates an ascii copy of supplied devmode on heap
622 */
623 static LPDEVMODEA DEVMODEdupWtoA(HANDLE heap, const DEVMODEW *dmW)
624 {
625 LPDEVMODEA dmA;
626 DWORD size;
627 BOOL Formname;
628 ptrdiff_t off_formname = (char *)dmW->dmFormName - (char *)dmW;
629
630 if(!dmW) return NULL;
631 Formname = (dmW->dmSize > off_formname);
632 size = dmW->dmSize - CCHDEVICENAME - (Formname ? CCHFORMNAME : 0);
633 dmA = HeapAlloc(heap, HEAP_ZERO_MEMORY, size + dmW->dmDriverExtra);
634 WideCharToMultiByte(CP_ACP, 0, dmW->dmDeviceName, -1, dmA->dmDeviceName,
635 CCHDEVICENAME, NULL, NULL);
636 if(!Formname) {
637 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
638 dmW->dmSize - CCHDEVICENAME * sizeof(WCHAR));
639 } else {
640 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
641 off_formname - CCHDEVICENAME * sizeof(WCHAR));
642 WideCharToMultiByte(CP_ACP, 0, dmW->dmFormName, -1, dmA->dmFormName,
643 CCHFORMNAME, NULL, NULL);
644 memcpy(&dmA->dmLogPixels, &dmW->dmLogPixels, dmW->dmSize -
645 (off_formname + CCHFORMNAME * sizeof(WCHAR)));
646 }
647 dmA->dmSize = size;
648 memcpy((char *)dmA + dmA->dmSize, (char *)dmW + dmW->dmSize,
649 dmW->dmDriverExtra);
650 return dmA;
651 }
652
653 /***********************************************************
654 * PRINTER_INFO_2AtoW
655 * Creates a unicode copy of PRINTER_INFO_2A on heap
656 */
657 static LPPRINTER_INFO_2W PRINTER_INFO_2AtoW(HANDLE heap, LPPRINTER_INFO_2A piA)
658 {
659 LPPRINTER_INFO_2W piW;
660 UNICODE_STRING usBuffer;
661
662 if(!piA) return NULL;
663 piW = HeapAlloc(heap, 0, sizeof(*piW));
664 memcpy(piW, piA, sizeof(*piW)); /* copy everything first */
665
666 piW->pServerName = asciitounicode(&usBuffer,piA->pServerName);
667 piW->pPrinterName = asciitounicode(&usBuffer,piA->pPrinterName);
668 piW->pShareName = asciitounicode(&usBuffer,piA->pShareName);
669 piW->pPortName = asciitounicode(&usBuffer,piA->pPortName);
670 piW->pDriverName = asciitounicode(&usBuffer,piA->pDriverName);
671 piW->pComment = asciitounicode(&usBuffer,piA->pComment);
672 piW->pLocation = asciitounicode(&usBuffer,piA->pLocation);
673 piW->pDevMode = piA->pDevMode ? GdiConvertToDevmodeW(piA->pDevMode) : NULL;
674 piW->pSepFile = asciitounicode(&usBuffer,piA->pSepFile);
675 piW->pPrintProcessor = asciitounicode(&usBuffer,piA->pPrintProcessor);
676 piW->pDatatype = asciitounicode(&usBuffer,piA->pDatatype);
677 piW->pParameters = asciitounicode(&usBuffer,piA->pParameters);
678 return piW;
679 }
680
681 /***********************************************************
682 * FREE_PRINTER_INFO_2W
683 * Free PRINTER_INFO_2W and all strings
684 */
685 static void FREE_PRINTER_INFO_2W(HANDLE heap, LPPRINTER_INFO_2W piW)
686 {
687 if(!piW) return;
688
689 HeapFree(heap,0,piW->pServerName);
690 HeapFree(heap,0,piW->pPrinterName);
691 HeapFree(heap,0,piW->pShareName);
692 HeapFree(heap,0,piW->pPortName);
693 HeapFree(heap,0,piW->pDriverName);
694 HeapFree(heap,0,piW->pComment);
695 HeapFree(heap,0,piW->pLocation);
696 HeapFree(heap,0,piW->pDevMode);
697 HeapFree(heap,0,piW->pSepFile);
698 HeapFree(heap,0,piW->pPrintProcessor);
699 HeapFree(heap,0,piW->pDatatype);
700 HeapFree(heap,0,piW->pParameters);
701 HeapFree(heap,0,piW);
702 return;
703 }
704
705 /******************************************************************
706 * DeviceCapabilities [WINSPOOL.@]
707 * DeviceCapabilitiesA [WINSPOOL.@]
708 *
709 */
710 INT WINAPI DeviceCapabilitiesA(LPCSTR pDevice,LPCSTR pPort, WORD cap,
711 LPSTR pOutput, LPDEVMODEA lpdm)
712 {
713 INT ret;
714
715 if (!GDI_CallDeviceCapabilities16)
716 {
717 GDI_CallDeviceCapabilities16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
718 (LPCSTR)104 );
719 if (!GDI_CallDeviceCapabilities16) return -1;
720 }
721 ret = GDI_CallDeviceCapabilities16(pDevice, pPort, cap, pOutput, lpdm);
722
723 /* If DC_PAPERSIZE map POINT16s to POINTs */
724 if(ret != -1 && cap == DC_PAPERSIZE && pOutput) {
725 POINT16 *tmp = HeapAlloc( GetProcessHeap(), 0, ret * sizeof(POINT16) );
726 POINT *pt = (POINT *)pOutput;
727 INT i;
728 memcpy(tmp, pOutput, ret * sizeof(POINT16));
729 for(i = 0; i < ret; i++, pt++)
730 {
731 pt->x = tmp[i].x;
732 pt->y = tmp[i].y;
733 }
734 HeapFree( GetProcessHeap(), 0, tmp );
735 }
736 return ret;
737 }
738
739
740 /*****************************************************************************
741 * DeviceCapabilitiesW [WINSPOOL.@]
742 *
743 * Call DeviceCapabilitiesA since we later call 16bit stuff anyway
744 *
745 */
746 INT WINAPI DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort,
747 WORD fwCapability, LPWSTR pOutput,
748 const DEVMODEW *pDevMode)
749 {
750 LPDEVMODEA dmA = DEVMODEdupWtoA(GetProcessHeap(), pDevMode);
751 LPSTR pDeviceA = HEAP_strdupWtoA(GetProcessHeap(),0,pDevice);
752 LPSTR pPortA = HEAP_strdupWtoA(GetProcessHeap(),0,pPort);
753 INT ret;
754
755 if(pOutput && (fwCapability == DC_BINNAMES ||
756 fwCapability == DC_FILEDEPENDENCIES ||
757 fwCapability == DC_PAPERNAMES)) {
758 /* These need A -> W translation */
759 INT size = 0, i;
760 LPSTR pOutputA;
761 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, NULL,
762 dmA);
763 if(ret == -1)
764 return ret;
765 switch(fwCapability) {
766 case DC_BINNAMES:
767 size = 24;
768 break;
769 case DC_PAPERNAMES:
770 case DC_FILEDEPENDENCIES:
771 size = 64;
772 break;
773 }
774 pOutputA = HeapAlloc(GetProcessHeap(), 0, size * ret);
775 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, pOutputA,
776 dmA);
777 for(i = 0; i < ret; i++)
778 MultiByteToWideChar(CP_ACP, 0, pOutputA + (i * size), -1,
779 pOutput + (i * size), size);
780 HeapFree(GetProcessHeap(), 0, pOutputA);
781 } else {
782 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability,
783 (LPSTR)pOutput, dmA);
784 }
785 HeapFree(GetProcessHeap(),0,pPortA);
786 HeapFree(GetProcessHeap(),0,pDeviceA);
787 HeapFree(GetProcessHeap(),0,dmA);
788 return ret;
789 }
790
791 /******************************************************************
792 * DocumentPropertiesA [WINSPOOL.@]
793 *
794 * FIXME: implement DocumentPropertiesA via DocumentPropertiesW, not vice versa
795 */
796 LONG WINAPI DocumentPropertiesA(HWND hWnd,HANDLE hPrinter,
797 LPSTR pDeviceName, LPDEVMODEA pDevModeOutput,
798 LPDEVMODEA pDevModeInput,DWORD fMode )
799 {
800 LPSTR lpName = pDeviceName;
801 LONG ret;
802
803 TRACE("(%p,%p,%s,%p,%p,%ld)\n",
804 hWnd,hPrinter,pDeviceName,pDevModeOutput,pDevModeInput,fMode
805 );
806
807 if(!pDeviceName) {
808 LPCWSTR lpNameW = WINSPOOL_GetOpenedPrinter(hPrinter);
809 if(!lpNameW) {
810 ERR("no name from hPrinter?\n");
811 return -1;
812 }
813 lpName = HEAP_strdupWtoA(GetProcessHeap(),0,lpNameW);
814 }
815
816 if (!GDI_CallExtDeviceMode16)
817 {
818 GDI_CallExtDeviceMode16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
819 (LPCSTR)102 );
820 if (!GDI_CallExtDeviceMode16) {
821 ERR("No CallExtDeviceMode16?\n");
822 return -1;
823 }
824 }
825 ret = GDI_CallExtDeviceMode16(hWnd, pDevModeOutput, lpName, "LPT1:",
826 pDevModeInput, NULL, fMode);
827
828 if(!pDeviceName)
829 HeapFree(GetProcessHeap(),0,lpName);
830 return ret;
831 }
832
833
834 /*****************************************************************************
835 * DocumentPropertiesW (WINSPOOL.@)
836 *
837 * FIXME: implement DocumentPropertiesA via DocumentPropertiesW, not vice versa
838 */
839 LONG WINAPI DocumentPropertiesW(HWND hWnd, HANDLE hPrinter,
840 LPWSTR pDeviceName,
841 LPDEVMODEW pDevModeOutput,
842 LPDEVMODEW pDevModeInput, DWORD fMode)
843 {
844
845 LPSTR pDeviceNameA = HEAP_strdupWtoA(GetProcessHeap(),0,pDeviceName);
846 LPDEVMODEA pDevModeInputA = DEVMODEdupWtoA(GetProcessHeap(),pDevModeInput);
847 LPDEVMODEA pDevModeOutputA = NULL;
848 LONG ret;
849
850 TRACE("(%p,%p,%s,%p,%p,%ld)\n",
851 hWnd,hPrinter,debugstr_w(pDeviceName),pDevModeOutput,pDevModeInput,
852 fMode);
853 if(pDevModeOutput) {
854 ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, NULL, NULL, 0);
855 if(ret < 0) return ret;
856 pDevModeOutputA = HeapAlloc(GetProcessHeap(), 0, ret);
857 }
858 ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, pDevModeOutputA,
859 pDevModeInputA, fMode);
860 if(pDevModeOutput) {
861 DEVMODEcpyAtoW(pDevModeOutput, pDevModeOutputA);
862 HeapFree(GetProcessHeap(),0,pDevModeOutputA);
863 }
864 if(fMode == 0 && ret > 0)
865 ret += (CCHDEVICENAME + CCHFORMNAME);
866 HeapFree(GetProcessHeap(),0,pDevModeInputA);
867 HeapFree(GetProcessHeap(),0,pDeviceNameA);
868 return ret;
869 }
870
871 /******************************************************************
872 * OpenPrinterA [WINSPOOL.@]
873 *
874 */
875 BOOL WINAPI OpenPrinterA(LPSTR lpPrinterName,HANDLE *phPrinter,
876 LPPRINTER_DEFAULTSA pDefault)
877 {
878 UNICODE_STRING lpPrinterNameW;
879 UNICODE_STRING usBuffer;
880 PRINTER_DEFAULTSW DefaultW, *pDefaultW = NULL;
881 PWSTR pwstrPrinterNameW;
882 BOOL ret;
883
884 pwstrPrinterNameW = asciitounicode(&lpPrinterNameW,lpPrinterName);
885
886 if(pDefault) {
887 DefaultW.pDatatype = asciitounicode(&usBuffer,pDefault->pDatatype);
888 DefaultW.pDevMode = pDefault->pDevMode ? GdiConvertToDevmodeW(pDefault->pDevMode) : NULL;
889 DefaultW.DesiredAccess = pDefault->DesiredAccess;
890 pDefaultW = &DefaultW;
891 }
892 ret = OpenPrinterW(pwstrPrinterNameW, phPrinter, pDefaultW);
893 if(pDefault) {
894 RtlFreeUnicodeString(&usBuffer);
895 HeapFree(GetProcessHeap(), 0, DefaultW.pDevMode);
896 }
897 RtlFreeUnicodeString(&lpPrinterNameW);
898 return ret;
899 }
900
901 /******************************************************************
902 * OpenPrinterW [WINSPOOL.@]
903 *
904 */
905 BOOL WINAPI OpenPrinterW(LPWSTR lpPrinterName,HANDLE *phPrinter,
906 LPPRINTER_DEFAULTSW pDefault)
907 {
908 HKEY hkeyPrinters, hkeyPrinter;
909
910 if (!lpPrinterName) {
911 FIXME("(printerName: NULL, pDefault %p Ret: False\n", pDefault);
912 SetLastError(ERROR_INVALID_PARAMETER);
913 return FALSE;
914 }
915
916 TRACE("(printerName: %s, pDefault %p)\n", debugstr_w(lpPrinterName),
917 pDefault);
918
919 /* Check Printer exists */
920 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
921 ERROR_SUCCESS) {
922 ERR("Can't create Printers key\n");
923 SetLastError(ERROR_FILE_NOT_FOUND); /* ?? */
924 return FALSE;
925 }
926
927 if(lpPrinterName[0] == '\0' || /* explicitly exclude "" */
928 RegOpenKeyW(hkeyPrinters, lpPrinterName, &hkeyPrinter)
929 != ERROR_SUCCESS) {
930 TRACE("Can't find printer %s in registry\n",
931 debugstr_w(lpPrinterName));
932 RegCloseKey(hkeyPrinters);
933 SetLastError(ERROR_INVALID_PRINTER_NAME);
934 return FALSE;
935 }
936 RegCloseKey(hkeyPrinter);
937 RegCloseKey(hkeyPrinters);
938
939 if(!phPrinter) /* This seems to be what win95 does anyway */
940 return TRUE;
941
942 /* Get the unique handle of the printer*/
943 *phPrinter = WINSPOOL_GetOpenedPrinterEntry( lpPrinterName );
944
945 if (pDefault != NULL)
946 FIXME("Not handling pDefault\n");
947
948 return TRUE;
949 }
950
951 /******************************************************************
952 * AddMonitorA [WINSPOOL.@]
953 *
954 */
955 BOOL WINAPI AddMonitorA(LPSTR pName, DWORD Level, LPBYTE pMonitors)
956 {
957 FIXME("(%s,%lx,%p):stub!\n", pName, Level, pMonitors);
958 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
959 return FALSE;
960 }
961
962 /******************************************************************
963 * DeletePrinterDriverA [WINSPOOL.@]
964 *
965 */
966 BOOL WINAPI
967 DeletePrinterDriverA (LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName)
968 {
969 FIXME("(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
970 debugstr_a(pDriverName));
971 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
972 return FALSE;
973 }
974
975
976 /******************************************************************
977 * DeleteMonitorA [WINSPOOL.@]
978 *
979 */
980 BOOL WINAPI
981 DeleteMonitorA (LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName)
982 {
983 FIXME("(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
984 debugstr_a(pMonitorName));
985 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
986 return FALSE;
987 }
988
989
990 /******************************************************************
991 * DeletePortA [WINSPOOL.@]
992 *
993 */
994 BOOL WINAPI
995 DeletePortA (LPSTR pName, HWND hWnd, LPSTR pPortName)
996 {
997 FIXME("(%s,%p,%s):stub\n",debugstr_a(pName),hWnd,
998 debugstr_a(pPortName));
999 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1000 return FALSE;
1001 }
1002
1003 /******************************************************************************
1004 * SetPrinterW [WINSPOOL.@]
1005 */
1006 BOOL WINAPI
1007 SetPrinterW(
1008 HANDLE hPrinter,
1009 DWORD Level,
1010 LPBYTE pPrinter,
1011 DWORD Command) {
1012
1013 FIXME("():stub\n");
1014 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1015 return FALSE;
1016 }
1017
1018 /******************************************************************************
1019 * WritePrinter [WINSPOOL.@]
1020 */
1021 BOOL WINAPI
1022 WritePrinter(
1023 HANDLE hPrinter,
1024 LPVOID pBuf,
1025 DWORD cbBuf,
1026 LPDWORD pcWritten) {
1027
1028 FIXME("():stub\n");
1029 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1030 return FALSE;
1031 }
1032
1033 /*****************************************************************************
1034 * AddFormA [WINSPOOL.@]
1035 */
1036 BOOL WINAPI AddFormA(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
1037 {
1038 FIXME("(%p,%ld,%p): stub\n", hPrinter, Level, pForm);
1039 return 1;
1040 }
1041
1042 /*****************************************************************************
1043 * AddFormW [WINSPOOL.@]
1044 */
1045 BOOL WINAPI AddFormW(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
1046 {
1047 FIXME("(%p,%ld,%p): stub\n", hPrinter, Level, pForm);
1048 return 1;
1049 }
1050
1051 /*****************************************************************************
1052 * AddJobA [WINSPOOL.@]
1053 */
1054 BOOL WINAPI AddJobA(HANDLE hPrinter, DWORD Level, LPBYTE pData,
1055 DWORD cbBuf, LPDWORD pcbNeeded)
1056 {
1057 FIXME("(%p,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
1058 pcbNeeded);
1059 return 1;
1060 }
1061
1062 /*****************************************************************************
1063 * AddJobW [WINSPOOL.@]
1064 */
1065 BOOL WINAPI AddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf,
1066 LPDWORD pcbNeeded)
1067 {
1068 FIXME("(%p,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
1069 pcbNeeded);
1070 return 1;
1071 }
1072
1073 /*****************************************************************************
1074 * GetPrintProcessorDirectoryA [WINSPOOL.@]
1075 */
1076 BOOL WINAPI GetPrintProcessorDirectoryA(LPSTR server, LPSTR env,
1077 DWORD level, LPBYTE Info,
1078 DWORD cbBuf, LPDWORD needed)
1079 {
1080 FIXME("(%s,%s,%ld,%p,0x%08lx): stub\n", server, env, level, Info, cbBuf);
1081 return 0;
1082 }
1083
1084 /*****************************************************************************
1085 * WINSPOOL_OpenDriverReg [internal]
1086 *
1087 * opens the registry for the printer drivers depending on the given input
1088 * variable pEnvironment
1089 *
1090 * RETURNS:
1091 * the opened hkey on success
1092 * NULL on error
1093 */
1094 static HKEY WINSPOOL_OpenDriverReg( LPVOID pEnvironment, BOOL unicode)
1095 { HKEY retval;
1096 LPSTR lpKey, p = NULL;
1097
1098 TRACE("%s\n",
1099 (unicode) ? debugstr_w(pEnvironment) : debugstr_a(pEnvironment));
1100
1101 if(pEnvironment)
1102 p = (unicode) ? HEAP_strdupWtoA( GetProcessHeap(), 0, pEnvironment) :
1103 pEnvironment;
1104 else {
1105 OSVERSIONINFOA ver;
1106 ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
1107
1108 if(!GetVersionExA( &ver))
1109 return 0;
1110
1111 switch (ver.dwPlatformId) {
1112 case VER_PLATFORM_WIN32s:
1113 ERR("win32 style printing used with 16 bits app, try specifying 'win95' Windows version\n");
1114 return 0;
1115
1116 case VER_PLATFORM_WIN32_NT:
1117 p = "Windows NT x86";
1118 break;
1119 default:
1120 p = "Windows 4.0";
1121 break;
1122 }
1123 TRACE("set environment to %s\n", p);
1124 }
1125
1126 lpKey = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
1127 strlen(p) + strlen(Drivers));
1128 sprintf( lpKey, Drivers, p);
1129
1130 TRACE("%s\n", lpKey);
1131
1132 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, lpKey, &retval) !=
1133 ERROR_SUCCESS)
1134 retval = 0;
1135
1136 if(pEnvironment && unicode)
1137 HeapFree( GetProcessHeap(), 0, p);
1138 HeapFree( GetProcessHeap(), 0, lpKey);
1139
1140 return retval;
1141 }
1142
1143 /*****************************************************************************
1144 * AddPrinterW [WINSPOOL.@]
1145 */
1146 HANDLE WINAPI AddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter)
1147 {
1148 PRINTER_INFO_2W *pi = (PRINTER_INFO_2W *) pPrinter;
1149 LPDEVMODEA dmA;
1150 LPDEVMODEW dmW;
1151 HANDLE retval;
1152 HKEY hkeyPrinter, hkeyPrinters, hkeyDriver, hkeyDrivers;
1153 LONG size;
1154
1155 TRACE("(%s,%ld,%p)\n", debugstr_w(pName), Level, pPrinter);
1156
1157 if(pName != NULL) {
1158 ERR("pName = %s - unsupported\n", debugstr_w(pName));
1159 SetLastError(ERROR_INVALID_PARAMETER);
1160 return 0;
1161 }
1162 if(Level != 2) {
1163 ERR("Level = %ld, unsupported!\n", Level);
1164 SetLastError(ERROR_INVALID_LEVEL);
1165 return 0;
1166 }
1167 if (strlenW(pi->pPrinterName) >= CCHDEVICENAME) {
1168 ERR("Printername %s must not exceed length of DEVMODE.dmDeviceName !\n",
1169 debugstr_w(pi->pPrinterName)
1170 );
1171 SetLastError(ERROR_INVALID_LEVEL);
1172 return 0;
1173 }
1174 if(!pPrinter) {
1175 SetLastError(ERROR_INVALID_PARAMETER);
1176 return 0;
1177 }
1178 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
1179 ERROR_SUCCESS) {
1180 ERR("Can't create Printers key\n");
1181 return 0;
1182 }
1183 if(!RegOpenKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter)) {
1184 if (!RegQueryValueA(hkeyPrinter,"Attributes",NULL,NULL)) {
1185 SetLastError(ERROR_PRINTER_ALREADY_EXISTS);
1186 RegCloseKey(hkeyPrinter);
1187 RegCloseKey(hkeyPrinters);
1188 return 0;
1189 }
1190 RegCloseKey(hkeyPrinter);
1191 }
1192 hkeyDrivers = WINSPOOL_OpenDriverReg( NULL, TRUE);
1193 if(!hkeyDrivers) {
1194 ERR("Can't create Drivers key\n");
1195 RegCloseKey(hkeyPrinters);
1196 return 0;
1197 }
1198 if(RegOpenKeyW(hkeyDrivers, pi->pDriverName, &hkeyDriver) !=
1199 ERROR_SUCCESS) {
1200 WARN("Can't find driver %s\n", debugstr_w(pi->pDriverName));
1201 RegCloseKey(hkeyPrinters);
1202 RegCloseKey(hkeyDrivers);
1203 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
1204 return 0;
1205 }
1206 RegCloseKey(hkeyDriver);
1207 RegCloseKey(hkeyDrivers);
1208
1209 if(lstrcmpiW(pi->pPrintProcessor, WinPrintW)) { /* FIXME */
1210 FIXME("Can't find processor %s\n", debugstr_w(pi->pPrintProcessor));
1211 SetLastError(ERROR_UNKNOWN_PRINTPROCESSOR);
1212 RegCloseKey(hkeyPrinters);
1213 return 0;
1214 }
1215
1216 if(RegCreateKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter) !=
1217 ERROR_SUCCESS) {
1218 FIXME("Can't create printer %s\n", debugstr_w(pi->pPrinterName));
1219 SetLastError(ERROR_INVALID_PRINTER_NAME);
1220 RegCloseKey(hkeyPrinters);
1221 return 0;
1222 }
1223 RegSetValueExA(hkeyPrinter, "Attributes", 0, REG_DWORD,
1224 (LPBYTE)&pi->Attributes, sizeof(DWORD));
1225 set_reg_szW(hkeyPrinter, DatatypeW, pi->pDatatype);
1226
1227 /* See if we can load the driver. We may need the devmode structure anyway
1228 *
1229 * FIXME:
1230 * Note that DocumentPropertiesW will briefly try to open the printer we
1231 * just create to find a DEVMODEA struct (it will use the WINEPS default
1232 * one in case it is not there, so we are ok).
1233 */
1234 size = DocumentPropertiesW(0, 0, pi->pPrinterName, NULL, NULL, 0);
1235
1236 if(size < 0) {
1237 FIXME("DocumentPropertiesW on printer '%s' fails\n", debugstr_w(pi->pPrinterName));
1238 size = sizeof(DEVMODEW);
1239 }
1240 if(pi->pDevMode)
1241 dmW = pi->pDevMode;
1242 else
1243 {
1244 dmW = HeapAlloc(GetProcessHeap(), 0, size);
1245 ZeroMemory(dmW,size);
1246 dmW->dmSize = size;
1247 if (0>DocumentPropertiesW(0,0,pi->pPrinterName,dmW,NULL,DM_OUT_BUFFER))
1248 {
1249 WARN("DocumentPropertiesW on printer '%s' failed!\n", debugstr_w(pi->pPrinterName));
1250 HeapFree(GetProcessHeap(),0,dmW);
1251 dmW=NULL;
1252 }
1253 else
1254 {
1255 /* set devmode to printer name */
1256 strcpyW(dmW->dmDeviceName,pi->pPrinterName);
1257 }
1258 }
1259
1260 /* Write DEVMODEA not DEVMODEW into reg. This is what win9x does
1261 and we support these drivers. NT writes DEVMODEW so somehow
1262 we'll need to distinguish between these when we support NT
1263 drivers */
1264 if (dmW)
1265 {
1266 dmA = DEVMODEdupWtoA(GetProcessHeap(), dmW);
1267 RegSetValueExA(hkeyPrinter, "Default DevMode", 0, REG_BINARY,
1268 (LPBYTE)dmA, dmA->dmSize + dmA->dmDriverExtra);
1269 HeapFree(GetProcessHeap(), 0, dmA);
1270 if(!pi->pDevMode)
1271 HeapFree(GetProcessHeap(), 0, dmW);
1272 }
1273 set_reg_szW(hkeyPrinter, DescriptionW, pi->pComment);
1274 set_reg_szW(hkeyPrinter, LocationW, pi->pLocation);
1275 set_reg_szW(hkeyPrinter, NameW, pi->pPrinterName);
1276 set_reg_szW(hkeyPrinter, ParametersW, pi->pParameters);
1277
1278 set_reg_szW(hkeyPrinter, PortW, pi->pPortName);
1279 set_reg_szW(hkeyPrinter, Print_ProcessorW, pi->pPrintProcessor);
1280 set_reg_szW(hkeyPrinter, Printer_DriverW, pi->pDriverName);
1281 RegSetValueExA(hkeyPrinter, "Priority", 0, REG_DWORD,
1282 (LPBYTE)&pi->Priority, sizeof(DWORD));
1283 set_reg_szW(hkeyPrinter, Separator_FileW, pi->pSepFile);
1284 set_reg_szW(hkeyPrinter, Share_NameW, pi->pShareName);
1285 RegSetValueExA(hkeyPrinter, "StartTime", 0, REG_DWORD,
1286 (LPBYTE)&pi->StartTime, sizeof(DWORD));
1287 RegSetValueExA(hkeyPrinter, "Status", 0, REG_DWORD,
1288 (LPBYTE)&pi->Status, sizeof(DWORD));
1289 RegSetValueExA(hkeyPrinter, "UntilTime", 0, REG_DWORD,
1290 (LPBYTE)&pi->UntilTime, sizeof(DWORD));
1291
1292 RegCloseKey(hkeyPrinter);
1293 RegCloseKey(hkeyPrinters);
1294 if(!OpenPrinterW(pi->pPrinterName, &retval, NULL)) {
1295 ERR("OpenPrinter failing\n");
1296 return 0;
1297 }
1298 return retval;
1299 }
1300
1301 /*****************************************************************************
1302 * AddPrinterA [WINSPOOL.@]
1303 */
1304 HANDLE WINAPI AddPrinterA(LPSTR pName, DWORD Level, LPBYTE pPrinter)
1305 {
1306 UNICODE_STRING pNameW;
1307 PWSTR pwstrNameW;
1308 PRINTER_INFO_2W *piW;
1309 PRINTER_INFO_2A *piA = (PRINTER_INFO_2A*)pPrinter;
1310 HANDLE ret;
1311
1312 TRACE("(%s,%ld,%p): stub\n", debugstr_a(pName), Level, pPrinter);
1313 if(Level != 2) {
1314 ERR("Level = %ld, unsupported!\n", Level);
1315 SetLastError(ERROR_INVALID_LEVEL);
1316 return 0;
1317 }
1318 pwstrNameW = asciitounicode(&pNameW,pName);
1319 piW = PRINTER_INFO_2AtoW(GetProcessHeap(), piA);
1320
1321 ret = AddPrinterW(pwstrNameW, Level, (LPBYTE)piW);
1322
1323 FREE_PRINTER_INFO_2W(GetProcessHeap(), piW);
1324 RtlFreeUnicodeString(&pNameW);
1325 return ret;
1326 }
1327
1328
1329 /*****************************************************************************
1330 * ClosePrinter [WINSPOOL.@]
1331 */
1332 BOOL WINAPI ClosePrinter(HANDLE hPrinter)
1333 {
1334 int i = (int)hPrinter;
1335
1336 TRACE("Handle %p\n", hPrinter);
1337
1338 if ((i <= 0) || (i > nb_printers)) return FALSE;
1339 HeapFree( GetProcessHeap(), 0, printer_array[i - 1] );
1340 printer_array[i - 1] = NULL;
1341 return TRUE;
1342 }
1343
1344 /*****************************************************************************
1345 * DeleteFormA [WINSPOOL.@]
1346 */
1347 BOOL WINAPI DeleteFormA(HANDLE hPrinter, LPSTR pFormName)
1348 {
1349 FIXME("(%p,%s): stub\n", hPrinter, pFormName);
1350 return 1;
1351 }
1352
1353 /*****************************************************************************
1354 * DeleteFormW [WINSPOOL.@]
1355 */
1356 BOOL WINAPI DeleteFormW(HANDLE hPrinter, LPWSTR pFormName)
1357 {
1358 FIXME("(%p,%s): stub\n", hPrinter, debugstr_w(pFormName));
1359 return 1;
1360 }
1361
1362 /*****************************************************************************
1363 * WINSPOOL_SHRegDeleteKey
1364 *
1365 * Recursively delete subkeys.
1366 * Cut & paste from shlwapi.
1367 *
1368 */
1369 static DWORD WINSPOOL_SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
1370 {
1371 DWORD dwRet, dwKeyCount = 0, dwMaxSubkeyLen = 0, dwSize, i;
1372 WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
1373 HKEY hSubKey = 0;
1374
1375 dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
1376 if(!dwRet)
1377 {
1378 /* Find how many subkeys there are */
1379 dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, &dwKeyCount,
1380 &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
1381 if(!dwRet)
1382 {
1383 dwMaxSubkeyLen++;
1384 if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
1385 /* Name too big: alloc a buffer for it */
1386 lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(WCHAR));
1387
1388 if(!lpszName)
1389 dwRet = ERROR_NOT_ENOUGH_MEMORY;
1390 else
1391 {
1392 /* Recursively delete all the subkeys */
1393 for(i = 0; i < dwKeyCount && !dwRet; i++)
1394 {
1395 dwSize = dwMaxSubkeyLen;
1396 dwRet = RegEnumKeyExW(hSubKey, i, lpszName, &dwSize, NULL, NULL, NULL, NULL);
1397 if(!dwRet)
1398 dwRet = WINSPOOL_SHDeleteKeyW(hSubKey, lpszName);
1399 }
1400
1401 if (lpszName != szNameBuf)
1402 HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
1403 }
1404 }
1405
1406 RegCloseKey(hSubKey);
1407 if(!dwRet)
1408 dwRet = RegDeleteKeyW(hKey, lpszSubKey);
1409 }
1410 return dwRet;
1411 }
1412
1413 /*****************************************************************************
1414 * DeletePrinter [WINSPOOL.@]
1415 */
1416 BOOL WINAPI DeletePrinter(HANDLE hPrinter)
1417 {
1418 LPCWSTR lpNameW = WINSPOOL_GetOpenedPrinter(hPrinter);
1419 HKEY hkeyPrinters;
1420
1421 if(!lpNameW) return FALSE;
1422 if(RegOpenKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) == ERROR_SUCCESS) {
1423 WINSPOOL_SHDeleteKeyW(hkeyPrinters, lpNameW);
1424 RegCloseKey(hkeyPrinters);
1425 }
1426 WriteProfileStringW(devicesW, lpNameW, NULL);
1427 return TRUE;
1428 }
1429
1430 /*****************************************************************************
1431 * SetPrinterA [WINSPOOL.@]
1432 */
1433 BOOL WINAPI SetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1434 DWORD Command)
1435 {
1436 FIXME("(%p,%ld,%p,%ld): stub\n",hPrinter,Level,pPrinter,Command);
1437 return FALSE;
1438 }
1439
1440 /*****************************************************************************
1441 * SetJobA [WINSPOOL.@]
1442 */
1443 BOOL WINAPI SetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level,
1444 LPBYTE pJob, DWORD Command)
1445 {
1446 FIXME("(%p,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
1447 Command);
1448 return FALSE;
1449 }
1450
1451 /*****************************************************************************
1452 * SetJobW [WINSPOOL.@]
1453 */
1454 BOOL WINAPI SetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level,
1455 LPBYTE pJob, DWORD Command)
1456 {
1457 FIXME("(%p,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
1458 Command);
1459 return FALSE;
1460 }
1461
1462 /*****************************************************************************
1463 * EndDocPrinter [WINSPOOL.@]
1464 */
1465 BOOL WINAPI EndDocPrinter(HANDLE hPrinter)
1466 {
1467 FIXME("(hPrinter=%p): stub\n", hPrinter);
1468 return FALSE;
1469 }
1470
1471 /*****************************************************************************
1472 * EndPagePrinter [WINSPOOL.@]
1473 */
1474 BOOL WINAPI EndPagePrinter(HANDLE hPrinter)
1475 {
1476 FIXME("(hPrinter=%p): stub\n", hPrinter);
1477 return FALSE;
1478 }
1479
1480 /*****************************************************************************
1481 * StartDocPrinterA [WINSPOOL.@]
1482 */
1483 DWORD WINAPI StartDocPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)
1484 {
1485 FIXME("(hPrinter=%p, Level=0x%lx, pDocInfo=%p): stub\n", hPrinter, Level, pDocInfo);
1486 return FALSE;
1487 }
1488
1489 /*****************************************************************************
1490 * StartDocPrinterW [WINSPOOL.@]
1491 */
1492 DWORD WINAPI StartDocPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pDocInfo)
1493 {
1494 FIXME("(hPrinter=%p, Level=0x%lx, pDocInfo=%p): stub\n", hPrinter, Level, pDocInfo);
1495 return FALSE;
1496 }
1497
1498 /*****************************************************************************
1499 * StartPagePrinter [WINSPOOL.@]
1500 */
1501 BOOL WINAPI StartPagePrinter(HANDLE hPrinter)
1502 {
1503 FIXME("(hPrinter=%p): stub\n", hPrinter);
1504 return FALSE;
1505 }
1506
1507 /*****************************************************************************
1508 * GetFormA [WINSPOOL.@]
1509 */
1510 BOOL WINAPI GetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
1511 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
1512 {
1513 FIXME("(%p,%s,%ld,%p,%ld,%p): stub\n",hPrinter,pFormName,
1514 Level,pForm,cbBuf,pcbNeeded);
1515 return FALSE;
1516 }
1517
1518 /*****************************************************************************
1519 * GetFormW [WINSPOOL.@]
1520 */
1521 BOOL WINAPI GetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1522 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
1523 {
1524 FIXME("(%p,%s,%ld,%p,%ld,%p): stub\n",hPrinter,
1525 debugstr_w(pFormName),Level,pForm,cbBuf,pcbNeeded);
1526 return FALSE;
1527 }
1528
1529 /*****************************************************************************
1530 * SetFormA [WINSPOOL.@]
1531 */
1532 BOOL WINAPI SetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
1533 LPBYTE pForm)
1534 {
1535 FIXME("(%p,%s,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1536 return FALSE;
1537 }
1538
1539 /*****************************************************************************
1540 * SetFormW [WINSPOOL.@]
1541 */
1542 BOOL WINAPI SetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1543 LPBYTE pForm)
1544 {
1545 FIXME("(%p,%p,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1546 return FALSE;
1547 }
1548
1549 /*****************************************************************************
1550 * ReadPrinter [WINSPOOL.@]
1551 */
1552 BOOL WINAPI ReadPrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf,
1553 LPDWORD pNoBytesRead)
1554 {
1555 FIXME("(%p,%p,%ld,%p): stub\n",hPrinter,pBuf,cbBuf,pNoBytesRead);
1556 return FALSE;
1557 }
1558
1559 /*****************************************************************************
1560 * ResetPrinterA [WINSPOOL.@]
1561 */
1562 BOOL WINAPI ResetPrinterA(HANDLE hPrinter, LPPRINTER_DEFAULTSA pDefault)
1563 {
1564 FIXME("(%p, %p): stub\n", hPrinter, pDefault);
1565 return FALSE;
1566 }
1567
1568 /*****************************************************************************
1569 * ResetPrinterW [WINSPOOL.@]
1570 */
1571 BOOL WINAPI ResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault)
1572 {
1573 FIXME("(%p, %p): stub\n", hPrinter, pDefault);
1574 return FALSE;
1575 }
1576
1577 /*****************************************************************************
1578 * WINSPOOL_GetDWORDFromReg
1579 *
1580 * Return DWORD associated with ValueName from hkey.
1581 */
1582 static DWORD WINSPOOL_GetDWORDFromReg(HKEY hkey, LPCSTR ValueName)
1583 {
1584 DWORD sz = sizeof(DWORD), type, value = 0;
1585 LONG ret;
1586
1587 ret = RegQueryValueExA(hkey, ValueName, 0, &type, (LPBYTE)&value, &sz);
1588
1589 if(ret != ERROR_SUCCESS) {
1590 WARN("Got ret = %ld on name %s\n", ret, ValueName);
1591 return 0;
1592 }
1593 if(type != REG_DWORD) {
1594 ERR("Got type %ld\n", type);
1595 return 0;
1596 }
1597 return value;
1598 }
1599
1600 /*****************************************************************************
1601 * WINSPOOL_GetStringFromReg
1602 *
1603 * Get ValueName from hkey storing result in ptr. buflen is space left in ptr
1604 * String is stored either as unicode or ascii.
1605 * Bit of a hack here to get the ValueName if we want ascii.
1606 */
1607 static BOOL WINSPOOL_GetStringFromReg(HKEY hkey, LPCWSTR ValueName, LPBYTE ptr,
1608 DWORD buflen, DWORD *needed,
1609 BOOL unicode)
1610 {
1611 DWORD sz = buflen, type;
1612 LONG ret;
1613
1614 if(unicode)
1615 ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
1616 else {
1617 LPSTR ValueNameA = HEAP_strdupWtoA(GetProcessHeap(),0,ValueName);
1618 ret = RegQueryValueExA(hkey, ValueNameA, 0, &type, ptr, &sz);
1619 HeapFree(GetProcessHeap(),0,ValueNameA);
1620 }
1621 if(ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
1622 WARN("Got ret = %ld\n", ret);
1623 *needed = 0;
1624 return FALSE;
1625 }
1626 *needed = sz;
1627 return TRUE;
1628 }
1629
1630 /*****************************************************************************
1631 * WINSPOOL_GetDefaultDevMode
1632 *
1633 * Get a default DevMode values for wineps.
1634 * FIXME - use ppd.
1635 */
1636
1637 static void WINSPOOL_GetDefaultDevMode(
1638 LPBYTE ptr,
1639 DWORD buflen, DWORD *needed,
1640 BOOL unicode)
1641 {
1642 DEVMODEA dm;
1643
1644 /* fill default DEVMODE - should be read from ppd... */
1645 ZeroMemory( &dm, sizeof(dm) );
1646 strcpy(dm.dmDeviceName,"wineps");
1647 dm.dmSpecVersion = DM_SPECVERSION;
1648 dm.dmDriverVersion = 1;
1649 dm.dmSize = sizeof(DEVMODEA);
1650 dm.dmDriverExtra = 0;
1651 dm.dmFields =
1652 DM_ORIENTATION | DM_PAPERSIZE |
1653 DM_PAPERLENGTH | DM_PAPERWIDTH |
1654 DM_SCALE |
1655 DM_COPIES |
1656 DM_DEFAULTSOURCE | DM_PRINTQUALITY |
1657 DM_YRESOLUTION | DM_TTOPTION;
1658
1659 dm.u1.s1.dmOrientation = DMORIENT_PORTRAIT;
1660 dm.u1.s1.dmPaperSize = DMPAPER_A4;
1661 dm.u1.s1.dmPaperLength = 2970;
1662 dm.u1.s1.dmPaperWidth = 2100;
1663
1664 dm.dmScale = 100;
1665 dm.dmCopies = 1;
1666 dm.dmDefaultSource = DMBIN_AUTO;
1667 dm.dmPrintQuality = DMRES_MEDIUM;
1668 /* dm.dmColor */
1669 /* dm.dmDuplex */
1670 dm.dmYResolution = 300; /* 300dpi */
1671 dm.dmTTOption = DMTT_BITMAP;
1672 /* dm.dmCollate */
1673 /* dm.dmFormName */
1674 /* dm.dmLogPixels */
1675 /* dm.dmBitsPerPel */
1676 /* dm.dmPelsWidth */
1677 /* dm.dmPelsHeight */
1678 /* dm.dmDisplayFlags */
1679 /* dm.dmDisplayFrequency */
1680 /* dm.dmICMMethod */
1681 /* dm.dmICMIntent */
1682 /* dm.dmMediaType */
1683 /* dm.dmDitherType */
1684 /* dm.dmReserved1 */
1685 /* dm.dmReserved2 */
1686 /* dm.dmPanningWidth */
1687 /* dm.dmPanningHeight */
1688
1689 if(unicode) {
1690 if(buflen >= sizeof(DEVMODEW)) {
1691 DEVMODEW *pdmW = GdiConvertToDevmodeW(&dm);
1692 memcpy(ptr, pdmW, sizeof(DEVMODEW));
1693 HeapFree(GetProcessHeap(),0,pdmW);
1694 }
1695 *needed = sizeof(DEVMODEW);
1696 }
1697 else
1698 {
1699 if(buflen >= sizeof(DEVMODEA)) {
1700 memcpy(ptr, &dm, sizeof(DEVMODEA));
1701 }
1702 *needed = sizeof(DEVMODEA);
1703 }
1704 }
1705
1706 /*****************************************************************************
1707 * WINSPOOL_GetDevModeFromReg
1708 *
1709 * Get ValueName from hkey storing result in ptr. buflen is space left in ptr
1710 * DevMode is stored either as unicode or ascii.
1711 */
1712 static BOOL WINSPOOL_GetDevModeFromReg(HKEY hkey, LPCWSTR ValueName,
1713 LPBYTE ptr,
1714 DWORD buflen, DWORD *needed,
1715 BOOL unicode)
1716 {
1717 DWORD sz = buflen, type;
1718 LONG ret;
1719
1720 if (ptr && buflen>=sizeof(DEVMODEA)) memset(ptr, 0, sizeof(DEVMODEA));
1721 ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
1722 if ((ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)) sz = 0;
1723 if (sz < sizeof(DEVMODEA))
1724 {
1725 TRACE("corrupted registry for %s ( size %ld)\n",debugstr_w(ValueName),sz);
1726 return FALSE;
1727 }
1728 /* ensures that dmSize is not erratically bogus if registry is invalid */
1729 if (ptr && ((DEVMODEA*)ptr)->dmSize < sizeof(DEVMODEA))
1730 ((DEVMODEA*)ptr)->dmSize = sizeof(DEVMODEA);
1731 if(unicode) {
1732 sz += (CCHDEVICENAME + CCHFORMNAME);
1733 if(buflen >= sz) {
1734 DEVMODEW *dmW = GdiConvertToDevmodeW((DEVMODEA*)ptr);
1735 memcpy(ptr, dmW, sz);
1736 HeapFree(GetProcessHeap(),0,dmW);
1737 }
1738 }
1739 *needed = sz;
1740 return TRUE;
1741 }
1742
1743 /*********************************************************************
1744 * WINSPOOL_GetPrinter_2
1745 *
1746 * Fills out a PRINTER_INFO_2A|W struct storing the strings in buf.
1747 * The strings are either stored as unicode or ascii.
1748 */
1749 static BOOL WINSPOOL_GetPrinter_2(HKEY hkeyPrinter, PRINTER_INFO_2W *pi2,
1750 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
1751 BOOL unicode)
1752 {
1753 DWORD size, left = cbBuf;
1754 BOOL space = (cbBuf > 0);
1755 LPBYTE ptr = buf;
1756
1757 *pcbNeeded = 0;
1758
1759 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
1760 unicode)) {
1761 if(space && size <= left) {
1762 pi2->pPrinterName = (LPWSTR)ptr;
1763 ptr += size;
1764 left -= size;
1765 } else
1766 space = FALSE;
1767 *pcbNeeded += size;
1768 }
1769 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Share_NameW, ptr, left, &size,
1770 unicode)) {
1771 if(space && size <= left) {
1772 pi2->pShareName = (LPWSTR)ptr;
1773 ptr += size;
1774 left -= size;
1775 } else
1776 space = FALSE;
1777 *pcbNeeded += size;
1778 }
1779 if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
1780 unicode)) {
1781 if(space && size <= left) {
1782 pi2->pPortName = (LPWSTR)ptr;
1783 ptr += size;
1784 left -= size;
1785 } else
1786 space = FALSE;
1787 *pcbNeeded += size;
1788 }
1789 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Printer_DriverW, ptr, left,
1790 &size, unicode)) {
1791 if(space && size <= left) {
1792 pi2->pDriverName = (LPWSTR)ptr;
1793 ptr += size;
1794 left -= size;
1795 } else
1796 space = FALSE;
1797 *pcbNeeded += size;
1798 }
1799 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DescriptionW, ptr, left, &size,
1800 unicode)) {
1801 if(space && size <= left) {
1802 pi2->pComment = (LPWSTR)ptr;
1803 ptr += size;
1804 left -= size;
1805 } else
1806 space = FALSE;
1807 *pcbNeeded += size;
1808 }
1809 if(WINSPOOL_GetStringFromReg(hkeyPrinter, LocationW, ptr, left, &size,
1810 unicode)) {
1811 if(space && size <= left) {
1812 pi2->pLocation = (LPWSTR)ptr;
1813 ptr += size;
1814 left -= size;
1815 } else
1816 space = FALSE;
1817 *pcbNeeded += size;
1818 }
1819 if(WINSPOOL_GetDevModeFromReg(hkeyPrinter, Default_DevModeW, ptr, left,
1820 &size, unicode)) {
1821 if(space && size <= left) {
1822 pi2->pDevMode = (LPDEVMODEW)ptr;
1823 ptr += size;
1824 left -= size;
1825 } else
1826 space = FALSE;
1827 *pcbNeeded += size;
1828 }
1829 else
1830 {
1831 WINSPOOL_GetDefaultDevMode(ptr, left, &size, unicode);
1832 if(space && size <= left) {
1833 pi2->pDevMode = (LPDEVMODEW)ptr;
1834 ptr += size;
1835 left -= size;
1836 } else
1837 space = FALSE;
1838 *pcbNeeded += size;
1839 }
1840 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Separator_FileW, ptr, left,
1841 &size, unicode)) {
1842 if(space && size <= left) {
1843 pi2->pSepFile = (LPWSTR)ptr;
1844 ptr += size;
1845 left -= size;
1846 } else
1847 space = FALSE;
1848 *pcbNeeded += size;
1849 }
1850 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Print_ProcessorW, ptr, left,
1851 &size, unicode)) {
1852 if(space && size <= left) {
1853 pi2->pPrintProcessor = (LPWSTR)ptr;
1854 ptr += size;
1855 left -= size;
1856 } else
1857 space = FALSE;
1858 *pcbNeeded += size;
1859 }
1860 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DatatypeW, ptr, left,
1861 &size, unicode)) {
1862 if(space && size <= left) {
1863 pi2->pDatatype = (LPWSTR)ptr;
1864 ptr += size;
1865 left -= size;
1866 } else
1867 space = FALSE;
1868 *pcbNeeded += size;
1869 }
1870 if(WINSPOOL_GetStringFromReg(hkeyPrinter, ParametersW, ptr, left,
1871 &size, unicode)) {
1872 if(space && size <= left) {
1873 pi2->pParameters = (LPWSTR)ptr;
1874 ptr += size;
1875 left -= size;
1876 } else
1877 space = FALSE;
1878 *pcbNeeded += size;
1879 }
1880 if(pi2) {
1881 pi2->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
1882 pi2->Priority = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Priority");
1883 pi2->DefaultPriority = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
1884 "Default Priority");
1885 pi2->StartTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "StartTime");
1886 pi2->UntilTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "UntilTime");
1887 }
1888
1889 if(!space && pi2) /* zero out pi2 if we can't completely fill buf */
1890 memset(pi2, 0, sizeof(*pi2));
1891
1892 return space;
1893 }
1894
1895 /*********************************************************************
1896 * WINSPOOL_GetPrinter_4
1897 *
1898 * Fills out a PRINTER_INFO_4 struct storing the strings in buf.
1899 */
1900 static BOOL WINSPOOL_GetPrinter_4(HKEY hkeyPrinter, PRINTER_INFO_4W *pi4,
1901 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
1902 BOOL unicode)
1903 {
1904 DWORD size, left = cbBuf;
1905 BOOL space = (cbBuf > 0);
1906 LPBYTE ptr = buf;
1907
1908 *pcbNeeded = 0;
1909
1910 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
1911 unicode)) {
1912 if(space && size <= left) {
1913 pi4->pPrinterName = (LPWSTR)ptr;
1914 ptr += size;
1915 left -= size;
1916 } else
1917 space = FALSE;
1918 *pcbNeeded += size;
1919 }
1920 if(pi4) {
1921 pi4->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
1922 }
1923
1924 if(!space && pi4) /* zero out pi4 if we can't completely fill buf */
1925 memset(pi4, 0, sizeof(*pi4));
1926
1927 return space;
1928 }
1929
1930 /*********************************************************************
1931 * WINSPOOL_GetPrinter_5
1932 *
1933 * Fills out a PRINTER_INFO_5 struct storing the strings in buf.
1934 */
1935 static BOOL WINSPOOL_GetPrinter_5(HKEY hkeyPrinter, PRINTER_INFO_5W *pi5,
1936 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
1937 BOOL unicode)
1938 {
1939 DWORD size, left = cbBuf;
1940 BOOL space = (cbBuf > 0);
1941 LPBYTE ptr = buf;
1942
1943 *pcbNeeded = 0;
1944
1945 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
1946 unicode)) {
1947 if(space && size <= left) {
1948 pi5->pPrinterName = (LPWSTR)ptr;
1949 ptr += size;
1950 left -= size;
1951 } else
1952 space = FALSE;
1953 *pcbNeeded += size;
1954 }
1955 if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
1956 unicode)) {
1957 if(space && size <= left) {
1958 pi5->pPortName = (LPWSTR)ptr;
1959 ptr += size;
1960 left -= size;
1961 } else
1962 space = FALSE;
1963 *pcbNeeded += size;
1964 }
1965 if(pi5) {
1966 pi5->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
1967 pi5->DeviceNotSelectedTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
1968 "dnsTimeout");
1969 pi5->TransmissionRetryTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
1970 "txTimeout");
1971 }
1972
1973 if(!space && pi5) /* zero out pi5 if we can't completely fill buf */
1974 memset(pi5, 0, sizeof(*pi5));
1975
1976 return space;
1977 }
1978
1979 /*****************************************************************************
1980 * WINSPOOL_GetPrinter
1981 *
1982 * Implementation of GetPrinterA|W. Relies on PRINTER_INFO_*W being
1983 * essentially the same as PRINTER_INFO_*A. i.e. the structure itself is
1984 * just a collection of pointers to strings.
1985 */
1986 static BOOL WINSPOOL_GetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1987 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
1988 {
1989 LPCWSTR name;
1990 DWORD size, needed = 0;
1991 LPBYTE ptr = NULL;
1992 HKEY hkeyPrinter, hkeyPrinters;
1993 BOOL ret;
1994
1995 TRACE("(%p,%ld,%p,%ld,%p)\n",hPrinter,Level,pPrinter,cbBuf, pcbNeeded);
1996
1997 if (!(name = WINSPOOL_GetOpenedPrinter(hPrinter))) return FALSE;
1998
1999 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
2000 ERROR_SUCCESS) {
2001 ERR("Can't create Printers key\n");
2002 return FALSE;
2003 }
2004 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter) != ERROR_SUCCESS)
2005 {
2006 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
2007 RegCloseKey(hkeyPrinters);
2008 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
2009 return FALSE;
2010 }
2011
2012 switch(Level) {
2013 case 2:
2014 {
2015 PRINTER_INFO_2W *pi2 = (PRINTER_INFO_2W *)pPrinter;
2016
2017 size = sizeof(PRINTER_INFO_2W);
2018 if(size <= cbBuf) {
2019 ptr = pPrinter + size;
2020 cbBuf -= size;
2021 memset(pPrinter, 0, size);
2022 } else {
2023 pi2 = NULL;
2024 cbBuf = 0;
2025 }
2026 ret = WINSPOOL_GetPrinter_2(hkeyPrinter, pi2, ptr, cbBuf, &needed,
2027 unicode);
2028 needed += size;
2029 break;
2030 }
2031
2032 case 4:
2033 {
2034 PRINTER_INFO_4W *pi4 = (PRINTER_INFO_4W *)pPrinter;
2035
2036 size = sizeof(PRINTER_INFO_4W);
2037 if(size <= cbBuf) {
2038 ptr = pPrinter + size;
2039 cbBuf -= size;
2040 memset(pPrinter, 0, size);
2041 } else {
2042 pi4 = NULL;
2043 cbBuf = 0;
2044 }
2045 ret = WINSPOOL_GetPrinter_4(hkeyPrinter, pi4, ptr, cbBuf, &needed,
2046 unicode);
2047 needed += size;
2048 break;
2049 }
2050
2051
2052 case 5:
2053 {
2054 PRINTER_INFO_5W *pi5 = (PRINTER_INFO_5W *)pPrinter;
2055
2056 size = sizeof(PRINTER_INFO_5W);
2057 if(size <= cbBuf) {
2058 ptr = pPrinter + size;
2059 cbBuf -= size;
2060 memset(pPrinter, 0, size);
2061 } else {
2062 pi5 = NULL;
2063 cbBuf = 0;
2064 }
2065
2066 ret = WINSPOOL_GetPrinter_5(hkeyPrinter, pi5, ptr, cbBuf, &needed,
2067 unicode);
2068 needed += size;
2069 break;
2070 }
2071
2072 default:
2073 FIXME("Unimplemented level %ld\n", Level);
2074 SetLastError(ERROR_INVALID_LEVEL);
2075 RegCloseKey(hkeyPrinters);
2076 RegCloseKey(hkeyPrinter);
2077 return FALSE;
2078 }
2079
2080 RegCloseKey(hkeyPrinter);
2081 RegCloseKey(hkeyPrinters);
2082
2083 TRACE("returning %d needed = %ld\n", ret, needed);
2084 if(pcbNeeded) *pcbNeeded = needed;
2085 if(!ret)
2086 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2087 return ret;
2088 }
2089
2090 /*****************************************************************************
2091 * GetPrinterW [WINSPOOL.@]
2092 */
2093 BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
2094 DWORD cbBuf, LPDWORD pcbNeeded)
2095 {
2096 return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
2097 TRUE);
2098 }
2099
2100 /*****************************************************************************
2101 * GetPrinterA [WINSPOOL.@]
2102 */
2103 BOOL WINAPI GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
2104 DWORD cbBuf, LPDWORD pcbNeeded)
2105 {
2106 return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
2107 FALSE);
2108 }
2109
2110 /*****************************************************************************
2111 * WINSPOOL_EnumPrinters
2112 *
2113 * Implementation of EnumPrintersA|W
2114 */
2115 static BOOL WINSPOOL_EnumPrinters(DWORD dwType, LPWSTR lpszName,
2116 DWORD dwLevel, LPBYTE lpbPrinters,
2117 DWORD cbBuf, LPDWORD lpdwNeeded,
2118 LPDWORD lpdwReturned, BOOL unicode)
2119
2120 {
2121 HKEY hkeyPrinters, hkeyPrinter;
2122 WCHAR PrinterName[255];
2123 DWORD needed = 0, number = 0;
2124 DWORD used, i, left;
2125 PBYTE pi, buf;
2126
2127 if(lpbPrinters)
2128 memset(lpbPrinters, 0, cbBuf);
2129 if(lpdwReturned)
2130 *lpdwReturned = 0;
2131 if(lpdwNeeded)
2132 *lpdwNeeded = 0;
2133
2134 /* PRINTER_ENUM_DEFAULT is only supported under win9x, we behave like NT */
2135 if(dwType == PRINTER_ENUM_DEFAULT)
2136 return TRUE;
2137
2138 if (dwType & PRINTER_ENUM_CONNECTIONS) {
2139 FIXME("We don't handle PRINTER_ENUM_CONNECTIONS\n");
2140 dwType &= ~PRINTER_ENUM_CONNECTIONS; /* we don't handle that */
2141 if(!dwType) return TRUE;
2142 }
2143
2144 if (!((dwType & PRINTER_ENUM_LOCAL) || (dwType & PRINTER_ENUM_NAME))) {
2145 FIXME("dwType = %08lx\n", dwType);
2146 SetLastError(ERROR_INVALID_FLAGS);
2147 return FALSE;
2148 }
2149
2150 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
2151 ERROR_SUCCESS) {
2152 ERR("Can't create Printers key\n");
2153 return FALSE;
2154 }
2155
2156 if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &number, NULL, NULL,
2157 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
2158 RegCloseKey(hkeyPrinters);
2159 ERR("Can't query Printers key\n");
2160 return FALSE;
2161 }
2162 TRACE("Found %ld printers\n", number);
2163
2164 switch(dwLevel) {
2165 case 1:
2166 RegCloseKey(hkeyPrinters);
2167 if (lpdwReturned)
2168 *lpdwReturned = number;
2169 return TRUE;
2170
2171 case 2:
2172 used = number * sizeof(PRINTER_INFO_2W);
2173 break;
2174 case 4:
2175 used = number * sizeof(PRINTER_INFO_4W);
2176 break;
2177 case 5:
2178 used = number * sizeof(PRINTER_INFO_5W);
2179 break;
2180
2181 default:
2182 SetLastError(ERROR_INVALID_LEVEL);
2183 RegCloseKey(hkeyPrinters);
2184 return FALSE;
2185 }
2186 pi = (used <= cbBuf) ? lpbPrinters : NULL;
2187
2188 for(i = 0; i < number; i++) {
2189 if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)) !=
2190 ERROR_SUCCESS) {
2191 ERR("Can't enum key number %ld\n", i);
2192 RegCloseKey(hkeyPrinters);
2193 return FALSE;
2194 }
2195 TRACE("Printer %ld is %s\n", i, debugstr_w(PrinterName));
2196 if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkeyPrinter) !=
2197 ERROR_SUCCESS) {
2198 ERR("Can't open key %s\n", debugstr_w(PrinterName));
2199 RegCloseKey(hkeyPrinters);
2200 return FALSE;
2201 }
2202
2203 if(cbBuf > used) {
2204 buf = lpbPrinters + used;
2205 left = cbBuf - used;
2206 } else {
2207 buf = NULL;
2208 left = 0;
2209 }
2210
2211 switch(dwLevel) {
2212 case 2:
2213 WINSPOOL_GetPrinter_2(hkeyPrinter, (PRINTER_INFO_2W *)pi, buf,
2214 left, &needed, unicode);
2215 used += needed;
2216 if(pi) pi += sizeof(PRINTER_INFO_2W);
2217 break;
2218 case 4:
2219 WINSPOOL_GetPrinter_4(hkeyPrinter, (PRINTER_INFO_4W *)pi, buf,
2220 left, &needed, unicode);
2221 used += needed;
2222 if(pi) pi += sizeof(PRINTER_INFO_4W);
2223 break;
2224 case 5:
2225 WINSPOOL_GetPrinter_5(hkeyPrinter, (PRINTER_INFO_5W *)pi, buf,
2226 left, &needed, unicode);
2227 used += needed;
2228 if(pi) pi += sizeof(PRINTER_INFO_5W);
2229 break;
2230 default:
2231 ERR("Shouldn't be here!\n");
2232 RegCloseKey(hkeyPrinter);
2233 RegCloseKey(hkeyPrinters);
2234 return FALSE;
2235 }
2236 RegCloseKey(hkeyPrinter);
2237 }
2238 RegCloseKey(hkeyPrinters);
2239
2240 if(lpdwNeeded)
2241 *lpdwNeeded = used;
2242
2243 if(used > cbBuf) {
2244 if(lpbPrinters)
2245 memset(lpbPrinters, 0, cbBuf);
2246 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2247 return FALSE;
2248 }
2249 if(lpdwReturned)
2250 *lpdwReturned = number;
2251 SetLastError(ERROR_SUCCESS);
2252 return TRUE;
2253 }
2254
2255
2256 /******************************************************************
2257 * EnumPrintersW [WINSPOOL.@]
2258 *
2259 * Enumerates the available printers, print servers and print
2260 * providers, depending on the specified flags, name and level.
2261 *
2262 * RETURNS:
2263 *
2264 * If level is set to 1:
2265 * Not implemented yet!
2266 * Returns TRUE with an empty list.
2267 *
2268 * If level is set to 2:
2269 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
2270 * Returns an array of PRINTER_INFO_2 data structures in the
2271 * lpbPrinters buffer. Note that according to MSDN also an
2272 * OpenPrinter should be performed on every remote printer.
2273 *
2274 * If level is set to 4 (officially WinNT only):
2275 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
2276 * Fast: Only the registry is queried to retrieve printer names,
2277 * no connection to the driver is made.
2278 * Returns an array of PRINTER_INFO_4 data structures in the
2279 * lpbPrinters buffer.
2280 *
2281 * If level is set to 5 (officially WinNT4/Win9x only):
2282 * Fast: Only the registry is queried to retrieve printer names,
2283 * no connection to the driver is made.
2284 * Returns an array of PRINTER_INFO_5 data structures in the
2285 * lpbPrinters buffer.
2286 *
2287 * If level set to 3 or 6+:
2288 * returns zero (failure!)
2289 *
2290 * Returns nonzero (TRUE) on success, or zero on failure, use GetLastError
2291 * for information.
2292 *
2293 * BUGS:
2294 * - Only PRINTER_ENUM_LOCAL and PRINTER_ENUM_NAME are implemented.
2295 * - Only levels 2, 4 and 5 are implemented at the moment.
2296 * - 16-bit printer drivers are not enumerated.
2297 * - Returned amount of bytes used/needed does not match the real Windoze
2298 * implementation (as in this implementation, all strings are part
2299 * of the buffer, whereas Win32 keeps them somewhere else)
2300 * - At level 2, EnumPrinters should also call OpenPrinter for remote printers.
2301 *
2302 * NOTE:
2303 * - In a regular Wine installation, no registry settings for printers
2304 * exist, which makes this function return an empty list.
2305 */
2306 BOOL WINAPI EnumPrintersW(
2307 DWORD dwType, /* [in] Types of print objects to enumerate */
2308 LPWSTR lpszName, /* [in] name of objects to enumerate */
2309 DWORD dwLevel, /* [in] type of printer info structure */
2310 LPBYTE lpbPrinters, /* [out] buffer which receives info */
2311 DWORD cbBuf, /* [in] max size of buffer in bytes */
2312 LPDWORD lpdwNeeded, /* [out] pointer to var: # bytes used/needed */
2313 LPDWORD lpdwReturned /* [out] number of entries returned */
2314 )
2315 {
2316 return WINSPOOL_EnumPrinters(dwType, lpszName, dwLevel, lpbPrinters, cbBuf,
2317 lpdwNeeded, lpdwReturned, TRUE);
2318 }
2319
2320 /******************************************************************
2321 * EnumPrintersA [WINSPOOL.@]
2322 *
2323 */
2324 BOOL WINAPI EnumPrintersA(DWORD dwType, LPSTR lpszName,
2325 DWORD dwLevel, LPBYTE lpbPrinters,
2326 DWORD cbBuf, LPDWORD lpdwNeeded,
2327 LPDWORD lpdwReturned)
2328 {
2329 BOOL ret;
2330 UNICODE_STRING lpszNameW;
2331 PWSTR pwstrNameW;
2332
2333 pwstrNameW = asciitounicode(&lpszNameW,lpszName);
2334 ret = WINSPOOL_EnumPrinters(dwType, pwstrNameW, dwLevel, lpbPrinters, cbBuf,
2335 lpdwNeeded, lpdwReturned, FALSE);
2336 RtlFreeUnicodeString(&lpszNameW);
2337 return ret;
2338 }
2339
2340 /*****************************************************************************
2341 * WINSPOOL_GetDriverInfoFromReg [internal]
2342 *
2343 * Enters the information from the registry into the DRIVER_INFO struct
2344 *
2345 * RETURNS
2346 * zero if the printer driver does not exist in the registry
2347 * (only if Level > 1) otherwise nonzero
2348 */
2349 static BOOL WINSPOOL_GetDriverInfoFromReg(
2350 HKEY hkeyDrivers,
2351 LPWSTR DriverName,
2352 LPWSTR pEnvironment,
2353 DWORD Level,
2354 LPBYTE ptr, /* DRIVER_INFO */
2355 LPBYTE pDriverStrings, /* strings buffer */
2356 DWORD cbBuf, /* size of string buffer */
2357 LPDWORD pcbNeeded, /* space needed for str. */
2358 BOOL unicode) /* type of strings */
2359 { DWORD dw, size, tmp, type;
2360 HKEY hkeyDriver;
2361 LPBYTE strPtr = pDriverStrings;
2362
2363 TRACE("%s,%s,%ld,%p,%p,%ld,%d\n",
2364 debugstr_w(DriverName), debugstr_w(pEnvironment),
2365 Level, ptr, pDriverStrings, cbBuf, unicode);
2366
2367 if(unicode) {
2368 *pcbNeeded = (lstrlenW(DriverName) + 1) * sizeof(WCHAR);
2369 if (*pcbNeeded <= cbBuf)
2370 strcpyW((LPWSTR)strPtr, DriverName);
2371 } else {
2372 *pcbNeeded = WideCharToMultiByte(CP_ACP, 0, DriverName, -1, NULL, 0,
2373 NULL, NULL);
2374 if(*pcbNeeded <= cbBuf)
2375 WideCharToMultiByte(CP_ACP, 0, DriverName, -1, strPtr, *pcbNeeded,
2376 NULL, NULL);
2377 }
2378 if(Level == 1) {
2379 if(ptr)
2380 ((PDRIVER_INFO_1W) ptr)->pName = (LPWSTR) strPtr;
2381 return TRUE;
2382 } else {
2383 if(ptr)
2384 ((PDRIVER_INFO_3W) ptr)->pName = (LPWSTR) strPtr;
2385 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
2386 }
2387
2388 if(!DriverName[0] || RegOpenKeyW(hkeyDrivers, DriverName, &hkeyDriver) != ERROR_SUCCESS) {
2389 ERR("Can't find driver '%s' in registry\n", debugstr_w(DriverName));
2390 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER); /* ? */
2391 return FALSE;
2392 }
2393
2394 size = sizeof(dw);
2395 if(RegQueryValueExA(hkeyDriver, "Version", 0, &type, (PBYTE)&dw, &size) !=
2396 ERROR_SUCCESS)
2397 WARN("Can't get Version\n");
2398 else if(ptr)
2399 ((PDRIVER_INFO_3A) ptr)->cVersion = dw;
2400
2401 if(!pEnvironment)
2402 pEnvironment = (LPWSTR)DefaultEnvironmentW;
2403 if(unicode)
2404 size = (lstrlenW(pEnvironment) + 1) * sizeof(WCHAR);
2405 else
2406 size = WideCharToMultiByte(CP_ACP, 0, pEnvironment, -1, NULL, 0,
2407 NULL, NULL);
2408 *pcbNeeded += size;
2409 if(*pcbNeeded <= cbBuf) {
2410 if(unicode)
2411 strcpyW((LPWSTR)strPtr, pEnvironment);
2412 else
2413 WideCharToMultiByte(CP_ACP, 0, pEnvironment, -1, strPtr, size,
2414 NULL, NULL);
2415 if(ptr)
2416 ((PDRIVER_INFO_3W) ptr)->pEnvironment = (LPWSTR)strPtr;
2417 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
2418 }
2419
2420 if(WINSPOOL_GetStringFromReg(hkeyDriver, DriverW, strPtr, 0, &size,
2421 unicode)) {
2422 *pcbNeeded += size;
2423 if(*pcbNeeded <= cbBuf)
2424 WINSPOOL_GetStringFromReg(hkeyDriver, DriverW, strPtr, size, &tmp,
2425 unicode);
2426 if(ptr)
2427 ((PDRIVER_INFO_3W) ptr)->pDriverPath = (LPWSTR)strPtr;
2428 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
2429 }
2430
2431 if(WINSPOOL_GetStringFromReg(hkeyDriver, Data_FileW, strPtr, 0, &size,
2432 unicode)) {
2433 *pcbNeeded += size;
2434 if(*pcbNeeded <= cbBuf)
2435 WINSPOOL_GetStringFromReg(hkeyDriver, Data_FileW, strPtr, size,
2436 &tmp, unicode);
2437 if(ptr)
2438 ((PDRIVER_INFO_3W) ptr)->pDataFile = (LPWSTR)strPtr;
2439 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2440 }
2441
2442 if(WINSPOOL_GetStringFromReg(hkeyDriver, Configuration_FileW, strPtr,
2443 0, &size, unicode)) {
2444 *pcbNeeded += size;
2445 if(*pcbNeeded <= cbBuf)
2446 WINSPOOL_GetStringFromReg(hkeyDriver, Configuration_FileW, strPtr,
2447 size, &tmp, unicode);
2448 if(ptr)
2449 ((PDRIVER_INFO_3W) ptr)->pConfigFile = (LPWSTR)strPtr;
2450 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2451 }
2452
2453 if(Level == 2 ) {
2454 RegCloseKey(hkeyDriver);
2455 TRACE("buffer space %ld required %ld\n", cbBuf, *pcbNeeded);
2456 return TRUE;
2457 }
2458
2459 if(WINSPOOL_GetStringFromReg(hkeyDriver, Help_FileW, strPtr, 0, &size,
2460 unicode)) {
2461 *pcbNeeded += size;
2462 if(*pcbNeeded <= cbBuf)
2463 WINSPOOL_GetStringFromReg(hkeyDriver, Help_FileW, strPtr,
2464 size, &tmp, unicode);
2465 if(ptr)
2466 ((PDRIVER_INFO_3W) ptr)->pHelpFile = (LPWSTR)strPtr;
2467 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2468 }
2469
2470 if(WINSPOOL_GetStringFromReg(hkeyDriver, Dependent_FilesW, strPtr, 0,
2471 &size, unicode)) {
2472 *pcbNeeded += size;
2473 if(*pcbNeeded <= cbBuf)
2474 WINSPOOL_GetStringFromReg(hkeyDriver, Dependent_FilesW, strPtr,
2475 size, &tmp, unicode);
2476 if(ptr)
2477 ((PDRIVER_INFO_3W) ptr)->pDependentFiles = (LPWSTR)strPtr;
2478 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2479 }
2480
2481 if(WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr, 0, &size,
2482 unicode)) {
2483 *pcbNeeded += size;
2484 if(*pcbNeeded <= cbBuf)
2485 WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr,
2486 size, &tmp, unicode);
2487 if(ptr)
2488 ((PDRIVER_INFO_3W) ptr)->pMonitorName = (LPWSTR)strPtr;
2489 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2490 }
2491
2492 if(WINSPOOL_GetStringFromReg(hkeyDriver, DatatypeW, strPtr, 0, &size,
2493 unicode)) {
2494 *pcbNeeded += size;
2495 if(*pcbNeeded <= cbBuf)
2496 WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr,
2497 size, &tmp, unicode);
2498 if(ptr)
2499 ((PDRIVER_INFO_3W) ptr)->pDefaultDataType = (LPWSTR)strPtr;
2500 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2501 }
2502
2503 TRACE("buffer space %ld required %ld\n", cbBuf, *pcbNeeded);
2504 RegCloseKey(hkeyDriver);
2505 return TRUE;
2506 }
2507
2508 /*****************************************************************************
2509 * WINSPOOL_GetPrinterDriver
2510 */
2511 static BOOL WINSPOOL_GetPrinterDriver(HANDLE hPrinter, LPWSTR pEnvironment,
2512 DWORD Level, LPBYTE pDriverInfo,
2513 DWORD cbBuf, LPDWORD pcbNeeded,
2514 BOOL unicode)
2515 {
2516 LPCWSTR name;
2517 WCHAR DriverName[100];
2518 DWORD ret, type, size, needed = 0;
2519 LPBYTE ptr = NULL;
2520 HKEY hkeyPrinter, hkeyPrinters, hkeyDrivers;
2521
2522 TRACE("(%p,%s,%ld,%p,%ld,%p)\n",hPrinter,debugstr_w(pEnvironment),
2523 Level,pDriverInfo,cbBuf, pcbNeeded);
2524
2525 ZeroMemory(pDriverInfo, cbBuf);
2526
2527 if (!(name = WINSPOOL_GetOpenedPrinter(hPrinter))) return FALSE;
2528
2529 if(Level < 1 || Level > 3) {
2530 SetLastError(ERROR_INVALID_LEVEL);
2531 return FALSE;
2532 }
2533 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
2534 ERROR_SUCCESS) {
2535 ERR("Can't create Printers key\n");
2536 return FALSE;
2537 }
2538 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter)
2539 != ERROR_SUCCESS) {
2540 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
2541 RegCloseKey(hkeyPrinters);
2542 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
2543 return FALSE;
2544 }
2545 size = sizeof(DriverName);
2546 DriverName[0] = 0;
2547 ret = RegQueryValueExW(hkeyPrinter, Printer_DriverW, 0, &type,
2548 (LPBYTE)DriverName, &size);
2549 RegCloseKey(hkeyPrinter);
2550 RegCloseKey(hkeyPrinters);
2551 if(ret != ERROR_SUCCESS) {
2552 ERR("Can't get DriverName for printer %s\n", debugstr_w(name));
2553 return FALSE;
2554 }
2555
2556 hkeyDrivers = WINSPOOL_OpenDriverReg( pEnvironment, TRUE);
2557 if(!hkeyDrivers) {
2558 ERR("Can't create Drivers key\n");
2559 return FALSE;
2560 }
2561
2562 switch(Level) {
2563 case 1:
2564 size = sizeof(DRIVER_INFO_1W);
2565 break;
2566 case 2:
2567 size = sizeof(DRIVER_INFO_2W);
2568 break;
2569 case 3:
2570 size = sizeof(DRIVER_INFO_3W);
2571 break;
2572 default:
2573 ERR("Invalid level\n");
2574 return FALSE;
2575 }
2576
2577 if(size <= cbBuf)
2578 ptr = pDriverInfo + size;
2579
2580 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverName,
2581 pEnvironment, Level, pDriverInfo,
2582 (cbBuf < size) ? NULL : ptr,
2583 (cbBuf < size) ? 0 : cbBuf - size,
2584 &needed, unicode)) {
2585 RegCloseKey(hkeyDrivers);
2586 return FALSE;
2587 }
2588
2589 RegCloseKey(hkeyDrivers);
2590
2591 if(pcbNeeded) *pcbNeeded = size + needed;
2592 TRACE("buffer space %ld required %ld\n", cbBuf, *pcbNeeded);
2593 if(cbBuf >= needed) return TRUE;
2594 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2595 return FALSE;
2596 }
2597
2598 /*****************************************************************************
2599 * GetPrinterDriverA [WINSPOOL.@]
2600 */
2601 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
2602 DWORD Level, LPBYTE pDriverInfo,
2603 DWORD cbBuf, LPDWORD pcbNeeded)
2604 {
2605 BOOL ret;
2606 UNICODE_STRING pEnvW;
2607 PWSTR pwstrEnvW;
2608
2609 pwstrEnvW = asciitounicode(&pEnvW, pEnvironment);
2610 ret = WINSPOOL_GetPrinterDriver(hPrinter, pwstrEnvW, Level, pDriverInfo,
2611 cbBuf, pcbNeeded, FALSE);
2612 RtlFreeUnicodeString(&pEnvW);
2613 return ret;
2614 }
2615 /*****************************************************************************
2616 * GetPrinterDriverW [WINSPOOL.@]
2617 */
2618 BOOL WINAPI GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment,
2619 DWORD Level, LPBYTE pDriverInfo,
2620 DWORD cbBuf, LPDWORD pcbNeeded)
2621 {
2622 return WINSPOOL_GetPrinterDriver(hPrinter, pEnvironment, Level,
2623 pDriverInfo, cbBuf, pcbNeeded, TRUE);
2624 }
2625
2626 /*****************************************************************************
2627 * GetPrinterDriverDirectoryW [WINSPOOL.@]
2628 */
2629 BOOL WINAPI GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment,
2630 DWORD Level, LPBYTE pDriverDirectory,
2631 DWORD cbBuf, LPDWORD pcbNeeded)
2632 {
2633 DWORD needed;
2634
2635 TRACE("(%s, %s, %ld, %p, %ld, %p)\n", debugstr_w(pName),
2636 debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
2637 if(pName != NULL) {
2638 FIXME("pName = `%s' - unsupported\n", debugstr_w(pName));
2639 SetLastError(ERROR_INVALID_PARAMETER);
2640 return FALSE;
2641 }
2642 if(pEnvironment != NULL) {
2643 FIXME("pEnvironment = `%s' - unsupported\n", debugstr_w(pEnvironment));
2644 SetLastError(ERROR_INVALID_ENVIRONMENT);
2645 return FALSE;
2646 }
2647 if(Level != 1) /* win95 ignores this so we just carry on */
2648 WARN("Level = %ld - assuming 1\n", Level);
2649
2650 /* FIXME should read from registry */
2651 needed = GetSystemDirectoryW( (LPWSTR)pDriverDirectory, cbBuf/sizeof(WCHAR));
2652 /* GetSystemDirectoryW returns number of TCHAR without '\0'
2653 * adjust this now
2654 */
2655 needed++;
2656 needed*=sizeof(WCHAR);
2657
2658 if(pcbNeeded)
2659 *pcbNeeded = needed;
2660 TRACE("required <%08lx>\n", *pcbNeeded);
2661 if(needed > cbBuf) {
2662 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2663 return FALSE;
2664 }
2665 return TRUE;
2666 }
2667
2668
2669 /*****************************************************************************
2670 * GetPrinterDriverDirectoryA [WINSPOOL.@]
2671 */
2672 BOOL WINAPI GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment,
2673 DWORD Level, LPBYTE pDriverDirectory,
2674 DWORD cbBuf, LPDWORD pcbNeeded)
2675 {
2676 UNICODE_STRING nameW, environmentW;
2677 BOOL ret;
2678 DWORD pcbNeededW;
2679 INT len = cbBuf * sizeof(WCHAR)/sizeof(CHAR);
2680 WCHAR *driverDirectoryW = NULL;
2681
2682 if (len) driverDirectoryW = HeapAlloc( GetProcessHeap(), 0, len );
2683
2684 if(pName) RtlCreateUnicodeStringFromAsciiz(&nameW, pName);
2685 else nameW.Buffer = NULL;
2686 if(pEnvironment) RtlCreateUnicodeStringFromAsciiz(&environmentW, pEnvironment);
2687 else environmentW.Buffer = NULL;
2688
2689 ret = GetPrinterDriverDirectoryW( nameW.Buffer, environmentW.Buffer, Level,
2690 (LPBYTE)driverDirectoryW, len, &pcbNeededW );
2691 if (ret) {
2692 DWORD needed;
2693 needed = 1 + WideCharToMultiByte( CP_ACP, 0, driverDirectoryW, -1,
2694 pDriverDirectory, cbBuf, NULL, NULL);
2695 if(pcbNeeded)
2696 *pcbNeeded = needed;
2697 ret = (needed <= cbBuf) ? TRUE : FALSE;
2698 } else
2699 if(pcbNeeded) *pcbNeeded = pcbNeededW * sizeof(CHAR)/sizeof(WCHAR);
2700
2701 TRACE("provided<%ld> required <%ld>\n", cbBuf, *pcbNeeded);
2702
2703 if(driverDirectoryW)
2704 HeapFree( GetProcessHeap(), 0, driverDirectoryW );
2705 RtlFreeUnicodeString(&environmentW);
2706 RtlFreeUnicodeString(&nameW);
2707
2708 return ret;
2709 }
2710
2711 /*****************************************************************************
2712 * AddPrinterDriverA [WINSPOOL.@]
2713 */
2714 BOOL WINAPI AddPrinterDriverA(LPSTR pName, DWORD level, LPBYTE pDriverInfo)
2715 {
2716 DRIVER_INFO_3A di3;
2717 HKEY hkeyDrivers, hkeyName;
2718
2719 TRACE("(%s,%ld,%p)\n",debugstr_a(pName),level,pDriverInfo);
2720
2721 if(level != 2 && level != 3) {
2722 SetLastError(ERROR_INVALID_LEVEL);
2723 return FALSE;
2724 }
2725 if(pName != NULL) {
2726 FIXME("pName= %s - unsupported\n", debugstr_a(pName));
2727 SetLastError(ERROR_INVALID_PARAMETER);
2728 return FALSE;
2729 }
2730 if(!pDriverInfo) {
2731 WARN("pDriverInfo == NULL\n");
2732 SetLastError(ERROR_INVALID_PARAMETER);
2733 return FALSE;
2734 }
2735
2736 if(level == 3)
2737 di3 = *(DRIVER_INFO_3A *)pDriverInfo;
2738 else {
2739 memset(&di3, 0, sizeof(di3));
2740 *(DRIVER_INFO_2A *)&di3 = *(DRIVER_INFO_2A *)pDriverInfo;
2741 }
2742
2743 if(!di3.pName || !di3.pDriverPath || !di3.pConfigFile ||
2744 !di3.pDataFile) {
2745 SetLastError(ERROR_INVALID_PARAMETER);
2746 return FALSE;
2747 }
2748 if(!di3.pDefaultDataType) di3.pDefaultDataType = "";
2749 if(!di3.pDependentFiles) di3.pDependentFiles = "\0";
2750 if(!di3.pHelpFile) di3.pHelpFile = "";
2751 if(!di3.pMonitorName) di3.pMonitorName = "";
2752
2753 hkeyDrivers = WINSPOOL_OpenDriverReg(di3.pEnvironment, FALSE);
2754
2755 if(!hkeyDrivers) {
2756 ERR("Can't create Drivers key\n");
2757 return FALSE;
2758 }
2759
2760 if(level == 2) { /* apparently can't overwrite with level2 */
2761 if(RegOpenKeyA(hkeyDrivers, di3.pName, &hkeyName) == ERROR_SUCCESS) {
2762 RegCloseKey(hkeyName);
2763 RegCloseKey(hkeyDrivers);
2764 WARN("Trying to create existing printer driver %s\n", debugstr_a(di3.pName));
2765 SetLastError(ERROR_PRINTER_DRIVER_ALREADY_INSTALLED);
2766 return FALSE;
2767 }
2768 }
2769 if(RegCreateKeyA(hkeyDrivers, di3.pName, &hkeyName) != ERROR_SUCCESS) {
2770 RegCloseKey(hkeyDrivers);
2771 ERR("Can't create Name key\n");
2772 return FALSE;
2773 }
2774 RegSetValueExA(hkeyName, "Configuration File", 0, REG_SZ, di3.pConfigFile,
2775 0);
2776 RegSetValueExA(hkeyName, "Data File", 0, REG_SZ, di3.pDataFile, 0);
2777 RegSetValueExA(hkeyName, "Driver", 0, REG_SZ, di3.pDriverPath, 0);
2778 RegSetValueExA(hkeyName, "Version", 0, REG_DWORD, (LPSTR)&di3.cVersion,
2779 sizeof(DWORD));
2780 RegSetValueExA(hkeyName, "Datatype", 0, REG_SZ, di3.pDefaultDataType, 0);
2781 RegSetValueExA(hkeyName, "Dependent Files", 0, REG_MULTI_SZ,
2782 di3.pDependentFiles, 0);
2783 RegSetValueExA(hkeyName, "Help File", 0, REG_SZ, di3.pHelpFile, 0);
2784 RegSetValueExA(hkeyName, "Monitor", 0, REG_SZ, di3.pMonitorName, 0);
2785 RegCloseKey(hkeyName);
2786 RegCloseKey(hkeyDrivers);
2787
2788 return TRUE;
2789 }
2790 /*****************************************************************************
2791 * AddPrinterDriverW [WINSPOOL.@]
2792 */
2793 BOOL WINAPI AddPrinterDriverW(LPWSTR printerName,DWORD level,
2794 LPBYTE pDriverInfo)
2795 {
2796 FIXME("(%s,%ld,%p): stub\n",debugstr_w(printerName),
2797 level,pDriverInfo);
2798 return FALSE;
2799 }
2800
2801
2802 /*****************************************************************************
2803 * PrinterProperties [WINSPOOL.@]
2804 *
2805 * Displays a dialog to set the properties of the printer.
2806 *
2807 * RETURNS
2808 * nonzero on success or zero on failure
2809 *
2810 * BUGS
2811 * implemented as stub only
2812 */
2813 BOOL WINAPI PrinterProperties(HWND hWnd, /* [in] handle to parent window */
2814 HANDLE hPrinter /* [in] handle to printer object */
2815 ){
2816 FIXME("(%p,%p): stub\n", hWnd, hPrinter);
2817 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2818 return FALSE;
2819 }
2820
2821 /*****************************************************************************
2822 * EnumJobsA [WINSPOOL.@]
2823 *
2824 */
2825 BOOL WINAPI EnumJobsA(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
2826 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
2827 LPDWORD pcReturned)
2828 {
2829 FIXME("(%p,first=%ld,no=%ld,level=%ld,job=%p,cb=%ld,%p,%p), stub!\n",
2830 hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
2831 );
2832 if(pcbNeeded) *pcbNeeded = 0;
2833 if(pcReturned) *pcReturned = 0;
2834 return FALSE;
2835 }
2836
2837
2838 /*****************************************************************************
2839 * EnumJobsW [WINSPOOL.@]
2840 *
2841 */
2842 BOOL WINAPI EnumJobsW(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
2843 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
2844 LPDWORD pcReturned)
2845 {
2846 FIXME("(%p,first=%ld,no=%ld,level=%ld,job=%p,cb=%ld,%p,%p), stub!\n",
2847 hPrinter, FirstJob, NoJobs, Level, pJob, cbBuf, pcbNeeded, pcReturned
2848 );
2849 if(pcbNeeded) *pcbNeeded = 0;
2850 if(pcReturned) *pcReturned = 0;
2851 return FALSE;
2852 }
2853
2854 /*****************************************************************************
2855 * WINSPOOL_EnumPrinterDrivers [internal]
2856 *
2857 * Delivers information about all printer drivers installed on the
2858 * localhost or a given server
2859 *
2860 * RETURNS
2861 * nonzero on success or zero on failure. If the buffer for the returned
2862 * information is too small the function will return an error
2863 *
2864 * BUGS
2865 * - only implemented for localhost, foreign hosts will return an error
2866 */
2867 static BOOL WINSPOOL_EnumPrinterDrivers(LPWSTR pName, LPWSTR pEnvironment,
2868 DWORD Level, LPBYTE pDriverInfo,
2869 DWORD cbBuf, LPDWORD pcbNeeded,
2870 LPDWORD pcReturned, BOOL unicode)
2871
2872 { HKEY hkeyDrivers;
2873 DWORD i, needed, number = 0, size = 0;
2874 WCHAR DriverNameW[255];
2875 PBYTE ptr;
2876
2877 TRACE("%s,%s,%ld,%p,%ld,%d\n",
2878 debugstr_w(pName), debugstr_w(pEnvironment),
2879 Level, pDriverInfo, cbBuf, unicode);
2880
2881 /* check for local drivers */
2882 if(pName) {
2883 ERR("remote drivers unsupported! Current remote host is %s\n",
2884 debugstr_w(pName));
2885 return FALSE;
2886 }
2887
2888 /* check input parameter */
2889 if((Level < 1) || (Level > 3)) {
2890 ERR("unsupported level %ld \n", Level);
2891 return FALSE;
2892 }
2893
2894 /* initialize return values */
2895 if(pDriverInfo)
2896 memset( pDriverInfo, 0, cbBuf);
2897 *pcbNeeded = 0;
2898 *pcReturned = 0;
2899
2900 hkeyDrivers = WINSPOOL_OpenDriverReg(pEnvironment, TRUE);
2901 if(!hkeyDrivers) {
2902 ERR("Can't open Drivers key\n");
2903 return FALSE;
2904 }
2905
2906 if(RegQueryInfoKeyA(hkeyDrivers, NULL, NULL, NULL, &number, NULL, NULL,
2907 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
2908 RegCloseKey(hkeyDrivers);
2909 ERR("Can't query Drivers key\n");
2910 return FALSE;
2911 }
2912 TRACE("Found %ld Drivers\n", number);
2913
2914 /* get size of single struct
2915 * unicode and ascii structure have the same size
2916 */
2917 switch (Level) {
2918 case 1:
2919 size = sizeof(DRIVER_INFO_1A);
2920 break;
2921 case 2:
2922 size = sizeof(DRIVER_INFO_2A);
2923 break;
2924 case 3:
2925 size = sizeof(DRIVER_INFO_3A);
2926 break;
2927 }
2928
2929 /* calculate required buffer size */
2930 *pcbNeeded = size * number;
2931
2932 for( i = 0, ptr = (pDriverInfo && (cbBuf >= size)) ? pDriverInfo : NULL ;
2933 i < number;
2934 i++, ptr = (ptr && (cbBuf >= size * i)) ? ptr + size : NULL) {
2935 if(RegEnumKeyW(hkeyDrivers, i, DriverNameW, sizeof(DriverNameW))
2936 != ERROR_SUCCESS) {
2937 ERR("Can't enum key number %ld\n", i);
2938 RegCloseKey(hkeyDrivers);
2939 return FALSE;
2940 }
2941 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverNameW,
2942 pEnvironment, Level, ptr,
2943 (cbBuf < *pcbNeeded) ? NULL : pDriverInfo + *pcbNeeded,
2944 (cbBuf < *pcbNeeded) ? 0 : cbBuf - *pcbNeeded,
2945 &needed, unicode)) {
2946 RegCloseKey(hkeyDrivers);
2947 return FALSE;
2948 }
2949 (*pcbNeeded) += needed;
2950 }
2951
2952 RegCloseKey(hkeyDrivers);
2953
2954 if(cbBuf < *pcbNeeded){
2955 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2956 return FALSE;
2957 }
2958
2959 return TRUE;
2960 }
2961
2962 /*****************************************************************************
2963 * EnumPrinterDriversW [WINSPOOL.@]
2964 *
2965 * see function EnumPrinterDrivers for RETURNS, BUGS
2966 */
2967 BOOL WINAPI EnumPrinterDriversW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
2968 LPBYTE pDriverInfo, DWORD cbBuf,
2969 LPDWORD pcbNeeded, LPDWORD pcReturned)
2970 {
2971 return WINSPOOL_EnumPrinterDrivers(pName, pEnvironment, Level, pDriverInfo,
2972 cbBuf, pcbNeeded, pcReturned, TRUE);
2973 }
2974
2975 /*****************************************************************************
2976 * EnumPrinterDriversA [WINSPOOL.@]
2977 *
2978 * see function EnumPrinterDrivers for RETURNS, BUGS
2979 */
2980 BOOL WINAPI EnumPrinterDriversA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
2981 LPBYTE pDriverInfo, DWORD cbBuf,
2982 LPDWORD pcbNeeded, LPDWORD pcReturned)
2983 { BOOL ret;
2984 UNICODE_STRING pNameW, pEnvironmentW;
2985 PWSTR pwstrNameW, pwstrEnvironmentW;
2986
2987 pwstrNameW = asciitounicode(&pNameW, pName);
2988 pwstrEnvironmentW = asciitounicode(&pEnvironmentW, pEnvironment);
2989
2990 ret = WINSPOOL_EnumPrinterDrivers(pwstrNameW, pwstrEnvironmentW,
2991 Level, pDriverInfo, cbBuf, pcbNeeded,
2992 pcReturned, FALSE);
2993 RtlFreeUnicodeString(&pNameW);
2994 RtlFreeUnicodeString(&pEnvironmentW);
2995
2996 return ret;
2997 }
2998
2999 static CHAR PortMonitor[] = "Wine Port Monitor";
3000 static CHAR PortDescription[] = "Wine Port";
3001
3002 /******************************************************************************
3003 * EnumPortsA (WINSPOOL.@)
3004 */
3005 BOOL WINAPI EnumPortsA(LPSTR name,DWORD level,LPBYTE buffer,DWORD bufsize,
3006 LPDWORD bufneeded,LPDWORD bufreturned)
3007 {
3008 CHAR portname[10];
3009 DWORD info_size, ofs, i, printer_count, serial_count, count, n, r;
3010 const LPCSTR szSerialPortKey = "Software\\Wine\\Wine\\Config\\serialports";
3011 const LPCSTR szPrinterPortKey = "Software\\Wine\\Wine\\Config\\spooler";
3012 HKEY hkey_serial, hkey_printer;
3013
3014 TRACE("(%s,%ld,%p,%ld,%p,%p)\n",
3015 name,level,buffer,bufsize,bufneeded,bufreturned);
3016
3017 switch( level )
3018 {
3019 case 1:
3020 info_size = sizeof (PORT_INFO_1A);
3021 break;
3022 case 2:
3023 info_size = sizeof (PORT_INFO_2A);
3024 break;
3025 default:
3026 SetLastError(ERROR_INVALID_LEVEL);
3027 return FALSE;
3028 }
3029
3030 /* see how many exist */
3031
3032 hkey_serial = 0;
3033 hkey_printer = 0;
3034 serial_count = 0;
3035 printer_count = 0;
3036 r = RegOpenKeyA( HKEY_LOCAL_MACHINE, szSerialPortKey, &hkey_serial);
3037 if (r == ERROR_SUCCESS)
3038 {
3039 RegQueryInfoKeyA ( hkey_serial, NULL, NULL, NULL, NULL, NULL, NULL,
3040 &serial_count, NULL, NULL, NULL, NULL);
3041 }
3042
3043 r = RegOpenKeyA( HKEY_LOCAL_MACHINE, szPrinterPortKey, &hkey_printer);
3044 if ( r == ERROR_SUCCESS )
3045 {
3046 RegQueryInfoKeyA( hkey_printer, NULL, NULL, NULL, NULL, NULL, NULL,
3047 &printer_count, NULL, NULL, NULL, NULL);
3048 }
3049 count = serial_count + printer_count;
3050
3051 /* then fill in the structure info structure once
3052 we know the offset to the first string */
3053
3054 memset( buffer, 0, bufsize );
3055 n = 0;
3056 ofs = info_size*count;
3057 for ( i=0; i<count; i++)
3058 {
3059 DWORD vallen = sizeof(portname) - 1;
3060
3061 /* get the serial port values, then the printer values */
3062 if ( i < serial_count )
3063 r = RegEnumValueA( hkey_serial, i,
3064 portname, &vallen, NULL, NULL, NULL, 0 );
3065 else
3066 r = RegEnumValueA( hkey_printer, i-serial_count,
3067 portname, &vallen, NULL, NULL, NULL, 0 );
3068
3069 if ( r )
3070 continue;
3071
3072 /* add a colon if necessary, and make it upper case */
3073 CharUpperBuffA(portname,vallen);
3074 if (strcasecmp(portname,"nul")!=0)
3075 if (vallen && (portname[vallen-1] != ':') )
3076 lstrcatA(portname,":");
3077
3078 /* add the port info structure if we can fit it */
3079 if ( info_size*(n+1) < bufsize )
3080 {
3081 if ( level == 1)
3082 {
3083 PORT_INFO_1A *info = (PORT_INFO_1A*) &buffer[info_size*n];
3084 info->pName = (LPSTR) &buffer[ofs];
3085 }
3086 else if ( level == 2)
3087 {
3088 PORT_INFO_2A *info = (PORT_INFO_2A*) &buffer[info_size*n];
3089 info->pPortName = (LPSTR) &buffer[ofs];
3090 /* FIXME: fill in more stuff here */
3091 info->pMonitorName = PortMonitor;
3092 info->pDescription = PortDescription;
3093 info->fPortType = PORT_TYPE_WRITE|PORT_TYPE_READ;
3094 }
3095
3096 /* add the name of the port if we can fit it */
3097 if ( ofs < bufsize )
3098 lstrcpynA(&buffer[ofs],portname,bufsize - ofs);
3099 }
3100
3101 ofs += lstrlenA(portname)+1;
3102 n++;
3103 }
3104
3105 RegCloseKey(hkey_serial);
3106 RegCloseKey(hkey_printer);
3107
3108 if(bufneeded)
3109 *bufneeded = ofs;
3110
3111 if(bufreturned)
3112 *bufreturned = count;
3113
3114 return TRUE;
3115 }
3116
3117 /******************************************************************************
3118 * GetDefaultPrinterA (WINSPOOL.@)
3119 */
3120 BOOL WINAPI GetDefaultPrinterA(LPSTR name, LPDWORD namesize)
3121 {
3122 char *ptr;
3123
3124 if (*namesize < 1)
3125 {
3126 SetLastError (ERROR_INSUFFICIENT_BUFFER);
3127 return FALSE;
3128 }
3129
3130 if (!GetProfileStringA ("windows", "device", "", name, *namesize))
3131 {
3132 SetLastError (ERROR_FILE_NOT_FOUND);
3133 return FALSE;
3134 }
3135
3136 if ((ptr = strchr (name, ',')) == NULL)
3137 {
3138 SetLastError (ERROR_FILE_NOT_FOUND);
3139 return FALSE;
3140 }
3141
3142 *ptr = '\0';
3143 *namesize = strlen (name) + 1;
3144 return TRUE;
3145 }
3146
3147
3148 /******************************************************************************
3149 * GetDefaultPrinterW (WINSPOOL.@)
3150 */
3151 BOOL WINAPI GetDefaultPrinterW(LPWSTR name, LPDWORD namesize)
3152 {
3153 char *buf;
3154 BOOL ret;
3155
3156 if (*namesize < 1)
3157 {
3158 SetLastError (ERROR_INSUFFICIENT_BUFFER);
3159 return FALSE;
3160 }
3161
3162 buf = HeapAlloc (GetProcessHeap (), 0, *namesize);
3163 ret = GetDefaultPrinterA (buf, namesize);
3164 if (ret)
3165 {
3166 DWORD len = MultiByteToWideChar (CP_ACP, 0, buf, -1, name, *namesize);
3167 if (!len)
3168 {
3169 SetLastError (ERROR_INSUFFICIENT_BUFFER);
3170 ret = FALSE;
3171 }
3172 else *namesize = len;
3173 }
3174
3175 HeapFree (GetProcessHeap (), 0, buf);
3176 return ret;
3177 }
3178
3179
3180 /******************************************************************************
3181 * SetPrinterDataExA (WINSPOOL.@)
3182 */
3183 DWORD WINAPI SetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
3184 LPCSTR pValueName, DWORD Type,
3185 LPBYTE pData, DWORD cbData)
3186 {
3187 HKEY hkeyPrinter, hkeySubkey;
3188 DWORD ret;
3189
3190 TRACE("(%p, %s, %s %08lx, %p, %08lx)\n", hPrinter, debugstr_a(pKeyName),
3191 debugstr_a(pValueName), Type, pData, cbData);
3192
3193 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
3194 != ERROR_SUCCESS)
3195 return ret;
3196
3197 if((ret = RegCreateKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
3198 != ERROR_SUCCESS) {
3199 ERR("Can't create subkey %s\n", debugstr_a(pKeyName));
3200 RegCloseKey(hkeyPrinter);
3201 return ret;
3202 }
3203 ret = RegSetValueExA(hkeySubkey, pValueName, 0, Type, pData, cbData);
3204 RegCloseKey(hkeySubkey);
3205 RegCloseKey(hkeyPrinter);
3206 return ret;
3207 }
3208
3209 /******************************************************************************
3210 * SetPrinterDataExW (WINSPOOL.@)
3211 */
3212 DWORD WINAPI SetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
3213 LPCWSTR pValueName, DWORD Type,
3214 LPBYTE pData, DWORD cbData)
3215 {
3216 HKEY hkeyPrinter, hkeySubkey;
3217 DWORD ret;
3218
3219 TRACE("(%p, %s, %s %08lx, %p, %08lx)\n", hPrinter, debugstr_w(pKeyName),
3220 debugstr_w(pValueName), Type, pData, cbData);
3221
3222 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
3223 != ERROR_SUCCESS)
3224 return ret;
3225
3226 if((ret = RegCreateKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
3227 != ERROR_SUCCESS) {
3228 ERR("Can't create subkey %s\n", debugstr_w(pKeyName));
3229 RegCloseKey(hkeyPrinter);
3230 return ret;
3231 }
3232 ret = RegSetValueExW(hkeySubkey, pValueName, 0, Type, pData, cbData);
3233 RegCloseKey(hkeySubkey);
3234 RegCloseKey(hkeyPrinter);
3235 return ret;
3236 }
3237
3238 /******************************************************************************
3239 * SetPrinterDataA (WINSPOOL.@)
3240 */
3241 DWORD WINAPI SetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, DWORD Type,
3242 LPBYTE pData, DWORD cbData)
3243 {
3244 return SetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, Type,
3245 pData, cbData);
3246 }
3247
3248 /******************************************************************************
3249 * SetPrinterDataW (WINSPOOL.@)
3250 */
3251 DWORD WINAPI SetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, DWORD Type,
3252 LPBYTE pData, DWORD cbData)
3253 {
3254 return SetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, Type,
3255 pData, cbData);
3256 }
3257
3258 /******************************************************************************
3259 * GetPrinterDataExA (WINSPOOL.@)
3260 */
3261 DWORD WINAPI GetPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
3262 LPCSTR pValueName, LPDWORD pType,
3263 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
3264 {
3265 HKEY hkeyPrinter, hkeySubkey;
3266 DWORD ret;
3267
3268 TRACE("(%p, %s, %s %p, %p, %08lx, %p)\n", hPrinter,
3269 debugstr_a(pKeyName), debugstr_a(pValueName), pType, pData, nSize,
3270 pcbNeeded);
3271
3272 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
3273 != ERROR_SUCCESS)
3274 return ret;
3275
3276 if((ret = RegOpenKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
3277 != ERROR_SUCCESS) {
3278 WARN("Can't open subkey %s\n", debugstr_a(pKeyName));
3279 RegCloseKey(hkeyPrinter);
3280 return ret;
3281 }
3282 *pcbNeeded = nSize;
3283 ret = RegQueryValueExA(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
3284 RegCloseKey(hkeySubkey);
3285 RegCloseKey(hkeyPrinter);
3286 return ret;
3287 }
3288
3289 /******************************************************************************
3290 * GetPrinterDataExW (WINSPOOL.@)
3291 */
3292 DWORD WINAPI GetPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
3293 LPCWSTR pValueName, LPDWORD pType,
3294 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
3295 {
3296 HKEY hkeyPrinter, hkeySubkey;
3297 DWORD ret;
3298
3299 TRACE("(%p, %s, %s %p, %p, %08lx, %p)\n", hPrinter,
3300 debugstr_w(pKeyName), debugstr_w(pValueName), pType, pData, nSize,
3301 pcbNeeded);
3302
3303 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
3304 != ERROR_SUCCESS)
3305 return ret;
3306
3307 if((ret = RegOpenKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
3308 != ERROR_SUCCESS) {
3309 WARN("Can't open subkey %s\n", debugstr_w(pKeyName));
3310 RegCloseKey(hkeyPrinter);
3311 return ret;
3312 }
3313 *pcbNeeded = nSize;
3314 ret = RegQueryValueExW(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
3315 RegCloseKey(hkeySubkey);
3316 RegCloseKey(hkeyPrinter);
3317 return ret;
3318 }
3319
3320 /******************************************************************************
3321 * GetPrinterDataA (WINSPOOL.@)
3322 */
3323 DWORD WINAPI GetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, LPDWORD pType,
3324 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
3325 {
3326 return GetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, pType,
3327 pData, nSize, pcbNeeded);
3328 }
3329
3330 /******************************************************************************
3331 * GetPrinterDataW (WINSPOOL.@)
3332 */
3333 DWORD WINAPI GetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, LPDWORD pType,
3334 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
3335 {
3336 return GetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, pType,
3337 pData, nSize, pcbNeeded);
3338 }
3339
3340 /*******************************************************************************
3341 * EnumPrinterDataExW [WINSPOOL.@]
3342 */
3343 DWORD WINAPI EnumPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
3344 LPBYTE pEnumValues, DWORD cbEnumValues,
3345 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
3346 {
3347 HKEY hkPrinter, hkSubKey;
3348 DWORD r, ret, dwIndex, cValues, cbMaxValueNameLen,
3349 cbValueNameLen, cbMaxValueLen, cbValueLen,
3350 cbBufSize, dwType;
3351 LPWSTR lpValueName;
3352 HANDLE hHeap;
3353 PBYTE lpValue;
3354 PPRINTER_ENUM_VALUESW ppev;
3355
3356 TRACE ("%p %s\n", hPrinter, debugstr_w (pKeyName));
3357
3358 if (pKeyName == NULL || *pKeyName == 0)
3359 return ERROR_INVALID_PARAMETER;
3360
3361 ret = WINSPOOL_GetOpenedPrinterRegKey (hPrinter, &hkPrinter);
3362 if (ret != ERROR_SUCCESS)
3363 {
3364 TRACE ("WINSPOOL_GetOpenedPrinterRegKey (%p) returned %li\n",
3365 hPrinter, ret);
3366 return ret;
3367 }
3368
3369 ret = RegOpenKeyExW (hkPrinter, pKeyName, 0, KEY_READ, &hkSubKey);
3370 if (ret != ERROR_SUCCESS)
3371 {
3372 r = RegCloseKey (hkPrinter);
3373 if (r != ERROR_SUCCESS)
3374 WARN ("RegCloseKey returned %li\n", r);
3375 TRACE ("RegOpenKeyExW (%p, %s) returned %li\n", hPrinter,
3376 debugstr_w (pKeyName), ret);
3377 return ret;
3378 }
3379
3380 ret = RegCloseKey (hkPrinter);
3381 if (ret != ERROR_SUCCESS)
3382 {
3383 ERR ("RegCloseKey returned %li\n", ret);
3384 r = RegCloseKey (hkSubKey);
3385 if (r != ERROR_SUCCESS)
3386 WARN ("RegCloseKey returned %li\n", r);
3387 return ret;
3388 }
3389
3390 ret = RegQueryInfoKeyW (hkSubKey, NULL, NULL, NULL, NULL, NULL, NULL,
3391 &cValues, &cbMaxValueNameLen, &cbMaxValueLen, NULL, NULL);
3392 if (ret != ERROR_SUCCESS)
3393 {
3394 r = RegCloseKey (hkSubKey);
3395 if (r != ERROR_SUCCESS)
3396 WARN ("RegCloseKey returned %li\n", r);
3397 TRACE ("RegQueryInfoKeyW (%p) returned %li\n", hkSubKey, ret);
3398 return ret;
3399 }
3400
3401 TRACE ("RegQueryInfoKeyW returned cValues = %li, cbMaxValueNameLen = %li, "
3402 "cbMaxValueLen = %li\n", cValues, cbMaxValueNameLen, cbMaxValueLen);
3403
3404 if (cValues == 0) /* empty key */
3405 {
3406 r = RegCloseKey (hkSubKey);
3407 if (r != ERROR_SUCCESS)
3408 WARN ("RegCloseKey returned %li\n", r);
3409 *pcbEnumValues = *pnEnumValues = 0;
3410 return ERROR_SUCCESS;
3411 }
3412
3413 ++cbMaxValueNameLen; /* allow for trailing '\0' */
3414
3415 hHeap = GetProcessHeap ();
3416 if (hHeap == NULL)
3417 {
3418 ERR ("GetProcessHeap failed\n");
3419 r = RegCloseKey (hkSubKey);
3420 if (r != ERROR_SUCCESS)
3421 WARN ("RegCloseKey returned %li\n", r);
3422 return ERROR_OUTOFMEMORY;
3423 }
3424
3425 lpValueName = HeapAlloc (hHeap, 0, cbMaxValueNameLen * sizeof (WCHAR));
3426 if (lpValueName == NULL)
3427 {
3428 ERR ("Failed to allocate %li bytes from process heap\n",
3429 cbMaxValueNameLen * sizeof (WCHAR));
3430 r = RegCloseKey (hkSubKey);
3431 if (r != ERROR_SUCCESS)
3432 WARN ("RegCloseKey returned %li\n", r);
3433 return ERROR_OUTOFMEMORY;
3434 }
3435
3436 lpValue = HeapAlloc (hHeap, 0, cbMaxValueLen);
3437 if (lpValue == NULL)
3438 {
3439 ERR ("Failed to allocate %li bytes from process heap\n", cbMaxValueLen);
3440 if (HeapFree (hHeap, 0, lpValueName) == 0)
3441 WARN ("HeapFree failed with code %li\n", GetLastError ());
3442 r = RegCloseKey (hkSubKey);
3443 if (r != ERROR_SUCCESS)
3444 WARN ("RegCloseKey returned %li\n", r);
3445 return ERROR_OUTOFMEMORY;
3446 }
3447
3448 TRACE ("pass 1: calculating buffer required for all names and values\n");
3449
3450 cbBufSize = cValues * sizeof (PRINTER_ENUM_VALUESW);
3451
3452 TRACE ("%li bytes required for %li headers\n", cbBufSize, cValues);
3453
3454 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
3455 {
3456 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
3457 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
3458 NULL, NULL, lpValue, &cbValueLen);
3459 if (ret != ERROR_SUCCESS)
3460 {
3461 if (HeapFree (hHeap, 0, lpValue) == 0)
3462 WARN ("HeapFree failed with code %li\n", GetLastError ());
3463 if (HeapFree (hHeap, 0, lpValueName) == 0)
3464 WARN ("HeapFree failed with code %li\n", GetLastError ());
3465 r = RegCloseKey (hkSubKey);
3466 if (r != ERROR_SUCCESS)
3467 WARN ("RegCloseKey returned %li\n", r);
3468 TRACE ("RegEnumValueW (%li) returned %li\n", dwIndex, ret);
3469 return ret;
3470 }
3471
3472 TRACE ("%s [%li]: name needs %li bytes, data needs %li bytes\n",
3473 debugstr_w (lpValueName), dwIndex,
3474 (cbValueNameLen + 1) * sizeof (WCHAR), cbValueLen);
3475
3476 cbBufSize += (cbValueNameLen + 1) * sizeof (WCHAR);
3477 cbBufSize += cbValueLen;
3478 }
3479
3480 TRACE ("%li bytes required for all %li values\n", cbBufSize, cValues);
3481
3482 *pcbEnumValues = cbBufSize;
3483 *pnEnumValues = cValues;
3484
3485 if (cbEnumValues < cbBufSize) /* buffer too small */
3486 {
3487 if (HeapFree (hHeap, 0, lpValue) == 0)
3488 WARN ("HeapFree failed with code %li\n", GetLastError ());
3489 if (HeapFree (hHeap, 0, lpValueName) == 0)
3490 WARN ("HeapFree failed with code %li\n", GetLastError ());
3491 r = RegCloseKey (hkSubKey);
3492 if (r != ERROR_SUCCESS)
3493 WARN ("RegCloseKey returned %li\n", r);
3494 TRACE ("%li byte buffer is not large enough\n", cbEnumValues);
3495 return ERROR_MORE_DATA;
3496 }
3497
3498 TRACE ("pass 2: copying all names and values to buffer\n");
3499
3500 ppev = (PPRINTER_ENUM_VALUESW) pEnumValues; /* array of structs */
3501 pEnumValues += cValues * sizeof (PRINTER_ENUM_VALUESW);
3502
3503 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
3504 {
3505 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
3506 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
3507 NULL, &dwType, lpValue, &cbValueLen);
3508 if (ret != ERROR_SUCCESS)
3509 {
3510 if (HeapFree (hHeap, 0, lpValue) == 0)
3511 WARN ("HeapFree failed with code %li\n", GetLastError ());
3512 if (HeapFree (hHeap, 0, lpValueName) == 0)
3513 WARN ("HeapFree failed with code %li\n", GetLastError ());
3514 r = RegCloseKey (hkSubKey);
3515 if (r != ERROR_SUCCESS)
3516 WARN ("RegCloseKey returned %li\n", r);
3517 TRACE ("RegEnumValueW (%li) returned %li\n", dwIndex, ret);
3518 return ret;
3519 }
3520
3521 cbValueNameLen = (cbValueNameLen + 1) * sizeof (WCHAR);
3522 memcpy (pEnumValues, lpValueName, cbValueNameLen);
3523 ppev[dwIndex].pValueName = (LPWSTR) pEnumValues;
3524 pEnumValues += cbValueNameLen;
3525
3526 /* return # of *bytes* (including trailing \0), not # of chars */
3527 ppev[dwIndex].cbValueName = cbValueNameLen;
3528
3529 ppev[dwIndex].dwType = dwType;
3530
3531 memcpy (pEnumValues, lpValue, cbValueLen);
3532 ppev[dwIndex].pData = pEnumValues;
3533 pEnumValues += cbValueLen;
3534
3535 ppev[dwIndex].cbData = cbValueLen;
3536
3537 TRACE ("%s [%li]: copied name (%li bytes) and data (%li bytes)\n",
3538 debugstr_w (lpValueName), dwIndex, cbValueNameLen, cbValueLen);
3539 }
3540
3541 if (HeapFree (hHeap, 0, lpValue) == 0)
3542 {
3543 ret = GetLastError ();
3544 ERR ("HeapFree failed with code %li\n", ret);
3545 if (HeapFree (hHeap, 0, lpValueName) == 0)
3546 WARN ("HeapFree failed with code %li\n", GetLastError ());
3547 r = RegCloseKey (hkSubKey);
3548 if (r != ERROR_SUCCESS)
3549 WARN ("RegCloseKey returned %li\n", r);
3550 return ret;
3551 }
3552
3553 if (HeapFree (hHeap, 0, lpValueName) == 0)
3554 {
3555 ret = GetLastError ();
3556 ERR ("HeapFree failed with code %li\n", ret);
3557 r = RegCloseKey (hkSubKey);
3558 if (r != ERROR_SUCCESS)
3559 WARN ("RegCloseKey returned %li\n", r);
3560 return ret;
3561 }
3562
3563 ret = RegCloseKey (hkSubKey);
3564 if (ret != ERROR_SUCCESS)
3565 {
3566 ERR ("RegCloseKey returned %li\n", ret);
3567 return ret;
3568 }
3569
3570 return ERROR_SUCCESS;
3571 }
3572
3573 /*******************************************************************************
3574 * EnumPrinterDataExA [WINSPOOL.@]
3575 *
3576 * This functions returns value names and REG_SZ, REG_EXPAND_SZ, and
3577 * REG_MULTI_SZ values as ASCII strings in Unicode-sized buffers. This is
3578 * what Windows 2000 SP1 does.
3579 *
3580 */
3581 DWORD WINAPI EnumPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
3582 LPBYTE pEnumValues, DWORD cbEnumValues,
3583 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
3584 {
3585 INT len;
3586 LPWSTR pKeyNameW;
3587 DWORD ret, dwIndex, dwBufSize;
3588 HANDLE hHeap;
3589 LPSTR pBuffer;
3590
3591 TRACE ("%p %s\n", hPrinter, pKeyName);
3592
3593 if (pKeyName == NULL || *pKeyName == 0)
3594 return ERROR_INVALID_PARAMETER;
3595
3596 len = MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, NULL, 0);
3597 if (len == 0)
3598 {
3599 ret = GetLastError ();
3600 ERR ("MultiByteToWideChar failed with code %li\n", ret);
3601 return ret;
3602 }
3603
3604 hHeap = GetProcessHeap ();
3605 if (hHeap == NULL)
3606 {
3607 ERR ("GetProcessHeap failed\n");
3608 return ERROR_OUTOFMEMORY;
3609 }
3610
3611 pKeyNameW = HeapAlloc (hHeap, 0, len * sizeof (WCHAR));
3612 if (pKeyNameW == NULL)
3613 {
3614 ERR ("Failed to allocate %li bytes from process heap\n",
3615 (LONG) len * sizeof (WCHAR));
3616 return ERROR_OUTOFMEMORY;
3617 }
3618
3619 if (MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, pKeyNameW, len) == 0)
3620 {
3621 ret = GetLastError ();
3622 ERR ("MultiByteToWideChar failed with code %li\n", ret);
3623 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
3624 WARN ("HeapFree failed with code %li\n", GetLastError ());
3625 return ret;
3626 }
3627
3628 ret = EnumPrinterDataExW (hPrinter, pKeyNameW, pEnumValues, cbEnumValues,
3629 pcbEnumValues, pnEnumValues);
3630 if (ret != ERROR_SUCCESS)
3631 {
3632 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
3633 WARN ("HeapFree failed with code %li\n", GetLastError ());
3634 TRACE ("EnumPrinterDataExW returned %li\n", ret);
3635 return ret;
3636 }
3637
3638 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
3639 {
3640 ret = GetLastError ();
3641 ERR ("HeapFree failed with code %li\n", ret);
3642 return ret;
3643 }
3644
3645 if (*pnEnumValues == 0) /* empty key */
3646 return ERROR_SUCCESS;
3647
3648 dwBufSize = 0;
3649 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
3650 {
3651 PPRINTER_ENUM_VALUESW ppev =
3652 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
3653
3654 if (dwBufSize < ppev->cbValueName)
3655 dwBufSize = ppev->cbValueName;
3656
3657 if (dwBufSize < ppev->cbData && (ppev->dwType == REG_SZ ||
3658 ppev->dwType == REG_EXPAND_SZ || ppev->dwType == REG_MULTI_SZ))
3659 dwBufSize = ppev->cbData;
3660 }
3661
3662 TRACE ("Largest Unicode name or value is %li bytes\n", dwBufSize);
3663
3664 pBuffer = HeapAlloc (hHeap, 0, dwBufSize);
3665 if (pBuffer == NULL)
3666 {
3667 ERR ("Failed to allocate %li bytes from process heap\n", dwBufSize);
3668 return ERROR_OUTOFMEMORY;
3669 }
3670
3671 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
3672 {
3673 PPRINTER_ENUM_VALUESW ppev =
3674 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
3675
3676 len = WideCharToMultiByte (CP_ACP, 0, ppev->pValueName,
3677 ppev->cbValueName / sizeof (WCHAR), pBuffer, dwBufSize, NULL,
3678 NULL);
3679 if (len == 0)
3680 {
3681 ret = GetLastError ();
3682 ERR ("WideCharToMultiByte failed with code %li\n", ret);
3683 if (HeapFree (hHeap, 0, pBuffer) == 0)
3684 WARN ("HeapFree failed with code %li\n", GetLastError ());
3685 return ret;
3686 }
3687
3688 memcpy (ppev->pValueName, pBuffer, len);
3689
3690 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
3691
3692 if (ppev->dwType != REG_SZ && ppev->dwType != REG_EXPAND_SZ &&
3693 ppev->dwType != REG_MULTI_SZ)
3694 continue;
3695
3696 len = WideCharToMultiByte (CP_ACP, 0, (LPWSTR) ppev->pData,
3697 ppev->cbData / sizeof (WCHAR), pBuffer, dwBufSize, NULL, NULL);
3698 if (len == 0)
3699 {
3700 ret = GetLastError ();
3701 ERR ("WideCharToMultiByte failed with code %li\n", ret);
3702 if (HeapFree (hHeap, 0, pBuffer) == 0)
3703 WARN ("HeapFree failed with code %li\n", GetLastError ());
3704 return ret;
3705 }
3706
3707 memcpy (ppev->pData, pBuffer, len);
3708
3709 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
3710 TRACE (" (only first string of REG_MULTI_SZ printed)\n");
3711 }
3712
3713 if (HeapFree (hHeap, 0, pBuffer) == 0)
3714 {
3715 ret = GetLastError ();
3716 ERR ("HeapFree failed with code %li\n", ret);
3717 return ret;
3718 }
3719
3720 return ERROR_SUCCESS;
3721 }
3722
3723 /******************************************************************************
3724 * AddPortA (WINSPOOL.@)
3725 */
3726 BOOL WINAPI AddPortA(LPSTR pName ,HWND hWnd, LPSTR pMonitorName)
3727 {
3728 FIXME("(%s, %p, %s\n), stub!\n",pName,hWnd,pMonitorName);
3729 return FALSE;
3730 }
3731
3732 /******************************************************************************
3733 * AddPrinterDriverExW (WINSPOOL.@)
3734 */
3735 BOOL WINAPI AddPrinterDriverExW( LPWSTR pName, DWORD Level,
3736 LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
3737 {
3738 FIXME("%s %ld %p %ld\n", debugstr_w(pName),
3739 Level, pDriverInfo, dwFileCopyFlags);
3740 SetLastError(ERROR_PRINTER_DRIVER_BLOCKED);
3741 return FALSE;
3742 }
3743
3744 /******************************************************************************
3745 * AddPrinterDriverExA (WINSPOOL.@)
3746 */
3747 BOOL WINAPI AddPrinterDriverExA( LPSTR pName, DWORD Level,
3748 LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
3749 {
3750 FIXME("%s %ld %p %ld\n", debugstr_a(pName),
3751 Level, pDriverInfo, dwFileCopyFlags);
3752 SetLastError(ERROR_PRINTER_DRIVER_BLOCKED);
3753 return FALSE;
3754 }
3755
3756 /******************************************************************************
3757 * DeletePrinterDriverExW (WINSPOOL.@)
3758 */
3759 BOOL WINAPI DeletePrinterDriverExW( LPWSTR pName, LPWSTR pEnvironment,
3760 LPWSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
3761 {
3762 FIXME("%s %s %s %lx %lx\n", debugstr_w(pName), debugstr_w(pEnvironment),
3763 debugstr_w(pDriverName), dwDeleteFlag, dwVersionFlag);
3764 return TRUE;
3765 }
3766
3767 /******************************************************************************
3768 * DeletePrinterDriverExA (WINSPOOL.@)
3769 */
3770 BOOL WINAPI DeletePrinterDriverExA( LPSTR pName, LPSTR pEnvironment,
3771 LPSTR pDriverName, DWORD dwDeleteFlag, DWORD dwVersionFlag)
3772 {
3773 FIXME("%s %s %s %lx %lx\n", debugstr_a(pName), debugstr_a(pEnvironment),
3774 debugstr_a(pDriverName), dwDeleteFlag, dwVersionFlag);
3775 return TRUE;
3776 }
3777
3778 /******************************************************************************
3779 * DeletePrinterDataExW (WINSPOOL.@)
3780 */
3781 DWORD WINAPI DeletePrinterDataExW( HANDLE hPrinter, LPCWSTR pKeyName,
3782 LPCWSTR pValueName)
3783 {
3784 FIXME("%p %s %s\n", hPrinter,
3785 debugstr_w(pKeyName), debugstr_w(pValueName));
3786 return ERROR_INVALID_PARAMETER;
3787 }
3788
3789 /******************************************************************************
3790 * DeletePrinterDataExA (WINSPOOL.@)
3791 */
3792 DWORD WINAPI DeletePrinterDataExA( HANDLE hPrinter, LPCSTR pKeyName,
3793 LPCSTR pValueName)
3794 {
3795 FIXME("%p %s %s\n", hPrinter,
3796 debugstr_a(pKeyName), debugstr_a(pValueName));
3797 return ERROR_INVALID_PARAMETER;
3798 }
3799
3800 /******************************************************************************
3801 * XcvDataW (WINSPOOL.@)
3802 *
3803 * Notes:
3804 * There doesn't seem to be an A version...
3805 */
3806 BOOL WINAPI XcvDataW( HANDLE hXcv, LPCWSTR pszDataName, PBYTE pInputData,
3807 DWORD cbInputData, PBYTE pOutputData, DWORD cbOutputData,
3808 PDWORD pcbOutputNeeded, PDWORD pdwStatus)
3809 {
3810 FIXME("%p %s %p %ld %p %ld %p %p\n", hXcv, debugstr_w(pszDataName),
3811 pInputData, cbInputData, pOutputData,
3812 cbOutputData, pcbOutputNeeded, pdwStatus);
3813 return FALSE;
3814 }
Windows API implementation