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