[NTOSKRNL]
[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
735 /* Add new symbolic link to symbolic link list */
736 if (ReturnBuffer.Length + KeyName.Length + sizeof(WCHAR) > ReturnBuffer.MaximumLength)
737 {
738 PWSTR NewBuffer;
739 ReturnBuffer.MaximumLength = max(ReturnBuffer.MaximumLength * 2, ReturnBuffer.Length + KeyName.Length + 2 * sizeof(WCHAR));
740 NewBuffer = ExAllocatePool(PagedPool, ReturnBuffer.MaximumLength);
741 if (!NewBuffer)
742 {
743 DPRINT("ExAllocatePool() failed\n");
744 Status = STATUS_INSUFFICIENT_RESOURCES;
745 goto cleanup;
746 }
747 RtlCopyMemory(NewBuffer, ReturnBuffer.Buffer, ReturnBuffer.Length);
748 if (ReturnBuffer.Buffer)
749 ExFreePool(ReturnBuffer.Buffer);
750 ReturnBuffer.Buffer = NewBuffer;
751 }
752 DPRINT("Adding symbolic link %wZ\n", &KeyName);
753 Status = RtlAppendUnicodeStringToString(&ReturnBuffer, &KeyName);
754 if (!NT_SUCCESS(Status))
755 {
756 DPRINT("RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
757 goto cleanup;
758 }
759 /* RtlAppendUnicodeStringToString added a NULL at the end of the
760 * destination string, but didn't increase the Length field.
761 * Do it for it.
762 */
763 ReturnBuffer.Length += sizeof(WCHAR);
764
765 NextReferenceString:
766 ExFreePool(ReferenceBi);
767 ReferenceBi = NULL;
768 if (bip)
769 ExFreePool(bip);
770 bip = NULL;
771 if (ReferenceKey != INVALID_HANDLE_VALUE)
772 {
773 ZwClose(ReferenceKey);
774 ReferenceKey = INVALID_HANDLE_VALUE;
775 }
776 if (ControlKey != INVALID_HANDLE_VALUE)
777 {
778 ZwClose(ControlKey);
779 ControlKey = INVALID_HANDLE_VALUE;
780 }
781 }
782 if (FoundRightPDO)
783 {
784 /* No need to go further, as we already have found what we searched */
785 break;
786 }
787
788 ExFreePool(DeviceBi);
789 DeviceBi = NULL;
790 ZwClose(DeviceKey);
791 DeviceKey = INVALID_HANDLE_VALUE;
792 }
793
794 /* Add final NULL to ReturnBuffer */
795 if (ReturnBuffer.Length >= ReturnBuffer.MaximumLength)
796 {
797 PWSTR NewBuffer;
798 ReturnBuffer.MaximumLength += sizeof(WCHAR);
799 NewBuffer = ExAllocatePool(PagedPool, ReturnBuffer.MaximumLength);
800 if (!NewBuffer)
801 {
802 DPRINT("ExAllocatePool() failed\n");
803 Status = STATUS_INSUFFICIENT_RESOURCES;
804 goto cleanup;
805 }
806 if (ReturnBuffer.Buffer)
807 {
808 RtlCopyMemory(NewBuffer, ReturnBuffer.Buffer, ReturnBuffer.Length);
809 ExFreePool(ReturnBuffer.Buffer);
810 }
811 ReturnBuffer.Buffer = NewBuffer;
812 }
813 ReturnBuffer.Buffer[ReturnBuffer.Length / sizeof(WCHAR)] = UNICODE_NULL;
814 *SymbolicLinkList = ReturnBuffer.Buffer;
815 Status = STATUS_SUCCESS;
816
817 cleanup:
818 if (!NT_SUCCESS(Status) && ReturnBuffer.Buffer)
819 ExFreePool(ReturnBuffer.Buffer);
820 if (InterfaceKey != INVALID_HANDLE_VALUE)
821 ZwClose(InterfaceKey);
822 if (DeviceKey != INVALID_HANDLE_VALUE)
823 ZwClose(DeviceKey);
824 if (ReferenceKey != INVALID_HANDLE_VALUE)
825 ZwClose(ReferenceKey);
826 if (ControlKey != INVALID_HANDLE_VALUE)
827 ZwClose(ControlKey);
828 if (DeviceBi)
829 ExFreePool(DeviceBi);
830 if (ReferenceBi)
831 ExFreePool(ReferenceBi);
832 if (bip)
833 ExFreePool(bip);
834 return Status;
835 }
836
837 /*++
838 * @name IoRegisterDeviceInterface
839 * @implemented
840 *
841 * Registers a device interface class, if it has not been previously registered,
842 * and creates a new instance of the interface class, which a driver can
843 * subsequently enable for use by applications or other system components.
844 * Documented in WDK.
845 *
846 * @param PhysicalDeviceObject
847 * Points to an optional PDO that narrows the search to only the
848 * device interfaces of the device represented by the PDO
849 *
850 * @param InterfaceClassGuid
851 * Points to a class GUID specifying the device interface class
852 *
853 * @param ReferenceString
854 * Optional parameter, pointing to a unicode string. For a full
855 * description of this rather rarely used param (usually drivers
856 * pass NULL here) see WDK
857 *
858 * @param SymbolicLinkName
859 * Pointer to the resulting unicode string
860 *
861 * @return Usual NTSTATUS
862 *
863 * @remarks Must be called at IRQL = PASSIVE_LEVEL in the context of a
864 * system thread
865 *
866 *--*/
867 NTSTATUS
868 NTAPI
869 IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject,
870 IN CONST GUID *InterfaceClassGuid,
871 IN PUNICODE_STRING ReferenceString OPTIONAL,
872 OUT PUNICODE_STRING SymbolicLinkName)
873 {
874 PUNICODE_STRING InstancePath;
875 UNICODE_STRING GuidString;
876 UNICODE_STRING SubKeyName;
877 UNICODE_STRING InterfaceKeyName;
878 UNICODE_STRING BaseKeyName;
879 UCHAR PdoNameInfoBuffer[sizeof(OBJECT_NAME_INFORMATION) + (256 * sizeof(WCHAR))];
880 POBJECT_NAME_INFORMATION PdoNameInfo = (POBJECT_NAME_INFORMATION)PdoNameInfoBuffer;
881 UNICODE_STRING DeviceInstance = RTL_CONSTANT_STRING(L"DeviceInstance");
882 UNICODE_STRING SymbolicLink = RTL_CONSTANT_STRING(L"SymbolicLink");
883 HANDLE ClassKey;
884 HANDLE InterfaceKey;
885 HANDLE SubKey;
886 ULONG StartIndex;
887 OBJECT_ATTRIBUTES ObjectAttributes;
888 ULONG i;
889 NTSTATUS Status;
890 PEXTENDED_DEVOBJ_EXTENSION DeviceObjectExtension;
891
892 ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
893
894 DPRINT("IoRegisterDeviceInterface(): PDO %p, RefString: %wZ\n",
895 PhysicalDeviceObject, ReferenceString);
896
897 /* Parameters must pass three border of checks */
898 DeviceObjectExtension = (PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension;
899
900 /* 1st level: Presence of a Device Node */
901 if (DeviceObjectExtension->DeviceNode == NULL)
902 {
903 DPRINT("PhysicalDeviceObject 0x%p doesn't have a DeviceNode\n", PhysicalDeviceObject);
904 return STATUS_INVALID_DEVICE_REQUEST;
905 }
906
907 /* 2nd level: Presence of an non-zero length InstancePath */
908 if (DeviceObjectExtension->DeviceNode->InstancePath.Length == 0)
909 {
910 DPRINT("PhysicalDeviceObject 0x%p's DOE has zero-length InstancePath\n", PhysicalDeviceObject);
911 return STATUS_INVALID_DEVICE_REQUEST;
912 }
913
914 /* 3rd level: Optional, based on WDK documentation */
915 if (ReferenceString != NULL)
916 {
917 /* Reference string must not contain path-separator symbols */
918 for (i = 0; i < ReferenceString->Length / sizeof(WCHAR); i++)
919 {
920 if ((ReferenceString->Buffer[i] == '\\') ||
921 (ReferenceString->Buffer[i] == '/'))
922 return STATUS_INVALID_DEVICE_REQUEST;
923 }
924 }
925
926 Status = RtlStringFromGUID(InterfaceClassGuid, &GuidString);
927 if (!NT_SUCCESS(Status))
928 {
929 DPRINT("RtlStringFromGUID() failed with status 0x%08lx\n", Status);
930 return Status;
931 }
932
933 /* Create Pdo name: \Device\xxxxxxxx (unnamed device) */
934 Status = ObQueryNameString(
935 PhysicalDeviceObject,
936 PdoNameInfo,
937 sizeof(PdoNameInfoBuffer),
938 &i);
939 if (!NT_SUCCESS(Status))
940 {
941 DPRINT("ObQueryNameString() failed with status 0x%08lx\n", Status);
942 return Status;
943 }
944 ASSERT(PdoNameInfo->Name.Length);
945
946 /* Create base key name for this interface: HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID} */
947 ASSERT(((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode);
948 InstancePath = &((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode->InstancePath;
949 BaseKeyName.Length = wcslen(BaseKeyString) * sizeof(WCHAR);
950 BaseKeyName.MaximumLength = BaseKeyName.Length
951 + GuidString.Length;
952 BaseKeyName.Buffer = ExAllocatePool(
953 PagedPool,
954 BaseKeyName.MaximumLength);
955 if (!BaseKeyName.Buffer)
956 {
957 DPRINT("ExAllocatePool() failed\n");
958 return STATUS_INSUFFICIENT_RESOURCES;
959 }
960 wcscpy(BaseKeyName.Buffer, BaseKeyString);
961 RtlAppendUnicodeStringToString(&BaseKeyName, &GuidString);
962
963 /* Create BaseKeyName key in registry */
964 InitializeObjectAttributes(
965 &ObjectAttributes,
966 &BaseKeyName,
967 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF,
968 NULL, /* RootDirectory */
969 NULL); /* SecurityDescriptor */
970
971 Status = ZwCreateKey(
972 &ClassKey,
973 KEY_WRITE,
974 &ObjectAttributes,
975 0, /* TileIndex */
976 NULL, /* Class */
977 REG_OPTION_VOLATILE,
978 NULL); /* Disposition */
979
980 if (!NT_SUCCESS(Status))
981 {
982 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
983 ExFreePool(BaseKeyName.Buffer);
984 return Status;
985 }
986
987 /* Create key name for this interface: ##?#ACPI#PNP0501#1#{GUID} */
988 InterfaceKeyName.Length = 0;
989 InterfaceKeyName.MaximumLength =
990 4 * sizeof(WCHAR) + /* 4 = size of ##?# */
991 InstancePath->Length +
992 sizeof(WCHAR) + /* 1 = size of # */
993 GuidString.Length;
994 InterfaceKeyName.Buffer = ExAllocatePool(
995 PagedPool,
996 InterfaceKeyName.MaximumLength);
997 if (!InterfaceKeyName.Buffer)
998 {
999 DPRINT("ExAllocatePool() failed\n");
1000 return STATUS_INSUFFICIENT_RESOURCES;
1001 }
1002
1003 RtlAppendUnicodeToString(&InterfaceKeyName, L"##?#");
1004 StartIndex = InterfaceKeyName.Length / sizeof(WCHAR);
1005 RtlAppendUnicodeStringToString(&InterfaceKeyName, InstancePath);
1006 for (i = 0; i < InstancePath->Length / sizeof(WCHAR); i++)
1007 {
1008 if (InterfaceKeyName.Buffer[StartIndex + i] == '\\')
1009 InterfaceKeyName.Buffer[StartIndex + i] = '#';
1010 }
1011 RtlAppendUnicodeToString(&InterfaceKeyName, L"#");
1012 RtlAppendUnicodeStringToString(&InterfaceKeyName, &GuidString);
1013
1014 /* Create the interface key in registry */
1015 InitializeObjectAttributes(
1016 &ObjectAttributes,
1017 &InterfaceKeyName,
1018 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE | OBJ_OPENIF,
1019 ClassKey,
1020 NULL); /* SecurityDescriptor */
1021
1022 Status = ZwCreateKey(
1023 &InterfaceKey,
1024 KEY_WRITE,
1025 &ObjectAttributes,
1026 0, /* TileIndex */
1027 NULL, /* Class */
1028 REG_OPTION_VOLATILE,
1029 NULL); /* Disposition */
1030
1031 if (!NT_SUCCESS(Status))
1032 {
1033 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
1034 ZwClose(ClassKey);
1035 ExFreePool(BaseKeyName.Buffer);
1036 return Status;
1037 }
1038
1039 /* Write DeviceInstance entry. Value is InstancePath */
1040 Status = ZwSetValueKey(
1041 InterfaceKey,
1042 &DeviceInstance,
1043 0, /* TileIndex */
1044 REG_SZ,
1045 InstancePath->Buffer,
1046 InstancePath->Length);
1047 if (!NT_SUCCESS(Status))
1048 {
1049 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
1050 ZwClose(InterfaceKey);
1051 ZwClose(ClassKey);
1052 ExFreePool(InterfaceKeyName.Buffer);
1053 ExFreePool(BaseKeyName.Buffer);
1054 return Status;
1055 }
1056
1057 /* Create subkey. Name is #ReferenceString */
1058 SubKeyName.Length = 0;
1059 SubKeyName.MaximumLength = sizeof(WCHAR);
1060 if (ReferenceString && ReferenceString->Length)
1061 SubKeyName.MaximumLength += ReferenceString->Length;
1062 SubKeyName.Buffer = ExAllocatePool(
1063 PagedPool,
1064 SubKeyName.MaximumLength);
1065 if (!SubKeyName.Buffer)
1066 {
1067 DPRINT("ExAllocatePool() failed\n");
1068 ZwClose(InterfaceKey);
1069 ZwClose(ClassKey);
1070 ExFreePool(InterfaceKeyName.Buffer);
1071 ExFreePool(BaseKeyName.Buffer);
1072 return STATUS_INSUFFICIENT_RESOURCES;
1073 }
1074 RtlAppendUnicodeToString(&SubKeyName, L"#");
1075 if (ReferenceString && ReferenceString->Length)
1076 RtlAppendUnicodeStringToString(&SubKeyName, ReferenceString);
1077
1078 /* Create SubKeyName key in registry */
1079 InitializeObjectAttributes(
1080 &ObjectAttributes,
1081 &SubKeyName,
1082 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1083 InterfaceKey, /* RootDirectory */
1084 NULL); /* SecurityDescriptor */
1085
1086 Status = ZwCreateKey(
1087 &SubKey,
1088 KEY_WRITE,
1089 &ObjectAttributes,
1090 0, /* TileIndex */
1091 NULL, /* Class */
1092 REG_OPTION_VOLATILE,
1093 NULL); /* Disposition */
1094
1095 if (!NT_SUCCESS(Status))
1096 {
1097 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
1098 ZwClose(InterfaceKey);
1099 ZwClose(ClassKey);
1100 ExFreePool(InterfaceKeyName.Buffer);
1101 ExFreePool(BaseKeyName.Buffer);
1102 return Status;
1103 }
1104
1105 /* Create symbolic link name: \??\ACPI#PNP0501#1#{GUID}\ReferenceString */
1106 SymbolicLinkName->Length = 0;
1107 SymbolicLinkName->MaximumLength = SymbolicLinkName->Length
1108 + 4 * sizeof(WCHAR) /* 4 = size of \??\ */
1109 + InstancePath->Length
1110 + sizeof(WCHAR) /* 1 = size of # */
1111 + GuidString.Length
1112 + sizeof(WCHAR); /* final NULL */
1113 if (ReferenceString && ReferenceString->Length)
1114 SymbolicLinkName->MaximumLength += sizeof(WCHAR) + ReferenceString->Length;
1115 SymbolicLinkName->Buffer = ExAllocatePool(
1116 PagedPool,
1117 SymbolicLinkName->MaximumLength);
1118 if (!SymbolicLinkName->Buffer)
1119 {
1120 DPRINT("ExAllocatePool() failed\n");
1121 ZwClose(SubKey);
1122 ZwClose(InterfaceKey);
1123 ZwClose(ClassKey);
1124 ExFreePool(InterfaceKeyName.Buffer);
1125 ExFreePool(SubKeyName.Buffer);
1126 ExFreePool(BaseKeyName.Buffer);
1127 return STATUS_INSUFFICIENT_RESOURCES;
1128 }
1129 RtlAppendUnicodeToString(SymbolicLinkName, L"\\??\\");
1130 StartIndex = SymbolicLinkName->Length / sizeof(WCHAR);
1131 RtlAppendUnicodeStringToString(SymbolicLinkName, InstancePath);
1132 for (i = 0; i < InstancePath->Length / sizeof(WCHAR); i++)
1133 {
1134 if (SymbolicLinkName->Buffer[StartIndex + i] == '\\')
1135 SymbolicLinkName->Buffer[StartIndex + i] = '#';
1136 }
1137 RtlAppendUnicodeToString(SymbolicLinkName, L"#");
1138 RtlAppendUnicodeStringToString(SymbolicLinkName, &GuidString);
1139 SymbolicLinkName->Buffer[SymbolicLinkName->Length/sizeof(WCHAR)] = L'\0';
1140
1141 /* Create symbolic link */
1142 DPRINT("IoRegisterDeviceInterface(): creating symbolic link %wZ -> %wZ\n", SymbolicLinkName, &PdoNameInfo->Name);
1143 Status = IoCreateSymbolicLink(SymbolicLinkName, &PdoNameInfo->Name);
1144 if (!NT_SUCCESS(Status) && ReferenceString == NULL)
1145 {
1146 DPRINT1("IoCreateSymbolicLink() failed with status 0x%08lx\n", Status);
1147 ZwClose(SubKey);
1148 ZwClose(InterfaceKey);
1149 ZwClose(ClassKey);
1150 ExFreePool(SubKeyName.Buffer);
1151 ExFreePool(InterfaceKeyName.Buffer);
1152 ExFreePool(BaseKeyName.Buffer);
1153 ExFreePool(SymbolicLinkName->Buffer);
1154 return Status;
1155 }
1156
1157 if (ReferenceString && ReferenceString->Length)
1158 {
1159 RtlAppendUnicodeToString(SymbolicLinkName, L"\\");
1160 RtlAppendUnicodeStringToString(SymbolicLinkName, ReferenceString);
1161 }
1162 SymbolicLinkName->Buffer[SymbolicLinkName->Length/sizeof(WCHAR)] = L'\0';
1163
1164 /* Write symbolic link name in registry */
1165 SymbolicLinkName->Buffer[1] = '\\';
1166 Status = ZwSetValueKey(
1167 SubKey,
1168 &SymbolicLink,
1169 0, /* TileIndex */
1170 REG_SZ,
1171 SymbolicLinkName->Buffer,
1172 SymbolicLinkName->Length);
1173 if (!NT_SUCCESS(Status))
1174 {
1175 DPRINT1("ZwSetValueKey() failed with status 0x%08lx\n", Status);
1176 ExFreePool(SymbolicLinkName->Buffer);
1177 }
1178 else
1179 {
1180 SymbolicLinkName->Buffer[1] = '?';
1181 }
1182
1183 ZwClose(SubKey);
1184 ZwClose(InterfaceKey);
1185 ZwClose(ClassKey);
1186 ExFreePool(SubKeyName.Buffer);
1187 ExFreePool(InterfaceKeyName.Buffer);
1188 ExFreePool(BaseKeyName.Buffer);
1189
1190 return Status;
1191 }
1192
1193 /*++
1194 * @name IoSetDeviceInterfaceState
1195 * @implemented
1196 *
1197 * Enables or disables an instance of a previously registered device
1198 * interface class.
1199 * Documented in WDK.
1200 *
1201 * @param SymbolicLinkName
1202 * Pointer to the string identifying instance to enable or disable
1203 *
1204 * @param Enable
1205 * TRUE = enable, FALSE = disable
1206 *
1207 * @return Usual NTSTATUS
1208 *
1209 * @remarks Must be called at IRQL = PASSIVE_LEVEL in the context of a
1210 * system thread
1211 *
1212 *--*/
1213 NTSTATUS
1214 NTAPI
1215 IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName,
1216 IN BOOLEAN Enable)
1217 {
1218 PDEVICE_OBJECT PhysicalDeviceObject;
1219 PFILE_OBJECT FileObject;
1220 UNICODE_STRING GuidString;
1221 UNICODE_STRING SymLink;
1222 PWCHAR StartPosition;
1223 PWCHAR EndPosition;
1224 NTSTATUS Status;
1225 LPCGUID EventGuid;
1226 HANDLE InstanceHandle, ControlHandle;
1227 UNICODE_STRING KeyName;
1228 OBJECT_ATTRIBUTES ObjectAttributes;
1229 ULONG LinkedValue;
1230 GUID DeviceGuid;
1231
1232 if (SymbolicLinkName == NULL)
1233 return STATUS_INVALID_PARAMETER_1;
1234
1235 DPRINT("IoSetDeviceInterfaceState('%wZ', %d)\n", SymbolicLinkName, Enable);
1236
1237 /* Symbolic link name is \??\ACPI#PNP0501#1#{GUID}\ReferenceString */
1238 /* Get GUID from SymbolicLinkName */
1239 StartPosition = wcschr(SymbolicLinkName->Buffer, L'{');
1240 EndPosition = wcschr(SymbolicLinkName->Buffer, L'}');
1241 if (!StartPosition ||!EndPosition || StartPosition > EndPosition)
1242 {
1243 DPRINT1("IoSetDeviceInterfaceState() returning STATUS_INVALID_PARAMETER_1\n");
1244 return STATUS_INVALID_PARAMETER_1;
1245 }
1246 GuidString.Buffer = StartPosition;
1247 GuidString.MaximumLength = GuidString.Length = (USHORT)((ULONG_PTR)(EndPosition + 1) - (ULONG_PTR)StartPosition);
1248
1249 SymLink.Buffer = SymbolicLinkName->Buffer;
1250 SymLink.MaximumLength = SymLink.Length = (USHORT)((ULONG_PTR)(EndPosition + 1) - (ULONG_PTR)SymLink.Buffer);
1251 DPRINT("IoSetDeviceInterfaceState('%wZ', %d)\n", SymbolicLinkName, Enable);
1252
1253 Status = OpenRegistryHandlesFromSymbolicLink(SymbolicLinkName,
1254 KEY_CREATE_SUB_KEY,
1255 NULL,
1256 NULL,
1257 &InstanceHandle);
1258 if (!NT_SUCCESS(Status))
1259 return Status;
1260
1261 RtlInitUnicodeString(&KeyName, L"Control");
1262 InitializeObjectAttributes(&ObjectAttributes,
1263 &KeyName,
1264 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
1265 InstanceHandle,
1266 NULL);
1267 Status = ZwCreateKey(&ControlHandle,
1268 KEY_SET_VALUE,
1269 &ObjectAttributes,
1270 0,
1271 NULL,
1272 REG_OPTION_VOLATILE,
1273 NULL);
1274 ZwClose(InstanceHandle);
1275 if (!NT_SUCCESS(Status))
1276 {
1277 DPRINT1("Failed to create the Control subkey\n");
1278 return Status;
1279 }
1280
1281 LinkedValue = (Enable ? 1 : 0);
1282
1283 RtlInitUnicodeString(&KeyName, L"Linked");
1284 Status = ZwSetValueKey(ControlHandle,
1285 &KeyName,
1286 0,
1287 REG_DWORD,
1288 &LinkedValue,
1289 sizeof(ULONG));
1290 ZwClose(ControlHandle);
1291 if (!NT_SUCCESS(Status))
1292 {
1293 DPRINT1("Failed to write the Linked value\n");
1294 return Status;
1295 }
1296
1297 /* Get pointer to the PDO */
1298 Status = IoGetDeviceObjectPointer(
1299 &SymLink,
1300 0, /* DesiredAccess */
1301 &FileObject,
1302 &PhysicalDeviceObject);
1303 if (!NT_SUCCESS(Status))
1304 {
1305 DPRINT1("IoGetDeviceObjectPointer() failed with status 0x%08lx\n", Status);
1306 return Status;
1307 }
1308
1309 Status = RtlGUIDFromString(&GuidString, &DeviceGuid);
1310 if (!NT_SUCCESS(Status))
1311 {
1312 DPRINT1("RtlGUIDFromString() failed with status 0x%08lx\n", Status);
1313 return Status;
1314 }
1315
1316 EventGuid = Enable ? &GUID_DEVICE_INTERFACE_ARRIVAL : &GUID_DEVICE_INTERFACE_REMOVAL;
1317 IopNotifyPlugPlayNotification(
1318 PhysicalDeviceObject,
1319 EventCategoryDeviceInterfaceChange,
1320 EventGuid,
1321 &DeviceGuid,
1322 (PVOID)SymbolicLinkName);
1323
1324 ObDereferenceObject(FileObject);
1325 DPRINT("Status %x\n", Status);
1326 return STATUS_SUCCESS;
1327 }
1328
1329 /* EOF */