?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
inetcomm: Add an implementation of IPOP3Transport::CommandSTAT.
[wine/multimedia.git] / dlls / localspl / localspl_main.c
blob80e84243cc6be4a1326f2577c4b249b28f7c7671
1 /*
2 * Implementation of the Local Printmonitor
3 *
4 * Copyright 2006-2008 Detlef Riekenberg
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "wingdi.h"
29 #include "winreg.h"
30 #include "winspool.h"
31 #include "ddk/winsplp.h"
32 #include "winuser.h"
33
34 #include "wine/list.h"
35 #include "wine/debug.h"
36 #include "wine/unicode.h"
37 #include "localspl_private.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(localspl);
40
41 /* ############################### */
42
43 static CRITICAL_SECTION monitor_handles_cs;
44 static CRITICAL_SECTION_DEBUG monitor_handles_cs_debug =
45 {
46 0, 0, &monitor_handles_cs,
47 { &monitor_handles_cs_debug.ProcessLocksList, &monitor_handles_cs_debug.ProcessLocksList },
48 0, 0, { (DWORD_PTR)(__FILE__ ": monitor_handles_cs") }
49 };
50 static CRITICAL_SECTION monitor_handles_cs = { &monitor_handles_cs_debug, -1, 0, 0, 0, 0 };
51
52 /* ############################### */
53
54 typedef struct {
55 WCHAR src[MAX_PATH+MAX_PATH];
56 WCHAR dst[MAX_PATH+MAX_PATH];
57 DWORD srclen;
58 DWORD dstlen;
59 DWORD copyflags;
60 BOOL lazy;
61 } apd_data_t;
62
63 typedef struct {
64 struct list entry;
65 LPWSTR name;
66 LPWSTR dllname;
67 PMONITORUI monitorUI;
68 LPMONITOR monitor;
69 HMODULE hdll;
70 DWORD refcount;
71 DWORD dwMonitorSize;
72 } monitor_t;
73
74 typedef struct {
75 LPCWSTR envname;
76 LPCWSTR subdir;
77 DWORD driverversion;
78 LPCWSTR versionregpath;
79 LPCWSTR versionsubdir;
80 } printenv_t;
81
82
83 /* ############################### */
84
85 static struct list monitor_handles = LIST_INIT( monitor_handles );
86 static monitor_t * pm_localport;
87
88 HINSTANCE LOCALSPL_hInstance = NULL;
89
90 static const PRINTPROVIDOR * pp = NULL;
91
92 static const WCHAR backslashW[] = {'\\',0};
93 static const WCHAR configuration_fileW[] = {'C','o','n','f','i','g','u','r','a','t','i','o','n',' ','F','i','l','e',0};
94 static const WCHAR datatypeW[] = {'D','a','t','a','t','y','p','e',0};
95 static const WCHAR data_fileW[] = {'D','a','t','a',' ','F','i','l','e',0};
96 static const WCHAR default_devmodeW[] = {'D','e','f','a','u','l','t',' ','D','e','v','M','o','d','e',0};
97 static const WCHAR dependent_filesW[] = {'D','e','p','e','n','d','e','n','t',' ','F','i','l','e','s',0};
98 static const WCHAR descriptionW[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
99 static const WCHAR driverW[] = {'D','r','i','v','e','r',0};
100 static const WCHAR fmt_driversW[] = { 'S','y','s','t','e','m','\\',
101 'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
102 'c','o','n','t','r','o','l','\\',
103 'P','r','i','n','t','\\',
104 'E','n','v','i','r','o','n','m','e','n','t','s','\\',
105 '%','s','\\','D','r','i','v','e','r','s','%','s',0 };
106 static const WCHAR hardwareidW[] = {'H','a','r','d','w','a','r','e','I','D',0};
107 static const WCHAR help_fileW[] = {'H','e','l','p',' ','F','i','l','e',0};
108 static const WCHAR localportW[] = {'L','o','c','a','l',' ','P','o','r','t',0};
109 static const WCHAR locationW[] = {'L','o','c','a','t','i','o','n',0};
110 static const WCHAR manufacturerW[] = {'M','a','n','u','f','a','c','t','u','r','e','r',0};
111 static const WCHAR monitorW[] = {'M','o','n','i','t','o','r',0};
112 static const WCHAR monitorsW[] = {'S','y','s','t','e','m','\\',
113 'C','u', 'r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
114 'C','o','n','t','r','o','l','\\',
115 'P','r','i','n','t','\\',
116 'M','o','n','i','t','o','r','s','\\',0};
117 static const WCHAR monitorUIW[] = {'M','o','n','i','t','o','r','U','I',0};
118 static const WCHAR nameW[] = {'N','a','m','e',0};
119 static const WCHAR oem_urlW[] = {'O','E','M',' ','U','r','l',0};
120 static const WCHAR parametersW[] = {'P','a','r','a','m','e','t','e','r','s',0};
121 static const WCHAR portW[] = {'P','o','r','t',0};
122 static const WCHAR previous_namesW[] = {'P','r','e','v','i','o','u','s',' ','N','a','m','e','s',0};
123 static const WCHAR spooldriversW[] = {'\\','s','p','o','o','l','\\','d','r','i','v','e','r','s','\\',0};
124 static const WCHAR versionW[] = {'V','e','r','s','i','o','n',0};
125
126 static const WCHAR win40_envnameW[] = {'W','i','n','d','o','w','s',' ','4','.','0',0};
127 static const WCHAR win40_subdirW[] = {'w','i','n','4','0',0};
128 static const WCHAR version0_regpathW[] = {'\\','V','e','r','s','i','o','n','-','0',0};
129 static const WCHAR version0_subdirW[] = {'\\','0',0};
130
131 static const WCHAR x86_envnameW[] = {'W','i','n','d','o','w','s',' ','N','T',' ','x','8','6',0};
132 static const WCHAR x86_subdirW[] = {'w','3','2','x','8','6',0};
133 static const WCHAR version3_regpathW[] = {'\\','V','e','r','s','i','o','n','-','3',0};
134 static const WCHAR version3_subdirW[] = {'\\','3',0};
135
136
137 static const printenv_t env_x86 = {x86_envnameW, x86_subdirW, 3,
138 version3_regpathW, version3_subdirW};
139
140 static const printenv_t env_win40 = {win40_envnameW, win40_subdirW, 0,
141 version0_regpathW, version0_subdirW};
142
143 static const printenv_t * const all_printenv[] = {&env_x86, &env_win40};
144
145
146 static const DWORD di_sizeof[] = {0, sizeof(DRIVER_INFO_1W), sizeof(DRIVER_INFO_2W),
147 sizeof(DRIVER_INFO_3W), sizeof(DRIVER_INFO_4W),
148 sizeof(DRIVER_INFO_5W), sizeof(DRIVER_INFO_6W),
149 0, sizeof(DRIVER_INFO_8W)};
150
151
152 /******************************************************************
153 * strdupW [internal]
154 *
155 * create a copy of a unicode-string
156 *
157 */
158
159 static LPWSTR strdupW(LPCWSTR p)
160 {
161 LPWSTR ret;
162 DWORD len;
163
164 if(!p) return NULL;
165 len = (lstrlenW(p) + 1) * sizeof(WCHAR);
166 ret = heap_alloc(len);
167 memcpy(ret, p, len);
168 return ret;
169 }
170
171 /******************************************************************
172 * apd_copyfile [internal]
173 *
174 * Copy a file from the driverdirectory to the versioned directory
175 *
176 * RETURNS
177 * Success: TRUE
178 * Failure: FALSE
179 *
180 */
181 static BOOL apd_copyfile(LPWSTR filename, apd_data_t *apd)
182 {
183 LPWSTR ptr;
184 LPWSTR srcname;
185 DWORD res;
186
187 apd->src[apd->srclen] = '\0';
188 apd->dst[apd->dstlen] = '\0';
189
190 if (!filename || !filename[0]) {
191 /* nothing to copy */
192 return TRUE;
193 }
194
195 ptr = strrchrW(filename, '\\');
196 if (ptr) {
197 ptr++;
198 }
199 else
200 {
201 ptr = filename;
202 }
203
204 if (apd->copyflags & APD_COPY_FROM_DIRECTORY) {
205 /* we have an absolute Path */
206 srcname = filename;
207 }
208 else
209 {
210 srcname = apd->src;
211 lstrcatW(srcname, ptr);
212 }
213 lstrcatW(apd->dst, ptr);
214
215 TRACE("%s => %s\n", debugstr_w(filename), debugstr_w(apd->dst));
216
217 /* FIXME: handle APD_COPY_NEW_FILES */
218 res = CopyFileW(srcname, apd->dst, FALSE);
219 TRACE("got %u with %u\n", res, GetLastError());
220
221 return (apd->lazy) ? TRUE : res;
222 }
223
224 /******************************************************************
225 * copy_servername_from_name (internal)
226 *
227 * for an external server, the serverpart from the name is copied.
228 *
229 * RETURNS
230 * the length (in WCHAR) of the serverpart (0 for the local computer)
231 * (-length), when the name is to long
232 *
233 */
234 static LONG copy_servername_from_name(LPCWSTR name, LPWSTR target)
235 {
236 LPCWSTR server;
237 LPWSTR ptr;
238 WCHAR buffer[MAX_COMPUTERNAME_LENGTH +1];
239 DWORD len;
240 DWORD serverlen;
241
242 if (target) *target = '\0';
243
244 if (name == NULL) return 0;
245 if ((name[0] != '\\') || (name[1] != '\\')) return 0;
246
247 server = &name[2];
248 /* skip over both backslash, find separator '\' */
249 ptr = strchrW(server, '\\');
250 serverlen = (ptr) ? ptr - server : lstrlenW(server);
251
252 /* servername is empty or to long */
253 if (serverlen == 0) return 0;
254
255 TRACE("found %s\n", debugstr_wn(server, serverlen));
256
257 if (serverlen > MAX_COMPUTERNAME_LENGTH) return -serverlen;
258
259 len = sizeof(buffer) / sizeof(buffer[0]);
260 if (GetComputerNameW(buffer, &len)) {
261 if ((serverlen == len) && (strncmpiW(server, buffer, len) == 0)) {
262 /* The requested Servername is our computername */
263 if (target) {
264 memcpy(target, server, serverlen * sizeof(WCHAR));
265 target[serverlen] = '\0';
266 }
267 return serverlen;
268 }
269 }
270 return 0;
271 }
272
273 /******************************************************************
274 * monitor_unload [internal]
275 *
276 * release a printmonitor and unload it from memory, when needed
277 *
278 */
279 static void monitor_unload(monitor_t * pm)
280 {
281 if (pm == NULL) return;
282 TRACE("%p (refcount: %d) %s\n", pm, pm->refcount, debugstr_w(pm->name));
283
284 EnterCriticalSection(&monitor_handles_cs);
285
286 if (pm->refcount) pm->refcount--;
287
288 if (pm->refcount == 0) {
289 list_remove(&pm->entry);
290 FreeLibrary(pm->hdll);
291 heap_free(pm->name);
292 heap_free(pm->dllname);
293 heap_free(pm);
294 }
295 LeaveCriticalSection(&monitor_handles_cs);
296 }
297
298 /******************************************************************
299 * monitor_load [internal]
300 *
301 * load a printmonitor, get the dllname from the registry, when needed
302 * initialize the monitor and dump found function-pointers
303 *
304 * On failure, SetLastError() is called and NULL is returned
305 */
306
307 static monitor_t * monitor_load(LPCWSTR name, LPWSTR dllname)
308 {
309 LPMONITOR2 (WINAPI *pInitializePrintMonitor2) (PMONITORINIT, LPHANDLE);
310 PMONITORUI (WINAPI *pInitializePrintMonitorUI)(VOID);
311 LPMONITOREX (WINAPI *pInitializePrintMonitor) (LPWSTR);
312 DWORD (WINAPI *pInitializeMonitorEx)(LPWSTR, LPMONITOR);
313 DWORD (WINAPI *pInitializeMonitor) (LPWSTR);
314
315 monitor_t * pm = NULL;
316 monitor_t * cursor;
317 LPWSTR regroot = NULL;
318 LPWSTR driver = dllname;
319
320 TRACE("(%s, %s)\n", debugstr_w(name), debugstr_w(dllname));
321 /* Is the Monitor already loaded? */
322 EnterCriticalSection(&monitor_handles_cs);
323
324 if (name) {
325 LIST_FOR_EACH_ENTRY(cursor, &monitor_handles, monitor_t, entry)
326 {
327 if (cursor->name && (lstrcmpW(name, cursor->name) == 0)) {
328 pm = cursor;
329 break;
330 }
331 }
332 }
333
334 if (pm == NULL) {
335 pm = heap_alloc_zero(sizeof(monitor_t));
336 if (pm == NULL) goto cleanup;
337 list_add_tail(&monitor_handles, &pm->entry);
338 }
339 pm->refcount++;
340
341 if (pm->name == NULL) {
342 /* Load the monitor */
343 LPMONITOREX pmonitorEx;
344 DWORD len;
345
346 if (name) {
347 len = lstrlenW(monitorsW) + lstrlenW(name) + 2;
348 regroot = heap_alloc(len * sizeof(WCHAR));
349 }
350
351 if (regroot) {
352 lstrcpyW(regroot, monitorsW);
353 lstrcatW(regroot, name);
354 /* Get the Driver from the Registry */
355 if (driver == NULL) {
356 HKEY hroot;
357 DWORD namesize;
358 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, regroot, &hroot) == ERROR_SUCCESS) {
359 if (RegQueryValueExW(hroot, driverW, NULL, NULL, NULL,
360 &namesize) == ERROR_SUCCESS) {
361 driver = heap_alloc(namesize);
362 RegQueryValueExW(hroot, driverW, NULL, NULL, (LPBYTE) driver, &namesize) ;
363 }
364 RegCloseKey(hroot);
365 }
366 }
367 }
368
369 pm->name = strdupW(name);
370 pm->dllname = strdupW(driver);
371
372 if ((name && (!regroot || !pm->name)) || !pm->dllname) {
373 monitor_unload(pm);
374 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
375 pm = NULL;
376 goto cleanup;
377 }
378
379 pm->hdll = LoadLibraryW(driver);
380 TRACE("%p: LoadLibrary(%s) => %d\n", pm->hdll, debugstr_w(driver), GetLastError());
381
382 if (pm->hdll == NULL) {
383 monitor_unload(pm);
384 SetLastError(ERROR_MOD_NOT_FOUND);
385 pm = NULL;
386 goto cleanup;
387 }
388
389 pInitializePrintMonitor2 = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor2");
390 pInitializePrintMonitorUI = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitorUI");
391 pInitializePrintMonitor = (void *)GetProcAddress(pm->hdll, "InitializePrintMonitor");
392 pInitializeMonitorEx = (void *)GetProcAddress(pm->hdll, "InitializeMonitorEx");
393 pInitializeMonitor = (void *)GetProcAddress(pm->hdll, "InitializeMonitor");
394
395
396 TRACE("%p: %s,pInitializePrintMonitor2\n", pInitializePrintMonitor2, debugstr_w(driver));
397 TRACE("%p: %s,pInitializePrintMonitorUI\n", pInitializePrintMonitorUI, debugstr_w(driver));
398 TRACE("%p: %s,pInitializePrintMonitor\n", pInitializePrintMonitor, debugstr_w(driver));
399 TRACE("%p: %s,pInitializeMonitorEx\n", pInitializeMonitorEx, debugstr_w(driver));
400 TRACE("%p: %s,pInitializeMonitor\n", pInitializeMonitor, debugstr_w(driver));
401
402 if (pInitializePrintMonitorUI != NULL) {
403 pm->monitorUI = pInitializePrintMonitorUI();
404 TRACE("%p: MONITORUI from %s,InitializePrintMonitorUI()\n", pm->monitorUI, debugstr_w(driver));
405 if (pm->monitorUI) {
406 TRACE("0x%08x: dwMonitorSize (%d)\n",
407 pm->monitorUI->dwMonitorUISize, pm->monitorUI->dwMonitorUISize);
408
409 }
410 }
411
412 if (pInitializePrintMonitor && regroot) {
413 pmonitorEx = pInitializePrintMonitor(regroot);
414 TRACE("%p: LPMONITOREX from %s,InitializePrintMonitor(%s)\n",
415 pmonitorEx, debugstr_w(driver), debugstr_w(regroot));
416
417 if (pmonitorEx) {
418 pm->dwMonitorSize = pmonitorEx->dwMonitorSize;
419 pm->monitor = &(pmonitorEx->Monitor);
420 }
421 }
422
423 if (pm->monitor) {
424 TRACE("0x%08x: dwMonitorSize (%d)\n", pm->dwMonitorSize, pm->dwMonitorSize);
425
426 }
427
428 if (!pm->monitor && regroot) {
429 if (pInitializePrintMonitor2 != NULL) {
430 FIXME("%s,InitializePrintMonitor2 not implemented\n", debugstr_w(driver));
431 }
432 if (pInitializeMonitorEx != NULL) {
433 FIXME("%s,InitializeMonitorEx not implemented\n", debugstr_w(driver));
434 }
435 if (pInitializeMonitor != NULL) {
436 FIXME("%s,InitializeMonitor not implemented\n", debugstr_w(driver));
437 }
438 }
439 if (!pm->monitor && !pm->monitorUI) {
440 monitor_unload(pm);
441 SetLastError(ERROR_PROC_NOT_FOUND);
442 pm = NULL;
443 }
444 }
445 cleanup:
446 if ((pm_localport == NULL) && (pm != NULL) && (lstrcmpW(pm->name, localportW) == 0)) {
447 pm->refcount++;
448 pm_localport = pm;
449 }
450 LeaveCriticalSection(&monitor_handles_cs);
451 if (driver != dllname) heap_free(driver);
452 heap_free(regroot);
453 TRACE("=> %p\n", pm);
454 return pm;
455 }
456
457 /******************************************************************
458 * Return the number of bytes for an multi_sz string.
459 * The result includes all \0s
460 * (specifically the extra \0, that is needed as multi_sz terminator).
461 */
462 static int multi_sz_lenW(const WCHAR *str)
463 {
464 const WCHAR *ptr = str;
465 if (!str) return 0;
466 do
467 {
468 ptr += lstrlenW(ptr) + 1;
469 } while (*ptr);
470
471 return (ptr - str + 1) * sizeof(WCHAR);
472 }
473
474 /******************************************************************
475 * validate_envW [internal]
476 *
477 * validate the user-supplied printing-environment
478 *
479 * PARAMS
480 * env [I] PTR to Environment-String or NULL
481 *
482 * RETURNS
483 * Success: PTR to printenv_t
484 * Failure: NULL and ERROR_INVALID_ENVIRONMENT
485 *
486 * NOTES
487 * An empty string is handled the same way as NULL.
488 *
489 */
490
491 static const printenv_t * validate_envW(LPCWSTR env)
492 {
493 const printenv_t *result = NULL;
494 unsigned int i;
495
496 TRACE("(%s)\n", debugstr_w(env));
497 if (env && env[0])
498 {
499 for (i = 0; i < sizeof(all_printenv)/sizeof(all_printenv[0]); i++)
500 {
501 if (lstrcmpiW(env, all_printenv[i]->envname) == 0)
502 {
503 result = all_printenv[i];
504 break;
505 }
506 }
507 if (result == NULL) {
508 FIXME("unsupported Environment: %s\n", debugstr_w(env));
509 SetLastError(ERROR_INVALID_ENVIRONMENT);
510 }
511 /* on win9x, only "Windows 4.0" is allowed, but we ignore this */
512 }
513 else
514 {
515 result = (GetVersion() & 0x80000000) ? &env_win40 : &env_x86;
516 }
517
518 TRACE("=> using %p: %s\n", result, debugstr_w(result ? result->envname : NULL));
519 return result;
520 }
521
522 /*****************************************************************************
523 * enumerate the local monitors (INTERNAL)
524 *
525 * returns the needed size (in bytes) for pMonitors
526 * and *lpreturned is set to number of entries returned in pMonitors
527 *
528 * Language-Monitors are also installed in the same Registry-Location but
529 * they are filtered in Windows (not returned by EnumMonitors).
530 * We do no filtering to simplify our Code.
531 *
532 */
533 static DWORD get_local_monitors(DWORD level, LPBYTE pMonitors, DWORD cbBuf, LPDWORD lpreturned)
534 {
535 HKEY hroot = NULL;
536 HKEY hentry = NULL;
537 LPWSTR ptr;
538 LPMONITOR_INFO_2W mi;
539 WCHAR buffer[MAX_PATH];
540 WCHAR dllname[MAX_PATH];
541 DWORD dllsize;
542 DWORD len;
543 DWORD index = 0;
544 DWORD needed = 0;
545 DWORD numentries;
546 DWORD entrysize;
547
548 entrysize = (level == 1) ? sizeof(MONITOR_INFO_1W) : sizeof(MONITOR_INFO_2W);
549
550 numentries = *lpreturned; /* this is 0, when we scan the registry */
551 len = entrysize * numentries;
552 ptr = (LPWSTR) &pMonitors[len];
553
554 numentries = 0;
555 len = sizeof(buffer)/sizeof(buffer[0]);
556 buffer[0] = '\0';
557
558 /* Windows creates the "Monitors"-Key on reboot / start "spooler" */
559 if (RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) == ERROR_SUCCESS) {
560 /* Scan all Monitor-Registry-Keys */
561 while (RegEnumKeyExW(hroot, index, buffer, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
562 TRACE("Monitor_%d: %s\n", numentries, debugstr_w(buffer));
563 dllsize = sizeof(dllname);
564 dllname[0] = '\0';
565
566 /* The Monitor must have a Driver-DLL */
567 if (RegOpenKeyExW(hroot, buffer, 0, KEY_READ, &hentry) == ERROR_SUCCESS) {
568 if (RegQueryValueExW(hentry, driverW, NULL, NULL, (LPBYTE) dllname, &dllsize) == ERROR_SUCCESS) {
569 /* We found a valid DLL for this Monitor. */
570 TRACE("using Driver: %s\n", debugstr_w(dllname));
571 }
572 RegCloseKey(hentry);
573 }
574
575 /* Windows returns only Port-Monitors here, but to simplify our code,
576 we do no filtering for Language-Monitors */
577 if (dllname[0]) {
578 numentries++;
579 needed += entrysize;
580 needed += (len+1) * sizeof(WCHAR); /* len is lstrlenW(monitorname) */
581 if (level > 1) {
582 /* we install and return only monitors for "Windows NT x86" */
583 needed += (lstrlenW(x86_envnameW) +1) * sizeof(WCHAR);
584 needed += dllsize;
585 }
586
587 /* required size is calculated. Now fill the user-buffer */
588 if (pMonitors && (cbBuf >= needed)){
589 mi = (LPMONITOR_INFO_2W) pMonitors;
590 pMonitors += entrysize;
591
592 TRACE("%p: writing MONITOR_INFO_%dW #%d\n", mi, level, numentries);
593 mi->pName = ptr;
594 lstrcpyW(ptr, buffer); /* Name of the Monitor */
595 ptr += (len+1); /* len is lstrlenW(monitorname) */
596 if (level > 1) {
597 mi->pEnvironment = ptr;
598 lstrcpyW(ptr, x86_envnameW); /* fixed to "Windows NT x86" */
599 ptr += (lstrlenW(x86_envnameW)+1);
600
601 mi->pDLLName = ptr;
602 lstrcpyW(ptr, dllname); /* Name of the Driver-DLL */
603 ptr += (dllsize / sizeof(WCHAR));
604 }
605 }
606 }
607 index++;
608 len = sizeof(buffer)/sizeof(buffer[0]);
609 buffer[0] = '\0';
610 }
611 RegCloseKey(hroot);
612 }
613 *lpreturned = numentries;
614 TRACE("need %d byte for %d entries\n", needed, numentries);
615 return needed;
616 }
617
618 /*****************************************************************************
619 * open_driver_reg [internal]
620 *
621 * opens the registry for the printer drivers depending on the given input
622 * variable pEnvironment
623 *
624 * RETURNS:
625 * Success: the opened hkey
626 * Failure: NULL
627 */
628 static HKEY open_driver_reg(LPCWSTR pEnvironment)
629 {
630 HKEY retval = NULL;
631 LPWSTR buffer;
632 const printenv_t * env;
633
634 TRACE("(%s)\n", debugstr_w(pEnvironment));
635
636 env = validate_envW(pEnvironment);
637 if (!env) return NULL;
638
639 buffer = HeapAlloc(GetProcessHeap(), 0, sizeof(fmt_driversW) +
640 (lstrlenW(env->envname) + lstrlenW(env->versionregpath)) * sizeof(WCHAR));
641
642 if (buffer) {
643 wsprintfW(buffer, fmt_driversW, env->envname, env->versionregpath);
644 RegCreateKeyW(HKEY_LOCAL_MACHINE, buffer, &retval);
645 HeapFree(GetProcessHeap(), 0, buffer);
646 }
647 return retval;
648 }
649
650 /*****************************************************************************
651 * fpGetPrinterDriverDirectory [exported through PRINTPROVIDOR]
652 *
653 * Return the PATH for the Printer-Drivers
654 *
655 * PARAMS
656 * pName [I] Servername (NT only) or NULL (local Computer)
657 * pEnvironment [I] Printing-Environment (see below) or NULL (Default)
658 * Level [I] Structure-Level (must be 1)
659 * pDriverDirectory [O] PTR to Buffer that receives the Result
660 * cbBuf [I] Size of Buffer at pDriverDirectory
661 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used /
662 * required for pDriverDirectory
663 *
664 * RETURNS
665 * Success: TRUE and in pcbNeeded the Bytes used in pDriverDirectory
666 * Failure: FALSE and in pcbNeeded the Bytes required for pDriverDirectory,
667 * if cbBuf is too small
668 *
669 * Native Values returned in pDriverDirectory on Success:
670 *| NT(Windows NT x86): "%winsysdir%\\spool\\DRIVERS\\w32x86"
671 *| NT(Windows 4.0): "%winsysdir%\\spool\\DRIVERS\\win40"
672 *| win9x(Windows 4.0): "%winsysdir%"
673 *
674 * "%winsysdir%" is the Value from GetSystemDirectoryW()
675 *
676 */
677 static BOOL WINAPI fpGetPrinterDriverDirectory(LPWSTR pName, LPWSTR pEnvironment,
678 DWORD Level, LPBYTE pDriverDirectory, DWORD cbBuf, LPDWORD pcbNeeded)
679 {
680 DWORD needed;
681 const printenv_t * env;
682
683 TRACE("(%s, %s, %d, %p, %d, %p)\n", debugstr_w(pName),
684 debugstr_w(pEnvironment), Level, pDriverDirectory, cbBuf, pcbNeeded);
685
686 if (pName != NULL && pName[0]) {
687 FIXME("server %s not supported\n", debugstr_w(pName));
688 SetLastError(ERROR_INVALID_PARAMETER);
689 return FALSE;
690 }
691
692 env = validate_envW(pEnvironment);
693 if (!env) return FALSE; /* pEnvironment invalid or unsupported */
694
695
696 /* GetSystemDirectoryW returns number of WCHAR including the '\0' */
697 needed = GetSystemDirectoryW(NULL, 0);
698 /* add the Size for the Subdirectories */
699 needed += lstrlenW(spooldriversW);
700 needed += lstrlenW(env->subdir);
701 needed *= sizeof(WCHAR); /* return-value is size in Bytes */
702
703 *pcbNeeded = needed;
704
705 if (needed > cbBuf) {
706 SetLastError(ERROR_INSUFFICIENT_BUFFER);
707 return FALSE;
708 }
709
710 if (pDriverDirectory == NULL) {
711 /* ERROR_INVALID_USER_BUFFER is NT, ERROR_INVALID_PARAMETER is win9x */
712 SetLastError(ERROR_INVALID_USER_BUFFER);
713 return FALSE;
714 }
715
716 GetSystemDirectoryW((LPWSTR) pDriverDirectory, cbBuf/sizeof(WCHAR));
717 /* add the Subdirectories */
718 lstrcatW((LPWSTR) pDriverDirectory, spooldriversW);
719 lstrcatW((LPWSTR) pDriverDirectory, env->subdir);
720
721 TRACE("=> %s\n", debugstr_w((LPWSTR) pDriverDirectory));
722 return TRUE;
723 }
724
725 /******************************************************************************
726 * myAddPrinterDriverEx [internal]
727 *
728 * Install a Printer Driver with the Option to upgrade / downgrade the Files
729 * and a special mode with lazy error checking.
730 *
731 */
732 static BOOL WINAPI myAddPrinterDriverEx(DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags, BOOL lazy)
733 {
734 static const WCHAR emptyW[1];
735 const printenv_t *env;
736 apd_data_t apd;
737 DRIVER_INFO_8W di;
738 LPWSTR ptr;
739 HKEY hroot;
740 HKEY hdrv;
741 DWORD disposition;
742 DWORD len;
743 LONG lres;
744
745 /* we need to set all entries in the Registry, independent from the Level of
746 DRIVER_INFO, that the caller supplied */
747
748 ZeroMemory(&di, sizeof(di));
749 if (pDriverInfo && (level < (sizeof(di_sizeof) / sizeof(di_sizeof[0])))) {
750 memcpy(&di, pDriverInfo, di_sizeof[level]);
751 }
752
753 /* dump the most used infos */
754 TRACE("%p: .cVersion : 0x%x/%d\n", pDriverInfo, di.cVersion, di.cVersion);
755 TRACE("%p: .pName : %s\n", di.pName, debugstr_w(di.pName));
756 TRACE("%p: .pEnvironment: %s\n", di.pEnvironment, debugstr_w(di.pEnvironment));
757 TRACE("%p: .pDriverPath : %s\n", di.pDriverPath, debugstr_w(di.pDriverPath));
758 TRACE("%p: .pDataFile : %s\n", di.pDataFile, debugstr_w(di.pDataFile));
759 TRACE("%p: .pConfigFile : %s\n", di.pConfigFile, debugstr_w(di.pConfigFile));
760 TRACE("%p: .pHelpFile : %s\n", di.pHelpFile, debugstr_w(di.pHelpFile));
761 /* dump only the first of the additional Files */
762 TRACE("%p: .pDependentFiles: %s\n", di.pDependentFiles, debugstr_w(di.pDependentFiles));
763
764
765 /* check environment */
766 env = validate_envW(di.pEnvironment);
767 if (env == NULL) return FALSE; /* ERROR_INVALID_ENVIRONMENT */
768
769 /* fill the copy-data / get the driverdir */
770 len = sizeof(apd.src) - sizeof(version3_subdirW) - sizeof(WCHAR);
771 if (!fpGetPrinterDriverDirectory(NULL, (LPWSTR) env->envname, 1,
772 (LPBYTE) apd.src, len, &len)) {
773 /* Should never Fail */
774 return FALSE;
775 }
776 memcpy(apd.dst, apd.src, len);
777 lstrcatW(apd.src, backslashW);
778 apd.srclen = lstrlenW(apd.src);
779 lstrcatW(apd.dst, env->versionsubdir);
780 lstrcatW(apd.dst, backslashW);
781 apd.dstlen = lstrlenW(apd.dst);
782 apd.copyflags = dwFileCopyFlags;
783 apd.lazy = lazy;
784 CreateDirectoryW(apd.src, NULL);
785 CreateDirectoryW(apd.dst, NULL);
786
787 hroot = open_driver_reg(env->envname);
788 if (!hroot) {
789 ERR("Can't create Drivers key\n");
790 return FALSE;
791 }
792
793 /* Fill the Registry for the Driver */
794 if ((lres = RegCreateKeyExW(hroot, di.pName, 0, NULL, REG_OPTION_NON_VOLATILE,
795 KEY_WRITE | KEY_QUERY_VALUE, NULL,
796 &hdrv, &disposition)) != ERROR_SUCCESS) {
797
798 ERR("can't create driver %s: %u\n", debugstr_w(di.pName), lres);
799 RegCloseKey(hroot);
800 SetLastError(lres);
801 return FALSE;
802 }
803 RegCloseKey(hroot);
804
805 if (disposition == REG_OPENED_EXISTING_KEY) {
806 TRACE("driver %s already installed\n", debugstr_w(di.pName));
807 RegCloseKey(hdrv);
808 SetLastError(ERROR_PRINTER_DRIVER_ALREADY_INSTALLED);
809 return FALSE;
810 }
811
812 /* Verified with the Adobe PS Driver, that w2k does not use di.Version */
813 RegSetValueExW(hdrv, versionW, 0, REG_DWORD, (LPBYTE) &env->driverversion,
814 sizeof(DWORD));
815
816 RegSetValueExW(hdrv, driverW, 0, REG_SZ, (LPBYTE) di.pDriverPath,
817 (lstrlenW(di.pDriverPath)+1)* sizeof(WCHAR));
818 apd_copyfile(di.pDriverPath, &apd);
819
820 RegSetValueExW(hdrv, data_fileW, 0, REG_SZ, (LPBYTE) di.pDataFile,
821 (lstrlenW(di.pDataFile)+1)* sizeof(WCHAR));
822 apd_copyfile(di.pDataFile, &apd);
823
824 RegSetValueExW(hdrv, configuration_fileW, 0, REG_SZ, (LPBYTE) di.pConfigFile,
825 (lstrlenW(di.pConfigFile)+1)* sizeof(WCHAR));
826 apd_copyfile(di.pConfigFile, &apd);
827
828 /* settings for level 3 */
829 if (di.pHelpFile)
830 RegSetValueExW(hdrv, help_fileW, 0, REG_SZ, (LPBYTE) di.pHelpFile,
831 (lstrlenW(di.pHelpFile)+1)* sizeof(WCHAR));
832 else
833 RegSetValueExW(hdrv, help_fileW, 0, REG_SZ, (LPBYTE)emptyW, sizeof(emptyW));
834 apd_copyfile(di.pHelpFile, &apd);
835
836
837 ptr = di.pDependentFiles;
838 if (ptr)
839 RegSetValueExW(hdrv, dependent_filesW, 0, REG_MULTI_SZ, (LPBYTE) di.pDependentFiles,
840 multi_sz_lenW(di.pDependentFiles));
841 else
842 RegSetValueExW(hdrv, dependent_filesW, 0, REG_MULTI_SZ, (LPBYTE)emptyW, sizeof(emptyW));
843 while ((ptr != NULL) && (ptr[0])) {
844 if (apd_copyfile(ptr, &apd)) {
845 ptr += lstrlenW(ptr) + 1;
846 }
847 else
848 {
849 WARN("Failed to copy %s\n", debugstr_w(ptr));
850 ptr = NULL;
851 }
852 }
853 /* The language-Monitor was already copied by the caller to "%SystemRoot%\system32" */
854 if (di.pMonitorName)
855 RegSetValueExW(hdrv, monitorW, 0, REG_SZ, (LPBYTE) di.pMonitorName,
856 (lstrlenW(di.pMonitorName)+1)* sizeof(WCHAR));
857 else
858 RegSetValueExW(hdrv, monitorW, 0, REG_SZ, (LPBYTE)emptyW, sizeof(emptyW));
859
860 if (di.pDefaultDataType)
861 RegSetValueExW(hdrv, datatypeW, 0, REG_SZ, (LPBYTE) di.pDefaultDataType,
862 (lstrlenW(di.pDefaultDataType)+1)* sizeof(WCHAR));
863 else
864 RegSetValueExW(hdrv, datatypeW, 0, REG_SZ, (LPBYTE)emptyW, sizeof(emptyW));
865
866 /* settings for level 4 */
867 if (di.pszzPreviousNames)
868 RegSetValueExW(hdrv, previous_namesW, 0, REG_MULTI_SZ, (LPBYTE) di.pszzPreviousNames,
869 multi_sz_lenW(di.pszzPreviousNames));
870 else
871 RegSetValueExW(hdrv, previous_namesW, 0, REG_MULTI_SZ, (LPBYTE)emptyW, sizeof(emptyW));
872
873 if (level > 5) TRACE("level %u for Driver %s is incomplete\n", level, debugstr_w(di.pName));
874
875 RegCloseKey(hdrv);
876 TRACE("### DrvDriverEvent(...,DRIVEREVENT_INITIALIZE) not implemented yet\n");
877
878 TRACE("=> TRUE with %u\n", GetLastError());
879 return TRUE;
880
881 }
882
883 /******************************************************************************
884 * fpAddMonitor [exported through PRINTPROVIDOR]
885 *
886 * Install a Printmonitor
887 *
888 * PARAMS
889 * pName [I] Servername or NULL (local Computer)
890 * Level [I] Structure-Level (Must be 2)
891 * pMonitors [I] PTR to MONITOR_INFO_2
892 *
893 * RETURNS
894 * Success: TRUE
895 * Failure: FALSE
896 *
897 * NOTES
898 * All Files for the Monitor must already be copied to %winsysdir% ("%SystemRoot%\system32")
899 *
900 */
901 BOOL WINAPI fpAddMonitor(LPWSTR pName, DWORD Level, LPBYTE pMonitors)
902 {
903 monitor_t * pm = NULL;
904 LPMONITOR_INFO_2W mi2w;
905 HKEY hroot = NULL;
906 HKEY hentry = NULL;
907 DWORD disposition;
908 BOOL res = FALSE;
909
910 mi2w = (LPMONITOR_INFO_2W) pMonitors;
911 TRACE("(%s, %d, %p): %s %s %s\n", debugstr_w(pName), Level, pMonitors,
912 debugstr_w(mi2w ? mi2w->pName : NULL),
913 debugstr_w(mi2w ? mi2w->pEnvironment : NULL),
914 debugstr_w(mi2w ? mi2w->pDLLName : NULL));
915
916 if (copy_servername_from_name(pName, NULL)) {
917 FIXME("server %s not supported\n", debugstr_w(pName));
918 SetLastError(ERROR_ACCESS_DENIED);
919 return FALSE;
920 }
921
922 if (!mi2w->pName || (! mi2w->pName[0])) {
923 WARN("pName not valid : %s\n", debugstr_w(mi2w->pName));
924 SetLastError(ERROR_INVALID_PARAMETER);
925 return FALSE;
926 }
927 if (!mi2w->pEnvironment || lstrcmpW(mi2w->pEnvironment, x86_envnameW)) {
928 WARN("Environment %s requested (we support only %s)\n",
929 debugstr_w(mi2w->pEnvironment), debugstr_w(x86_envnameW));
930 SetLastError(ERROR_INVALID_ENVIRONMENT);
931 return FALSE;
932 }
933
934 if (!mi2w->pDLLName || (! mi2w->pDLLName[0])) {
935 WARN("pDLLName not valid : %s\n", debugstr_w(mi2w->pDLLName));
936 SetLastError(ERROR_INVALID_PARAMETER);
937 return FALSE;
938 }
939
940 /* Load and initialize the monitor. SetLastError() is called on failure */
941 if ((pm = monitor_load(mi2w->pName, mi2w->pDLLName)) == NULL) {
942 return FALSE;
943 }
944 monitor_unload(pm);
945
946 if (RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) != ERROR_SUCCESS) {
947 ERR("unable to create key %s\n", debugstr_w(monitorsW));
948 return FALSE;
949 }
950
951 if (RegCreateKeyExW(hroot, mi2w->pName, 0, NULL, REG_OPTION_NON_VOLATILE,
952 KEY_WRITE | KEY_QUERY_VALUE, NULL, &hentry,
953 &disposition) == ERROR_SUCCESS) {
954
955 /* Some installers set options for the port before calling AddMonitor.
956 We query the "Driver" entry to verify that the monitor is installed,
957 before we return an error.
958 When a user installs two print monitors at the same time with the
959 same name, a race condition is possible but silently ignored. */
960
961 DWORD namesize = 0;
962
963 if ((disposition == REG_OPENED_EXISTING_KEY) &&
964 (RegQueryValueExW(hentry, driverW, NULL, NULL, NULL,
965 &namesize) == ERROR_SUCCESS)) {
966 TRACE("monitor %s already exists\n", debugstr_w(mi2w->pName));
967 /* 9x use ERROR_ALREADY_EXISTS */
968 SetLastError(ERROR_PRINT_MONITOR_ALREADY_INSTALLED);
969 }
970 else
971 {
972 INT len;
973 len = (lstrlenW(mi2w->pDLLName) +1) * sizeof(WCHAR);
974 res = (RegSetValueExW(hentry, driverW, 0, REG_SZ,
975 (LPBYTE) mi2w->pDLLName, len) == ERROR_SUCCESS);
976 }
977 RegCloseKey(hentry);
978 }
979
980 RegCloseKey(hroot);
981 return (res);
982 }
983
984 /******************************************************************************
985 * fpAddPrinterDriverEx [exported through PRINTPROVIDOR]
986 *
987 * Install a Printer Driver with the Option to upgrade / downgrade the Files
988 *
989 * PARAMS
990 * pName [I] Servername or NULL (local Computer)
991 * level [I] Level for the supplied DRIVER_INFO_*W struct
992 * pDriverInfo [I] PTR to DRIVER_INFO_*W struct with the Driver Parameter
993 * dwFileCopyFlags [I] How to Copy / Upgrade / Downgrade the needed Files
994 *
995 * RESULTS
996 * Success: TRUE
997 * Failure: FALSE
998 *
999 */
1000 static BOOL WINAPI fpAddPrinterDriverEx(LPWSTR pName, DWORD level, LPBYTE pDriverInfo, DWORD dwFileCopyFlags)
1001 {
1002 LONG lres;
1003
1004 TRACE("(%s, %d, %p, 0x%x)\n", debugstr_w(pName), level, pDriverInfo, dwFileCopyFlags);
1005 lres = copy_servername_from_name(pName, NULL);
1006 if (lres) {
1007 FIXME("server %s not supported\n", debugstr_w(pName));
1008 SetLastError(ERROR_ACCESS_DENIED);
1009 return FALSE;
1010 }
1011
1012 if ((dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY) != APD_COPY_ALL_FILES) {
1013 TRACE("Flags 0x%x ignored (using APD_COPY_ALL_FILES)\n", dwFileCopyFlags & ~APD_COPY_FROM_DIRECTORY);
1014 }
1015
1016 return myAddPrinterDriverEx(level, pDriverInfo, dwFileCopyFlags, TRUE);
1017 }
1018 /******************************************************************
1019 * fpDeleteMonitor [exported through PRINTPROVIDOR]
1020 *
1021 * Delete a specific Printmonitor from a Printing-Environment
1022 *
1023 * PARAMS
1024 * pName [I] Servername or NULL (local Computer)
1025 * pEnvironment [I] Printing-Environment of the Monitor or NULL (Default)
1026 * pMonitorName [I] Name of the Monitor, that should be deleted
1027 *
1028 * RETURNS
1029 * Success: TRUE
1030 * Failure: FALSE
1031 *
1032 * NOTES
1033 * pEnvironment is ignored in Windows for the local Computer.
1034 *
1035 */
1036
1037 BOOL WINAPI fpDeleteMonitor(LPWSTR pName, LPWSTR pEnvironment, LPWSTR pMonitorName)
1038 {
1039 HKEY hroot = NULL;
1040 LONG lres;
1041
1042 TRACE("(%s, %s, %s)\n",debugstr_w(pName),debugstr_w(pEnvironment),
1043 debugstr_w(pMonitorName));
1044
1045 lres = copy_servername_from_name(pName, NULL);
1046 if (lres) {
1047 FIXME("server %s not supported\n", debugstr_w(pName));
1048 SetLastError(ERROR_INVALID_NAME);
1049 return FALSE;
1050 }
1051
1052 /* pEnvironment is ignored in Windows for the local Computer */
1053 if (!pMonitorName || !pMonitorName[0]) {
1054 TRACE("pMonitorName %s is invalid\n", debugstr_w(pMonitorName));
1055 SetLastError(ERROR_INVALID_PARAMETER);
1056 return FALSE;
1057 }
1058
1059 if(RegCreateKeyW(HKEY_LOCAL_MACHINE, monitorsW, &hroot) != ERROR_SUCCESS) {
1060 ERR("unable to create key %s\n", debugstr_w(monitorsW));
1061 return FALSE;
1062 }
1063
1064 if(RegDeleteTreeW(hroot, pMonitorName) == ERROR_SUCCESS) {
1065 TRACE("%s deleted\n", debugstr_w(pMonitorName));
1066 RegCloseKey(hroot);
1067 return TRUE;
1068 }
1069
1070 TRACE("%s does not exist\n", debugstr_w(pMonitorName));
1071 RegCloseKey(hroot);
1072
1073 /* NT: ERROR_UNKNOWN_PRINT_MONITOR (3000), 9x: ERROR_INVALID_PARAMETER (87) */
1074 SetLastError(ERROR_UNKNOWN_PRINT_MONITOR);
1075 return FALSE;
1076 }
1077
1078 /*****************************************************************************
1079 * fpEnumMonitors [exported through PRINTPROVIDOR]
1080 *
1081 * Enumerate available Port-Monitors
1082 *
1083 * PARAMS
1084 * pName [I] Servername or NULL (local Computer)
1085 * Level [I] Structure-Level (1:Win9x+NT or 2:NT only)
1086 * pMonitors [O] PTR to Buffer that receives the Result
1087 * cbBuf [I] Size of Buffer at pMonitors
1088 * pcbNeeded [O] PTR to DWORD that receives the size in Bytes used / required for pMonitors
1089 * pcReturned [O] PTR to DWORD that receives the number of Monitors in pMonitors
1090 *
1091 * RETURNS
1092 * Success: TRUE
1093 * Failure: FALSE and in pcbNeeded the Bytes required for buffer, if cbBuf is too small
1094 *
1095 * NOTES
1096 * Windows reads the Registry once and cache the Results.
1097 *
1098 */
1099 BOOL WINAPI fpEnumMonitors(LPWSTR pName, DWORD Level, LPBYTE pMonitors, DWORD cbBuf,
1100 LPDWORD pcbNeeded, LPDWORD pcReturned)
1101 {
1102 DWORD numentries = 0;
1103 DWORD needed = 0;
1104 LONG lres;
1105 BOOL res = FALSE;
1106
1107 TRACE("(%s, %d, %p, %d, %p, %p)\n", debugstr_w(pName), Level, pMonitors,
1108 cbBuf, pcbNeeded, pcReturned);
1109
1110 lres = copy_servername_from_name(pName, NULL);
1111 if (lres) {
1112 FIXME("server %s not supported\n", debugstr_w(pName));
1113 SetLastError(ERROR_INVALID_NAME);
1114 goto em_cleanup;
1115 }
1116
1117 if (!Level || (Level > 2)) {
1118 WARN("level (%d) is ignored in win9x\n", Level);
1119 SetLastError(ERROR_INVALID_LEVEL);
1120 return FALSE;
1121 }
1122
1123 /* Scan all Monitor-Keys */
1124 numentries = 0;
1125 needed = get_local_monitors(Level, NULL, 0, &numentries);
1126
1127 /* we calculated the needed buffersize. now do more error-checks */
1128 if (cbBuf < needed) {
1129 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1130 goto em_cleanup;
1131 }
1132
1133 /* fill the Buffer with the Monitor-Keys */
1134 needed = get_local_monitors(Level, pMonitors, cbBuf, &numentries);
1135 res = TRUE;
1136
1137 em_cleanup:
1138 if (pcbNeeded) *pcbNeeded = needed;
1139 if (pcReturned) *pcReturned = numentries;
1140
1141 TRACE("returning %d with %d (%d byte for %d entries)\n",
1142 res, GetLastError(), needed, numentries);
1143
1144 return (res);
1145 }
1146
1147 /*****************************************************
1148 * get_backend [internal]
1149 */
1150 static const PRINTPROVIDOR * get_backend(void)
1151 {
1152 static const PRINTPROVIDOR backend = {
1153 NULL, /* fpOpenPrinter */
1154 NULL, /* fpSetJob */
1155 NULL, /* fpGetJob */
1156 NULL, /* fpEnumJobs */
1157 NULL, /* fpAddPrinter */
1158 NULL, /* fpDeletePrinter */
1159 NULL, /* fpSetPrinter */
1160 NULL, /* fpGetPrinter */
1161 NULL, /* fpEnumPrinters */
1162 NULL, /* fpAddPrinterDriver */
1163 NULL, /* fpEnumPrinterDrivers */
1164 NULL, /* fpGetPrinterDriver */
1165 fpGetPrinterDriverDirectory,
1166 NULL, /* fpDeletePrinterDriver */
1167 NULL, /* fpAddPrintProcessor */
1168 NULL, /* fpEnumPrintProcessors */
1169 NULL, /* fpGetPrintProcessorDirectory */
1170 NULL, /* fpDeletePrintProcessor */
1171 NULL, /* fpEnumPrintProcessorDatatypes */
1172 NULL, /* fpStartDocPrinter */
1173 NULL, /* fpStartPagePrinter */
1174 NULL, /* fpWritePrinter */
1175 NULL, /* fpEndPagePrinter */
1176 NULL, /* fpAbortPrinter */
1177 NULL, /* fpReadPrinter */
1178 NULL, /* fpEndDocPrinter */
1179 NULL, /* fpAddJob */
1180 NULL, /* fpScheduleJob */
1181 NULL, /* fpGetPrinterData */
1182 NULL, /* fpSetPrinterData */
1183 NULL, /* fpWaitForPrinterChange */
1184 NULL, /* fpClosePrinter */
1185 NULL, /* fpAddForm */
1186 NULL, /* fpDeleteForm */
1187 NULL, /* fpGetForm */
1188 NULL, /* fpSetForm */
1189 NULL, /* fpEnumForms */
1190 fpEnumMonitors,
1191 NULL, /* fpEnumPorts */
1192 NULL, /* fpAddPort */
1193 NULL, /* fpConfigurePort */
1194 NULL, /* fpDeletePort */
1195 NULL, /* fpCreatePrinterIC */
1196 NULL, /* fpPlayGdiScriptOnPrinterIC */
1197 NULL, /* fpDeletePrinterIC */
1198 NULL, /* fpAddPrinterConnection */
1199 NULL, /* fpDeletePrinterConnection */
1200 NULL, /* fpPrinterMessageBox */
1201 fpAddMonitor,
1202 fpDeleteMonitor,
1203 NULL, /* fpResetPrinter */
1204 NULL, /* fpGetPrinterDriverEx */
1205 NULL, /* fpFindFirstPrinterChangeNotification */
1206 NULL, /* fpFindClosePrinterChangeNotification */
1207 NULL, /* fpAddPortEx */
1208 NULL, /* fpShutDown */
1209 NULL, /* fpRefreshPrinterChangeNotification */
1210 NULL, /* fpOpenPrinterEx */
1211 NULL, /* fpAddPrinterEx */
1212 NULL, /* fpSetPort */
1213 NULL, /* fpEnumPrinterData */
1214 NULL, /* fpDeletePrinterData */
1215 NULL, /* fpClusterSplOpen */
1216 NULL, /* fpClusterSplClose */
1217 NULL, /* fpClusterSplIsAlive */
1218 NULL, /* fpSetPrinterDataEx */
1219 NULL, /* fpGetPrinterDataEx */
1220 NULL, /* fpEnumPrinterDataEx */
1221 NULL, /* fpEnumPrinterKey */
1222 NULL, /* fpDeletePrinterDataEx */
1223 NULL, /* fpDeletePrinterKey */
1224 NULL, /* fpSeekPrinter */
1225 NULL, /* fpDeletePrinterDriverEx */
1226 NULL, /* fpAddPerMachineConnection */
1227 NULL, /* fpDeletePerMachineConnection */
1228 NULL, /* fpEnumPerMachineConnections */
1229 NULL, /* fpXcvData */
1230 fpAddPrinterDriverEx,
1231 NULL, /* fpSplReadPrinter */
1232 NULL, /* fpDriverUnloadComplete */
1233 NULL, /* fpGetSpoolFileInfo */
1234 NULL, /* fpCommitSpoolData */
1235 NULL, /* fpCloseSpoolFileHandle */
1236 NULL, /* fpFlushPrinter */
1237 NULL, /* fpSendRecvBidiData */
1238 NULL /* fpAddDriverCatalog */
1239 };
1240 TRACE("=> %p\n", &backend);
1241 return &backend;
1242
1243 }
1244
1245 /*****************************************************
1246 * DllMain
1247 */
1248 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1249 {
1250 TRACE("(%p, %d, %p)\n",hinstDLL, fdwReason, lpvReserved);
1251
1252 switch(fdwReason)
1253 {
1254 case DLL_WINE_PREATTACH:
1255 return FALSE; /* prefer native version */
1256
1257 case DLL_PROCESS_ATTACH:
1258 DisableThreadLibraryCalls( hinstDLL );
1259 LOCALSPL_hInstance = hinstDLL;
1260 pp = get_backend();
1261 break;
1262 }
1263 return TRUE;
1264 }
1265
1266
1267 /*****************************************************
1268 * InitializePrintProvidor (localspl.@)
1269 *
1270 * Initialize the Printprovider
1271 *
1272 * PARAMS
1273 * pPrintProvidor [I] Buffer to fill with a struct PRINTPROVIDOR
1274 * cbPrintProvidor [I] Size of Buffer in Bytes
1275 * pFullRegistryPath [I] Registry-Path for the Printprovidor
1276 *
1277 * RETURNS
1278 * Success: TRUE and pPrintProvidor filled
1279 * Failure: FALSE
1280 *
1281 * NOTES
1282 * The RegistryPath should be:
1283 * "System\CurrentControlSet\Control\Print\Providers\<providername>",
1284 * but this Parameter is ignored in "localspl.dll".
1285 *
1286 */
1287
1288 BOOL WINAPI InitializePrintProvidor(LPPRINTPROVIDOR pPrintProvidor,
1289 DWORD cbPrintProvidor, LPWSTR pFullRegistryPath)
1290 {
1291
1292 TRACE("(%p, %u, %s)\n", pPrintProvidor, cbPrintProvidor, debugstr_w(pFullRegistryPath));
1293 memcpy(pPrintProvidor, pp, (cbPrintProvidor < sizeof(PRINTPROVIDOR)) ? cbPrintProvidor : sizeof(PRINTPROVIDOR));
1294
1295 return TRUE;
1296 }
Maarten's multimedia branch