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) || (wMsg >= 0x4000 && wMsg < 0x4100 )) {
 224             /* FIXME: another hack to handle MCI and ICM 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) || (wMsg >= 0x4000 && wMsg < 0x4100 )) {
 290             /* FIXME: another hack to handle MCI and ICM 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) || (wMsg >= 0x4000 && wMsg < 0x4100 )) {
 400             /* FIXME: another hack to handle MCI and ICM 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) || (wMsg >= 0x4000 && wMsg < 0x4100 )) {
 470             /* FIXME: another hack to handle MCI and ICM 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     /* Now just open a new instance of a driver on this module */
 621     if (bCallFrom32) {
 622         lpNewDrv->dwDriverID = SendDriverMessage((HDRVR)lpNewDrv, DRV_OPEN, 0L, lParam);
 623     } else {
 624         lpNewDrv->dwDriverID = SendDriverMessage16(lpNewDrv->hDriver16, DRV_OPEN, 0L, lParam);
 625     }
 626     if (lpNewDrv->dwDriverID == 0) {
 627         TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 628         DRIVER_RemoveFromList(lpNewDrv);
 629         return FALSE;
 630     }
 631
 632     return TRUE;
 633 }
 634
 635 /**************************************************************************
 636  *                              DRIVER_CreateDrvr16             [internal]
 637  *
 638  * Creates unique ID for 16 bit drivers.
 639  */
 640 static  HDRVR16 DRIVER_CreateDrvr16()
 641 {
 642     static      WORD    DRIVER_hDrvr16Counter = 0;
 643
 644     while (DRIVER_FindFromHDrvr16(++DRIVER_hDrvr16Counter));
 645     return DRIVER_hDrvr16Counter;
 646 }
 647
 648 /**************************************************************************
 649  *                              DRIVER_CloseDriver              [internal]
 650  *
 651  */
 652 BOOL DRIVER_CloseDriver(LPWINE_DRIVER lpDrv, DWORD lParam1, DWORD lParam2)
 653 {
 654     if (lpDrv != NULL) {
 655         SendDriverMessage((HDRVR)lpDrv, DRV_CLOSE, lParam1, lParam2);
 656
 657         if (DRIVER_RemoveFromList(lpDrv)) {
 658             HeapFree(GetProcessHeap(), 0, lpDrv);
 659             return TRUE;
 660         }
 661     }
 662     WARN("Failed to close driver\n");
 663     return FALSE;
 664 }
 665
 666 /**************************************************************************
 667  *                              DRIVER_RegisterDriver16         [internal]
 668  *
 669  * Creates all the WINE internal representations for a 16 bit driver.
 670  * The driver is also open by sending the correct messages.
 671  */
 672 LPWINE_DRIVER DRIVER_RegisterDriver16(LPCSTR lpName, HMODULE16 hModule, DRIVERPROC16 lpProc,
 673                                       LPARAM lParam, BOOL bCallFrom32)
 674 {
 675     LPWINE_DRIVER       lpDrv;
 676
 677     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 678     if (lpDrv != NULL) {
 679         lpDrv->dwFlags         = WINE_GDF_EXIST|WINE_GDF_16BIT;
 680         lpDrv->dwDriverID      = 0;
 681         lpDrv->hDriver16       = DRIVER_CreateDrvr16();
 682         lstrcpynA(lpDrv->szAliasName, lpName, sizeof(lpDrv->szAliasName));
 683         lpDrv->d.d16.hModule   = hModule;
 684         lpDrv->d.d16.lpDrvProc = lpProc;
 685
 686         if (!DRIVER_AddToList(lpDrv, lParam, bCallFrom32)) {
 687             HeapFree(GetProcessHeap(), 0, lpDrv);
 688             lpDrv = NULL;
 689         }
 690     }
 691     return lpDrv;
 692 }
 693
 694 /**************************************************************************
 695  *                              DRIVER_RegisterDriver32         [internal]
 696  *
 697  * Creates all the WINE internal representations for a 32 bit driver.
 698  * The driver is also open by sending the correct messages.
 699  */
 700 LPWINE_DRIVER DRIVER_RegisterDriver32(LPCSTR lpName, HMODULE hModule, DRIVERPROC lpProc,
 701                                       LPARAM lParam, BOOL bCallFrom32)
 702 {
 703     LPWINE_DRIVER       lpDrv;
 704
 705     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 706     if (lpDrv != NULL) {
 707         lpDrv->dwFlags          = WINE_GDF_EXIST;
 708         lpDrv->dwDriverID       = 0;
 709         lpDrv->hDriver16        = DRIVER_CreateDrvr16();
 710         lstrcpynA(lpDrv->szAliasName, lpName, sizeof(lpDrv->szAliasName));
 711         lpDrv->d.d32.hModule    = hModule;
 712         lpDrv->d.d32.lpDrvProc  = lpProc;
 713
 714         if (!DRIVER_AddToList(lpDrv, lParam, bCallFrom32)) {
 715             HeapFree(GetProcessHeap(), 0, lpDrv);
 716             lpDrv = NULL;
 717         }
 718     }
 719     return lpDrv;
 720 }
 721
 722 /**************************************************************************
 723  *                              DRIVER_TryOpenDriver16          [internal]
 724  *
 725  * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
 726  */
 727 static  HDRVR16 DRIVER_TryOpenDriver16(LPCSTR lpFileName, LPARAM lParam, BOOL bCallFrom32)
 728 {
 729     LPWINE_DRIVER       lpDrv = NULL;
 730     LPCSTR              lpSFN;
 731     HMODULE16           hModule;
 732     DRIVERPROC16        lpProc;
 733
 734     TRACE("('%s', %08lX, %d);\n", lpFileName, lParam, bCallFrom32);
 735
 736     if (lstrlenA(lpFileName) < 1)
 737         return 0;
 738
 739     lpSFN = strrchr(lpFileName, '\\');
 740     lpSFN = (lpSFN) ? (lpSFN + 1) : lpFileName;
 741
 742     if ((hModule = LoadModule16(lpFileName, (LPVOID)-1)) >= 32) {
 743         if ((lpProc = (DRIVERPROC16)WIN32_GetProcAddress16(hModule, "DRIVERPROC")) != NULL) {
 744             lpDrv = DRIVER_RegisterDriver16(lpSFN, hModule, lpProc, lParam, bCallFrom32);
 745         } else {
 746             FreeLibrary16(hModule);
 747             TRACE("No DriverProc found\n");
 748             lpDrv = 0;
 749         }
 750     } else {
 751         TRACE("Unable to load 16 bit module (%s): %d\n", lpFileName, hModule);
 752     }
 753     return lpDrv ? lpDrv->hDriver16 : 0;
 754 }
 755
 756 /**************************************************************************
 757  *                              DRIVER_TryOpenDriver32          [internal]
 758  *
 759  * Tries to load a 32 bit driver whose DLL's (module) name is lpFileName.
 760  */
 761 static  HDRVR   DRIVER_TryOpenDriver32(LPCSTR lpFileName, LPARAM lParam, BOOL bCallFrom32)
 762 {
 763     LPWINE_DRIVER       lpDrv = NULL;
 764     LPCSTR              lpSFN;
 765     HMODULE             hModule;
 766     DRIVERPROC          lpProc;
 767
 768     TRACE("('%s', %08lX, %d);\n", lpFileName, lParam, bCallFrom32);
 769
 770     if (lstrlenA(lpFileName) < 1)
 771         return 0;
 772
 773     lpSFN = strrchr(lpFileName, '\\');
 774     lpSFN = (lpSFN) ? (lpSFN + 1) : lpFileName;
 775
 776     if ((hModule = LoadLibraryA(lpFileName)) != 0) {
 777         if ((lpProc = GetProcAddress(hModule, "DriverProc")) != NULL) {
 778             lpDrv = DRIVER_RegisterDriver32(lpSFN, hModule, lpProc, lParam, bCallFrom32);
 779         } else {
 780             FreeLibrary(hModule);
 781             lpDrv = 0;
 782             TRACE("No DriverProc found\n");
 783         }
 784     } else {
 785         TRACE("Unable to load 32 bit module \"%s\"\n", lpFileName);
 786     }
 787     TRACE("=> %p\n", lpDrv);
 788     return (HDRVR)lpDrv;
 789 }
 790
 791 /**************************************************************************
 792  *                              OpenDriver16                    [USER.252]
 793  */
 794 HDRVR16 WINAPI OpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
 795 {
 796     HDRVR16             hDriver = 0;
 797     char                drvName[128];
 798
 799     TRACE("('%s', '%s', %08lX);\n", lpDriverName, lpSectionName, lParam);
 800
 801     if (lpSectionName == NULL) {
 802         hDriver = DRIVER_TryOpenDriver16(lpDriverName, lParam, FALSE);
 803         if (!hDriver) {
 804             hDriver = DRIVER_TryOpenDriver32(lpDriverName, lParam, FALSE);
 805         }
 806         if (!hDriver) {
 807             /* in case hDriver is NULL, search in Drivers32 section */
 808             lpSectionName = "Drivers";
 809         }
 810     }
 811     if (!hDriver && GetPrivateProfileStringA(lpSectionName, lpDriverName, "",
 812                                              drvName, sizeof(drvName), "SYSTEM.INI") > 0) {
 813         hDriver = DRIVER_TryOpenDriver16(drvName, lParam, FALSE);
 814     }
 815     if (!hDriver)
 816         ERR("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
 817     else
 818         TRACE("=> %08x\n", hDriver);
 819     return hDriver;
 820 }
 821
 822 /**************************************************************************
 823  *                              OpenDriverA                     [WINMM.15]
 824  * (0,1,DRV_LOAD  ,0       ,0)
 825  * (0,1,DRV_ENABLE,0       ,0)
 826  * (0,1,DRV_OPEN  ,buf[256],0)
 827  */
 828 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
 829 {
 830     HDRVR               hDriver = 0;
 831     char                drvName[128];
 832
 833     TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam);
 834
 835     if (lpSectionName == NULL) {
 836         lstrcpynA(drvName, lpDriverName, sizeof(drvName));
 837         hDriver = DRIVER_TryOpenDriver32(lpDriverName, lParam, TRUE);
 838         if (!hDriver) {
 839             hDriver = DRIVER_TryOpenDriver16(lpDriverName, lParam, TRUE);
 840         }
 841         if (!hDriver) {
 842             if (GetPrivateProfileStringA("Drivers32", lpDriverName, "", drvName,
 843                                          sizeof(drvName), "SYSTEM.INI")) {
 844                 hDriver = DRIVER_TryOpenDriver32(drvName, lParam, TRUE);
 845
 846             }
 847         }
 848         if (!hDriver) {
 849             if (GetPrivateProfileStringA("Drivers", lpDriverName, "", drvName,
 850                                          sizeof(drvName), "SYSTEM.INI")) {
 851                 hDriver = DRIVER_TryOpenDriver16(drvName, lParam, TRUE);
 852
 853             }
 854         }
 855     } else {
 856         if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
 857                                      sizeof(drvName), "SYSTEM.INI")) {
 858             hDriver = DRIVER_TryOpenDriver32(drvName, lParam, TRUE);
 859             if (!hDriver) {
 860                 hDriver = DRIVER_TryOpenDriver16(drvName, lParam, TRUE);
 861             }
 862         }
 863     }
 864     if (!hDriver)
 865         ERR("Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
 866     else
 867         TRACE("=> %08x\n", hDriver);
 868     return hDriver;
 869 }
 870
 871 /**************************************************************************
 872  *                              OpenDriverW                     [WINMM.15]
 873  */
 874 HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
 875 {
 876     LPSTR               dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
 877     LPSTR               sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
 878     HDRVR               ret = OpenDriverA(dn, sn, lParam);
 879
 880     if (dn) HeapFree(GetProcessHeap(), 0, dn);
 881     if (sn) HeapFree(GetProcessHeap(), 0, sn);
 882     return ret;
 883 }
 884
 885 /**************************************************************************
 886  *                      CloseDriver16                           [USER.253]
 887  */
 888 LRESULT WINAPI CloseDriver16(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
 889 {
 890     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 891
 892     return DRIVER_CloseDriver(DRIVER_FindFromHDrvr16(hDrvr), lParam1, lParam2);
 893 }
 894
 895 /**************************************************************************
 896  *                      CloseDriver                             [WINMM.4]
 897  */
 898 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 899 {
 900     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 901
 902     return DRIVER_CloseDriver(DRIVER_FindFromHDrvr(hDrvr), lParam1, lParam2);
 903 }
 904
 905 /**************************************************************************
 906  *                              GetDriverModuleHandle   [USER.254]
 907  */
 908 HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16 hDrvr)
 909 {
 910     LPWINE_DRIVER       lpDrv;
 911     HMODULE16           hModule = 0;
 912
 913     TRACE("(%04x);\n", hDrvr);
 914
 915     lpDrv = DRIVER_FindFromHDrvr16(hDrvr);
 916     if (lpDrv != NULL && lpDrv->hDriver16 == hDrvr && (lpDrv->dwFlags & WINE_GDF_16BIT)) {
 917         hModule = lpDrv->d.d16.hModule;
 918     }
 919     TRACE("=> %d\n", hModule);
 920     return hModule;
 921 }
 922
 923 /**************************************************************************
 924  *                              GetDriverFlags          [WINMM.13]
 925  * [in] hDrvr handle to the driver
 926  *
 927  * Returns:
 928  *      0x00000000 if hDrvr is an invalid handle
 929  *      0x80000000 if hDrvr is a valid 32 bit driver
 930  *      0x90000000 if hDrvr is a valid 16 bit driver
 931  */
 932 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
 933 {
 934     LPWINE_DRIVER       lpDrv;
 935     DWORD               ret = 0;
 936
 937     TRACE("(%04x)\n", hDrvr);
 938
 939     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 940         ret = lpDrv->dwFlags;
 941     }
 942     return ret;
 943 }
 944
 945 /**************************************************************************
 946  *                              GetDriverModuleHandle   [WINMM.14]
 947  */
 948 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
 949 {
 950     LPWINE_DRIVER       lpDrv;
 951     HMODULE             hModule = 0;
 952
 953     TRACE("(%04x);\n", hDrvr);
 954
 955     lpDrv = DRIVER_FindFromHDrvr(hDrvr);
 956     if (lpDrv != NULL && !(lpDrv->dwFlags & WINE_GDF_16BIT)) {
 957         hModule = lpDrv->d.d32.hModule;
 958     }
 959     TRACE("=> %d\n", hModule);
 960     return hModule;
 961 }
 962
 963 /**************************************************************************
 964  *                              DefDriverProc16                 [USER.255]
 965  */
 966 LRESULT WINAPI DefDriverProc16(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
 967                                LPARAM lParam1, LPARAM lParam2)
 968 {
 969     TRACE("devID=0x%08lx hDrv=0x%04x wMsg=%04x lP1=0x%08lx lP2=0x%08lx\n",
 970           dwDevID, hDriv, wMsg, lParam1, lParam2);
 971
 972     switch(wMsg) {
 973     case DRV_LOAD:
 974     case DRV_FREE:
 975     case DRV_ENABLE:
 976     case DRV_DISABLE:
 977         return (LRESULT)1L;
 978     case DRV_OPEN:
 979     case DRV_CLOSE:
 980     case DRV_QUERYCONFIGURE:
 981         return (LRESULT)0L;
 982     case DRV_CONFIGURE:
 983         MessageBoxA(0, "Driver isn't configurable !", "Wine Driver", MB_OK);
 984         return (LRESULT)0L;
 985     case DRV_INSTALL:
 986     case DRV_REMOVE:
 987         return DRV_SUCCESS;
 988     default:
 989         return (LRESULT)0L;
 990     }
 991 }
 992
 993 /**************************************************************************
 994  *                              GetDriverInfo                   [USER.256]
 995  */
 996 BOOL16 WINAPI GetDriverInfo16(HDRVR16 hDrvr, LPDRIVERINFOSTRUCT16 lpDrvInfo)
 997 {
 998     LPWINE_DRIVER       lpDrv;
 999     BOOL16              ret = FALSE;
1000
1001     TRACE("(%04x, %p);\n", hDrvr, lpDrvInfo);
1002
1003     if (lpDrvInfo == NULL || lpDrvInfo->length != sizeof(DRIVERINFOSTRUCT16))
1004         return FALSE;
1005
1006     lpDrv = DRIVER_FindFromHDrvr16(hDrvr);
1007     if (lpDrv != NULL && lpDrv->hDriver16 == hDrvr &&
1008         (lpDrv->dwFlags & WINE_GDF_16BIT)) {
1009         lpDrvInfo->hDriver = lpDrv->hDriver16;
1010         lpDrvInfo->hModule = lpDrv->d.d16.hModule;
1011         lstrcpynA(lpDrvInfo->szAliasName, lpDrv->szAliasName, sizeof(lpDrvInfo->szAliasName));
1012         ret = TRUE;
1013     }
1014
1015     return ret;
1016 }
1017
1018 /**************************************************************************
1019  *                              GetNextDriver                   [USER.257]
1020  */
1021 HDRVR16 WINAPI GetNextDriver16(HDRVR16 hDrvr, DWORD dwFlags)
1022 {
1023     HDRVR16             hRetDrv = 0;
1024     LPWINE_DRIVER       lpDrv;
1025
1026     TRACE("(%04x, %08lX);\n", hDrvr, dwFlags);
1027
1028     if (hDrvr == 0) {
1029         if (lpDrvItemList == NULL) {
1030             FIXME("drivers list empty !\n");
1031             /* FIXME: code was using DRIVER_LoadStartupDrivers(); before ?
1032              * I (EPP) don't quite understand this
1033              */
1034             if (lpDrvItemList == NULL)
1035                 return 0;
1036         }
1037         lpDrv = lpDrvItemList;
1038         if (dwFlags & GND_REVERSE) {
1039             while (lpDrv->lpNextItem)
1040                 lpDrv = lpDrv->lpNextItem;
1041         }
1042     } else {
1043         lpDrv = DRIVER_FindFromHDrvr16(hDrvr);
1044         if (lpDrv != NULL) {
1045             if (dwFlags & GND_REVERSE) {
1046                 lpDrv = (lpDrv->lpPrevItem) ? lpDrv->lpPrevItem : NULL;
1047             } else {
1048                 lpDrv = (lpDrv->lpNextItem) ? lpDrv->lpNextItem : NULL;
1049             }
1050         }
1051     }
1052
1053     hRetDrv = (lpDrv) ? lpDrv->hDriver16 : (HDRVR16)0;
1054     TRACE("return %04x !\n", hRetDrv);
1055     return hRetDrv;
1056 }
1057