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