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