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