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