Installation d'un driver par code

Version imprimable

02/08/2007, 14h43
franckgar

Installation d'un driver par code

Salut,
je cherche à installer un driver par code dans Windows. Seulement je voudrais que l'installation soit complete, c'est à dire quand je connecte mon instrument au PC je ne veux pas que Windows ouvre une fenêtre pour me demander où aller chercher le driver.
Je dispose du .sys et du .inf.
Merci d'avance

Bon voici le code que j'utilise (c'est plus du c++ que du delphi malheureusemnet)

Mais vue qu'on joue surtout avec l'API ca devrait etre assez simple à traduire.

N.B moi je m'en sers surtout avec des legacy drivers...
Alors je ne sais pas ce que ca va donner dans ton cas.

Ca devrait pouvoir se faire en delphi (y'a une unit winsvc qui tradauit winsvc.h, suffit de la mettre dans les uses)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
BOOL InstallDriver(
    IN SC_HANDLE  SchSCManager,
    IN LPCTSTR    DriverName,
    IN LPCTSTR    ServiceExe
    );
 
BOOL
StartDriver(
    IN SC_HANDLE  SchSCManager,
    IN LPCTSTR    DriverName
    );
 
BOOL
OpenDevice(
    IN LPCTSTR    DriverName, HANDLE * lphDevice
    );
 
BOOL
StopDriver(
    IN SC_HANDLE  SchSCManager,
    IN LPCTSTR    DriverName
    );
 
BOOL
RemoveDriver(
    IN SC_HANDLE  SchSCManager,
    IN LPCTSTR    DriverName
    );
 
 
 
/****************************************************************************
*
*    FUNCTION: LoadDeviceDriver( const TCHAR, const TCHAR, HANDLE *)
*
*    PURPOSE: Registers a driver with the system configuration manager
*  and then loads it.
*
****************************************************************************/
BOOL LoadDeviceDriver( const TCHAR * Name, const TCHAR * Path, HANDLE * lphDevice )
{
 SC_HANDLE schSCManager;
 BOOL  okay;
 
 schSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
 
 // Ignore success of installation: it may already be installed.
 InstallDriver( schSCManager, Name, Path );
 
 // Ignore success of start: it may already be started.
 StartDriver( schSCManager, Name );
 
 // Do make sure we can open it.
 okay = OpenDevice( Name, lphDevice );
 
 CloseServiceHandle( schSCManager );
 
 return okay;
}
 
 
/****************************************************************************
*
*    FUNCTION: InstallDriver( IN SC_HANDLE, IN LPCTSTR, IN LPCTSTR)
*
*    PURPOSE: Creates a driver service.
*
****************************************************************************/
BOOL InstallDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName, IN LPCTSTR ServiceExe )
{
    SC_HANDLE  schService;
 
    //
    // NOTE: This creates an entry for a standalone driver. If this
    //       is modified for use with a driver that requires a Tag,
    //       Group, and/or Dependencies, it may be necessary to
    //       query the registry for existing driver information
    //       (in order to determine a unique Tag, etc.).
    //
 
    schService = CreateService( SchSCManager,          // SCManager database
                                DriverName,           // name of service
                                DriverName,           // name to display
                                SERVICE_ALL_ACCESS,    // desired access
                                SERVICE_KERNEL_DRIVER, // service type
                                SERVICE_DEMAND_START,  // start type
                                SERVICE_ERROR_NORMAL,  // error control type
                                ServiceExe,            // service's binary
                                NULL,                  // no load ordering group
                                NULL,                  // no tag identifier
                                NULL,                  // no dependencies
                                NULL,                  // LocalSystem account
                                NULL                   // no password
                                );
    if ( schService == NULL )
        return FALSE;
 
    CloseServiceHandle( schService );
 
    return TRUE;
}
 
 
/****************************************************************************
*
*    FUNCTION: StartDriver( IN SC_HANDLE, IN LPCTSTR)
*
*    PURPOSE: Starts the driver service.
*
****************************************************************************/
BOOL StartDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
{
    SC_HANDLE  schService;
    BOOL       ret;
 
    schService = OpenService( SchSCManager,
                              DriverName,
                              SERVICE_ALL_ACCESS
                              );
    if ( schService == NULL )
        return FALSE;
 
    ret = StartService( schService, 0, NULL )
       || GetLastError() == ERROR_SERVICE_ALREADY_RUNNING;
 
    CloseServiceHandle( schService );
 
    return ret;
}
 
 
 
