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