dll/win32/setupapi/interface.c

   1 /*
   2  * SetupAPI interface-related functions
   3  *
   4  * Copyright 2000 Andreas Mohr for CodeWeavers
   5  *           2005-2006 Herv� Poussineau (hpoussin@reactos.org)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "setupapi_private.h"
  23
  24 /* Unicode constants */
  25 static const WCHAR AddInterface[]  = {'A','d','d','I','n','t','e','r','f','a','c','e',0};
  26 static const WCHAR ClassGUID[]  = {'C','l','a','s','s','G','U','I','D',0};
  27 static const WCHAR Control[]  = {'C','o','n','t','r','o','l',0};
  28 static const WCHAR DeviceInstance[]  = {'D','e','v','i','c','e','I','n','s','t','a','n','c','e',0};
  29 static const WCHAR DotInterfaces[]  = {'.','I','n','t','e','r','f','a','c','e','s',0};
  30 static const WCHAR Linked[]  = {'L','i','n','k','e','d',0};
  31 static const WCHAR SymbolicLink[]  = {'S','y','m','b','o','l','i','c','L','i','n','k',0};
  32
  33 static BOOL
  34 CreateDeviceInterface(
  35     IN struct DeviceInfo* deviceInfo,
  36     IN LPCWSTR SymbolicLink,
  37     IN LPCGUID pInterfaceGuid,
  38     OUT struct DeviceInterface **pDeviceInterface)
  39 {
  40     struct DeviceInterface *deviceInterface;
  41
  42     *pDeviceInterface = NULL;
  43
  44     deviceInterface = HeapAlloc(GetProcessHeap(), 0,
  45         FIELD_OFFSET(struct DeviceInterface, SymbolicLink) + (strlenW(SymbolicLink) + 1) * sizeof(WCHAR));
  46     if (!deviceInterface)
  47     {
  48         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  49         return FALSE;
  50     }
  51     deviceInterface->DeviceInfo = deviceInfo;
  52     strcpyW(deviceInterface->SymbolicLink, SymbolicLink);
  53     deviceInterface->Flags = 0; /* Flags will be updated later */
  54     memcpy(&deviceInterface->InterfaceClassGuid, pInterfaceGuid, sizeof(GUID));
  55
  56     *pDeviceInterface = deviceInterface;
  57     return TRUE;
  58 }
  59
  60 BOOL
  61 DestroyDeviceInterface(
  62     struct DeviceInterface* deviceInterface)
  63 {
  64     return HeapFree(GetProcessHeap(), 0, deviceInterface);
  65 }
  66
  67 LONG
  68 SETUP_CreateInterfaceList(
  69     struct DeviceInfoSet *list,
  70     PCWSTR MachineName,
  71     CONST GUID *InterfaceGuid,
  72     PCWSTR DeviceInstanceW /* OPTIONAL */,
  73     BOOL OnlyPresentInterfaces)
  74 {
  75     HKEY hInterfaceKey;      /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID} */
  76     HKEY hDeviceInstanceKey; /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath} */
  77     HKEY hReferenceKey;      /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath}\#{ReferenceString} */
  78     HKEY hControlKey;        /* HKLM\SYSTEM\CurrentControlSet\Control\DeviceClasses\{GUID}\##?#{InstancePath}\#{ReferenceString}\Control */
  79     HKEY hEnumKey;           /* HKLM\SYSTEM\CurrentControlSet\Enum */
  80     HKEY hKey;               /* HKLM\SYSTEM\CurrentControlSet\Enum\{Instance\Path} */
  81     LONG rc;
  82     WCHAR KeyBuffer[max(MAX_PATH, MAX_GUID_STRING_LEN) + 1];
  83     PWSTR pSymbolicLink = NULL;
  84     PWSTR InstancePath = NULL;
  85     DWORD i, j;
  86     DWORD dwLength, dwInstancePathLength;
  87     DWORD dwRegType;
  88     DWORD LinkedValue;
  89     GUID ClassGuid;
  90     struct DeviceInfo *deviceInfo;
  91
  92     hInterfaceKey = INVALID_HANDLE_VALUE;
  93     hDeviceInstanceKey = NULL;
  94     hReferenceKey = NULL;
  95
  96     /* Open registry key related to this interface */
  97     hInterfaceKey = SetupDiOpenClassRegKeyExW(InterfaceGuid, KEY_ENUMERATE_SUB_KEYS, DIOCR_INTERFACE, MachineName, NULL);
  98     if (hInterfaceKey == INVALID_HANDLE_VALUE)
  99     {
 100         /* Key doesn't exist. Let's keep it empty */
 101         rc = ERROR_SUCCESS;
 102         goto cleanup;
 103     }
 104
 105     /* Enumerate sub keys of hInterfaceKey */
 106     i = 0;
 107     while (TRUE)
 108     {
 109         dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
 110         rc = RegEnumKeyExW(hInterfaceKey, i, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
 111         if (rc == ERROR_NO_MORE_ITEMS)
 112             break;
 113         if (rc != ERROR_SUCCESS)
 114             goto cleanup;
 115         i++;
 116
 117         /* Open sub key */
 118         if (hDeviceInstanceKey != NULL)
 119             RegCloseKey(hDeviceInstanceKey);
 120         rc = RegOpenKeyExW(hInterfaceKey, KeyBuffer, 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &hDeviceInstanceKey);
 121         if (rc != ERROR_SUCCESS)
 122             goto cleanup;
 123
 124         /* Read DeviceInstance */
 125         rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL, &dwRegType, NULL, &dwInstancePathLength);
 126         if (rc != ERROR_SUCCESS)
 127             goto cleanup;
 128         if (dwRegType != REG_SZ)
 129         {
 130             rc = ERROR_GEN_FAILURE;
 131             goto cleanup;
 132         }
 133         HeapFree(GetProcessHeap(), 0, InstancePath);
 134         InstancePath = HeapAlloc(GetProcessHeap(), 0, dwInstancePathLength + sizeof(WCHAR));
 135         if (!InstancePath)
 136         {
 137             rc = ERROR_NOT_ENOUGH_MEMORY;
 138             goto cleanup;
 139         }
 140         rc = RegQueryValueExW(hDeviceInstanceKey, DeviceInstance, NULL, NULL, (LPBYTE)InstancePath, &dwInstancePathLength);
 141         if (rc != ERROR_SUCCESS)
 142             goto cleanup;
 143         InstancePath[dwInstancePathLength / sizeof(WCHAR)] = '\0';
 144         TRACE("DeviceInstance %s\n", debugstr_w(InstancePath));
 145
 146         if (DeviceInstanceW)
 147         {
 148             /* Check if device enumerator is not the right one */
 149             if (strcmpW(DeviceInstanceW, InstancePath) != 0)
 150                 continue;
 151         }
 152
 153         /* Find class GUID associated to the device instance */
 154         rc = RegOpenKeyExW(
 155             list->HKLM,
 156             REGSTR_PATH_SYSTEMENUM,
 157             0, /* Options */
 158             READ_CONTROL,
 159             &hEnumKey);
 160         if (rc != ERROR_SUCCESS)
 161             goto cleanup;
 162         rc = RegOpenKeyExW(
 163             hEnumKey,
 164             InstancePath,
 165             0, /* Options */
 166             KEY_QUERY_VALUE,
 167             &hKey);
 168         RegCloseKey(hEnumKey);
 169         if (rc != ERROR_SUCCESS)
 170             goto cleanup;
 171         dwLength = sizeof(KeyBuffer) - sizeof(WCHAR);
 172         rc = RegQueryValueExW(hKey, ClassGUID, NULL, NULL, (LPBYTE)KeyBuffer, &dwLength);
 173         RegCloseKey(hKey);
 174         if (rc != ERROR_SUCCESS)
 175             goto cleanup;
 176         KeyBuffer[dwLength / sizeof(WCHAR)] = '\0';
 177         KeyBuffer[37] = '\0'; /* Replace the } by a NULL character */
 178         if (UuidFromStringW(&KeyBuffer[1], &ClassGuid) != RPC_S_OK)
 179         {
 180             rc = ERROR_GEN_FAILURE;
 181             goto cleanup;
 182         }
 183         TRACE("ClassGUID %s\n", debugstr_guid(&ClassGuid));
 184
 185         /* If current device doesn't match the list GUID (if any), skip this entry */
 186         if (!IsEqualIID(&list->ClassGuid, &GUID_NULL) && !IsEqualIID(&list->ClassGuid, &ClassGuid))
 187             continue;
 188
 189         /* Enumerate subkeys of hDeviceInstanceKey (ie "#ReferenceString" in IoRegisterDeviceInterface). Skip entries that don't start with '#' */
 190         j = 0;
 191         while (TRUE)
 192         {
 193             struct DeviceInterface *interfaceInfo;
 194
 195             dwLength = sizeof(KeyBuffer) / sizeof(KeyBuffer[0]);
 196             rc = RegEnumKeyExW(hDeviceInstanceKey, j, KeyBuffer, &dwLength, NULL, NULL, NULL, NULL);
 197             if (rc == ERROR_NO_MORE_ITEMS)
 198                 break;
 199             if (rc != ERROR_SUCCESS)
 200                 goto cleanup;
 201             j++;
 202             if (KeyBuffer[0] != '#')
 203                 /* This entry doesn't represent an interesting entry */
 204                 continue;
 205
 206             /* Open sub key */
 207             if (hReferenceKey != NULL)
 208                 RegCloseKey(hReferenceKey);
 209             rc = RegOpenKeyExW(hDeviceInstanceKey, KeyBuffer, 0, KEY_QUERY_VALUE, &hReferenceKey);
 210             if (rc != ERROR_SUCCESS)
 211                 goto cleanup;
 212
 213             /* Read SymbolicLink value */
 214             rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL, &dwRegType, NULL, &dwLength);
 215             if (rc != ERROR_SUCCESS )
 216                 goto cleanup;
 217             if (dwRegType != REG_SZ)
 218             {
 219                 rc = ERROR_GEN_FAILURE;
 220                 goto cleanup;
 221             }
 222
 223             /* We have found a device */
 224             /* Step 1. Create a device info element */
 225             if (!CreateDeviceInfo(list, InstancePath, &ClassGuid, &deviceInfo))
 226             {
 227                 rc = GetLastError();
 228                 goto cleanup;
 229             }
 230             TRACE("Adding device %s to list\n", debugstr_w(InstancePath));
 231             InsertTailList(&list->ListHead, &deviceInfo->ListEntry);
 232
 233             /* Step 2. Create an interface list for this element */
 234             HeapFree(GetProcessHeap(), 0, pSymbolicLink);
 235             pSymbolicLink = HeapAlloc(GetProcessHeap(), 0, dwLength + sizeof(WCHAR));
 236             if (!pSymbolicLink)
 237             {
 238                 rc = ERROR_NOT_ENOUGH_MEMORY;
 239                 goto cleanup;
 240             }
 241             rc = RegQueryValueExW(hReferenceKey, SymbolicLink, NULL, NULL, (LPBYTE)pSymbolicLink, &dwLength);
 242             pSymbolicLink[dwLength / sizeof(WCHAR)] = '\0';
 243             if (rc != ERROR_SUCCESS)
 244                 goto cleanup;
 245             if (!CreateDeviceInterface(deviceInfo, pSymbolicLink, InterfaceGuid, &interfaceInfo))
 246             {
 247                 rc = GetLastError();
 248                 goto cleanup;
 249             }
 250
 251             /* Step 3. Update flags */
 252             if (KeyBuffer[1] == '\0')
 253                 interfaceInfo->Flags |= SPINT_DEFAULT;
 254             rc = RegOpenKeyExW(hReferenceKey, Control, 0, KEY_QUERY_VALUE, &hControlKey);
 255             if (rc != ERROR_SUCCESS)
 256             {
 257 #if 0
 258                 if (OnlyPresentInterfaces)
 259                 {
 260                     DestroyDeviceInterface(interfaceInfo);
 261                     continue;
 262                 }
 263                 else
 264                     interfaceInfo->Flags |= SPINT_REMOVED;
 265 #endif
 266             }
 267             else
 268             {
 269                 dwLength = sizeof(DWORD);
 270                 if (RegQueryValueExW(hControlKey, Linked, NULL, &dwRegType, (LPBYTE)&LinkedValue, &dwLength) == ERROR_SUCCESS
 271                     && dwRegType == REG_DWORD && LinkedValue)
 272                     interfaceInfo->Flags |= SPINT_ACTIVE;
 273                 RegCloseKey(hControlKey);
 274             }
 275
 276             TRACE("Adding interface %s to list\n", debugstr_w(pSymbolicLink));
 277             InsertTailList(&deviceInfo->InterfaceListHead, &interfaceInfo->ListEntry);
 278         }
 279     }
 280     rc = ERROR_SUCCESS;
 281
 282 cleanup:
 283     if (hReferenceKey != NULL)
 284         RegCloseKey(hReferenceKey);
 285     if (hDeviceInstanceKey != NULL)
 286         RegCloseKey(hDeviceInstanceKey);
 287     if (hInterfaceKey != INVALID_HANDLE_VALUE)
 288         RegCloseKey(hInterfaceKey);
 289     HeapFree(GetProcessHeap(), 0, InstancePath);
 290     HeapFree(GetProcessHeap(), 0, pSymbolicLink);
 291     return rc;
 292 }
 293
 294 static LPWSTR
 295 CreateSymbolicLink(
 296     IN LPGUID InterfaceGuid,
 297     IN LPCWSTR ReferenceString,
 298     IN struct DeviceInfo *devInfo)
 299 {
 300     DWORD Length, Index, Offset;
 301     LPWSTR Key;
 302
 303     Length = wcslen(devInfo->instanceId) + 4 /* prepend ##?# */ + 41 /* #{GUID} + */ + 1 /* zero byte */;
 304
 305     Key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Length * sizeof(WCHAR));
 306     if (!Key)
 307         return NULL;
 308
 309     wcscpy(Key, L"##?#");
 310     wcscat(Key, devInfo->instanceId);
 311
 312     for(Index = 4; Index < Length; Index++)
 313     {
 314         if (Key[Index] == L'\\')
 315         {
 316             Key[Index] = L'#';
 317         }
 318     }
 319
 320     wcscat(Key, L"#");
 321
 322     Offset = wcslen(Key);
 323     pSetupStringFromGuid(InterfaceGuid, Key + Offset, Length - Offset);
 324
 325     return Key;
 326 }
 327
 328
 329 static BOOL
 330 InstallOneInterface(
 331     IN LPGUID InterfaceGuid,
 332     IN LPCWSTR ReferenceString,
 333     IN LPCWSTR InterfaceSection,
 334     IN UINT InterfaceFlags,
 335     IN HINF hInf,
 336     IN HDEVINFO DeviceInfoSet,
 337     IN struct DeviceInfo *devInfo)
 338 {
 339     HKEY hKey, hRefKey;
 340     LPWSTR Path;
 341     SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
 342     struct DeviceInterface *DevItf = NULL;
 343
 344     if (InterfaceFlags != 0)
 345     {
 346         SetLastError(ERROR_INVALID_PARAMETER);
 347         return FALSE;
 348     }
 349
 350     TRACE("Need to InstallOneInterface(%s %s %s %u) hInf %p DeviceInfoSet %p devInfo %p instanceId %s\n", debugstr_guid(InterfaceGuid),
 351         debugstr_w(ReferenceString), debugstr_w(InterfaceSection), InterfaceFlags, hInf, DeviceInfoSet, devInfo, debugstr_w(devInfo->instanceId));
 352
 353
 354     Path = CreateSymbolicLink(InterfaceGuid, ReferenceString, devInfo);
 355     if (!Path)
 356         return FALSE;
 357
 358     CreateDeviceInterface(devInfo, Path, InterfaceGuid, &DevItf);
 359     HeapFree(GetProcessHeap(), 0, Path);
 360     if (!DevItf)
 361     {
 362         return FALSE;
 363     }
 364
 365     memcpy(&DeviceInterfaceData.InterfaceClassGuid, &DevItf->InterfaceClassGuid, sizeof(GUID));
 366     DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 367     DeviceInterfaceData.Flags = DevItf->Flags;
 368     DeviceInterfaceData.Reserved = (ULONG_PTR)DevItf;
 369
 370     hKey = SetupDiCreateDeviceInterfaceRegKeyW(DeviceInfoSet, &DeviceInterfaceData, 0, KEY_ALL_ACCESS, NULL, 0);
 371     HeapFree(GetProcessHeap(), 0, DevItf);
 372     if (hKey == INVALID_HANDLE_VALUE)
 373     {
 374         return FALSE;
 375     }
 376
 377     if (ReferenceString)
 378     {
 379         Path = HeapAlloc(GetProcessHeap(), 0, (wcslen(ReferenceString) + 2) * sizeof(WCHAR));
 380         if (!Path)
 381         {
 382             RegCloseKey(hKey);
 383             return FALSE;
 384         }
 385
 386         wcscpy(Path, L"#");
 387         wcscat(Path, ReferenceString);
 388
 389         if (RegCreateKeyExW(hKey, Path, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hRefKey, NULL) != ERROR_SUCCESS)
 390         {
 391             ERR("failed to create key %s %lx\n", debugstr_w(Path), GetLastError());
 392             HeapFree(GetProcessHeap(), 0, Path);
 393             return FALSE;
 394         }
 395
 396         RegCloseKey(hKey);
 397         hKey = hRefKey;
 398         HeapFree(GetProcessHeap(), 0, Path);
 399     }
 400
 401     if (RegCreateKeyExW(hKey, L"Device Parameters", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hRefKey, NULL) != ERROR_SUCCESS)
 402     {
 403         RegCloseKey(hKey);
 404         return FALSE;
 405     }
 406
 407     return SetupInstallFromInfSectionW(NULL, /* FIXME */ hInf, InterfaceSection, SPINST_REGISTRY, hRefKey, NULL, 0, NULL, NULL, NULL, NULL);
 408 }
 409
 410 /***********************************************************************
 411  *              SetupDiInstallDeviceInterfaces (SETUPAPI.@)
 412  */
 413 BOOL WINAPI
 414 SetupDiInstallDeviceInterfaces(
 415     IN HDEVINFO DeviceInfoSet,
 416     IN PSP_DEVINFO_DATA DeviceInfoData)
 417 {
 418     struct DeviceInfoSet *list = NULL;
 419     BOOL ret = FALSE;
 420
 421     TRACE("%p %p\n", DeviceInfoSet, DeviceInfoData);
 422
 423     if (!DeviceInfoSet)
 424         SetLastError(ERROR_INVALID_PARAMETER);
 425     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
 426         SetLastError(ERROR_INVALID_HANDLE);
 427     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
 428         SetLastError(ERROR_INVALID_HANDLE);
 429     else if (!DeviceInfoData)
 430         SetLastError(ERROR_INVALID_PARAMETER);
 431     else if (DeviceInfoData && DeviceInfoData->Reserved == 0)
 432         SetLastError(ERROR_INVALID_USER_BUFFER);
 433     else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
 434         SetLastError(ERROR_INVALID_USER_BUFFER);
 435     else
 436     {
 437         struct DeviceInfo *devInfo;
 438         struct DriverInfoElement *SelectedDriver = NULL;
 439         SP_DEVINSTALL_PARAMS_W InstallParams;
 440         WCHAR SectionName[MAX_PATH];
 441         DWORD SectionNameLength = 0;
 442         INFCONTEXT ContextInterface;
 443         LPWSTR InterfaceGuidString = NULL;
 444         LPWSTR ReferenceString = NULL;
 445         LPWSTR InterfaceSection = NULL;
 446         INT InterfaceFlags;
 447         GUID InterfaceGuid;
 448         BOOL Result;
 449
 450         devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 451
 452         InstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS_W);
 453         Result = SetupDiGetDeviceInstallParamsW(DeviceInfoSet, DeviceInfoData, &InstallParams);
 454         if (!Result)
 455             goto cleanup;
 456
 457         SelectedDriver = (struct DriverInfoElement *)InstallParams.Reserved;
 458         if (SelectedDriver == NULL)
 459         {
 460             SetLastError(ERROR_NO_DRIVER_SELECTED);
 461             ret = FALSE;
 462             goto cleanup;
 463         }
 464
 465         /* Get .Interfaces section name */
 466         Result = SetupDiGetActualSectionToInstallW(
 467             SelectedDriver->InfFileDetails->hInf,
 468             SelectedDriver->Details.SectionName,
 469             SectionName, MAX_PATH, &SectionNameLength, NULL);
 470         if (!Result || SectionNameLength > MAX_PATH - strlenW(DotInterfaces) - 1)
 471             goto cleanup;
 472         strcatW(SectionName, DotInterfaces);
 473
 474         ret = TRUE;
 475         Result = SetupFindFirstLineW(
 476             SelectedDriver->InfFileDetails->hInf,
 477             SectionName,
 478             AddInterface,
 479             &ContextInterface);
 480         while (ret && Result)
 481         {
 482             ret = GetStringField(&ContextInterface, 1, &InterfaceGuidString);
 483             if (!ret)
 484                 goto cleanup;
 485             else if (strlenW(InterfaceGuidString) != MAX_GUID_STRING_LEN - 1)
 486             {
 487                 SetLastError(ERROR_INVALID_PARAMETER);
 488                 ret = FALSE;
 489                 goto cleanup;
 490             }
 491
 492             InterfaceGuidString[MAX_GUID_STRING_LEN - 2] = '\0'; /* Replace the } by a NULL character */
 493             if (UuidFromStringW(&InterfaceGuidString[1], &InterfaceGuid) != RPC_S_OK)
 494             {
 495                 /* Bad GUID, skip the entry */
 496                 SetLastError(ERROR_INVALID_PARAMETER);
 497                 ret = FALSE;
 498                 goto cleanup;
 499             }
 500
 501             ret = GetStringField(&ContextInterface, 2, &ReferenceString);
 502             if (!ret)
 503                 goto cleanup;
 504
 505             ret = GetStringField(&ContextInterface, 3, &InterfaceSection);
 506             if (!ret)
 507             {
 508                 /* ReferenceString is optional */
 509                 InterfaceSection = ReferenceString;
 510                 ReferenceString = NULL;
 511             }
 512
 513             ret = SetupGetIntField(
 514                 &ContextInterface,
 515                 (ReferenceString ? 4 : 3), /* Field index */
 516                 &InterfaceFlags);
 517             if (!ret)
 518             {
 519                 if (GetLastError() == ERROR_INVALID_PARAMETER)
 520                 {
 521                     /* The field may be empty. Ignore the error */
 522                     InterfaceFlags = 0;
 523                     ret = TRUE;
 524                 }
 525                 else
 526                     goto cleanup;
 527             }
 528
 529             /* Install Interface */
 530             ret = InstallOneInterface(&InterfaceGuid, ReferenceString, InterfaceSection, InterfaceFlags, SelectedDriver->InfFileDetails->hInf, DeviceInfoSet, devInfo);
 531
 532 cleanup:
 533             MyFree(InterfaceGuidString);
 534             if (ReferenceString)
 535                 MyFree(ReferenceString);
 536             MyFree(InterfaceSection);
 537             InterfaceGuidString = ReferenceString = InterfaceSection = NULL;
 538             Result = SetupFindNextMatchLineW(&ContextInterface, AddInterface, &ContextInterface);
 539         }
 540     }
 541
 542     TRACE("Returning %d\n", ret);
 543     return ret;
 544 }
 545
 546 HKEY WINAPI
 547 SetupDiOpenDeviceInterfaceRegKey(
 548     IN HDEVINFO  DeviceInfoSet, IN PSP_DEVICE_INTERFACE_DATA  DeviceInterfaceData, IN DWORD  Reserved, IN REGSAM  samDesired)
 549 {
 550     HKEY hKey = INVALID_HANDLE_VALUE, hDevKey;
 551     struct DeviceInfoSet * list;
 552
 553     TRACE("%p %p %p 0x%08x 0x%08x)\n", DeviceInfoSet, DeviceInterfaceData, Reserved, samDesired);
 554
 555     if (!DeviceInfoSet)
 556         SetLastError(ERROR_INVALID_PARAMETER);
 557     else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
 558         SetLastError(ERROR_INVALID_HANDLE);
 559     else if ((list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
 560         SetLastError(ERROR_INVALID_HANDLE);
 561     else if (!DeviceInterfaceData)
 562         SetLastError(ERROR_INVALID_PARAMETER);
 563     else if (DeviceInterfaceData && DeviceInterfaceData->Reserved == 0)
 564         SetLastError(ERROR_INVALID_USER_BUFFER);
 565     else if (DeviceInterfaceData && DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
 566         SetLastError(ERROR_INVALID_USER_BUFFER);
 567     else
 568     {
 569         struct DeviceInterface *DevItf;
 570         LPWSTR Path, Guid, Slash;
 571         DWORD Length;
 572         DevItf = (struct DeviceInterface *)DeviceInterfaceData->Reserved;
 573
 574         Length = wcslen(DevItf->SymbolicLink);
 575
 576         Path = HeapAlloc(GetProcessHeap(), 0, (Length+2) * sizeof(WCHAR));
 577         if (!Path)
 578         {
 579             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 580             return INVALID_HANDLE_VALUE;
 581         }
 582
 583         wcscpy(Path, DevItf->SymbolicLink);
 584
 585         Guid = wcsrchr(Path, '}');
 586         Slash = wcsrchr(Path, '\\');
 587         if (!Guid || !Slash)
 588         {
 589             HeapFree(GetProcessHeap(), 0, Path);
 590             SetLastError(ERROR_INVALID_PARAMETER);
 591             return INVALID_HANDLE_VALUE;
 592         }
 593
 594         if ((ULONG_PTR)Slash > (ULONG_PTR)Guid)
 595         {
 596             /* Create an extra slash */
 597             memmove(Slash+1, Slash, (wcslen(Slash) + 1) * sizeof(WCHAR));
 598             Slash[1] = L'#';
 599         }
 600
 601         Guid = Path;
 602         while((ULONG_PTR)Guid < (ULONG_PTR)Slash)
 603         {
 604             if (*Guid == L'\\')
 605                 *Guid = L'#';
 606
 607             Guid++;
 608         }
 609
 610         hKey = SetupDiOpenClassRegKeyExW(&DeviceInterfaceData->InterfaceClassGuid, samDesired, DIOCR_INTERFACE, NULL, NULL);
 611         if (hKey != INVALID_HANDLE_VALUE)
 612         {
 613             if (RegOpenKeyExW(hKey, Path, 0, samDesired, &hDevKey) == ERROR_SUCCESS)
 614             {
 615                 RegCloseKey(hKey);
 616                 hKey = hDevKey;
 617             }
 618             else
 619             {
 620                 RegCloseKey(hKey);
 621                 hKey = INVALID_HANDLE_VALUE;
 622             }
 623         }
 624
 625         HeapFree(GetProcessHeap(), 0, Path);
 626     }
 627
 628     return hKey;
 629 }