dcc086eb659371c546ab07fdb26002ae749642ea
[reactos.git] / reactos / ntoskrnl / io / iomgr / deviface.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/io/iomgr/deviface.c
5 * PURPOSE: Device interface functions
6 *
7 * PROGRAMMERS: Filip Navara (xnavara@volny.cz)
8 * Matthew Brace (ismarc@austin.rr.com)
9 * Hervé Poussineau (hpoussin@reactos.org)
10 */
11
12 /* INCLUDES ******************************************************************/
13
14 #include <ntoskrnl.h>
15
16 #define NDEBUG
17 #include <debug.h>
18
19 /* FUNCTIONS *****************************************************************/
20
21 static PWCHAR BaseKeyString = L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\DeviceClasses\\";
22
23 static
24 NTSTATUS
25 OpenRegistryHandlesFromSymbolicLink(IN PUNICODE_STRING SymbolicLinkName,
26 IN ACCESS_MASK DesiredAccess,
27 IN OPTIONAL PHANDLE GuidKey,
28 IN OPTIONAL PHANDLE DeviceKey,
29 IN OPTIONAL PHANDLE InstanceKey)
30 {
31 OBJECT_ATTRIBUTES ObjectAttributes;
32 WCHAR PathBuffer[MAX_PATH];
33 UNICODE_STRING BaseKeyU;
34 UNICODE_STRING GuidString, SubKeyName, ReferenceString;
35 PWCHAR StartPosition, EndPosition;
36 HANDLE ClassesKey;
37 PHANDLE GuidKeyRealP, DeviceKeyRealP, InstanceKeyRealP;
38 HANDLE GuidKeyReal, DeviceKeyReal, InstanceKeyReal;
39 NTSTATUS Status;
40
41 SubKeyName.Buffer = NULL;
42
43 if (GuidKey != NULL)
44 GuidKeyRealP = GuidKey;
45 else
46 GuidKeyRealP = &GuidKeyReal;
47
48 if (DeviceKey != NULL)
49 DeviceKeyRealP = DeviceKey;
50 else
51 DeviceKeyRealP = &DeviceKeyReal;
52
53 if (InstanceKey != NULL)
54 InstanceKeyRealP = InstanceKey;
55 else
56 InstanceKeyRealP = &InstanceKeyReal;
57
58 *GuidKeyRealP = INVALID_HANDLE_VALUE;
59 *DeviceKeyRealP = INVALID_HANDLE_VALUE;
60 *InstanceKeyRealP = INVALID_HANDLE_VALUE;
61
62 BaseKeyU.Buffer = PathBuffer;
63 BaseKeyU.Length = 0;
64 BaseKeyU.MaximumLength = MAX_PATH * sizeof(WCHAR);
65
66 RtlAppendUnicodeToString(&BaseKeyU, BaseKeyString);
67
68 /* Open the DeviceClasses key */
69 InitializeObjectAttributes(&ObjectAttributes,
70 &BaseKeyU,
71 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
72 NULL,
73 NULL);
74 Status = ZwOpenKey(&ClassesKey,
75 DesiredAccess | KEY_ENUMERATE_SUB_KEYS,
76 &ObjectAttributes);
77 if (!NT_SUCCESS(Status))
78 {
79 DPRINT1("Failed to open %wZ\n", &BaseKeyU);
80 goto cleanup;
81 }
82
83 StartPosition = wcschr(SymbolicLinkName->Buffer, L'{');
84 EndPosition = wcschr(SymbolicLinkName->Buffer, L'}');
85 if (!StartPosition || !EndPosition || StartPosition > EndPosition)
86 {
87 DPRINT1("Bad symbolic link: %wZ\n", SymbolicLinkName);
88 return STATUS_INVALID_PARAMETER_1;
89 }
90 GuidString.Buffer = StartPosition;
91 GuidString.MaximumLength = GuidString.Length = (USHORT)((ULONG_PTR)(EndPosition + 1) - (ULONG_PTR)StartPosition);
92
93 InitializeObjectAttributes(&ObjectAttributes,
94 &GuidString,
95 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
96 ClassesKey,
97 NULL);
98 Status = ZwOpenKey(GuidKeyRealP,
99 DesiredAccess | KEY_ENUMERATE_SUB_KEYS,
100 &ObjectAttributes);
101 ZwClose(ClassesKey);
102 if (!NT_SUCCESS(Status))
103 {
104 DPRINT1("Failed to open %wZ%wZ (%x)\n", &BaseKeyU, &GuidString, Status);
105 goto cleanup;
106 }
107
108 SubKeyName.MaximumLength = SymbolicLinkName->Length + sizeof(WCHAR);
109 SubKeyName.Length = 0;
110 SubKeyName.Buffer = ExAllocatePool(PagedPool, SubKeyName.MaximumLength);
111 if (!SubKeyName.Buffer)
112 {
113 Status = STATUS_INSUFFICIENT_RESOURCES;
114 goto cleanup;
115 }
116
117 RtlAppendUnicodeStringToString(&SubKeyName,
118 SymbolicLinkName);
119
120 SubKeyName.Buffer[SubKeyName.Length / sizeof(WCHAR)] = UNICODE_NULL;
121
122 SubKeyName.Buffer[0] = L'#';
123 SubKeyName.Buffer[1] = L'#';
124 SubKeyName.Buffer[2] = L'?';
125 SubKeyName.Buffer[3] = L'#';
126
127 ReferenceString.Buffer = wcsrchr(SubKeyName.Buffer, '\\');
128 if (ReferenceString.Buffer != NULL)
129 {
130 ReferenceString.Buffer[0] = L'#';
131
132 SubKeyName.Length = (USHORT)((ULONG_PTR)(ReferenceString.Buffer) - (ULONG_PTR)SubKeyName.Buffer);
133 ReferenceString.Length = SymbolicLinkName->Length - SubKeyName.Length;
134 }
135 else
136 {
137 RtlInitUnicodeString(&ReferenceString, L"#");
138 }
139
140 InitializeObjectAttributes(&ObjectAttributes,
141 &SubKeyName,
142 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
143 *GuidKeyRealP,
144 NULL);
145 Status = ZwOpenKey(DeviceKeyRealP,
146 DesiredAccess | KEY_ENUMERATE_SUB_KEYS,
147 &ObjectAttributes);
148 if (!NT_SUCCESS(Status))
149 {
150 DPRINT1("Failed to open %wZ%wZ\\%wZ\n", &BaseKeyU, &GuidString, &SubKeyName);
151 goto cleanup;
152 }
153
154 InitializeObjectAttributes(&ObjectAttributes,
155 &ReferenceString,
156 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
157 *DeviceKeyRealP,
158 NULL);
159 Status = ZwOpenKey(InstanceKeyRealP,
160 DesiredAccess,
161 &ObjectAttributes);
162 if (!NT_SUCCESS(Status))
163 {
164 DPRINT1("Failed to open %wZ%wZ\\%wZ%\\%wZ (%x)\n", &BaseKeyU, &GuidString, &SubKeyName, &ReferenceString, Status);
165 goto cleanup;
166 }
167
168 Status = STATUS_SUCCESS;
169
170 cleanup:
171 if (SubKeyName.Buffer != NULL)
172 ExFreePool(SubKeyName.Buffer);
173
174 if (NT_SUCCESS(Status))
175 {
176 if (!GuidKey)
177 ZwClose(*GuidKeyRealP);
178
179 if (!DeviceKey)
180 ZwClose(*DeviceKeyRealP);
181
182 if (!InstanceKey)
183 ZwClose(*InstanceKeyRealP);
184 }
185 else
186 {
187 if (*GuidKeyRealP != INVALID_HANDLE_VALUE)
188 ZwClose(*GuidKeyRealP);
189
190 if (*DeviceKeyRealP != INVALID_HANDLE_VALUE)
191 ZwClose(*DeviceKeyRealP);
192
193 if (*InstanceKeyRealP != INVALID_HANDLE_VALUE)
194 ZwClose(*InstanceKeyRealP);
195 }
196
197 return Status;
198 }
199 /*++
200 * @name IoOpenDeviceInterfaceRegistryKey
201 * @unimplemented
202 *
203 * Provides a handle to the device's interface instance registry key.
204 * Documented in WDK.
205 *
206 * @param SymbolicLinkName
207 * Pointer to a string which identifies the device interface instance
208 *
209 * @param DesiredAccess
210 * Desired ACCESS_MASK used to access the key (like KEY_READ,
211 * KEY_WRITE, etc)
212 *
213 * @param DeviceInterfaceKey
214 * If a call has been succesfull, a handle to the registry key
215 * will be stored there
216 *
217 * @return Three different NTSTATUS values in case of errors, and STATUS_SUCCESS
218 * otherwise (see WDK for details)
219 *
220 * @remarks Must be called at IRQL = PASSIVE_LEVEL in the context of a system thread
221 *
222 *--*/
223 NTSTATUS
224 NTAPI
225 IoOpenDeviceInterfaceRegistryKey(IN PUNICODE_STRING SymbolicLinkName,
226 IN ACCESS_MASK DesiredAccess,
227 OUT PHANDLE DeviceInterfaceKey)
228 {
229 HANDLE InstanceKey, DeviceParametersKey;
230 NTSTATUS Status;
231 OBJECT_ATTRIBUTES ObjectAttributes;
232 UNICODE_STRING DeviceParametersU = RTL_CONSTANT_STRING(L"Device Parameters");
233
234 Status = OpenRegistryHandlesFromSymbolicLink(SymbolicLinkName,
235 KEY_CREATE_SUB_KEY,
236 NULL,
237 NULL,
238 &InstanceKey);
239 if (!NT_SUCCESS(Status))
240 return Status;
241
242 InitializeObjectAttributes(&ObjectAttributes,
243 &DeviceParametersU,
244 OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
245 InstanceKey,
246 NULL);
247 Status = ZwCreateKey(&DeviceParametersKey,
248 DesiredAccess,
249 &ObjectAttributes,
250 0,
251 NULL,
252 REG_OPTION_NON_VOLATILE,
253 NULL);
254 ZwClose(InstanceKey);
255
256 if (NT_SUCCESS(Status))
257 *DeviceInterfaceKey = DeviceParametersKey;
258
259 return Status;
260 }
261
262 /*++
263 * @name IoGetDeviceInterfaceAlias
264 * @unimplemented
265 *
266 * Returns the alias device interface of the specified device interface
267 * instance, if the alias exists.
268 * Documented in WDK.
269 *
270 * @param SymbolicLinkName
271 * Pointer to a string which identifies the device interface instance
272 *
273 * @param AliasInterfaceClassGuid
274 * See WDK
275 *
276 * @param AliasSymbolicLinkName
277 * See WDK
278 *
279 * @return Three different NTSTATUS values in case of errors, and STATUS_SUCCESS
280 * otherwise (see WDK for details)
281 *
282 * @remarks Must be called at IRQL = PASSIVE_LEVEL in the context of a system thread
283 *
284 *--*/
285 NTSTATUS
286 NTAPI
287 IoGetDeviceInterfaceAlias(IN PUNICODE_STRING SymbolicLinkName,
288 IN CONST GUID *AliasInterfaceClassGuid,
289 OUT PUNICODE_STRING AliasSymbolicLinkName)
290 {
291 return STATUS_NOT_IMPLEMENTED;
292 }
293
294 /*++
295 * @name IopOpenInterfaceKey
296 *
297 * Returns the alias device interface of the specified device interface
298 *
299 * @param InterfaceClassGuid
300 * FILLME
301 *
302 * @param DesiredAccess
303 * FILLME
304 *
305 * @param pInterfaceKey
306 * FILLME
307 *
308 * @return Usual NTSTATUS
309 *
310 * @remarks None
311 *
312 *--*/
313 static NTSTATUS
314 IopOpenInterfaceKey(IN CONST GUID *InterfaceClassGuid,
315 IN ACCESS_MASK DesiredAccess,
316 OUT HANDLE *pInterfaceKey)
317 {
318 UNICODE_STRING LocalMachine = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\");
319 UNICODE_STRING GuidString;
320 UNICODE_STRING KeyName;
321 OBJECT_ATTRIBUTES ObjectAttributes;
322 HANDLE InterfaceKey = INVALID_HANDLE_VALUE;
323 NTSTATUS Status;
324
325 GuidString.Buffer = KeyName.Buffer = NULL;
326
327 Status = RtlStringFromGUID(InterfaceClassGuid, &GuidString);
328 if (!NT_SUCCESS(Status))
329 {
330 DPRINT("RtlStringFromGUID() failed with status 0x%08lx\n", Status);
331 goto cleanup;
332 }
333
334 KeyName.Length = 0;
335 KeyName.MaximumLength = LocalMachine.Length + (wcslen(REGSTR_PATH_DEVICE_CLASSES) + 1) * sizeof(WCHAR) + GuidString.Length;
336 KeyName.Buffer = ExAllocatePool(PagedPool, KeyName.MaximumLength);
337 if (!KeyName.Buffer)
338 {
339 DPRINT("ExAllocatePool() failed\n");
340 Status = STATUS_INSUFFICIENT_RESOURCES;
341 goto cleanup;
342 }
343
344 Status = RtlAppendUnicodeStringToString(&KeyName, &LocalMachine);
345 if (!NT_SUCCESS(Status))
346 {
347 DPRINT("RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
348 goto cleanup;
349 }
350 Status = RtlAppendUnicodeToString(&KeyName, REGSTR_PATH_DEVICE_CLASSES);
351 if (!NT_SUCCESS(Status))
352 {
353 DPRINT("RtlAppendUnicodeToString() failed with status 0x%08lx\n", Status);
354 goto cleanup;
355 }
356 Status = RtlAppendUnicodeToString(&KeyName, L"\\");
357 if (!NT_SUCCESS(Status))
358 {
359 DPRINT("RtlAppendUnicodeToString() failed with status 0x%08lx\n", Status);
360 goto cleanup;
361 }
362 Status = RtlAppendUnicodeStringToString(&KeyName, &GuidString);
363 if (!NT_SUCCESS(Status))
364 {
365 DPRINT("RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
366 goto cleanup;
367 }
368
369 InitializeObjectAttributes(
370 &ObjectAttributes,
371 &KeyName,
372 OBJ_CASE_INSENSITIVE,
373 NULL,
374 NULL);
375 Status = ZwOpenKey(
376 &InterfaceKey,
377 DesiredAccess,
378 &ObjectAttributes);
379 if (!NT_SUCCESS(Status))
380 {
381 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
382 goto cleanup;
383 }
384
385 *pInterfaceKey = InterfaceKey;
386 Status = STATUS_SUCCESS;
387
388 cleanup:
389 if (!NT_SUCCESS(Status))
390 {
391 if (InterfaceKey != INVALID_HANDLE_VALUE)
392 ZwClose(InterfaceKey);
393 }
394 RtlFreeUnicodeString(&GuidString);
395 RtlFreeUnicodeString(&KeyName);
396 return Status;
397 }
398
399 /*++
400 * @name IoGetDeviceInterfaces
401 * @implemented
402 *
403 * Returns a list of device interfaces of a particular device interface class.
404 * Documented in WDK
405 *
406 * @param InterfaceClassGuid
407 * Points to a class GUID specifying the device interface class
408 *
409 * @param PhysicalDeviceObject
410 * Points to an optional PDO that narrows the search to only the
411 * device interfaces of the device represented by the PDO
412 *
413 * @param Flags
414 * Specifies flags that modify the search for device interfaces. The
415 * DEVICE_INTERFACE_INCLUDE_NONACTIVE flag specifies that the list of
416 * returned symbolic links should contain also disabled device
417 * interfaces in addition to the enabled ones.
418 *
419 * @param SymbolicLinkList
420 * Points to a character pointer that is filled in on successful return
421 * with a list of unicode strings identifying the device interfaces
422 * that match the search criteria. The newly allocated buffer contains
423 * a list of symbolic link names. Each unicode string in the list is
424 * null-terminated; the end of the whole list is marked by an additional
425 * NULL. The caller is responsible for freeing the buffer (ExFreePool)
426 * when it is no longer needed.
427 * If no device interfaces match the search criteria, this routine
428 * returns STATUS_SUCCESS and the string contains a single NULL
429 * character.
430 *
431 * @return Usual NTSTATUS
432 *
433 * @remarks None
434 *
435 *--*/
436 NTSTATUS
437 NTAPI
438 IoGetDeviceInterfaces(IN CONST GUID *InterfaceClassGuid,
439 IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
440 IN ULONG Flags,
441 OUT PWSTR *SymbolicLinkList)
442 {
443 UNICODE_STRING Control = RTL_CONSTANT_STRING(L"Control");
444 UNICODE_STRING SymbolicLink = RTL_CONSTANT_STRING(L"SymbolicLink");
445 HANDLE InterfaceKey = INVALID_HANDLE_VALUE;
446 HANDLE DeviceKey = INVALID_HANDLE_VALUE;
447 HANDLE ReferenceKey = INVALID_HANDLE_VALUE;
448 HANDLE ControlKey = INVALID_HANDLE_VALUE;
449 PKEY_BASIC_INFORMATION DeviceBi = NULL;
450 PKEY_BASIC_INFORMATION ReferenceBi = NULL;
451 PKEY_VALUE_PARTIAL_INFORMATION bip = NULL;
452 PKEY_VALUE_PARTIAL_INFORMATION PartialInfo;
453 UNICODE_STRING KeyName;
454 OBJECT_ATTRIBUTES ObjectAttributes;
455 BOOLEAN FoundRightPDO = FALSE;
456 ULONG i = 0, j, Size, NeededLength, ActualLength, LinkedValue;
457 UNICODE_STRING ReturnBuffer = { 0, 0, NULL };
458 NTSTATUS Status;
459
460 PAGED_CODE();
461
462 Status = IopOpenInterfaceKey(InterfaceClassGuid, KEY_ENUMERATE_SUB_KEYS, &InterfaceKey);
463 if (!NT_SUCCESS(Status))
464 {
465 DPRINT("IopOpenInterfaceKey() failed with status 0x%08lx\n", Status);
466 goto cleanup;
467 }
468
469 /* Enumerate subkeys (ie the different device objets) */
470 while (TRUE)
471 {
472 Status = ZwEnumerateKey(
473 InterfaceKey,
474 i,
475 KeyBasicInformation,
476 NULL,
477 0,
478 &Size);
479 if (Status == STATUS_NO_MORE_ENTRIES)
480 {
481 break;
482 }
483 else if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
484 {
485 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
486 goto cleanup;
487 }
488
489 DeviceBi = ExAllocatePool(PagedPool, Size);
490 if (!DeviceBi)
491 {
492 DPRINT("ExAllocatePool() failed\n");
493 Status = STATUS_INSUFFICIENT_RESOURCES;
494 goto cleanup;
495 }
496 Status = ZwEnumerateKey(
497 InterfaceKey,
498 i++,
499 KeyBasicInformation,
500 DeviceBi,
501 Size,
502 &Size);
503 if (!NT_SUCCESS(Status))
504 {
505 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
506 goto cleanup;
507 }
508
509 /* Open device key */
510 KeyName.Length = KeyName.MaximumLength = (USHORT)DeviceBi->NameLength;
511 KeyName.Buffer = DeviceBi->Name;
512 InitializeObjectAttributes(
513 &ObjectAttributes,
514 &KeyName,
515 OBJ_CASE_INSENSITIVE,
516 InterfaceKey,
517 NULL);
518 Status = ZwOpenKey(
519 &DeviceKey,
520 KEY_ENUMERATE_SUB_KEYS,
521 &ObjectAttributes);
522 if (!NT_SUCCESS(Status))
523 {
524 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
525 goto cleanup;
526 }
527
528 if (PhysicalDeviceObject)
529 {
530 /* Check if we are on the right physical device object,
531 * by reading the DeviceInstance string
532 */
533 DPRINT1("PhysicalDeviceObject != NULL. Case not implemented.\n");
534 //FoundRightPDO = TRUE;
535 Status = STATUS_NOT_IMPLEMENTED;
536 goto cleanup;
537 }
538
539 /* Enumerate subkeys (ie the different reference strings) */
540 j = 0;
541 while (TRUE)
542 {
543 Status = ZwEnumerateKey(
544 DeviceKey,
545 j,
546 KeyBasicInformation,
547 NULL,
548 0,
549 &Size);
550 if (Status == STATUS_NO_MORE_ENTRIES)
551 {
552 break;
553 }
554 else if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
555 {
556 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
557 goto cleanup;
558 }
559
560 ReferenceBi = ExAllocatePool(PagedPool, Size);
561 if (!ReferenceBi)
562 {
563 DPRINT("ExAllocatePool() failed\n");
564 Status = STATUS_INSUFFICIENT_RESOURCES;
565 goto cleanup;
566 }
567 Status = ZwEnumerateKey(
568 DeviceKey,
569 j++,
570 KeyBasicInformation,
571 ReferenceBi,
572 Size,
573 &Size);
574 if (!NT_SUCCESS(Status))
575 {
576 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
577 goto cleanup;
578 }
579
580 KeyName.Length = KeyName.MaximumLength = (USHORT)ReferenceBi->NameLength;
581 KeyName.Buffer = ReferenceBi->Name;
582 if (RtlEqualUnicodeString(&KeyName, &Control, TRUE))
583 {
584 /* Skip Control subkey */
585 goto NextReferenceString;
586 }
587
588 /* Open reference key */
589 InitializeObjectAttributes(
590 &ObjectAttributes,
591 &KeyName,
592 OBJ_CASE_INSENSITIVE,
593 DeviceKey,
594 NULL);
595 Status = ZwOpenKey(
596 &ReferenceKey,
597 KEY_QUERY_VALUE,
598 &ObjectAttributes);
599 if (!NT_SUCCESS(Status))
600 {
601 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
602 goto cleanup;
603 }
604
605 if (!(Flags & DEVICE_INTERFACE_INCLUDE_NONACTIVE))
606 {
607 /* We have to check if the interface is enabled, by
608 * reading the Linked value in the Control subkey
609 */
610 InitializeObjectAttributes(
611 &ObjectAttributes,
612 &Control,
613 OBJ_CASE_INSENSITIVE,
614 ReferenceKey,
615 NULL);
616 Status = ZwOpenKey(
617 &ControlKey,
618 KEY_QUERY_VALUE,
619 &ObjectAttributes);
620 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
621 {
622 /* That's OK. The key doesn't exist (yet) because
623 * the interface is not activated.
624 */
625 goto NextReferenceString;
626 }
627 else if (!NT_SUCCESS(Status))
628 {
629 DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
630 goto cleanup;
631 }
632
633 RtlInitUnicodeString(&KeyName, L"Linked");
634 Status = ZwQueryValueKey(ControlKey,
635 &KeyName,
636 KeyValuePartialInformation,
637 NULL,
638 0,
639 &NeededLength);
640 if (Status == STATUS_BUFFER_TOO_SMALL)
641 {
642 ActualLength = NeededLength;
643 PartialInfo = ExAllocatePool(NonPagedPool, ActualLength);
644 if (!PartialInfo)
645 {
646 Status = STATUS_INSUFFICIENT_RESOURCES;
647 goto cleanup;
648 }
649
650 Status = ZwQueryValueKey(ControlKey,
651 &KeyName,
652 KeyValuePartialInformation,
653 PartialInfo,
654 ActualLength,
655 &NeededLength);
656 if (!NT_SUCCESS(Status))
657 {
658 DPRINT1("ZwQueryValueKey #2 failed (%x)\n", Status);
659 ExFreePool(PartialInfo);
660 goto cleanup;
661 }
662
663 if (PartialInfo->Type != REG_DWORD || PartialInfo->DataLength != sizeof(ULONG))
664 {
665 DPRINT1("Bad registry read\n");
666 ExFreePool(PartialInfo);
667 goto cleanup;
668 }
669
670 RtlCopyMemory(&LinkedValue,
671 PartialInfo->Data,
672 PartialInfo->DataLength);
673
674 ExFreePool(PartialInfo);
675 if (LinkedValue == 0)
676 {
677 /* This interface isn't active */
678 goto NextReferenceString;
679 }
680 }
681 else
682 {
683 DPRINT1("ZwQueryValueKey #1 failed (%x)\n", Status);
684 goto cleanup;
685 }
686 }
687
688 /* Read the SymbolicLink string and add it into SymbolicLinkList */
689 Status = ZwQueryValueKey(
690 ReferenceKey,
691 &SymbolicLink,
692 KeyValuePartialInformation,
693 NULL,
694 0,
695 &Size);
696 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL)
697 {
698 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
699 goto cleanup;
700 }
701 bip = ExAllocatePool(PagedPool, Size);
702 if (!bip)
703 {
704 DPRINT("ExAllocatePool() failed\n");
705 Status = STATUS_INSUFFICIENT_RESOURCES;
706 goto cleanup;
707 }
708 Status = ZwQueryValueKey(
709 ReferenceKey,
710 &SymbolicLink,
711 KeyValuePartialInformation,
712 bip,
713 Size,
714 &Size);
715 if (!NT_SUCCESS(Status))
716 {
717 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
718 goto cleanup;
719 }
720 else if (bip->Type != REG_SZ)
721 {
722 DPRINT("Unexpected registry type 0x%lx (expected 0x%lx)\n", bip->Type, REG_SZ);
723 Status = STATUS_UNSUCCESSFUL;
724 goto cleanup;
725 }
726 else if (bip->DataLength < 5 * sizeof(WCHAR))
727 {
728 DPRINT("Registry string too short (length %lu, expected %lu at least)\n", bip->DataLength < 5 * sizeof(WCHAR));
729 Status = STATUS_UNSUCCESSFUL;
730 goto cleanup;
731 }
732 KeyName.Length = KeyName.MaximumLength = (USHORT)bip->DataLength - 4 * sizeof(WCHAR);
733 KeyName.Buffer = &((PWSTR)bip->Data)[4];
734 if (KeyName.Length && KeyName.Buffer[KeyName.Length / sizeof(WCHAR)] == UNICODE_NULL)
735 {
736 /* Remove trailing NULL */
737 KeyName.Length -= sizeof(WCHAR);
738 }
739
740 /* Add new symbolic link to symbolic link list */
741 if (ReturnBuffer.Length + KeyName.Length + sizeof(WCHAR) > ReturnBuffer.MaximumLength)
742 {
743 PWSTR NewBuffer;
744 ReturnBuffer.MaximumLength = max(ReturnBuffer.MaximumLength * 2, ReturnBuffer.Length + KeyName.Length + 2 * sizeof(WCHAR));
745 NewBuffer = ExAllocatePool(PagedPool, ReturnBuffer.MaximumLength);
746 if (!NewBuffer)
747 {
748 DPRINT("ExAllocatePool() failed\n");
749 Status = STATUS_INSUFFICIENT_RESOURCES;
750 goto cleanup;
751 }
752 RtlCopyMemory(NewBuffer, ReturnBuffer.Buffer, ReturnBuffer.Length);
753 if (ReturnBuffer.Buffer)
754 ExFreePool(ReturnBuffer.Buffer);
755 ReturnBuffer.Buffer = NewBuffer;
756 }
757 DPRINT("Adding symbolic link %wZ\n", &KeyName);
758 Status = RtlAppendUnicodeStringToString(&ReturnBuffer, &KeyName);
759 if (!NT_SUCCESS(Status))
760 {
761 DPRINT("RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
762 goto cleanup;
763 }
764 /* RtlAppendUnicodeStringToString added a NULL at the end of the
765 * destination string, but didn't increase the Length field.
766 * Do it for it.
767 */
768 ReturnBuffer.Length += sizeof(WCHAR);
769
770 NextReferenceString:
771 ExFreePool(ReferenceBi);
772 ReferenceBi = NULL;
773 if (bip)
774 ExFreePool(bip);
775 bip = NULL;
776 if (ReferenceKey != INVALID_HANDLE_VALUE)
777 {
778 ZwClose(ReferenceKey);
779 ReferenceKey = INVALID_HANDLE_VALUE;
780 }
781 if (ControlKey != INVALID_HANDLE_VALUE)
782 {
783 ZwClose(ControlKey);
784 ControlKey = INVALID_HANDLE_VALUE;
785 }
786 }
787 if (FoundRightPDO)
788 {
789 /* No need to go further, as we already have found what we searched */
790 break;
791 }
792
793 ExFreePool(DeviceBi);
794 DeviceBi = NULL;
795 ZwClose(DeviceKey);
796 DeviceKey = INVALID_HANDLE_VALUE;
797 }
798
799 /* Add final NULL to ReturnBuffer */
800 if (ReturnBuffer.Length >= ReturnBuffer.MaximumLength)
801 {
802 PWSTR NewBuffer;
803 ReturnBuffer.MaximumLength += sizeof(WCHAR);
804 NewBuffer = ExAllocatePool(PagedPool, ReturnBuffer.MaximumLength);
805 if (!NewBuffer)
806 {
807 DPRINT("ExAllocatePool() failed\n");
808 Status = STATUS_INSUFFICIENT_RESOURCES;
809 goto cleanup;
810 }
811 if (ReturnBuffer.Buffer)
812 {
813 RtlCopyMemory(NewBuffer, ReturnBuffer.Buffer, ReturnBuffer.Length);
814 ExFreePool(ReturnBuffer.Buffer);
815 }
816 ReturnBuffer.Buffer = NewBuffer;
817 }
818 ReturnBuffer.Buffer[ReturnBuffer.Length / sizeof(WCHAR)] = UNICODE_NULL;
819 *SymbolicLinkList = ReturnBuffer.Buffer;
820 Status = STATUS_SUCCESS;
821
822 cleanup:
823 if (!NT_SUCCESS(Status) && ReturnBuffer.Buffer)
824 ExFreePool(ReturnBuffer.Buffer);
825 if (InterfaceKey != INVALID_HANDLE_VALUE)
826 ZwClose(InterfaceKey);
827 if (DeviceKey != INVALID_HANDLE_VALUE)
828 ZwClose(DeviceKey);
829 if (ReferenceKey != INVALID_HANDLE_VALUE)
830 ZwClose(ReferenceKey);
831 if (ControlKey != INVALID_HANDLE_VALUE)
832 ZwClose(ControlKey);
833 if (DeviceBi)
834 ExFreePool(DeviceBi);
835 if (ReferenceBi)
836 ExFreePool(ReferenceBi);
837 if (bip)
838 ExFreePool(bip);
839 return Status;
840 }
841
842 /*++
843 * @name IoRegisterDeviceInterface
844 * @implemented
845 *
846 * Registers a device interface class, if it has not been previously registered,
847 * and creates a new instance of the interface class, which a driver can
848 * subsequently enable for use by applications or other system components.
849 * Documented in WDK.
850 *
851 * @param PhysicalDeviceObject
852 * Points to an optional PDO that narrows the search to only the
853 * device interfaces of the device represented by the PDO
854 *
855 * @param InterfaceClassGuid
856 * Points to a class GUID specifying the device interface class
857 *
858 * @param ReferenceString
859 * Optional parameter, pointing to a unicode string. For a full
860 * description of this rather rarely used param (usually drivers
861 * pass NULL here) see WDK
862 *
863 * @param SymbolicLinkName
864 * Pointer to the resulting unicode string
865 *
866 * @return Usual NTSTATUS
867 *
868 * @remarks Must be called at IRQL = PASSIVE_LEVEL in the context of a
869 * system thread
870 *
871 *--*/
872 NTSTATUS
873 NTAPI
874 IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject,
875 IN CONST GUID *InterfaceClassGuid,
876 IN PUNICODE_STRING ReferenceString OPTIONAL,
877 OUT PUNICODE_STRING SymbolicLinkName)
878 {
879 PUNICODE_STRING InstancePath;
880 UNICODE_STRING GuidString;
881 UNICODE_STRING SubKeyName;
882 UNICODE_STRING InterfaceKeyName;
883 UNICODE_STRING BaseKeyName;
884 UCHAR PdoNameInfoBuffer[sizeof(OBJECT_NAME_INFORMATION) + (256 * sizeof(WCHAR))];
885 POBJECT_NAME_INFORMATION PdoNameInfo = (POBJECT_NAME_INFORMATION)PdoNameInfoBuffer;
886 UNICODE_STRING DeviceInstance = RTL_CONSTANT_STRING(L"DeviceInstance");
887 UNICODE_STRING SymbolicLink = RTL_CONSTANT_STRING(L"SymbolicLink");
888 HANDLE ClassKey;
889 HANDLE InterfaceKey;
890 HANDLE SubKey;
891 ULONG StartIndex;
892 OBJECT_ATTRIBUTES ObjectAttributes;
893 ULONG i;
894 NTSTATUS Status;
895 PEXTENDED_DEVOBJ_EXTENSION DeviceObjectExtension;
896
897 ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
898
899 DPRINT("IoRegisterDeviceInterface(): PDO %p, RefString: %wZ\n",
900 PhysicalDeviceObject, ReferenceString);
901
902 /* Parameters must pass three border of checks */
903 DeviceObjectExtension = (PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension;
904
905 /* 1st level: Presence of a Device Node */
906 if (DeviceObjectExtension->DeviceNode == NULL)
907 {
908 DPRINT("PhysicalDeviceObject 0x%p doesn't have a DeviceNode\n", PhysicalDeviceObject);
909 return STATUS_INVALID_DEVICE_REQUEST;
910 }
911
912 /* 2nd level: Presence of an non-zero length InstancePath */
913 if (DeviceObjectExtension->DeviceNode->InstancePath.Length == 0)
914 {
915 DPRINT("PhysicalDeviceObject 0x%p's DOE has zero-length InstancePath\n", PhysicalDeviceObject);
916 return STATUS_INVALID_DEVICE_REQUEST;
917 }
918
919 /* 3rd level: Optional, based on WDK documentation */
920 if (ReferenceString != NULL)
921 {
922 /* Reference string must not contain path-separator symbols */
923 for (i = 0; i < ReferenceString->Length / sizeof(WCHAR); i++)
924 {
925 if ((ReferenceString->Buffer[i] == '\\') ||
926 (ReferenceString->Buffer[i] == '/'))
927 return STATUS_INVALID_DEVICE_REQUEST;
928 }
929 }
930
931 Status = RtlStringFromGUID(InterfaceClassGuid, &GuidString);
932 if (!NT_SUCCESS(Status))
933 {
934 DPRINT("RtlStringFromGUID() failed with status 0x%08lx\n", Status);
935 return Status;
936 }
937
938 /* Create Pdo name: \Device\xxxxxxxx (unnamed device) */
939 Status = ObQueryNameString(
940 PhysicalDeviceObject,
941 PdoNameInfo,
942 sizeof(PdoNameInfoBuffer),
943 &i);
944 if (!NT_SUCCESS(Status))
945 {
946 DPRINT("ObQueryNameString() failed with status 0x%08lx\n", Status);
947 return Status;
948 }
949 ASSERT(PdoNameInfo->Name.Length);
950
951 /* Create base key name for this interface: HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID} */
952 ASSERT(((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode);
953 InstancePath = &((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode->InstancePath;
954 BaseKeyName.Length = wcslen(BaseKeyString) * sizeof(WCHAR);
955 BaseKeyName.MaximumLength = BaseKeyName.Length
956 + GuidString.Length;
957 BaseKeyName.Buffer = ExAllocatePool(
958 PagedPool,
959 BaseKeyName.MaximumLength);
960 if (!BaseKeyName.Buffer)
961 {
962 DPRINT("ExAllocatePool() failed\n");
963 return STATUS_INSUFFICIENT_RESOURCES;
964 }
965 wcscpy(BaseKeyName.Buffer, BaseKeyString);
966 RtlAppendUnicodeStringToString(&BaseKeyName, &GuidString);
967
968 /* Create BaseKeyName key in registry */
969 InitializeObjectAttributes(
970 &ObjectAttributes,
971 &BaseKeyName,
972 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF,
973 NULL, /* RootDirectory */
974 NULL); /* SecurityDescriptor */
975
976 Status = ZwCreateKey(
977 &ClassKey,
978 KEY_WRITE,
979 &ObjectAttributes,
980 0, /* TileIndex */
981 NULL, /* Class */
982 REG_OPTION_VOLATILE,
983 NULL); /* Disposition */
984
985 if (!NT_SUCCESS(Status))
986 {
987 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
988 ExFreePool(BaseKeyName.Buffer);
989 return Status;
990 }
991
992 /* Create key name for this interface: ##?#ACPI#PNP0501#1#{GUID} */
993 InterfaceKeyName.Length = 0;
994 InterfaceKeyName.MaximumLength =
995 4 * sizeof(WCHAR) + /* 4 = size of ##?# */
996 InstancePath->Length +
997 sizeof(WCHAR) + /* 1 = size of # */
998 GuidString.Length;
999 InterfaceKeyName.Buffer = ExAllocatePool(
1000 PagedPool,
1001 InterfaceKeyName.MaximumLength);
1002 if (!InterfaceKeyName.Buffer)
1003 {
1004 DPRINT("ExAllocatePool() failed\n");
1005 return STATUS_INSUFFICIENT_RESOURCES;
1006 }
1007
1008 RtlAppendUnicodeToString(&InterfaceKeyName, L"##?#");
1009 StartIndex = InterfaceKeyName.Length / sizeof(WCHAR);
1010 RtlAppendUnicodeStringToString(&InterfaceKeyName, InstancePath);
1011 for (i = 0; i < InstancePath->Length / sizeof(WCHAR); i++)
1012 {
1013 if (InterfaceKeyName.Buffer[StartIndex + i] == '\\')
1014 InterfaceKeyName.Buffer[StartIndex + i] = '#';
1015 }
1016 RtlAppendUnicodeToString(&InterfaceKeyName, L"#");
1017 RtlAppendUnicodeStringToString(&InterfaceKeyName, &GuidString);
1018
1019 /* Create the interface key in registry */
1020 InitializeObjectAttributes(
1021 &ObjectAttributes,
1022 &InterfaceKeyName,
1023 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF,
1024 ClassKey,
1025 NULL); /* SecurityDescriptor */
1026
1027 Status = ZwCreateKey(
1028 &InterfaceKey,
1029 KEY_WRITE,
1030 &ObjectAttributes,
1031 0, /* TileIndex */
1032 NULL, /* Class */
1033 REG_OPTION_VOLATILE,
1034 NULL); /* Disposition */
1035
1036 if (!NT_SUCCESS(Status))
1037 {
1038 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
1039 ZwClose(ClassKey);
1040 ExFreePool(BaseKeyName.Buffer);
1041 return Status;
1042 }
1043
1044 /* Write DeviceInstance entry. Value is InstancePath */
1045 Status = ZwSetValueKey(
1046 InterfaceKey,
1047 &DeviceInstance,
1048 0, /* TileIndex */
1049 REG_SZ,
1050 InstancePath->Buffer,
1051 InstancePath->Length);
1052 if (!NT_SUCCESS(Status))
1053 {
1054 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
1055 ZwClose(InterfaceKey);
1056 ZwClose(ClassKey);
1057 ExFreePool(InterfaceKeyName.Buffer);
1058 ExFreePool(BaseKeyName.Buffer);
1059 return Status;
1060 }
1061
1062 /* Create subkey. Name is #ReferenceString */
1063 SubKeyName.Length = 0;
1064 SubKeyName.MaximumLength = sizeof(WCHAR);
1065 if (ReferenceString && ReferenceString->Length)
1066 SubKeyName.MaximumLength += ReferenceString->Length;
1067 SubKeyName.Buffer = ExAllocatePool(
1068 PagedPool,
1069 SubKeyName.MaximumLength);
1070 if (!SubKeyName.Buffer)
1071 {
1072 DPRINT("ExAllocatePool() failed\n");
1073 ZwClose(InterfaceKey);
1074 ZwClose(ClassKey);
1075 ExFreePool(InterfaceKeyName.Buffer);
1076 ExFreePool(BaseKeyName.Buffer);
1077 return STATUS_INSUFFICIENT_RESOURCES;
1078 }
1079 RtlAppendUnicodeToString(&SubKeyName, L"#");
1080 if (ReferenceString && ReferenceString->Length)
1081 RtlAppendUnicodeStringToString(&SubKeyName, ReferenceString);
1082
1083 /* Create SubKeyName key in registry */
1084 InitializeObjectAttributes(
1085 &ObjectAttributes,
1086 &SubKeyName,
1087 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1088 InterfaceKey, /* RootDirectory */
1089 NULL); /* SecurityDescriptor */
1090
1091 Status = ZwCreateKey(
1092 &SubKey,
1093 KEY_WRITE,
1094 &ObjectAttributes,
1095 0, /* TileIndex */
1096 NULL, /* Class */
1097 REG_OPTION_VOLATILE,
1098 NULL); /* Disposition */
1099
1100 if (!NT_SUCCESS(Status))
1101 {
1102 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
1103 ZwClose(InterfaceKey);
1104 ZwClose(ClassKey);
1105 ExFreePool(InterfaceKeyName.Buffer);
1106 ExFreePool(BaseKeyName.Buffer);
1107 return Status;
1108 }
1109
1110 /* Create symbolic link name: \??\ACPI#PNP0501#1#{GUID}\ReferenceString */
1111 SymbolicLinkName->Length = 0;
1112 SymbolicLinkName->MaximumLength = SymbolicLinkName->Length
1113 + 4 * sizeof(WCHAR) /* 4 = size of \??\ */
1114 + InstancePath->Length
1115 + sizeof(WCHAR) /* 1 = size of # */
1116 + GuidString.Length
1117 + sizeof(WCHAR); /* final NULL */
1118 if (ReferenceString && ReferenceString->Length)
1119 SymbolicLinkName->MaximumLength += sizeof(WCHAR) + ReferenceString->Length;
1120 SymbolicLinkName->Buffer = ExAllocatePool(
1121 PagedPool,
1122 SymbolicLinkName->MaximumLength);
1123 if (!SymbolicLinkName->Buffer)
1124 {
1125 DPRINT("ExAllocatePool() failed\n");
1126 ZwClose(SubKey);
1127 ZwClose(InterfaceKey);
1128 ZwClose(ClassKey);
1129 ExFreePool(InterfaceKeyName.Buffer);
1130 ExFreePool(SubKeyName.Buffer);
1131 ExFreePool(BaseKeyName.Buffer);
1132 return STATUS_INSUFFICIENT_RESOURCES;
1133 }
1134 RtlAppendUnicodeToString(SymbolicLinkName, L"\\??\\");
1135 StartIndex = SymbolicLinkName->Length / sizeof(WCHAR);
1136 RtlAppendUnicodeStringToString(SymbolicLinkName, InstancePath);
1137 for (i = 0; i < InstancePath->Length / sizeof(WCHAR); i++)
1138 {
1139 if (SymbolicLinkName->Buffer[StartIndex + i] == '\\')
1140 SymbolicLinkName->Buffer[StartIndex + i] = '#';
1141 }
1142 RtlAppendUnicodeToString(SymbolicLinkName, L"#");
1143 RtlAppendUnicodeStringToString(SymbolicLinkName, &GuidString);
1144 SymbolicLinkName->Buffer[SymbolicLinkName->Length/sizeof(WCHAR)] = L'\0';
1145
1146 /* Create symbolic link */
1147 DPRINT("IoRegisterDeviceInterface(): creating symbolic link %wZ -> %wZ\n", SymbolicLinkName, &PdoNameInfo->Name);
1148 Status = IoCreateSymbolicLink(SymbolicLinkName, &PdoNameInfo->Name);
1149 if (!NT_SUCCESS(Status) && ReferenceString == NULL)
1150 {
1151 DPRINT1("IoCreateSymbolicLink() failed with status 0x%08lx\n", Status);
1152 ZwClose(SubKey);
1153 ZwClose(InterfaceKey);
1154 ZwClose(ClassKey);
1155 ExFreePool(SubKeyName.Buffer);
1156 ExFreePool(InterfaceKeyName.Buffer);
1157 ExFreePool(BaseKeyName.Buffer);
1158 ExFreePool(SymbolicLinkName->Buffer);
1159 return Status;
1160 }
1161
1162 if (ReferenceString && ReferenceString->Length)
1163 {
1164 RtlAppendUnicodeToString(SymbolicLinkName, L"\\");
1165 RtlAppendUnicodeStringToString(SymbolicLinkName, ReferenceString);
1166 }
1167 SymbolicLinkName->Buffer[SymbolicLinkName->Length/sizeof(WCHAR)] = L'\0';
1168
1169 /* Write symbolic link name in registry */
1170 SymbolicLinkName->Buffer[1] = '\\';
1171 Status = ZwSetValueKey(
1172 SubKey,
1173 &SymbolicLink,
1174 0, /* TileIndex */
1175 REG_SZ,
1176 SymbolicLinkName->Buffer,
1177 SymbolicLinkName->Length);
1178 if (!NT_SUCCESS(Status))
1179 {
1180 DPRINT1("ZwSetValueKey() failed with status 0x%08lx\n", Status);
1181 ExFreePool(SymbolicLinkName->Buffer);
1182 }
1183 else
1184 {
1185 SymbolicLinkName->Buffer[1] = '?';
1186 }
1187
1188 ZwClose(SubKey);
1189 ZwClose(InterfaceKey);
1190 ZwClose(ClassKey);
1191 ExFreePool(SubKeyName.Buffer);
1192 ExFreePool(InterfaceKeyName.Buffer);
1193 ExFreePool(BaseKeyName.Buffer);
1194
1195 return Status;
1196 }
1197
1198 /*++
1199 * @name IoSetDeviceInterfaceState
1200 * @implemented
1201 *
1202 * Enables or disables an instance of a previously registered device
1203 * interface class.
1204 * Documented in WDK.
1205 *
1206 * @param SymbolicLinkName
1207 * Pointer to the string identifying instance to enable or disable
1208 *
1209 * @param Enable
1210 * TRUE = enable, FALSE = disable
1211 *
1212 * @return Usual NTSTATUS
1213 *
1214 * @remarks Must be called at IRQL = PASSIVE_LEVEL in the context of a
1215 * system thread
1216 *
1217 *--*/
1218 NTSTATUS
1219 NTAPI
1220 IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName,
1221 IN BOOLEAN Enable)
1222 {
1223 PDEVICE_OBJECT PhysicalDeviceObject;
1224 PFILE_OBJECT FileObject;
1225 UNICODE_STRING GuidString;
1226 UNICODE_STRING SymLink;
1227 PWCHAR StartPosition;
1228 PWCHAR EndPosition;
1229 NTSTATUS Status;
1230 LPCGUID EventGuid;
1231 HANDLE InstanceHandle, ControlHandle;
1232 UNICODE_STRING KeyName;
1233 OBJECT_ATTRIBUTES ObjectAttributes;
1234 ULONG LinkedValue;
1235
1236 if (SymbolicLinkName == NULL)
1237 return STATUS_INVALID_PARAMETER_1;
1238
1239 DPRINT("IoSetDeviceInterfaceState('%wZ', %d)\n", SymbolicLinkName, Enable);
1240
1241 /* Symbolic link name is \??\ACPI#PNP0501#1#{GUID}\ReferenceString */
1242 /* Get GUID from SymbolicLinkName */
1243 StartPosition = wcschr(SymbolicLinkName->Buffer, L'{');
1244 EndPosition = wcschr(SymbolicLinkName->Buffer, L'}');
1245 if (!StartPosition ||!EndPosition || StartPosition > EndPosition)
1246 {
1247 DPRINT1("IoSetDeviceInterfaceState() returning STATUS_INVALID_PARAMETER_1\n");
1248 return STATUS_INVALID_PARAMETER_1;
1249 }
1250 GuidString.Buffer = StartPosition;
1251 GuidString.MaximumLength = GuidString.Length = (USHORT)((ULONG_PTR)(EndPosition + 1) - (ULONG_PTR)StartPosition);
1252
1253 SymLink.Buffer = SymbolicLinkName->Buffer;
1254 SymLink.MaximumLength = SymLink.Length = (USHORT)((ULONG_PTR)(EndPosition + 1) - (ULONG_PTR)SymLink.Buffer);
1255 DPRINT("IoSetDeviceInterfaceState('%wZ', %d)\n", SymbolicLinkName, Enable);
1256
1257 Status = OpenRegistryHandlesFromSymbolicLink(SymbolicLinkName,
1258 KEY_CREATE_SUB_KEY,
1259 NULL,
1260 NULL,
1261 &InstanceHandle);
1262 if (!NT_SUCCESS(Status))
1263 return Status;
1264
1265 RtlInitUnicodeString(&KeyName, L"Control");
1266 InitializeObjectAttributes(&ObjectAttributes,
1267 &KeyName,
1268 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1269 InstanceHandle,
1270 NULL);
1271 Status = ZwCreateKey(&ControlHandle,
1272 KEY_SET_VALUE,
1273 &ObjectAttributes,
1274 0,
1275 NULL,
1276 REG_OPTION_VOLATILE,
1277 NULL);
1278 ZwClose(InstanceHandle);
1279 if (!NT_SUCCESS(Status))
1280 {
1281 DPRINT1("Failed to create the Control subkey\n");
1282 return Status;
1283 }
1284
1285 LinkedValue = (Enable ? 1 : 0);
1286
1287 RtlInitUnicodeString(&KeyName, L"Linked");
1288 Status = ZwSetValueKey(ControlHandle,
1289 &KeyName,
1290 0,
1291 REG_DWORD,
1292 &LinkedValue,
1293 sizeof(ULONG));
1294 ZwClose(ControlHandle);
1295 if (!NT_SUCCESS(Status))
1296 {
1297 DPRINT1("Failed to write the Linked value\n");
1298 return Status;
1299 }
1300
1301 /* Get pointer to the PDO */
1302 Status = IoGetDeviceObjectPointer(
1303 &SymLink,
1304 0, /* DesiredAccess */
1305 &FileObject,
1306 &PhysicalDeviceObject);
1307 if (!NT_SUCCESS(Status))
1308 {
1309 DPRINT1("IoGetDeviceObjectPointer() failed with status 0x%08lx\n", Status);
1310 return Status;
1311 }
1312
1313 EventGuid = Enable ? &GUID_DEVICE_INTERFACE_ARRIVAL : &GUID_DEVICE_INTERFACE_REMOVAL;
1314 IopNotifyPlugPlayNotification(
1315 PhysicalDeviceObject,
1316 EventCategoryDeviceInterfaceChange,
1317 EventGuid,
1318 &GuidString,
1319 (PVOID)SymbolicLinkName);
1320
1321 ObDereferenceObject(FileObject);
1322 DPRINT("Status %x\n", Status);
1323 return STATUS_SUCCESS;
1324 }
1325
1326 /* EOF */