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