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