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