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