windows/driver.c

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