winhttp: Add the remaining completion notifications.
[wine] / dlls / winmm / driver.c
1 /*
2  * WINE Drivers functions
3  *
4  * Copyright 1994 Martin Ayotte
5  * Copyright 1998 Marcus Meissner
6  * Copyright 1999 Eric Pouech
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <string.h>
27 #include <stdarg.h>
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winnls.h"
33 #include "winreg.h"
34 #include "mmddk.h"
35 #include "winemm.h"
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38 #include "excpt.h"
39 #include "wine/exception.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(driver);
42
43 static CRITICAL_SECTION mmdriver_lock;
44 static CRITICAL_SECTION_DEBUG mmdriver_lock_debug =
45 {
46     0, 0, &mmdriver_lock,
47     { &mmdriver_lock_debug.ProcessLocksList, &mmdriver_lock_debug.ProcessLocksList },
48       0, 0, { (DWORD_PTR)(__FILE__ ": mmdriver_lock") }
49 };
50 static CRITICAL_SECTION mmdriver_lock = { &mmdriver_lock_debug, -1, 0, 0, 0, 0 };
51
52 static LPWINE_DRIVER   lpDrvItemList  /* = NULL */;
53 static const WCHAR HKLM_BASE[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
54                                   'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
55
56 WINE_MMTHREAD*  (*pFnGetMMThread16)(UINT16 h) /* = NULL */;
57 LPWINE_DRIVER   (*pFnOpenDriver16)(LPCWSTR,LPCWSTR,LPARAM) /* = NULL */;
58 LRESULT         (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */;
59 LRESULT         (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */;
60
61 static void DRIVER_Dump(const char *comment)
62 {
63 #if 0
64     LPWINE_DRIVER       lpDrv;
65
66     TRACE("%s\n", comment);
67
68     EnterCriticalSection( &mmdriver_lock );
69
70     for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpDrv->lpNextItem)
71     {
72         TRACE("%p, magic %04lx, id %p, next %p\n", lpDrv, lpDrv->dwMagic, (void *)lpDrv->d.d32.dwDriverID, lpDrv->lpNextItem);
73     }
74
75     LeaveCriticalSection( &mmdriver_lock );
76 #endif
77 }
78
79 /**************************************************************************
80  *                      DRIVER_GetNumberOfModuleRefs            [internal]
81  *
82  * Returns the number of open drivers which share the same module.
83  */
84 static  unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** found)
85 {
86     LPWINE_DRIVER       lpDrv;
87     unsigned            count = 0;
88
89     EnterCriticalSection( &mmdriver_lock );
90
91     if (found) *found = NULL;
92     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
93     {
94         if (!(lpDrv->dwFlags & WINE_GDF_16BIT) && lpDrv->d.d32.hModule == hModule)
95         {
96             if (found && !*found) *found = lpDrv;
97             count++;
98         }
99     }
100
101     LeaveCriticalSection( &mmdriver_lock );
102     return count;
103 }
104
105 /**************************************************************************
106  *                              DRIVER_FindFromHDrvr            [internal]
107  *
108  * From a hDrvr being 32 bits, returns the WINE internal structure.
109  */
110 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
111 {
112     LPWINE_DRIVER d;
113
114     __TRY
115     {
116         d = (LPWINE_DRIVER)hDrvr;
117         if (d && d->dwMagic != WINE_DI_MAGIC) d = NULL;
118     }
119     __EXCEPT_PAGE_FAULT
120     {
121         return NULL;
122     }
123     __ENDTRY;
124
125     if (d) TRACE("%p -> %p, %p\n", hDrvr, d->d.d32.lpDrvProc, (void *)d->d.d32.dwDriverID);
126     else TRACE("%p -> NULL\n", hDrvr);
127
128     return d;
129 }
130
131 /**************************************************************************
132  *                              DRIVER_SendMessage              [internal]
133  */
134 static inline LRESULT DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
135                                          LPARAM lParam1, LPARAM lParam2)
136 {
137     LRESULT             ret = 0;
138
139     if (lpDrv->dwFlags & WINE_GDF_16BIT) {
140         /* no need to check mmsystem presence: the driver must have been opened as a 16 bit one,
141          */
142         if (pFnSendMessage16)
143             ret = pFnSendMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
144     } else {
145         TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n", 
146               lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
147         ret = lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
148         TRACE("After  call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n", 
149               lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2, ret);
150     }
151     return ret;
152 }
153
154 /**************************************************************************
155  *                              SendDriverMessage               [WINMM.@]
156  *                              DrvSendMessage                  [WINMM.@]
157  */
158 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
159                                  LPARAM lParam2)
160 {
161     LPWINE_DRIVER       lpDrv;
162     LRESULT             retval = 0;
163
164     TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
165
166     if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
167         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
168     } else {
169         WARN("Bad driver handle %p\n", hDriver);
170     }
171     TRACE("retval = %ld\n", retval);
172
173     return retval;
174 }
175
176 /**************************************************************************
177  *                              DRIVER_RemoveFromList           [internal]
178  *
179  * Generates all the logic to handle driver closure / deletion
180  * Removes a driver struct to the list of open drivers.
181  */
182 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
183 {
184     if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
185         /* last of this driver in list ? */
186         if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 1) {
187             DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
188             DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
189         }
190     }
191
192     EnterCriticalSection( &mmdriver_lock );
193
194     if (lpDrv->lpPrevItem)
195         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
196     else
197         lpDrvItemList = lpDrv->lpNextItem;
198     if (lpDrv->lpNextItem)
199         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
200     /* trash magic number */
201     lpDrv->dwMagic ^= 0xa5a5a5a5;
202     lpDrv->d.d32.lpDrvProc = NULL;
203     lpDrv->d.d32.dwDriverID = 0;
204     lpDrv->d.d16.hDriver16 = 0;
205
206     LeaveCriticalSection( &mmdriver_lock );
207
208     return TRUE;
209 }
210
211 /**************************************************************************
212  *                              DRIVER_AddToList                [internal]
213  *
214  * Adds a driver struct to the list of open drivers.
215  * Generates all the logic to handle driver creation / open.
216  */
217 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
218 {
219     lpNewDrv->dwMagic = WINE_DI_MAGIC;
220     /* First driver to be loaded for this module, need to load correctly the module */
221     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
222         /* first of this driver in list ? */
223         if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
224             if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
225                 TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
226                 return FALSE;
227             }
228             /* returned value is not checked */
229             DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
230         }
231
232         /* Now just open a new instance of a driver on this module */
233         lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
234
235         if (lpNewDrv->d.d32.dwDriverID == 0)
236         {
237             TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
238             return FALSE;
239         }
240     }
241
242     EnterCriticalSection( &mmdriver_lock );
243
244     lpNewDrv->lpNextItem = NULL;
245     if (lpDrvItemList == NULL) {
246         lpDrvItemList = lpNewDrv;
247         lpNewDrv->lpPrevItem = NULL;
248     } else {
249         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
250         while (lpDrv->lpNextItem != NULL)
251             lpDrv = lpDrv->lpNextItem;
252
253         lpDrv->lpNextItem = lpNewDrv;
254         lpNewDrv->lpPrevItem = lpDrv;
255     }
256
257     LeaveCriticalSection( &mmdriver_lock );
258     return TRUE;
259 }
260
261 /**************************************************************************
262  *                              DRIVER_GetLibName               [internal]
263  *
264  */
265 BOOL    DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz)
266 {
267     HKEY        hKey, hSecKey;
268     DWORD       bufLen, lRet;
269     static const WCHAR wszSystemIni[] = {'S','Y','S','T','E','M','.','I','N','I',0};
270     WCHAR       wsznull = '\0';
271
272     TRACE("registry: %s, %s, %p, %d\n", debugstr_w(keyName), debugstr_w(sectName), buf, sz);
273
274     lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
275     if (lRet == ERROR_SUCCESS) {
276         lRet = RegOpenKeyExW(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
277         if (lRet == ERROR_SUCCESS) {
278             bufLen = sz;
279             lRet = RegQueryValueExW(hSecKey, keyName, 0, 0, (void*)buf, &bufLen);
280             RegCloseKey( hSecKey );
281         }
282         RegCloseKey( hKey );
283     }
284     if (lRet == ERROR_SUCCESS) return TRUE;
285
286     /* default to system.ini if we can't find it in the registry,
287      * to support native installations where system.ini is still used */
288     TRACE("system.ini: %s, %s, %p, %d\n", debugstr_w(keyName), debugstr_w(sectName), buf, sz);
289     return GetPrivateProfileStringW(sectName, keyName, &wsznull, buf, sz / sizeof(WCHAR), wszSystemIni);
290 }
291
292 /**************************************************************************
293  *                              DRIVER_TryOpenDriver32          [internal]
294  *
295  * Tries to load a 32 bit driver whose DLL's (module) name is fn
296  */
297 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
298 {
299     LPWINE_DRIVER       lpDrv = NULL;
300     HMODULE             hModule = 0;
301     LPWSTR              ptr;
302     LPCSTR              cause = 0;
303
304     TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2);
305
306     if ((ptr = strchrW(fn, ' ')) != NULL) {
307         *ptr++ = '\0';
308         while (*ptr == ' ') ptr++;
309         if (*ptr == '\0') ptr = NULL;
310     }
311
312     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
313     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
314
315     if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
316
317     lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
318     if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
319
320     lpDrv->dwFlags          = 0;
321     lpDrv->d.d32.hModule    = hModule;
322     lpDrv->d.d32.dwDriverID = 0;
323
324     /* Win32 installable drivers must support a two phase opening scheme:
325      * + first open with NULL as lParam2 (session instance),
326      * + then do a second open with the real non null lParam2)
327      */
328     if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 0 && lParam2)
329     {
330         LPWINE_DRIVER   ret;
331
332         if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
333         {
334             cause = "load0 failed";
335             goto exit;
336         }
337         ret = DRIVER_TryOpenDriver32(fn, lParam2);
338         if (!ret)
339         {
340             CloseDriver((HDRVR)lpDrv, 0L, 0L);
341             cause = "load1 failed";
342             goto exit;
343         }
344         lpDrv->dwFlags |= WINE_GDF_SESSION;
345         return ret;
346     }
347
348     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
349     {cause = "load failed"; goto exit;}
350
351     TRACE("=> %p\n", lpDrv);
352     return lpDrv;
353  exit:
354     FreeLibrary(hModule);
355     HeapFree(GetProcessHeap(), 0, lpDrv);
356     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause);
357     return NULL;
358 }
359
360 /**************************************************************************
361  *                              OpenDriverA                     [WINMM.@]
362  *                              DrvOpenA                        [WINMM.@]
363  * (0,1,DRV_LOAD  ,0       ,0)
364  * (0,1,DRV_ENABLE,0       ,0)
365  * (0,1,DRV_OPEN  ,buf[256],0)
366  */
367 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
368 {
369     INT                 len;
370     LPWSTR              dn = NULL;
371     LPWSTR              sn = NULL;
372     HDRVR               ret = 0;
373
374     if (lpDriverName)
375     {
376         len = MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, NULL, 0 );
377         dn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
378         if (!dn) goto done;
379         MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, dn, len );
380     }
381
382     if (lpSectionName)
383     {
384         len = MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, NULL, 0 );
385         sn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
386         if (!sn) goto done;
387         MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, sn, len );
388     }
389
390     ret = OpenDriver(dn, sn, lParam);
391
392 done:
393     HeapFree(GetProcessHeap(), 0, dn);
394     HeapFree(GetProcessHeap(), 0, sn);
395     return ret;
396 }
397
398 /**************************************************************************
399  *                              OpenDriver                      [WINMM.@]
400  *                              DrvOpen                         [WINMM.@]
401  */
402 HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
403 {
404     LPWINE_DRIVER       lpDrv = NULL;
405     WCHAR               libName[MAX_PATH + 1];
406     LPCWSTR             lsn = lpSectionName;
407
408     TRACE("(%s, %s, 0x%08lx);\n", 
409           debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam);
410
411     DRIVER_Dump("BEFORE:");
412
413     if (lsn == NULL) {
414         static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0};
415         lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR));
416
417         if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
418             goto the_end;
419         lsn = wszDrivers32;
420     }
421     if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
422         (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
423         goto the_end;
424
425     /* now we will try a 16 bit driver (and add all the glue to make it work... which
426      * is located in our mmsystem implementation)
427      * so ensure, we can load our mmsystem, otherwise just fail
428      */
429     WINMM_CheckForMMSystem();
430     if (pFnOpenDriver16 &&
431         (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam)))
432     {
433         if (DRIVER_AddToList(lpDrv, 0, lParam)) goto the_end;
434         HeapFree(GetProcessHeap(), 0, lpDrv);
435     }
436     TRACE("Failed to open driver %s from system.ini file, section %s\n", 
437           debugstr_w(lpDriverName), debugstr_w(lpSectionName));
438
439 the_end:
440     TRACE("=> %p\n", lpDrv);
441
442     DRIVER_Dump("AFTER:");
443
444     return (HDRVR)lpDrv;
445 }
446
447 /**************************************************************************
448  *                      CloseDriver                             [WINMM.@]
449  *                      DrvClose                                [WINMM.@]
450  */
451 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
452 {
453     BOOL ret;
454     LPWINE_DRIVER       lpDrv;
455
456     TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
457
458     DRIVER_Dump("BEFORE:");
459
460     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
461     {
462         if (lpDrv->dwFlags & WINE_GDF_16BIT)
463         {
464             if (pFnCloseDriver16)
465                 pFnCloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
466         }
467         else
468             DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
469
470         DRIVER_RemoveFromList(lpDrv);
471
472         if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
473         {
474             LPWINE_DRIVER lpDrv0;
475
476             if (lpDrv->dwFlags & WINE_GDF_SESSION)
477                 FIXME("WINE_GDF_SESSION: Shouldn't happen (%p)\n", lpDrv);
478             /* if driver has an opened session instance, we have to close it too */
479             if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, &lpDrv0) == 1 &&
480                 (lpDrv0->dwFlags & WINE_GDF_SESSION))
481             {
482                 DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0, 0);
483                 DRIVER_RemoveFromList(lpDrv0);
484                 FreeLibrary(lpDrv0->d.d32.hModule);
485                 HeapFree(GetProcessHeap(), 0, lpDrv0);
486             }
487             FreeLibrary(lpDrv->d.d32.hModule);
488         }
489         HeapFree(GetProcessHeap(), 0, lpDrv);
490         ret = TRUE;
491     }
492     else
493     {
494         WARN("Failed to close driver\n");
495         ret = FALSE;
496     }
497
498     DRIVER_Dump("AFTER:");
499
500     return ret;
501 }
502
503 /**************************************************************************
504  *                              GetDriverFlags          [WINMM.@]
505  * [in] hDrvr handle to the driver
506  *
507  * Returns:
508  *      0x00000000 if hDrvr is an invalid handle
509  *      0x80000000 if hDrvr is a valid 32 bit driver
510  *      0x90000000 if hDrvr is a valid 16 bit driver
511  *
512  * native WINMM doesn't return those flags
513  *      0x80000000 for a valid 32 bit driver and that's it
514  *      (I may have mixed up the two flags :-(
515  */
516 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
517 {
518     LPWINE_DRIVER       lpDrv;
519     DWORD               ret = 0;
520
521     TRACE("(%p)\n", hDrvr);
522
523     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
524         ret = WINE_GDF_EXIST | (lpDrv->dwFlags & WINE_GDF_EXTERNAL_MASK);
525     }
526     return ret;
527 }
528
529 /**************************************************************************
530  *                              GetDriverModuleHandle   [WINMM.@]
531  *                              DrvGetModuleHandle      [WINMM.@]
532  */
533 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
534 {
535     LPWINE_DRIVER       lpDrv;
536     HMODULE             hModule = 0;
537
538     TRACE("(%p);\n", hDrvr);
539
540     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
541         if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
542             hModule = lpDrv->d.d32.hModule;
543     }
544     TRACE("=> %p\n", hModule);
545     return hModule;
546 }
547
548 /**************************************************************************
549  *                              DefDriverProc                     [WINMM.@]
550  *                              DrvDefDriverProc                  [WINMM.@]
551  */
552 LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv,
553                              UINT Msg, LPARAM lParam1, LPARAM lParam2)
554 {
555     switch (Msg) {
556     case DRV_LOAD:
557     case DRV_FREE:
558     case DRV_ENABLE:
559     case DRV_DISABLE:
560         return 1;
561     case DRV_INSTALL:
562     case DRV_REMOVE:
563         return DRV_SUCCESS;
564     default:
565         return 0;
566     }
567 }
568
569 /**************************************************************************
570  *                              DriverCallback                  [WINMM.@]
571  */
572 BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
573                            DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
574                            DWORD_PTR dwParam2)
575 {
576     TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX)\n",
577           dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
578
579     switch (uFlags & DCB_TYPEMASK) {
580     case DCB_NULL:
581         TRACE("Null !\n");
582         if (dwCallBack)
583             WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
584         break;
585     case DCB_WINDOW:
586         TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev);
587         PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
588         break;
589     case DCB_TASK: /* aka DCB_THREAD */
590         TRACE("Task(%04lx) !\n", dwCallBack);
591         PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
592         break;
593     case DCB_FUNCTION:
594         TRACE("Function (32 bit) !\n");
595         ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
596         break;
597     case DCB_EVENT:
598         TRACE("Event(%08lx) !\n", dwCallBack);
599         SetEvent((HANDLE)dwCallBack);
600         break;
601     case 6: /* I would dub it DCB_MMTHREADSIGNAL */
602         /* this is an undocumented DCB_ value used for mmThreads
603          * loword of dwCallBack contains the handle of the lpMMThd block
604          * which dwSignalCount has to be incremented
605          */     
606         if (pFnGetMMThread16)
607         {
608             WINE_MMTHREAD*      lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
609
610             TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
611             /* same as mmThreadSignal16 */
612             InterlockedIncrement(&lpMMThd->dwSignalCount);
613             SetEvent(lpMMThd->hEvent);
614             /* some other stuff on lpMMThd->hVxD */
615         }
616         break;
617 #if 0
618     case 4:
619         /* this is an undocumented DCB_ value for... I don't know */
620         break;
621 #endif
622     default:
623         WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
624         return FALSE;
625     }
626     TRACE("Done\n");
627     return TRUE;
628 }
629
630 /******************************************************************
631  *              DRIVER_UnloadAll
632  *
633  *
634  */
635 void    DRIVER_UnloadAll(void)
636 {
637     LPWINE_DRIVER       lpDrv;
638     LPWINE_DRIVER       lpNextDrv = NULL;
639     unsigned            count = 0;
640
641 restart:
642     EnterCriticalSection( &mmdriver_lock );
643
644     for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv)
645     {
646         lpNextDrv = lpDrv->lpNextItem;
647
648         /* session instances will be unloaded automatically */
649         if (!(lpDrv->dwFlags & WINE_GDF_SESSION))
650         {
651             LeaveCriticalSection( &mmdriver_lock );
652             CloseDriver((HDRVR)lpDrv, 0, 0);
653             count++;
654             /* restart from the beginning of the list */
655             goto restart;
656         }
657     }
658
659     LeaveCriticalSection( &mmdriver_lock );
660
661     TRACE("Unloaded %u drivers\n", count);
662 }