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