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,2000 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
  27 #include "windef.h"
  28 #include "wine/winbase16.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "mmddk.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(driver);
  35
  36 typedef struct tagWINE_DRIVER
  37 {
  38     char                        szAliasName[128];
  39     /* as usual LPWINE_DRIVER == hDriver32 */
  40     HDRVR16                     hDriver16;
  41     HMODULE16                   hModule16;
  42     DRIVERPROC16                lpDrvProc;
  43     DWORD                       dwDriverID;
  44     struct tagWINE_DRIVER*      lpPrevItem;
  45     struct tagWINE_DRIVER*      lpNextItem;
  46 } WINE_DRIVER, *LPWINE_DRIVER;
  47
  48 static LPWINE_DRIVER    lpDrvItemList = NULL;
  49
  50 /* TODO list :
  51  *      - LoadModule count and clean up is not handled correctly (it's not a
  52  *        problem as long as FreeLibrary is not working correctly)
  53  */
  54
  55 /* ### start build ### */
  56 extern LONG CALLBACK DRIVER_CallTo16_long_lwwll(FARPROC16,LONG,WORD,WORD,LONG,LONG);
  57 /* ### stop build ### */
  58
  59 /**************************************************************************
  60  *                      LoadStartupDrivers                      [internal]
  61  */
  62 static void WINE_UNUSED DRIVER_LoadStartupDrivers(void)
  63 {
  64     char        str[256];
  65
  66     if (GetPrivateProfileStringA("drivers", NULL, "", str, sizeof(str), "SYSTEM.INI") < 2) {
  67         ERR("Can't find drivers section in system.ini\n");
  68     } else {
  69         HDRVR16 hDrv;
  70         LPSTR   ptr;
  71
  72         for (ptr = str; *ptr; ptr += strlen(ptr) + 1) {
  73             TRACE("str='%s'\n", ptr);
  74             hDrv = OpenDriver16(ptr, "drivers", 0L);
  75             TRACE("hDrv=%04x\n", hDrv);
  76         }
  77         TRACE("end of list !\n");
  78     }
  79 }
  80
  81 /**************************************************************************
  82  *                      DRIVER_GetNumberOfModuleRefs            [internal]
  83  *
  84  * Returns the number of open drivers which share the same module.
  85  */
  86 static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
  87 {
  88     LPWINE_DRIVER       lpDrv;
  89     WORD                count = 0;
  90
  91     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
  92         if (lpDrv->hModule16 == lpNewDrv->hModule16) {
  93             count++;
  94         }
  95     }
  96     return count;
  97 }
  98
  99 /**************************************************************************
 100  *                              DRIVER_FindFromHDrvr16          [internal]
 101  *
 102  * From a hDrvr being 16 bits, returns the WINE internal structure.
 103  */
 104 static  LPWINE_DRIVER   DRIVER_FindFromHDrvr16(HDRVR16 hDrvr)
 105 {
 106     LPWINE_DRIVER       lpDrv;
 107
 108     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
 109         if (lpDrv->hDriver16 == hDrvr) {
 110             break;
 111         }
 112     }
 113     return lpDrv;
 114 }
 115
 116 /**************************************************************************
 117  *                              DRIVER_SendMessage              [internal]
 118  */
 119 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT16 msg,
 120                                          LPARAM lParam1, LPARAM lParam2)
 121 {
 122     TRACE("Before CallDriverProc proc=%p driverID=%08lx wMsg=%04x p1=%08lx p2=%08lx\n",
 123           lpDrv->lpDrvProc, lpDrv->dwDriverID, msg, lParam1, lParam2);
 124     return DRIVER_CallTo16_long_lwwll((FARPROC16)lpDrv->lpDrvProc, lpDrv->dwDriverID,
 125                                       lpDrv->hDriver16, msg, lParam1, lParam2);
 126 }
 127
 128 /**************************************************************************
 129  *              SendDriverMessage (USER.251)
 130  */
 131 LRESULT WINAPI SendDriverMessage16(HDRVR16 hDriver, UINT16 msg, LPARAM lParam1,
 132                                    LPARAM lParam2)
 133 {
 134     LPWINE_DRIVER       lpDrv;
 135     LRESULT             retval = 0;
 136
 137     TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
 138
 139     if ((lpDrv = DRIVER_FindFromHDrvr16(hDriver)) != NULL) {
 140         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
 141     } else {
 142         WARN("Bad driver handle %u\n", hDriver);
 143     }
 144
 145     TRACE("retval = %ld\n", retval);
 146     return retval;
 147 }
 148
 149 /**************************************************************************
 150  *                              DRIVER_RemoveFromList           [internal]
 151  *
 152  * Generates all the logic to handle driver closure / deletion
 153  * Removes a driver struct to the list of open drivers.
 154  */
 155 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
 156 {
 157     lpDrv->dwDriverID = 0;
 158     if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
 159         DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
 160         DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
 161     }
 162
 163     if (lpDrv->lpPrevItem)
 164         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
 165     else
 166         lpDrvItemList = lpDrv->lpNextItem;
 167     if (lpDrv->lpNextItem)
 168         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
 169
 170     return TRUE;
 171 }
 172
 173 /**************************************************************************
 174  *                              DRIVER_AddToList                [internal]
 175  *
 176  * Adds a driver struct to the list of open drivers.
 177  * Generates all the logic to handle driver creation / open.
 178  */
 179 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
 180 {
 181     /* First driver to be loaded for this module, need to load correctly the module */
 182     if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
 183         if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
 184             TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 185             return FALSE;
 186         }
 187         /* returned value is not checked */
 188         DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
 189     }
 190
 191     lpNewDrv->lpNextItem = NULL;
 192     if (lpDrvItemList == NULL) {
 193         lpDrvItemList = lpNewDrv;
 194         lpNewDrv->lpPrevItem = NULL;
 195     } else {
 196         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
 197         while (lpDrv->lpNextItem != NULL)
 198             lpDrv = lpDrv->lpNextItem;
 199
 200         lpDrv->lpNextItem = lpNewDrv;
 201         lpNewDrv->lpPrevItem = lpDrv;
 202     }
 203     /* Now just open a new instance of a driver on this module */
 204     lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
 205
 206     if (lpNewDrv->dwDriverID == 0) {
 207         TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 208         DRIVER_RemoveFromList(lpNewDrv);
 209         return FALSE;
 210     }
 211
 212     return TRUE;
 213 }
 214
 215 /**************************************************************************
 216  *                              DRIVER_TryOpenDriver16          [internal]
 217  *
 218  * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
 219  */
 220 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpFileName, LPARAM lParam2)
 221 {
 222     static      WORD    DRIVER_hDrvr16Counter /* = 0 */;
 223     LPWINE_DRIVER       lpDrv = NULL;
 224     HMODULE16           hModule;
 225     DRIVERPROC16        lpProc;
 226     LPCSTR              lpSFN;
 227     LPSTR               ptr;
 228
 229     TRACE("('%s', %08lX);\n", lpFileName, lParam2);
 230
 231     if (strlen(lpFileName) < 1) return lpDrv;
 232
 233     if ((lpSFN = strrchr(lpFileName, '\\')) == NULL)
 234         lpSFN = lpFileName;
 235     else
 236         lpSFN++;
 237     if ((ptr = strchr(lpFileName, ' ')) != NULL) {
 238         *ptr++ = '\0';
 239         while (*ptr == ' ') ptr++;
 240         if (*ptr == '\0') ptr = NULL;
 241     }
 242
 243     if ((hModule = LoadLibrary16(lpFileName)) < 32) goto exit;
 244     if ((lpProc = (DRIVERPROC16)GetProcAddress16(hModule, "DRIVERPROC")) == NULL)
 245         goto exit;
 246
 247     if ((lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER))) == NULL)
 248         goto exit;
 249
 250     lpDrv->dwDriverID  = 0;
 251     while (DRIVER_FindFromHDrvr16(++DRIVER_hDrvr16Counter));
 252     lpDrv->hDriver16   = DRIVER_hDrvr16Counter;
 253     lstrcpynA(lpDrv->szAliasName, lpSFN, sizeof(lpDrv->szAliasName));
 254     lpDrv->hModule16   = hModule;
 255     lpDrv->lpDrvProc   = lpProc;
 256
 257     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2)) goto exit;
 258
 259     return lpDrv;
 260  exit:
 261     TRACE("Unable to load 16 bit module (%s): %04x\n", lpFileName, hModule);
 262     if (hModule >= 32)  FreeLibrary16(hModule);
 263     HeapFree(GetProcessHeap(), 0, lpDrv);
 264     return NULL;
 265 }
 266
 267 /**************************************************************************
 268  *              OpenDriver (USER.252)
 269  */
 270 HDRVR16 WINAPI OpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
 271 {
 272     LPWINE_DRIVER       lpDrv = NULL;
 273     char                drvName[128];
 274
 275     TRACE("(%s, %s, %08lX);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
 276
 277     if (!lpDriverName || !*lpDriverName) return 0;
 278
 279     if (lpSectionName == NULL) {
 280         strcpy(drvName, lpDriverName);
 281
 282         if ((lpDrv = DRIVER_TryOpenDriver16(drvName, lParam2)))
 283             goto the_end;
 284         /* in case hDriver is NULL, search in Drivers section */
 285         lpSectionName = "Drivers";
 286     }
 287     if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "",
 288                                  drvName, sizeof(drvName), "SYSTEM.INI") > 0) {
 289         lpDrv = DRIVER_TryOpenDriver16(drvName, lParam2);
 290     }
 291     if (!lpDrv) {
 292         TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
 293         return 0;
 294     }
 295  the_end:
 296     TRACE("=> %04x / %08lx\n", lpDrv->hDriver16, (DWORD)lpDrv);
 297     return lpDrv->hDriver16;
 298 }
 299
 300 /**************************************************************************
 301  *              CloseDriver (USER.253)
 302  */
 303 LRESULT WINAPI CloseDriver16(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
 304 {
 305     LPWINE_DRIVER       lpDrv;
 306
 307     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 308
 309     if ((lpDrv = DRIVER_FindFromHDrvr16(hDrvr)) != NULL) {
 310         DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
 311
 312         if (DRIVER_RemoveFromList(lpDrv)) {
 313             HeapFree(GetProcessHeap(), 0, lpDrv);
 314             return TRUE;
 315         }
 316     }
 317     WARN("Failed to close driver\n");
 318     return FALSE;
 319 }
 320
 321 /**************************************************************************
 322  *              GetDriverModuleHandle (USER.254)
 323  */
 324 HMODULE16 WINAPI GetDriverModuleHandle16(HDRVR16 hDrvr)
 325 {
 326     LPWINE_DRIVER       lpDrv;
 327     HMODULE16           hModule = 0;
 328
 329     TRACE("(%04x);\n", hDrvr);
 330
 331     if ((lpDrv = DRIVER_FindFromHDrvr16(hDrvr)) != NULL) {
 332         hModule = lpDrv->hModule16;
 333     }
 334     TRACE("=> %04x\n", hModule);
 335     return hModule;
 336 }
 337
 338 /**************************************************************************
 339  *              DefDriverProc (USER.255)
 340  */
 341 LRESULT WINAPI DefDriverProc16(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
 342                                LPARAM lParam1, LPARAM lParam2)
 343 {
 344     TRACE("devID=0x%08lx hDrv=0x%04x wMsg=%04x lP1=0x%08lx lP2=0x%08lx\n",
 345           dwDevID, hDriv, wMsg, lParam1, lParam2);
 346
 347     switch(wMsg) {
 348     case DRV_LOAD:
 349     case DRV_FREE:
 350     case DRV_ENABLE:
 351     case DRV_DISABLE:
 352         return (LRESULT)1L;
 353     case DRV_OPEN:
 354     case DRV_CLOSE:
 355     case DRV_QUERYCONFIGURE:
 356         return (LRESULT)0L;
 357     case DRV_CONFIGURE:
 358         MessageBoxA(0, "Driver isn't configurable !", "Wine Driver", MB_OK);
 359         return (LRESULT)0L;
 360     case DRV_INSTALL:
 361     case DRV_REMOVE:
 362         return DRV_SUCCESS;
 363     default:
 364         return (LRESULT)0L;
 365     }
 366 }
 367
 368 /**************************************************************************
 369  *              GetDriverInfo (USER.256)
 370  */
 371 BOOL16 WINAPI GetDriverInfo16(HDRVR16 hDrvr, LPDRIVERINFOSTRUCT16 lpDrvInfo)
 372 {
 373     LPWINE_DRIVER       lpDrv;
 374     BOOL16              ret = FALSE;
 375
 376     TRACE("(%04x, %p);\n", hDrvr, lpDrvInfo);
 377
 378     if (lpDrvInfo == NULL || lpDrvInfo->length != sizeof(DRIVERINFOSTRUCT16))
 379         return FALSE;
 380
 381     if ((lpDrv = DRIVER_FindFromHDrvr16(hDrvr)) != NULL) {
 382         lpDrvInfo->hDriver = lpDrv->hDriver16;
 383         lpDrvInfo->hModule = lpDrv->hModule16;
 384         lstrcpynA(lpDrvInfo->szAliasName, lpDrv->szAliasName, sizeof(lpDrvInfo->szAliasName));
 385         ret = TRUE;
 386     }
 387
 388     return ret;
 389 }
 390
 391 /**************************************************************************
 392  *              GetNextDriver (USER.257)
 393  */
 394 HDRVR16 WINAPI GetNextDriver16(HDRVR16 hDrvr, DWORD dwFlags)
 395 {
 396     HDRVR16             hRetDrv = 0;
 397     LPWINE_DRIVER       lpDrv;
 398
 399     TRACE("(%04x, %08lX);\n", hDrvr, dwFlags);
 400
 401     if (hDrvr == 0) {
 402         if (lpDrvItemList == NULL) {
 403             FIXME("drivers list empty !\n");
 404             /* FIXME: code was using DRIVER_LoadStartupDrivers(); before ?
 405              * I (EPP) don't quite understand this
 406              */
 407             if (lpDrvItemList == NULL)
 408                 return 0;
 409         }
 410         lpDrv = lpDrvItemList;
 411         if (dwFlags & GND_REVERSE) {
 412             while (lpDrv->lpNextItem)
 413                 lpDrv = lpDrv->lpNextItem;
 414         }
 415     } else {
 416         if ((lpDrv = DRIVER_FindFromHDrvr16(hDrvr)) != NULL) {
 417             if (dwFlags & GND_REVERSE) {
 418                 lpDrv = (lpDrv->lpPrevItem) ? lpDrv->lpPrevItem : NULL;
 419             } else {
 420                 lpDrv = (lpDrv->lpNextItem) ? lpDrv->lpNextItem : NULL;
 421             }
 422         }
 423     }
 424
 425     hRetDrv = (lpDrv) ? lpDrv->hDriver16 : (HDRVR16)0;
 426     TRACE("return %04x !\n", hRetDrv);
 427     return hRetDrv;
 428 }