/****************************************************************************
*
*    FUNCTION: OpenDevice( IN LPCTSTR, HANDLE *)
*
*    PURPOSE: Opens the device and returns a handle if desired.
*
****************************************************************************/
BOOL OpenDevice( IN LPCTSTR DriverName, HANDLE * lphDevice )
{
    TCHAR    completeDeviceName[64];
    HANDLE   hDevice;
 
    //
    // Create a \\.\XXX device name that CreateFile can use
    //
    // NOTE: We're making an assumption here that the driver
    //       has created a symbolic link using it's own name
    //       (i.e. if the driver has the name "XXX" we assume
    //       that it used IoCreateSymbolicLink to create a
    //       symbolic link "\DosDevices\XXX". Usually, there
    //       is this understanding between related apps/drivers.
    //
    //       An application might also peruse the DEVICEMAP
    //       section of the registry, or use the QueryDosDevice
    //       API to enumerate the existing symbolic links in the
    //       system.
    //
 
    wsprintf( completeDeviceName, TEXT("\\\\.\\%s"), DriverName );
 
    hDevice = CreateFile( completeDeviceName,
                          GENERIC_READ | GENERIC_WRITE,
                          0,
                          NULL,
                          OPEN_EXISTING,
                          FILE_ATTRIBUTE_NORMAL,
                          NULL
                          );
    if ( hDevice == ((HANDLE)-1) )
        return FALSE;
 
 // If user wants handle, give it to them.  Otherwise, just close it.
 if ( lphDevice )
  *lphDevice = hDevice;
 else
     CloseHandle( hDevice );
 
    return TRUE;
}
 
 
/****************************************************************************
*
*    FUNCTION: UnloadDeviceDriver( const TCHAR *)
*
*    PURPOSE: Stops the driver and has the configuration manager unload it.
*
****************************************************************************/
BOOL UnloadDeviceDriver( const TCHAR * Name )
{
 SC_HANDLE schSCManager;
 
 schSCManager = OpenSCManager( NULL,                 // machine (NULL == local)
                                NULL,                 // database (NULL == default)
         SC_MANAGER_ALL_ACCESS // access required
        );
 
 StopDriver( schSCManager, Name );
 RemoveDriver( schSCManager, Name );
 
 CloseServiceHandle( schSCManager );
 
 return TRUE;
}
 
 
 
/****************************************************************************
*
*    FUNCTION: StopDriver( IN SC_HANDLE, IN LPCTSTR)
*
*    PURPOSE: Has the configuration manager stop the driver (unload it)
*
****************************************************************************/
BOOL StopDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
{
    SC_HANDLE       schService;
    BOOL            ret;
    SERVICE_STATUS  serviceStatus;
 
    schService = OpenService( SchSCManager, DriverName, SERVICE_ALL_ACCESS );
    if ( schService == NULL )
        return FALSE;
 
    ret = ControlService( schService, SERVICE_CONTROL_STOP, &serviceStatus );
 
    CloseServiceHandle( schService );
 
    return ret;
}
 
 
/****************************************************************************
*
*    FUNCTION: RemoveDriver( IN SC_HANDLE, IN LPCTSTR)
*
*    PURPOSE: Deletes the driver service.
*
****************************************************************************/
BOOL RemoveDriver( IN SC_HANDLE SchSCManager, IN LPCTSTR DriverName )
{
    SC_HANDLE  schService;
    BOOL       ret;
 
    schService = OpenService( SchSCManager,
                              DriverName,
                              SERVICE_ALL_ACCESS
                              );
 
    if ( schService == NULL )
        return FALSE;
 
    ret = DeleteService( schService );
 
    CloseServiceHandle( schService );
 
    return ret;
}

