?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added atfork support.
[wine/multimedia.git] / windows / driver.c
blob402b5d73cf01011058e2ec303bb7111704eb393d
1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * WINE Drivers functions
5 *
6 * Copyright 1994 Martin Ayotte
7 * Copyright 1998 Marcus Meissner
8 * Copyright 1999 Eric Pouech
9 */
10
11 #include <string.h>
12 #include "heap.h"
13 #include "windef.h"
14 #include "wingdi.h"
15 #include "winuser.h"
16 #include "driver.h"
17 #include "ldt.h"
18 #include "module.h"
19 #include "mmddk.h"
20 #include "debugtools.h"
21
22 DEFAULT_DEBUG_CHANNEL(driver)
23
24 /* The following definitions are WINE internals */
25 /* FIXME: This is a WINE internal struct and should be moved in include/wine directory
26 * Please note that WINE shares 16 and 32 bit drivers on a single list...
27 * Basically, we maintain an external double view on drivers, so that a 16 bit drivers
28 * can be loaded/used... by 32 functions transparently
29 */
30
31 /* Who said goofy boy ? */
32 #define WINE_DI_MAGIC 0x900F1B01
33
34 typedef struct tagWINE_DRIVER
35 {
36 DWORD dwMagic;
37 char szAliasName[128];
38 /* as usual LPWINE_DRIVER == hDriver32 */
39 HDRVR16 hDriver16;
40 union {
41 struct {
42 HMODULE16 hModule;
43 DRIVERPROC16 lpDrvProc;
44 } d16;
45 struct {
46 HMODULE hModule;
47 DRIVERPROC lpDrvProc;
48 } d32;
49 } d;
50 DWORD dwDriverID;
51 DWORD dwFlags;
52 struct tagWINE_DRIVER* lpPrevItem;
53 struct tagWINE_DRIVER* lpNextItem;
54 } WINE_DRIVER, *LPWINE_DRIVER;
55
56 LPWINE_DRIVER DRIVER_RegisterDriver16(LPCSTR, HMODULE16, DRIVERPROC16, LPARAM, BOOL);
57 LPWINE_DRIVER DRIVER_RegisterDriver32(LPCSTR, HMODULE, DRIVERPROC, LPARAM, BOOL);
58
59 static LPWINE_DRIVER lpDrvItemList = NULL;
60
61 /* TODO list :
62 * - LoadModule count and clean up is not handled correctly (it's not a
63 * problem as long as FreeLibrary is not working correctly)
64 * - shoudln't the allocations be done on a per process basis ?
65 * - split 16/32 bit functions between DLLs as windows do (16 bit in USER, 32 bit in WINMM)
66 */
67
68 /* ### start build ### */
69 extern LONG CALLBACK DRIVER_CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
70 /* ### stop build ### */
71
72 /**************************************************************************
73 * LoadStartupDrivers [internal]
74 */
75 static void WINE_UNUSED DRIVER_LoadStartupDrivers(void)
76 {
77 char str[256];
78
79 if (GetPrivateProfileStringA("drivers", NULL, "", str, sizeof(str), "SYSTEM.INI") < 2) {
80 ERR("Can't find drivers section in system.ini\n");
81 } else {
82 HDRVR16 hDrv;
83 LPSTR ptr;
84
85 for (ptr = str; lstrlenA(ptr) != 0; ptr += lstrlenA(ptr) + 1) {
86 TRACE("str='%s'\n", ptr);
87 hDrv = OpenDriver16(ptr, "drivers", 0L);
88 TRACE("hDrv=%04x\n", hDrv);
89 }
90 TRACE("end of list !\n");
91 }
92 }
93
94 /**************************************************************************
95 * DRIVER_GetNumberOfModuleRefs [internal]
96 *
97 * Returns the number of open drivers which share the same module.
98 */
99 static WORD DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
100 {
101 LPWINE_DRIVER lpDrv;
102 WORD count = 0;
103
104 for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
105 if (lpDrv->dwFlags & WINE_GDF_16BIT) {
106 if (lpDrv->d.d16.hModule == lpNewDrv->d.d16.hModule) {
107 count++;
108 }
109 } else {
110 if (lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
111 count++;
112 }
113 }
114 }
115 return count;
116 }
117
118 /**************************************************************************
119 * DRIVER_FindFromHDrvr16 [internal]
120 *
121 * From a hDrvr being 16 bits, returns the WINE internal structure.
122 */
123 static LPWINE_DRIVER DRIVER_FindFromHDrvr16(HDRVR16 hDrvr)
124 {
125 LPWINE_DRIVER lpDrv;
126
127 for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
128 if (lpDrv->hDriver16 == hDrvr) {
129 break;
130 }
131 }
132 return lpDrv;
133 }
134
135 /**************************************************************************
136 * DRIVER_FindFromHDrvr [internal]
137 *
138 * From a hDrvr (being 16 or 32 bits), returns the WINE internal structure.
139 */
140 static LPWINE_DRIVER DRIVER_FindFromHDrvr(HDRVR hDrvr)
141 {
142 if (!IsBadWritePtr((void*)hDrvr, sizeof(WINE_DRIVER)) &&
143 ((LPWINE_DRIVER)hDrvr)->dwMagic == WINE_DI_MAGIC) {
144 return (LPWINE_DRIVER)hDrvr;
145 }
146 return DRIVER_FindFromHDrvr16(hDrvr);
147 }
148
149 /**************************************************************************
150 * DRIVER_MapMsg16To32 [internal]
151 *
152 * Map a 16 bit driver message to a 32 bit driver message.
153 * 1 : ok, some memory allocated, need to call DRIVER_UnMapMsg16To32
154 * 0 : ok, no memory allocated
155 * -1 : ko, unknown message
156 * -2 : ko, memory problem
157 */
158 static int DRIVER_MapMsg16To32(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
159 {
160 int ret = -1;
161
162 switch (wMsg) {
163 case DRV_LOAD:
164 case DRV_ENABLE:
165 case DRV_DISABLE:
166 case DRV_FREE:
167 case DRV_QUERYCONFIGURE:
168 case DRV_REMOVE:
169 case DRV_EXITSESSION:
170 case DRV_EXITAPPLICATION:
171 case DRV_POWER:
172 /* lParam1 and lParam2 are not used */
173 ret = 0;
174 break;
175 case DRV_OPEN:
176 case DRV_CLOSE:
177 /* lParam1 is a NULL terminated string */
178 /* lParam2 is a pointer to an MCI_OPEN_DRIVER_PARMS for an MCI device */
179 if (*lParam1)
180 *lParam1 = (DWORD)PTR_SEG_TO_LIN(*lParam1);
181 if (*lParam2 && wMsg == DRV_OPEN) {
182 LPMCI_OPEN_DRIVER_PARMS16 modp16 = PTR_SEG_TO_LIN(*lParam2);
183 char* ptr = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_DRIVER_PARMS16) + sizeof(MCI_OPEN_DRIVER_PARMSA));
184 LPMCI_OPEN_DRIVER_PARMSA modp32;
185
186 if (ptr) {
187 *(LPMCI_OPEN_DRIVER_PARMS16*)ptr = modp16;
188 modp32 = (LPMCI_OPEN_DRIVER_PARMSA)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
189
190 modp32->wDeviceID = modp16->wDeviceID;
191 modp32->lpstrParams = PTR_SEG_TO_LIN(modp16->lpstrParams);
192 } else {
193 return -2;
194 }
195 *lParam2 = (DWORD)modp32;
196 }
197 ret = 1;
198 break;
199 case DRV_CONFIGURE:
200 case DRV_INSTALL:
201 /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO */
202 if (*lParam2) {
203 LPDRVCONFIGINFO dci32 = HeapAlloc(GetProcessHeap(), 0, sizeof(DRVCONFIGINFO));
204 LPDRVCONFIGINFO16 dci16 = PTR_SEG_TO_LIN(*lParam2);
205
206 if (dci32) {
207 dci32->dwDCISize = sizeof(DRVCONFIGINFO);
208 dci32->lpszDCISectionName = HEAP_strdupAtoW(GetProcessHeap(), 0, PTR_SEG_TO_LIN(dci16->lpszDCISectionName));
209 dci32->lpszDCIAliasName = HEAP_strdupAtoW(GetProcessHeap(), 0, PTR_SEG_TO_LIN(dci16->lpszDCIAliasName));
210 if (dci32->lpszDCISectionName == NULL || dci32->lpszDCIAliasName == NULL)
211 return -2;
212 } else {
213 return -2;
214 }
215 *lParam2 = (DWORD)dci32;
216 ret = 1;
217 } else {
218 ret = 0;
219 }
220 break;
221 default:
222 if (wMsg >= 0x800 && wMsg < 0x900) {
223 /* FIXME: another hack to handle MCI messages...
224 * should find a *NICE* way to integrate DRIVER_ and
225 * MCI_ mapping/unmapping functions
226 */
227 ret = 0;
228 } else {
229 FIXME("Unknown message 0x%04x\n", wMsg);
230 }
231 }
232 return ret;
233 }
234
235 /**************************************************************************
236 * DRIVER_MapMsg16To32 [internal]
237 *
238 * UnMap a 16 bit driver message to a 32 bit driver message.
239 * 0 : ok
240 * -1 : ko
241 * -2 : ko, memory problem
242 */
243 static int DRIVER_UnMapMsg16To32(WORD wMsg, DWORD lParam1, DWORD lParam2)
244 {
245 int ret = -1;
246
247 switch (wMsg) {
248 case DRV_LOAD:
249 case DRV_ENABLE:
250 case DRV_DISABLE:
251 case DRV_FREE:
252 case DRV_QUERYCONFIGURE:
253 case DRV_REMOVE:
254 case DRV_EXITSESSION:
255 case DRV_EXITAPPLICATION:
256 case DRV_POWER:
257 /* lParam1 and lParam2 are not used */
258 case DRV_OPEN:
259 case DRV_CLOSE:
260 /* lParam1 is a NULL terminated string */
261 /* lParam2 is a pointer to an MCI_OPEN_DRIVER_PARMS for an MCI device */
262 if (lParam2 && wMsg == DRV_OPEN) {
263 LPMCI_OPEN_DRIVER_PARMSA modp32 = (LPMCI_OPEN_DRIVER_PARMSA)lParam2;
264 LPMCI_OPEN_DRIVER_PARMS16 modp16 = *(LPMCI_OPEN_DRIVER_PARMS16*)(lParam2 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
265
266 modp16->wCustomCommandTable = modp32->wCustomCommandTable;
267 modp16->wType = modp32->wType;
268 if (!HeapFree(GetProcessHeap(), 0, modp32))
269 FIXME("bad free line=%d\n", __LINE__);
270 }
271 ret = 0;
272 break;
273 case DRV_CONFIGURE:
274 case DRV_INSTALL:
275 /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
276 if (lParam2) {
277 LPDRVCONFIGINFO dci32 = (LPDRVCONFIGINFO)lParam2;
278 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)dci32->lpszDCISectionName))
279 FIXME("bad free line=%d\n", __LINE__);
280 if (!HeapFree(GetProcessHeap(), 0, (LPVOID)dci32->lpszDCIAliasName))
281 FIXME("bad free line=%d\n", __LINE__);
282 if (!HeapFree(GetProcessHeap(), 0, dci32))
283 FIXME("bad free line=%d\n", __LINE__);
284 }
285 ret = 0;
286 break;
287 default:
288 if (wMsg >= 0x800 && wMsg < 0x900) {
289 /* FIXME: another hack to handle MCI messages...
290 * should find a *NICE* way to integrate DRIVER_ and
291 * MCI_ mapping/unmapping functions
292 */
293 ret = 0;
294 } else {
295 FIXME("Unknown message 0x%04x\n", wMsg);
296 }
297 }
298 return ret;
299 }
300
301 /**************************************************************************
302 * DRIVER_MapMsg32To16 [internal]
303 *
304 * Map a 32 bit driver message to a 16 bit driver message.
305 * 1 : ok, some memory allocated, need to call DRIVER_UnMapMsg32To16
306 * 0 : ok, no memory allocated
307 * -1 : ko, unknown message
308 * -2 : ko, memory problem
309 */
310 static int DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
311 {
312 int ret = -1;
313
314 switch (wMsg) {
315 case DRV_LOAD:
316 case DRV_ENABLE:
317 case DRV_DISABLE:
318 case DRV_FREE:
319 case DRV_QUERYCONFIGURE:
320 case DRV_REMOVE:
321 case DRV_EXITSESSION:
322 case DRV_EXITAPPLICATION:
323 case DRV_POWER:
324 /* lParam1 and lParam2 are not used */
325 ret = 0;
326 break;
327 case DRV_OPEN:
328 case DRV_CLOSE:
329 /* lParam1 is a NULL terminated string */
330 /* lParam2 is a pointer to an MCI_OPEN_DRIVER_PARMS for an MCI device */
331 if (*lParam1) {
332 LPSTR str = SEGPTR_STRDUP((LPSTR)*lParam1);
333 if (str) {
334 *lParam1 = (LPARAM)SEGPTR_GET(str);
335 ret = 0;
336 } else {
337 ret = -2;
338 }
339 } else {
340 ret = 0;
341 }
342 if (*lParam2 && wMsg == DRV_OPEN) {
343 LPMCI_OPEN_DRIVER_PARMS16 modp16;
344 char* ptr = SEGPTR_ALLOC(sizeof(LPMCI_OPEN_DRIVER_PARMSA) + sizeof(MCI_OPEN_DRIVER_PARMS16));
345 LPMCI_OPEN_DRIVER_PARMSA modp32 = (LPMCI_OPEN_DRIVER_PARMSA)(*lParam2);
346
347 if (ptr) {
348 *(LPMCI_OPEN_DRIVER_PARMSA*)ptr = modp32;
349 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)(ptr + sizeof(LPMCI_OPEN_DRIVER_PARMSA));
350
351 modp16->wDeviceID = modp32->wDeviceID;
352 modp16->lpstrParams = PTR_SEG_TO_LIN(modp32->lpstrParams);
353 } else {
354 return -2;
355 }
356 *lParam2 = (DWORD)SEGPTR_GET(modp16);
357 ret = 1;
358 }
359 break;
360 case DRV_CONFIGURE:
361 case DRV_INSTALL:
362 /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO */
363 if (*lParam2) {
364 LPDRVCONFIGINFO16 dci16 = (LPDRVCONFIGINFO16)SEGPTR_ALLOC(sizeof(DRVCONFIGINFO16));
365 LPDRVCONFIGINFO dci32 = (LPDRVCONFIGINFO)(*lParam2);
366
367 if (dci16) {
368 LPSTR str1, str2;
369
370 dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
371
372 if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL &&
373 (str2 = SEGPTR_STRDUP(str1)) != NULL) {
374 dci16->lpszDCISectionName = (LPSTR)SEGPTR_GET(str2);
375 if (!HeapFree(GetProcessHeap(), 0, str1))
376 FIXME("bad free line=%d\n", __LINE__);
377 } else {
378 return -2;
379 }
380 if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL &&
381 (str2 = SEGPTR_STRDUP(str1)) != NULL) {
382 dci16->lpszDCIAliasName = (LPSTR)SEGPTR_GET(str2);
383 if (!HeapFree(GetProcessHeap(), 0, str1))
384 FIXME("bad free line=%d\n", __LINE__);
385 } else {
386 return -2;
387 }
388 } else {
389 return -2;
390 }
391 *lParam2 = (LPARAM)SEGPTR_GET(dci16);
392 ret = 1;
393 } else {
394 ret = 0;
395 }
396 break;
397 default:
398 if (wMsg >= 0x800 && wMsg < 0x900) {
399 /* FIXME: another hack to handle MCI messages...
400 * should find a *NICE* way to integrate DRIVER_ and
401 * MCI_ mapping/unmapping functions
402 */
403 ret = 0;
404 } else {
405 FIXME("Unknown message 0x%04x\n", wMsg);
406 }
407 }
408 return ret;
409 }
410
411 /**************************************************************************
412 * DRIVER_UnMapMsg32To16 [internal]
413 *
414 * UnMap a 32 bit driver message to a 16 bit driver message.
415 * 0 : ok
416 * -1 : ko
417 * -2 : ko, memory problem
418 */
419 static int DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
420 {
421 int ret = -1;
422
423 switch (wMsg) {
424 case DRV_LOAD:
425 case DRV_ENABLE:
426 case DRV_DISABLE:
427 case DRV_FREE:
428 case DRV_QUERYCONFIGURE:
429 case DRV_REMOVE:
430 case DRV_EXITSESSION:
431 case DRV_EXITAPPLICATION:
432 case DRV_POWER:
433 /* lParam1 and lParam2 are not used */
434 case DRV_OPEN:
435 case DRV_CLOSE:
436 /* lParam1 is a NULL terminated string, lParam2 is unknown => may lead to some problem */
437 /* lParam2 is a pointer to an MCI_OPEN_DRIVER_PARMS for an MCI device */
438 if (lParam1) if (!SEGPTR_FREE(PTR_SEG_TO_LIN(lParam1)))
439 FIXME("bad free line=%d\n", __LINE__);
440
441 if (lParam2 && wMsg == DRV_OPEN) {
442 LPMCI_OPEN_DRIVER_PARMS16 modp16 = (LPMCI_OPEN_DRIVER_PARMS16)PTR_SEG_TO_LIN(lParam2);
443 LPMCI_OPEN_DRIVER_PARMSA modp32 = *(LPMCI_OPEN_DRIVER_PARMSA*)((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA));
444
445 modp32->wCustomCommandTable = modp16->wCustomCommandTable;
446 modp32->wType = modp16->wType;
447 if (!SEGPTR_FREE((char*)modp16 - sizeof(LPMCI_OPEN_DRIVER_PARMSA)))
448 FIXME("bad free line=%d\n", __LINE__);
449 }
450 ret = 0;
451 break;
452 case DRV_CONFIGURE:
453 case DRV_INSTALL:
454 /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
455 if (lParam2) {
456 LPDRVCONFIGINFO16 dci16 = (LPDRVCONFIGINFO16)PTR_SEG_TO_LIN(lParam2);
457
458 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(dci16->lpszDCISectionName)))
459 FIXME("bad free line=%d\n", __LINE__);
460 if (!SEGPTR_FREE(PTR_SEG_TO_LIN(dci16->lpszDCIAliasName)))
461 FIXME("bad free line=%d\n", __LINE__);
462 if (!SEGPTR_FREE(dci16))
463 FIXME("bad free line=%d\n", __LINE__);
464 }
465 ret = 0;
466 break;
467 default:
468 if (wMsg >= 0x800 && wMsg < 0x900) {
469 /* FIXME: another hack to handle MCI messages...
470 * should find a *NICE* way to integrate DRIVER_ and
471 * MCI_ mapping/unmapping functions
472 */
473 ret = 0;
474 } else {
475 FIXME("Unknown message 0x%04x\n", wMsg);
476 }
477 }
478 return ret;
479 }
480
481 /**************************************************************************
482 * SendDriverMessage [USER.251]
483 */
484 LRESULT WINAPI SendDriverMessage16(HDRVR16 hDriver, UINT16 msg, LPARAM lParam1,
485 LPARAM lParam2)
486 {
487 LPWINE_DRIVER lpDrv;
488 LRESULT retval = 0;
489 int mapRet;
490
491 TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
492
493 lpDrv = DRIVER_FindFromHDrvr16(hDriver);
494 if (lpDrv != NULL && lpDrv->hDriver16 == hDriver) {
495 if (lpDrv->dwFlags & WINE_GDF_16BIT) {
496 TRACE("Before CallDriverProc proc=%p driverID=%08lx hDrv=%u wMsg=%04x p1=%08lx p2=%08lx\n",
497 lpDrv->d.d16.lpDrvProc, lpDrv->dwDriverID, hDriver, msg, lParam1, lParam2);
498 retval = DRIVER_CallTo16_long_lwwll((FARPROC16)lpDrv->d.d16.lpDrvProc, lpDrv->dwDriverID,
499 hDriver, msg, lParam1, lParam2);
500 } else {
501 mapRet = DRIVER_MapMsg16To32(msg, &lParam1, &lParam2);
502 if (mapRet >= 0) {
503 TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%u wMsg=%04x p1=%08lx p2=%08lx\n",
504 lpDrv->d.d32.lpDrvProc, lpDrv->dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
505 retval = lpDrv->d.d32.lpDrvProc(lpDrv->dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
506 if (mapRet >= 1) {
507 DRIVER_UnMapMsg16To32(msg, lParam1, lParam2);
508 }
509 } else {
510 retval = 0;
511 }
512 }
513 } else {
514 WARN("Bad driver handle %u\n", hDriver);
515 }
516
517 TRACE("retval = %ld\n", retval);
518 return retval;
519 }
520
521 /**************************************************************************
522 * SendDriverMessage [WINMM.19]
523 */
524 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
525 LPARAM lParam2)
526 {
527 LPWINE_DRIVER lpDrv;
528 LRESULT retval = 0;
529 int mapRet;
530
531 TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
532
533 lpDrv = DRIVER_FindFromHDrvr(hDriver);
534
535 if (lpDrv != NULL) {
536 if (lpDrv->dwFlags & WINE_GDF_16BIT) {
537 mapRet = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2);
538 if (mapRet >= 0) {
539 TRACE("Before CallDriverProc proc=%p driverID=%08lx hDrv=%u wMsg=%04x p1=%08lx p2=%08lx\n",
540 lpDrv->d.d16.lpDrvProc, lpDrv->dwDriverID, lpDrv->hDriver16, msg, lParam1, lParam2);
541 retval = DRIVER_CallTo16_long_lwwll((FARPROC16)lpDrv->d.d16.lpDrvProc, lpDrv->dwDriverID,
542 lpDrv->hDriver16, msg, lParam1, lParam2);
543 if (mapRet >= 1) {
544 DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
545 }
546 } else {
547 retval = 0;
548 }
549 } else {
550 TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%u wMsg=%04x p1=%08lx p2=%08lx\n",
551 lpDrv->d.d32.lpDrvProc, lpDrv->dwDriverID, hDriver, msg, lParam1, lParam2);
552 retval = lpDrv->d.d32.lpDrvProc(lpDrv->dwDriverID, hDriver, msg, lParam1, lParam2);
553 }
554 } else {
555 WARN("Bad driver handle %u\n", hDriver);
556 }
557 TRACE("retval = %ld\n", retval);
558
559 return retval;
560 }
561
562 /**************************************************************************
563 * DRIVER_RemoveFromList [internal]
564 *
565 * Generates all the logic to handle driver closure / deletion
566 * Removes a driver struct to the list of open drivers.
567 */
568 static BOOL DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
569 {
570 lpDrv->dwDriverID = 0;
571 if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
572 SendDriverMessage((HDRVR)lpDrv, DRV_DISABLE, 0L, 0L);
573 SendDriverMessage((HDRVR)lpDrv, DRV_FREE, 0L, 0L);
574 }
575
576 if (lpDrv->lpPrevItem)
577 lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
578 else
579 lpDrvItemList = lpDrv->lpNextItem;
580 if (lpDrv->lpNextItem)
581 lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
582
583 return TRUE;
584 }
585
586 /**************************************************************************
587 * DRIVER_AddToList [internal]
588 *
589 * Adds a driver struct to the list of open drivers.
590 * Generates all the logic to handle driver creation / open.
591 */
592 static BOOL DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam, BOOL bCallFrom32)
593 {
594 lpNewDrv->dwMagic = WINE_DI_MAGIC;
595 /* First driver to be loaded for this module, need to load correctly the module */
596 if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
597 if (SendDriverMessage((HDRVR)lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
598 TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
599 return FALSE;
600 }
601 if (SendDriverMessage((HDRVR)lpNewDrv, DRV_ENABLE, 0L, 0L) != DRV_SUCCESS) {
602 TRACE("DRV_ENABLE failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
603 return FALSE;
604 }
605 }
606
607 lpNewDrv->lpNextItem = NULL;
608 if (lpDrvItemList == NULL) {
609 lpDrvItemList = lpNewDrv;
610 lpNewDrv->lpPrevItem = NULL;
611 } else {
612 LPWINE_DRIVER lpDrv = lpDrvItemList; /* find end of list */
613 while (lpDrv->lpNextItem != NULL)
614 lpDrv = lpDrv->lpNextItem;
615
616 lpDrv->lpNextItem = lpNewDrv;
617 lpNewDrv->lpPrevItem = lpDrv;
618 }
619
620 /* Now just open a new instance of a driver on this module */
621 if (bCallFrom32) {
622 lpNewDrv->dwDriverID = SendDriverMessage((HDRVR)lpNewDrv, DRV_OPEN, 0L, lParam);
623 } else {
624 lpNewDrv->dwDriverID = SendDriverMessage16(lpNewDrv->hDriver16, DRV_OPEN, 0L, lParam);
625 }
626 if (lpNewDrv->dwDriverID == 0) {
627 TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
628 DRIVER_RemoveFromList(lpNewDrv);
629 return FALSE;
630 }
631
632 return TRUE;
633 }
634
635 /**************************************************************************
636 * DRIVER_CreateDrvr16 [internal]
637 *
638 * Creates unique ID for 16 bit drivers.
639 */
640 static HDRVR16 DRIVER_CreateDrvr16()
641 {
642 static WORD DRIVER_hDrvr16Counter = 0;
643
644 while (DRIVER_FindFromHDrvr16(++DRIVER_hDrvr16Counter));
645 return DRIVER_hDrvr16Counter;
646 }
647
648 /**************************************************************************
649 * DRIVER_CloseDriver [internal]
650 *
651 */
652 BOOL DRIVER_CloseDriver(LPWINE_DRIVER lpDrv, DWORD lParam1, DWORD lParam2)
653 {
654 if (lpDrv != NULL) {
655 SendDriverMessage((HDRVR)lpDrv, DRV_CLOSE, lParam1, lParam2);
656
657 if (DRIVER_RemoveFromList(lpDrv)) {
658 HeapFree(GetProcessHeap(), 0, lpDrv);
659 return TRUE;
660 }
661 }
662 WARN("Failed to close driver\n");
663 return FALSE;
664 }
665
666 /**************************************************************************
667 * DRIVER_RegisterDriver16 [internal]
668 *
669 * Creates all the WINE internal representations for a 16 bit driver.
670 * The driver is also open by sending the correct messages.
671 */
672 LPWINE_DRIVER DRIVER_RegisterDriver16(LPCSTR lpName, HMODULE16 hModule, DRIVERPROC16 lpProc,
673 LPARAM lParam, BOOL bCallFrom32)
674 {
675 LPWINE_DRIVER lpDrv;
676
677 lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
678 if (lpDrv != NULL) {
679 lpDrv->dwFlags = WINE_GDF_EXIST|WINE_GDF_16BIT;
680 lpDrv->dwDriverID = 0;
681 lpDrv->hDriver16 = DRIVER_CreateDrvr16();
682 lstrcpynA(lpDrv->szAliasName, lpName, sizeof(lpDrv->szAliasName));
683 lpDrv->d.d16.hModule = hModule;
684 lpDrv->d.d16.lpDrvProc = lpProc;
685
686 if (!DRIVER_AddToList(lpDrv, lParam, bCallFrom32)) {
687 HeapFree(GetProcessHeap(), 0, lpDrv);
688 lpDrv = NULL;
689 }
690 }
691 return lpDrv;
692 }
693
694 /**************************************************************************
695 * DRIVER_RegisterDriver32 [internal]
696 *
697 * Creates all the WINE internal representations for a 32 bit driver.
698 * The driver is also open by sending the correct messages.
699 */
700 LPWINE_DRIVER DRIVER_RegisterDriver32(LPCSTR lpName, HMODULE hModule, DRIVERPROC lpProc,
701 LPARAM lParam, BOOL bCallFrom32)
702 {
703 LPWINE_DRIVER lpDrv;
704
705 lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
706 if (lpDrv != NULL) {
707 lpDrv->dwFlags = WINE_GDF_EXIST;
708 lpDrv->dwDriverID = 0;
709 lpDrv->hDriver16 = DRIVER_CreateDrvr16();
710 lstrcpynA(lpDrv->szAliasName, lpName, sizeof(lpDrv->szAliasName));
711 lpDrv->d.d32.hModule = hModule;
712 lpDrv->d.d32.lpDrvProc = lpProc;
713
714 if (!DRIVER_AddToList(lpDrv, lParam, bCallFrom32)) {
715 HeapFree(GetProcessHeap(), 0, lpDrv);
716 lpDrv = NULL;
717 }
718 }
719 return lpDrv;
720 }
721
722 /**************************************************************************
723 * DRIVER_TryOpenDriver16 [internal]
724 *
725 * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
726 */
727 static HDRVR16 DRIVER_TryOpenDriver16(LPCSTR lpFileName, LPARAM lParam, BOOL bCallFrom32)
728 {
729 LPWINE_DRIVER lpDrv = NULL;
730 LPCSTR lpSFN;
731 HMODULE16 hModule;
732 DRIVERPROC16 lpProc;
733
734 TRACE("('%s', %08lX, %d);\n", lpFileName, lParam, bCallFrom32);
735
736 if (lstrlenA(lpFileName) < 1)
737 return 0;
738
739 lpSFN = strrchr(lpFileName, '\\');
740 lpSFN = (lpSFN) ? (lpSFN + 1) : lpFileName;
741
742 if ((hModule = LoadModule16(lpFileName, (LPVOID)-1)) >= 32) {
743 if ((lpProc = (DRIVERPROC16)WIN32_GetProcAddress16(hModule, "DRIVERPROC")) != NULL) {
744 lpDrv = DRIVER_RegisterDriver16(lpSFN, hModule, lpProc, lParam, bCallFrom32);
745 } else {
746 FreeLibrary16(hModule);
747 TRACE("No DriverProc found\n");
748 lpDrv = 0;
749 }
750 } else {
751 TRACE("Unable to load 16 bit module (%s): %d\n", lpFileName, hModule);
752 }
753 return lpDrv ? lpDrv->hDriver16 : 0;
754 }
755
756 /**************************************************************************
757 * DRIVER_TryOpenDriver32 [internal]
758 *
759 * Tries to load a 32 bit driver whose DLL's (module) name is lpFileName.
760 */
761 static HDRVR DRIVER_TryOpenDriver32(LPCSTR lpFileName, LPARAM lParam, BOOL bCallFrom32)
762 {
763 LPWINE_DRIVER lpDrv = NULL;
764 LPCSTR lpSFN;
765 HMODULE hModule;
766 DRIVERPROC lpProc;
767
768 TRACE("('%s', %08lX, %d);\n", lpFileName, lParam, bCallFrom32);
769
770 if (lstrlenA(lpFileName) < 1)
771 return 0;
772
773 lpSFN = strrchr(lpFileName, '\\');
774 lpSFN = (lpSFN) ? (lpSFN + 1) : lpFileName;
775
776 if ((hModule = LoadLibraryA(lpFileName)) != 0) {
777 if ((lpProc = GetProcAddress(hModule, "DriverProc")) != NULL) {
778 lpDrv = DRIVER_RegisterDriver32(lpSFN, hModule, lpProc, lParam, bCallFrom32);
779 } else {
780 FreeLibrary(hModule);
781 lpDrv = 0;
782 TRACE("No DriverProc found\n");
783 }
784 } else {
785 TRACE("Unable to load 32 bit module \"%s\"\n", lpFileName);
786 }
787 TRACE("=> %p\n", lpDrv);
788 return (HDRVR)lpDrv;
789 }
790
791 /**************************************************************************
792 * OpenDriver16 [USER.252]
793 */
794 HDRVR16 WINAPI OpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
795 {
796 HDRVR16 hDriver = 0;
797 char drvName[128];
798
799 TRACE("('%s', '%s', %08lX);\n", lpDriverName, lpSectionName, lParam);
800
801 if (lpSectionName == NULL) {
802 hDriver = DRIVER_TryOpenDriver16(lpDriverName, lParam, FALSE);
803 if (!hDriver) {
804 hDriver = DRIVER_TryOpenDriver32(lpDriverName, lParam, FALSE);
805 }
806 if (!hDriver) {
807 /* in case hDriver is NULL, search in Drivers32 section */
808 lpSectionName = "Drivers";
809 }
810 }
811 if (!hDriver && GetPrivateProfileStringA(lpSectionName, lpDriverName, "",
812 drvName, sizeof(drvName), "SYSTEM.INI") > 0) {
813 hDriver = DRIVER_TryOpenDriver16(drvName, lParam, FALSE);
814 }
815 if (!hDriver)
816 ERR("Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
817 else
818 TRACE("=> %08x\n", hDriver);
819 return hDriver;
820 }
821
822 /**************************************************************************
823 * OpenDriverA [WINMM.15]
824 * (0,1,DRV_LOAD ,0 ,0)
825 * (0,1,DRV_ENABLE,0 ,0)
826 * (0,1,DRV_OPEN ,buf[256],0)
827 */
828 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
829 {
830 HDRVR hDriver = 0;
831 char drvName[128];
832
833 TRACE("('%s', '%s', %08lX);\n", lpDriverName, lpSectionName, lParam);
834
835 if (lpSectionName == NULL) {
836 lstrcpynA(drvName, lpDriverName, sizeof(drvName));
837 hDriver = DRIVER_TryOpenDriver32(lpDriverName, lParam, TRUE);
838 if (!hDriver) {
839 hDriver = DRIVER_TryOpenDriver16(lpDriverName, lParam, TRUE);
840 }
841 if (!hDriver) {
842 if (GetPrivateProfileStringA("Drivers32", lpDriverName, "", drvName,
843 sizeof(drvName), "SYSTEM.INI")) {
844 hDriver = DRIVER_TryOpenDriver32(drvName, lParam, TRUE);
845
846 }
847 }
848 if (!hDriver) {
849 if (GetPrivateProfileStringA("Drivers", lpDriverName, "", drvName,
850 sizeof(drvName), "SYSTEM.INI")) {
851 hDriver = DRIVER_TryOpenDriver16(drvName, lParam, TRUE);
852
853 }
854 }
855 } else {
856 if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
857 sizeof(drvName), "SYSTEM.INI")) {
858 hDriver = DRIVER_TryOpenDriver32(drvName, lParam, TRUE);
859 if (!hDriver) {
860 hDriver = DRIVER_TryOpenDriver16(drvName, lParam, TRUE);
861 }
862 }
863 }
864 if (!hDriver)
865 ERR("Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
866 else
867 TRACE("=> %08x\n", hDriver);
868 return hDriver;
869 }
870
871 /**************************************************************************
872 * OpenDriverW [WINMM.15]
873 */
874 HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
875 {
876 LPSTR dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
877 LPSTR sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
878 HDRVR ret = OpenDriverA(dn, sn, lParam);
879
880 if (dn) HeapFree(GetProcessHeap(), 0, dn);
881 if (sn) HeapFree(GetProcessHeap(), 0, sn);
882 return ret;
883 }
884
885 /**************************************************************************
886 * CloseDriver16 [USER.253]
887 */
888 LRESULT WINAPI CloseDriver16(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
889 {
890 TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
891
892 return DRIVER_CloseDriver(DRIVER_FindFromHDrvr16(hDrvr), lParam1, lParam2);
893 }
894
895 /**************************************************************************
896 * CloseDriver [WINMM.4]
897 */
898 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
899 {
900 TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
901
902 return DRIVER_CloseDriver(DRIVER_FindFromHDrvr(hDrvr), lParam1, lParam2);
903 }
904
905 /**************************************************************************
906 * GetDriverModuleHandle [USER.254]
907 */
908 HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16 hDrvr)
909 {
910 LPWINE_DRIVER lpDrv;
911 HMODULE16 hModule = 0;
912
913 TRACE("(%04x);\n", hDrvr);
914
915 lpDrv = DRIVER_FindFromHDrvr16(hDrvr);
916 if (lpDrv != NULL && lpDrv->hDriver16 == hDrvr && (lpDrv->dwFlags & WINE_GDF_16BIT)) {
917 hModule = lpDrv->d.d16.hModule;
918 }
919 TRACE("=> %d\n", hModule);
920 return hModule;
921 }
922
923 /**************************************************************************
924 * GetDriverFlags [WINMM.13]
925 * [in] hDrvr handle to the driver
926 *
927 * Returns:
928 * 0x00000000 if hDrvr is an invalid handle
929 * 0x80000000 if hDrvr is a valid 32 bit driver
930 * 0x90000000 if hDrvr is a valid 16 bit driver
931 */
932 DWORD WINAPI GetDriverFlags(HDRVR hDrvr)
933 {
934 LPWINE_DRIVER lpDrv;
935 DWORD ret = 0;
936
937 TRACE("(%04x)\n", hDrvr);
938
939 if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
940 ret = lpDrv->dwFlags;
941 }
942 return ret;
943 }
944
945 /**************************************************************************
946 * GetDriverModuleHandle [WINMM.14]
947 */
948 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
949 {
950 LPWINE_DRIVER lpDrv;
951 HMODULE hModule = 0;
952
953 TRACE("(%04x);\n", hDrvr);
954
955 lpDrv = DRIVER_FindFromHDrvr(hDrvr);
956 if (lpDrv != NULL && !(lpDrv->dwFlags & WINE_GDF_16BIT)) {
957 hModule = lpDrv->d.d32.hModule;
958 }
959 TRACE("=> %d\n", hModule);
960 return hModule;
961 }
962
963 /**************************************************************************
964 * DefDriverProc16 [USER.255]
965 */
966 LRESULT WINAPI DefDriverProc16(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
967 LPARAM lParam1, LPARAM lParam2)
968 {
969 TRACE("devID=0x%08lx hDrv=0x%04x wMsg=%04x lP1=0x%08lx lP2=0x%08lx\n",
970 dwDevID, hDriv, wMsg, lParam1, lParam2);
971
972 switch(wMsg) {
973 case DRV_LOAD:
974 case DRV_FREE:
975 case DRV_ENABLE:
976 case DRV_DISABLE:
977 return (LRESULT)1L;
978 case DRV_OPEN:
979 case DRV_CLOSE:
980 case DRV_QUERYCONFIGURE:
981 return (LRESULT)0L;
982 case DRV_CONFIGURE:
983 MessageBoxA(0, "Driver isn't configurable !", "Wine Driver", MB_OK);
984 return (LRESULT)0L;
985 case DRV_INSTALL:
986 case DRV_REMOVE:
987 return DRV_SUCCESS;
988 default:
989 return (LRESULT)0L;
990 }
991 }
992
993 /**************************************************************************
994 * GetDriverInfo [USER.256]
995 */
996 BOOL16 WINAPI GetDriverInfo16(HDRVR16 hDrvr, LPDRIVERINFOSTRUCT16 lpDrvInfo)
997 {
998 LPWINE_DRIVER lpDrv;
999 BOOL16 ret = FALSE;
1000
1001 TRACE("(%04x, %p);\n", hDrvr, lpDrvInfo);
1002
1003 if (lpDrvInfo == NULL || lpDrvInfo->length != sizeof(DRIVERINFOSTRUCT16))
1004 return FALSE;
1005
1006 lpDrv = DRIVER_FindFromHDrvr16(hDrvr);
1007 if (lpDrv != NULL && lpDrv->hDriver16 == hDrvr &&
1008 (lpDrv->dwFlags & WINE_GDF_16BIT)) {
1009 lpDrvInfo->hDriver = lpDrv->hDriver16;
1010 lpDrvInfo->hModule = lpDrv->d.d16.hModule;
1011 lstrcpynA(lpDrvInfo->szAliasName, lpDrv->szAliasName, sizeof(lpDrvInfo->szAliasName));
1012 ret = TRUE;
1013 }
1014
1015 return ret;
1016 }
1017
1018 /**************************************************************************
1019 * GetNextDriver [USER.257]
1020 */
1021 HDRVR16 WINAPI GetNextDriver16(HDRVR16 hDrvr, DWORD dwFlags)
1022 {
1023 HDRVR16 hRetDrv = 0;
1024 LPWINE_DRIVER lpDrv;
1025
1026 TRACE("(%04x, %08lX);\n", hDrvr, dwFlags);
1027
1028 if (hDrvr == 0) {
1029 if (lpDrvItemList == NULL) {
1030 FIXME("drivers list empty !\n");
1031 /* FIXME: code was using DRIVER_LoadStartupDrivers(); before ?
1032 * I (EPP) don't quite understand this
1033 */
1034 if (lpDrvItemList == NULL)
1035 return 0;
1036 }
1037 lpDrv = lpDrvItemList;
1038 if (dwFlags & GND_REVERSE) {
1039 while (lpDrv->lpNextItem)
1040 lpDrv = lpDrv->lpNextItem;
1041 }
1042 } else {
1043 lpDrv = DRIVER_FindFromHDrvr16(hDrvr);
1044 if (lpDrv != NULL) {
1045 if (dwFlags & GND_REVERSE) {
1046 lpDrv = (lpDrv->lpPrevItem) ? lpDrv->lpPrevItem : NULL;
1047 } else {
1048 lpDrv = (lpDrv->lpNextItem) ? lpDrv->lpNextItem : NULL;
1049 }
1050 }
1051 }
1052
1053 hRetDrv = (lpDrv) ? lpDrv->hDriver16 : (HDRVR16)0;
1054 TRACE("return %04x !\n", hRetDrv);
1055 return hRetDrv;
1056 }
1057
Maarten's multimedia branch