misc/driver.c

   1 /*
   2  * Wine Drivers functions
   3  *
   4  * Copyright 1994 Martin Ayotte
   5 static char Copyright[] = "Copyright  Martin Ayotte, 1994";
   6 */
   7
   8 #include <stdio.h>
   9 #include "windows.h"
  10 #include "win.h"
  11 #include "user.h"
  12 #include "dlls.h"
  13 #include "driver.h"
  14 #include "stddebug.h"
  15 #include "debug.h"
  16
  17 LPDRIVERITEM lpDrvItemList = NULL;
  18
  19 void LoadStartupDrivers(void)
  20 {
  21         HDRVR   hDrv;
  22         char    str[256];
  23         LPSTR   ptr     = str;
  24         LPSTR   file = "SYSTEM.INI";
  25         if (GetPrivateProfileString("drivers", NULL,
  26                 "", str, sizeof(str), file) < 2) {
  27                 fprintf(stderr,
  28                 "LoadStartupDrivers // can't find drivers section in '%s'\n",
  29                 file);
  30                 return;
  31                 }
  32         while(strlen(ptr) != 0) {
  33                 dprintf_driver(stddeb,"LoadStartupDrivers // str='%s'\n", ptr);
  34                 hDrv = OpenDriver(ptr, "drivers", 0L);
  35                 dprintf_driver(stddeb,
  36                         "LoadStartupDrivers // hDrv=%04X\n", hDrv);
  37                 ptr += strlen(ptr) + 1;
  38                 }
  39         dprintf_driver(stddeb,"LoadStartupDrivers // end of list !\n");
  40 }
  41
  42 /**************************************************************************
  43  *                              SendDriverMessage               [USER.251]
  44  */
  45 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, WORD msg, LPARAM lParam1, LPARAM lParam2)
  46 {
  47         dprintf_driver(stdnimp,"SendDriverMessage(%04X, %04X, %08lX, %08lX);\n",
  48                                                 hDriver, msg, lParam1, lParam2);
  49         return 0;
  50 }
  51
  52 /**************************************************************************
  53  *                              OpenDriver                      [USER.252]
  54  */
  55 HDRVR OpenDriver(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
  56 {
  57         HDRVR                   hDrvr;
  58         LPDRIVERITEM    lpnewdrv;
  59         LPDRIVERITEM    lpdrv = lpDrvItemList;
  60         char                    DrvName[128];
  61         dprintf_driver(stddeb,"OpenDriver('%s', '%s', %08lX);\n",
  62                 lpDriverName, lpSectionName, lParam);
  63         if (lpSectionName == NULL) lpSectionName = "drivers";
  64         GetPrivateProfileString(lpSectionName, lpDriverName,
  65                 "", DrvName, sizeof(DrvName), "SYSTEM.INI");
  66         dprintf_driver(stddeb,"OpenDriver // DrvName='%s'\n", DrvName);
  67         if (strlen(DrvName) < 1) return 0;
  68         while (lpdrv != NULL) {
  69                 if (lpdrv->lpNextItem == NULL) break;
  70                 lpdrv = lpdrv->lpNextItem;
  71                 }
  72         hDrvr = GlobalAlloc(GMEM_MOVEABLE, sizeof(DRIVERITEM));
  73         lpnewdrv = (LPDRIVERITEM) GlobalLock(hDrvr);
  74         if (lpnewdrv == NULL) return 0;
  75         lpnewdrv->dis.length = sizeof(DRIVERINFOSTRUCT);
  76         lpnewdrv->dis.hModule = 0;
  77 /*      lpnewdrv->dis.hModule = LoadImage(DrvName, DLL, 0);
  78         if (lpnewdrv->dis.hModule == 0) {
  79                 GlobalUnlock(hDrvr);
  80                 GlobalFree(hDrvr);
  81                 return 0;
  82                 } */
  83         lpnewdrv->dis.hDriver = hDrvr;
  84         strcpy(lpnewdrv->dis.szAliasName, lpDriverName);
  85         lpnewdrv->count = 0;
  86         lpnewdrv->lpNextItem = NULL;
  87         if (lpDrvItemList == NULL || lpdrv == NULL) {
  88                 lpDrvItemList = lpnewdrv;
  89                 lpnewdrv->lpPrevItem = NULL;
  90                 }
  91         else {
  92                 lpdrv->lpNextItem = lpnewdrv;
  93                 lpnewdrv->lpPrevItem = lpdrv;
  94                 }
  95         lpnewdrv->lpDrvProc = NULL;
  96         dprintf_driver(stddeb,"OpenDriver // hDrvr=%04X loaded !\n", hDrvr);
  97         return hDrvr;
  98 }
  99
 100 /**************************************************************************
 101  *                              CloseDriver                             [USER.253]
 102  */
 103 LRESULT CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 104 {
 105         LPDRIVERITEM    lpdrv;
 106         dprintf_driver(stddeb,
 107                 "CloseDriver(%04X, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 108         lpdrv = (LPDRIVERITEM) GlobalLock(hDrvr);
 109         if (lpdrv != NULL && lpdrv->dis.hDriver == hDrvr) {
 110                 if (lpdrv->lpPrevItem)
 111                         ((LPDRIVERITEM)lpdrv->lpPrevItem)->lpNextItem = lpdrv->lpNextItem;
 112                 if (lpdrv->lpNextItem)
 113                         ((LPDRIVERITEM)lpdrv->lpNextItem)->lpPrevItem = lpdrv->lpPrevItem;
 114                 GlobalUnlock(hDrvr);
 115                 GlobalFree(hDrvr);
 116         dprintf_driver(stddeb,"CloseDriver // hDrvr=%04X closed !\n", hDrvr);
 117                 return TRUE;
 118                 }
 119         return FALSE;
 120 }
 121
 122 /**************************************************************************
 123  *                              GetDriverModuleHandle   [USER.254]
 124  */
 125 HANDLE GetDriverModuleHandle(HDRVR hDrvr)
 126 {
 127         LPDRIVERITEM    lpdrv;
 128         HANDLE                  hModule = 0;
 129         dprintf_driver(stddeb,"GetDriverModuleHandle(%04X);\n", hDrvr);
 130         lpdrv = (LPDRIVERITEM) GlobalLock(hDrvr);
 131         if (lpdrv != NULL) {
 132                 hModule = lpdrv->dis.hModule;
 133                 GlobalUnlock(hDrvr);
 134                 }
 135         return hModule;
 136 }
 137
 138 /**************************************************************************
 139  *                              DefDriverProc                   [USER.255]
 140  */
 141 LRESULT DefDriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
 142                                                 DWORD dwParam1, DWORD dwParam2)
 143 {
 144         switch(wMsg) {
 145                 case DRV_LOAD:
 146                         return (LRESULT)0L;
 147                 case DRV_FREE:
 148                         return (LRESULT)0L;
 149                 case DRV_OPEN:
 150                         return (LRESULT)0L;
 151                 case DRV_CLOSE:
 152                         return (LRESULT)0L;
 153                 case DRV_ENABLE:
 154                         return (LRESULT)0L;
 155                 case DRV_DISABLE:
 156                         return (LRESULT)0L;
 157                 case DRV_QUERYCONFIGURE:
 158                         return (LRESULT)0L;
 159                 case DRV_CONFIGURE:
 160                         MessageBox((HWND)NULL, "Driver isn't configurable !",
 161                                                                         "Wine Driver", MB_OK);
 162                         return (LRESULT)0L;
 163                 case DRV_INSTALL:
 164                         return (LRESULT)DRVCNF_RESTART;
 165                 case DRV_REMOVE:
 166                         return (LRESULT)DRVCNF_RESTART;
 167                 default:
 168                         return (LRESULT)0L;
 169                 }
 170 }
 171
 172 /**************************************************************************
 173  *                              GetDriverInfo                   [USER.256]
 174  */
 175 BOOL GetDriverInfo(HDRVR hDrvr, LPDRIVERINFOSTRUCT lpDrvInfo)
 176 {
 177         LPDRIVERITEM    lpdrv;
 178         dprintf_driver(stddeb,"GetDriverInfo(%04X, %p);\n", hDrvr, lpDrvInfo);
 179         if (lpDrvInfo == NULL) return FALSE;
 180         lpdrv = (LPDRIVERITEM) GlobalLock(hDrvr);
 181         if (lpdrv == NULL) return FALSE;
 182         memcpy(lpDrvInfo, &lpdrv->dis, sizeof(DRIVERINFOSTRUCT));
 183         GlobalUnlock(hDrvr);
 184         return TRUE;
 185 }
 186
 187 /**************************************************************************
 188  *                              GetNextDriver                   [USER.257]
 189  */
 190 HDRVR GetNextDriver(HDRVR hDrvr, DWORD dwFlags)
 191 {
 192         LPDRIVERITEM    lpdrv;
 193         HDRVR                   hRetDrv = 0;
 194         dprintf_driver(stddeb,"GetNextDriver(%04X, %08lX);\n", hDrvr, dwFlags);
 195         if (hDrvr == 0) {
 196                 if (lpDrvItemList == NULL) {
 197                         dprintf_driver(stddeb,
 198                                 "GetNextDriver // drivers list empty !\n");
 199                         LoadStartupDrivers();
 200                         if (lpDrvItemList == NULL) return 0;
 201                         }
 202                 dprintf_driver(stddeb,"GetNextDriver // return first %04X !\n",
 203                                         lpDrvItemList->dis.hDriver);
 204                 return lpDrvItemList->dis.hDriver;
 205                 }
 206         lpdrv = (LPDRIVERITEM) GlobalLock(hDrvr);
 207         if (lpdrv != NULL) {
 208                 if (dwFlags & GND_REVERSE) {
 209                         if (lpdrv->lpPrevItem)
 210                                 hRetDrv = ((LPDRIVERITEM)lpdrv->lpPrevItem)->dis.hDriver;
 211                         }
 212                 else {
 213                         if (lpdrv->lpNextItem)
 214                                 hRetDrv = ((LPDRIVERITEM)lpdrv->lpNextItem)->dis.hDriver;
 215                         }
 216                 GlobalUnlock(hDrvr);
 217                 }
 218         dprintf_driver(stddeb,"GetNextDriver // return %04X !\n", hRetDrv);
 219         return hRetDrv;
 220 }
 221
 222