[MKHIVE/USETUP]
[reactos.git] / reactos / base / setup / usetup / interface / devinst.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS text-mode setup
4 * FILE: subsys/system/usetup/interface/devinst.c
5 * PURPOSE: Device installation
6 * PROGRAMMER: Hervé Poussineau (hpoussin@reactos.org)
7 */
8
9 #include "usetup.h"
10
11 #define NDEBUG
12 #include <debug.h>
13
14 #define INITGUID
15 #include <guiddef.h>
16 #include <libs/umpnpmgr/sysguid.h>
17
18 BOOLEAN
19 ResetDevice(
20 IN LPCWSTR DeviceId)
21 {
22 PLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData;
23 NTSTATUS Status;
24
25 RtlInitUnicodeString(&ResetDeviceData.DeviceInstance, DeviceId);
26 Status = NtPlugPlayControl(PlugPlayControlResetDevice, &ResetDeviceData, sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA));
27 if (!NT_SUCCESS(Status))
28 {
29 DPRINT1("NtPlugPlayControl() failed with status 0x%08x\n", Status);
30 return FALSE;
31 }
32 return TRUE;
33 }
34
35 BOOLEAN
36 InstallDriver(
37 IN HINF hInf,
38 IN HANDLE hServices,
39 IN HANDLE hDeviceKey,
40 IN LPCWSTR DeviceId,
41 IN LPCWSTR HardwareId)
42 {
43 UNICODE_STRING PathPrefix = RTL_CONSTANT_STRING(L"System32\\DRIVERS\\");
44 UNICODE_STRING ServiceU = RTL_CONSTANT_STRING(L"Service");
45 UNICODE_STRING ErrorControlU = RTL_CONSTANT_STRING(L"ErrorControl");
46 UNICODE_STRING ImagePathU = RTL_CONSTANT_STRING(L"ImagePath");
47 UNICODE_STRING StartU = RTL_CONSTANT_STRING(L"Start");
48 UNICODE_STRING TypeU = RTL_CONSTANT_STRING(L"Type");
49 UNICODE_STRING StringU;
50 OBJECT_ATTRIBUTES ObjectAttributes;
51 HANDLE hService;
52 INFCONTEXT Context;
53 LPWSTR Driver, ImagePath, FullImagePath;
54 ULONG dwValue;
55 ULONG Disposition;
56 NTSTATUS Status;
57 BOOLEAN deviceInstalled = FALSE;
58
59 /* Check if we know the hardware */
60 if (!SetupFindFirstLineW(hInf, L"HardwareIdsDatabase", HardwareId, &Context))
61 return FALSE;
62 if (!INF_GetDataField(&Context, 1, &Driver))
63 return FALSE;
64
65 /* Find associated driver name */
66 /* FIXME: check in other sections too! */
67 if (!SetupFindFirstLineW(hInf, L"BootBusExtenders.Load", Driver, &Context)
68 && !SetupFindFirstLineW(hInf, L"Keyboard.Load", Driver, &Context))
69 return FALSE;
70 if (!INF_GetDataField(&Context, 1, &ImagePath))
71 return FALSE;
72
73 /* Prepare full driver path */
74 dwValue = PathPrefix.MaximumLength + wcslen(ImagePath) * sizeof(WCHAR);
75 FullImagePath = (LPWSTR)RtlAllocateHeap(ProcessHeap, 0, dwValue);
76 if (!FullImagePath)
77 {
78 DPRINT1("RtlAllocateHeap() failed\n");
79 return FALSE;
80 }
81 RtlCopyMemory(FullImagePath, PathPrefix.Buffer, PathPrefix.MaximumLength);
82 wcscat(FullImagePath, ImagePath);
83
84 DPRINT("Using driver '%S' for device '%S'\n", ImagePath, DeviceId);
85
86 /* Create service key */
87 RtlInitUnicodeString(&StringU, Driver);
88 InitializeObjectAttributes(&ObjectAttributes, &StringU, 0, hServices, NULL);
89 Status = NtCreateKey(&hService, KEY_SET_VALUE, &ObjectAttributes, 0, NULL, 0, &Disposition);
90 if (!NT_SUCCESS(Status))
91 {
92 DPRINT1("NtCreateKey('%wZ') failed with status 0x%08x\n", &StringU, Status);
93 RtlFreeHeap(ProcessHeap, 0, FullImagePath);
94 return FALSE;
95 }
96
97 /* Fill service key */
98 if (Disposition == REG_CREATED_NEW_KEY)
99 {
100 dwValue = 0;
101 NtSetValueKey(
102 hService,
103 &ErrorControlU,
104 0,
105 REG_DWORD,
106 &dwValue,
107 sizeof(dwValue));
108 dwValue = 0;
109 NtSetValueKey(
110 hService,
111 &StartU,
112 0,
113 REG_DWORD,
114 &dwValue,
115 sizeof(dwValue));
116 dwValue = SERVICE_KERNEL_DRIVER;
117 NtSetValueKey(
118 hService,
119 &TypeU,
120 0,
121 REG_DWORD,
122 &dwValue,
123 sizeof(dwValue));
124 }
125 /* HACK: don't put any path in registry */
126 NtSetValueKey(
127 hService,
128 &ImagePathU,
129 0,
130 REG_SZ,
131 ImagePath,
132 (wcslen(ImagePath) + 1) * sizeof(WCHAR));
133
134 /* Associate device with the service we just filled */
135 Status = NtSetValueKey(
136 hDeviceKey,
137 &ServiceU,
138 0,
139 REG_SZ,
140 Driver,
141 (wcslen(Driver) + 1) * sizeof(WCHAR));
142 if (NT_SUCCESS(Status))
143 {
144 /* Restart the device, so it will use the driver we registred */
145 deviceInstalled = ResetDevice(DeviceId);
146 }
147
148 /* HACK: Update driver path */
149 NtSetValueKey(
150 hService,
151 &ImagePathU,
152 0,
153 REG_SZ,
154 FullImagePath,
155 (wcslen(FullImagePath) + 1) * sizeof(WCHAR));
156 RtlFreeHeap(ProcessHeap, 0, FullImagePath);
157 NtClose(hService);
158
159 return deviceInstalled;
160 }
161
162 VOID
163 InstallDevice(
164 IN HINF hInf,
165 IN HANDLE hEnum,
166 IN HANDLE hServices,
167 IN LPCWSTR DeviceId)
168 {
169 UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
170 UNICODE_STRING CompatibleIDsU = RTL_CONSTANT_STRING(L"CompatibleIDs");
171 UNICODE_STRING DeviceIdU;
172 OBJECT_ATTRIBUTES ObjectAttributes;
173 LPCWSTR HardwareID;
174 PKEY_VALUE_PARTIAL_INFORMATION pPartialInformation = NULL;
175 HANDLE hDeviceKey;
176 ULONG ulRequired;
177 BOOLEAN bDriverInstalled = FALSE;
178 NTSTATUS Status;
179
180 RtlInitUnicodeString(&DeviceIdU, DeviceId);
181 InitializeObjectAttributes(&ObjectAttributes, &DeviceIdU, 0, hEnum, NULL);
182 Status = NtOpenKey(&hDeviceKey, KEY_QUERY_VALUE | KEY_SET_VALUE, &ObjectAttributes);
183 if (!NT_SUCCESS(Status))
184 {
185 DPRINT("Unable to open subkey '%S'\n", DeviceId);
186 return;
187 }
188
189 Status = NtQueryValueKey(
190 hDeviceKey,
191 &HardwareIDU,
192 KeyValuePartialInformation,
193 NULL,
194 0,
195 &ulRequired);
196 if (Status == STATUS_BUFFER_TOO_SMALL)
197 {
198 pPartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(ProcessHeap, 0, ulRequired);
199 if (!pPartialInformation)
200 {
201 DPRINT1("RtlAllocateHeap() failed\n");
202 NtClose(hDeviceKey);
203 return;
204 }
205 Status = NtQueryValueKey(
206 hDeviceKey,
207 &HardwareIDU,
208 KeyValuePartialInformation,
209 pPartialInformation,
210 ulRequired,
211 &ulRequired);
212 }
213 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
214 {
215 /* Nothing to do */
216 }
217 else if (!NT_SUCCESS(Status))
218 {
219 DPRINT1("NtQueryValueKey() failed with status 0x%08x\n", Status);
220 if (pPartialInformation)
221 RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
222 NtClose(hDeviceKey);
223 return;
224 }
225 else if (pPartialInformation)
226 {
227 for (HardwareID = (LPCWSTR)pPartialInformation->Data;
228 (PUCHAR)HardwareID < pPartialInformation->Data + pPartialInformation->DataLength
229 && *HardwareID
230 && !bDriverInstalled;
231 HardwareID += wcslen(HardwareID) + 1)
232 {
233 bDriverInstalled = InstallDriver(hInf, hServices,hDeviceKey, DeviceId, HardwareID);
234 }
235 }
236
237 if (!bDriverInstalled)
238 {
239 if (pPartialInformation)
240 {
241 RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
242 pPartialInformation = NULL;
243 }
244 Status = NtQueryValueKey(
245 hDeviceKey,
246 &CompatibleIDsU,
247 KeyValuePartialInformation,
248 NULL,
249 0,
250 &ulRequired);
251 if (Status == STATUS_BUFFER_TOO_SMALL)
252 {
253 pPartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(ProcessHeap, 0, ulRequired);
254 if (!pPartialInformation)
255 {
256 DPRINT("RtlAllocateHeap() failed\n");
257 NtClose(hDeviceKey);
258 return;
259 }
260 Status = NtQueryValueKey(
261 hDeviceKey,
262 &CompatibleIDsU,
263 KeyValuePartialInformation,
264 pPartialInformation,
265 ulRequired,
266 &ulRequired);
267 }
268 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
269 {
270 /* Nothing to do */
271 }
272 else if (!NT_SUCCESS(Status))
273 {
274 if (pPartialInformation)
275 RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
276 NtClose(hDeviceKey);
277 DPRINT1("NtQueryValueKey() failed with status 0x%08x\n", Status);
278 return;
279 }
280 else if (pPartialInformation)
281 {
282 for (HardwareID = (LPCWSTR)pPartialInformation->Data;
283 (PUCHAR)HardwareID < pPartialInformation->Data + pPartialInformation->DataLength
284 && *HardwareID
285 && !bDriverInstalled;
286 HardwareID += wcslen(HardwareID) + 1)
287 {
288 bDriverInstalled = InstallDriver(hInf, hServices,hDeviceKey, DeviceId, HardwareID);
289 }
290 }
291 }
292 if (!bDriverInstalled)
293 DPRINT("No driver available for %S\n", DeviceId);
294
295 RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
296 NtClose(hDeviceKey);
297 }
298
299 NTSTATUS
300 EventThread(IN LPVOID lpParameter)
301 {
302 UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
303 UNICODE_STRING ServicesU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services");
304 PPLUGPLAY_EVENT_BLOCK PnpEvent;
305 OBJECT_ATTRIBUTES ObjectAttributes;
306 ULONG PnpEventSize;
307 HINF hInf;
308 HANDLE hEnum, hServices;
309 NTSTATUS Status;
310
311 hInf = *(HINF *)lpParameter;
312
313 InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_CASE_INSENSITIVE, NULL, NULL);
314 Status = NtOpenKey(&hEnum, KEY_QUERY_VALUE, &ObjectAttributes);
315 if (!NT_SUCCESS(Status))
316 {
317 DPRINT1("NtOpenKey('%wZ') failed with status 0x%08lx\n", &EnumU, Status);
318 return Status;
319 }
320
321 InitializeObjectAttributes(&ObjectAttributes, &ServicesU, OBJ_CASE_INSENSITIVE, NULL, NULL);
322 Status = NtCreateKey(&hServices, 0, &ObjectAttributes, 0, NULL, 0, NULL);
323 if (!NT_SUCCESS(Status))
324 {
325 DPRINT1("NtCreateKey('%wZ') failed with status 0x%08lx\n", &ServicesU, Status);
326 NtClose(hEnum);
327 return Status;
328 }
329
330 PnpEventSize = 0x1000;
331 PnpEvent = (PPLUGPLAY_EVENT_BLOCK)RtlAllocateHeap(ProcessHeap, 0, PnpEventSize);
332 if (PnpEvent == NULL)
333 {
334 NtClose(hEnum);
335 NtClose(hServices);
336 return STATUS_NO_MEMORY;
337 }
338
339 for (;;)
340 {
341 DPRINT("Calling NtGetPlugPlayEvent()\n");
342
343 /* Wait for the next pnp event */
344 Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
345
346 /* Resize the buffer for the PnP event if it's too small. */
347 if (Status == STATUS_BUFFER_TOO_SMALL)
348 {
349 PnpEventSize += 0x400;
350 RtlFreeHeap(ProcessHeap, 0, PnpEvent);
351 PnpEvent = (PPLUGPLAY_EVENT_BLOCK)RtlAllocateHeap(ProcessHeap, 0, PnpEventSize);
352 if (PnpEvent == NULL)
353 {
354 NtClose(hEnum);
355 NtClose(hServices);
356 return STATUS_NO_MEMORY;
357 }
358 continue;
359 }
360
361 if (!NT_SUCCESS(Status))
362 {
363 DPRINT("NtPlugPlayEvent() failed (Status %lx)\n", Status);
364 break;
365 }
366
367 /* Process the pnp event */
368 DPRINT("Received PnP Event\n");
369 if (IsEqualIID(&PnpEvent->EventGuid, (REFGUID)&GUID_DEVICE_ENUMERATED))
370 {
371 DPRINT("Device arrival event: %S\n", PnpEvent->TargetDevice.DeviceIds);
372 InstallDevice(hInf, hEnum, hServices, PnpEvent->TargetDevice.DeviceIds);
373 }
374 else
375 {
376 DPRINT("Unknown event\n");
377 }
378
379 /* Dequeue the current pnp event and signal the next one */
380 NtPlugPlayControl(PlugPlayControlUserResponse, NULL, 0);
381 }
382
383 RtlFreeHeap(ProcessHeap, 0, PnpEvent);
384 NtClose(hEnum);
385 NtClose(hServices);
386
387 return STATUS_SUCCESS;
388 }
389
390 DWORD WINAPI
391 PnpEventThread(IN LPVOID lpParameter)
392 {
393 NTSTATUS Status;
394 Status = EventThread(lpParameter);
395 NtTerminateThread(NtCurrentThread(), Status);
396 return 0;
397 }