misc/driver.c

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