dlls/winmm/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  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include <string.h>
  26 #include "heap.h"
  27 #include "windef.h"
  28 #include "mmddk.h"
  29 #include "winemm.h"
  30 #include "wine/winbase16.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(driver);
  34
  35 static LPWINE_DRIVER    lpDrvItemList = NULL;
  36
  37 /**************************************************************************
  38  *                      DRIVER_GetNumberOfModuleRefs            [internal]
  39  *
  40  * Returns the number of open drivers which share the same module.
  41  */
  42 static  unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** found)
  43 {
  44     LPWINE_DRIVER       lpDrv;
  45     unsigned            count = 0;
  46
  47     if (found) *found = NULL;
  48     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
  49     {
  50         if (!(lpDrv->dwFlags & WINE_GDF_16BIT) && lpDrv->d.d32.hModule == hModule)
  51         {
  52             if (found && !*found) *found = lpDrv;
  53             count++;
  54         }
  55     }
  56     return count;
  57 }
  58
  59 /**************************************************************************
  60  *                              DRIVER_FindFromHDrvr            [internal]
  61  *
  62  * From a hDrvr being 32 bits, returns the WINE internal structure.
  63  */
  64 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
  65 {
  66     LPWINE_DRIVER       d = (LPWINE_DRIVER)hDrvr;
  67
  68     if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
  69         return d;
  70     }
  71     return NULL;
  72 }
  73
  74 /**************************************************************************
  75  *                              DRIVER_SendMessage              [internal]
  76  */
  77 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
  78                                         LPARAM lParam1, LPARAM lParam2)
  79 {
  80     if (lpDrv->dwFlags & WINE_GDF_16BIT) {
  81         LRESULT         ret;
  82         int             map = 0;
  83         TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
  84               lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
  85
  86         if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
  87             ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
  88             if (map == 1)
  89                 DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
  90         } else {
  91             ret = 0;
  92         }
  93         return ret;
  94     }
  95     TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n",
  96           lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
  97     return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
  98 }
  99
 100 /**************************************************************************
 101  *                              SendDriverMessage               [WINMM.@]
 102  *                              DrvSendMessage                  [WINMM.@]
 103  */
 104 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
 105                                  LPARAM lParam2)
 106 {
 107     LPWINE_DRIVER       lpDrv;
 108     LRESULT             retval = 0;
 109
 110     TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
 111
 112     if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
 113         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
 114     } else {
 115         WARN("Bad driver handle %u\n", hDriver);
 116     }
 117     TRACE("retval = %ld\n", retval);
 118
 119     return retval;
 120 }
 121
 122 /**************************************************************************
 123  *                              DRIVER_RemoveFromList           [internal]
 124  *
 125  * Generates all the logic to handle driver closure / deletion
 126  * Removes a driver struct to the list of open drivers.
 127  */
 128 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
 129 {
 130     if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
 131         /* last of this driver in list ? */
 132         if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 1) {
 133             DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
 134             DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
 135         }
 136     }
 137
 138     if (lpDrv->lpPrevItem)
 139         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
 140     else
 141         lpDrvItemList = lpDrv->lpNextItem;
 142     if (lpDrv->lpNextItem)
 143         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
 144     /* trash magic number */
 145     lpDrv->dwMagic ^= 0xa5a5a5a5;
 146
 147     return TRUE;
 148 }
 149
 150 /**************************************************************************
 151  *                              DRIVER_AddToList                [internal]
 152  *
 153  * Adds a driver struct to the list of open drivers.
 154  * Generates all the logic to handle driver creation / open.
 155  */
 156 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
 157 {
 158     lpNewDrv->dwMagic = WINE_DI_MAGIC;
 159     /* First driver to be loaded for this module, need to load correctly the module */
 160     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
 161         /* first of this driver in list ? */
 162         if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
 163             if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
 164                 TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 165                 return FALSE;
 166             }
 167             /* returned value is not checked */
 168             DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
 169         }
 170     }
 171
 172     lpNewDrv->lpNextItem = NULL;
 173     if (lpDrvItemList == NULL) {
 174         lpDrvItemList = lpNewDrv;
 175         lpNewDrv->lpPrevItem = NULL;
 176     } else {
 177         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
 178         while (lpDrv->lpNextItem != NULL)
 179             lpDrv = lpDrv->lpNextItem;
 180
 181         lpDrv->lpNextItem = lpNewDrv;
 182         lpNewDrv->lpPrevItem = lpDrv;
 183     }
 184
 185     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
 186         /* Now just open a new instance of a driver on this module */
 187         lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
 188
 189         if (lpNewDrv->d.d32.dwDriverID == 0) {
 190             TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 191             DRIVER_RemoveFromList(lpNewDrv);
 192             return FALSE;
 193         }
 194     }
 195     return TRUE;
 196 }
 197
 198 /**************************************************************************
 199  *                              DRIVER_GetLibName               [internal]
 200  *
 201  */
 202 BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
 203 {
 204     /* should also do some registry diving */
 205     return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI");
 206 }
 207
 208 /**************************************************************************
 209  *                              DRIVER_TryOpenDriver32          [internal]
 210  *
 211  * Tries to load a 32 bit driver whose DLL's (module) name is fn
 212  */
 213 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
 214 {
 215     LPWINE_DRIVER       lpDrv = NULL;
 216     HMODULE             hModule = 0;
 217     LPSTR               ptr;
 218     LPCSTR              cause = 0;
 219
 220     TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2);
 221
 222     if ((ptr = strchr(fn, ' ')) != NULL) {
 223         *ptr++ = '\0';
 224         while (*ptr == ' ') ptr++;
 225         if (*ptr == '\0') ptr = NULL;
 226     }
 227
 228     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 229     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
 230
 231     if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
 232
 233     lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
 234     if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
 235
 236     lpDrv->dwFlags          = 0;
 237     lpDrv->d.d32.hModule    = hModule;
 238     lpDrv->d.d32.dwDriverID = 0;
 239
 240     /* Win32 installable drivers must support a two phase opening scheme:
 241      * + first open with NULL as lParam2 (session instance),
 242      * + then do a second open with the real non null lParam2)
 243      */
 244     if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 0 && lParam2)
 245     {
 246         LPWINE_DRIVER   ret;
 247
 248         if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
 249         {
 250             cause = "load0 failed";
 251             goto exit;
 252         }
 253         ret = DRIVER_TryOpenDriver32(fn, lParam2);
 254         if (!ret)
 255         {
 256             CloseDriver((HDRVR)lpDrv, 0L, 0L);
 257             cause = "load1 failed";
 258             goto exit;
 259         }
 260         return ret;
 261     }
 262
 263     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
 264     {cause = "load failed"; goto exit;}
 265
 266     TRACE("=> %p\n", lpDrv);
 267     return lpDrv;
 268  exit:
 269     FreeLibrary(hModule);
 270     HeapFree(GetProcessHeap(), 0, lpDrv);
 271     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
 272     return NULL;
 273 }
 274
 275 /**************************************************************************
 276  *                              DRIVER_TryOpenDriver16          [internal]
 277  *
 278  * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
 279  */
 280 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
 281 {
 282     LPWINE_DRIVER       lpDrv = NULL;
 283     LPCSTR              cause = 0;
 284
 285     TRACE("(%s, %08lX);\n", debugstr_a(sn), lParam2);
 286
 287     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 288     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
 289
 290     /* FIXME: shall we do some black magic here on sn ?
 291      *  drivers32 => drivers
 292      *  mci32 => mci
 293      * ...
 294      */
 295     lpDrv->d.d16.hDriver16 = OpenDriver16(fn, sn, lParam2);
 296     if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
 297     lpDrv->dwFlags = WINE_GDF_16BIT;
 298
 299     if (!DRIVER_AddToList(lpDrv, 0, lParam2)) {cause = "load failed"; goto exit;}
 300
 301     TRACE("=> %p\n", lpDrv);
 302     return lpDrv;
 303  exit:
 304     HeapFree(GetProcessHeap(), 0, lpDrv);
 305     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
 306     return NULL;
 307 }
 308
 309 /**************************************************************************
 310  *                              OpenDriverA                     [WINMM.@]
 311  *                              DrvOpenA                        [WINMM.@]
 312  * (0,1,DRV_LOAD  ,0       ,0)
 313  * (0,1,DRV_ENABLE,0       ,0)
 314  * (0,1,DRV_OPEN  ,buf[256],0)
 315  */
 316 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
 317 {
 318     LPWINE_DRIVER       lpDrv = NULL;
 319     char                libName[128];
 320     LPCSTR              lsn = lpSectionName;
 321
 322     TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
 323
 324     if (lsn == NULL) {
 325         lstrcpynA(libName, lpDriverName, sizeof(libName));
 326
 327         if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 328             goto the_end;
 329         lsn = "Drivers32";
 330     }
 331     if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
 332         (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 333         goto the_end;
 334
 335     if (!(lpDrv = DRIVER_TryOpenDriver16(lpDriverName, lpSectionName, lParam2)))
 336         TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
 337  the_end:
 338     if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
 339     return (HDRVR)lpDrv;
 340 }
 341
 342 /**************************************************************************
 343  *                              OpenDriver                      [WINMM.@]
 344  *                              DrvOpen                         [WINMM.@]
 345  */
 346 HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
 347 {
 348     LPSTR               dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
 349     LPSTR               sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
 350     HDRVR               ret = OpenDriverA(dn, sn, lParam);
 351
 352     if (dn) HeapFree(GetProcessHeap(), 0, dn);
 353     if (sn) HeapFree(GetProcessHeap(), 0, sn);
 354     return ret;
 355 }
 356
 357 /**************************************************************************
 358  *                      CloseDriver                             [WINMM.@]
 359  *                      DrvClose                                [WINMM.@]
 360  */
 361 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 362 {
 363     LPWINE_DRIVER       lpDrv;
 364
 365     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 366
 367     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
 368     {
 369         if (lpDrv->dwFlags & WINE_GDF_16BIT)
 370             CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
 371         else
 372         {
 373             DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
 374             lpDrv->d.d32.dwDriverID = 0;
 375         }
 376         if (DRIVER_RemoveFromList(lpDrv)) {
 377             if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
 378             {
 379                 LPWINE_DRIVER       lpDrv0;
 380
 381                 /* if driver has an opened session instance, we have to close it too */
 382                 if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, &lpDrv0) == 1)
 383                 {
 384                     DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
 385                     lpDrv0->d.d32.dwDriverID = 0;
 386                     DRIVER_RemoveFromList(lpDrv0);
 387                     FreeLibrary(lpDrv->d.d32.hModule);
 388                     HeapFree(GetProcessHeap(), 0, lpDrv0);
 389                 }
 390                 FreeLibrary(lpDrv->d.d32.hModule);
 391             }
 392             HeapFree(GetProcessHeap(), 0, lpDrv);
 393             return TRUE;
 394         }
 395     }
 396     WARN("Failed to close driver\n");
 397     return FALSE;
 398 }
 399
 400 /**************************************************************************
 401  *                              GetDriverFlags          [WINMM.@]
 402  * [in] hDrvr handle to the driver
 403  *
 404  * Returns:
 405  *      0x00000000 if hDrvr is an invalid handle
 406  *      0x80000000 if hDrvr is a valid 32 bit driver
 407  *      0x90000000 if hDrvr is a valid 16 bit driver
 408  *
 409  * native WINMM doesn't return those flags
 410  *      0x80000000 for a valid 32 bit driver and that's it
 411  *      (I may have mixed up the two flags :-(
 412  */
 413 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
 414 {
 415     LPWINE_DRIVER       lpDrv;
 416     DWORD               ret = 0;
 417
 418     TRACE("(%04x)\n", hDrvr);
 419
 420     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 421         ret = WINE_GDF_EXIST | lpDrv->dwFlags;
 422     }
 423     return ret;
 424 }
 425
 426 /**************************************************************************
 427  *                              GetDriverModuleHandle   [WINMM.@]
 428  *                              DrvGetModuleHandle      [WINMM.@]
 429  */
 430 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
 431 {
 432     LPWINE_DRIVER       lpDrv;
 433     HMODULE             hModule = 0;
 434
 435     TRACE("(%04x);\n", hDrvr);
 436
 437     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 438         if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
 439             hModule = lpDrv->d.d32.hModule;
 440     }
 441     TRACE("=> %04x\n", hModule);
 442     return hModule;
 443 }
 444
 445 /**************************************************************************
 446  *                              DefDriverProc                     [WINMM.@]
 447  *                              DrvDefDriverProc                  [WINMM.@]
 448  */
 449 LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
 450                              UINT Msg, LPARAM lParam1, LPARAM lParam2)
 451 {
 452     switch (Msg) {
 453     case DRV_LOAD:
 454     case DRV_FREE:
 455     case DRV_ENABLE:
 456     case DRV_DISABLE:
 457         return 1;
 458     case DRV_INSTALL:
 459     case DRV_REMOVE:
 460         return DRV_SUCCESS;
 461     default:
 462         return 0;
 463     }
 464 }