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