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