dlls/setupapi/devinst.c

   1 /*
   2  * SetupAPI device installer
   3  *
   4  * Copyright 2000 Andreas Mohr for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnt.h"
  29 #include "winreg.h"
  30 #include "winternl.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winnls.h"
  34 #include "setupapi.h"
  35 #include "wine/debug.h"
  36 #include "wine/list.h"
  37 #include "wine/unicode.h"
  38 #include "cfgmgr32.h"
  39 #include "winioctl.h"
  40 #include "rpc.h"
  41 #include "rpcdce.h"
  42
  43 #include "setupapi_private.h"
  44
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  47
  48 /* Unicode constants */
  49 static const WCHAR Chicago[]  = {'$','C','h','i','c','a','g','o','$',0};
  50 static const WCHAR ClassGUID[]  = {'C','l','a','s','s','G','U','I','D',0};
  51 static const WCHAR Class[]  = {'C','l','a','s','s',0};
  52 static const WCHAR ClassInstall32[]  = {'C','l','a','s','s','I','n','s','t','a','l','l','3','2',0};
  53 static const WCHAR NoDisplayClass[]  = {'N','o','D','i','s','p','l','a','y','C','l','a','s','s',0};
  54 static const WCHAR NoInstallClass[]  = {'N','o','I','n','s','t','a','l','l','C','l','a','s','s',0};
  55 static const WCHAR NoUseClass[]  = {'N','o','U','s','e','C','l','a','s','s',0};
  56 static const WCHAR NtExtension[]  = {'.','N','T',0};
  57 static const WCHAR NtPlatformExtension[]  = {'.','N','T','x','8','6',0};
  58 static const WCHAR Signature[]  = {'S','i','g','n','a','t','u','r','e',0};
  59 static const WCHAR Version[]  = {'V','e','r','s','i','o','n',0};
  60 static const WCHAR WinExtension[]  = {'.','W','i','n',0};
  61
  62 /* Registry key and value names */
  63 static const WCHAR ControlClass[] = {'S','y','s','t','e','m','\\',
  64                                   'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  65                                   'C','o','n','t','r','o','l','\\',
  66                                   'C','l','a','s','s',0};
  67
  68 static const WCHAR DeviceClasses[] = {'S','y','s','t','e','m','\\',
  69                                   'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  70                                   'C','o','n','t','r','o','l','\\',
  71                                   'D','e','v','i','c','e','C','l','a','s','s','e','s',0};
  72 static const WCHAR Enum[] = {'S','y','s','t','e','m','\\',
  73                                   'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  74                                   'E','n','u','m',0};
  75 static const WCHAR DeviceDesc[] = {'D','e','v','i','c','e','D','e','s','c',0};
  76 static const WCHAR DeviceInstance[] = {'D','e','v','i','c','e','I','n','s','t','a','n','c','e',0};
  77 static const WCHAR HardwareId[] = {'H','a','r','d','w','a','r','e','I','D',0};
  78 static const WCHAR CompatibleIDs[] = {'C','o','m','p','a','t','i','b','l','e','I','d','s',0};
  79 static const WCHAR Service[] = {'S','e','r','v','i','c','e',0};
  80 static const WCHAR Driver[] = {'D','r','i','v','e','r',0};
  81 static const WCHAR ConfigFlags[] = {'C','o','n','f','i','g','F','l','a','g','s',0};
  82 static const WCHAR Mfg[] = {'M','f','g',0};
  83 static const WCHAR FriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
  84 static const WCHAR LocationInformation[] = {'L','o','c','a','t','i','o','n','I','n','f','o','r','m','a','t','i','o','n',0};
  85 static const WCHAR Capabilities[] = {'C','a','p','a','b','i','l','i','t','i','e','s',0};
  86 static const WCHAR UINumber[] = {'U','I','N','u','m','b','e','r',0};
  87 static const WCHAR UpperFilters[] = {'U','p','p','e','r','F','i','l','t','e','r','s',0};
  88 static const WCHAR LowerFilters[] = {'L','o','w','e','r','F','i','l','t','e','r','s',0};
  89 static const WCHAR Phantom[] = {'P','h','a','n','t','o','m',0};
  90 static const WCHAR SymbolicLink[] = {'S','y','m','b','o','l','i','c','L','i','n','k',0};
  91
  92 /* is used to identify if a DeviceInfoSet pointer is
  93 valid or not */
  94 #define SETUP_DEVICE_INFO_SET_MAGIC 0xd00ff056
  95
  96 struct DeviceInfoSet
  97 {
  98     DWORD magic;        /* if is equal to SETUP_DEVICE_INFO_SET_MAGIC struct is okay */
  99     GUID ClassGuid;
 100     HWND hwndParent;
 101     DWORD cDevices;
 102     struct list devices;
 103 };
 104
 105 struct DeviceInstance
 106 {
 107     struct list entry;
 108     SP_DEVINFO_DATA data;
 109 };
 110
 111 /* Pointed to by SP_DEVICE_INTERFACE_DATA's Reserved member */
 112 struct InterfaceInfo
 113 {
 114     LPWSTR           referenceString;
 115     LPWSTR           symbolicLink;
 116     PSP_DEVINFO_DATA device;
 117 };
 118
 119 /* A device may have multiple instances of the same interface, so this holds
 120  * each instance belonging to a particular interface.
 121  */
 122 struct InterfaceInstances
 123 {
 124     GUID                      guid;
 125     DWORD                     cInstances;
 126     DWORD                     cInstancesAllocated;
 127     SP_DEVICE_INTERFACE_DATA *instances;
 128     struct list               entry;
 129 };
 130
 131 /* Pointed to by SP_DEVINFO_DATA's Reserved member */
 132 struct DeviceInfo
 133 {
 134     struct DeviceInfoSet *set;
 135     HKEY                  key;
 136     BOOL                  phantom;
 137     DWORD                 devId;
 138     LPWSTR                instanceId;
 139     struct list           interfaces;
 140 };
 141
 142 static void SETUPDI_GuidToString(const GUID *guid, LPWSTR guidStr)
 143 {
 144     static const WCHAR fmt[] = {'{','%','0','8','X','-','%','0','4','X','-',
 145         '%','0','4','X','-','%','0','2','X','%','0','2','X','-','%','0','2',
 146         'X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%',
 147         '0','2','X','}',0};
 148
 149     sprintfW(guidStr, fmt, guid->Data1, guid->Data2, guid->Data3,
 150         guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 151         guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 152 }
 153
 154 static void SETUPDI_FreeInterfaceInstances(struct InterfaceInstances *instances)
 155 {
 156     DWORD i;
 157
 158     for (i = 0; i < instances->cInstances; i++)
 159     {
 160         struct InterfaceInfo *ifaceInfo =
 161             (struct InterfaceInfo *)instances->instances[i].Reserved;
 162
 163         if (ifaceInfo->device && ifaceInfo->device->Reserved)
 164         {
 165             struct DeviceInfo *devInfo =
 166                 (struct DeviceInfo *)ifaceInfo->device->Reserved;
 167
 168             if (devInfo->phantom)
 169                 SetupDiDeleteDeviceInterfaceRegKey(devInfo->set,
 170                         &instances->instances[i], 0);
 171         }
 172         HeapFree(GetProcessHeap(), 0, ifaceInfo->referenceString);
 173         HeapFree(GetProcessHeap(), 0, ifaceInfo->symbolicLink);
 174         HeapFree(GetProcessHeap(), 0, ifaceInfo);
 175     }
 176     HeapFree(GetProcessHeap(), 0, instances->instances);
 177 }
 178
 179 /* Finds the interface with interface class InterfaceClassGuid in the device.
 180  * Returns TRUE if found, and updates *interface to point to device's
 181  * interfaces member where the given interface was found.
 182  * Returns FALSE if not found.
 183  */
 184 static BOOL SETUPDI_FindInterface(const struct DeviceInfo *devInfo,
 185         const GUID *InterfaceClassGuid, struct InterfaceInstances **iface_ret)
 186 {
 187     BOOL found = FALSE;
 188     struct InterfaceInstances *iface;
 189
 190     TRACE("%s\n", debugstr_guid(InterfaceClassGuid));
 191
 192     LIST_FOR_EACH_ENTRY(iface, &devInfo->interfaces, struct InterfaceInstances,
 193             entry)
 194     {
 195         if (IsEqualGUID(&iface->guid, InterfaceClassGuid))
 196         {
 197             *iface_ret = iface;
 198             found = TRUE;
 199             break;
 200         }
 201     }
 202     TRACE("returning %d (%p)\n", found, found ? *iface_ret : NULL);
 203     return found;
 204 }
 205
 206 /* Finds the interface instance with reference string ReferenceString in the
 207  * interface instance map.  Returns TRUE if found, and updates instanceIndex to
 208  * the index of the interface instance's instances member
 209  * where the given instance was found.  Returns FALSE if not found.
 210  */
 211 static BOOL SETUPDI_FindInterfaceInstance(
 212         const struct InterfaceInstances *instances,
 213         LPCWSTR ReferenceString, DWORD *instanceIndex)
 214 {
 215     BOOL found = FALSE;
 216     DWORD i;
 217
 218     TRACE("%s\n", debugstr_w(ReferenceString));
 219
 220     for (i = 0; !found && i < instances->cInstances; i++)
 221     {
 222         SP_DEVICE_INTERFACE_DATA *ifaceData = &instances->instances[i];
 223         struct InterfaceInfo *ifaceInfo =
 224             (struct InterfaceInfo *)ifaceData->Reserved;
 225
 226         if (!ReferenceString && !ifaceInfo->referenceString)
 227         {
 228             *instanceIndex = i;
 229             found = TRUE;
 230         }
 231         else if (ReferenceString && ifaceInfo->referenceString &&
 232                 !lstrcmpiW(ifaceInfo->referenceString, ReferenceString))
 233         {
 234             *instanceIndex = i;
 235             found = TRUE;
 236         }
 237     }
 238     TRACE("returning %d (%d)\n", found, found ? *instanceIndex : 0);
 239     return found;
 240 }
 241
 242 static LPWSTR SETUPDI_CreateSymbolicLinkPath(LPCWSTR instanceId,
 243         const GUID *InterfaceClassGuid, LPCWSTR ReferenceString)
 244 {
 245     static const WCHAR fmt[] = {'\\','\\','?','\\','%','s','#','%','s',0};
 246     WCHAR guidStr[39];
 247     DWORD len;
 248     LPWSTR ret;
 249
 250     SETUPDI_GuidToString(InterfaceClassGuid, guidStr);
 251     /* omit length of format specifiers, but include NULL terminator: */
 252     len = lstrlenW(fmt) - 4 + 1;
 253     len += lstrlenW(instanceId) + lstrlenW(guidStr);
 254     if (ReferenceString && *ReferenceString)
 255     {
 256         /* space for a hash between string and reference string: */
 257         len += lstrlenW(ReferenceString) + 1;
 258     }
 259     ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 260     if (ret)
 261     {
 262         int printed = sprintfW(ret, fmt, instanceId, guidStr);
 263         LPWSTR ptr;
 264
 265         /* replace '\\' with '#' after the "\\\\?\\" beginning */
 266         for (ptr = strchrW(ret + 4, '\\'); ptr; ptr = strchrW(ptr + 1, '\\'))
 267             *ptr = '#';
 268         if (ReferenceString && *ReferenceString)
 269         {
 270             ret[printed] = '\\';
 271             lstrcpyW(ret + printed + 1, ReferenceString);
 272         }
 273     }
 274     return ret;
 275 }
 276
 277 /* Adds an interface with the given interface class and reference string to
 278  * the device, if it doesn't already exist in the device.  If iface is not
 279  * NULL, returns a pointer to the newly added (or already existing) interface.
 280  */
 281 static BOOL SETUPDI_AddInterfaceInstance(PSP_DEVINFO_DATA DeviceInfoData,
 282         const GUID *InterfaceClassGuid, LPCWSTR ReferenceString,
 283         SP_DEVICE_INTERFACE_DATA **ifaceData)
 284 {
 285     struct DeviceInfo *devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
 286     BOOL newInterface = FALSE, ret;
 287     struct InterfaceInstances *iface = NULL;
 288
 289     TRACE("%p %s %s %p\n", devInfo, debugstr_guid(InterfaceClassGuid),
 290             debugstr_w(ReferenceString), iface);
 291
 292     if (!(ret = SETUPDI_FindInterface(devInfo, InterfaceClassGuid, &iface)))
 293     {
 294         iface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 295                 sizeof(struct InterfaceInstances));
 296         if (iface)
 297         {
 298             list_add_tail(&devInfo->interfaces, &iface->entry);
 299             newInterface = TRUE;
 300         }
 301     }
 302     if (iface)
 303     {
 304         DWORD instanceIndex = 0;
 305
 306         if (!(ret = SETUPDI_FindInterfaceInstance(iface, ReferenceString,
 307                         &instanceIndex)))
 308         {
 309             SP_DEVICE_INTERFACE_DATA *instance = NULL;
 310
 311             if (!iface->cInstancesAllocated)
 312             {
 313                 iface->instances = HeapAlloc(GetProcessHeap(), 0,
 314                         sizeof(SP_DEVICE_INTERFACE_DATA));
 315                 if (iface->instances)
 316                     instance = &iface->instances[iface->cInstancesAllocated++];
 317             }
 318             else if (iface->cInstances == iface->cInstancesAllocated)
 319             {
 320                 iface->instances = HeapReAlloc(GetProcessHeap(), 0,
 321                         iface->instances,
 322                         (iface->cInstancesAllocated + 1) *
 323                         sizeof(SP_DEVICE_INTERFACE_DATA));
 324                 if (iface->instances)
 325                     instance = &iface->instances[iface->cInstancesAllocated++];
 326             }
 327             else
 328                 instance = &iface->instances[iface->cInstances];
 329             if (instance)
 330             {
 331                 struct InterfaceInfo *ifaceInfo = HeapAlloc(GetProcessHeap(),
 332                         0, sizeof(struct InterfaceInfo));
 333
 334                 if (ifaceInfo)
 335                 {
 336                     ret = TRUE;
 337                     ifaceInfo->device = DeviceInfoData;
 338                     ifaceInfo->symbolicLink = SETUPDI_CreateSymbolicLinkPath(
 339                             devInfo->instanceId, InterfaceClassGuid,
 340                             ReferenceString);
 341                     if (ReferenceString)
 342                     {
 343                         ifaceInfo->referenceString =
 344                             HeapAlloc(GetProcessHeap(), 0,
 345                                 (lstrlenW(ReferenceString) + 1) *
 346                                 sizeof(WCHAR));
 347                         if (ifaceInfo->referenceString)
 348                             lstrcpyW(ifaceInfo->referenceString,
 349                                     ReferenceString);
 350                         else
 351                             ret = FALSE;
 352                     }
 353                     else
 354                         ifaceInfo->referenceString = NULL;
 355                     if (ret)
 356                     {
 357                         HKEY key;
 358
 359                         iface->cInstances++;
 360                         instance->cbSize =
 361                             sizeof(SP_DEVICE_INTERFACE_DATA);
 362                         instance->InterfaceClassGuid = *InterfaceClassGuid;
 363                         instance->Flags = SPINT_ACTIVE; /* FIXME */
 364                         instance->Reserved = (ULONG_PTR)ifaceInfo;
 365                         if (newInterface)
 366                             iface->guid = *InterfaceClassGuid;
 367                         key = SetupDiCreateDeviceInterfaceRegKeyW(devInfo->set,
 368                                 instance, 0, KEY_WRITE, NULL, NULL);
 369                         if (key != INVALID_HANDLE_VALUE)
 370                         {
 371                             RegSetValueExW(key, SymbolicLink, 0, REG_SZ,
 372                                     (BYTE *)ifaceInfo->symbolicLink,
 373                                     lstrlenW(ifaceInfo->symbolicLink) *
 374                                     sizeof(WCHAR));
 375                             RegCloseKey(key);
 376                         }
 377                         if (ifaceData)
 378                             *ifaceData = instance;
 379                     }
 380                     else
 381                         HeapFree(GetProcessHeap(), 0, ifaceInfo);
 382                 }
 383             }
 384         }
 385         else
 386         {
 387             if (ifaceData)
 388                 *ifaceData = &iface->instances[instanceIndex];
 389         }
 390     }
 391     else
 392         ret = FALSE;
 393     TRACE("returning %d\n", ret);
 394     return ret;
 395 }
 396
 397 static BOOL SETUPDI_SetInterfaceSymbolicLink(SP_DEVICE_INTERFACE_DATA *iface,
 398         LPCWSTR symbolicLink)
 399 {
 400     struct InterfaceInfo *info = (struct InterfaceInfo *)iface->Reserved;
 401     BOOL ret = FALSE;
 402
 403     if (info)
 404     {
 405         HeapFree(GetProcessHeap(), 0, info->symbolicLink);
 406         info->symbolicLink = HeapAlloc(GetProcessHeap(), 0,
 407                 (lstrlenW(symbolicLink) + 1) * sizeof(WCHAR));
 408         if (info->symbolicLink)
 409         {
 410             lstrcpyW(info->symbolicLink, symbolicLink);
 411             ret = TRUE;
 412         }
 413     }
 414     return ret;
 415 }
 416
 417 static HKEY SETUPDI_CreateDevKey(struct DeviceInfo *devInfo)
 418 {
 419     HKEY enumKey, key = INVALID_HANDLE_VALUE;
 420     LONG l;
 421
 422     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
 423             NULL, &enumKey, NULL);
 424     if (!l)
 425     {
 426         RegCreateKeyExW(enumKey, devInfo->instanceId, 0, NULL, 0,
 427                 KEY_READ | KEY_WRITE, NULL, &key, NULL);
 428         RegCloseKey(enumKey);
 429     }
 430     return key;
 431 }
 432
 433 static HKEY SETUPDI_CreateDrvKey(struct DeviceInfo *devInfo)
 434 {
 435     static const WCHAR slash[] = { '\\',0 };
 436     WCHAR classKeyPath[MAX_PATH];
 437     HKEY classKey, key = INVALID_HANDLE_VALUE;
 438     LONG l;
 439
 440     lstrcpyW(classKeyPath, ControlClass);
 441     lstrcatW(classKeyPath, slash);
 442     SETUPDI_GuidToString(&devInfo->set->ClassGuid,
 443             classKeyPath + lstrlenW(classKeyPath));
 444     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
 445             KEY_ALL_ACCESS, NULL, &classKey, NULL);
 446     if (!l)
 447     {
 448         static const WCHAR fmt[] = { '%','0','4','u',0 };
 449         WCHAR devId[10];
 450
 451         sprintfW(devId, fmt, devInfo->devId);
 452         RegCreateKeyExW(classKey, devId, 0, NULL, 0, KEY_READ | KEY_WRITE,
 453                 NULL, &key, NULL);
 454         RegCloseKey(classKey);
 455     }
 456     return key;
 457 }
 458
 459 static struct DeviceInfo *SETUPDI_AllocateDeviceInfo(struct DeviceInfoSet *set,
 460         DWORD devId, LPCWSTR instanceId, BOOL phantom)
 461 {
 462     struct DeviceInfo *devInfo = NULL;
 463     HANDLE devInst = GlobalAlloc(GMEM_FIXED, sizeof(struct DeviceInfo));
 464     if (devInst)
 465         devInfo = GlobalLock(devInst);
 466
 467     if (devInfo)
 468     {
 469         devInfo->set = set;
 470         devInfo->devId = (DWORD)devInst;
 471
 472         devInfo->instanceId = HeapAlloc(GetProcessHeap(), 0,
 473                 (lstrlenW(instanceId) + 1) * sizeof(WCHAR));
 474         if (devInfo->instanceId)
 475         {
 476             devInfo->key = INVALID_HANDLE_VALUE;
 477             devInfo->phantom = phantom;
 478             lstrcpyW(devInfo->instanceId, instanceId);
 479             struprW(devInfo->instanceId);
 480             devInfo->key = SETUPDI_CreateDevKey(devInfo);
 481             if (devInfo->key != INVALID_HANDLE_VALUE)
 482             {
 483                 if (phantom)
 484                     RegSetValueExW(devInfo->key, Phantom, 0, REG_DWORD,
 485                             (LPBYTE)&phantom, sizeof(phantom));
 486             }
 487             list_init(&devInfo->interfaces);
 488             GlobalUnlock(devInst);
 489         }
 490         else
 491         {
 492             GlobalUnlock(devInst);
 493             GlobalFree(devInst);
 494             devInfo = NULL;
 495         }
 496     }
 497     return devInfo;
 498 }
 499
 500 static void SETUPDI_FreeDeviceInfo(struct DeviceInfo *devInfo)
 501 {
 502     struct InterfaceInstances *iface, *next;
 503
 504     if (devInfo->key != INVALID_HANDLE_VALUE)
 505         RegCloseKey(devInfo->key);
 506     if (devInfo->phantom)
 507     {
 508         HKEY enumKey;
 509         LONG l;
 510
 511         l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0,
 512                 KEY_ALL_ACCESS, NULL, &enumKey, NULL);
 513         if (!l)
 514         {
 515             RegDeleteTreeW(enumKey, devInfo->instanceId);
 516             RegCloseKey(enumKey);
 517         }
 518     }
 519     HeapFree(GetProcessHeap(), 0, devInfo->instanceId);
 520     LIST_FOR_EACH_ENTRY_SAFE(iface, next, &devInfo->interfaces,
 521             struct InterfaceInstances, entry)
 522     {
 523         list_remove(&iface->entry);
 524         SETUPDI_FreeInterfaceInstances(iface);
 525         HeapFree(GetProcessHeap(), 0, iface);
 526     }
 527     GlobalFree((HANDLE)devInfo->devId);
 528 }
 529
 530 /* Adds a device with GUID guid and identifer devInst to set.  Allocates a
 531  * struct DeviceInfo, and points the returned device info's Reserved member
 532  * to it.  "Phantom" devices are deleted from the registry when closed.
 533  * Returns a pointer to the newly allocated device info.
 534  */
 535 static BOOL SETUPDI_AddDeviceToSet(struct DeviceInfoSet *set,
 536         const GUID *guid,
 537         DWORD devInst,
 538         LPCWSTR instanceId,
 539         BOOL phantom,
 540         SP_DEVINFO_DATA **dev)
 541 {
 542     BOOL ret = FALSE;
 543     struct DeviceInfo *devInfo = SETUPDI_AllocateDeviceInfo(set, set->cDevices,
 544             instanceId, phantom);
 545
 546     TRACE("%p, %s, %d, %s, %d\n", set, debugstr_guid(guid), devInst,
 547             debugstr_w(instanceId), phantom);
 548
 549     if (devInfo)
 550     {
 551         struct DeviceInstance *devInst =
 552                 HeapAlloc(GetProcessHeap(), 0, sizeof(struct DeviceInstance));
 553
 554         if (devInst)
 555         {
 556             WCHAR classGuidStr[39];
 557
 558             list_add_tail(&set->devices, &devInst->entry);
 559             set->cDevices++;
 560             devInst->data.cbSize = sizeof(SP_DEVINFO_DATA);
 561             devInst->data.ClassGuid = *guid;
 562             devInst->data.DevInst = devInfo->devId;
 563             devInst->data.Reserved = (ULONG_PTR)devInfo;
 564             SETUPDI_GuidToString(guid, classGuidStr);
 565             SetupDiSetDeviceRegistryPropertyW(set, &devInst->data,
 566                 SPDRP_CLASSGUID, (const BYTE *)classGuidStr,
 567                 lstrlenW(classGuidStr) * sizeof(WCHAR));
 568             if (dev) *dev = &devInst->data;
 569             ret = TRUE;
 570         }
 571         else
 572         {
 573             HeapFree(GetProcessHeap(), 0, devInfo);
 574             SetLastError(ERROR_OUTOFMEMORY);
 575         }
 576     }
 577     return ret;
 578 }
 579
 580 /***********************************************************************
 581  *              SetupDiBuildClassInfoList  (SETUPAPI.@)
 582  *
 583  * Returns a list of setup class GUIDs that identify the classes
 584  * that are installed on a local machine.
 585  *
 586  * PARAMS
 587  *   Flags [I] control exclusion of classes from the list.
 588  *   ClassGuidList [O] pointer to a GUID-typed array that receives a list of setup class GUIDs.
 589  *   ClassGuidListSize [I] The number of GUIDs in the array (ClassGuidList).
 590  *   RequiredSize [O] pointer, which receives the number of GUIDs that are returned.
 591  *
 592  * RETURNS
 593  *   Success: TRUE.
 594  *   Failure: FALSE.
 595  */
 596 BOOL WINAPI SetupDiBuildClassInfoList(
 597         DWORD Flags,
 598         LPGUID ClassGuidList,
 599         DWORD ClassGuidListSize,
 600         PDWORD RequiredSize)
 601 {
 602     TRACE("\n");
 603     return SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
 604                                         ClassGuidListSize, RequiredSize,
 605                                         NULL, NULL);
 606 }
 607
 608 /***********************************************************************
 609  *              SetupDiBuildClassInfoListExA  (SETUPAPI.@)
 610  *
 611  * Returns a list of setup class GUIDs that identify the classes
 612  * that are installed on a local or remote macine.
 613  *
 614  * PARAMS
 615  *   Flags [I] control exclusion of classes from the list.
 616  *   ClassGuidList [O] pointer to a GUID-typed array that receives a list of setup class GUIDs.
 617  *   ClassGuidListSize [I] The number of GUIDs in the array (ClassGuidList).
 618  *   RequiredSize [O] pointer, which receives the number of GUIDs that are returned.
 619  *   MachineName [I] name of a remote machine.
 620  *   Reserved [I] must be NULL.
 621  *
 622  * RETURNS
 623  *   Success: TRUE.
 624  *   Failure: FALSE.
 625  */
 626 BOOL WINAPI SetupDiBuildClassInfoListExA(
 627         DWORD Flags,
 628         LPGUID ClassGuidList,
 629         DWORD ClassGuidListSize,
 630         PDWORD RequiredSize,
 631         LPCSTR MachineName,
 632         PVOID Reserved)
 633 {
 634     LPWSTR MachineNameW = NULL;
 635     BOOL bResult;
 636
 637     TRACE("\n");
 638
 639     if (MachineName)
 640     {
 641         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
 642         if (MachineNameW == NULL) return FALSE;
 643     }
 644
 645     bResult = SetupDiBuildClassInfoListExW(Flags, ClassGuidList,
 646                                            ClassGuidListSize, RequiredSize,
 647                                            MachineNameW, Reserved);
 648
 649     MyFree(MachineNameW);
 650
 651     return bResult;
 652 }
 653
 654 /***********************************************************************
 655  *              SetupDiBuildClassInfoListExW  (SETUPAPI.@)
 656  *
 657  * Returns a list of setup class GUIDs that identify the classes
 658  * that are installed on a local or remote macine.
 659  *
 660  * PARAMS
 661  *   Flags [I] control exclusion of classes from the list.
 662  *   ClassGuidList [O] pointer to a GUID-typed array that receives a list of setup class GUIDs.
 663  *   ClassGuidListSize [I] The number of GUIDs in the array (ClassGuidList).
 664  *   RequiredSize [O] pointer, which receives the number of GUIDs that are returned.
 665  *   MachineName [I] name of a remote machine.
 666  *   Reserved [I] must be NULL.
 667  *
 668  * RETURNS
 669  *   Success: TRUE.
 670  *   Failure: FALSE.
 671  */
 672 BOOL WINAPI SetupDiBuildClassInfoListExW(
 673         DWORD Flags,
 674         LPGUID ClassGuidList,
 675         DWORD ClassGuidListSize,
 676         PDWORD RequiredSize,
 677         LPCWSTR MachineName,
 678         PVOID Reserved)
 679 {
 680     WCHAR szKeyName[40];
 681     HKEY hClassesKey;
 682     HKEY hClassKey;
 683     DWORD dwLength;
 684     DWORD dwIndex;
 685     LONG lError;
 686     DWORD dwGuidListIndex = 0;
 687
 688     TRACE("\n");
 689
 690     if (RequiredSize != NULL)
 691         *RequiredSize = 0;
 692
 693     hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
 694                                             KEY_ALL_ACCESS,
 695                                             DIOCR_INSTALLER,
 696                                             MachineName,
 697                                             Reserved);
 698     if (hClassesKey == INVALID_HANDLE_VALUE)
 699     {
 700         return FALSE;
 701     }
 702
 703     for (dwIndex = 0; ; dwIndex++)
 704     {
 705         dwLength = 40;
 706         lError = RegEnumKeyExW(hClassesKey,
 707                                dwIndex,
 708                                szKeyName,
 709                                &dwLength,
 710                                NULL,
 711                                NULL,
 712                                NULL,
 713                                NULL);
 714         TRACE("RegEnumKeyExW() returns %d\n", lError);
 715         if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
 716         {
 717             TRACE("Key name: %p\n", szKeyName);
 718
 719             if (RegOpenKeyExW(hClassesKey,
 720                               szKeyName,
 721                               0,
 722                               KEY_ALL_ACCESS,
 723                               &hClassKey))
 724             {
 725                 RegCloseKey(hClassesKey);
 726                 return FALSE;
 727             }
 728
 729             if (!RegQueryValueExW(hClassKey,
 730                                   NoUseClass,
 731                                   NULL,
 732                                   NULL,
 733                                   NULL,
 734                                   NULL))
 735             {
 736                 TRACE("'NoUseClass' value found!\n");
 737                 RegCloseKey(hClassKey);
 738                 continue;
 739             }
 740
 741             if ((Flags & DIBCI_NOINSTALLCLASS) &&
 742                 (!RegQueryValueExW(hClassKey,
 743                                    NoInstallClass,
 744                                    NULL,
 745                                    NULL,
 746                                    NULL,
 747                                    NULL)))
 748             {
 749                 TRACE("'NoInstallClass' value found!\n");
 750                 RegCloseKey(hClassKey);
 751                 continue;
 752             }
 753
 754             if ((Flags & DIBCI_NODISPLAYCLASS) &&
 755                 (!RegQueryValueExW(hClassKey,
 756                                    NoDisplayClass,
 757                                    NULL,
 758                                    NULL,
 759                                    NULL,
 760                                    NULL)))
 761             {
 762                 TRACE("'NoDisplayClass' value found!\n");
 763                 RegCloseKey(hClassKey);
 764                 continue;
 765             }
 766
 767             RegCloseKey(hClassKey);
 768
 769             TRACE("Guid: %p\n", szKeyName);
 770             if (dwGuidListIndex < ClassGuidListSize)
 771             {
 772                 if (szKeyName[0] == '{' && szKeyName[37] == '}')
 773                 {
 774                     szKeyName[37] = 0;
 775                 }
 776                 TRACE("Guid: %p\n", &szKeyName[1]);
 777
 778                 UuidFromStringW(&szKeyName[1],
 779                                 &ClassGuidList[dwGuidListIndex]);
 780             }
 781
 782             dwGuidListIndex++;
 783         }
 784
 785         if (lError != ERROR_SUCCESS)
 786             break;
 787     }
 788
 789     RegCloseKey(hClassesKey);
 790
 791     if (RequiredSize != NULL)
 792         *RequiredSize = dwGuidListIndex;
 793
 794     if (ClassGuidListSize < dwGuidListIndex)
 795     {
 796         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 797         return FALSE;
 798     }
 799
 800     return TRUE;
 801 }
 802
 803 /***********************************************************************
 804  *              SetupDiClassGuidsFromNameA  (SETUPAPI.@)
 805  */
 806 BOOL WINAPI SetupDiClassGuidsFromNameA(
 807         LPCSTR ClassName,
 808         LPGUID ClassGuidList,
 809         DWORD ClassGuidListSize,
 810         PDWORD RequiredSize)
 811 {
 812   return SetupDiClassGuidsFromNameExA(ClassName, ClassGuidList,
 813                                       ClassGuidListSize, RequiredSize,
 814                                       NULL, NULL);
 815 }
 816
 817 /***********************************************************************
 818  *              SetupDiClassGuidsFromNameW  (SETUPAPI.@)
 819  */
 820 BOOL WINAPI SetupDiClassGuidsFromNameW(
 821         LPCWSTR ClassName,
 822         LPGUID ClassGuidList,
 823         DWORD ClassGuidListSize,
 824         PDWORD RequiredSize)
 825 {
 826   return SetupDiClassGuidsFromNameExW(ClassName, ClassGuidList,
 827                                       ClassGuidListSize, RequiredSize,
 828                                       NULL, NULL);
 829 }
 830
 831 /***********************************************************************
 832  *              SetupDiClassGuidsFromNameExA  (SETUPAPI.@)
 833  */
 834 BOOL WINAPI SetupDiClassGuidsFromNameExA(
 835         LPCSTR ClassName,
 836         LPGUID ClassGuidList,
 837         DWORD ClassGuidListSize,
 838         PDWORD RequiredSize,
 839         LPCSTR MachineName,
 840         PVOID Reserved)
 841 {
 842     LPWSTR ClassNameW = NULL;
 843     LPWSTR MachineNameW = NULL;
 844     BOOL bResult;
 845
 846     ClassNameW = MultiByteToUnicode(ClassName, CP_ACP);
 847     if (ClassNameW == NULL)
 848         return FALSE;
 849
 850     if (MachineName)
 851     {
 852         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
 853         if (MachineNameW == NULL)
 854         {
 855             MyFree(ClassNameW);
 856             return FALSE;
 857         }
 858     }
 859
 860     bResult = SetupDiClassGuidsFromNameExW(ClassNameW, ClassGuidList,
 861                                            ClassGuidListSize, RequiredSize,
 862                                            MachineNameW, Reserved);
 863
 864     MyFree(MachineNameW);
 865     MyFree(ClassNameW);
 866
 867     return bResult;
 868 }
 869
 870 /***********************************************************************
 871  *              SetupDiClassGuidsFromNameExW  (SETUPAPI.@)
 872  */
 873 BOOL WINAPI SetupDiClassGuidsFromNameExW(
 874         LPCWSTR ClassName,
 875         LPGUID ClassGuidList,
 876         DWORD ClassGuidListSize,
 877         PDWORD RequiredSize,
 878         LPCWSTR MachineName,
 879         PVOID Reserved)
 880 {
 881     WCHAR szKeyName[40];
 882     WCHAR szClassName[256];
 883     HKEY hClassesKey;
 884     HKEY hClassKey;
 885     DWORD dwLength;
 886     DWORD dwIndex;
 887     LONG lError;
 888     DWORD dwGuidListIndex = 0;
 889
 890     if (RequiredSize != NULL)
 891         *RequiredSize = 0;
 892
 893     hClassesKey = SetupDiOpenClassRegKeyExW(NULL,
 894                                             KEY_ALL_ACCESS,
 895                                             DIOCR_INSTALLER,
 896                                             MachineName,
 897                                             Reserved);
 898     if (hClassesKey == INVALID_HANDLE_VALUE)
 899     {
 900         return FALSE;
 901     }
 902
 903     for (dwIndex = 0; ; dwIndex++)
 904     {
 905         dwLength = 40;
 906         lError = RegEnumKeyExW(hClassesKey,
 907                                dwIndex,
 908                                szKeyName,
 909                                &dwLength,
 910                                NULL,
 911                                NULL,
 912                                NULL,
 913                                NULL);
 914         TRACE("RegEnumKeyExW() returns %d\n", lError);
 915         if (lError == ERROR_SUCCESS || lError == ERROR_MORE_DATA)
 916         {
 917             TRACE("Key name: %p\n", szKeyName);
 918
 919             if (RegOpenKeyExW(hClassesKey,
 920                               szKeyName,
 921                               0,
 922                               KEY_ALL_ACCESS,
 923                               &hClassKey))
 924             {
 925                 RegCloseKey(hClassesKey);
 926                 return FALSE;
 927             }
 928
 929             dwLength = 256 * sizeof(WCHAR);
 930             if (!RegQueryValueExW(hClassKey,
 931                                   Class,
 932                                   NULL,
 933                                   NULL,
 934                                   (LPBYTE)szClassName,
 935                                   &dwLength))
 936             {
 937                 TRACE("Class name: %p\n", szClassName);
 938
 939                 if (strcmpiW(szClassName, ClassName) == 0)
 940                 {
 941                     TRACE("Found matching class name\n");
 942
 943                     TRACE("Guid: %p\n", szKeyName);
 944                     if (dwGuidListIndex < ClassGuidListSize)
 945                     {
 946                         if (szKeyName[0] == '{' && szKeyName[37] == '}')
 947                         {
 948                             szKeyName[37] = 0;
 949                         }
 950                         TRACE("Guid: %p\n", &szKeyName[1]);
 951
 952                         UuidFromStringW(&szKeyName[1],
 953                                         &ClassGuidList[dwGuidListIndex]);
 954                     }
 955
 956                     dwGuidListIndex++;
 957                 }
 958             }
 959
 960             RegCloseKey(hClassKey);
 961         }
 962
 963         if (lError != ERROR_SUCCESS)
 964             break;
 965     }
 966
 967     RegCloseKey(hClassesKey);
 968
 969     if (RequiredSize != NULL)
 970         *RequiredSize = dwGuidListIndex;
 971
 972     if (ClassGuidListSize < dwGuidListIndex)
 973     {
 974         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 975         return FALSE;
 976     }
 977
 978     return TRUE;
 979 }
 980
 981 /***********************************************************************
 982  *              SetupDiClassNameFromGuidA  (SETUPAPI.@)
 983  */
 984 BOOL WINAPI SetupDiClassNameFromGuidA(
 985         const GUID* ClassGuid,
 986         PSTR ClassName,
 987         DWORD ClassNameSize,
 988         PDWORD RequiredSize)
 989 {
 990   return SetupDiClassNameFromGuidExA(ClassGuid, ClassName,
 991                                      ClassNameSize, RequiredSize,
 992                                      NULL, NULL);
 993 }
 994
 995 /***********************************************************************
 996  *              SetupDiClassNameFromGuidW  (SETUPAPI.@)
 997  */
 998 BOOL WINAPI SetupDiClassNameFromGuidW(
 999         const GUID* ClassGuid,
1000         PWSTR ClassName,
1001         DWORD ClassNameSize,
1002         PDWORD RequiredSize)
1003 {
1004   return SetupDiClassNameFromGuidExW(ClassGuid, ClassName,
1005                                      ClassNameSize, RequiredSize,
1006                                      NULL, NULL);
1007 }
1008
1009 /***********************************************************************
1010  *              SetupDiClassNameFromGuidExA  (SETUPAPI.@)
1011  */
1012 BOOL WINAPI SetupDiClassNameFromGuidExA(
1013         const GUID* ClassGuid,
1014         PSTR ClassName,
1015         DWORD ClassNameSize,
1016         PDWORD RequiredSize,
1017         PCSTR MachineName,
1018         PVOID Reserved)
1019 {
1020     WCHAR ClassNameW[MAX_CLASS_NAME_LEN];
1021     LPWSTR MachineNameW = NULL;
1022     BOOL ret;
1023
1024     if (MachineName)
1025         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
1026     ret = SetupDiClassNameFromGuidExW(ClassGuid, ClassNameW, MAX_CLASS_NAME_LEN,
1027      NULL, MachineNameW, Reserved);
1028     if (ret)
1029     {
1030         int len = WideCharToMultiByte(CP_ACP, 0, ClassNameW, -1, ClassName,
1031          ClassNameSize, NULL, NULL);
1032
1033         if (!ClassNameSize && RequiredSize)
1034             *RequiredSize = len;
1035     }
1036     MyFree(MachineNameW);
1037     return ret;
1038 }
1039
1040 /***********************************************************************
1041  *              SetupDiClassNameFromGuidExW  (SETUPAPI.@)
1042  */
1043 BOOL WINAPI SetupDiClassNameFromGuidExW(
1044         const GUID* ClassGuid,
1045         PWSTR ClassName,
1046         DWORD ClassNameSize,
1047         PDWORD RequiredSize,
1048         PCWSTR MachineName,
1049         PVOID Reserved)
1050 {
1051     HKEY hKey;
1052     DWORD dwLength;
1053
1054     hKey = SetupDiOpenClassRegKeyExW(ClassGuid,
1055                                      KEY_ALL_ACCESS,
1056                                      DIOCR_INSTALLER,
1057                                      MachineName,
1058                                      Reserved);
1059     if (hKey == INVALID_HANDLE_VALUE)
1060     {
1061         return FALSE;
1062     }
1063
1064     if (RequiredSize != NULL)
1065     {
1066         dwLength = 0;
1067         if (RegQueryValueExW(hKey,
1068                              Class,
1069                              NULL,
1070                              NULL,
1071                              NULL,
1072                              &dwLength))
1073         {
1074             RegCloseKey(hKey);
1075             return FALSE;
1076         }
1077
1078         *RequiredSize = dwLength / sizeof(WCHAR);
1079     }
1080
1081     dwLength = ClassNameSize * sizeof(WCHAR);
1082     if (RegQueryValueExW(hKey,
1083                          Class,
1084                          NULL,
1085                          NULL,
1086                          (LPBYTE)ClassName,
1087                          &dwLength))
1088     {
1089         RegCloseKey(hKey);
1090         return FALSE;
1091     }
1092
1093     RegCloseKey(hKey);
1094
1095     return TRUE;
1096 }
1097
1098 /***********************************************************************
1099  *              SetupDiCreateDeviceInfoList (SETUPAPI.@)
1100  */
1101 HDEVINFO WINAPI
1102 SetupDiCreateDeviceInfoList(const GUID *ClassGuid,
1103                             HWND hwndParent)
1104 {
1105   return SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent, NULL, NULL);
1106 }
1107
1108 /***********************************************************************
1109  *              SetupDiCreateDeviceInfoListExA (SETUPAPI.@)
1110  */
1111 HDEVINFO WINAPI
1112 SetupDiCreateDeviceInfoListExA(const GUID *ClassGuid,
1113                                HWND hwndParent,
1114                                PCSTR MachineName,
1115                                PVOID Reserved)
1116 {
1117     LPWSTR MachineNameW = NULL;
1118     HDEVINFO hDevInfo;
1119
1120     TRACE("\n");
1121
1122     if (MachineName)
1123     {
1124         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
1125         if (MachineNameW == NULL)
1126             return INVALID_HANDLE_VALUE;
1127     }
1128
1129     hDevInfo = SetupDiCreateDeviceInfoListExW(ClassGuid, hwndParent,
1130                                               MachineNameW, Reserved);
1131
1132     MyFree(MachineNameW);
1133
1134     return hDevInfo;
1135 }
1136
1137 /***********************************************************************
1138  *              SetupDiCreateDeviceInfoListExW (SETUPAPI.@)
1139  *
1140  * Create an empty DeviceInfoSet list.
1141  *
1142  * PARAMS
1143  *   ClassGuid [I] if not NULL only devices with GUID ClassGuid are associated
1144  *                 with this list.
1145  *   hwndParent [I] hwnd needed for interface related actions.
1146  *   MachineName [I] name of machine to create emtpy DeviceInfoSet list, if NULL
1147  *                   local registry will be used.
1148  *   Reserved [I] must be NULL
1149  *
1150  * RETURNS
1151  *   Success: empty list.
1152  *   Failure: INVALID_HANDLE_VALUE.
1153  */
1154 HDEVINFO WINAPI
1155 SetupDiCreateDeviceInfoListExW(const GUID *ClassGuid,
1156                                HWND hwndParent,
1157                                PCWSTR MachineName,
1158                                PVOID Reserved)
1159 {
1160     struct DeviceInfoSet *list = NULL;
1161     DWORD size = sizeof(struct DeviceInfoSet);
1162
1163     TRACE("%s %p %s %p\n", debugstr_guid(ClassGuid), hwndParent,
1164       debugstr_w(MachineName), Reserved);
1165
1166     if (MachineName != NULL)
1167     {
1168         FIXME("remote support is not implemented\n");
1169         SetLastError(ERROR_INVALID_MACHINENAME);
1170         return INVALID_HANDLE_VALUE;
1171     }
1172
1173     if (Reserved != NULL)
1174     {
1175         SetLastError(ERROR_INVALID_PARAMETER);
1176         return INVALID_HANDLE_VALUE;
1177     }
1178
1179     list = HeapAlloc(GetProcessHeap(), 0, size);
1180     if (!list)
1181     {
1182         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1183         return INVALID_HANDLE_VALUE;
1184     }
1185
1186     list->magic = SETUP_DEVICE_INFO_SET_MAGIC;
1187     list->hwndParent = hwndParent;
1188     memcpy(&list->ClassGuid,
1189             ClassGuid ? ClassGuid : &GUID_NULL,
1190             sizeof(list->ClassGuid));
1191     list->cDevices = 0;
1192     list_init(&list->devices);
1193
1194     return list;
1195 }
1196
1197 /***********************************************************************
1198  *              SetupDiCreateDevRegKeyA (SETUPAPI.@)
1199  */
1200 HKEY WINAPI SetupDiCreateDevRegKeyA(
1201         HDEVINFO DeviceInfoSet,
1202         PSP_DEVINFO_DATA DeviceInfoData,
1203         DWORD Scope,
1204         DWORD HwProfile,
1205         DWORD KeyType,
1206         HINF InfHandle,
1207         PCSTR InfSectionName)
1208 {
1209     PWSTR InfSectionNameW = NULL;
1210     HKEY key;
1211
1212     TRACE("%p %p %d %d %d %p %s\n", DeviceInfoSet, DeviceInfoData, Scope,
1213             HwProfile, KeyType, InfHandle, debugstr_a(InfSectionName));
1214
1215     if (InfHandle)
1216     {
1217         if (!InfSectionName)
1218         {
1219             SetLastError(ERROR_INVALID_PARAMETER);
1220             return INVALID_HANDLE_VALUE;
1221         }
1222         else
1223         {
1224             InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
1225             if (InfSectionNameW == NULL) return INVALID_HANDLE_VALUE;
1226         }
1227     }
1228     key = SetupDiCreateDevRegKeyW(DeviceInfoSet, DeviceInfoData, Scope,
1229             HwProfile, KeyType, InfHandle, InfSectionNameW);
1230     MyFree(InfSectionNameW);
1231     return key;
1232 }
1233
1234 /***********************************************************************
1235  *              SetupDiCreateDevRegKeyW (SETUPAPI.@)
1236  */
1237 HKEY WINAPI SetupDiCreateDevRegKeyW(
1238         HDEVINFO DeviceInfoSet,
1239         PSP_DEVINFO_DATA DeviceInfoData,
1240         DWORD Scope,
1241         DWORD HwProfile,
1242         DWORD KeyType,
1243         HINF InfHandle,
1244         PCWSTR InfSectionName)
1245 {
1246     struct DeviceInfoSet *set = DeviceInfoSet;
1247     struct DeviceInfo *devInfo;
1248     HKEY key = INVALID_HANDLE_VALUE;
1249
1250     TRACE("%p %p %d %d %d %p %s\n", DeviceInfoSet, DeviceInfoData, Scope,
1251             HwProfile, KeyType, InfHandle, debugstr_w(InfSectionName));
1252
1253     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
1254     {
1255         SetLastError(ERROR_INVALID_HANDLE);
1256         return INVALID_HANDLE_VALUE;
1257     }
1258     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
1259     {
1260         SetLastError(ERROR_INVALID_HANDLE);
1261         return INVALID_HANDLE_VALUE;
1262     }
1263     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
1264             || !DeviceInfoData->Reserved)
1265     {
1266         SetLastError(ERROR_INVALID_PARAMETER);
1267         return INVALID_HANDLE_VALUE;
1268     }
1269     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
1270     if (devInfo->set != set)
1271     {
1272         SetLastError(ERROR_INVALID_PARAMETER);
1273         return INVALID_HANDLE_VALUE;
1274     }
1275     if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
1276     {
1277         SetLastError(ERROR_INVALID_FLAGS);
1278         return INVALID_HANDLE_VALUE;
1279     }
1280     if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
1281     {
1282         SetLastError(ERROR_INVALID_FLAGS);
1283         return INVALID_HANDLE_VALUE;
1284     }
1285     if (devInfo->phantom)
1286     {
1287         SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
1288         return INVALID_HANDLE_VALUE;
1289     }
1290     if (Scope != DICS_FLAG_GLOBAL)
1291         FIXME("unimplemented for scope %d\n", Scope);
1292     switch (KeyType)
1293     {
1294         case DIREG_DEV:
1295             key = SETUPDI_CreateDevKey(devInfo);
1296             break;
1297         case DIREG_DRV:
1298             key = SETUPDI_CreateDrvKey(devInfo);
1299             break;
1300         default:
1301             WARN("unknown KeyType %d\n", KeyType);
1302     }
1303     if (InfHandle)
1304         SetupInstallFromInfSectionW(NULL, InfHandle, InfSectionName, SPINST_ALL,
1305                 NULL, NULL, SP_COPY_NEWER_ONLY, NULL, NULL, DeviceInfoSet,
1306                 DeviceInfoData);
1307     return key;
1308 }
1309
1310 /***********************************************************************
1311  *              SetupDiCreateDeviceInfoA (SETUPAPI.@)
1312  */
1313 BOOL WINAPI SetupDiCreateDeviceInfoA(
1314        HDEVINFO DeviceInfoSet,
1315        PCSTR DeviceName,
1316        CONST GUID *ClassGuid,
1317        PCSTR DeviceDescription,
1318        HWND hwndParent,
1319        DWORD CreationFlags,
1320        PSP_DEVINFO_DATA DeviceInfoData)
1321 {
1322     BOOL ret = FALSE;
1323     LPWSTR DeviceNameW = NULL;
1324     LPWSTR DeviceDescriptionW = NULL;
1325
1326     if (DeviceName)
1327     {
1328         DeviceNameW = MultiByteToUnicode(DeviceName, CP_ACP);
1329         if (DeviceNameW == NULL) return FALSE;
1330     }
1331     if (DeviceDescription)
1332     {
1333         DeviceDescriptionW = MultiByteToUnicode(DeviceDescription, CP_ACP);
1334         if (DeviceDescriptionW == NULL)
1335         {
1336             MyFree(DeviceNameW);
1337             return FALSE;
1338         }
1339     }
1340
1341     ret = SetupDiCreateDeviceInfoW(DeviceInfoSet, DeviceNameW, ClassGuid, DeviceDescriptionW,
1342             hwndParent, CreationFlags, DeviceInfoData);
1343
1344     MyFree(DeviceNameW);
1345     MyFree(DeviceDescriptionW);
1346
1347     return ret;
1348 }
1349
1350 static DWORD SETUPDI_DevNameToDevID(LPCWSTR devName)
1351 {
1352     LPCWSTR ptr;
1353     int devNameLen = lstrlenW(devName);
1354     DWORD devInst = 0;
1355     BOOL valid = TRUE;
1356
1357     TRACE("%s\n", debugstr_w(devName));
1358     for (ptr = devName; valid && *ptr && ptr - devName < devNameLen; )
1359     {
1360         if (isdigitW(*ptr))
1361         {
1362             devInst *= 10;
1363             devInst |= *ptr - '0';
1364             ptr++;
1365         }
1366         else
1367             valid = FALSE;
1368     }
1369     TRACE("%d\n", valid ? devInst : 0xffffffff);
1370     return valid ? devInst : 0xffffffff;
1371 }
1372
1373 /***********************************************************************
1374  *              SetupDiCreateDeviceInfoW (SETUPAPI.@)
1375  */
1376 BOOL WINAPI SetupDiCreateDeviceInfoW(
1377        HDEVINFO DeviceInfoSet,
1378        PCWSTR DeviceName,
1379        CONST GUID *ClassGuid,
1380        PCWSTR DeviceDescription,
1381        HWND hwndParent,
1382        DWORD CreationFlags,
1383        PSP_DEVINFO_DATA DeviceInfoData)
1384 {
1385     struct DeviceInfoSet *set = DeviceInfoSet;
1386     BOOL ret = FALSE, allocatedInstanceId = FALSE;
1387     LPCWSTR instanceId = NULL;
1388
1389     TRACE("%p %s %s %s %p %x %p\n", DeviceInfoSet, debugstr_w(DeviceName),
1390         debugstr_guid(ClassGuid), debugstr_w(DeviceDescription),
1391         hwndParent, CreationFlags, DeviceInfoData);
1392
1393     if (!DeviceName)
1394     {
1395         SetLastError(ERROR_INVALID_DEVINST_NAME);
1396         return FALSE;
1397     }
1398     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
1399     {
1400         SetLastError(ERROR_INVALID_HANDLE);
1401         return FALSE;
1402     }
1403     if (!ClassGuid)
1404     {
1405         SetLastError(ERROR_INVALID_PARAMETER);
1406         return FALSE;
1407     }
1408     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
1409     {
1410         SetLastError(ERROR_INVALID_HANDLE);
1411         return FALSE;
1412     }
1413     if (!IsEqualGUID(&set->ClassGuid, &GUID_NULL) &&
1414         !IsEqualGUID(ClassGuid, &set->ClassGuid))
1415     {
1416         SetLastError(ERROR_CLASS_MISMATCH);
1417         return FALSE;
1418     }
1419     if ((CreationFlags & DICD_GENERATE_ID))
1420     {
1421         if (strchrW(DeviceName, '\\'))
1422             SetLastError(ERROR_INVALID_DEVINST_NAME);
1423         else
1424         {
1425             static const WCHAR newDeviceFmt[] = {'R','O','O','T','\\','%','s',
1426                 '\\','%','0','4','d',0};
1427             DWORD devId;
1428
1429             if (set->cDevices)
1430             {
1431                 DWORD highestDevID = 0;
1432                 struct DeviceInstance *devInst;
1433
1434                 LIST_FOR_EACH_ENTRY(devInst, &set->devices, struct DeviceInstance, entry)
1435                 {
1436                     struct DeviceInfo *devInfo = (struct DeviceInfo *)devInst->data.Reserved;
1437                     LPCWSTR devName = strrchrW(devInfo->instanceId, '\\');
1438                     DWORD id;
1439
1440                     if (devName)
1441                         devName++;
1442                     else
1443                         devName = devInfo->instanceId;
1444                     id = SETUPDI_DevNameToDevID(devName);
1445                     if (id != 0xffffffff && id > highestDevID)
1446                         highestDevID = id;
1447                 }
1448                 devId = highestDevID + 1;
1449             }
1450             else
1451                 devId = 0;
1452             /* 17 == lstrlenW(L"Root\\") + lstrlenW("\\") + 1 + %d max size */
1453             instanceId = HeapAlloc(GetProcessHeap(), 0,
1454                     (17 + lstrlenW(DeviceName)) * sizeof(WCHAR));
1455             if (instanceId)
1456             {
1457                 sprintfW((LPWSTR)instanceId, newDeviceFmt, DeviceName,
1458                         devId);
1459                 allocatedInstanceId = TRUE;
1460                 ret = TRUE;
1461             }
1462             else
1463                 ret = FALSE;
1464         }
1465     }
1466     else
1467     {
1468         struct DeviceInstance *devInst;
1469
1470         ret = TRUE;
1471         instanceId = DeviceName;
1472         LIST_FOR_EACH_ENTRY(devInst, &set->devices, struct DeviceInstance, entry)
1473         {
1474             struct DeviceInfo *devInfo = (struct DeviceInfo *)devInst->data.Reserved;
1475
1476             if (!lstrcmpiW(DeviceName, devInfo->instanceId))
1477             {
1478                 SetLastError(ERROR_DEVINST_ALREADY_EXISTS);
1479                 ret = FALSE;
1480             }
1481         }
1482     }
1483     if (ret)
1484     {
1485         SP_DEVINFO_DATA *dev = NULL;
1486
1487         ret = SETUPDI_AddDeviceToSet(set, ClassGuid, 0 /* FIXME: DevInst */,
1488                 instanceId, TRUE, &dev);
1489         if (ret)
1490         {
1491             if (DeviceDescription)
1492                 SetupDiSetDeviceRegistryPropertyW(DeviceInfoSet,
1493                     dev, SPDRP_DEVICEDESC, (const BYTE *)DeviceDescription,
1494                     lstrlenW(DeviceDescription) * sizeof(WCHAR));
1495             if (DeviceInfoData)
1496             {
1497                 if (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
1498                 {
1499                     SetLastError(ERROR_INVALID_USER_BUFFER);
1500                     ret = FALSE;
1501                 }
1502                 else
1503                     *DeviceInfoData = *dev;
1504             }
1505         }
1506     }
1507     if (allocatedInstanceId)
1508         HeapFree(GetProcessHeap(), 0, (LPWSTR)instanceId);
1509
1510     return ret;
1511 }
1512
1513 /***********************************************************************
1514  *              SetupDiRegisterDeviceInfo (SETUPAPI.@)
1515  */
1516 BOOL WINAPI SetupDiRegisterDeviceInfo(
1517         HDEVINFO DeviceInfoSet,
1518         PSP_DEVINFO_DATA DeviceInfoData,
1519         DWORD Flags,
1520         PSP_DETSIG_CMPPROC CompareProc,
1521         PVOID CompareContext,
1522         PSP_DEVINFO_DATA DupDeviceInfoData)
1523 {
1524     struct DeviceInfoSet *set = DeviceInfoSet;
1525     struct DeviceInfo *devInfo;
1526
1527     TRACE("%p %p %08x %p %p %p\n", DeviceInfoSet, DeviceInfoData, Flags,
1528             CompareProc, CompareContext, DupDeviceInfoData);
1529
1530     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
1531     {
1532         SetLastError(ERROR_INVALID_HANDLE);
1533         return FALSE;
1534     }
1535     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
1536     {
1537         SetLastError(ERROR_INVALID_HANDLE);
1538         return FALSE;
1539     }
1540     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
1541             || !DeviceInfoData->Reserved)
1542     {
1543         SetLastError(ERROR_INVALID_PARAMETER);
1544         return FALSE;
1545     }
1546     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
1547     if (devInfo->set != set)
1548     {
1549         SetLastError(ERROR_INVALID_PARAMETER);
1550         return FALSE;
1551     }
1552     if (devInfo->phantom)
1553     {
1554         devInfo->phantom = FALSE;
1555         RegDeleteValueW(devInfo->key, Phantom);
1556     }
1557     return TRUE;
1558 }
1559
1560 /***********************************************************************
1561  *              SetupDiRemoveDevice (SETUPAPI.@)
1562  */
1563 BOOL WINAPI SetupDiRemoveDevice(
1564         HDEVINFO devinfo,
1565         PSP_DEVINFO_DATA info)
1566 {
1567     FIXME("(%p, %p): stub\n", devinfo, info);
1568     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1569     return FALSE;
1570 }
1571
1572 /***********************************************************************
1573  *              SetupDiEnumDeviceInfo (SETUPAPI.@)
1574  */
1575 BOOL WINAPI SetupDiEnumDeviceInfo(
1576         HDEVINFO  devinfo,
1577         DWORD  index,
1578         PSP_DEVINFO_DATA info)
1579 {
1580     BOOL ret = FALSE;
1581
1582     TRACE("%p %d %p\n", devinfo, index, info);
1583
1584     if(info==NULL)
1585     {
1586         SetLastError(ERROR_INVALID_PARAMETER);
1587         return FALSE;
1588     }
1589     if (devinfo && devinfo != INVALID_HANDLE_VALUE)
1590     {
1591         struct DeviceInfoSet *list = devinfo;
1592         if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC)
1593         {
1594             if (index < list->cDevices)
1595             {
1596                 if (info->cbSize == sizeof(SP_DEVINFO_DATA))
1597                 {
1598                     struct DeviceInstance *devInst;
1599                     DWORD i = 0;
1600
1601                     LIST_FOR_EACH_ENTRY(devInst, &list->devices,
1602                             struct DeviceInstance, entry)
1603                     {
1604                         if (i++ == index)
1605                         {
1606                             *info = devInst->data;
1607                             break;
1608                         }
1609                     }
1610                     ret = TRUE;
1611                 }
1612                 else
1613                     SetLastError(ERROR_INVALID_USER_BUFFER);
1614             }
1615             else
1616                 SetLastError(ERROR_NO_MORE_ITEMS);
1617         }
1618         else
1619             SetLastError(ERROR_INVALID_HANDLE);
1620     }
1621     else
1622         SetLastError(ERROR_INVALID_HANDLE);
1623     return ret;
1624 }
1625
1626 /***********************************************************************
1627  *              SetupDiGetDeviceInstanceIdA (SETUPAPI.@)
1628  */
1629 BOOL WINAPI SetupDiGetDeviceInstanceIdA(
1630         HDEVINFO DeviceInfoSet,
1631         PSP_DEVINFO_DATA DeviceInfoData,
1632         PSTR DeviceInstanceId,
1633         DWORD DeviceInstanceIdSize,
1634         PDWORD RequiredSize)
1635 {
1636     BOOL ret = FALSE;
1637     DWORD size;
1638     PWSTR instanceId;
1639
1640     TRACE("%p %p %p %d %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstanceId,
1641             DeviceInstanceIdSize, RequiredSize);
1642
1643     SetupDiGetDeviceInstanceIdW(DeviceInfoSet,
1644                                 DeviceInfoData,
1645                                 NULL,
1646                                 0,
1647                                 &size);
1648     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1649         return FALSE;
1650     instanceId = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
1651     if (instanceId)
1652     {
1653         ret = SetupDiGetDeviceInstanceIdW(DeviceInfoSet,
1654                                           DeviceInfoData,
1655                                           instanceId,
1656                                           size,
1657                                           &size);
1658         if (ret)
1659         {
1660             int len = WideCharToMultiByte(CP_ACP, 0, instanceId, -1,
1661                                           DeviceInstanceId,
1662                                           DeviceInstanceIdSize, NULL, NULL);
1663
1664             if (!len)
1665                 ret = FALSE;
1666             else
1667             {
1668                 if (len > DeviceInstanceIdSize)
1669                 {
1670                     SetLastError(ERROR_INSUFFICIENT_BUFFER);
1671                     ret = FALSE;
1672                 }
1673                 if (RequiredSize)
1674                     *RequiredSize = len;
1675             }
1676         }
1677         HeapFree(GetProcessHeap(), 0, instanceId);
1678     }
1679     return ret;
1680 }
1681
1682 /***********************************************************************
1683  *              SetupDiGetDeviceInstanceIdW (SETUPAPI.@)
1684  */
1685 BOOL WINAPI SetupDiGetDeviceInstanceIdW(
1686         HDEVINFO DeviceInfoSet,
1687         PSP_DEVINFO_DATA DeviceInfoData,
1688         PWSTR DeviceInstanceId,
1689         DWORD DeviceInstanceIdSize,
1690         PDWORD RequiredSize)
1691 {
1692     struct DeviceInfoSet *set = DeviceInfoSet;
1693     struct DeviceInfo *devInfo;
1694
1695     TRACE("%p %p %p %d %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstanceId,
1696             DeviceInstanceIdSize, RequiredSize);
1697
1698     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
1699     {
1700         SetLastError(ERROR_INVALID_HANDLE);
1701         return FALSE;
1702     }
1703     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
1704     {
1705         SetLastError(ERROR_INVALID_HANDLE);
1706         return FALSE;
1707     }
1708     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
1709             || !DeviceInfoData->Reserved)
1710     {
1711         SetLastError(ERROR_INVALID_PARAMETER);
1712         return FALSE;
1713     }
1714     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
1715     if (devInfo->set != set)
1716     {
1717         SetLastError(ERROR_INVALID_PARAMETER);
1718         return FALSE;
1719     }
1720     TRACE("instance ID: %s\n", debugstr_w(devInfo->instanceId));
1721     if (DeviceInstanceIdSize < strlenW(devInfo->instanceId) + 1)
1722     {
1723         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1724         if (RequiredSize)
1725             *RequiredSize = lstrlenW(devInfo->instanceId) + 1;
1726         return FALSE;
1727     }
1728     lstrcpyW(DeviceInstanceId, devInfo->instanceId);
1729     if (RequiredSize)
1730         *RequiredSize = lstrlenW(devInfo->instanceId) + 1;
1731     return TRUE;
1732 }
1733
1734 /***********************************************************************
1735  *              SetupDiGetActualSectionToInstallA (SETUPAPI.@)
1736  */
1737 BOOL WINAPI SetupDiGetActualSectionToInstallA(
1738         HINF InfHandle,
1739         PCSTR InfSectionName,
1740         PSTR InfSectionWithExt,
1741         DWORD InfSectionWithExtSize,
1742         PDWORD RequiredSize,
1743         PSTR *Extension)
1744 {
1745     FIXME("\n");
1746     return FALSE;
1747 }
1748
1749 /***********************************************************************
1750  *              SetupDiGetActualSectionToInstallW (SETUPAPI.@)
1751  */
1752 BOOL WINAPI SetupDiGetActualSectionToInstallW(
1753         HINF InfHandle,
1754         PCWSTR InfSectionName,
1755         PWSTR InfSectionWithExt,
1756         DWORD InfSectionWithExtSize,
1757         PDWORD RequiredSize,
1758         PWSTR *Extension)
1759 {
1760     WCHAR szBuffer[MAX_PATH];
1761     DWORD dwLength;
1762     DWORD dwFullLength;
1763     LONG lLineCount = -1;
1764
1765     lstrcpyW(szBuffer, InfSectionName);
1766     dwLength = lstrlenW(szBuffer);
1767
1768     if (OsVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
1769     {
1770         /* Test section name with '.NTx86' extension */
1771         lstrcpyW(&szBuffer[dwLength], NtPlatformExtension);
1772         lLineCount = SetupGetLineCountW(InfHandle, szBuffer);
1773
1774         if (lLineCount == -1)
1775         {
1776             /* Test section name with '.NT' extension */
1777             lstrcpyW(&szBuffer[dwLength], NtExtension);
1778             lLineCount = SetupGetLineCountW(InfHandle, szBuffer);
1779         }
1780     }
1781     else
1782     {
1783         /* Test section name with '.Win' extension */
1784         lstrcpyW(&szBuffer[dwLength], WinExtension);
1785         lLineCount = SetupGetLineCountW(InfHandle, szBuffer);
1786     }
1787
1788     if (lLineCount == -1)
1789     {
1790         /* Test section name without extension */
1791         szBuffer[dwLength] = 0;
1792         lLineCount = SetupGetLineCountW(InfHandle, szBuffer);
1793     }
1794
1795     if (lLineCount == -1)
1796     {
1797         SetLastError(ERROR_INVALID_PARAMETER);
1798         return FALSE;
1799     }
1800
1801     dwFullLength = lstrlenW(szBuffer);
1802
1803     if (InfSectionWithExt != NULL && InfSectionWithExtSize != 0)
1804     {
1805         if (InfSectionWithExtSize < (dwFullLength + 1))
1806         {
1807             SetLastError(ERROR_INSUFFICIENT_BUFFER);
1808             return FALSE;
1809         }
1810
1811         lstrcpyW(InfSectionWithExt, szBuffer);
1812         if (Extension != NULL)
1813         {
1814             *Extension = (dwLength == dwFullLength) ? NULL : &InfSectionWithExt[dwLength];
1815         }
1816     }
1817
1818     if (RequiredSize != NULL)
1819     {
1820         *RequiredSize = dwFullLength + 1;
1821     }
1822
1823     return TRUE;
1824 }
1825
1826 /***********************************************************************
1827  *              SetupDiGetClassDescriptionA  (SETUPAPI.@)
1828  */
1829 BOOL WINAPI SetupDiGetClassDescriptionA(
1830         const GUID* ClassGuid,
1831         PSTR ClassDescription,
1832         DWORD ClassDescriptionSize,
1833         PDWORD RequiredSize)
1834 {
1835   return SetupDiGetClassDescriptionExA(ClassGuid, ClassDescription,
1836                                        ClassDescriptionSize,
1837                                        RequiredSize, NULL, NULL);
1838 }
1839
1840 /***********************************************************************
1841  *              SetupDiGetClassDescriptionW  (SETUPAPI.@)
1842  */
1843 BOOL WINAPI SetupDiGetClassDescriptionW(
1844         const GUID* ClassGuid,
1845         PWSTR ClassDescription,
1846         DWORD ClassDescriptionSize,
1847         PDWORD RequiredSize)
1848 {
1849   return SetupDiGetClassDescriptionExW(ClassGuid, ClassDescription,
1850                                        ClassDescriptionSize,
1851                                        RequiredSize, NULL, NULL);
1852 }
1853
1854 /***********************************************************************
1855  *              SetupDiGetClassDescriptionExA  (SETUPAPI.@)
1856  */
1857 BOOL WINAPI SetupDiGetClassDescriptionExA(
1858         const GUID* ClassGuid,
1859         PSTR ClassDescription,
1860         DWORD ClassDescriptionSize,
1861         PDWORD RequiredSize,
1862         PCSTR MachineName,
1863         PVOID Reserved)
1864 {
1865     HKEY hKey;
1866     DWORD dwLength;
1867     BOOL ret;
1868
1869     hKey = SetupDiOpenClassRegKeyExA(ClassGuid,
1870                                      KEY_ALL_ACCESS,
1871                                      DIOCR_INSTALLER,
1872                                      MachineName,
1873                                      Reserved);
1874     if (hKey == INVALID_HANDLE_VALUE)
1875     {
1876         WARN("SetupDiOpenClassRegKeyExA() failed (Error %u)\n", GetLastError());
1877         return FALSE;
1878     }
1879
1880     dwLength = ClassDescriptionSize;
1881     ret = !RegQueryValueExA( hKey, NULL, NULL, NULL,
1882                              (LPBYTE)ClassDescription, &dwLength );
1883     if (RequiredSize) *RequiredSize = dwLength;
1884     RegCloseKey(hKey);
1885     return ret;
1886 }
1887
1888 /***********************************************************************
1889  *              SetupDiGetClassDescriptionExW  (SETUPAPI.@)
1890  */
1891 BOOL WINAPI SetupDiGetClassDescriptionExW(
1892         const GUID* ClassGuid,
1893         PWSTR ClassDescription,
1894         DWORD ClassDescriptionSize,
1895         PDWORD RequiredSize,
1896         PCWSTR MachineName,
1897         PVOID Reserved)
1898 {
1899     HKEY hKey;
1900     DWORD dwLength;
1901     BOOL ret;
1902
1903     hKey = SetupDiOpenClassRegKeyExW(ClassGuid,
1904                                      KEY_ALL_ACCESS,
1905                                      DIOCR_INSTALLER,
1906                                      MachineName,
1907                                      Reserved);
1908     if (hKey == INVALID_HANDLE_VALUE)
1909     {
1910         WARN("SetupDiOpenClassRegKeyExW() failed (Error %u)\n", GetLastError());
1911         return FALSE;
1912     }
1913
1914     dwLength = ClassDescriptionSize * sizeof(WCHAR);
1915     ret = !RegQueryValueExW( hKey, NULL, NULL, NULL,
1916                              (LPBYTE)ClassDescription, &dwLength );
1917     if (RequiredSize) *RequiredSize = dwLength / sizeof(WCHAR);
1918     RegCloseKey(hKey);
1919     return ret;
1920 }
1921
1922 /***********************************************************************
1923  *              SetupDiGetClassDevsA (SETUPAPI.@)
1924  */
1925 HDEVINFO WINAPI SetupDiGetClassDevsA(
1926        CONST GUID *class,
1927        LPCSTR enumstr,
1928        HWND parent,
1929        DWORD flags)
1930 {
1931     HDEVINFO ret;
1932     LPWSTR enumstrW = NULL;
1933
1934     if (enumstr)
1935     {
1936         int len = MultiByteToWideChar(CP_ACP, 0, enumstr, -1, NULL, 0);
1937         enumstrW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1938         if (!enumstrW)
1939         {
1940             ret = INVALID_HANDLE_VALUE;
1941             goto end;
1942         }
1943         MultiByteToWideChar(CP_ACP, 0, enumstr, -1, enumstrW, len);
1944     }
1945     ret = SetupDiGetClassDevsExW(class, enumstrW, parent, flags, NULL, NULL,
1946             NULL);
1947     HeapFree(GetProcessHeap(), 0, enumstrW);
1948
1949 end:
1950     return ret;
1951 }
1952
1953 /***********************************************************************
1954  *                SetupDiGetClassDevsExA (SETUPAPI.@)
1955  */
1956 HDEVINFO WINAPI SetupDiGetClassDevsExA(
1957         const GUID *class,
1958         PCSTR enumstr,
1959         HWND parent,
1960         DWORD flags,
1961         HDEVINFO deviceset,
1962         PCSTR machine,
1963         PVOID reserved)
1964 {
1965     HDEVINFO ret;
1966     LPWSTR enumstrW = NULL, machineW = NULL;
1967
1968     if (enumstr)
1969     {
1970         int len = MultiByteToWideChar(CP_ACP, 0, enumstr, -1, NULL, 0);
1971         enumstrW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1972         if (!enumstrW)
1973         {
1974             ret = INVALID_HANDLE_VALUE;
1975             goto end;
1976         }
1977         MultiByteToWideChar(CP_ACP, 0, enumstr, -1, enumstrW, len);
1978     }
1979     if (machine)
1980     {
1981         int len = MultiByteToWideChar(CP_ACP, 0, machine, -1, NULL, 0);
1982         machineW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1983         if (!machineW)
1984         {
1985             HeapFree(GetProcessHeap(), 0, enumstrW);
1986             ret = INVALID_HANDLE_VALUE;
1987             goto end;
1988         }
1989         MultiByteToWideChar(CP_ACP, 0, machine, -1, machineW, len);
1990     }
1991     ret = SetupDiGetClassDevsExW(class, enumstrW, parent, flags, deviceset,
1992             machineW, reserved);
1993     HeapFree(GetProcessHeap(), 0, enumstrW);
1994     HeapFree(GetProcessHeap(), 0, machineW);
1995
1996 end:
1997     return ret;
1998 }
1999
2000 static void SETUPDI_AddDeviceInterfaces(SP_DEVINFO_DATA *dev, HKEY key,
2001         const GUID *guid)
2002 {
2003     DWORD i, len;
2004     WCHAR subKeyName[MAX_PATH];
2005     LONG l = ERROR_SUCCESS;
2006
2007     for (i = 0; !l; i++)
2008     {
2009         len = sizeof(subKeyName) / sizeof(subKeyName[0]);
2010         l = RegEnumKeyExW(key, i, subKeyName, &len, NULL, NULL, NULL, NULL);
2011         if (!l)
2012         {
2013             HKEY subKey;
2014             SP_DEVICE_INTERFACE_DATA *iface = NULL;
2015
2016             if (*subKeyName == '#')
2017             {
2018                 /* The subkey name is the reference string, with a '#' prepended */
2019                 SETUPDI_AddInterfaceInstance(dev, guid, subKeyName + 1, &iface);
2020                 l = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
2021                 if (!l)
2022                 {
2023                     WCHAR symbolicLink[MAX_PATH];
2024                     DWORD dataType;
2025
2026                     len = sizeof(symbolicLink);
2027                     l = RegQueryValueExW(subKey, SymbolicLink, NULL, &dataType,
2028                             (BYTE *)symbolicLink, &len);
2029                     if (!l && dataType == REG_SZ)
2030                         SETUPDI_SetInterfaceSymbolicLink(iface, symbolicLink);
2031                     RegCloseKey(subKey);
2032                 }
2033             }
2034             /* Allow enumeration to continue */
2035             l = ERROR_SUCCESS;
2036         }
2037     }
2038     /* FIXME: find and add all the device's interfaces to the device */
2039 }
2040
2041 static void SETUPDI_EnumerateMatchingInterfaces(HDEVINFO DeviceInfoSet,
2042         HKEY key, const GUID *guid, LPCWSTR enumstr)
2043 {
2044     struct DeviceInfoSet *set = DeviceInfoSet;
2045     DWORD i, len;
2046     WCHAR subKeyName[MAX_PATH];
2047     LONG l;
2048     HKEY enumKey = INVALID_HANDLE_VALUE;
2049
2050     TRACE("%s\n", debugstr_w(enumstr));
2051
2052     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_READ, NULL,
2053             &enumKey, NULL);
2054     for (i = 0; !l; i++)
2055     {
2056         len = sizeof(subKeyName) / sizeof(subKeyName[0]);
2057         l = RegEnumKeyExW(key, i, subKeyName, &len, NULL, NULL, NULL, NULL);
2058         if (!l)
2059         {
2060             HKEY subKey;
2061
2062             l = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
2063             if (!l)
2064             {
2065                 WCHAR deviceInst[MAX_PATH * 3];
2066                 DWORD dataType;
2067
2068                 len = sizeof(deviceInst);
2069                 l = RegQueryValueExW(subKey, DeviceInstance, NULL, &dataType,
2070                         (BYTE *)deviceInst, &len);
2071                 if (!l && dataType == REG_SZ)
2072                 {
2073                     TRACE("found instance ID %s\n", debugstr_w(deviceInst));
2074                     if (!enumstr || !lstrcmpiW(enumstr, deviceInst))
2075                     {
2076                         HKEY deviceKey;
2077
2078                         l = RegOpenKeyExW(enumKey, deviceInst, 0, KEY_READ,
2079                                 &deviceKey);
2080                         if (!l)
2081                         {
2082                             WCHAR deviceClassStr[40];
2083
2084                             len = sizeof(deviceClassStr);
2085                             l = RegQueryValueExW(deviceKey, ClassGUID, NULL,
2086                                     &dataType, (BYTE *)deviceClassStr, &len);
2087                             if (!l && dataType == REG_SZ &&
2088                                     deviceClassStr[0] == '{' &&
2089                                     deviceClassStr[37] == '}')
2090                             {
2091                                 GUID deviceClass;
2092                                 SP_DEVINFO_DATA *dev;
2093
2094                                 deviceClassStr[37] = 0;
2095                                 UuidFromStringW(&deviceClassStr[1],
2096                                         &deviceClass);
2097                                 if (SETUPDI_AddDeviceToSet(set, &deviceClass,
2098                                         0 /* FIXME: DevInst */, deviceInst,
2099                                         FALSE, &dev))
2100                                     SETUPDI_AddDeviceInterfaces(dev, subKey, guid);
2101                             }
2102                             RegCloseKey(deviceKey);
2103                         }
2104                     }
2105                 }
2106                 RegCloseKey(subKey);
2107             }
2108             /* Allow enumeration to continue */
2109             l = ERROR_SUCCESS;
2110         }
2111     }
2112     if (enumKey != INVALID_HANDLE_VALUE)
2113         RegCloseKey(enumKey);
2114 }
2115
2116 static void SETUPDI_EnumerateInterfaces(HDEVINFO DeviceInfoSet,
2117         const GUID *guid, LPCWSTR enumstr, DWORD flags)
2118 {
2119     HKEY interfacesKey = SetupDiOpenClassRegKeyExW(guid, KEY_READ,
2120             DIOCR_INTERFACE, NULL, NULL);
2121
2122     TRACE("%p, %s, %s, %08x\n", DeviceInfoSet, debugstr_guid(guid),
2123             debugstr_w(enumstr), flags);
2124
2125     if (interfacesKey != INVALID_HANDLE_VALUE)
2126     {
2127         if (flags & DIGCF_ALLCLASSES)
2128         {
2129             DWORD i, len;
2130             WCHAR interfaceGuidStr[40];
2131             LONG l = ERROR_SUCCESS;
2132
2133             for (i = 0; !l; i++)
2134             {
2135                 len = sizeof(interfaceGuidStr) / sizeof(interfaceGuidStr[0]);
2136                 l = RegEnumKeyExW(interfacesKey, i, interfaceGuidStr, &len,
2137                         NULL, NULL, NULL, NULL);
2138                 if (!l)
2139                 {
2140                     if (interfaceGuidStr[0] == '{' &&
2141                             interfaceGuidStr[37] == '}')
2142                     {
2143                         HKEY interfaceKey;
2144                         GUID interfaceGuid;
2145
2146                         interfaceGuidStr[37] = 0;
2147                         UuidFromStringW(&interfaceGuidStr[1], &interfaceGuid);
2148                         l = RegOpenKeyExW(interfacesKey, interfaceGuidStr, 0,
2149                                 KEY_READ, &interfaceKey);
2150                         if (!l)
2151                         {
2152                             SETUPDI_EnumerateMatchingInterfaces(DeviceInfoSet,
2153                                     interfaceKey, &interfaceGuid, enumstr);
2154                             RegCloseKey(interfaceKey);
2155                         }
2156                     }
2157                 }
2158             }
2159         }
2160         else
2161         {
2162             /* In this case, SetupDiOpenClassRegKeyExW opened the specific
2163              * interface's key, so just pass that long
2164              */
2165             SETUPDI_EnumerateMatchingInterfaces(DeviceInfoSet,
2166                     interfacesKey, guid, enumstr);
2167         }
2168         RegCloseKey(interfacesKey);
2169     }
2170 }
2171
2172 static void SETUPDI_EnumerateMatchingDeviceInstances(struct DeviceInfoSet *set,
2173         LPCWSTR enumerator, LPCWSTR deviceName, HKEY deviceKey,
2174         const GUID *class, DWORD flags)
2175 {
2176     DWORD i, len;
2177     WCHAR deviceInstance[MAX_PATH];
2178     LONG l = ERROR_SUCCESS;
2179
2180     TRACE("%s %s\n", debugstr_w(enumerator), debugstr_w(deviceName));
2181
2182     for (i = 0; !l; i++)
2183     {
2184         len = sizeof(deviceInstance) / sizeof(deviceInstance[0]);
2185         l = RegEnumKeyExW(deviceKey, i, deviceInstance, &len, NULL, NULL, NULL,
2186                 NULL);
2187         if (!l)
2188         {
2189             HKEY subKey;
2190
2191             l = RegOpenKeyExW(deviceKey, deviceInstance, 0, KEY_READ, &subKey);
2192             if (!l)
2193             {
2194                 WCHAR classGuid[40];
2195                 DWORD dataType;
2196
2197                 len = sizeof(classGuid);
2198                 l = RegQueryValueExW(subKey, ClassGUID, NULL, &dataType,
2199                         (BYTE *)classGuid, &len);
2200                 if (!l && dataType == REG_SZ)
2201                 {
2202                     if (classGuid[0] == '{' && classGuid[37] == '}')
2203                     {
2204                         GUID deviceClass;
2205
2206                         classGuid[37] = 0;
2207                         UuidFromStringW(&classGuid[1], &deviceClass);
2208                         if ((flags & DIGCF_ALLCLASSES) ||
2209                                 IsEqualGUID(class, &deviceClass))
2210                         {
2211                             static const WCHAR fmt[] =
2212                              {'%','s','\\','%','s','\\','%','s',0};
2213                             LPWSTR instanceId;
2214
2215                             instanceId = HeapAlloc(GetProcessHeap(), 0,
2216                                 (lstrlenW(enumerator) + lstrlenW(deviceName) +
2217                                 lstrlenW(deviceInstance) + 3) * sizeof(WCHAR));
2218                             if (instanceId)
2219                             {
2220                                 sprintfW(instanceId, fmt, enumerator,
2221                                         deviceName, deviceInstance);
2222                                 SETUPDI_AddDeviceToSet(set, &deviceClass,
2223                                         0 /* FIXME: DevInst */, instanceId,
2224                                         FALSE, NULL);
2225                                 HeapFree(GetProcessHeap(), 0, instanceId);
2226                             }
2227                         }
2228                     }
2229                 }
2230                 RegCloseKey(subKey);
2231             }
2232             /* Allow enumeration to continue */
2233             l = ERROR_SUCCESS;
2234         }
2235     }
2236 }
2237
2238 static void SETUPDI_EnumerateMatchingDevices(HDEVINFO DeviceInfoSet,
2239         LPCWSTR parent, HKEY key, const GUID *class, DWORD flags)
2240 {
2241     struct DeviceInfoSet *set = DeviceInfoSet;
2242     DWORD i, len;
2243     WCHAR subKeyName[MAX_PATH];
2244     LONG l = ERROR_SUCCESS;
2245
2246     TRACE("%s\n", debugstr_w(parent));
2247
2248     for (i = 0; !l; i++)
2249     {
2250         len = sizeof(subKeyName) / sizeof(subKeyName[0]);
2251         l = RegEnumKeyExW(key, i, subKeyName, &len, NULL, NULL, NULL, NULL);
2252         if (!l)
2253         {
2254             HKEY subKey;
2255
2256             l = RegOpenKeyExW(key, subKeyName, 0, KEY_READ, &subKey);
2257             if (!l)
2258             {
2259                 TRACE("%s\n", debugstr_w(subKeyName));
2260                 SETUPDI_EnumerateMatchingDeviceInstances(set, parent,
2261                         subKeyName, subKey, class, flags);
2262                 RegCloseKey(subKey);
2263             }
2264             /* Allow enumeration to continue */
2265             l = ERROR_SUCCESS;
2266         }
2267     }
2268 }
2269
2270 static void SETUPDI_EnumerateDevices(HDEVINFO DeviceInfoSet, const GUID *class,
2271         LPCWSTR enumstr, DWORD flags)
2272 {
2273     HKEY enumKey;
2274     LONG l;
2275
2276     TRACE("%p, %s, %s, %08x\n", DeviceInfoSet, debugstr_guid(class),
2277             debugstr_w(enumstr), flags);
2278
2279     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_READ, NULL,
2280             &enumKey, NULL);
2281     if (enumKey != INVALID_HANDLE_VALUE)
2282     {
2283         if (enumstr)
2284         {
2285             HKEY enumStrKey;
2286
2287             l = RegOpenKeyExW(enumKey, enumstr, 0, KEY_READ,
2288                     &enumStrKey);
2289             if (!l)
2290             {
2291                 SETUPDI_EnumerateMatchingDevices(DeviceInfoSet, enumstr,
2292                         enumStrKey, class, flags);
2293                 RegCloseKey(enumStrKey);
2294             }
2295         }
2296         else
2297         {
2298             DWORD i, len;
2299             WCHAR subKeyName[MAX_PATH];
2300
2301             l = ERROR_SUCCESS;
2302             for (i = 0; !l; i++)
2303             {
2304                 len = sizeof(subKeyName) / sizeof(subKeyName[0]);
2305                 l = RegEnumKeyExW(enumKey, i, subKeyName, &len, NULL,
2306                         NULL, NULL, NULL);
2307                 if (!l)
2308                 {
2309                     HKEY subKey;
2310
2311                     l = RegOpenKeyExW(enumKey, subKeyName, 0, KEY_READ,
2312                             &subKey);
2313                     if (!l)
2314                     {
2315                         SETUPDI_EnumerateMatchingDevices(DeviceInfoSet,
2316                                 subKeyName, subKey, class, flags);
2317                         RegCloseKey(subKey);
2318                     }
2319                     /* Allow enumeration to continue */
2320                     l = ERROR_SUCCESS;
2321                 }
2322             }
2323         }
2324         RegCloseKey(enumKey);
2325     }
2326 }
2327
2328 /***********************************************************************
2329  *              SetupDiGetClassDevsW (SETUPAPI.@)
2330  */
2331 HDEVINFO WINAPI SetupDiGetClassDevsW(
2332        CONST GUID *class,
2333        LPCWSTR enumstr,
2334        HWND parent,
2335        DWORD flags)
2336 {
2337     return SetupDiGetClassDevsExW(class, enumstr, parent, flags, NULL, NULL,
2338             NULL);
2339 }
2340
2341 /***********************************************************************
2342  *              SetupDiGetClassDevsExW (SETUPAPI.@)
2343  */
2344 HDEVINFO WINAPI SetupDiGetClassDevsExW(
2345         CONST GUID *class,
2346         PCWSTR enumstr,
2347         HWND parent,
2348         DWORD flags,
2349         HDEVINFO deviceset,
2350         PCWSTR machine,
2351         PVOID reserved)
2352 {
2353     static const DWORD unsupportedFlags = DIGCF_DEFAULT | DIGCF_PRESENT |
2354         DIGCF_PROFILE;
2355     HDEVINFO set;
2356
2357     TRACE("%s %s %p 0x%08x %p %s %p\n", debugstr_guid(class),
2358             debugstr_w(enumstr), parent, flags, deviceset, debugstr_w(machine),
2359             reserved);
2360
2361     if (!(flags & DIGCF_ALLCLASSES) && !class)
2362     {
2363         SetLastError(ERROR_INVALID_PARAMETER);
2364         return NULL;
2365     }
2366     if (flags & unsupportedFlags)
2367         WARN("unsupported flags %08x\n", flags & unsupportedFlags);
2368     if (deviceset)
2369         set = deviceset;
2370     else
2371         set = SetupDiCreateDeviceInfoListExW(class, parent, machine, reserved);
2372     if (set)
2373     {
2374         if (machine)
2375             FIXME("%s: unimplemented for remote machines\n",
2376                     debugstr_w(machine));
2377         else if (flags & DIGCF_DEVICEINTERFACE)
2378             SETUPDI_EnumerateInterfaces(set, class, enumstr, flags);
2379         else
2380             SETUPDI_EnumerateDevices(set, class, enumstr, flags);
2381     }
2382     return set;
2383 }
2384
2385 /***********************************************************************
2386  *              SetupDiGetDeviceInfoListDetailA  (SETUPAPI.@)
2387  */
2388 BOOL WINAPI SetupDiGetDeviceInfoListDetailA(
2389         HDEVINFO DeviceInfoSet,
2390         PSP_DEVINFO_LIST_DETAIL_DATA_A DevInfoData )
2391 {
2392     struct DeviceInfoSet *set = DeviceInfoSet;
2393
2394     TRACE("%p %p\n", DeviceInfoSet, DevInfoData);
2395
2396     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
2397     {
2398         SetLastError(ERROR_INVALID_HANDLE);
2399         return FALSE;
2400     }
2401     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2402     {
2403         SetLastError(ERROR_INVALID_HANDLE);
2404         return FALSE;
2405     }
2406     if (!DevInfoData ||
2407             DevInfoData->cbSize != sizeof(SP_DEVINFO_LIST_DETAIL_DATA_A))
2408     {
2409         SetLastError(ERROR_INVALID_PARAMETER);
2410         return FALSE;
2411     }
2412     DevInfoData->ClassGuid = set->ClassGuid;
2413     DevInfoData->RemoteMachineHandle = NULL;
2414     DevInfoData->RemoteMachineName[0] = '\0';
2415     return TRUE;
2416 }
2417
2418 /***********************************************************************
2419  *              SetupDiGetDeviceInfoListDetailW  (SETUPAPI.@)
2420  */
2421 BOOL WINAPI SetupDiGetDeviceInfoListDetailW(
2422         HDEVINFO DeviceInfoSet,
2423         PSP_DEVINFO_LIST_DETAIL_DATA_W DevInfoData )
2424 {
2425     struct DeviceInfoSet *set = DeviceInfoSet;
2426
2427     TRACE("%p %p\n", DeviceInfoSet, DevInfoData);
2428
2429     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
2430     {
2431         SetLastError(ERROR_INVALID_HANDLE);
2432         return FALSE;
2433     }
2434     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2435     {
2436         SetLastError(ERROR_INVALID_HANDLE);
2437         return FALSE;
2438     }
2439     if (!DevInfoData ||
2440             DevInfoData->cbSize != sizeof(SP_DEVINFO_LIST_DETAIL_DATA_W))
2441     {
2442         SetLastError(ERROR_INVALID_PARAMETER);
2443         return FALSE;
2444     }
2445     DevInfoData->ClassGuid = set->ClassGuid;
2446     DevInfoData->RemoteMachineHandle = NULL;
2447     DevInfoData->RemoteMachineName[0] = '\0';
2448     return TRUE;
2449 }
2450
2451 /***********************************************************************
2452  *              SetupDiCreateDeviceInterfaceA (SETUPAPI.@)
2453  */
2454 BOOL WINAPI SetupDiCreateDeviceInterfaceA(
2455         HDEVINFO DeviceInfoSet,
2456         PSP_DEVINFO_DATA DeviceInfoData,
2457         const GUID *InterfaceClassGuid,
2458         PCSTR ReferenceString,
2459         DWORD CreationFlags,
2460         PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
2461 {
2462     BOOL ret;
2463     LPWSTR ReferenceStringW = NULL;
2464
2465     TRACE("%p %p %s %s %08x %p\n", DeviceInfoSet, DeviceInfoData,
2466             debugstr_guid(InterfaceClassGuid), debugstr_a(ReferenceString),
2467             CreationFlags, DeviceInterfaceData);
2468
2469     if (ReferenceString)
2470     {
2471         ReferenceStringW = MultiByteToUnicode(ReferenceString, CP_ACP);
2472         if (ReferenceStringW == NULL) return FALSE;
2473     }
2474
2475     ret = SetupDiCreateDeviceInterfaceW(DeviceInfoSet, DeviceInfoData,
2476             InterfaceClassGuid, ReferenceStringW, CreationFlags,
2477             DeviceInterfaceData);
2478
2479     MyFree(ReferenceStringW);
2480
2481     return ret;
2482 }
2483
2484 /***********************************************************************
2485  *              SetupDiCreateDeviceInterfaceW (SETUPAPI.@)
2486  */
2487 BOOL WINAPI SetupDiCreateDeviceInterfaceW(
2488         HDEVINFO DeviceInfoSet,
2489         PSP_DEVINFO_DATA DeviceInfoData,
2490         const GUID *InterfaceClassGuid,
2491         PCWSTR ReferenceString,
2492         DWORD CreationFlags,
2493         PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
2494 {
2495     struct DeviceInfoSet *set = DeviceInfoSet;
2496     struct DeviceInfo *devInfo;
2497     SP_DEVICE_INTERFACE_DATA *iface = NULL;
2498     BOOL ret;
2499
2500     TRACE("%p %p %s %s %08x %p\n", DeviceInfoSet, DeviceInfoData,
2501             debugstr_guid(InterfaceClassGuid), debugstr_w(ReferenceString),
2502             CreationFlags, DeviceInterfaceData);
2503
2504     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
2505     {
2506         SetLastError(ERROR_INVALID_HANDLE);
2507         return FALSE;
2508     }
2509     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2510     {
2511         SetLastError(ERROR_INVALID_HANDLE);
2512         return FALSE;
2513     }
2514     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
2515             || !DeviceInfoData->Reserved)
2516     {
2517         SetLastError(ERROR_INVALID_PARAMETER);
2518         return FALSE;
2519     }
2520     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
2521     if (devInfo->set != set)
2522     {
2523         SetLastError(ERROR_INVALID_PARAMETER);
2524         return FALSE;
2525     }
2526     if (!InterfaceClassGuid)
2527     {
2528         SetLastError(ERROR_INVALID_USER_BUFFER);
2529         return FALSE;
2530     }
2531     if ((ret = SETUPDI_AddInterfaceInstance(DeviceInfoData, InterfaceClassGuid,
2532                     ReferenceString, &iface)))
2533     {
2534         if (DeviceInterfaceData)
2535         {
2536             if (DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
2537             {
2538                 SetLastError(ERROR_INVALID_USER_BUFFER);
2539                 ret = FALSE;
2540             }
2541             else
2542                 *DeviceInterfaceData = *iface;
2543         }
2544     }
2545     return ret;
2546 }
2547
2548 /***********************************************************************
2549  *              SetupDiCreateDeviceInterfaceRegKeyA (SETUPAPI.@)
2550  */
2551 HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyA(
2552         HDEVINFO DeviceInfoSet,
2553         PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2554         DWORD Reserved,
2555         REGSAM samDesired,
2556         HINF InfHandle,
2557         PCSTR InfSectionName)
2558 {
2559     HKEY key;
2560     PWSTR InfSectionNameW = NULL;
2561
2562     TRACE("%p %p %d %08x %p %p\n", DeviceInfoSet, DeviceInterfaceData, Reserved,
2563             samDesired, InfHandle, InfSectionName);
2564     if (InfHandle)
2565     {
2566         if (!InfSectionName)
2567         {
2568             SetLastError(ERROR_INVALID_PARAMETER);
2569             return INVALID_HANDLE_VALUE;
2570         }
2571         InfSectionNameW = MultiByteToUnicode(InfSectionName, CP_ACP);
2572         if (!InfSectionNameW)
2573             return INVALID_HANDLE_VALUE;
2574     }
2575     key = SetupDiCreateDeviceInterfaceRegKeyW(DeviceInfoSet,
2576             DeviceInterfaceData, Reserved, samDesired, InfHandle,
2577             InfSectionNameW);
2578     MyFree(InfSectionNameW);
2579     return key;
2580 }
2581
2582 static PWSTR SETUPDI_GetInstancePath(struct InterfaceInfo *ifaceInfo)
2583 {
2584     static const WCHAR hash[] = {'#',0};
2585     PWSTR instancePath = NULL;
2586
2587     if (ifaceInfo->referenceString)
2588     {
2589         instancePath = HeapAlloc(GetProcessHeap(), 0,
2590                 (lstrlenW(ifaceInfo->referenceString) + 2) * sizeof(WCHAR));
2591         if (instancePath)
2592         {
2593             lstrcpyW(instancePath, hash);
2594             lstrcatW(instancePath, ifaceInfo->referenceString);
2595         }
2596         else
2597             SetLastError(ERROR_OUTOFMEMORY);
2598     }
2599     else
2600     {
2601         instancePath = HeapAlloc(GetProcessHeap(), 0,
2602                 (lstrlenW(hash) + 1) * sizeof(WCHAR));
2603         if (instancePath)
2604             lstrcpyW(instancePath, hash);
2605     }
2606     return instancePath;
2607 }
2608
2609 /***********************************************************************
2610  *              SetupDiCreateDeviceInterfaceRegKeyW (SETUPAPI.@)
2611  */
2612 HKEY WINAPI SetupDiCreateDeviceInterfaceRegKeyW(
2613         HDEVINFO DeviceInfoSet,
2614         PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2615         DWORD Reserved,
2616         REGSAM samDesired,
2617         HINF InfHandle,
2618         PCWSTR InfSectionName)
2619 {
2620     struct DeviceInfoSet *set = DeviceInfoSet;
2621     HKEY key = INVALID_HANDLE_VALUE, interfacesKey;
2622     LONG l;
2623
2624     TRACE("%p %p %d %08x %p %p\n", DeviceInfoSet, DeviceInterfaceData, Reserved,
2625             samDesired, InfHandle, InfSectionName);
2626
2627     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2628             set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2629     {
2630         SetLastError(ERROR_INVALID_HANDLE);
2631         return INVALID_HANDLE_VALUE;
2632     }
2633     if (!DeviceInterfaceData ||
2634             DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2635             !DeviceInterfaceData->Reserved)
2636     {
2637         SetLastError(ERROR_INVALID_PARAMETER);
2638         return INVALID_HANDLE_VALUE;
2639     }
2640     if (InfHandle && !InfSectionName)
2641     {
2642         SetLastError(ERROR_INVALID_PARAMETER);
2643         return INVALID_HANDLE_VALUE;
2644     }
2645     if (!(l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, DeviceClasses, 0, NULL, 0,
2646                     samDesired, NULL, &interfacesKey, NULL)))
2647     {
2648         HKEY parent;
2649         WCHAR bracedGuidString[39];
2650
2651         SETUPDI_GuidToString(&DeviceInterfaceData->InterfaceClassGuid,
2652                 bracedGuidString);
2653         if (!(l = RegCreateKeyExW(interfacesKey, bracedGuidString, 0, NULL, 0,
2654                         samDesired, NULL, &parent, NULL)))
2655         {
2656             struct InterfaceInfo *ifaceInfo =
2657                 (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
2658             PWSTR instancePath = SETUPDI_GetInstancePath(ifaceInfo);
2659             PWSTR interfKeyName = HeapAlloc(GetProcessHeap(), 0,
2660                     (lstrlenW(ifaceInfo->symbolicLink) + 1) * sizeof(WCHAR));
2661             HKEY interfKey;
2662             WCHAR *ptr;
2663
2664             lstrcpyW(interfKeyName, ifaceInfo->symbolicLink);
2665             if (lstrlenW(ifaceInfo->symbolicLink) > 3)
2666             {
2667                 interfKeyName[0] = '#';
2668                 interfKeyName[1] = '#';
2669                 interfKeyName[3] = '#';
2670             }
2671             ptr = strchrW(interfKeyName, '\\');
2672             if (ptr)
2673                 *ptr = 0;
2674             l = RegCreateKeyExW(parent, interfKeyName, 0, NULL, 0,
2675                     samDesired, NULL, &interfKey, NULL);
2676             if (!l)
2677             {
2678                 struct DeviceInfo *devInfo =
2679                         (struct DeviceInfo *)ifaceInfo->device->Reserved;
2680
2681                 l = RegSetValueExW(interfKey, DeviceInstance, 0, REG_SZ,
2682                         (BYTE *)devInfo->instanceId,
2683                         (lstrlenW(devInfo->instanceId) + 1) * sizeof(WCHAR));
2684                 if (!l)
2685                 {
2686                     if (instancePath)
2687                     {
2688                         LONG l;
2689
2690                         l = RegCreateKeyExW(interfKey, instancePath, 0, NULL, 0,
2691                                 samDesired, NULL, &key, NULL);
2692                         if (l)
2693                         {
2694                             SetLastError(l);
2695                             key = INVALID_HANDLE_VALUE;
2696                         }
2697                         else if (InfHandle)
2698                             FIXME("INF section installation unsupported\n");
2699                     }
2700                 }
2701                 else
2702                     SetLastError(l);
2703                 RegCloseKey(interfKey);
2704             }
2705             else
2706                 SetLastError(l);
2707             HeapFree(GetProcessHeap(), 0, interfKeyName);
2708             HeapFree(GetProcessHeap(), 0, instancePath);
2709             RegCloseKey(parent);
2710         }
2711         else
2712             SetLastError(l);
2713         RegCloseKey(interfacesKey);
2714     }
2715     else
2716         SetLastError(l);
2717     return key;
2718 }
2719
2720 /***********************************************************************
2721  *              SetupDiDeleteDeviceInterfaceRegKey (SETUPAPI.@)
2722  */
2723 BOOL WINAPI SetupDiDeleteDeviceInterfaceRegKey(
2724         HDEVINFO DeviceInfoSet,
2725         PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2726         DWORD Reserved)
2727 {
2728     struct DeviceInfoSet *set = DeviceInfoSet;
2729     HKEY parent;
2730     BOOL ret = FALSE;
2731
2732     TRACE("%p %p %d\n", DeviceInfoSet, DeviceInterfaceData, Reserved);
2733
2734     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2735             set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2736     {
2737         SetLastError(ERROR_INVALID_HANDLE);
2738         return FALSE;
2739     }
2740     if (!DeviceInterfaceData ||
2741             DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2742             !DeviceInterfaceData->Reserved)
2743     {
2744         SetLastError(ERROR_INVALID_PARAMETER);
2745         return FALSE;
2746     }
2747     parent = SetupDiOpenClassRegKeyExW(&DeviceInterfaceData->InterfaceClassGuid,
2748             KEY_ALL_ACCESS, DIOCR_INTERFACE, NULL, NULL);
2749     if (parent != INVALID_HANDLE_VALUE)
2750     {
2751         struct InterfaceInfo *ifaceInfo =
2752             (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
2753         PWSTR instancePath = SETUPDI_GetInstancePath(ifaceInfo);
2754
2755         if (instancePath)
2756         {
2757             LONG l = RegDeleteKeyW(parent, instancePath);
2758
2759             if (l)
2760                 SetLastError(l);
2761             else
2762                 ret = TRUE;
2763             HeapFree(GetProcessHeap(), 0, instancePath);
2764         }
2765         RegCloseKey(parent);
2766     }
2767     return ret;
2768 }
2769
2770 /***********************************************************************
2771  *              SetupDiEnumDeviceInterfaces (SETUPAPI.@)
2772  *
2773  * PARAMS
2774  *   DeviceInfoSet      [I]    Set of devices from which to enumerate
2775  *                             interfaces
2776  *   DeviceInfoData     [I]    (Optional) If specified, a specific device
2777  *                             instance from which to enumerate interfaces.
2778  *                             If it isn't specified, all interfaces for all
2779  *                             devices in the set are enumerated.
2780  *   InterfaceClassGuid [I]    The interface class to enumerate.
2781  *   MemberIndex        [I]    An index of the interface instance to enumerate.
2782  *                             A caller should start with MemberIndex set to 0,
2783  *                             and continue until the function fails with
2784  *                             ERROR_NO_MORE_ITEMS.
2785  *   DeviceInterfaceData [I/O] Returns an enumerated interface.  Its cbSize
2786  *                             member must be set to
2787  *                             sizeof(SP_DEVICE_INTERFACE_DATA).
2788  *
2789  * RETURNS
2790  *   Success: non-zero value.
2791  *   Failure: FALSE.  Call GetLastError() for more info.
2792  */
2793 BOOL WINAPI SetupDiEnumDeviceInterfaces(
2794        HDEVINFO DeviceInfoSet,
2795        PSP_DEVINFO_DATA DeviceInfoData,
2796        CONST GUID * InterfaceClassGuid,
2797        DWORD MemberIndex,
2798        PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
2799 {
2800     struct DeviceInfoSet *set = DeviceInfoSet;
2801     BOOL ret = FALSE;
2802
2803     TRACE("%p, %p, %s, %d, %p\n", DeviceInfoSet, DeviceInfoData,
2804      debugstr_guid(InterfaceClassGuid), MemberIndex, DeviceInterfaceData);
2805
2806     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2807             set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2808     {
2809         SetLastError(ERROR_INVALID_HANDLE);
2810         return FALSE;
2811     }
2812     if (DeviceInfoData && (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA) ||
2813                 !DeviceInfoData->Reserved))
2814     {
2815         SetLastError(ERROR_INVALID_PARAMETER);
2816         return FALSE;
2817     }
2818     if (!DeviceInterfaceData ||
2819             DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
2820     {
2821         SetLastError(ERROR_INVALID_PARAMETER);
2822         return FALSE;
2823     }
2824     if (DeviceInfoData)
2825     {
2826         struct DeviceInfo *devInfo =
2827             (struct DeviceInfo *)DeviceInfoData->Reserved;
2828         struct InterfaceInstances *iface;
2829
2830         if ((ret = SETUPDI_FindInterface(devInfo, InterfaceClassGuid, &iface)))
2831         {
2832             if (MemberIndex < iface->cInstances)
2833                 *DeviceInterfaceData = iface->instances[MemberIndex];
2834             else
2835             {
2836                 SetLastError(ERROR_NO_MORE_ITEMS);
2837                 ret = FALSE;
2838             }
2839         }
2840         else
2841             SetLastError(ERROR_NO_MORE_ITEMS);
2842     }
2843     else
2844     {
2845         struct DeviceInstance *devInst;
2846         DWORD cEnumerated = 0;
2847         BOOL found = FALSE;
2848
2849         LIST_FOR_EACH_ENTRY(devInst, &set->devices, struct DeviceInstance, entry)
2850         {
2851             struct DeviceInfo *devInfo = (struct DeviceInfo *)devInst->data.Reserved;
2852             struct InterfaceInstances *iface;
2853
2854             if (found || cEnumerated >= MemberIndex + 1)
2855                 break;
2856             if (SETUPDI_FindInterface(devInfo, InterfaceClassGuid, &iface))
2857             {
2858                 if (cEnumerated + iface->cInstances < MemberIndex + 1)
2859                     cEnumerated += iface->cInstances;
2860                 else
2861                 {
2862                     DWORD instanceIndex = MemberIndex - cEnumerated;
2863
2864                     *DeviceInterfaceData = iface->instances[instanceIndex];
2865                     cEnumerated += instanceIndex + 1;
2866                     found = TRUE;
2867                     ret = TRUE;
2868                 }
2869             }
2870         }
2871         if (!found)
2872             SetLastError(ERROR_NO_MORE_ITEMS);
2873     }
2874     return ret;
2875 }
2876
2877 /***********************************************************************
2878  *              SetupDiDestroyDeviceInfoList (SETUPAPI.@)
2879   *
2880  * Destroy a DeviceInfoList and free all used memory of the list.
2881  *
2882  * PARAMS
2883  *   devinfo [I] DeviceInfoList pointer to list to destroy
2884  *
2885  * RETURNS
2886  *   Success: non zero value.
2887  *   Failure: zero value.
2888  */
2889 BOOL WINAPI SetupDiDestroyDeviceInfoList(HDEVINFO devinfo)
2890 {
2891     BOOL ret = FALSE;
2892
2893     TRACE("%p\n", devinfo);
2894     if (devinfo && devinfo != INVALID_HANDLE_VALUE)
2895     {
2896         struct DeviceInfoSet *list = devinfo;
2897
2898         if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC)
2899         {
2900             struct DeviceInstance *devInst, *devInst2;
2901
2902             LIST_FOR_EACH_ENTRY_SAFE(devInst, devInst2, &list->devices,
2903                     struct DeviceInstance, entry)
2904             {
2905                 SETUPDI_FreeDeviceInfo( (struct DeviceInfo *)devInst->data.Reserved );
2906                 list_remove(&devInst->entry);
2907                 HeapFree(GetProcessHeap(), 0, devInst);
2908             }
2909             HeapFree(GetProcessHeap(), 0, list);
2910             ret = TRUE;
2911         }
2912     }
2913
2914     if (ret == FALSE)
2915         SetLastError(ERROR_INVALID_HANDLE);
2916
2917     return ret;
2918 }
2919
2920 /***********************************************************************
2921  *              SetupDiGetDeviceInterfaceDetailA (SETUPAPI.@)
2922  */
2923 BOOL WINAPI SetupDiGetDeviceInterfaceDetailA(
2924       HDEVINFO DeviceInfoSet,
2925       PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2926       PSP_DEVICE_INTERFACE_DETAIL_DATA_A DeviceInterfaceDetailData,
2927       DWORD DeviceInterfaceDetailDataSize,
2928       PDWORD RequiredSize,
2929       PSP_DEVINFO_DATA DeviceInfoData)
2930 {
2931     struct DeviceInfoSet *set = DeviceInfoSet;
2932     struct InterfaceInfo *info;
2933     DWORD bytesNeeded = FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath[1]);
2934     BOOL ret = FALSE;
2935
2936     TRACE("(%p, %p, %p, %d, %p, %p)\n", DeviceInfoSet,
2937      DeviceInterfaceData, DeviceInterfaceDetailData,
2938      DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2939
2940     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2941             set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2942     {
2943         SetLastError(ERROR_INVALID_HANDLE);
2944         return FALSE;
2945     }
2946     if (!DeviceInterfaceData ||
2947             DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2948             !DeviceInterfaceData->Reserved)
2949     {
2950         SetLastError(ERROR_INVALID_PARAMETER);
2951         return FALSE;
2952     }
2953     if (DeviceInterfaceDetailData &&
2954         DeviceInterfaceDetailData->cbSize != sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A))
2955     {
2956         SetLastError(ERROR_INVALID_USER_BUFFER);
2957         return FALSE;
2958     }
2959     if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
2960     {
2961         SetLastError(ERROR_INVALID_USER_BUFFER);
2962         return FALSE;
2963     }
2964     info = (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
2965     if (info->symbolicLink)
2966         bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info->symbolicLink, -1,
2967                 NULL, 0, NULL, NULL);
2968     if (DeviceInterfaceDetailDataSize >= bytesNeeded)
2969     {
2970         if (info->symbolicLink)
2971             WideCharToMultiByte(CP_ACP, 0, info->symbolicLink, -1,
2972                     DeviceInterfaceDetailData->DevicePath,
2973                     DeviceInterfaceDetailDataSize -
2974                     offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath),
2975                     NULL, NULL);
2976         else
2977             DeviceInterfaceDetailData->DevicePath[0] = '\0';
2978         if (DeviceInfoData && DeviceInfoData->cbSize == sizeof(SP_DEVINFO_DATA))
2979             *DeviceInfoData = *info->device;
2980         ret = TRUE;
2981     }
2982     else
2983     {
2984         if (RequiredSize)
2985             *RequiredSize = bytesNeeded;
2986         SetLastError(ERROR_INSUFFICIENT_BUFFER);
2987     }
2988     return ret;
2989 }
2990
2991 /***********************************************************************
2992  *              SetupDiGetDeviceInterfaceDetailW (SETUPAPI.@)
2993  */
2994 BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(
2995       HDEVINFO DeviceInfoSet,
2996       PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2997       PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData,
2998       DWORD DeviceInterfaceDetailDataSize,
2999       PDWORD RequiredSize,
3000       PSP_DEVINFO_DATA DeviceInfoData)
3001 {
3002     struct DeviceInfoSet *set = DeviceInfoSet;
3003     struct InterfaceInfo *info;
3004     DWORD bytesNeeded = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)
3005         + sizeof(WCHAR); /* include NULL terminator */
3006     BOOL ret = FALSE;
3007
3008     TRACE("(%p, %p, %p, %d, %p, %p)\n", DeviceInfoSet,
3009      DeviceInterfaceData, DeviceInterfaceDetailData,
3010      DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
3011
3012     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
3013             set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3014     {
3015         SetLastError(ERROR_INVALID_HANDLE);
3016         return FALSE;
3017     }
3018     if (!DeviceInterfaceData ||
3019             DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
3020             !DeviceInterfaceData->Reserved)
3021     {
3022         SetLastError(ERROR_INVALID_PARAMETER);
3023         return FALSE;
3024     }
3025     if (DeviceInterfaceDetailData && (DeviceInterfaceDetailData->cbSize <
3026             offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath) + sizeof(WCHAR) ||
3027             DeviceInterfaceDetailData->cbSize > sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)))
3028     {
3029         SetLastError(ERROR_INVALID_USER_BUFFER);
3030         return FALSE;
3031     }
3032     if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
3033     {
3034         SetLastError(ERROR_INVALID_USER_BUFFER);
3035         return FALSE;
3036     }
3037     info = (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
3038     if (info->symbolicLink)
3039         bytesNeeded += sizeof(WCHAR)*lstrlenW(info->symbolicLink);
3040     if (DeviceInterfaceDetailDataSize >= bytesNeeded)
3041     {
3042         if (info->symbolicLink)
3043             lstrcpyW(DeviceInterfaceDetailData->DevicePath, info->symbolicLink);
3044         else
3045             DeviceInterfaceDetailData->DevicePath[0] = '\0';
3046         if (DeviceInfoData && DeviceInfoData->cbSize == sizeof(SP_DEVINFO_DATA))
3047             *DeviceInfoData = *info->device;
3048         ret = TRUE;
3049     }
3050     else
3051     {
3052         if (RequiredSize)
3053             *RequiredSize = bytesNeeded;
3054         SetLastError(ERROR_INSUFFICIENT_BUFFER);
3055     }
3056     return ret;
3057 }
3058
3059 struct PropertyMapEntry
3060 {
3061     DWORD   regType;
3062     LPCSTR  nameA;
3063     LPCWSTR nameW;
3064 };
3065
3066 static const struct PropertyMapEntry PropertyMap[] = {
3067     { REG_SZ, "DeviceDesc", DeviceDesc },
3068     { REG_MULTI_SZ, "HardwareId", HardwareId },
3069     { REG_MULTI_SZ, "CompatibleIDs", CompatibleIDs },
3070     { 0, NULL, NULL }, /* SPDRP_UNUSED0 */
3071     { REG_SZ, "Service", Service },
3072     { 0, NULL, NULL }, /* SPDRP_UNUSED1 */
3073     { 0, NULL, NULL }, /* SPDRP_UNUSED2 */
3074     { REG_SZ, "Class", Class },
3075     { REG_SZ, "ClassGUID", ClassGUID },
3076     { REG_SZ, "Driver", Driver },
3077     { REG_DWORD, "ConfigFlags", ConfigFlags },
3078     { REG_SZ, "Mfg", Mfg },
3079     { REG_SZ, "FriendlyName", FriendlyName },
3080     { REG_SZ, "LocationInformation", LocationInformation },
3081     { 0, NULL, NULL }, /* SPDRP_PHYSICAL_DEVICE_OBJECT_NAME */
3082     { REG_DWORD, "Capabilities", Capabilities },
3083     { REG_DWORD, "UINumber", UINumber },
3084     { REG_MULTI_SZ, "UpperFilters", UpperFilters },
3085     { REG_MULTI_SZ, "LowerFilters", LowerFilters },
3086 };
3087
3088 /***********************************************************************
3089  *              SetupDiGetDeviceRegistryPropertyA (SETUPAPI.@)
3090  */
3091 BOOL WINAPI SetupDiGetDeviceRegistryPropertyA(
3092         HDEVINFO  DeviceInfoSet,
3093         PSP_DEVINFO_DATA  DeviceInfoData,
3094         DWORD   Property,
3095         PDWORD  PropertyRegDataType,
3096         PBYTE   PropertyBuffer,
3097         DWORD   PropertyBufferSize,
3098         PDWORD  RequiredSize)
3099 {
3100     BOOL ret = FALSE;
3101     struct DeviceInfoSet *set = DeviceInfoSet;
3102     struct DeviceInfo *devInfo;
3103
3104     TRACE("%04x %p %d %p %p %d %p\n", (DWORD)DeviceInfoSet, DeviceInfoData,
3105         Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
3106         RequiredSize);
3107
3108     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3109     {
3110         SetLastError(ERROR_INVALID_HANDLE);
3111         return FALSE;
3112     }
3113     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3114     {
3115         SetLastError(ERROR_INVALID_HANDLE);
3116         return FALSE;
3117     }
3118     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3119             || !DeviceInfoData->Reserved)
3120     {
3121         SetLastError(ERROR_INVALID_PARAMETER);
3122         return FALSE;
3123     }
3124     if (PropertyBufferSize && PropertyBuffer == NULL)
3125     {
3126         SetLastError(ERROR_INVALID_DATA);
3127         return FALSE;
3128     }
3129     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3130     if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3131         && PropertyMap[Property].nameA)
3132     {
3133         DWORD size = PropertyBufferSize;
3134         LONG l = RegQueryValueExA(devInfo->key, PropertyMap[Property].nameA,
3135                 NULL, PropertyRegDataType, PropertyBuffer, &size);
3136
3137         if (l == ERROR_MORE_DATA || !PropertyBufferSize)
3138             SetLastError(ERROR_INSUFFICIENT_BUFFER);
3139         else if (!l)
3140             ret = TRUE;
3141         else
3142             SetLastError(l);
3143         if (RequiredSize)
3144             *RequiredSize = size;
3145     }
3146     return ret;
3147 }
3148
3149 /***********************************************************************
3150  *              SetupDiGetDeviceRegistryPropertyW (SETUPAPI.@)
3151  */
3152 BOOL WINAPI SetupDiGetDeviceRegistryPropertyW(
3153         HDEVINFO  DeviceInfoSet,
3154         PSP_DEVINFO_DATA  DeviceInfoData,
3155         DWORD   Property,
3156         PDWORD  PropertyRegDataType,
3157         PBYTE   PropertyBuffer,
3158         DWORD   PropertyBufferSize,
3159         PDWORD  RequiredSize)
3160 {
3161     BOOL ret = FALSE;
3162     struct DeviceInfoSet *set = DeviceInfoSet;
3163     struct DeviceInfo *devInfo;
3164
3165     TRACE("%04x %p %d %p %p %d %p\n", (DWORD)DeviceInfoSet, DeviceInfoData,
3166         Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
3167         RequiredSize);
3168
3169     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3170     {
3171         SetLastError(ERROR_INVALID_HANDLE);
3172         return FALSE;
3173     }
3174     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3175     {
3176         SetLastError(ERROR_INVALID_HANDLE);
3177         return FALSE;
3178     }
3179     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3180             || !DeviceInfoData->Reserved)
3181     {
3182         SetLastError(ERROR_INVALID_PARAMETER);
3183         return FALSE;
3184     }
3185     if (PropertyBufferSize && PropertyBuffer == NULL)
3186     {
3187         SetLastError(ERROR_INVALID_DATA);
3188         return FALSE;
3189     }
3190     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3191     if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3192         && PropertyMap[Property].nameW)
3193     {
3194         DWORD size = PropertyBufferSize;
3195         LONG l = RegQueryValueExW(devInfo->key, PropertyMap[Property].nameW,
3196                 NULL, PropertyRegDataType, PropertyBuffer, &size);
3197
3198         if (l == ERROR_MORE_DATA || !PropertyBufferSize)
3199             SetLastError(ERROR_INSUFFICIENT_BUFFER);
3200         else if (!l)
3201             ret = TRUE;
3202         else
3203             SetLastError(l);
3204         if (RequiredSize)
3205             *RequiredSize = size;
3206     }
3207     return ret;
3208 }
3209
3210 /***********************************************************************
3211  *              SetupDiSetDeviceRegistryPropertyA (SETUPAPI.@)
3212  */
3213 BOOL WINAPI SetupDiSetDeviceRegistryPropertyA(
3214         HDEVINFO DeviceInfoSet,
3215         PSP_DEVINFO_DATA DeviceInfoData,
3216         DWORD Property,
3217         const BYTE *PropertyBuffer,
3218         DWORD PropertyBufferSize)
3219 {
3220     BOOL ret = FALSE;
3221     struct DeviceInfoSet *set = DeviceInfoSet;
3222     struct DeviceInfo *devInfo;
3223
3224     TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
3225         PropertyBuffer, PropertyBufferSize);
3226
3227     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3228     {
3229         SetLastError(ERROR_INVALID_HANDLE);
3230         return FALSE;
3231     }
3232     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3233     {
3234         SetLastError(ERROR_INVALID_HANDLE);
3235         return FALSE;
3236     }
3237     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3238             || !DeviceInfoData->Reserved)
3239     {
3240         SetLastError(ERROR_INVALID_PARAMETER);
3241         return FALSE;
3242     }
3243     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3244     if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3245         && PropertyMap[Property].nameA)
3246     {
3247         LONG l = RegSetValueExA(devInfo->key, PropertyMap[Property].nameA, 0,
3248                 PropertyMap[Property].regType, PropertyBuffer,
3249                 PropertyBufferSize);
3250         if (!l)
3251             ret = TRUE;
3252         else
3253             SetLastError(l);
3254     }
3255     return ret;
3256 }
3257
3258 /***********************************************************************
3259  *              SetupDiSetDeviceRegistryPropertyW (SETUPAPI.@)
3260  */
3261 BOOL WINAPI SetupDiSetDeviceRegistryPropertyW(
3262         HDEVINFO DeviceInfoSet,
3263         PSP_DEVINFO_DATA DeviceInfoData,
3264         DWORD Property,
3265         const BYTE *PropertyBuffer,
3266         DWORD PropertyBufferSize)
3267 {
3268     BOOL ret = FALSE;
3269     struct DeviceInfoSet *set = DeviceInfoSet;
3270     struct DeviceInfo *devInfo;
3271
3272     TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
3273         PropertyBuffer, PropertyBufferSize);
3274
3275     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3276     {
3277         SetLastError(ERROR_INVALID_HANDLE);
3278         return FALSE;
3279     }
3280     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3281     {
3282         SetLastError(ERROR_INVALID_HANDLE);
3283         return FALSE;
3284     }
3285     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3286             || !DeviceInfoData->Reserved)
3287     {
3288         SetLastError(ERROR_INVALID_PARAMETER);
3289         return FALSE;
3290     }
3291     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3292     if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3293         && PropertyMap[Property].nameW)
3294     {
3295         LONG l = RegSetValueExW(devInfo->key, PropertyMap[Property].nameW, 0,
3296                 PropertyMap[Property].regType, PropertyBuffer,
3297                 PropertyBufferSize);
3298         if (!l)
3299             ret = TRUE;
3300         else
3301             SetLastError(l);
3302     }
3303     return ret;
3304 }
3305
3306 /***********************************************************************
3307  *              SetupDiInstallClassA (SETUPAPI.@)
3308  */
3309 BOOL WINAPI SetupDiInstallClassA(
3310         HWND hwndParent,
3311         PCSTR InfFileName,
3312         DWORD Flags,
3313         HSPFILEQ FileQueue)
3314 {
3315     UNICODE_STRING FileNameW;
3316     BOOL Result;
3317
3318     if (!InfFileName)
3319     {
3320         SetLastError(ERROR_INVALID_PARAMETER);
3321         return FALSE;
3322     }
3323     if (!RtlCreateUnicodeStringFromAsciiz(&FileNameW, InfFileName))
3324     {
3325         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3326         return FALSE;
3327     }
3328
3329     Result = SetupDiInstallClassW(hwndParent, FileNameW.Buffer, Flags, FileQueue);
3330
3331     RtlFreeUnicodeString(&FileNameW);
3332
3333     return Result;
3334 }
3335
3336 static HKEY CreateClassKey(HINF hInf)
3337 {
3338     static const WCHAR slash[] = { '\\',0 };
3339     WCHAR FullBuffer[MAX_PATH];
3340     WCHAR Buffer[MAX_PATH];
3341     DWORD RequiredSize;
3342     HKEY hClassKey;
3343
3344     if (!SetupGetLineTextW(NULL,
3345                            hInf,
3346                            Version,
3347                            ClassGUID,
3348                            Buffer,
3349                            MAX_PATH,
3350                            &RequiredSize))
3351     {
3352         return INVALID_HANDLE_VALUE;
3353     }
3354
3355     lstrcpyW(FullBuffer, ControlClass);
3356     lstrcatW(FullBuffer, slash);
3357     lstrcatW(FullBuffer, Buffer);
3358
3359     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3360                       FullBuffer,
3361                       0,
3362                       KEY_ALL_ACCESS,
3363                       &hClassKey))
3364     {
3365         if (!SetupGetLineTextW(NULL,
3366                                hInf,
3367                                Version,
3368                                Class,
3369                                Buffer,
3370                                MAX_PATH,
3371                                &RequiredSize))
3372         {
3373             return INVALID_HANDLE_VALUE;
3374         }
3375
3376         if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
3377                             FullBuffer,
3378                             0,
3379                             NULL,
3380                             REG_OPTION_NON_VOLATILE,
3381                             KEY_ALL_ACCESS,
3382                             NULL,
3383                             &hClassKey,
3384                             NULL))
3385         {
3386             return INVALID_HANDLE_VALUE;
3387         }
3388
3389     }
3390
3391     if (RegSetValueExW(hClassKey,
3392                        Class,
3393                        0,
3394                        REG_SZ,
3395                        (LPBYTE)Buffer,
3396                        RequiredSize * sizeof(WCHAR)))
3397     {
3398         RegCloseKey(hClassKey);
3399         RegDeleteKeyW(HKEY_LOCAL_MACHINE,
3400                       FullBuffer);
3401         return INVALID_HANDLE_VALUE;
3402     }
3403
3404     return hClassKey;
3405 }
3406
3407 /***********************************************************************
3408  *              SetupDiInstallClassW (SETUPAPI.@)
3409  */
3410 BOOL WINAPI SetupDiInstallClassW(
3411         HWND hwndParent,
3412         PCWSTR InfFileName,
3413         DWORD Flags,
3414         HSPFILEQ FileQueue)
3415 {
3416     WCHAR SectionName[MAX_PATH];
3417     DWORD SectionNameLength = 0;
3418     HINF hInf;
3419     BOOL bFileQueueCreated = FALSE;
3420     HKEY hClassKey;
3421
3422
3423     FIXME("\n");
3424
3425     if (!InfFileName)
3426     {
3427         SetLastError(ERROR_INVALID_PARAMETER);
3428         return FALSE;
3429     }
3430     if ((Flags & DI_NOVCP) && (FileQueue == NULL || FileQueue == INVALID_HANDLE_VALUE))
3431     {
3432         SetLastError(ERROR_INVALID_PARAMETER);
3433         return FALSE;
3434     }
3435
3436     /* Open the .inf file */
3437     hInf = SetupOpenInfFileW(InfFileName,
3438                              NULL,
3439                              INF_STYLE_WIN4,
3440                              NULL);
3441     if (hInf == INVALID_HANDLE_VALUE)
3442     {
3443
3444         return FALSE;
3445     }
3446
3447     /* Create or open the class registry key 'HKLM\\CurrentControlSet\\Class\\{GUID}' */
3448     hClassKey = CreateClassKey(hInf);
3449     if (hClassKey == INVALID_HANDLE_VALUE)
3450     {
3451         SetupCloseInfFile(hInf);
3452         return FALSE;
3453     }
3454
3455
3456     /* Try to append a layout file */
3457     SetupOpenAppendInfFileW(NULL, hInf, NULL);
3458
3459     /* Retrieve the actual section name */
3460     SetupDiGetActualSectionToInstallW(hInf,
3461                                       ClassInstall32,
3462                                       SectionName,
3463                                       MAX_PATH,
3464                                       &SectionNameLength,
3465                                       NULL);
3466
3467 #if 0
3468     if (!(Flags & DI_NOVCP))
3469     {
3470         FileQueue = SetupOpenFileQueue();
3471         if (FileQueue == INVALID_HANDLE_VALUE)
3472         {
3473             SetupCloseInfFile(hInf);
3474             return FALSE;
3475         }
3476
3477         bFileQueueCreated = TRUE;
3478
3479     }
3480 #endif
3481
3482     SetupInstallFromInfSectionW(NULL,
3483                                 hInf,
3484                                 SectionName,
3485                                 SPINST_COPYINF | SPINST_FILES | SPINST_REGISTRY,
3486                                 hClassKey,
3487                                 NULL,
3488                                 0,
3489                                 NULL,
3490                                 NULL,
3491                                 INVALID_HANDLE_VALUE,
3492                                 NULL);
3493
3494     /* FIXME: More code! */
3495
3496     if (bFileQueueCreated)
3497         SetupCloseFileQueue(FileQueue);
3498
3499     SetupCloseInfFile(hInf);
3500
3501     return TRUE;
3502 }
3503
3504
3505 /***********************************************************************
3506  *              SetupDiOpenClassRegKey  (SETUPAPI.@)
3507  */
3508 HKEY WINAPI SetupDiOpenClassRegKey(
3509         const GUID* ClassGuid,
3510         REGSAM samDesired)
3511 {
3512     return SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3513                                      DIOCR_INSTALLER, NULL, NULL);
3514 }
3515
3516
3517 /***********************************************************************
3518  *              SetupDiOpenClassRegKeyExA  (SETUPAPI.@)
3519  */
3520 HKEY WINAPI SetupDiOpenClassRegKeyExA(
3521         const GUID* ClassGuid,
3522         REGSAM samDesired,
3523         DWORD Flags,
3524         PCSTR MachineName,
3525         PVOID Reserved)
3526 {
3527     PWSTR MachineNameW = NULL;
3528     HKEY hKey;
3529
3530     TRACE("\n");
3531
3532     if (MachineName)
3533     {
3534         MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
3535         if (MachineNameW == NULL)
3536             return INVALID_HANDLE_VALUE;
3537     }
3538
3539     hKey = SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3540                                      Flags, MachineNameW, Reserved);
3541
3542     MyFree(MachineNameW);
3543
3544     return hKey;
3545 }
3546
3547
3548 /***********************************************************************
3549  *              SetupDiOpenClassRegKeyExW  (SETUPAPI.@)
3550  */
3551 HKEY WINAPI SetupDiOpenClassRegKeyExW(
3552         const GUID* ClassGuid,
3553         REGSAM samDesired,
3554         DWORD Flags,
3555         PCWSTR MachineName,
3556         PVOID Reserved)
3557 {
3558     HKEY hClassesKey;
3559     HKEY key;
3560     LPCWSTR lpKeyName;
3561     LONG l;
3562
3563     if (MachineName != NULL)
3564     {
3565         FIXME("Remote access not supported yet!\n");
3566         return INVALID_HANDLE_VALUE;
3567     }
3568
3569     if (Flags == DIOCR_INSTALLER)
3570     {
3571         lpKeyName = ControlClass;
3572     }
3573     else if (Flags == DIOCR_INTERFACE)
3574     {
3575         lpKeyName = DeviceClasses;
3576     }
3577     else
3578     {
3579         ERR("Invalid Flags parameter!\n");
3580         SetLastError(ERROR_INVALID_PARAMETER);
3581         return INVALID_HANDLE_VALUE;
3582     }
3583
3584     if (!ClassGuid)
3585     {
3586         if ((l = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3587                           lpKeyName,
3588                           0,
3589                           samDesired,
3590                           &hClassesKey)))
3591         {
3592             SetLastError(l);
3593             hClassesKey = INVALID_HANDLE_VALUE;
3594         }
3595         key = hClassesKey;
3596     }
3597     else
3598     {
3599         WCHAR bracedGuidString[39];
3600
3601         SETUPDI_GuidToString(ClassGuid, bracedGuidString);
3602
3603         if (!(l = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3604                           lpKeyName,
3605                           0,
3606                           samDesired,
3607                           &hClassesKey)))
3608         {
3609             if ((l = RegOpenKeyExW(hClassesKey,
3610                               bracedGuidString,
3611                               0,
3612                               samDesired,
3613                               &key)))
3614             {
3615                 SetLastError(l);
3616                 key = INVALID_HANDLE_VALUE;
3617             }
3618             RegCloseKey(hClassesKey);
3619         }
3620         else
3621         {
3622             SetLastError(l);
3623             key = INVALID_HANDLE_VALUE;
3624         }
3625     }
3626     return key;
3627 }
3628
3629 /***********************************************************************
3630  *              SetupDiOpenDeviceInterfaceW (SETUPAPI.@)
3631  */
3632 BOOL WINAPI SetupDiOpenDeviceInterfaceW(
3633        HDEVINFO DeviceInfoSet,
3634        PCWSTR DevicePath,
3635        DWORD OpenFlags,
3636        PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3637 {
3638     FIXME("%p %s %08x %p\n",
3639         DeviceInfoSet, debugstr_w(DevicePath), OpenFlags, DeviceInterfaceData);
3640     return FALSE;
3641 }
3642
3643 /***********************************************************************
3644  *              SetupDiOpenDeviceInterfaceA (SETUPAPI.@)
3645  */
3646 BOOL WINAPI SetupDiOpenDeviceInterfaceA(
3647        HDEVINFO DeviceInfoSet,
3648        PCSTR DevicePath,
3649        DWORD OpenFlags,
3650        PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3651 {
3652     FIXME("%p %s %08x %p\n", DeviceInfoSet,
3653         debugstr_a(DevicePath), OpenFlags, DeviceInterfaceData);
3654     return FALSE;
3655 }
3656
3657 /***********************************************************************
3658  *              SetupDiSetClassInstallParamsA (SETUPAPI.@)
3659  */
3660 BOOL WINAPI SetupDiSetClassInstallParamsA(
3661        HDEVINFO  DeviceInfoSet,
3662        PSP_DEVINFO_DATA DeviceInfoData,
3663        PSP_CLASSINSTALL_HEADER ClassInstallParams,
3664        DWORD ClassInstallParamsSize)
3665 {
3666     FIXME("%p %p %x %u\n",DeviceInfoSet, DeviceInfoData,
3667           ClassInstallParams->InstallFunction, ClassInstallParamsSize);
3668     return FALSE;
3669 }
3670
3671 /***********************************************************************
3672  *              SetupDiCallClassInstaller (SETUPAPI.@)
3673  */
3674 BOOL WINAPI SetupDiCallClassInstaller(
3675        DI_FUNCTION InstallFunction,
3676        HDEVINFO DeviceInfoSet,
3677        PSP_DEVINFO_DATA DeviceInfoData)
3678 {
3679     FIXME("%d %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
3680     return FALSE;
3681 }
3682
3683 /***********************************************************************
3684  *              SetupDiGetDeviceInstallParamsA (SETUPAPI.@)
3685  */
3686 BOOL WINAPI SetupDiGetDeviceInstallParamsA(
3687        HDEVINFO DeviceInfoSet,
3688        PSP_DEVINFO_DATA DeviceInfoData,
3689        PSP_DEVINSTALL_PARAMS_A DeviceInstallParams)
3690 {
3691     FIXME("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
3692     return FALSE;
3693 }
3694
3695 static HKEY SETUPDI_OpenDevKey(struct DeviceInfo *devInfo, REGSAM samDesired)
3696 {
3697     HKEY enumKey, key = INVALID_HANDLE_VALUE;
3698     LONG l;
3699
3700     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
3701             NULL, &enumKey, NULL);
3702     if (!l)
3703     {
3704         RegOpenKeyExW(enumKey, devInfo->instanceId, 0, samDesired, &key);
3705         RegCloseKey(enumKey);
3706     }
3707     return key;
3708 }
3709
3710 static HKEY SETUPDI_OpenDrvKey(struct DeviceInfo *devInfo, REGSAM samDesired)
3711 {
3712     static const WCHAR slash[] = { '\\',0 };
3713     WCHAR classKeyPath[MAX_PATH];
3714     HKEY classKey, key = INVALID_HANDLE_VALUE;
3715     LONG l;
3716
3717     lstrcpyW(classKeyPath, ControlClass);
3718     lstrcatW(classKeyPath, slash);
3719     SETUPDI_GuidToString(&devInfo->set->ClassGuid,
3720             classKeyPath + lstrlenW(classKeyPath));
3721     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
3722             KEY_ALL_ACCESS, NULL, &classKey, NULL);
3723     if (!l)
3724     {
3725         static const WCHAR fmt[] = { '%','0','4','u',0 };
3726         WCHAR devId[10];
3727
3728         sprintfW(devId, fmt, devInfo->devId);
3729         RegOpenKeyExW(classKey, devId, 0, samDesired, &key);
3730         RegCloseKey(classKey);
3731     }
3732     return key;
3733 }
3734
3735 /***********************************************************************
3736  *              SetupDiOpenDevRegKey (SETUPAPI.@)
3737  */
3738 HKEY WINAPI SetupDiOpenDevRegKey(
3739        HDEVINFO DeviceInfoSet,
3740        PSP_DEVINFO_DATA DeviceInfoData,
3741        DWORD Scope,
3742        DWORD HwProfile,
3743        DWORD KeyType,
3744        REGSAM samDesired)
3745 {
3746     struct DeviceInfoSet *set = DeviceInfoSet;
3747     struct DeviceInfo *devInfo;
3748     HKEY key = INVALID_HANDLE_VALUE;
3749
3750     TRACE("%p %p %d %d %d %x\n", DeviceInfoSet, DeviceInfoData,
3751           Scope, HwProfile, KeyType, samDesired);
3752
3753     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3754     {
3755         SetLastError(ERROR_INVALID_HANDLE);
3756         return INVALID_HANDLE_VALUE;
3757     }
3758     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3759     {
3760         SetLastError(ERROR_INVALID_HANDLE);
3761         return INVALID_HANDLE_VALUE;
3762     }
3763     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3764             || !DeviceInfoData->Reserved)
3765     {
3766         SetLastError(ERROR_INVALID_PARAMETER);
3767         return INVALID_HANDLE_VALUE;
3768     }
3769     if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
3770     {
3771         SetLastError(ERROR_INVALID_FLAGS);
3772         return INVALID_HANDLE_VALUE;
3773     }
3774     if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
3775     {
3776         SetLastError(ERROR_INVALID_FLAGS);
3777         return INVALID_HANDLE_VALUE;
3778     }
3779     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3780     if (devInfo->set != set)
3781     {
3782         SetLastError(ERROR_INVALID_PARAMETER);
3783         return INVALID_HANDLE_VALUE;
3784     }
3785     if (devInfo->phantom)
3786     {
3787         SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
3788         return INVALID_HANDLE_VALUE;
3789     }
3790     if (Scope != DICS_FLAG_GLOBAL)
3791         FIXME("unimplemented for scope %d\n", Scope);
3792     switch (KeyType)
3793     {
3794         case DIREG_DEV:
3795             key = SETUPDI_OpenDevKey(devInfo, samDesired);
3796             break;
3797         case DIREG_DRV:
3798             key = SETUPDI_OpenDrvKey(devInfo, samDesired);
3799             break;
3800         default:
3801             WARN("unknown KeyType %d\n", KeyType);
3802     }
3803     return key;
3804 }
3805
3806 static BOOL SETUPDI_DeleteDevKey(struct DeviceInfo *devInfo)
3807 {
3808     HKEY enumKey;
3809     BOOL ret = FALSE;
3810     LONG l;
3811
3812     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
3813             NULL, &enumKey, NULL);
3814     if (!l)
3815     {
3816         ret = RegDeleteTreeW(enumKey, devInfo->instanceId);
3817         RegCloseKey(enumKey);
3818     }
3819     else
3820         SetLastError(l);
3821     return ret;
3822 }
3823
3824 static BOOL SETUPDI_DeleteDrvKey(struct DeviceInfo *devInfo)
3825 {
3826     static const WCHAR slash[] = { '\\',0 };
3827     WCHAR classKeyPath[MAX_PATH];
3828     HKEY classKey;
3829     LONG l;
3830     BOOL ret = FALSE;
3831
3832     lstrcpyW(classKeyPath, ControlClass);
3833     lstrcatW(classKeyPath, slash);
3834     SETUPDI_GuidToString(&devInfo->set->ClassGuid,
3835             classKeyPath + lstrlenW(classKeyPath));
3836     l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
3837             KEY_ALL_ACCESS, NULL, &classKey, NULL);
3838     if (!l)
3839     {
3840         static const WCHAR fmt[] = { '%','0','4','u',0 };
3841         WCHAR devId[10];
3842
3843         sprintfW(devId, fmt, devInfo->devId);
3844         ret = RegDeleteTreeW(classKey, devId);
3845         RegCloseKey(classKey);
3846     }
3847     else
3848         SetLastError(l);
3849     return ret;
3850 }
3851
3852 /***********************************************************************
3853  *              SetupDiDeleteDevRegKey (SETUPAPI.@)
3854  */
3855 BOOL WINAPI SetupDiDeleteDevRegKey(
3856        HDEVINFO DeviceInfoSet,
3857        PSP_DEVINFO_DATA DeviceInfoData,
3858        DWORD Scope,
3859        DWORD HwProfile,
3860        DWORD KeyType)
3861 {
3862     struct DeviceInfoSet *set = DeviceInfoSet;
3863     struct DeviceInfo *devInfo;
3864     BOOL ret = FALSE;
3865
3866     TRACE("%p %p %d %d %d\n", DeviceInfoSet, DeviceInfoData, Scope, HwProfile,
3867             KeyType);
3868
3869     if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3870     {
3871         SetLastError(ERROR_INVALID_HANDLE);
3872         return FALSE;
3873     }
3874     if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3875     {
3876         SetLastError(ERROR_INVALID_HANDLE);
3877         return FALSE;
3878     }
3879     if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3880             || !DeviceInfoData->Reserved)
3881     {
3882         SetLastError(ERROR_INVALID_PARAMETER);
3883         return FALSE;
3884     }
3885     if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
3886     {
3887         SetLastError(ERROR_INVALID_FLAGS);
3888         return FALSE;
3889     }
3890     if (KeyType != DIREG_DEV && KeyType != DIREG_DRV && KeyType != DIREG_BOTH)
3891     {
3892         SetLastError(ERROR_INVALID_FLAGS);
3893         return FALSE;
3894     }
3895     devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3896     if (devInfo->set != set)
3897     {
3898         SetLastError(ERROR_INVALID_PARAMETER);
3899         return FALSE;
3900     }
3901     if (devInfo->phantom)
3902     {
3903         SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
3904         return FALSE;
3905     }
3906     if (Scope != DICS_FLAG_GLOBAL)
3907         FIXME("unimplemented for scope %d\n", Scope);
3908     switch (KeyType)
3909     {
3910         case DIREG_DEV:
3911             ret = SETUPDI_DeleteDevKey(devInfo);
3912             break;
3913         case DIREG_DRV:
3914             ret = SETUPDI_DeleteDrvKey(devInfo);
3915             break;
3916         case DIREG_BOTH:
3917             ret = SETUPDI_DeleteDevKey(devInfo);
3918             if (ret)
3919                 ret = SETUPDI_DeleteDrvKey(devInfo);
3920             break;
3921         default:
3922             WARN("unknown KeyType %d\n", KeyType);
3923     }
3924     return ret;
3925 }
3926
3927 /***********************************************************************
3928  *              CM_Get_Device_IDA  (SETUPAPI.@)
3929  */
3930 CONFIGRET WINAPI CM_Get_Device_IDA( DEVINST dnDevInst, PSTR Buffer,
3931                                    ULONG  BufferLen, ULONG  ulFlags)
3932 {
3933     struct DeviceInfo *devInfo = GlobalLock((HANDLE)dnDevInst);
3934
3935     TRACE("%x->%p, %p, %u %u\n", dnDevInst, devInfo, Buffer, BufferLen, ulFlags);
3936
3937     if (!devInfo)
3938         return CR_NO_SUCH_DEVINST;
3939
3940     WideCharToMultiByte(CP_ACP, 0, devInfo->instanceId, -1, Buffer, BufferLen, 0, 0);
3941     TRACE("Returning %s\n", debugstr_a(Buffer));
3942     return CR_SUCCESS;
3943 }
3944
3945 /***********************************************************************
3946  *              CM_Get_Device_IDW  (SETUPAPI.@)
3947  */
3948 CONFIGRET WINAPI CM_Get_Device_IDW( DEVINST dnDevInst, LPWSTR Buffer,
3949                                    ULONG  BufferLen, ULONG  ulFlags)
3950 {
3951     struct DeviceInfo *devInfo = GlobalLock((HANDLE)dnDevInst);
3952
3953     TRACE("%x->%p, %p, %u %u\n", dnDevInst, devInfo, Buffer, BufferLen, ulFlags);
3954
3955     if (!devInfo)
3956     {
3957         WARN("dev instance %d not found!\n", dnDevInst);
3958         return CR_NO_SUCH_DEVINST;
3959     }
3960
3961     lstrcpynW(Buffer, devInfo->instanceId, BufferLen);
3962     TRACE("Returning %s\n", debugstr_w(Buffer));
3963     GlobalUnlock((HANDLE)dnDevInst);
3964     return CR_SUCCESS;
3965 }
3966
3967
3968
3969 /***********************************************************************
3970  *              CM_Get_Device_ID_Size  (SETUPAPI.@)
3971  */
3972 CONFIGRET WINAPI CM_Get_Device_ID_Size( PULONG  pulLen, DEVINST dnDevInst,
3973                                         ULONG  ulFlags)
3974 {
3975     struct DeviceInfo *ppdevInfo = GlobalLock((HANDLE)dnDevInst);
3976
3977     TRACE("%x->%p, %p, %u\n", dnDevInst, ppdevInfo, pulLen, ulFlags);
3978
3979     if (!ppdevInfo)
3980     {
3981         WARN("dev instance %d not found!\n", dnDevInst);
3982         return CR_NO_SUCH_DEVINST;
3983     }
3984
3985     *pulLen = lstrlenW(ppdevInfo->instanceId);
3986     GlobalUnlock((HANDLE)dnDevInst);
3987     return CR_SUCCESS;
3988 }
3989
3990 /***********************************************************************
3991  *      SetupDiGetINFClassA (SETUPAPI.@)
3992  */
3993 BOOL WINAPI SetupDiGetINFClassA(PCSTR inf, LPGUID class_guid, PSTR class_name,
3994         DWORD size, PDWORD required_size)
3995 {
3996     BOOL retval;
3997     DWORD required_sizeA, required_sizeW;
3998     PWSTR class_nameW = NULL;
3999     UNICODE_STRING infW;
4000
4001     if (inf) RtlCreateUnicodeStringFromAsciiz(&infW, inf);
4002     else infW.Buffer = NULL;
4003     if (class_name && size)
4004         class_nameW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
4005
4006     retval = SetupDiGetINFClassW(infW.Buffer, class_guid, class_nameW, size, &required_sizeW);
4007
4008     if (retval)
4009     {
4010         required_sizeA = WideCharToMultiByte( CP_ACP, 0, class_nameW, required_sizeW,
4011                                               class_name, size, NULL, NULL);
4012
4013         if(required_size) *required_size = required_sizeA;
4014     }
4015     else
4016         if(required_size) *required_size = required_sizeW;
4017
4018     return retval;
4019 }
4020
4021 /***********************************************************************
4022  *              SetupDiGetINFClassW (SETUPAPI.@)
4023  */
4024 BOOL WINAPI SetupDiGetINFClassW(PCWSTR inf, LPGUID class_guid, PWSTR class_name,
4025         DWORD size, PDWORD required_size)
4026 {
4027     BOOL have_guid, have_name;
4028     DWORD dret;
4029     WCHAR buffer[MAX_PATH];
4030
4031     if (!inf)
4032     {
4033         SetLastError(ERROR_INVALID_PARAMETER);
4034         return FALSE;
4035     }
4036
4037     if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(inf))
4038     {
4039         FIXME("%s not found. Searching via DevicePath not implemented\n", debugstr_w(inf));
4040         SetLastError(ERROR_FILE_NOT_FOUND);
4041         return FALSE;
4042     }
4043
4044     if (!class_guid || !class_name || !size)
4045     {
4046         SetLastError(ERROR_INVALID_PARAMETER);
4047         return FALSE;
4048     }
4049
4050     if (!GetPrivateProfileStringW(Version, Signature, NULL, buffer, MAX_PATH, inf))
4051         return FALSE;
4052
4053     if (lstrcmpiW(buffer, Chicago))
4054         return FALSE;
4055
4056     buffer[0] = '\0';
4057     have_guid = 0 < GetPrivateProfileStringW(Version, ClassGUID, NULL, buffer, MAX_PATH, inf);
4058     if (have_guid)
4059     {
4060         buffer[lstrlenW(buffer)-1] = 0;
4061         if (RPC_S_OK != UuidFromStringW(buffer + 1, class_guid))
4062         {
4063             FIXME("failed to convert \"%s\" into a guid\n", debugstr_w(buffer));
4064             SetLastError(ERROR_INVALID_PARAMETER);
4065             return FALSE;
4066         }
4067     }
4068
4069     buffer[0] = '\0';
4070     dret = GetPrivateProfileStringW(Version, Class, NULL, buffer, MAX_PATH, inf);
4071     have_name = 0 < dret;
4072
4073     if (dret >= MAX_PATH -1) FIXME("buffer might be too small\n");
4074     if (have_guid && !have_name) FIXME("class name lookup via guid not implemented\n");
4075
4076     if (have_name)
4077     {
4078         if (dret < size) lstrcpyW(class_name, buffer);
4079         else
4080         {
4081             SetLastError(ERROR_INSUFFICIENT_BUFFER);
4082             have_name = FALSE;
4083         }
4084     }
4085
4086     if (required_size) *required_size = dret + ((dret) ? 1 : 0);
4087
4088     return (have_guid || have_name);
4089 }