sinon pour un bon point de départ j'ai trouvé ca en delphi

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
program SCMTestApp;
 
{$APPTYPE CONSOLE}
 
uses
 SysUtils,
 Winsvc,  //для работы с сервисами
 Windows; //для распознавания ошибок
 
//===================================================
// далее идут вспомогательные процедуры и функции
//
 
//установка драйвера
function InstallDriver(scm :SC_HANDLE;DrvName,DrvPath:PChar):string;
var
 Service:SC_HANDLE;
begin
//создаем сервис
Service:=CreateService(scm, //дескриптор создаваемого сервиса
DrvName,                    //имя сервиса (для системы)
DrvName,                    //имя сервиса для вывода на экран
SERVICE_ALL_ACCESS,         //тип доступа (полный)
SERVICE_KERNEL_DRIVER,      //тип сервиса (драйвер)
SERVICE_DEMAND_START,       //тип запуска (по опросу)
SERVICE_ERROR_NORMAL,       //реакция системы на ошибку
DrvPath,                    //путь к *.sys файлу
nil,nil,nil,nil,nil);       //здесь не используются
 
if scm<>0 then result:='Install driver OK' else
 //вывод ошибок
 case GetLastError of
 ERROR_ACCESS_DENIED:        result:='ERROR_ACCESS_DENIED';
 ERROR_CIRCULAR_DEPENDENCY:  result:='ERROR_CIRCULAR_DEPENDENCY';
 ERROR_DUP_NAME:             result:='ERROR_DUP_NAME';
 ERROR_INVALID_HANDLE:       result:='Driver fail install';
 ERROR_INVALID_NAME:         result:='ERROR_INVALID_NAME';
 ERROR_INVALID_PARAMETER:    result:='ERROR_INVALID_PARAMETER';
 ERROR_INVALID_SERVICE_ACCOUNT: result:='ERROR_INVALID_SERVICE_ACCOUNT';
 ERROR_SERVICE_EXISTS:       result:='Driver already install';
 end;
//закрываем сервис
CloseServiceHandle(Service);
end;
 
//удаление драйвера
function RemoveDriver(scm :SC_HANDLE;DrvName:PChar):string;
var
 Service:SC_HANDLE;
begin
//открываем сервис
Service:=OpenService(scm,DrvName,SERVICE_ALL_ACCESS);
if Service=0 then result:='Driver not install' else
if DeleteService(Service) then result:='Driver remove OK';
//закрываем сервис
CloseServiceHandle(Service);
end;
 
//запуск драйвера
function StartDriver(scm :SC_HANDLE;DrvName:PChar):string;
var
 Service:SC_HANDLE;
 arg:PChar;
begin
arg:=nil;
//открываем сервис
Service:=OpenService(scm,DrvName,SERVICE_ALL_ACCESS);
if Service=0 then result:='Driver not install' else
 if StartService(Service,0,arg) then result:='Driver start OK' else
 //вывод ошибок
 case GetLastError of
 ERROR_INVALID_HANDLE:         result:='ERROR_INVALID_HANDLE';
 ERROR_PATH_NOT_FOUND:         result:='ERROR_PATH_NOT_FOUND';
 ERROR_SERVICE_ALREADY_RUNNING:result:='Driver already start';
 ERROR_SERVICE_DATABASE_LOCKED:result:='ERROR_SERVICE_DATABASE_LOCKED';
 ERROR_SERVICE_DEPENDENCY_DELETED: result:='ERROR_SERVICE_DEPENDENCY_DELETED';
 ERROR_SERVICE_DEPENDENCY_FAIL:result:='ERROR_SERVICE_DEPENDENCY_FAIL';
 ERROR_SERVICE_DISABLED:       result:='ERROR_SERVICE_DISABLED';
 ERROR_SERVICE_LOGON_FAILED:   result:='ERROR_SERVICE_LOGON_FAILED';
 ERROR_SERVICE_MARKED_FOR_DELETE: result:='ERROR_SERVICE_MARKED_FOR_DELETE';
 ERROR_SERVICE_NO_THREAD:      result:='ERROR_SERVICE_NO_THREAD';
 ERROR_SERVICE_REQUEST_TIMEOUT:result:='ERROR_SERVICE_REQUEST_TIMEOUT';
 end;
