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 */