?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Documentation ordinal fixes.
[wine/wine64.git] / dlls / winspool / info.c
blob387170ed133c1f575d38fc0f8bd8aa28e891d009
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
11 #include "config.h"
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <ctype.h>
17 #include <stddef.h>
18 #ifdef HAVE_CUPS
19 # include <cups/cups.h>
20 #endif
21 #include "winspool.h"
22 #include "winbase.h"
23 #include "winerror.h"
24 #include "winreg.h"
25 #include "wine/windef16.h"
26 #include "wine/unicode.h"
27 #include "debugtools.h"
28 #include "heap.h"
29 #include "winnls.h"
30
31 DEFAULT_DEBUG_CHANNEL(winspool);
32
33 static LPWSTR *printer_array;
34 static int nb_printers;
35
36 static DWORD WINAPI (*GDI_CallDeviceCapabilities16)( LPCSTR lpszDevice, LPCSTR lpszPort,
37 WORD fwCapability, LPSTR lpszOutput,
38 LPDEVMODEA lpdm );
39 static INT WINAPI (*GDI_CallExtDeviceMode16)( HWND hwnd, LPDEVMODEA lpdmOutput,
40 LPSTR lpszDevice, LPSTR lpszPort,
41 LPDEVMODEA lpdmInput, LPSTR lpszProfile,
42 DWORD fwMode );
43
44 static char Printers[] =
45 "System\\CurrentControlSet\\control\\Print\\Printers\\";
46 static char Drivers[] =
47 "System\\CurrentControlSet\\control\\Print\\Environments\\%s\\Drivers\\";
48
49 static WCHAR DefaultEnvironmentW[] = {'W','i','n','e',0};
50
51 static WCHAR Configuration_FileW[] = {'C','o','n','f','i','g','u','r','a','t',
52 'i','o','n',' ','F','i','l','e',0};
53 static WCHAR DatatypeW[] = {'D','a','t','a','t','y','p','e',0};
54 static WCHAR Data_FileW[] = {'D','a','t','a',' ','F','i','l','e',0};
55 static WCHAR Default_DevModeW[] = {'D','e','f','a','u','l','t',' ','D','e','v',
56 'M','o','d','e',0};
57 static WCHAR Dependent_FilesW[] = {'D','e','p','e','n','d','e','n','t',' ','F',
58 'i','l','e','s',0};
59 static WCHAR DescriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
60 static WCHAR DriverW[] = {'D','r','i','v','e','r',0};
61 static WCHAR Help_FileW[] = {'H','e','l','p',' ','F','i','l','e',0};
62 static WCHAR LocationW[] = {'L','o','c','a','t','i','o','n',0};
63 static WCHAR MonitorW[] = {'M','o','n','i','t','o','r',0};
64 static WCHAR NameW[] = {'N','a','m','e',0};
65 static WCHAR ParametersW[] = {'P','a','r','a','m','e','t','e','r','s',0};
66 static WCHAR PortW[] = {'P','o','r','t',0};
67 static WCHAR Print_ProcessorW[] = {'P','r','i','n','t',' ','P','r','o','c','e',
68 's','s','o','r',0};
69 static WCHAR Printer_DriverW[] = {'P','r','i','n','t','e','r',' ','D','r','i',
70 'v','e','r',0};
71 static WCHAR PrinterDriverDataW[] = {'P','r','i','n','t','e','r','D','r','i',
72 'v','e','r','D','a','t','a',0};
73 static WCHAR Separator_FileW[] = {'S','e','p','a','r','a','t','o','r',' ','F',
74 'i','l','e',0};
75 static WCHAR Share_NameW[] = {'S','h','a','r','e',' ','N','a','m','e',0};
76 static WCHAR WinPrintW[] = {'W','i','n','P','r','i','n','t',0};
77
78 static HKEY WINSPOOL_OpenDriverReg( LPVOID pEnvironment, BOOL unicode);
79 static BOOL WINSPOOL_GetPrinterDriver(HANDLE hPrinter, LPWSTR pEnvironment,
80 DWORD Level, LPBYTE pDriverInfo,
81 DWORD cbBuf, LPDWORD pcbNeeded,
82 BOOL unicode);
83 static void
84 WINSPOOL_SetDefaultPrinter(const char *devname, const char *name,BOOL force) {
85 char qbuf[200];
86
87 /* If forcing, or no profile string entry for device yet, set the entry
88 *
89 * The always change entry if not WINEPS yet is discussable.
90 */
91 if (force ||
92 !GetProfileStringA("windows","device","*",qbuf,sizeof(qbuf)) ||
93 !strcmp(qbuf,"*") ||
94 !strstr(qbuf,"WINEPS")
95 ) {
96 char *buf = HeapAlloc(GetProcessHeap(),0,strlen(name)+strlen(devname)+strlen(",WINEPS,LPR:")+1);
97
98 sprintf(buf,"%s,WINEPS,LPR:%s",devname,name);
99 WriteProfileStringA("windows","device",buf);
100 HeapFree(GetProcessHeap(),0,buf);
101 }
102 }
103
104 #ifdef HAVE_CUPS
105 BOOL
106 CUPS_LoadPrinters(void) {
107 char **printers;
108 int i,nrofdests,hadprinter = FALSE;
109 PRINTER_INFO_2A pinfo2a;
110 const char* def = cupsGetDefault();
111
112 nrofdests = cupsGetPrinters(&printers);
113
114 for (i=0;i<nrofdests;i++) {
115 const char *ppd = cupsGetPPD(printers[i]);
116 char *port,*devline;
117
118 if (!ppd) {
119 WARN("No ppd file for %s.\n",printers[i]);
120 continue;
121 }
122 unlink(ppd);
123
124 hadprinter = TRUE;
125
126 if (!strcmp(def,printers[i]))
127 WINSPOOL_SetDefaultPrinter(printers[i],printers[i],FALSE);
128 memset(&pinfo2a,0,sizeof(pinfo2a));
129 pinfo2a.pPrinterName = printers[i];
130 pinfo2a.pDatatype = "RAW";
131 pinfo2a.pPrintProcessor = "WinPrint";
132 pinfo2a.pDriverName = "PS Driver";
133 pinfo2a.pComment = "WINEPS Printer using CUPS";
134 pinfo2a.pLocation = "<physical location of printer>";
135 port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(printers[i])+1);
136 sprintf(port,"LPR:%s",printers[i]);
137 pinfo2a.pPortName = port;
138 pinfo2a.pParameters = "<parameters?>";
139 pinfo2a.pShareName = "<share name?>";
140 pinfo2a.pSepFile = "<sep file?>";
141
142 devline=HeapAlloc(GetProcessHeap(),0,strlen("WINEPS,")+strlen(port)+1);
143 sprintf(devline,"WINEPS,%s",port);
144 WriteProfileStringA("devices",printers[i],devline);
145 HeapFree(GetProcessHeap(),0,devline);
146
147 if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
148 if (GetLastError()!=ERROR_PRINTER_ALREADY_EXISTS)
149 ERR("%s not added by AddPrinterA (%ld)\n",printers[i],GetLastError());
150 }
151 HeapFree(GetProcessHeap(),0,port);
152 }
153 return hadprinter;
154 }
155 #endif
156
157 static BOOL
158 PRINTCAP_ParseEntry(char *pent,BOOL isfirst) {
159 PRINTER_INFO_2A pinfo2a;
160 char *s,*name,*prettyname,*devname;
161 BOOL isps = FALSE;
162 char *port,*devline;
163
164 s = strchr(pent,':');
165 if (!s) return FALSE;
166 *s='\0';
167 name = pent;
168 pent = s+1;
169 TRACE("%s\n",name);
170
171 /* Determine whether this is a postscript printer. */
172
173 /* 1. Check if name or aliases contain trigger phrases like 'ps' */
174 if (strstr(name,"ps") ||
175 strstr(name,"pd") || /* postscript double page */
176 strstr(name,"postscript") ||
177 strstr(name,"PostScript")
178 ) {
179 TRACE("%s has 'ps' style name, assuming postscript.\n",name);
180 isps = TRUE;
181 }
182 /* 2. Check if this is a remote printer. These usually are postscript
183 * capable
184 */
185 if (strstr(pent,":rm")) {
186 isps = TRUE;
187 TRACE("%s is remote, assuming postscript.\n",name);
188 }
189 /* 3. Check if we have an input filter program. If we have one, it
190 * most likely is one capable of converting postscript.
191 * (Could probably check for occurence of 'gs' or 'ghostscript'
192 * in the if file itself.)
193 */
194 if (strstr(pent,":if=/")) {
195 isps = TRUE;
196 TRACE("%s has inputfilter program, assuming postscript.\n",name);
197 }
198
199 /* If it is not a postscript printer, we cannot use it. */
200 if (!isps)
201 return FALSE;
202
203 prettyname = name;
204 /* Get longest name, usually the one at the right for later display. */
205 while ((s=strchr(prettyname,'|'))) prettyname = s+1;
206 s=strchr(name,'|');if (s) *s='\0';
207
208 /* prettyname must fit into the dmDeviceName member of DEVMODE struct,
209 * if it is too long, we use it as comment below. */
210 devname = prettyname;
211 if (strlen(devname)>=CCHDEVICENAME-1)
212 devname = name;
213 if (strlen(devname)>=CCHDEVICENAME-1)
214 return FALSE;
215
216 if (isfirst) /* set first entry as default */
217 WINSPOOL_SetDefaultPrinter(devname,name,FALSE);
218
219 memset(&pinfo2a,0,sizeof(pinfo2a));
220 pinfo2a.pPrinterName = devname;
221 pinfo2a.pDatatype = "RAW";
222 pinfo2a.pPrintProcessor = "WinPrint";
223 pinfo2a.pDriverName = "PS Driver";
224 pinfo2a.pComment = "WINEPS Printer using LPR";
225 pinfo2a.pLocation = prettyname;
226 port = HeapAlloc(GetProcessHeap(),0,strlen("LPR:")+strlen(name)+1);
227 sprintf(port,"LPR:%s",name);
228 pinfo2a.pPortName = port;
229 pinfo2a.pParameters = "<parameters?>";
230 pinfo2a.pShareName = "<share name?>";
231 pinfo2a.pSepFile = "<sep file?>";
232
233 devline=HeapAlloc(GetProcessHeap(),0,strlen("WINEPS,")+strlen(port)+1);
234 sprintf(devline,"WINEPS,%s",port);
235 WriteProfileStringA("devices",devname,devline);
236 HeapFree(GetProcessHeap(),0,devline);
237
238 if (!AddPrinterA(NULL,2,(LPBYTE)&pinfo2a)) {
239 if (GetLastError()!=ERROR_PRINTER_ALREADY_EXISTS)
240 ERR("%s not added by AddPrinterA (%ld)\n",name,GetLastError());
241 }
242 HeapFree(GetProcessHeap(),0,port);
243 return TRUE;
244 }
245
246 static BOOL
247 PRINTCAP_LoadPrinters(void) {
248 BOOL hadprinter = FALSE, isfirst = TRUE;
249 char buf[200];
250 FILE *f;
251
252 f = fopen("/etc/printcap","r");
253 if (!f)
254 return FALSE;
255
256 while (fgets(buf,sizeof(buf),f)) {
257 char *pent = NULL;
258 do {
259 char *s;
260 s=strchr(buf,'\n'); if (s) *s='\0';
261 if ((buf[0]=='#') || (buf[0]=='\0'))
262 continue;
263
264 if (pent) {
265 pent=HeapReAlloc(GetProcessHeap(),0,pent,strlen(pent)+strlen(buf)+2);
266 strcat(pent,buf);
267 } else {
268 pent=HeapAlloc(GetProcessHeap(),0,strlen(buf)+1);
269 strcpy(pent,buf);
270 }
271
272 if (strlen(pent) && (pent[strlen(pent)-1] == '\\'))
273 pent[strlen(pent)-1] = '\0';
274 else
275 break;
276 } while (fgets(buf,sizeof(buf),f));
277 if (pent)
278 hadprinter |= PRINTCAP_ParseEntry(pent,isfirst);
279 isfirst = FALSE;
280 if (pent) HeapFree(GetProcessHeap(),0,pent);
281 pent = NULL;
282 if (feof(f)) break;
283 }
284 fclose(f);
285 return hadprinter;
286 }
287
288 void
289 WINSPOOL_LoadSystemPrinters() {
290 HKEY hkPPD;
291 DRIVER_INFO_3A di3a;
292 di3a.cVersion = 0x400;
293 di3a.pName = "PS Driver";
294 di3a.pEnvironment = NULL; /* NULL means auto */
295 di3a.pDriverPath = "wineps.drv";
296 di3a.pDataFile = "<datafile?>";
297 di3a.pConfigFile = "wineps.drv";
298 di3a.pHelpFile = "<helpfile?>";
299 di3a.pDependentFiles = "<dependend files?>";
300 di3a.pMonitorName = "<monitor name?>";
301 di3a.pDefaultDataType = "RAW";
302
303 if (!AddPrinterDriverA(NULL,3,(LPBYTE)&di3a)) {
304 ERR("Failed adding PS Driver (%ld)\n",GetLastError());
305 return;
306 }
307 #ifdef HAVE_CUPS
308 /* If we have any CUPS based printers, skip looking for printcap printers */
309 if (CUPS_LoadPrinters())
310 return;
311 #endif
312
313 /* Check for [ppd] section in config file before parsing /etc/printcap */
314
315 if (RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\ppd",
316 &hkPPD) == ERROR_SUCCESS)
317 {
318 RegCloseKey(hkPPD);
319 PRINTCAP_LoadPrinters();
320 }
321 }
322
323
324 /******************************************************************
325 * WINSPOOL_GetOpenedPrinterEntry
326 * Get the first place empty in the opened printer table
327 */
328 static HANDLE WINSPOOL_GetOpenedPrinterEntry( LPCWSTR name )
329 {
330 int i;
331
332 for (i = 0; i < nb_printers; i++) if (!printer_array[i]) break;
333
334 if (i >= nb_printers)
335 {
336 LPWSTR *new_array = HeapReAlloc( GetProcessHeap(), 0, printer_array,
337 (nb_printers + 16) * sizeof(*new_array) );
338 if (!new_array) return 0;
339 printer_array = new_array;
340 nb_printers += 16;
341 }
342
343 if ((printer_array[i] = HeapAlloc( GetProcessHeap(), 0, (strlenW(name)+1)*sizeof(WCHAR) )))
344 {
345 strcpyW( printer_array[i], name );
346 return (HANDLE)(i + 1);
347 }
348 return 0;
349 }
350
351 /******************************************************************
352 * WINSPOOL_GetOpenedPrinter
353 * Get the pointer to the opened printer referred by the handle
354 */
355 static LPCWSTR WINSPOOL_GetOpenedPrinter(HANDLE printerHandle)
356 {
357 int idx = (int)printerHandle;
358 if ((idx <= 0) || (idx > nb_printers))
359 {
360 SetLastError(ERROR_INVALID_HANDLE);
361 return NULL;
362 }
363 return printer_array[idx - 1];
364 }
365
366 /******************************************************************
367 * WINSPOOL_GetOpenedPrinterRegKey
368 *
369 */
370 static DWORD WINSPOOL_GetOpenedPrinterRegKey(HANDLE hPrinter, HKEY *phkey)
371 {
372 LPCWSTR name = WINSPOOL_GetOpenedPrinter(hPrinter);
373 DWORD ret;
374 HKEY hkeyPrinters;
375
376 if(!name) return ERROR_INVALID_HANDLE;
377
378 if((ret = RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters)) !=
379 ERROR_SUCCESS)
380 return ret;
381
382 if(RegOpenKeyW(hkeyPrinters, name, phkey) != ERROR_SUCCESS)
383 {
384 ERR("Can't find opened printer %s in registry\n",
385 debugstr_w(name));
386 RegCloseKey(hkeyPrinters);
387 return ERROR_INVALID_PRINTER_NAME; /* ? */
388 }
389 RegCloseKey(hkeyPrinters);
390 return ERROR_SUCCESS;
391 }
392
393 /***********************************************************
394 * DEVMODEcpyAtoW
395 */
396 static LPDEVMODEW DEVMODEcpyAtoW(DEVMODEW *dmW, const DEVMODEA *dmA)
397 {
398 BOOL Formname;
399 ptrdiff_t off_formname = (char *)dmA->dmFormName - (char *)dmA;
400 DWORD size;
401
402 Formname = (dmA->dmSize > off_formname);
403 size = dmA->dmSize + CCHDEVICENAME + (Formname ? CCHFORMNAME : 0);
404 MultiByteToWideChar(CP_ACP, 0, dmA->dmDeviceName, -1, dmW->dmDeviceName,
405 CCHDEVICENAME);
406 if(!Formname) {
407 memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
408 dmA->dmSize - CCHDEVICENAME);
409 } else {
410 memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
411 off_formname - CCHDEVICENAME);
412 MultiByteToWideChar(CP_ACP, 0, dmA->dmFormName, -1, dmW->dmFormName,
413 CCHFORMNAME);
414 memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA->dmSize -
415 (off_formname + CCHFORMNAME));
416 }
417 dmW->dmSize = size;
418 memcpy((char *)dmW + dmW->dmSize, (char *)dmA + dmA->dmSize,
419 dmA->dmDriverExtra);
420 return dmW;
421 }
422
423 /***********************************************************
424 * DEVMODEdupAtoW
425 * Creates a unicode copy of supplied devmode on heap
426 */
427 static LPDEVMODEW DEVMODEdupAtoW(HANDLE heap, const DEVMODEA *dmA)
428 {
429 LPDEVMODEW dmW;
430 DWORD size;
431 BOOL Formname;
432 ptrdiff_t off_formname;
433
434 TRACE("\n");
435 if(!dmA) return NULL;
436
437 off_formname = (char *)dmA->dmFormName - (char *)dmA;
438 Formname = (dmA->dmSize > off_formname);
439 size = dmA->dmSize + CCHDEVICENAME + (Formname ? CCHFORMNAME : 0);
440 dmW = HeapAlloc(heap, HEAP_ZERO_MEMORY, size + dmA->dmDriverExtra);
441 return DEVMODEcpyAtoW(dmW, dmA);
442 }
443
444 /***********************************************************
445 * DEVMODEdupWtoA
446 * Creates an ascii copy of supplied devmode on heap
447 */
448 static LPDEVMODEA DEVMODEdupWtoA(HANDLE heap, const DEVMODEW *dmW)
449 {
450 LPDEVMODEA dmA;
451 DWORD size;
452 BOOL Formname;
453 ptrdiff_t off_formname = (char *)dmW->dmFormName - (char *)dmW;
454
455 if(!dmW) return NULL;
456 Formname = (dmW->dmSize > off_formname);
457 size = dmW->dmSize - CCHDEVICENAME - (Formname ? CCHFORMNAME : 0);
458 dmA = HeapAlloc(heap, HEAP_ZERO_MEMORY, size + dmW->dmDriverExtra);
459 WideCharToMultiByte(CP_ACP, 0, dmW->dmDeviceName, -1, dmA->dmDeviceName,
460 CCHDEVICENAME, NULL, NULL);
461 if(!Formname) {
462 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
463 dmW->dmSize - CCHDEVICENAME * sizeof(WCHAR));
464 } else {
465 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
466 off_formname - CCHDEVICENAME * sizeof(WCHAR));
467 WideCharToMultiByte(CP_ACP, 0, dmW->dmFormName, -1, dmA->dmFormName,
468 CCHFORMNAME, NULL, NULL);
469 memcpy(&dmA->dmLogPixels, &dmW->dmLogPixels, dmW->dmSize -
470 (off_formname + CCHFORMNAME * sizeof(WCHAR)));
471 }
472 dmA->dmSize = size;
473 memcpy((char *)dmA + dmA->dmSize, (char *)dmW + dmW->dmSize,
474 dmW->dmDriverExtra);
475 return dmA;
476 }
477
478 /***********************************************************
479 * PRINTER_INFO_2AtoW
480 * Creates a unicode copy of PRINTER_INFO_2A on heap
481 */
482 static LPPRINTER_INFO_2W PRINTER_INFO_2AtoW(HANDLE heap, LPPRINTER_INFO_2A piA)
483 {
484 LPPRINTER_INFO_2W piW;
485 if(!piA) return NULL;
486 piW = HeapAlloc(heap, 0, sizeof(*piW));
487 memcpy(piW, piA, sizeof(*piW)); /* copy everything first */
488 piW->pServerName = HEAP_strdupAtoW(heap, 0, piA->pServerName);
489 piW->pPrinterName = HEAP_strdupAtoW(heap, 0, piA->pPrinterName);
490 piW->pShareName = HEAP_strdupAtoW(heap, 0, piA->pShareName);
491 piW->pPortName = HEAP_strdupAtoW(heap, 0, piA->pPortName);
492 piW->pDriverName = HEAP_strdupAtoW(heap, 0, piA->pDriverName);
493 piW->pComment = HEAP_strdupAtoW(heap, 0, piA->pComment);
494 piW->pLocation = HEAP_strdupAtoW(heap, 0, piA->pLocation);
495 piW->pDevMode = DEVMODEdupAtoW(heap, piA->pDevMode);
496 piW->pSepFile = HEAP_strdupAtoW(heap, 0, piA->pSepFile);
497 piW->pPrintProcessor = HEAP_strdupAtoW(heap, 0, piA->pPrintProcessor);
498 piW->pDatatype = HEAP_strdupAtoW(heap, 0, piA->pDatatype);
499 piW->pParameters = HEAP_strdupAtoW(heap, 0, piA->pParameters);
500 return piW;
501 }
502
503 /***********************************************************
504 * FREE_PRINTER_INFO_2W
505 * Free PRINTER_INFO_2W and all strings
506 */
507 static void FREE_PRINTER_INFO_2W(HANDLE heap, LPPRINTER_INFO_2W piW)
508 {
509 if(!piW) return;
510
511 HeapFree(heap,0,piW->pServerName);
512 HeapFree(heap,0,piW->pPrinterName);
513 HeapFree(heap,0,piW->pShareName);
514 HeapFree(heap,0,piW->pPortName);
515 HeapFree(heap,0,piW->pDriverName);
516 HeapFree(heap,0,piW->pComment);
517 HeapFree(heap,0,piW->pLocation);
518 HeapFree(heap,0,piW->pDevMode);
519 HeapFree(heap,0,piW->pSepFile);
520 HeapFree(heap,0,piW->pPrintProcessor);
521 HeapFree(heap,0,piW->pDatatype);
522 HeapFree(heap,0,piW->pParameters);
523 HeapFree(heap,0,piW);
524 return;
525 }
526
527 /******************************************************************
528 * DeviceCapabilitiesA [WINSPOOL.150 & WINSPOOL.151]
529 *
530 */
531 INT WINAPI DeviceCapabilitiesA(LPCSTR pDevice,LPCSTR pPort, WORD cap,
532 LPSTR pOutput, LPDEVMODEA lpdm)
533 {
534 INT ret;
535
536 if (!GDI_CallDeviceCapabilities16)
537 {
538 GDI_CallDeviceCapabilities16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
539 (LPCSTR)104 );
540 if (!GDI_CallDeviceCapabilities16) return -1;
541 }
542 ret = GDI_CallDeviceCapabilities16(pDevice, pPort, cap, pOutput, lpdm);
543
544 /* If DC_PAPERSIZE map POINT16s to POINTs */
545 if(ret != -1 && cap == DC_PAPERSIZE && pOutput) {
546 POINT16 *tmp = HeapAlloc( GetProcessHeap(), 0, ret * sizeof(POINT16) );
547 POINT *pt = (POINT *)pOutput;
548 INT i;
549 memcpy(tmp, pOutput, ret * sizeof(POINT16));
550 for(i = 0; i < ret; i++, pt++)
551 {
552 pt->x = tmp[i].x;
553 pt->y = tmp[i].y;
554 }
555 HeapFree( GetProcessHeap(), 0, tmp );
556 }
557 return ret;
558 }
559
560
561 /*****************************************************************************
562 * DeviceCapabilitiesW [WINSPOOL.@]
563 *
564 * Call DeviceCapabilitiesA since we later call 16bit stuff anyway
565 *
566 */
567 INT WINAPI DeviceCapabilitiesW(LPCWSTR pDevice, LPCWSTR pPort,
568 WORD fwCapability, LPWSTR pOutput,
569 const DEVMODEW *pDevMode)
570 {
571 LPDEVMODEA dmA = DEVMODEdupWtoA(GetProcessHeap(), pDevMode);
572 LPSTR pDeviceA = HEAP_strdupWtoA(GetProcessHeap(),0,pDevice);
573 LPSTR pPortA = HEAP_strdupWtoA(GetProcessHeap(),0,pPort);
574 INT ret;
575
576 if(pOutput && (fwCapability == DC_BINNAMES ||
577 fwCapability == DC_FILEDEPENDENCIES ||
578 fwCapability == DC_PAPERNAMES)) {
579 /* These need A -> W translation */
580 INT size = 0, i;
581 LPSTR pOutputA;
582 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, NULL,
583 dmA);
584 if(ret == -1)
585 return ret;
586 switch(fwCapability) {
587 case DC_BINNAMES:
588 size = 24;
589 break;
590 case DC_PAPERNAMES:
591 case DC_FILEDEPENDENCIES:
592 size = 64;
593 break;
594 }
595 pOutputA = HeapAlloc(GetProcessHeap(), 0, size * ret);
596 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability, pOutputA,
597 dmA);
598 for(i = 0; i < ret; i++)
599 MultiByteToWideChar(CP_ACP, 0, pOutputA + (i * size), -1,
600 pOutput + (i * size), size);
601 HeapFree(GetProcessHeap(), 0, pOutputA);
602 } else {
603 ret = DeviceCapabilitiesA(pDeviceA, pPortA, fwCapability,
604 (LPSTR)pOutput, dmA);
605 }
606 HeapFree(GetProcessHeap(),0,pPortA);
607 HeapFree(GetProcessHeap(),0,pDeviceA);
608 HeapFree(GetProcessHeap(),0,dmA);
609 return ret;
610 }
611
612 /******************************************************************
613 * DocumentPropertiesA [WINSPOOL.@]
614 *
615 */
616 LONG WINAPI DocumentPropertiesA(HWND hWnd,HANDLE hPrinter,
617 LPSTR pDeviceName, LPDEVMODEA pDevModeOutput,
618 LPDEVMODEA pDevModeInput,DWORD fMode )
619 {
620 LPSTR lpName = pDeviceName;
621 LONG ret;
622
623 TRACE("(%d,%d,%s,%p,%p,%ld)\n",
624 hWnd,hPrinter,pDeviceName,pDevModeOutput,pDevModeInput,fMode
625 );
626
627 if(!pDeviceName) {
628 LPCWSTR lpNameW = WINSPOOL_GetOpenedPrinter(hPrinter);
629 if(!lpNameW) {
630 ERR("no name from hPrinter?\n");
631 return -1;
632 }
633 lpName = HEAP_strdupWtoA(GetProcessHeap(),0,lpNameW);
634 }
635
636 if (!GDI_CallExtDeviceMode16)
637 {
638 GDI_CallExtDeviceMode16 = (void*)GetProcAddress( GetModuleHandleA("gdi32"),
639 (LPCSTR)102 );
640 if (!GDI_CallExtDeviceMode16) {
641 ERR("No CallExtDeviceMode16?\n");
642 return -1;
643 }
644 }
645 ret = GDI_CallExtDeviceMode16(hWnd, pDevModeOutput, lpName, "LPT1:",
646 pDevModeInput, NULL, fMode);
647
648 if(!pDeviceName)
649 HeapFree(GetProcessHeap(),0,lpName);
650 return ret;
651 }
652
653
654 /*****************************************************************************
655 * DocumentPropertiesW (WINSPOOL.@)
656 */
657 LONG WINAPI DocumentPropertiesW(HWND hWnd, HANDLE hPrinter,
658 LPWSTR pDeviceName,
659 LPDEVMODEW pDevModeOutput,
660 LPDEVMODEW pDevModeInput, DWORD fMode)
661 {
662
663 LPSTR pDeviceNameA = HEAP_strdupWtoA(GetProcessHeap(),0,pDeviceName);
664 LPDEVMODEA pDevModeInputA = DEVMODEdupWtoA(GetProcessHeap(),pDevModeInput);
665 LPDEVMODEA pDevModeOutputA = NULL;
666 LONG ret;
667
668 TRACE("(%d,%d,%s,%p,%p,%ld)\n",
669 hWnd,hPrinter,debugstr_w(pDeviceName),pDevModeOutput,pDevModeInput,
670 fMode);
671 if(pDevModeOutput) {
672 ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, NULL, NULL, 0);
673 if(ret < 0) return ret;
674 pDevModeOutputA = HeapAlloc(GetProcessHeap(), 0, ret);
675 }
676 ret = DocumentPropertiesA(hWnd, hPrinter, pDeviceNameA, pDevModeOutputA,
677 pDevModeInputA, fMode);
678 if(pDevModeOutput) {
679 DEVMODEcpyAtoW(pDevModeOutput, pDevModeOutputA);
680 HeapFree(GetProcessHeap(),0,pDevModeOutputA);
681 }
682 if(fMode == 0 && ret > 0)
683 ret += (CCHDEVICENAME + CCHFORMNAME);
684 HeapFree(GetProcessHeap(),0,pDevModeInputA);
685 HeapFree(GetProcessHeap(),0,pDeviceNameA);
686 return ret;
687 }
688
689 /******************************************************************
690 * OpenPrinterA [WINSPOOL.@]
691 *
692 */
693 BOOL WINAPI OpenPrinterA(LPSTR lpPrinterName,HANDLE *phPrinter,
694 LPPRINTER_DEFAULTSA pDefault)
695 {
696 LPWSTR lpPrinterNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpPrinterName);
697 PRINTER_DEFAULTSW DefaultW, *pDefaultW = NULL;
698 BOOL ret;
699
700 if(pDefault) {
701 DefaultW.pDatatype = HEAP_strdupAtoW(GetProcessHeap(), 0,
702 pDefault->pDatatype);
703 DefaultW.pDevMode = DEVMODEdupAtoW(GetProcessHeap(),
704 pDefault->pDevMode);
705 DefaultW.DesiredAccess = pDefault->DesiredAccess;
706 pDefaultW = &DefaultW;
707 }
708 ret = OpenPrinterW(lpPrinterNameW, phPrinter, pDefaultW);
709 if(pDefault) {
710 HeapFree(GetProcessHeap(), 0, DefaultW.pDatatype);
711 HeapFree(GetProcessHeap(), 0, DefaultW.pDevMode);
712 }
713 HeapFree(GetProcessHeap(), 0, lpPrinterNameW);
714 return ret;
715 }
716
717 /******************************************************************
718 * OpenPrinterW [WINSPOOL.@]
719 *
720 */
721 BOOL WINAPI OpenPrinterW(LPWSTR lpPrinterName,HANDLE *phPrinter,
722 LPPRINTER_DEFAULTSW pDefault)
723 {
724 HKEY hkeyPrinters, hkeyPrinter;
725
726 if (!lpPrinterName) {
727 WARN("(printerName: NULL, pDefault %p Ret: False\n", pDefault);
728 SetLastError(ERROR_INVALID_PARAMETER);
729 return FALSE;
730 }
731
732 TRACE("(printerName: %s, pDefault %p)\n", debugstr_w(lpPrinterName),
733 pDefault);
734
735 /* Check Printer exists */
736 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
737 ERROR_SUCCESS) {
738 ERR("Can't create Printers key\n");
739 SetLastError(ERROR_FILE_NOT_FOUND); /* ?? */
740 return FALSE;
741 }
742
743 if(RegOpenKeyW(hkeyPrinters, lpPrinterName, &hkeyPrinter)
744 != ERROR_SUCCESS) {
745 ERR("Can't find printer %s in registry\n", debugstr_w(lpPrinterName));
746 RegCloseKey(hkeyPrinters);
747 SetLastError(ERROR_INVALID_PARAMETER);
748 return FALSE;
749 }
750 RegCloseKey(hkeyPrinter);
751 RegCloseKey(hkeyPrinters);
752
753 if(!phPrinter) /* This seems to be what win95 does anyway */
754 return TRUE;
755
756 /* Get the unique handle of the printer*/
757 *phPrinter = WINSPOOL_GetOpenedPrinterEntry( lpPrinterName );
758
759 if (pDefault != NULL)
760 FIXME("Not handling pDefault\n");
761
762 return TRUE;
763 }
764
765 /******************************************************************
766 * AddMonitorA [WINSPOOL.@]
767 *
768 */
769 BOOL WINAPI AddMonitorA(LPSTR pName, DWORD Level, LPBYTE pMonitors)
770 {
771 FIXME("(%s,%lx,%p):stub!\n", pName, Level, pMonitors);
772 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
773 return FALSE;
774 }
775
776 /******************************************************************
777 * DeletePrinterDriverA [WINSPOOL.@]
778 *
779 */
780 BOOL WINAPI
781 DeletePrinterDriverA (LPSTR pName, LPSTR pEnvironment, LPSTR pDriverName)
782 {
783 FIXME("(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
784 debugstr_a(pDriverName));
785 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
786 return FALSE;
787 }
788
789
790 /******************************************************************
791 * DeleteMonitorA [WINSPOOL.@]
792 *
793 */
794 BOOL WINAPI
795 DeleteMonitorA (LPSTR pName, LPSTR pEnvironment, LPSTR pMonitorName)
796 {
797 FIXME("(%s,%s,%s):stub\n",debugstr_a(pName),debugstr_a(pEnvironment),
798 debugstr_a(pMonitorName));
799 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
800 return FALSE;
801 }
802
803
804 /******************************************************************
805 * DeletePortA [WINSPOOL.@]
806 *
807 */
808 BOOL WINAPI
809 DeletePortA (LPSTR pName, HWND hWnd, LPSTR pPortName)
810 {
811 FIXME("(%s,0x%08x,%s):stub\n",debugstr_a(pName),hWnd,
812 debugstr_a(pPortName));
813 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
814 return FALSE;
815 }
816
817 /******************************************************************************
818 * SetPrinterW [WINSPOOL.@]
819 */
820 BOOL WINAPI
821 SetPrinterW(
822 HANDLE hPrinter,
823 DWORD Level,
824 LPBYTE pPrinter,
825 DWORD Command) {
826
827 FIXME("():stub\n");
828 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
829 return FALSE;
830 }
831
832 /******************************************************************************
833 * WritePrinter [WINSPOOL.@]
834 */
835 BOOL WINAPI
836 WritePrinter(
837 HANDLE hPrinter,
838 LPVOID pBuf,
839 DWORD cbBuf,
840 LPDWORD pcWritten) {
841
842 FIXME("():stub\n");
843 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
844 return FALSE;
845 }
846
847 /*****************************************************************************
848 * AddFormA [WINSPOOL.@]
849 */
850 BOOL WINAPI AddFormA(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
851 {
852 FIXME("(%d,%ld,%p): stub\n", hPrinter, Level, pForm);
853 return 1;
854 }
855
856 /*****************************************************************************
857 * AddFormW [WINSPOOL.@]
858 */
859 BOOL WINAPI AddFormW(HANDLE hPrinter, DWORD Level, LPBYTE pForm)
860 {
861 FIXME("(%d,%ld,%p): stub\n", hPrinter, Level, pForm);
862 return 1;
863 }
864
865 /*****************************************************************************
866 * AddJobA [WINSPOOL.@]
867 */
868 BOOL WINAPI AddJobA(HANDLE hPrinter, DWORD Level, LPBYTE pData,
869 DWORD cbBuf, LPDWORD pcbNeeded)
870 {
871 FIXME("(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
872 pcbNeeded);
873 return 1;
874 }
875
876 /*****************************************************************************
877 * AddJobW [WINSPOOL.@]
878 */
879 BOOL WINAPI AddJobW(HANDLE hPrinter, DWORD Level, LPBYTE pData, DWORD cbBuf,
880 LPDWORD pcbNeeded)
881 {
882 FIXME("(%d,%ld,%p,%ld,%p): stub\n", hPrinter, Level, pData, cbBuf,
883 pcbNeeded);
884 return 1;
885 }
886
887 /*****************************************************************************
888 * WINSPOOL_OpenDriverReg [internal]
889 *
890 * opens the registry for the printer drivers depending on the given input
891 * variable pEnvironment
892 *
893 * RETURNS:
894 * the opened hkey on success
895 * NULL on error
896 */
897 static HKEY WINSPOOL_OpenDriverReg( LPVOID pEnvironment, BOOL unicode)
898 { HKEY retval;
899 LPSTR lpKey, p = NULL;
900
901 TRACE("%s\n",
902 (unicode) ? debugstr_w(pEnvironment) : debugstr_a(pEnvironment));
903
904 if(pEnvironment)
905 p = (unicode) ? HEAP_strdupWtoA( GetProcessHeap(), 0, pEnvironment) :
906 pEnvironment;
907 else {
908 OSVERSIONINFOA ver;
909 ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
910
911 if(!GetVersionExA( &ver))
912 return 0;
913
914 switch (ver.dwPlatformId) {
915 case VER_PLATFORM_WIN32s:
916 return 0;
917 case VER_PLATFORM_WIN32_NT:
918 p = "Windows NT x86";
919 break;
920 default:
921 p = "Windows 4.0";
922 break;
923 }
924 TRACE("set environment to %s\n", p);
925 }
926
927 lpKey = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
928 strlen(p) + strlen(Drivers));
929 sprintf( lpKey, Drivers, p);
930
931 TRACE("%s\n", lpKey);
932
933 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, lpKey, &retval) !=
934 ERROR_SUCCESS)
935 retval = 0;
936
937 if(pEnvironment && unicode)
938 HeapFree( GetProcessHeap(), 0, p);
939 HeapFree( GetProcessHeap(), 0, lpKey);
940
941 return retval;
942 }
943
944 /*****************************************************************************
945 * AddPrinterW [WINSPOOL.@]
946 */
947 HANDLE WINAPI AddPrinterW(LPWSTR pName, DWORD Level, LPBYTE pPrinter)
948 {
949 PRINTER_INFO_2W *pi = (PRINTER_INFO_2W *) pPrinter;
950 LPDEVMODEA dmA;
951 LPDEVMODEW dmW;
952 HANDLE retval;
953 HKEY hkeyPrinter, hkeyPrinters, hkeyDriver, hkeyDrivers;
954 LONG size;
955
956 TRACE("(%s,%ld,%p)\n", debugstr_w(pName), Level, pPrinter);
957
958 if(pName != NULL) {
959 ERR("pName = %s - unsupported\n", debugstr_w(pName));
960 SetLastError(ERROR_INVALID_PARAMETER);
961 return 0;
962 }
963 if(Level != 2) {
964 ERR("Level = %ld, unsupported!\n", Level);
965 SetLastError(ERROR_INVALID_LEVEL);
966 return 0;
967 }
968 if (strlenW(pi->pPrinterName) >= CCHDEVICENAME) {
969 ERR("Printername %s must not exceed length of DEVMODE.dmDeviceName !\n",
970 debugstr_w(pi->pPrinterName)
971 );
972 SetLastError(ERROR_INVALID_LEVEL);
973 return 0;
974 }
975 if(!pPrinter) {
976 SetLastError(ERROR_INVALID_PARAMETER);
977 return 0;
978 }
979 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
980 ERROR_SUCCESS) {
981 ERR("Can't create Printers key\n");
982 return 0;
983 }
984 if(!RegOpenKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter)) {
985 if (!RegQueryValueA(hkeyPrinter,"Attributes",NULL,NULL)) {
986 SetLastError(ERROR_PRINTER_ALREADY_EXISTS);
987 RegCloseKey(hkeyPrinter);
988 RegCloseKey(hkeyPrinters);
989 return 0;
990 }
991 RegCloseKey(hkeyPrinter);
992 }
993 hkeyDrivers = WINSPOOL_OpenDriverReg( NULL, TRUE);
994 if(!hkeyDrivers) {
995 ERR("Can't create Drivers key\n");
996 RegCloseKey(hkeyPrinters);
997 return 0;
998 }
999 if(RegOpenKeyW(hkeyDrivers, pi->pDriverName, &hkeyDriver) !=
1000 ERROR_SUCCESS) {
1001 WARN("Can't find driver %s\n", debugstr_w(pi->pDriverName));
1002 RegCloseKey(hkeyPrinters);
1003 RegCloseKey(hkeyDrivers);
1004 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
1005 return 0;
1006 }
1007 RegCloseKey(hkeyDriver);
1008 RegCloseKey(hkeyDrivers);
1009
1010 if(lstrcmpiW(pi->pPrintProcessor, WinPrintW)) { /* FIXME */
1011 FIXME("Can't find processor %s\n", debugstr_w(pi->pPrintProcessor));
1012 SetLastError(ERROR_UNKNOWN_PRINTPROCESSOR);
1013 RegCloseKey(hkeyPrinters);
1014 return 0;
1015 }
1016
1017 if(RegCreateKeyW(hkeyPrinters, pi->pPrinterName, &hkeyPrinter) !=
1018 ERROR_SUCCESS) {
1019 FIXME("Can't create printer %s\n", debugstr_w(pi->pPrinterName));
1020 SetLastError(ERROR_INVALID_PRINTER_NAME);
1021 RegCloseKey(hkeyPrinters);
1022 return 0;
1023 }
1024 RegSetValueExA(hkeyPrinter, "Attributes", 0, REG_DWORD,
1025 (LPBYTE)&pi->Attributes, sizeof(DWORD));
1026 RegSetValueExW(hkeyPrinter, DatatypeW, 0, REG_SZ, (LPBYTE)pi->pDatatype,
1027 0);
1028
1029 /* See if we can load the driver. We may need the devmode structure anyway
1030 *
1031 * FIXME:
1032 * Note that DocumentPropertiesW will briefly try to open the printer we
1033 * just create to find a DEVMODEA struct (it will use the WINEPS default
1034 * one in case it is not there, so we are ok).
1035 */
1036 size = DocumentPropertiesW(0, -1, pi->pPrinterName, NULL, NULL, 0);
1037 if(size < 0) {
1038 FIXME("DocumentProperties fails\n");
1039 size = sizeof(DEVMODEW);
1040 }
1041 if(pi->pDevMode)
1042 dmW = pi->pDevMode;
1043 else {
1044 dmW = HeapAlloc(GetProcessHeap(), 0, size);
1045 dmW->dmSize = size;
1046 if (0>DocumentPropertiesW(0,-1,pi->pPrinterName,dmW,NULL,DM_OUT_BUFFER)) {
1047 ERR("DocumentPropertiesW failed!\n");
1048 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER);
1049 return 0;
1050 }
1051 /* set devmode to printer name */
1052 strcpyW(dmW->dmDeviceName,pi->pPrinterName);
1053 }
1054
1055 /* Write DEVMODEA not DEVMODEW into reg. This is what win9x does
1056 and we support these drivers. NT writes DEVMODEW so somehow
1057 we'll need to distinguish between these when we support NT
1058 drivers */
1059 dmA = DEVMODEdupWtoA(GetProcessHeap(), dmW);
1060 RegSetValueExA(hkeyPrinter, "Default DevMode", 0, REG_BINARY, (LPBYTE)dmA,
1061 dmA->dmSize + dmA->dmDriverExtra);
1062 HeapFree(GetProcessHeap(), 0, dmA);
1063 if(!pi->pDevMode)
1064 HeapFree(GetProcessHeap(), 0, dmW);
1065 RegSetValueExW(hkeyPrinter, DescriptionW, 0, REG_SZ, (LPBYTE)pi->pComment,
1066 0);
1067 RegSetValueExW(hkeyPrinter, LocationW, 0, REG_SZ, (LPBYTE)pi->pLocation,
1068 0);
1069 RegSetValueExW(hkeyPrinter, NameW, 0, REG_SZ, (LPBYTE)pi->pPrinterName, 0);
1070 RegSetValueExW(hkeyPrinter, ParametersW, 0, REG_SZ,
1071 (LPBYTE)pi->pParameters, 0);
1072 RegSetValueExW(hkeyPrinter, PortW, 0, REG_SZ, (LPBYTE)pi->pPortName, 0);
1073 RegSetValueExW(hkeyPrinter, Print_ProcessorW, 0, REG_SZ,
1074 (LPBYTE)pi->pPrintProcessor, 0);
1075 RegSetValueExW(hkeyPrinter, Printer_DriverW, 0, REG_SZ,
1076 (LPBYTE)pi->pDriverName, 0);
1077 RegSetValueExA(hkeyPrinter, "Priority", 0, REG_DWORD,
1078 (LPBYTE)&pi->Priority, sizeof(DWORD));
1079 RegSetValueExW(hkeyPrinter, Separator_FileW, 0, REG_SZ,
1080 (LPBYTE)pi->pSepFile, 0);
1081 RegSetValueExW(hkeyPrinter, Share_NameW, 0, REG_SZ, (LPBYTE)pi->pShareName,
1082 0);
1083 RegSetValueExA(hkeyPrinter, "StartTime", 0, REG_DWORD,
1084 (LPBYTE)&pi->StartTime, sizeof(DWORD));
1085 RegSetValueExA(hkeyPrinter, "Status", 0, REG_DWORD,
1086 (LPBYTE)&pi->Status, sizeof(DWORD));
1087 RegSetValueExA(hkeyPrinter, "UntilTime", 0, REG_DWORD,
1088 (LPBYTE)&pi->UntilTime, sizeof(DWORD));
1089
1090 RegCloseKey(hkeyPrinter);
1091 RegCloseKey(hkeyPrinters);
1092 if(!OpenPrinterW(pi->pPrinterName, &retval, NULL)) {
1093 ERR("OpenPrinter failing\n");
1094 return 0;
1095 }
1096 return retval;
1097 }
1098
1099 /*****************************************************************************
1100 * AddPrinterA [WINSPOOL.@]
1101 */
1102 HANDLE WINAPI AddPrinterA(LPSTR pName, DWORD Level, LPBYTE pPrinter)
1103 {
1104 WCHAR *pNameW;
1105 PRINTER_INFO_2W *piW;
1106 PRINTER_INFO_2A *piA = (PRINTER_INFO_2A*)pPrinter;
1107 HANDLE ret;
1108
1109 TRACE("(%s,%ld,%p): stub\n", debugstr_a(pName), Level, pPrinter);
1110 if(Level != 2) {
1111 ERR("Level = %ld, unsupported!\n", Level);
1112 SetLastError(ERROR_INVALID_LEVEL);
1113 return 0;
1114 }
1115 pNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, pName);
1116 piW = PRINTER_INFO_2AtoW(GetProcessHeap(), piA);
1117
1118 ret = AddPrinterW(pNameW, Level, (LPBYTE)piW);
1119
1120 FREE_PRINTER_INFO_2W(GetProcessHeap(), piW);
1121 HeapFree(GetProcessHeap(),0,pNameW);
1122 return ret;
1123 }
1124
1125
1126 /*****************************************************************************
1127 * ClosePrinter [WINSPOOL.@]
1128 */
1129 BOOL WINAPI ClosePrinter(HANDLE hPrinter)
1130 {
1131 int i = (int)hPrinter;
1132
1133 TRACE("Handle %d\n", hPrinter);
1134
1135 if ((i <= 0) || (i > nb_printers)) return FALSE;
1136 HeapFree( GetProcessHeap(), 0, printer_array[i - 1] );
1137 printer_array[i - 1] = NULL;
1138 return TRUE;
1139 }
1140
1141 /*****************************************************************************
1142 * DeleteFormA [WINSPOOL.@]
1143 */
1144 BOOL WINAPI DeleteFormA(HANDLE hPrinter, LPSTR pFormName)
1145 {
1146 FIXME("(%d,%s): stub\n", hPrinter, pFormName);
1147 return 1;
1148 }
1149
1150 /*****************************************************************************
1151 * DeleteFormW [WINSPOOL.@]
1152 */
1153 BOOL WINAPI DeleteFormW(HANDLE hPrinter, LPWSTR pFormName)
1154 {
1155 FIXME("(%d,%s): stub\n", hPrinter, debugstr_w(pFormName));
1156 return 1;
1157 }
1158
1159 /*****************************************************************************
1160 * DeletePrinter [WINSPOOL.@]
1161 */
1162 BOOL WINAPI DeletePrinter(HANDLE hPrinter)
1163 {
1164 LPCWSTR lpNameW = WINSPOOL_GetOpenedPrinter(hPrinter);
1165 HKEY hkeyPrinters;
1166
1167 if(!lpNameW) return FALSE;
1168 if(RegOpenKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
1169 ERROR_SUCCESS) {
1170 ERR("Can't open Printers key\n");
1171 return 0;
1172 }
1173
1174 /* This should use a recursive delete see Q142491 or SHDeleteKey */
1175 if(RegDeleteKeyW(hkeyPrinters, lpNameW) == ERROR_SUCCESS) {
1176 SetLastError(ERROR_PRINTER_NOT_FOUND); /* ?? */
1177 RegCloseKey(hkeyPrinters);
1178 return 0;
1179 }
1180
1181 ClosePrinter(hPrinter);
1182 return TRUE;
1183 }
1184
1185 /*****************************************************************************
1186 * SetPrinterA [WINSPOOL.@]
1187 */
1188 BOOL WINAPI SetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1189 DWORD Command)
1190 {
1191 FIXME("(%d,%ld,%p,%ld): stub\n",hPrinter,Level,pPrinter,Command);
1192 return FALSE;
1193 }
1194
1195 /*****************************************************************************
1196 * SetJobA [WINSPOOL.@]
1197 */
1198 BOOL WINAPI SetJobA(HANDLE hPrinter, DWORD JobId, DWORD Level,
1199 LPBYTE pJob, DWORD Command)
1200 {
1201 FIXME("(%d,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
1202 Command);
1203 return FALSE;
1204 }
1205
1206 /*****************************************************************************
1207 * SetJobW [WINSPOOL.@]
1208 */
1209 BOOL WINAPI SetJobW(HANDLE hPrinter, DWORD JobId, DWORD Level,
1210 LPBYTE pJob, DWORD Command)
1211 {
1212 FIXME("(%d,%ld,%ld,%p,%ld): stub\n",hPrinter,JobId,Level,pJob,
1213 Command);
1214 return FALSE;
1215 }
1216
1217 /*****************************************************************************
1218 * GetFormA [WINSPOOL.@]
1219 */
1220 BOOL WINAPI GetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
1221 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
1222 {
1223 FIXME("(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,pFormName,
1224 Level,pForm,cbBuf,pcbNeeded);
1225 return FALSE;
1226 }
1227
1228 /*****************************************************************************
1229 * GetFormW [WINSPOOL.@]
1230 */
1231 BOOL WINAPI GetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1232 LPBYTE pForm, DWORD cbBuf, LPDWORD pcbNeeded)
1233 {
1234 FIXME("(%d,%s,%ld,%p,%ld,%p): stub\n",hPrinter,
1235 debugstr_w(pFormName),Level,pForm,cbBuf,pcbNeeded);
1236 return FALSE;
1237 }
1238
1239 /*****************************************************************************
1240 * SetFormA [WINSPOOL.@]
1241 */
1242 BOOL WINAPI SetFormA(HANDLE hPrinter, LPSTR pFormName, DWORD Level,
1243 LPBYTE pForm)
1244 {
1245 FIXME("(%d,%s,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1246 return FALSE;
1247 }
1248
1249 /*****************************************************************************
1250 * SetFormW [WINSPOOL.@]
1251 */
1252 BOOL WINAPI SetFormW(HANDLE hPrinter, LPWSTR pFormName, DWORD Level,
1253 LPBYTE pForm)
1254 {
1255 FIXME("(%d,%p,%ld,%p): stub\n",hPrinter,pFormName,Level,pForm);
1256 return FALSE;
1257 }
1258
1259 /*****************************************************************************
1260 * ReadPrinter [WINSPOOL.@]
1261 */
1262 BOOL WINAPI ReadPrinter(HANDLE hPrinter, LPVOID pBuf, DWORD cbBuf,
1263 LPDWORD pNoBytesRead)
1264 {
1265 FIXME("(%d,%p,%ld,%p): stub\n",hPrinter,pBuf,cbBuf,pNoBytesRead);
1266 return FALSE;
1267 }
1268
1269 /*****************************************************************************
1270 * ResetPrinterA [WINSPOOL.@]
1271 */
1272 BOOL WINAPI ResetPrinterA(HANDLE hPrinter, LPPRINTER_DEFAULTSA pDefault)
1273 {
1274 FIXME("(%d, %p): stub\n", hPrinter, pDefault);
1275 return FALSE;
1276 }
1277
1278 /*****************************************************************************
1279 * ResetPrinterW [WINSPOOL.@]
1280 */
1281 BOOL WINAPI ResetPrinterW(HANDLE hPrinter, LPPRINTER_DEFAULTSW pDefault)
1282 {
1283 FIXME("(%d, %p): stub\n", hPrinter, pDefault);
1284 return FALSE;
1285 }
1286
1287 /*****************************************************************************
1288 * WINSPOOL_GetDWORDFromReg
1289 *
1290 * Return DWORD associated with ValueName from hkey.
1291 */
1292 static DWORD WINSPOOL_GetDWORDFromReg(HKEY hkey, LPCSTR ValueName)
1293 {
1294 DWORD sz = sizeof(DWORD), type, value = 0;
1295 LONG ret;
1296
1297 ret = RegQueryValueExA(hkey, ValueName, 0, &type, (LPBYTE)&value, &sz);
1298
1299 if(ret != ERROR_SUCCESS) {
1300 WARN("Got ret = %ld on name %s\n", ret, ValueName);
1301 return 0;
1302 }
1303 if(type != REG_DWORD) {
1304 ERR("Got type %ld\n", type);
1305 return 0;
1306 }
1307 return value;
1308 }
1309
1310 /*****************************************************************************
1311 * WINSPOOL_GetStringFromReg
1312 *
1313 * Get ValueName from hkey storing result in ptr. buflen is space left in ptr
1314 * String is stored either as unicode or ascii.
1315 * Bit of a hack here to get the ValueName if we want ascii.
1316 */
1317 static BOOL WINSPOOL_GetStringFromReg(HKEY hkey, LPCWSTR ValueName, LPBYTE ptr,
1318 DWORD buflen, DWORD *needed,
1319 BOOL unicode)
1320 {
1321 DWORD sz = buflen, type;
1322 LONG ret;
1323
1324 if(unicode)
1325 ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
1326 else {
1327 LPSTR ValueNameA = HEAP_strdupWtoA(GetProcessHeap(),0,ValueName);
1328 ret = RegQueryValueExA(hkey, ValueNameA, 0, &type, ptr, &sz);
1329 HeapFree(GetProcessHeap(),0,ValueNameA);
1330 }
1331 if(ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
1332 WARN("Got ret = %ld\n", ret);
1333 *needed = 0;
1334 return FALSE;
1335 }
1336 *needed = sz;
1337 return TRUE;
1338 }
1339
1340 /*****************************************************************************
1341 * WINSPOOL_GetDevModeFromReg
1342 *
1343 * Get ValueName from hkey storing result in ptr. buflen is space left in ptr
1344 * DevMode is stored either as unicode or ascii.
1345 */
1346 static BOOL WINSPOOL_GetDevModeFromReg(HKEY hkey, LPCWSTR ValueName,
1347 LPBYTE ptr,
1348 DWORD buflen, DWORD *needed,
1349 BOOL unicode)
1350 {
1351 DWORD sz = buflen, type;
1352 LONG ret;
1353
1354 if (ptr) memset(ptr, 0, sizeof(DEVMODEA));
1355 ret = RegQueryValueExW(hkey, ValueName, 0, &type, ptr, &sz);
1356 if ((ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)) sz = 0;
1357 if (sz < sizeof(DEVMODEA))
1358 {
1359 ERR("corrupted registry for %s ( size %ld)\n",debugstr_w(ValueName),sz);
1360 return FALSE;
1361 }
1362 /* ensures that dmSize is not erratically bogus if registry is invalid */
1363 if (ptr && ((DEVMODEA*)ptr)->dmSize < sizeof(DEVMODEA))
1364 ((DEVMODEA*)ptr)->dmSize = sizeof(DEVMODEA);
1365 if(unicode) {
1366 sz += (CCHDEVICENAME + CCHFORMNAME);
1367 if(buflen >= sz) {
1368 DEVMODEW *dmW = DEVMODEdupAtoW(GetProcessHeap(), (DEVMODEA*)ptr);
1369 memcpy(ptr, dmW, sz);
1370 HeapFree(GetProcessHeap(),0,dmW);
1371 }
1372 }
1373 *needed = sz;
1374 return TRUE;
1375 }
1376
1377 /*********************************************************************
1378 * WINSPOOL_GetPrinter_2
1379 *
1380 * Fills out a PRINTER_INFO_2A|W struct storing the strings in buf.
1381 * The strings are either stored as unicode or ascii.
1382 */
1383 static BOOL WINSPOOL_GetPrinter_2(HKEY hkeyPrinter, PRINTER_INFO_2W *pi2,
1384 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
1385 BOOL unicode)
1386 {
1387 DWORD size, left = cbBuf;
1388 BOOL space = (cbBuf > 0);
1389 LPBYTE ptr = buf;
1390
1391 *pcbNeeded = 0;
1392
1393 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
1394 unicode)) {
1395 if(space && size <= left) {
1396 pi2->pPrinterName = (LPWSTR)ptr;
1397 ptr += size;
1398 left -= size;
1399 } else
1400 space = FALSE;
1401 *pcbNeeded += size;
1402 }
1403 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Share_NameW, ptr, left, &size,
1404 unicode)) {
1405 if(space && size <= left) {
1406 pi2->pShareName = (LPWSTR)ptr;
1407 ptr += size;
1408 left -= size;
1409 } else
1410 space = FALSE;
1411 *pcbNeeded += size;
1412 }
1413 if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
1414 unicode)) {
1415 if(space && size <= left) {
1416 pi2->pPortName = (LPWSTR)ptr;
1417 ptr += size;
1418 left -= size;
1419 } else
1420 space = FALSE;
1421 *pcbNeeded += size;
1422 }
1423 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Printer_DriverW, ptr, left,
1424 &size, unicode)) {
1425 if(space && size <= left) {
1426 pi2->pDriverName = (LPWSTR)ptr;
1427 ptr += size;
1428 left -= size;
1429 } else
1430 space = FALSE;
1431 *pcbNeeded += size;
1432 }
1433 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DescriptionW, ptr, left, &size,
1434 unicode)) {
1435 if(space && size <= left) {
1436 pi2->pComment = (LPWSTR)ptr;
1437 ptr += size;
1438 left -= size;
1439 } else
1440 space = FALSE;
1441 *pcbNeeded += size;
1442 }
1443 if(WINSPOOL_GetStringFromReg(hkeyPrinter, LocationW, ptr, left, &size,
1444 unicode)) {
1445 if(space && size <= left) {
1446 pi2->pLocation = (LPWSTR)ptr;
1447 ptr += size;
1448 left -= size;
1449 } else
1450 space = FALSE;
1451 *pcbNeeded += size;
1452 }
1453 if(WINSPOOL_GetDevModeFromReg(hkeyPrinter, Default_DevModeW, ptr, left,
1454 &size, unicode)) {
1455 if(space && size <= left) {
1456 pi2->pDevMode = (LPDEVMODEW)ptr;
1457 ptr += size;
1458 left -= size;
1459 } else
1460 space = FALSE;
1461 *pcbNeeded += size;
1462 }
1463 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Separator_FileW, ptr, left,
1464 &size, unicode)) {
1465 if(space && size <= left) {
1466 pi2->pSepFile = (LPWSTR)ptr;
1467 ptr += size;
1468 left -= size;
1469 } else
1470 space = FALSE;
1471 *pcbNeeded += size;
1472 }
1473 if(WINSPOOL_GetStringFromReg(hkeyPrinter, Print_ProcessorW, ptr, left,
1474 &size, unicode)) {
1475 if(space && size <= left) {
1476 pi2->pPrintProcessor = (LPWSTR)ptr;
1477 ptr += size;
1478 left -= size;
1479 } else
1480 space = FALSE;
1481 *pcbNeeded += size;
1482 }
1483 if(WINSPOOL_GetStringFromReg(hkeyPrinter, DatatypeW, ptr, left,
1484 &size, unicode)) {
1485 if(space && size <= left) {
1486 pi2->pDatatype = (LPWSTR)ptr;
1487 ptr += size;
1488 left -= size;
1489 } else
1490 space = FALSE;
1491 *pcbNeeded += size;
1492 }
1493 if(WINSPOOL_GetStringFromReg(hkeyPrinter, ParametersW, ptr, left,
1494 &size, unicode)) {
1495 if(space && size <= left) {
1496 pi2->pParameters = (LPWSTR)ptr;
1497 ptr += size;
1498 left -= size;
1499 } else
1500 space = FALSE;
1501 *pcbNeeded += size;
1502 }
1503 if(pi2) {
1504 pi2->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
1505 pi2->Priority = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Priority");
1506 pi2->DefaultPriority = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
1507 "Default Priority");
1508 pi2->StartTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "StartTime");
1509 pi2->UntilTime = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "UntilTime");
1510 }
1511
1512 if(!space && pi2) /* zero out pi2 if we can't completely fill buf */
1513 memset(pi2, 0, sizeof(*pi2));
1514
1515 return space;
1516 }
1517
1518 /*********************************************************************
1519 * WINSPOOL_GetPrinter_4
1520 *
1521 * Fills out a PRINTER_INFO_4 struct storing the strings in buf.
1522 */
1523 static BOOL WINSPOOL_GetPrinter_4(HKEY hkeyPrinter, PRINTER_INFO_4W *pi4,
1524 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
1525 BOOL unicode)
1526 {
1527 DWORD size, left = cbBuf;
1528 BOOL space = (cbBuf > 0);
1529 LPBYTE ptr = buf;
1530
1531 *pcbNeeded = 0;
1532
1533 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
1534 unicode)) {
1535 if(space && size <= left) {
1536 pi4->pPrinterName = (LPWSTR)ptr;
1537 ptr += size;
1538 left -= size;
1539 } else
1540 space = FALSE;
1541 *pcbNeeded += size;
1542 }
1543 if(pi4) {
1544 pi4->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
1545 }
1546
1547 if(!space && pi4) /* zero out pi4 if we can't completely fill buf */
1548 memset(pi4, 0, sizeof(*pi4));
1549
1550 return space;
1551 }
1552
1553 /*********************************************************************
1554 * WINSPOOL_GetPrinter_5
1555 *
1556 * Fills out a PRINTER_INFO_5 struct storing the strings in buf.
1557 */
1558 static BOOL WINSPOOL_GetPrinter_5(HKEY hkeyPrinter, PRINTER_INFO_5W *pi5,
1559 LPBYTE buf, DWORD cbBuf, LPDWORD pcbNeeded,
1560 BOOL unicode)
1561 {
1562 DWORD size, left = cbBuf;
1563 BOOL space = (cbBuf > 0);
1564 LPBYTE ptr = buf;
1565
1566 *pcbNeeded = 0;
1567
1568 if(WINSPOOL_GetStringFromReg(hkeyPrinter, NameW, ptr, left, &size,
1569 unicode)) {
1570 if(space && size <= left) {
1571 pi5->pPrinterName = (LPWSTR)ptr;
1572 ptr += size;
1573 left -= size;
1574 } else
1575 space = FALSE;
1576 *pcbNeeded += size;
1577 }
1578 if(WINSPOOL_GetStringFromReg(hkeyPrinter, PortW, ptr, left, &size,
1579 unicode)) {
1580 if(space && size <= left) {
1581 pi5->pPortName = (LPWSTR)ptr;
1582 ptr += size;
1583 left -= size;
1584 } else
1585 space = FALSE;
1586 *pcbNeeded += size;
1587 }
1588 if(pi5) {
1589 pi5->Attributes = WINSPOOL_GetDWORDFromReg(hkeyPrinter, "Attributes");
1590 pi5->DeviceNotSelectedTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
1591 "dnsTimeout");
1592 pi5->TransmissionRetryTimeout = WINSPOOL_GetDWORDFromReg(hkeyPrinter,
1593 "txTimeout");
1594 }
1595
1596 if(!space && pi5) /* zero out pi5 if we can't completely fill buf */
1597 memset(pi5, 0, sizeof(*pi5));
1598
1599 return space;
1600 }
1601
1602 /*****************************************************************************
1603 * WINSPOOL_GetPrinter
1604 *
1605 * Implementation of GetPrinterA|W. Relies on PRINTER_INFO_*W being
1606 * essentially the same as PRINTER_INFO_*A. i.e. the structure itself is
1607 * just a collection of pointers to strings.
1608 */
1609 static BOOL WINSPOOL_GetPrinter(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1610 DWORD cbBuf, LPDWORD pcbNeeded, BOOL unicode)
1611 {
1612 LPCWSTR name;
1613 DWORD size, needed = 0;
1614 LPBYTE ptr = NULL;
1615 HKEY hkeyPrinter, hkeyPrinters;
1616 BOOL ret;
1617
1618 TRACE("(%d,%ld,%p,%ld,%p)\n",hPrinter,Level,pPrinter,cbBuf, pcbNeeded);
1619
1620 if (!(name = WINSPOOL_GetOpenedPrinter(hPrinter))) return FALSE;
1621
1622 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
1623 ERROR_SUCCESS) {
1624 ERR("Can't create Printers key\n");
1625 return FALSE;
1626 }
1627 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter) != ERROR_SUCCESS)
1628 {
1629 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
1630 RegCloseKey(hkeyPrinters);
1631 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
1632 return FALSE;
1633 }
1634
1635 switch(Level) {
1636 case 2:
1637 {
1638 PRINTER_INFO_2W *pi2 = (PRINTER_INFO_2W *)pPrinter;
1639
1640 size = sizeof(PRINTER_INFO_2W);
1641 if(size <= cbBuf) {
1642 ptr = pPrinter + size;
1643 cbBuf -= size;
1644 memset(pPrinter, 0, size);
1645 } else {
1646 pi2 = NULL;
1647 cbBuf = 0;
1648 }
1649 ret = WINSPOOL_GetPrinter_2(hkeyPrinter, pi2, ptr, cbBuf, &needed,
1650 unicode);
1651 needed += size;
1652 break;
1653 }
1654
1655 case 4:
1656 {
1657 PRINTER_INFO_4W *pi4 = (PRINTER_INFO_4W *)pPrinter;
1658
1659 size = sizeof(PRINTER_INFO_4W);
1660 if(size <= cbBuf) {
1661 ptr = pPrinter + size;
1662 cbBuf -= size;
1663 memset(pPrinter, 0, size);
1664 } else {
1665 pi4 = NULL;
1666 cbBuf = 0;
1667 }
1668 ret = WINSPOOL_GetPrinter_4(hkeyPrinter, pi4, ptr, cbBuf, &needed,
1669 unicode);
1670 needed += size;
1671 break;
1672 }
1673
1674
1675 case 5:
1676 {
1677 PRINTER_INFO_5W *pi5 = (PRINTER_INFO_5W *)pPrinter;
1678
1679 size = sizeof(PRINTER_INFO_5W);
1680 if(size <= cbBuf) {
1681 ptr = pPrinter + size;
1682 cbBuf -= size;
1683 memset(pPrinter, 0, size);
1684 } else {
1685 pi5 = NULL;
1686 cbBuf = 0;
1687 }
1688
1689 ret = WINSPOOL_GetPrinter_5(hkeyPrinter, pi5, ptr, cbBuf, &needed,
1690 unicode);
1691 needed += size;
1692 break;
1693 }
1694
1695 default:
1696 FIXME("Unimplemented level %ld\n", Level);
1697 SetLastError(ERROR_INVALID_LEVEL);
1698 RegCloseKey(hkeyPrinters);
1699 RegCloseKey(hkeyPrinter);
1700 return FALSE;
1701 }
1702
1703 RegCloseKey(hkeyPrinter);
1704 RegCloseKey(hkeyPrinters);
1705
1706 TRACE("returing %d needed = %ld\n", ret, needed);
1707 if(pcbNeeded) *pcbNeeded = needed;
1708 if(!ret)
1709 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1710 return ret;
1711 }
1712
1713 /*****************************************************************************
1714 * GetPrinterW [WINSPOOL.@]
1715 */
1716 BOOL WINAPI GetPrinterW(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1717 DWORD cbBuf, LPDWORD pcbNeeded)
1718 {
1719 return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
1720 TRUE);
1721 }
1722
1723 /*****************************************************************************
1724 * GetPrinterA [WINSPOOL.@]
1725 */
1726 BOOL WINAPI GetPrinterA(HANDLE hPrinter, DWORD Level, LPBYTE pPrinter,
1727 DWORD cbBuf, LPDWORD pcbNeeded)
1728 {
1729 return WINSPOOL_GetPrinter(hPrinter, Level, pPrinter, cbBuf, pcbNeeded,
1730 FALSE);
1731 }
1732
1733 /*****************************************************************************
1734 * WINSPOOL_EnumPrinters
1735 *
1736 * Implementation of EnumPrintersA|W
1737 */
1738 static BOOL WINSPOOL_EnumPrinters(DWORD dwType, LPWSTR lpszName,
1739 DWORD dwLevel, LPBYTE lpbPrinters,
1740 DWORD cbBuf, LPDWORD lpdwNeeded,
1741 LPDWORD lpdwReturned, BOOL unicode)
1742
1743 {
1744 HKEY hkeyPrinters, hkeyPrinter;
1745 WCHAR PrinterName[255];
1746 DWORD needed = 0, number = 0;
1747 DWORD used, i, left;
1748 PBYTE pi, buf;
1749
1750 if(lpbPrinters)
1751 memset(lpbPrinters, 0, cbBuf);
1752 if(lpdwReturned)
1753 *lpdwReturned = 0;
1754 if(lpdwNeeded)
1755 *lpdwNeeded = 0;
1756
1757 /* PRINTER_ENUM_DEFAULT is only supported under win9x, we behave like NT */
1758 if(dwType == PRINTER_ENUM_DEFAULT)
1759 return TRUE;
1760
1761 if (!((dwType & PRINTER_ENUM_LOCAL) || (dwType & PRINTER_ENUM_NAME))) {
1762 FIXME("dwType = %08lx\n", dwType);
1763 SetLastError(ERROR_INVALID_FLAGS);
1764 return FALSE;
1765 }
1766
1767 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
1768 ERROR_SUCCESS) {
1769 ERR("Can't create Printers key\n");
1770 return FALSE;
1771 }
1772
1773 if(RegQueryInfoKeyA(hkeyPrinters, NULL, NULL, NULL, &number, NULL, NULL,
1774 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
1775 RegCloseKey(hkeyPrinters);
1776 ERR("Can't query Printers key\n");
1777 return FALSE;
1778 }
1779 TRACE("Found %ld printers\n", number);
1780
1781 switch(dwLevel) {
1782 case 1:
1783 RegCloseKey(hkeyPrinters);
1784 if (lpdwReturned)
1785 *lpdwReturned = number;
1786 return TRUE;
1787
1788 case 2:
1789 used = number * sizeof(PRINTER_INFO_2W);
1790 break;
1791 case 4:
1792 used = number * sizeof(PRINTER_INFO_4W);
1793 break;
1794 case 5:
1795 used = number * sizeof(PRINTER_INFO_5W);
1796 break;
1797
1798 default:
1799 SetLastError(ERROR_INVALID_LEVEL);
1800 RegCloseKey(hkeyPrinters);
1801 return FALSE;
1802 }
1803 pi = (used <= cbBuf) ? lpbPrinters : NULL;
1804
1805 for(i = 0; i < number; i++) {
1806 if(RegEnumKeyW(hkeyPrinters, i, PrinterName, sizeof(PrinterName)) !=
1807 ERROR_SUCCESS) {
1808 ERR("Can't enum key number %ld\n", i);
1809 RegCloseKey(hkeyPrinters);
1810 return FALSE;
1811 }
1812 TRACE("Printer %ld is %s\n", i, debugstr_w(PrinterName));
1813 if(RegOpenKeyW(hkeyPrinters, PrinterName, &hkeyPrinter) !=
1814 ERROR_SUCCESS) {
1815 ERR("Can't open key %s\n", debugstr_w(PrinterName));
1816 RegCloseKey(hkeyPrinters);
1817 return FALSE;
1818 }
1819
1820 if(cbBuf > used) {
1821 buf = lpbPrinters + used;
1822 left = cbBuf - used;
1823 } else {
1824 buf = NULL;
1825 left = 0;
1826 }
1827
1828 switch(dwLevel) {
1829 case 2:
1830 WINSPOOL_GetPrinter_2(hkeyPrinter, (PRINTER_INFO_2W *)pi, buf,
1831 left, &needed, unicode);
1832 used += needed;
1833 if(pi) pi += sizeof(PRINTER_INFO_2W);
1834 break;
1835 case 4:
1836 WINSPOOL_GetPrinter_4(hkeyPrinter, (PRINTER_INFO_4W *)pi, buf,
1837 left, &needed, unicode);
1838 used += needed;
1839 if(pi) pi += sizeof(PRINTER_INFO_4W);
1840 break;
1841 case 5:
1842 WINSPOOL_GetPrinter_5(hkeyPrinter, (PRINTER_INFO_5W *)pi, buf,
1843 left, &needed, unicode);
1844 used += needed;
1845 if(pi) pi += sizeof(PRINTER_INFO_5W);
1846 break;
1847 default:
1848 ERR("Shouldn't be here!\n");
1849 RegCloseKey(hkeyPrinter);
1850 RegCloseKey(hkeyPrinters);
1851 return FALSE;
1852 }
1853 RegCloseKey(hkeyPrinter);
1854 }
1855 RegCloseKey(hkeyPrinters);
1856
1857 if(lpdwNeeded)
1858 *lpdwNeeded = used;
1859
1860 if(used > cbBuf) {
1861 if(lpbPrinters)
1862 memset(lpbPrinters, 0, cbBuf);
1863 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1864 return FALSE;
1865 }
1866 if(lpdwReturned)
1867 *lpdwReturned = number;
1868 SetLastError(ERROR_SUCCESS);
1869 return TRUE;
1870 }
1871
1872
1873 /******************************************************************
1874 * EnumPrintersW [WINSPOOL.@]
1875 *
1876 * Enumerates the available printers, print servers and print
1877 * providers, depending on the specified flags, name and level.
1878 *
1879 * RETURNS:
1880 *
1881 * If level is set to 1:
1882 * Not implemented yet!
1883 * Returns TRUE with an empty list.
1884 *
1885 * If level is set to 2:
1886 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
1887 * Returns an array of PRINTER_INFO_2 data structures in the
1888 * lpbPrinters buffer. Note that according to MSDN also an
1889 * OpenPrinter should be performed on every remote printer.
1890 *
1891 * If level is set to 4 (officially WinNT only):
1892 * Possible flags: PRINTER_ENUM_CONNECTIONS, PRINTER_ENUM_LOCAL.
1893 * Fast: Only the registry is queried to retrieve printer names,
1894 * no connection to the driver is made.
1895 * Returns an array of PRINTER_INFO_4 data structures in the
1896 * lpbPrinters buffer.
1897 *
1898 * If level is set to 5 (officially WinNT4/Win9x only):
1899 * Fast: Only the registry is queried to retrieve printer names,
1900 * no connection to the driver is made.
1901 * Returns an array of PRINTER_INFO_5 data structures in the
1902 * lpbPrinters buffer.
1903 *
1904 * If level set to 3 or 6+:
1905 * returns zero (failure!)
1906 *
1907 * Returns nonzero (TRUE) on success, or zero on failure, use GetLastError
1908 * for information.
1909 *
1910 * BUGS:
1911 * - Only PRINTER_ENUM_LOCAL and PRINTER_ENUM_NAME are implemented.
1912 * - Only levels 2, 4 and 5 are implemented at the moment.
1913 * - 16-bit printer drivers are not enumerated.
1914 * - Returned amount of bytes used/needed does not match the real Windoze
1915 * implementation (as in this implementation, all strings are part
1916 * of the buffer, whereas Win32 keeps them somewhere else)
1917 * - At level 2, EnumPrinters should also call OpenPrinter for remote printers.
1918 *
1919 * NOTE:
1920 * - In a regular Wine installation, no registry settings for printers
1921 * exist, which makes this function return an empty list.
1922 */
1923 BOOL WINAPI EnumPrintersW(
1924 DWORD dwType, /* [in] Types of print objects to enumerate */
1925 LPWSTR lpszName, /* [in] name of objects to enumerate */
1926 DWORD dwLevel, /* [in] type of printer info structure */
1927 LPBYTE lpbPrinters, /* [out] buffer which receives info */
1928 DWORD cbBuf, /* [in] max size of buffer in bytes */
1929 LPDWORD lpdwNeeded, /* [out] pointer to var: # bytes used/needed */
1930 LPDWORD lpdwReturned /* [out] number of entries returned */
1931 )
1932 {
1933 return WINSPOOL_EnumPrinters(dwType, lpszName, dwLevel, lpbPrinters, cbBuf,
1934 lpdwNeeded, lpdwReturned, TRUE);
1935 }
1936
1937 /******************************************************************
1938 * EnumPrintersA [WINSPOOL.@]
1939 *
1940 */
1941 BOOL WINAPI EnumPrintersA(DWORD dwType, LPSTR lpszName,
1942 DWORD dwLevel, LPBYTE lpbPrinters,
1943 DWORD cbBuf, LPDWORD lpdwNeeded,
1944 LPDWORD lpdwReturned)
1945 {
1946 BOOL ret;
1947 LPWSTR lpszNameW = HEAP_strdupAtoW(GetProcessHeap(),0,lpszName);
1948
1949 ret = WINSPOOL_EnumPrinters(dwType, lpszNameW, dwLevel, lpbPrinters, cbBuf,
1950 lpdwNeeded, lpdwReturned, FALSE);
1951 HeapFree(GetProcessHeap(),0,lpszNameW);
1952 return ret;
1953 }
1954
1955 /*****************************************************************************
1956 * WINSPOOL_GetDriverInfoFromReg [internal]
1957 *
1958 * Enters the information from the registry into the DRIVER_INFO struct
1959 *
1960 * RETURNS
1961 * zero if the printer driver does not exist in the registry
1962 * (only if Level > 1) otherwise nonzero
1963 */
1964 static BOOL WINSPOOL_GetDriverInfoFromReg(
1965 HKEY hkeyDrivers,
1966 LPWSTR DriverName,
1967 LPWSTR pEnvironment,
1968 DWORD Level,
1969 LPBYTE ptr, /* DRIVER_INFO */
1970 LPBYTE pDriverStrings, /* strings buffer */
1971 DWORD cbBuf, /* size of string buffer */
1972 LPDWORD pcbNeeded, /* space needed for str. */
1973 BOOL unicode) /* type of strings */
1974 { DWORD dw, size, tmp, type;
1975 HKEY hkeyDriver;
1976 LPBYTE strPtr = pDriverStrings;
1977
1978 TRACE("%s,%s,%ld,%p,%p,%ld,%d\n",
1979 debugstr_w(DriverName), debugstr_w(pEnvironment),
1980 Level, ptr, pDriverStrings, cbBuf, unicode);
1981
1982 if(unicode) {
1983 *pcbNeeded = (lstrlenW(DriverName) + 1) * sizeof(WCHAR);
1984 if (*pcbNeeded <= cbBuf)
1985 strcpyW((LPWSTR)strPtr, DriverName);
1986 } else {
1987 *pcbNeeded = WideCharToMultiByte(CP_ACP, 0, DriverName, -1, NULL, 0,
1988 NULL, NULL);
1989 if(*pcbNeeded <= cbBuf)
1990 WideCharToMultiByte(CP_ACP, 0, DriverName, -1, strPtr, *pcbNeeded,
1991 NULL, NULL);
1992 }
1993 if(Level == 1) {
1994 if(ptr)
1995 ((PDRIVER_INFO_1W) ptr)->pName = (LPWSTR) strPtr;
1996 return TRUE;
1997 } else {
1998 if(ptr)
1999 ((PDRIVER_INFO_3W) ptr)->pName = (LPWSTR) strPtr;
2000 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
2001 }
2002
2003 if(RegOpenKeyW(hkeyDrivers, DriverName, &hkeyDriver) != ERROR_SUCCESS) {
2004 ERR("Can't find driver %s in registry\n", debugstr_w(DriverName));
2005 SetLastError(ERROR_UNKNOWN_PRINTER_DRIVER); /* ? */
2006 return FALSE;
2007 }
2008
2009 size = sizeof(dw);
2010 if(RegQueryValueExA(hkeyDriver, "Version", 0, &type, (PBYTE)&dw, &size) !=
2011 ERROR_SUCCESS)
2012 WARN("Can't get Version\n");
2013 else if(ptr)
2014 ((PDRIVER_INFO_3A) ptr)->cVersion = dw;
2015
2016 if(!pEnvironment)
2017 pEnvironment = DefaultEnvironmentW;
2018 if(unicode)
2019 size = (lstrlenW(pEnvironment) + 1) * sizeof(WCHAR);
2020 else
2021 size = WideCharToMultiByte(CP_ACP, 0, pEnvironment, -1, NULL, 0,
2022 NULL, NULL);
2023 *pcbNeeded += size;
2024 if(*pcbNeeded <= cbBuf) {
2025 if(unicode)
2026 strcpyW((LPWSTR)strPtr, pEnvironment);
2027 else
2028 WideCharToMultiByte(CP_ACP, 0, pEnvironment, -1, strPtr, size,
2029 NULL, NULL);
2030 if(ptr)
2031 ((PDRIVER_INFO_3W) ptr)->pEnvironment = (LPWSTR)strPtr;
2032 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
2033 }
2034
2035 if(WINSPOOL_GetStringFromReg(hkeyDriver, DriverW, strPtr, 0, &size,
2036 unicode)) {
2037 *pcbNeeded += size;
2038 if(*pcbNeeded <= cbBuf)
2039 WINSPOOL_GetStringFromReg(hkeyDriver, DriverW, strPtr, size, &tmp,
2040 unicode);
2041 if(ptr)
2042 ((PDRIVER_INFO_3W) ptr)->pDriverPath = (LPWSTR)strPtr;
2043 strPtr = (pDriverStrings) ? (pDriverStrings + (*pcbNeeded)) : NULL;
2044 }
2045
2046 if(WINSPOOL_GetStringFromReg(hkeyDriver, Data_FileW, strPtr, 0, &size,
2047 unicode)) {
2048 *pcbNeeded += size;
2049 if(*pcbNeeded <= cbBuf)
2050 WINSPOOL_GetStringFromReg(hkeyDriver, Data_FileW, strPtr, size,
2051 &tmp, unicode);
2052 if(ptr)
2053 ((PDRIVER_INFO_3W) ptr)->pDataFile = (LPWSTR)strPtr;
2054 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2055 }
2056
2057 if(WINSPOOL_GetStringFromReg(hkeyDriver, Configuration_FileW, strPtr,
2058 0, &size, unicode)) {
2059 *pcbNeeded += size;
2060 if(*pcbNeeded <= cbBuf)
2061 WINSPOOL_GetStringFromReg(hkeyDriver, Configuration_FileW, strPtr,
2062 size, &tmp, unicode);
2063 if(ptr)
2064 ((PDRIVER_INFO_3W) ptr)->pConfigFile = (LPWSTR)strPtr;
2065 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2066 }
2067
2068 if(Level == 2 ) {
2069 RegCloseKey(hkeyDriver);
2070 TRACE("buffer space %ld required %ld\n", cbBuf, *pcbNeeded);
2071 return TRUE;
2072 }
2073
2074 if(WINSPOOL_GetStringFromReg(hkeyDriver, Help_FileW, strPtr, 0, &size,
2075 unicode)) {
2076 *pcbNeeded += size;
2077 if(*pcbNeeded <= cbBuf)
2078 WINSPOOL_GetStringFromReg(hkeyDriver, Help_FileW, strPtr,
2079 size, &tmp, unicode);
2080 if(ptr)
2081 ((PDRIVER_INFO_3W) ptr)->pHelpFile = (LPWSTR)strPtr;
2082 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2083 }
2084
2085 if(WINSPOOL_GetStringFromReg(hkeyDriver, Dependent_FilesW, strPtr, 0,
2086 &size, unicode)) {
2087 *pcbNeeded += size;
2088 if(*pcbNeeded <= cbBuf)
2089 WINSPOOL_GetStringFromReg(hkeyDriver, Dependent_FilesW, strPtr,
2090 size, &tmp, unicode);
2091 if(ptr)
2092 ((PDRIVER_INFO_3W) ptr)->pDependentFiles = (LPWSTR)strPtr;
2093 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2094 }
2095
2096 if(WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr, 0, &size,
2097 unicode)) {
2098 *pcbNeeded += size;
2099 if(*pcbNeeded <= cbBuf)
2100 WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr,
2101 size, &tmp, unicode);
2102 if(ptr)
2103 ((PDRIVER_INFO_3W) ptr)->pMonitorName = (LPWSTR)strPtr;
2104 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2105 }
2106
2107 if(WINSPOOL_GetStringFromReg(hkeyDriver, DatatypeW, strPtr, 0, &size,
2108 unicode)) {
2109 *pcbNeeded += size;
2110 if(*pcbNeeded <= cbBuf)
2111 WINSPOOL_GetStringFromReg(hkeyDriver, MonitorW, strPtr,
2112 size, &tmp, unicode);
2113 if(ptr)
2114 ((PDRIVER_INFO_3W) ptr)->pDefaultDataType = (LPWSTR)strPtr;
2115 strPtr = (pDriverStrings) ? pDriverStrings + (*pcbNeeded) : NULL;
2116 }
2117
2118 TRACE("buffer space %ld required %ld\n", cbBuf, *pcbNeeded);
2119 RegCloseKey(hkeyDriver);
2120 return TRUE;
2121 }
2122
2123 /*****************************************************************************
2124 * WINSPOOL_GetPrinterDriver
2125 */
2126 static BOOL WINSPOOL_GetPrinterDriver(HANDLE hPrinter, LPWSTR pEnvironment,
2127 DWORD Level, LPBYTE pDriverInfo,
2128 DWORD cbBuf, LPDWORD pcbNeeded,
2129 BOOL unicode)
2130 {
2131 LPCWSTR name;
2132 WCHAR DriverName[100];
2133 DWORD ret, type, size, needed = 0;
2134 LPBYTE ptr = NULL;
2135 HKEY hkeyPrinter, hkeyPrinters, hkeyDrivers;
2136
2137 TRACE("(%d,%s,%ld,%p,%ld,%p)\n",hPrinter,debugstr_w(pEnvironment),
2138 Level,pDriverInfo,cbBuf, pcbNeeded);
2139
2140 ZeroMemory(pDriverInfo, cbBuf);
2141
2142 if (!(name = WINSPOOL_GetOpenedPrinter(hPrinter))) return FALSE;
2143
2144 if(Level < 1 || Level > 3) {
2145 SetLastError(ERROR_INVALID_LEVEL);
2146 return FALSE;
2147 }
2148 if(RegCreateKeyA(HKEY_LOCAL_MACHINE, Printers, &hkeyPrinters) !=
2149 ERROR_SUCCESS) {
2150 ERR("Can't create Printers key\n");
2151 return FALSE;
2152 }
2153 if(RegOpenKeyW(hkeyPrinters, name, &hkeyPrinter)
2154 != ERROR_SUCCESS) {
2155 ERR("Can't find opened printer %s in registry\n", debugstr_w(name));
2156 RegCloseKey(hkeyPrinters);
2157 SetLastError(ERROR_INVALID_PRINTER_NAME); /* ? */
2158 return FALSE;
2159 }
2160 size = sizeof(DriverName);
2161 ret = RegQueryValueExW(hkeyPrinter, Printer_DriverW, 0, &type,
2162 (LPBYTE)DriverName, &size);
2163 RegCloseKey(hkeyPrinter);
2164 RegCloseKey(hkeyPrinters);
2165 if(ret != ERROR_SUCCESS) {
2166 ERR("Can't get DriverName for printer %s\n", debugstr_w(name));
2167 return FALSE;
2168 }
2169
2170 hkeyDrivers = WINSPOOL_OpenDriverReg( pEnvironment, TRUE);
2171 if(!hkeyDrivers) {
2172 ERR("Can't create Drivers key\n");
2173 return FALSE;
2174 }
2175
2176 switch(Level) {
2177 case 1:
2178 size = sizeof(DRIVER_INFO_1W);
2179 break;
2180 case 2:
2181 size = sizeof(DRIVER_INFO_2W);
2182 break;
2183 case 3:
2184 size = sizeof(DRIVER_INFO_3W);
2185 break;
2186 default:
2187 ERR("Invalid level\n");
2188 return FALSE;
2189 }
2190
2191 if(size <= cbBuf)
2192 ptr = pDriverInfo + size;
2193
2194 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverName,
2195 pEnvironment, Level, pDriverInfo,
2196 (cbBuf < size) ? NULL : ptr,
2197 (cbBuf < size) ? 0 : cbBuf - size,
2198 &needed, unicode)) {
2199 RegCloseKey(hkeyDrivers);
2200 return FALSE;
2201 }
2202
2203 RegCloseKey(hkeyDrivers);
2204
2205 if(pcbNeeded) *pcbNeeded = size + needed;
2206 TRACE("buffer space %ld required %ld\n", cbBuf, *pcbNeeded);
2207 if(cbBuf >= needed) return TRUE;
2208 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2209 return FALSE;
2210 }
2211
2212 /*****************************************************************************
2213 * GetPrinterDriverA [WINSPOOL.@]
2214 */
2215 BOOL WINAPI GetPrinterDriverA(HANDLE hPrinter, LPSTR pEnvironment,
2216 DWORD Level, LPBYTE pDriverInfo,
2217 DWORD cbBuf, LPDWORD pcbNeeded)
2218 {
2219 BOOL ret;
2220 LPWSTR pEnvW = HEAP_strdupAtoW(GetProcessHeap(),0,pEnvironment);
2221 ret = WINSPOOL_GetPrinterDriver(hPrinter, pEnvW, Level, pDriverInfo,
2222 cbBuf, pcbNeeded, FALSE);
2223 HeapFree(GetProcessHeap(),0,pEnvW);
2224 return ret;
2225 }
2226 /*****************************************************************************
2227 * GetPrinterDriverW [WINSPOOL.@]
2228 */
2229 BOOL WINAPI GetPrinterDriverW(HANDLE hPrinter, LPWSTR pEnvironment,
2230 DWORD Level, LPBYTE pDriverInfo,
2231 DWORD cbBuf, LPDWORD pcbNeeded)
2232 {
2233 return WINSPOOL_GetPrinterDriver(hPrinter, pEnvironment, Level,
2234 pDriverInfo, cbBuf, pcbNeeded, TRUE);
2235 }
2236
2237 /*****************************************************************************
2238 * GetPrinterDriverDirectoryA [WINSPOOL.@]
2239 */
2240 BOOL WINAPI GetPrinterDriverDirectoryA(LPSTR pName, LPSTR pEnvironment,
2241 DWORD Level, LPBYTE pDriverDirectory,
2242 DWORD cbBuf, LPDWORD pcbNeeded)
2243 {
2244 DWORD needed;
2245
2246 TRACE("(%s, %s, %ld, %p, %ld, %p)\n", pName, pEnvironment, Level,
2247 pDriverDirectory, cbBuf, pcbNeeded);
2248 if(pName != NULL) {
2249 FIXME("pName = `%s' - unsupported\n", pName);
2250 SetLastError(ERROR_INVALID_PARAMETER);
2251 return FALSE;
2252 }
2253 if(pEnvironment != NULL) {
2254 FIXME("pEnvironment = `%s' - unsupported\n", pEnvironment);
2255 SetLastError(ERROR_INVALID_ENVIRONMENT);
2256 return FALSE;
2257 }
2258 if(Level != 1) /* win95 ignores this so we just carry on */
2259 WARN("Level = %ld - assuming 1\n", Level);
2260
2261 /* FIXME should read from registry */
2262 needed = GetSystemDirectoryA(pDriverDirectory, cbBuf);
2263 needed++;
2264 if(pcbNeeded)
2265 *pcbNeeded = needed;
2266 if(needed > cbBuf) {
2267 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2268 return FALSE;
2269 }
2270 return TRUE;
2271 }
2272
2273
2274 /*****************************************************************************
2275 * GetPrinterDriverDirectoryW [WINSPOOL.@]
2276 */
2277 BOOL WINAPI GetPrinterDriverDirectoryW(LPWSTR pName, LPWSTR pEnvironment,
2278 DWORD Level, LPBYTE pDriverDirectory,
2279 DWORD cbBuf, LPDWORD pcbNeeded)
2280 {
2281 LPSTR pNameA = NULL, pEnvironmentA = NULL;
2282 BOOL ret;
2283
2284 if(pName)
2285 pNameA = HEAP_strdupWtoA( GetProcessHeap(), 0, pName );
2286 if(pEnvironment)
2287 pEnvironmentA = HEAP_strdupWtoA( GetProcessHeap(), 0, pEnvironment );
2288 ret = GetPrinterDriverDirectoryA( pNameA, pEnvironmentA, Level,
2289 pDriverDirectory, cbBuf, pcbNeeded );
2290 if(pNameA)
2291 HeapFree( GetProcessHeap(), 0, pNameA );
2292 if(pEnvironmentA)
2293 HeapFree( GetProcessHeap(), 0, pEnvironmentA );
2294
2295 return ret;
2296 }
2297
2298 /*****************************************************************************
2299 * AddPrinterDriverA [WINSPOOL.@]
2300 */
2301 BOOL WINAPI AddPrinterDriverA(LPSTR pName, DWORD level, LPBYTE pDriverInfo)
2302 {
2303 DRIVER_INFO_3A di3;
2304 HKEY hkeyDrivers, hkeyName;
2305
2306 TRACE("(%s,%ld,%p)\n",pName,level,pDriverInfo);
2307
2308 if(level != 2 && level != 3) {
2309 SetLastError(ERROR_INVALID_LEVEL);
2310 return FALSE;
2311 }
2312 if(pName != NULL) {
2313 FIXME("pName= `%s' - unsupported\n", pName);
2314 SetLastError(ERROR_INVALID_PARAMETER);
2315 return FALSE;
2316 }
2317 if(!pDriverInfo) {
2318 WARN("pDriverInfo == NULL\n");
2319 SetLastError(ERROR_INVALID_PARAMETER);
2320 return FALSE;
2321 }
2322
2323 if(level == 3)
2324 di3 = *(DRIVER_INFO_3A *)pDriverInfo;
2325 else {
2326 memset(&di3, 0, sizeof(di3));
2327 *(DRIVER_INFO_2A *)&di3 = *(DRIVER_INFO_2A *)pDriverInfo;
2328 }
2329
2330 if(!di3.pName || !di3.pDriverPath || !di3.pConfigFile ||
2331 !di3.pDataFile) {
2332 SetLastError(ERROR_INVALID_PARAMETER);
2333 return FALSE;
2334 }
2335 if(!di3.pDefaultDataType) di3.pDefaultDataType = "";
2336 if(!di3.pDependentFiles) di3.pDependentFiles = "\0";
2337 if(!di3.pHelpFile) di3.pHelpFile = "";
2338 if(!di3.pMonitorName) di3.pMonitorName = "";
2339
2340 hkeyDrivers = WINSPOOL_OpenDriverReg(di3.pEnvironment, FALSE);
2341
2342 if(!hkeyDrivers) {
2343 ERR("Can't create Drivers key\n");
2344 return FALSE;
2345 }
2346
2347 if(level == 2) { /* apparently can't overwrite with level2 */
2348 if(RegOpenKeyA(hkeyDrivers, di3.pName, &hkeyName) == ERROR_SUCCESS) {
2349 RegCloseKey(hkeyName);
2350 RegCloseKey(hkeyDrivers);
2351 WARN("Trying to create existing printer driver `%s'\n", di3.pName);
2352 SetLastError(ERROR_PRINTER_DRIVER_ALREADY_INSTALLED);
2353 return FALSE;
2354 }
2355 }
2356 if(RegCreateKeyA(hkeyDrivers, di3.pName, &hkeyName) != ERROR_SUCCESS) {
2357 RegCloseKey(hkeyDrivers);
2358 ERR("Can't create Name key\n");
2359 return FALSE;
2360 }
2361 RegSetValueExA(hkeyName, "Configuration File", 0, REG_SZ, di3.pConfigFile,
2362 0);
2363 RegSetValueExA(hkeyName, "Data File", 0, REG_SZ, di3.pDataFile, 0);
2364 RegSetValueExA(hkeyName, "Driver", 0, REG_SZ, di3.pDriverPath, 0);
2365 RegSetValueExA(hkeyName, "Version", 0, REG_DWORD, (LPSTR)&di3.cVersion,
2366 sizeof(DWORD));
2367 RegSetValueExA(hkeyName, "Datatype", 0, REG_SZ, di3.pDefaultDataType, 0);
2368 RegSetValueExA(hkeyName, "Dependent Files", 0, REG_MULTI_SZ,
2369 di3.pDependentFiles, 0);
2370 RegSetValueExA(hkeyName, "Help File", 0, REG_SZ, di3.pHelpFile, 0);
2371 RegSetValueExA(hkeyName, "Monitor", 0, REG_SZ, di3.pMonitorName, 0);
2372 RegCloseKey(hkeyName);
2373 RegCloseKey(hkeyDrivers);
2374
2375 return TRUE;
2376 }
2377 /*****************************************************************************
2378 * AddPrinterDriverW [WINSPOOL.@]
2379 */
2380 BOOL WINAPI AddPrinterDriverW(LPWSTR printerName,DWORD level,
2381 LPBYTE pDriverInfo)
2382 {
2383 FIXME("(%s,%ld,%p): stub\n",debugstr_w(printerName),
2384 level,pDriverInfo);
2385 return FALSE;
2386 }
2387
2388
2389 /*****************************************************************************
2390 * PrinterProperties [WINSPOOL.@]
2391 *
2392 * Displays a dialog to set the properties of the printer.
2393 *
2394 * RETURNS
2395 * nonzero on success or zero on failure
2396 *
2397 * BUGS
2398 * implemented as stub only
2399 */
2400 BOOL WINAPI PrinterProperties(HWND hWnd, /* [in] handle to parent window */
2401 HANDLE hPrinter /* [in] handle to printer object */
2402 ){
2403 FIXME("(%d,%d): stub\n", hWnd, hPrinter);
2404 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2405 return FALSE;
2406 }
2407
2408 /*****************************************************************************
2409 * EnumJobsA [WINSPOOL.@]
2410 *
2411 */
2412 BOOL WINAPI EnumJobsA(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
2413 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
2414 LPDWORD pcReturned)
2415 {
2416 FIXME("stub\n");
2417 if(pcbNeeded) *pcbNeeded = 0;
2418 if(pcReturned) *pcReturned = 0;
2419 return TRUE;
2420 }
2421
2422
2423 /*****************************************************************************
2424 * EnumJobsW [WINSPOOL.@]
2425 *
2426 */
2427 BOOL WINAPI EnumJobsW(HANDLE hPrinter, DWORD FirstJob, DWORD NoJobs,
2428 DWORD Level, LPBYTE pJob, DWORD cbBuf, LPDWORD pcbNeeded,
2429 LPDWORD pcReturned)
2430 {
2431 FIXME("stub\n");
2432 if(pcbNeeded) *pcbNeeded = 0;
2433 if(pcReturned) *pcReturned = 0;
2434 return TRUE;
2435 }
2436
2437 /*****************************************************************************
2438 * WINSPOOL_EnumPrinterDrivers [internal]
2439 *
2440 * Delivers information about all printer drivers installed on the
2441 * localhost or a given server
2442 *
2443 * RETURNS
2444 * nonzero on success or zero on failure. If the buffer for the returned
2445 * information is too small the function will return an error
2446 *
2447 * BUGS
2448 * - only implemented for localhost, foreign hosts will return an error
2449 */
2450 static BOOL WINSPOOL_EnumPrinterDrivers(LPWSTR pName, LPWSTR pEnvironment,
2451 DWORD Level, LPBYTE pDriverInfo,
2452 DWORD cbBuf, LPDWORD pcbNeeded,
2453 LPDWORD pcReturned, BOOL unicode)
2454
2455 { HKEY hkeyDrivers;
2456 DWORD i, needed, number = 0, size = 0;
2457 WCHAR DriverNameW[255];
2458 PBYTE ptr;
2459
2460 TRACE("%s,%s,%ld,%p,%ld,%d\n",
2461 debugstr_w(pName), debugstr_w(pEnvironment),
2462 Level, pDriverInfo, cbBuf, unicode);
2463
2464 /* check for local drivers */
2465 if(pName) {
2466 ERR("remote drivers unsupported! Current remote host is %s\n",
2467 debugstr_w(pName));
2468 return FALSE;
2469 }
2470
2471 /* check input parameter */
2472 if((Level < 1) || (Level > 3)) {
2473 ERR("unsupported level %ld \n", Level);
2474 return FALSE;
2475 }
2476
2477 /* initialize return values */
2478 if(pDriverInfo)
2479 memset( pDriverInfo, 0, cbBuf);
2480 *pcbNeeded = 0;
2481 *pcReturned = 0;
2482
2483 hkeyDrivers = WINSPOOL_OpenDriverReg(pEnvironment, TRUE);
2484 if(!hkeyDrivers) {
2485 ERR("Can't open Drivers key\n");
2486 return FALSE;
2487 }
2488
2489 if(RegQueryInfoKeyA(hkeyDrivers, NULL, NULL, NULL, &number, NULL, NULL,
2490 NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
2491 RegCloseKey(hkeyDrivers);
2492 ERR("Can't query Drivers key\n");
2493 return FALSE;
2494 }
2495 TRACE("Found %ld Drivers\n", number);
2496
2497 /* get size of single struct
2498 * unicode and ascii structure have the same size
2499 */
2500 switch (Level) {
2501 case 1:
2502 size = sizeof(DRIVER_INFO_1A);
2503 break;
2504 case 2:
2505 size = sizeof(DRIVER_INFO_2A);
2506 break;
2507 case 3:
2508 size = sizeof(DRIVER_INFO_3A);
2509 break;
2510 }
2511
2512 /* calculate required buffer size */
2513 *pcbNeeded = size * number;
2514
2515 for( i = 0, ptr = (pDriverInfo && (cbBuf >= size)) ? pDriverInfo : NULL ;
2516 i < number;
2517 i++, ptr = (ptr && (cbBuf >= size * i)) ? ptr + size : NULL) {
2518 if(RegEnumKeyW(hkeyDrivers, i, DriverNameW, sizeof(DriverNameW))
2519 != ERROR_SUCCESS) {
2520 ERR("Can't enum key number %ld\n", i);
2521 RegCloseKey(hkeyDrivers);
2522 return FALSE;
2523 }
2524 if(!WINSPOOL_GetDriverInfoFromReg(hkeyDrivers, DriverNameW,
2525 pEnvironment, Level, ptr,
2526 (cbBuf < *pcbNeeded) ? NULL : pDriverInfo + *pcbNeeded,
2527 (cbBuf < *pcbNeeded) ? 0 : cbBuf - *pcbNeeded,
2528 &needed, unicode)) {
2529 RegCloseKey(hkeyDrivers);
2530 return FALSE;
2531 }
2532 (*pcbNeeded) += needed;
2533 }
2534
2535 RegCloseKey(hkeyDrivers);
2536
2537 if(cbBuf < *pcbNeeded){
2538 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2539 return FALSE;
2540 }
2541
2542 return TRUE;
2543 }
2544
2545 /*****************************************************************************
2546 * EnumPrinterDriversW [WINSPOOL.@]
2547 *
2548 * see function EnumPrinterDrivers for RETURNS, BUGS
2549 */
2550 BOOL WINAPI EnumPrinterDriversW(LPWSTR pName, LPWSTR pEnvironment, DWORD Level,
2551 LPBYTE pDriverInfo, DWORD cbBuf,
2552 LPDWORD pcbNeeded, LPDWORD pcReturned)
2553 {
2554 return WINSPOOL_EnumPrinterDrivers(pName, pEnvironment, Level, pDriverInfo,
2555 cbBuf, pcbNeeded, pcReturned, TRUE);
2556 }
2557
2558 /*****************************************************************************
2559 * EnumPrinterDriversA [WINSPOOL.@]
2560 *
2561 * see function EnumPrinterDrivers for RETURNS, BUGS
2562 */
2563 BOOL WINAPI EnumPrinterDriversA(LPSTR pName, LPSTR pEnvironment, DWORD Level,
2564 LPBYTE pDriverInfo, DWORD cbBuf,
2565 LPDWORD pcbNeeded, LPDWORD pcReturned)
2566 { BOOL ret;
2567 WCHAR *pNameW = NULL, *pEnvironmentW = NULL;
2568
2569 if(pName)
2570 pNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, pName);
2571 if(pEnvironment)
2572 pEnvironmentW = HEAP_strdupAtoW(GetProcessHeap(), 0, pEnvironment);
2573
2574 ret = WINSPOOL_EnumPrinterDrivers(pNameW, pEnvironmentW, Level, pDriverInfo,
2575 cbBuf, pcbNeeded, pcReturned, FALSE);
2576 if(pNameW)
2577 HeapFree(GetProcessHeap(), 0, pNameW);
2578 if(pEnvironmentW)
2579 HeapFree(GetProcessHeap(), 0, pEnvironmentW);
2580
2581 return ret;
2582 }
2583
2584
2585 /******************************************************************************
2586 * EnumPortsA (WINSPOOL.@)
2587 */
2588 BOOL WINAPI EnumPortsA(LPSTR name,DWORD level,LPBYTE ports,DWORD bufsize,
2589 LPDWORD bufneeded,LPDWORD bufreturned)
2590 {
2591 FIXME("(%s,%ld,%p,%ld,%p,%p), stub!\n",name,level,ports,bufsize,bufneeded,bufreturned);
2592 return FALSE;
2593 }
2594
2595 /******************************************************************************
2596 * SetPrinterDataExA (WINSPOOL)
2597 */
2598 DWORD WINAPI SetPrinterDataExA(HANDLE hPrinter, LPSTR pKeyName,
2599 LPSTR pValueName, DWORD Type,
2600 LPBYTE pData, DWORD cbData)
2601 {
2602 HKEY hkeyPrinter, hkeySubkey;
2603 DWORD ret;
2604
2605 TRACE("(%08x, %s, %s %08lx, %p, %08lx)\n", hPrinter, debugstr_a(pKeyName),
2606 debugstr_a(pValueName), Type, pData, cbData);
2607
2608 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
2609 != ERROR_SUCCESS)
2610 return ret;
2611
2612 if((ret = RegCreateKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
2613 != ERROR_SUCCESS) {
2614 ERR("Can't create subkey %s\n", debugstr_a(pKeyName));
2615 RegCloseKey(hkeyPrinter);
2616 return ret;
2617 }
2618 ret = RegSetValueExA(hkeySubkey, pValueName, 0, Type, pData, cbData);
2619 RegCloseKey(hkeySubkey);
2620 RegCloseKey(hkeyPrinter);
2621 return ret;
2622 }
2623
2624 /******************************************************************************
2625 * SetPrinterDataExW (WINSPOOL)
2626 */
2627 DWORD WINAPI SetPrinterDataExW(HANDLE hPrinter, LPWSTR pKeyName,
2628 LPWSTR pValueName, DWORD Type,
2629 LPBYTE pData, DWORD cbData)
2630 {
2631 HKEY hkeyPrinter, hkeySubkey;
2632 DWORD ret;
2633
2634 TRACE("(%08x, %s, %s %08lx, %p, %08lx)\n", hPrinter, debugstr_w(pKeyName),
2635 debugstr_w(pValueName), Type, pData, cbData);
2636
2637 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
2638 != ERROR_SUCCESS)
2639 return ret;
2640
2641 if((ret = RegCreateKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
2642 != ERROR_SUCCESS) {
2643 ERR("Can't create subkey %s\n", debugstr_w(pKeyName));
2644 RegCloseKey(hkeyPrinter);
2645 return ret;
2646 }
2647 ret = RegSetValueExW(hkeySubkey, pValueName, 0, Type, pData, cbData);
2648 RegCloseKey(hkeySubkey);
2649 RegCloseKey(hkeyPrinter);
2650 return ret;
2651 }
2652
2653 /******************************************************************************
2654 * SetPrinterDataA (WINSPOOL)
2655 */
2656 DWORD WINAPI SetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, DWORD Type,
2657 LPBYTE pData, DWORD cbData)
2658 {
2659 return SetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, Type,
2660 pData, cbData);
2661 }
2662
2663 /******************************************************************************
2664 * SetPrinterDataW (WINSPOOL)
2665 */
2666 DWORD WINAPI SetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, DWORD Type,
2667 LPBYTE pData, DWORD cbData)
2668 {
2669 return SetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, Type,
2670 pData, cbData);
2671 }
2672
2673 /******************************************************************************
2674 * GetPrinterDataExA (WINSPOOL)
2675 */
2676 DWORD WINAPI GetPrinterDataExA(HANDLE hPrinter, LPSTR pKeyName,
2677 LPSTR pValueName, LPDWORD pType,
2678 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
2679 {
2680 HKEY hkeyPrinter, hkeySubkey;
2681 DWORD ret;
2682
2683 TRACE("(%08x, %s, %s %p, %p, %08lx, %p)\n", hPrinter,
2684 debugstr_a(pKeyName), debugstr_a(pValueName), pType, pData, nSize,
2685 pcbNeeded);
2686
2687 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
2688 != ERROR_SUCCESS)
2689 return ret;
2690
2691 if((ret = RegOpenKeyA(hkeyPrinter, pKeyName, &hkeySubkey))
2692 != ERROR_SUCCESS) {
2693 WARN("Can't open subkey %s\n", debugstr_a(pKeyName));
2694 RegCloseKey(hkeyPrinter);
2695 return ret;
2696 }
2697 *pcbNeeded = nSize;
2698 ret = RegQueryValueExA(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
2699 RegCloseKey(hkeySubkey);
2700 RegCloseKey(hkeyPrinter);
2701 return ret;
2702 }
2703
2704 /******************************************************************************
2705 * GetPrinterDataExW (WINSPOOL)
2706 */
2707 DWORD WINAPI GetPrinterDataExW(HANDLE hPrinter, LPWSTR pKeyName,
2708 LPWSTR pValueName, LPDWORD pType,
2709 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
2710 {
2711 HKEY hkeyPrinter, hkeySubkey;
2712 DWORD ret;
2713
2714 TRACE("(%08x, %s, %s %p, %p, %08lx, %p)\n", hPrinter,
2715 debugstr_w(pKeyName), debugstr_w(pValueName), pType, pData, nSize,
2716 pcbNeeded);
2717
2718 if((ret = WINSPOOL_GetOpenedPrinterRegKey(hPrinter, &hkeyPrinter))
2719 != ERROR_SUCCESS)
2720 return ret;
2721
2722 if((ret = RegOpenKeyW(hkeyPrinter, pKeyName, &hkeySubkey))
2723 != ERROR_SUCCESS) {
2724 WARN("Can't open subkey %s\n", debugstr_w(pKeyName));
2725 RegCloseKey(hkeyPrinter);
2726 return ret;
2727 }
2728 *pcbNeeded = nSize;
2729 ret = RegQueryValueExW(hkeySubkey, pValueName, 0, pType, pData, pcbNeeded);
2730 RegCloseKey(hkeySubkey);
2731 RegCloseKey(hkeyPrinter);
2732 return ret;
2733 }
2734
2735 /******************************************************************************
2736 * GetPrinterDataA (WINSPOOL)
2737 */
2738 DWORD WINAPI GetPrinterDataA(HANDLE hPrinter, LPSTR pValueName, LPDWORD pType,
2739 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
2740 {
2741 return GetPrinterDataExA(hPrinter, "PrinterDriverData", pValueName, pType,
2742 pData, nSize, pcbNeeded);
2743 }
2744
2745 /******************************************************************************
2746 * GetPrinterDataW (WINSPOOL)
2747 */
2748 DWORD WINAPI GetPrinterDataW(HANDLE hPrinter, LPWSTR pValueName, LPDWORD pType,
2749 LPBYTE pData, DWORD nSize, LPDWORD pcbNeeded)
2750 {
2751 return GetPrinterDataExW(hPrinter, PrinterDriverDataW, pValueName, pType,
2752 pData, nSize, pcbNeeded);
2753 }
2754
2755 /*******************************************************************************
2756 * EnumPrinterDataExW [WINSPOOL.@]
2757 */
2758 DWORD WINAPI EnumPrinterDataExW(HANDLE hPrinter, LPCWSTR pKeyName,
2759 LPBYTE pEnumValues, DWORD cbEnumValues,
2760 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
2761 {
2762 HKEY hkPrinter, hkSubKey;
2763 DWORD r, ret, dwIndex, cValues, cbMaxValueNameLen,
2764 cbValueNameLen, cbMaxValueLen, cbValueLen,
2765 cbBufSize, dwType;
2766 LPWSTR lpValueName;
2767 HANDLE hHeap;
2768 PBYTE lpValue;
2769 PPRINTER_ENUM_VALUESW ppev;
2770
2771 TRACE ("%08x %s\n", hPrinter, debugstr_w (pKeyName));
2772
2773 if (pKeyName == NULL || *pKeyName == 0)
2774 return ERROR_INVALID_PARAMETER;
2775
2776 ret = WINSPOOL_GetOpenedPrinterRegKey (hPrinter, &hkPrinter);
2777 if (ret != ERROR_SUCCESS)
2778 {
2779 TRACE ("WINSPOOL_GetOpenedPrinterRegKey (%08x) returned %li\n",
2780 hPrinter, ret);
2781 return ret;
2782 }
2783
2784 ret = RegOpenKeyExW (hkPrinter, pKeyName, 0, KEY_READ, &hkSubKey);
2785 if (ret != ERROR_SUCCESS)
2786 {
2787 r = RegCloseKey (hkPrinter);
2788 if (r != ERROR_SUCCESS)
2789 WARN ("RegCloseKey returned %li\n", r);
2790 TRACE ("RegOpenKeyExW (%08x, %s) returned %li\n", hPrinter,
2791 debugstr_w (pKeyName), ret);
2792 return ret;
2793 }
2794
2795 ret = RegCloseKey (hkPrinter);
2796 if (ret != ERROR_SUCCESS)
2797 {
2798 ERR ("RegCloseKey returned %li\n", ret);
2799 r = RegCloseKey (hkSubKey);
2800 if (r != ERROR_SUCCESS)
2801 WARN ("RegCloseKey returned %li\n", r);
2802 return ret;
2803 }
2804
2805 ret = RegQueryInfoKeyW (hkSubKey, NULL, NULL, NULL, NULL, NULL, NULL,
2806 &cValues, &cbMaxValueNameLen, &cbMaxValueLen, NULL, NULL);
2807 if (ret != ERROR_SUCCESS)
2808 {
2809 r = RegCloseKey (hkSubKey);
2810 if (r != ERROR_SUCCESS)
2811 WARN ("RegCloseKey returned %li\n", r);
2812 TRACE ("RegQueryInfoKeyW (%08x) returned %li\n", hkSubKey, ret);
2813 return ret;
2814 }
2815
2816 TRACE ("RegQueryInfoKeyW returned cValues = %li, cbMaxValueNameLen = %li, "
2817 "cbMaxValueLen = %li\n", cValues, cbMaxValueNameLen, cbMaxValueLen);
2818
2819 if (cValues == 0) /* empty key */
2820 {
2821 r = RegCloseKey (hkSubKey);
2822 if (r != ERROR_SUCCESS)
2823 WARN ("RegCloseKey returned %li\n", r);
2824 *pcbEnumValues = *pnEnumValues = 0;
2825 return ERROR_SUCCESS;
2826 }
2827
2828 ++cbMaxValueNameLen; /* allow for trailing '\0' */
2829
2830 hHeap = GetProcessHeap ();
2831 if (hHeap == (HANDLE) NULL)
2832 {
2833 ERR ("GetProcessHeap failed\n");
2834 r = RegCloseKey (hkSubKey);
2835 if (r != ERROR_SUCCESS)
2836 WARN ("RegCloseKey returned %li\n", r);
2837 return ERROR_OUTOFMEMORY;
2838 }
2839
2840 lpValueName = HeapAlloc (hHeap, 0, cbMaxValueNameLen * sizeof (WCHAR));
2841 if (lpValueName == NULL)
2842 {
2843 ERR ("Failed to allocate %li bytes from process heap\n",
2844 cbMaxValueNameLen * sizeof (WCHAR));
2845 r = RegCloseKey (hkSubKey);
2846 if (r != ERROR_SUCCESS)
2847 WARN ("RegCloseKey returned %li\n", r);
2848 return ERROR_OUTOFMEMORY;
2849 }
2850
2851 lpValue = HeapAlloc (hHeap, 0, cbMaxValueLen);
2852 if (lpValue == NULL)
2853 {
2854 ERR ("Failed to allocate %li bytes from process heap\n", cbMaxValueLen);
2855 if (HeapFree (hHeap, 0, lpValueName) == 0)
2856 WARN ("HeapFree failed with code %li\n", GetLastError ());
2857 r = RegCloseKey (hkSubKey);
2858 if (r != ERROR_SUCCESS)
2859 WARN ("RegCloseKey returned %li\n", r);
2860 return ERROR_OUTOFMEMORY;
2861 }
2862
2863 TRACE ("pass 1: calculating buffer required for all names and values\n");
2864
2865 cbBufSize = cValues * sizeof (PRINTER_ENUM_VALUESW);
2866
2867 TRACE ("%li bytes required for %li headers\n", cbBufSize, cValues);
2868
2869 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
2870 {
2871 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
2872 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
2873 NULL, NULL, lpValue, &cbValueLen);
2874 if (ret != ERROR_SUCCESS)
2875 {
2876 if (HeapFree (hHeap, 0, lpValue) == 0)
2877 WARN ("HeapFree failed with code %li\n", GetLastError ());
2878 if (HeapFree (hHeap, 0, lpValueName) == 0)
2879 WARN ("HeapFree failed with code %li\n", GetLastError ());
2880 r = RegCloseKey (hkSubKey);
2881 if (r != ERROR_SUCCESS)
2882 WARN ("RegCloseKey returned %li\n", r);
2883 TRACE ("RegEnumValueW (%li) returned %li\n", dwIndex, ret);
2884 return ret;
2885 }
2886
2887 TRACE ("%s [%li]: name needs %li bytes, data needs %li bytes\n",
2888 debugstr_w (lpValueName), dwIndex,
2889 (cbValueNameLen + 1) * sizeof (WCHAR), cbValueLen);
2890
2891 cbBufSize += (cbValueNameLen + 1) * sizeof (WCHAR);
2892 cbBufSize += cbValueLen;
2893 }
2894
2895 TRACE ("%li bytes required for all %li values\n", cbBufSize, cValues);
2896
2897 *pcbEnumValues = cbBufSize;
2898 *pnEnumValues = cValues;
2899
2900 if (cbEnumValues < cbBufSize) /* buffer too small */
2901 {
2902 if (HeapFree (hHeap, 0, lpValue) == 0)
2903 WARN ("HeapFree failed with code %li\n", GetLastError ());
2904 if (HeapFree (hHeap, 0, lpValueName) == 0)
2905 WARN ("HeapFree failed with code %li\n", GetLastError ());
2906 r = RegCloseKey (hkSubKey);
2907 if (r != ERROR_SUCCESS)
2908 WARN ("RegCloseKey returned %li\n", r);
2909 TRACE ("%li byte buffer is not large enough\n", cbEnumValues);
2910 return ERROR_MORE_DATA;
2911 }
2912
2913 TRACE ("pass 2: copying all names and values to buffer\n");
2914
2915 ppev = (PPRINTER_ENUM_VALUESW) pEnumValues; /* array of structs */
2916 pEnumValues += cValues * sizeof (PRINTER_ENUM_VALUESW);
2917
2918 for (dwIndex = 0; dwIndex < cValues; ++dwIndex)
2919 {
2920 cbValueNameLen = cbMaxValueNameLen; cbValueLen = cbMaxValueLen;
2921 ret = RegEnumValueW (hkSubKey, dwIndex, lpValueName, &cbValueNameLen,
2922 NULL, &dwType, lpValue, &cbValueLen);
2923 if (ret != ERROR_SUCCESS)
2924 {
2925 if (HeapFree (hHeap, 0, lpValue) == 0)
2926 WARN ("HeapFree failed with code %li\n", GetLastError ());
2927 if (HeapFree (hHeap, 0, lpValueName) == 0)
2928 WARN ("HeapFree failed with code %li\n", GetLastError ());
2929 r = RegCloseKey (hkSubKey);
2930 if (r != ERROR_SUCCESS)
2931 WARN ("RegCloseKey returned %li\n", r);
2932 TRACE ("RegEnumValueW (%li) returned %li\n", dwIndex, ret);
2933 return ret;
2934 }
2935
2936 cbValueNameLen = (cbValueNameLen + 1) * sizeof (WCHAR);
2937 memcpy (pEnumValues, lpValueName, cbValueNameLen);
2938 ppev[dwIndex].pValueName = (LPWSTR) pEnumValues;
2939 pEnumValues += cbValueNameLen;
2940
2941 /* return # of *bytes* (including trailing \0), not # of chars */
2942 ppev[dwIndex].cbValueName = cbValueNameLen;
2943
2944 ppev[dwIndex].dwType = dwType;
2945
2946 memcpy (pEnumValues, lpValue, cbValueLen);
2947 ppev[dwIndex].pData = pEnumValues;
2948 pEnumValues += cbValueLen;
2949
2950 ppev[dwIndex].cbData = cbValueLen;
2951
2952 TRACE ("%s [%li]: copied name (%li bytes) and data (%li bytes)\n",
2953 debugstr_w (lpValueName), dwIndex, cbValueNameLen, cbValueLen);
2954 }
2955
2956 if (HeapFree (hHeap, 0, lpValue) == 0)
2957 {
2958 ret = GetLastError ();
2959 ERR ("HeapFree failed with code %li\n", ret);
2960 if (HeapFree (hHeap, 0, lpValueName) == 0)
2961 WARN ("HeapFree failed with code %li\n", GetLastError ());
2962 r = RegCloseKey (hkSubKey);
2963 if (r != ERROR_SUCCESS)
2964 WARN ("RegCloseKey returned %li\n", r);
2965 return ret;
2966 }
2967
2968 if (HeapFree (hHeap, 0, lpValueName) == 0)
2969 {
2970 ret = GetLastError ();
2971 ERR ("HeapFree failed with code %li\n", ret);
2972 r = RegCloseKey (hkSubKey);
2973 if (r != ERROR_SUCCESS)
2974 WARN ("RegCloseKey returned %li\n", r);
2975 return ret;
2976 }
2977
2978 ret = RegCloseKey (hkSubKey);
2979 if (ret != ERROR_SUCCESS)
2980 {
2981 ERR ("RegCloseKey returned %li\n", ret);
2982 return ret;
2983 }
2984
2985 return ERROR_SUCCESS;
2986 }
2987
2988 /*******************************************************************************
2989 * EnumPrinterDataExA [WINSPOOL.@]
2990 *
2991 * This functions returns value names and REG_SZ, REG_EXPAND_SZ, and
2992 * REG_MULTI_SZ values as ASCII strings in Unicode-sized buffers. This is
2993 * what Windows 2000 SP1 does.
2994 *
2995 */
2996 DWORD WINAPI EnumPrinterDataExA(HANDLE hPrinter, LPCSTR pKeyName,
2997 LPBYTE pEnumValues, DWORD cbEnumValues,
2998 LPDWORD pcbEnumValues, LPDWORD pnEnumValues)
2999 {
3000 INT len;
3001 LPWSTR pKeyNameW;
3002 DWORD ret, dwIndex, dwBufSize;
3003 HANDLE hHeap;
3004 LPSTR pBuffer;
3005
3006 TRACE ("%08x %s\n", hPrinter, pKeyName);
3007
3008 if (pKeyName == NULL || *pKeyName == 0)
3009 return ERROR_INVALID_PARAMETER;
3010
3011 len = MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, NULL, 0);
3012 if (len == 0)
3013 {
3014 ret = GetLastError ();
3015 ERR ("MultiByteToWideChar failed with code %li\n", ret);
3016 return ret;
3017 }
3018
3019 hHeap = GetProcessHeap ();
3020 if (hHeap == (HANDLE) NULL)
3021 {
3022 ERR ("GetProcessHeap failed\n");
3023 return ERROR_OUTOFMEMORY;
3024 }
3025
3026 pKeyNameW = HeapAlloc (hHeap, 0, len * sizeof (WCHAR));
3027 if (pKeyNameW == NULL)
3028 {
3029 ERR ("Failed to allocate %li bytes from process heap\n",
3030 (LONG) len * sizeof (WCHAR));
3031 return ERROR_OUTOFMEMORY;
3032 }
3033
3034 if (MultiByteToWideChar (CP_ACP, 0, pKeyName, -1, pKeyNameW, len) == 0)
3035 {
3036 ret = GetLastError ();
3037 ERR ("MultiByteToWideChar failed with code %li\n", ret);
3038 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
3039 WARN ("HeapFree failed with code %li\n", GetLastError ());
3040 return ret;
3041 }
3042
3043 ret = EnumPrinterDataExW (hPrinter, pKeyNameW, pEnumValues, cbEnumValues,
3044 pcbEnumValues, pnEnumValues);
3045 if (ret != ERROR_SUCCESS)
3046 {
3047 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
3048 WARN ("HeapFree failed with code %li\n", GetLastError ());
3049 TRACE ("EnumPrinterDataExW returned %li\n", ret);
3050 return ret;
3051 }
3052
3053 if (HeapFree (hHeap, 0, pKeyNameW) == 0)
3054 {
3055 ret = GetLastError ();
3056 ERR ("HeapFree failed with code %li\n", ret);
3057 return ret;
3058 }
3059
3060 if (*pnEnumValues == 0) /* empty key */
3061 return ERROR_SUCCESS;
3062
3063 dwBufSize = 0;
3064 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
3065 {
3066 PPRINTER_ENUM_VALUESW ppev =
3067 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
3068
3069 if (dwBufSize < ppev->cbValueName)
3070 dwBufSize = ppev->cbValueName;
3071
3072 if (dwBufSize < ppev->cbData && (ppev->dwType == REG_SZ ||
3073 ppev->dwType == REG_EXPAND_SZ || ppev->dwType == REG_MULTI_SZ))
3074 dwBufSize = ppev->cbData;
3075 }
3076
3077 TRACE ("Largest Unicode name or value is %li bytes\n", dwBufSize);
3078
3079 pBuffer = HeapAlloc (hHeap, 0, dwBufSize);
3080 if (pBuffer == NULL)
3081 {
3082 ERR ("Failed to allocate %li bytes from process heap\n", dwBufSize);
3083 return ERROR_OUTOFMEMORY;
3084 }
3085
3086 for (dwIndex = 0; dwIndex < *pnEnumValues; ++dwIndex)
3087 {
3088 PPRINTER_ENUM_VALUESW ppev =
3089 &((PPRINTER_ENUM_VALUESW) pEnumValues)[dwIndex];
3090
3091 len = WideCharToMultiByte (CP_ACP, 0, ppev->pValueName,
3092 ppev->cbValueName / sizeof (WCHAR), pBuffer, dwBufSize, NULL,
3093 NULL);
3094 if (len == 0)
3095 {
3096 ret = GetLastError ();
3097 ERR ("WideCharToMultiByte failed with code %li\n", ret);
3098 if (HeapFree (hHeap, 0, pBuffer) == 0)
3099 WARN ("HeapFree failed with code %li\n", GetLastError ());
3100 return ret;
3101 }
3102
3103 memcpy (ppev->pValueName, pBuffer, len);
3104
3105 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
3106
3107 if (ppev->dwType != REG_SZ && ppev->dwType != REG_EXPAND_SZ &&
3108 ppev->dwType != REG_MULTI_SZ)
3109 continue;
3110
3111 len = WideCharToMultiByte (CP_ACP, 0, (LPWSTR) ppev->pData,
3112 ppev->cbData / sizeof (WCHAR), pBuffer, dwBufSize, NULL, NULL);
3113 if (len == 0)
3114 {
3115 ret = GetLastError ();
3116 ERR ("WideCharToMultiByte failed with code %li\n", ret);
3117 if (HeapFree (hHeap, 0, pBuffer) == 0)
3118 WARN ("HeapFree failed with code %li\n", GetLastError ());
3119 return ret;
3120 }
3121
3122 memcpy (ppev->pData, pBuffer, len);
3123
3124 TRACE ("Converted '%s' from Unicode to ASCII\n", pBuffer);
3125 TRACE (" (only first string of REG_MULTI_SZ printed)\n");
3126 }
3127
3128 if (HeapFree (hHeap, 0, pBuffer) == 0)
3129 {
3130 ret = GetLastError ();
3131 ERR ("HeapFree failed with code %li\n", ret);
3132 return ret;
3133 }
3134
3135 return ERROR_SUCCESS;
3136 }