//закрываем сервис
CloseServiceHandle(Service);
end;
 
//остановка драйвера
function StopDriver(scm :SC_HANDLE;DrvName:PChar):string;
var
 Service:SC_HANDLE;
 ServStatus:TServiceStatus;
begin
//открываем сервис
Service:=OpenService(scm,DrvName,SERVICE_ALL_ACCESS);
if Service=0 then result:='Driver not install' else
 if ControlService(Service,SERVICE_CONTROL_STOP,ServStatus) then result:='Driver stop OK' else
 //вывод ошибок
 case GetLastError of
 ERROR_INVALID_HANDLE:         result:='ERROR_INVALID_HANDLE';
 ERROR_ACCESS_DENIED:            result:='ERROR_ACCESS_DENIED';
 ERROR_DEPENDENT_SERVICES_RUNNING:result:='ERROR_DEPENDENT_SERVICES_RUNNING';
 ERROR_INVALID_SERVICE_CONTROL:  result:='ERROR_INVALID_SERVICE_CONTROL';
 ERROR_SERVICE_CANNOT_ACCEPT_CTRL:result:='ERROR_SERVICE_CANNOT_ACCEPT_CTRL';
 ERROR_SERVICE_NOT_ACTIVE:       result:='Driver already stopped';
 ERROR_SERVICE_REQUEST_TIMEOUT:  result:='ERROR_SERVICE_REQUEST_TIMEOUT';
 end;
//закрываем сервис
CloseServiceHandle(Service);
end;
 
//помощь о командах
procedure Help;
begin
Writeln('-------------------------------');
Writeln('|Test drivers from SCM meneger|');
Writeln('-------------------------------');
Writeln('Commands:');
Writeln('1 - Install driver');
Writeln('2 - Start   driver');
Writeln('3 - Stop    driver');
Writeln('4 - Remove  driver');
Writeln('99 - exit');
Writeln('-------------------------------');
end;
//
// вспомогательные процедуры и функции заканчиваются здесь,
// далее идёт главная процедура программы
// (в языке C/C++ она называется Main)
//===================================================
 
var
 i:integer;
 scm_:SC_HANDLE;//дескриптор SCM менеждера
 status:string; //строка статуса (для вывода)
begin
//запуск SCM менеждера
scm_:=OpenSCManager(nil,nil,SC_MANAGER_ALL_ACCESS);
 
if scm_<>0 then WriteLn('SCM Manager start OK')//успешный запуск
else begin
 WriteLn('SCM Manager start fail');//показываем ошибку на экране
 readln;// до ввода любого символа
 exit;  // выход из программы
end;
 
status:='';
Help; // выводим меню команд при старте
repeat
//цикл, до тех пор, пока не будет
//введена цифра 99
begin
  readln(i);// запоминаем код команды
  Help;     // выводим меню команд после ввода команды
  case i of
  //команды
     1: status:=InstallDriver(scm_,'Example','D:\Example\objchk_wxp_x86\i386\Example.sys ');
     2: status:=StartDriver  (scm_,'Example');
     3: status:=StopDriver   (scm_,'Example');
     4: status:=RemoveDriver (scm_,'Example');
  end;
  Writeln('Driver status='+Status);//статус результата команды
  Write('>'); //командное приглашение
end;
until i=99;
 
//останавливаем SCM менеждер
CloseServiceHandle(scm_);
end.

Bon les commentaires c'est du russe donc ca ne va pas bien s'afficher