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