ntoskrnl/io/iomgr/deviface.c

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