?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hnetcfg: Improve the stub for INetFwServices::Item.
[wine/hacks.git] / dlls / setupapi / devinst.c
blob89e3cb6d3890ff4ed8bd7fddb3573da3f525ab23
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 = FIELD_OFFSET(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath[1]);
2920 BOOL ret = FALSE;
2921
2922 TRACE("(%p, %p, %p, %d, %p, %p)\n", DeviceInfoSet,
2923 DeviceInterfaceData, DeviceInterfaceDetailData,
2924 DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2925
2926 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2927 set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2928 {
2929 SetLastError(ERROR_INVALID_HANDLE);
2930 return FALSE;
2931 }
2932 if (!DeviceInterfaceData ||
2933 DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2934 !DeviceInterfaceData->Reserved)
2935 {
2936 SetLastError(ERROR_INVALID_PARAMETER);
2937 return FALSE;
2938 }
2939 if (DeviceInterfaceDetailData &&
2940 DeviceInterfaceDetailData->cbSize != sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_A))
2941 {
2942 SetLastError(ERROR_INVALID_USER_BUFFER);
2943 return FALSE;
2944 }
2945 if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
2946 {
2947 SetLastError(ERROR_INVALID_USER_BUFFER);
2948 return FALSE;
2949 }
2950 info = (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
2951 if (info->symbolicLink)
2952 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info->symbolicLink, -1,
2953 NULL, 0, NULL, NULL);
2954 if (DeviceInterfaceDetailDataSize >= bytesNeeded)
2955 {
2956 if (info->symbolicLink)
2957 WideCharToMultiByte(CP_ACP, 0, info->symbolicLink, -1,
2958 DeviceInterfaceDetailData->DevicePath,
2959 DeviceInterfaceDetailDataSize -
2960 offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath),
2961 NULL, NULL);
2962 else
2963 DeviceInterfaceDetailData->DevicePath[0] = '\0';
2964 if (DeviceInfoData && DeviceInfoData->cbSize == sizeof(SP_DEVINFO_DATA))
2965 *DeviceInfoData = *info->device;
2966 ret = TRUE;
2967 }
2968 else
2969 {
2970 if (RequiredSize)
2971 *RequiredSize = bytesNeeded;
2972 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2973 }
2974 return ret;
2975 }
2976
2977 /***********************************************************************
2978 * SetupDiGetDeviceInterfaceDetailW (SETUPAPI.@)
2979 */
2980 BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(
2981 HDEVINFO DeviceInfoSet,
2982 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2983 PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData,
2984 DWORD DeviceInterfaceDetailDataSize,
2985 PDWORD RequiredSize,
2986 PSP_DEVINFO_DATA DeviceInfoData)
2987 {
2988 struct DeviceInfoSet *set = DeviceInfoSet;
2989 struct InterfaceInfo *info;
2990 DWORD bytesNeeded = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)
2991 + sizeof(WCHAR); /* include NULL terminator */
2992 BOOL ret = FALSE;
2993
2994 TRACE("(%p, %p, %p, %d, %p, %p)\n", DeviceInfoSet,
2995 DeviceInterfaceData, DeviceInterfaceDetailData,
2996 DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2997
2998 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2999 set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3000 {
3001 SetLastError(ERROR_INVALID_HANDLE);
3002 return FALSE;
3003 }
3004 if (!DeviceInterfaceData ||
3005 DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
3006 !DeviceInterfaceData->Reserved)
3007 {
3008 SetLastError(ERROR_INVALID_PARAMETER);
3009 return FALSE;
3010 }
3011 if (DeviceInterfaceDetailData && (DeviceInterfaceDetailData->cbSize <
3012 offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath) + sizeof(WCHAR) ||
3013 DeviceInterfaceDetailData->cbSize > sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)))
3014 {
3015 SetLastError(ERROR_INVALID_USER_BUFFER);
3016 return FALSE;
3017 }
3018 if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
3019 {
3020 SetLastError(ERROR_INVALID_USER_BUFFER);
3021 return FALSE;
3022 }
3023 info = (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
3024 if (info->symbolicLink)
3025 bytesNeeded += sizeof(WCHAR)*lstrlenW(info->symbolicLink);
3026 if (DeviceInterfaceDetailDataSize >= bytesNeeded)
3027 {
3028 if (info->symbolicLink)
3029 lstrcpyW(DeviceInterfaceDetailData->DevicePath, info->symbolicLink);
3030 else
3031 DeviceInterfaceDetailData->DevicePath[0] = '\0';
3032 if (DeviceInfoData && DeviceInfoData->cbSize == sizeof(SP_DEVINFO_DATA))
3033 *DeviceInfoData = *info->device;
3034 ret = TRUE;
3035 }
3036 else
3037 {
3038 if (RequiredSize)
3039 *RequiredSize = bytesNeeded;
3040 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3041 }
3042 return ret;
3043 }
3044
3045 struct PropertyMapEntry
3046 {
3047 DWORD regType;
3048 LPCSTR nameA;
3049 LPCWSTR nameW;
3050 };
3051
3052 static const struct PropertyMapEntry PropertyMap[] = {
3053 { REG_SZ, "DeviceDesc", DeviceDesc },
3054 { REG_MULTI_SZ, "HardwareId", HardwareId },
3055 { REG_MULTI_SZ, "CompatibleIDs", CompatibleIDs },
3056 { 0, NULL, NULL }, /* SPDRP_UNUSED0 */
3057 { REG_SZ, "Service", Service },
3058 { 0, NULL, NULL }, /* SPDRP_UNUSED1 */
3059 { 0, NULL, NULL }, /* SPDRP_UNUSED2 */
3060 { REG_SZ, "Class", Class },
3061 { REG_SZ, "ClassGUID", ClassGUID },
3062 { REG_SZ, "Driver", Driver },
3063 { REG_DWORD, "ConfigFlags", ConfigFlags },
3064 { REG_SZ, "Mfg", Mfg },
3065 { REG_SZ, "FriendlyName", FriendlyName },
3066 { REG_SZ, "LocationInformation", LocationInformation },
3067 { 0, NULL, NULL }, /* SPDRP_PHYSICAL_DEVICE_OBJECT_NAME */
3068 { REG_DWORD, "Capabilities", Capabilities },
3069 { REG_DWORD, "UINumber", UINumber },
3070 { REG_MULTI_SZ, "UpperFilters", UpperFilters },
3071 { REG_MULTI_SZ, "LowerFilters", LowerFilters },
3072 };
3073
3074 /***********************************************************************
3075 * SetupDiGetDeviceRegistryPropertyA (SETUPAPI.@)
3076 */
3077 BOOL WINAPI SetupDiGetDeviceRegistryPropertyA(
3078 HDEVINFO DeviceInfoSet,
3079 PSP_DEVINFO_DATA DeviceInfoData,
3080 DWORD Property,
3081 PDWORD PropertyRegDataType,
3082 PBYTE PropertyBuffer,
3083 DWORD PropertyBufferSize,
3084 PDWORD RequiredSize)
3085 {
3086 BOOL ret = FALSE;
3087 struct DeviceInfoSet *set = DeviceInfoSet;
3088 struct DeviceInfo *devInfo;
3089
3090 TRACE("%04x %p %d %p %p %d %p\n", (DWORD)DeviceInfoSet, DeviceInfoData,
3091 Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
3092 RequiredSize);
3093
3094 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3095 {
3096 SetLastError(ERROR_INVALID_HANDLE);
3097 return FALSE;
3098 }
3099 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3100 {
3101 SetLastError(ERROR_INVALID_HANDLE);
3102 return FALSE;
3103 }
3104 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3105 || !DeviceInfoData->Reserved)
3106 {
3107 SetLastError(ERROR_INVALID_PARAMETER);
3108 return FALSE;
3109 }
3110 if (PropertyBufferSize && PropertyBuffer == NULL)
3111 {
3112 SetLastError(ERROR_INVALID_DATA);
3113 return FALSE;
3114 }
3115 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3116 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3117 && PropertyMap[Property].nameA)
3118 {
3119 DWORD size = PropertyBufferSize;
3120 LONG l = RegQueryValueExA(devInfo->key, PropertyMap[Property].nameA,
3121 NULL, PropertyRegDataType, PropertyBuffer, &size);
3122
3123 if (l == ERROR_MORE_DATA || !PropertyBufferSize)
3124 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3125 else if (!l)
3126 ret = TRUE;
3127 else
3128 SetLastError(l);
3129 if (RequiredSize)
3130 *RequiredSize = size;
3131 }
3132 return ret;
3133 }
3134
3135 /***********************************************************************
3136 * SetupDiGetDeviceRegistryPropertyW (SETUPAPI.@)
3137 */
3138 BOOL WINAPI SetupDiGetDeviceRegistryPropertyW(
3139 HDEVINFO DeviceInfoSet,
3140 PSP_DEVINFO_DATA DeviceInfoData,
3141 DWORD Property,
3142 PDWORD PropertyRegDataType,
3143 PBYTE PropertyBuffer,
3144 DWORD PropertyBufferSize,
3145 PDWORD RequiredSize)
3146 {
3147 BOOL ret = FALSE;
3148 struct DeviceInfoSet *set = DeviceInfoSet;
3149 struct DeviceInfo *devInfo;
3150
3151 TRACE("%04x %p %d %p %p %d %p\n", (DWORD)DeviceInfoSet, DeviceInfoData,
3152 Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
3153 RequiredSize);
3154
3155 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3156 {
3157 SetLastError(ERROR_INVALID_HANDLE);
3158 return FALSE;
3159 }
3160 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3161 {
3162 SetLastError(ERROR_INVALID_HANDLE);
3163 return FALSE;
3164 }
3165 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3166 || !DeviceInfoData->Reserved)
3167 {
3168 SetLastError(ERROR_INVALID_PARAMETER);
3169 return FALSE;
3170 }
3171 if (PropertyBufferSize && PropertyBuffer == NULL)
3172 {
3173 SetLastError(ERROR_INVALID_DATA);
3174 return FALSE;
3175 }
3176 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3177 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3178 && PropertyMap[Property].nameW)
3179 {
3180 DWORD size = PropertyBufferSize;
3181 LONG l = RegQueryValueExW(devInfo->key, PropertyMap[Property].nameW,
3182 NULL, PropertyRegDataType, PropertyBuffer, &size);
3183
3184 if (l == ERROR_MORE_DATA || !PropertyBufferSize)
3185 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3186 else if (!l)
3187 ret = TRUE;
3188 else
3189 SetLastError(l);
3190 if (RequiredSize)
3191 *RequiredSize = size;
3192 }
3193 return ret;
3194 }
3195
3196 /***********************************************************************
3197 * SetupDiSetDeviceRegistryPropertyA (SETUPAPI.@)
3198 */
3199 BOOL WINAPI SetupDiSetDeviceRegistryPropertyA(
3200 HDEVINFO DeviceInfoSet,
3201 PSP_DEVINFO_DATA DeviceInfoData,
3202 DWORD Property,
3203 const BYTE *PropertyBuffer,
3204 DWORD PropertyBufferSize)
3205 {
3206 BOOL ret = FALSE;
3207 struct DeviceInfoSet *set = DeviceInfoSet;
3208 struct DeviceInfo *devInfo;
3209
3210 TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
3211 PropertyBuffer, PropertyBufferSize);
3212
3213 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3214 {
3215 SetLastError(ERROR_INVALID_HANDLE);
3216 return FALSE;
3217 }
3218 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3219 {
3220 SetLastError(ERROR_INVALID_HANDLE);
3221 return FALSE;
3222 }
3223 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3224 || !DeviceInfoData->Reserved)
3225 {
3226 SetLastError(ERROR_INVALID_PARAMETER);
3227 return FALSE;
3228 }
3229 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3230 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3231 && PropertyMap[Property].nameA)
3232 {
3233 LONG l = RegSetValueExA(devInfo->key, PropertyMap[Property].nameA, 0,
3234 PropertyMap[Property].regType, PropertyBuffer,
3235 PropertyBufferSize);
3236 if (!l)
3237 ret = TRUE;
3238 else
3239 SetLastError(l);
3240 }
3241 return ret;
3242 }
3243
3244 /***********************************************************************
3245 * SetupDiSetDeviceRegistryPropertyW (SETUPAPI.@)
3246 */
3247 BOOL WINAPI SetupDiSetDeviceRegistryPropertyW(
3248 HDEVINFO DeviceInfoSet,
3249 PSP_DEVINFO_DATA DeviceInfoData,
3250 DWORD Property,
3251 const BYTE *PropertyBuffer,
3252 DWORD PropertyBufferSize)
3253 {
3254 BOOL ret = FALSE;
3255 struct DeviceInfoSet *set = DeviceInfoSet;
3256 struct DeviceInfo *devInfo;
3257
3258 TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
3259 PropertyBuffer, PropertyBufferSize);
3260
3261 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3262 {
3263 SetLastError(ERROR_INVALID_HANDLE);
3264 return FALSE;
3265 }
3266 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3267 {
3268 SetLastError(ERROR_INVALID_HANDLE);
3269 return FALSE;
3270 }
3271 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3272 || !DeviceInfoData->Reserved)
3273 {
3274 SetLastError(ERROR_INVALID_PARAMETER);
3275 return FALSE;
3276 }
3277 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3278 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3279 && PropertyMap[Property].nameW)
3280 {
3281 LONG l = RegSetValueExW(devInfo->key, PropertyMap[Property].nameW, 0,
3282 PropertyMap[Property].regType, PropertyBuffer,
3283 PropertyBufferSize);
3284 if (!l)
3285 ret = TRUE;
3286 else
3287 SetLastError(l);
3288 }
3289 return ret;
3290 }
3291
3292 /***********************************************************************
3293 * SetupDiInstallClassA (SETUPAPI.@)
3294 */
3295 BOOL WINAPI SetupDiInstallClassA(
3296 HWND hwndParent,
3297 PCSTR InfFileName,
3298 DWORD Flags,
3299 HSPFILEQ FileQueue)
3300 {
3301 UNICODE_STRING FileNameW;
3302 BOOL Result;
3303
3304 if (!InfFileName)
3305 {
3306 SetLastError(ERROR_INVALID_PARAMETER);
3307 return FALSE;
3308 }
3309 if (!RtlCreateUnicodeStringFromAsciiz(&FileNameW, InfFileName))
3310 {
3311 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3312 return FALSE;
3313 }
3314
3315 Result = SetupDiInstallClassW(hwndParent, FileNameW.Buffer, Flags, FileQueue);
3316
3317 RtlFreeUnicodeString(&FileNameW);
3318
3319 return Result;
3320 }
3321
3322 static HKEY CreateClassKey(HINF hInf)
3323 {
3324 static const WCHAR slash[] = { '\\',0 };
3325 WCHAR FullBuffer[MAX_PATH];
3326 WCHAR Buffer[MAX_PATH];
3327 DWORD RequiredSize;
3328 HKEY hClassKey;
3329
3330 if (!SetupGetLineTextW(NULL,
3331 hInf,
3332 Version,
3333 ClassGUID,
3334 Buffer,
3335 MAX_PATH,
3336 &RequiredSize))
3337 {
3338 return INVALID_HANDLE_VALUE;
3339 }
3340
3341 lstrcpyW(FullBuffer, ControlClass);
3342 lstrcatW(FullBuffer, slash);
3343 lstrcatW(FullBuffer, Buffer);
3344
3345 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3346 FullBuffer,
3347 0,
3348 KEY_ALL_ACCESS,
3349 &hClassKey))
3350 {
3351 if (!SetupGetLineTextW(NULL,
3352 hInf,
3353 Version,
3354 Class,
3355 Buffer,
3356 MAX_PATH,
3357 &RequiredSize))
3358 {
3359 return INVALID_HANDLE_VALUE;
3360 }
3361
3362 if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
3363 FullBuffer,
3364 0,
3365 NULL,
3366 REG_OPTION_NON_VOLATILE,
3367 KEY_ALL_ACCESS,
3368 NULL,
3369 &hClassKey,
3370 NULL))
3371 {
3372 return INVALID_HANDLE_VALUE;
3373 }
3374
3375 }
3376
3377 if (RegSetValueExW(hClassKey,
3378 Class,
3379 0,
3380 REG_SZ,
3381 (LPBYTE)Buffer,
3382 RequiredSize * sizeof(WCHAR)))
3383 {
3384 RegCloseKey(hClassKey);
3385 RegDeleteKeyW(HKEY_LOCAL_MACHINE,
3386 FullBuffer);
3387 return INVALID_HANDLE_VALUE;
3388 }
3389
3390 return hClassKey;
3391 }
3392
3393 /***********************************************************************
3394 * SetupDiInstallClassW (SETUPAPI.@)
3395 */
3396 BOOL WINAPI SetupDiInstallClassW(
3397 HWND hwndParent,
3398 PCWSTR InfFileName,
3399 DWORD Flags,
3400 HSPFILEQ FileQueue)
3401 {
3402 WCHAR SectionName[MAX_PATH];
3403 DWORD SectionNameLength = 0;
3404 HINF hInf;
3405 BOOL bFileQueueCreated = FALSE;
3406 HKEY hClassKey;
3407
3408
3409 FIXME("\n");
3410
3411 if (!InfFileName)
3412 {
3413 SetLastError(ERROR_INVALID_PARAMETER);
3414 return FALSE;
3415 }
3416 if ((Flags & DI_NOVCP) && (FileQueue == NULL || FileQueue == INVALID_HANDLE_VALUE))
3417 {
3418 SetLastError(ERROR_INVALID_PARAMETER);
3419 return FALSE;
3420 }
3421
3422 /* Open the .inf file */
3423 hInf = SetupOpenInfFileW(InfFileName,
3424 NULL,
3425 INF_STYLE_WIN4,
3426 NULL);
3427 if (hInf == INVALID_HANDLE_VALUE)
3428 {
3429
3430 return FALSE;
3431 }
3432
3433 /* Create or open the class registry key 'HKLM\\CurrentControlSet\\Class\\{GUID}' */
3434 hClassKey = CreateClassKey(hInf);
3435 if (hClassKey == INVALID_HANDLE_VALUE)
3436 {
3437 SetupCloseInfFile(hInf);
3438 return FALSE;
3439 }
3440
3441
3442 /* Try to append a layout file */
3443 SetupOpenAppendInfFileW(NULL, hInf, NULL);
3444
3445 /* Retrieve the actual section name */
3446 SetupDiGetActualSectionToInstallW(hInf,
3447 ClassInstall32,
3448 SectionName,
3449 MAX_PATH,
3450 &SectionNameLength,
3451 NULL);
3452
3453 #if 0
3454 if (!(Flags & DI_NOVCP))
3455 {
3456 FileQueue = SetupOpenFileQueue();
3457 if (FileQueue == INVALID_HANDLE_VALUE)
3458 {
3459 SetupCloseInfFile(hInf);
3460 return FALSE;
3461 }
3462
3463 bFileQueueCreated = TRUE;
3464
3465 }
3466 #endif
3467
3468 SetupInstallFromInfSectionW(NULL,
3469 hInf,
3470 SectionName,
3471 SPINST_COPYINF | SPINST_FILES | SPINST_REGISTRY,
3472 hClassKey,
3473 NULL,
3474 0,
3475 NULL,
3476 NULL,
3477 INVALID_HANDLE_VALUE,
3478 NULL);
3479
3480 /* FIXME: More code! */
3481
3482 if (bFileQueueCreated)
3483 SetupCloseFileQueue(FileQueue);
3484
3485 SetupCloseInfFile(hInf);
3486
3487 return TRUE;
3488 }
3489
3490
3491 /***********************************************************************
3492 * SetupDiOpenClassRegKey (SETUPAPI.@)
3493 */
3494 HKEY WINAPI SetupDiOpenClassRegKey(
3495 const GUID* ClassGuid,
3496 REGSAM samDesired)
3497 {
3498 return SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3499 DIOCR_INSTALLER, NULL, NULL);
3500 }
3501
3502
3503 /***********************************************************************
3504 * SetupDiOpenClassRegKeyExA (SETUPAPI.@)
3505 */
3506 HKEY WINAPI SetupDiOpenClassRegKeyExA(
3507 const GUID* ClassGuid,
3508 REGSAM samDesired,
3509 DWORD Flags,
3510 PCSTR MachineName,
3511 PVOID Reserved)
3512 {
3513 PWSTR MachineNameW = NULL;
3514 HKEY hKey;
3515
3516 TRACE("\n");
3517
3518 if (MachineName)
3519 {
3520 MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
3521 if (MachineNameW == NULL)
3522 return INVALID_HANDLE_VALUE;
3523 }
3524
3525 hKey = SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3526 Flags, MachineNameW, Reserved);
3527
3528 MyFree(MachineNameW);
3529
3530 return hKey;
3531 }
3532
3533
3534 /***********************************************************************
3535 * SetupDiOpenClassRegKeyExW (SETUPAPI.@)
3536 */
3537 HKEY WINAPI SetupDiOpenClassRegKeyExW(
3538 const GUID* ClassGuid,
3539 REGSAM samDesired,
3540 DWORD Flags,
3541 PCWSTR MachineName,
3542 PVOID Reserved)
3543 {
3544 HKEY hClassesKey;
3545 HKEY key;
3546 LPCWSTR lpKeyName;
3547 LONG l;
3548
3549 if (MachineName != NULL)
3550 {
3551 FIXME("Remote access not supported yet!\n");
3552 return INVALID_HANDLE_VALUE;
3553 }
3554
3555 if (Flags == DIOCR_INSTALLER)
3556 {
3557 lpKeyName = ControlClass;
3558 }
3559 else if (Flags == DIOCR_INTERFACE)
3560 {
3561 lpKeyName = DeviceClasses;
3562 }
3563 else
3564 {
3565 ERR("Invalid Flags parameter!\n");
3566 SetLastError(ERROR_INVALID_PARAMETER);
3567 return INVALID_HANDLE_VALUE;
3568 }
3569
3570 if (!ClassGuid)
3571 {
3572 if ((l = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3573 lpKeyName,
3574 0,
3575 samDesired,
3576 &hClassesKey)))
3577 {
3578 SetLastError(l);
3579 hClassesKey = INVALID_HANDLE_VALUE;
3580 }
3581 key = hClassesKey;
3582 }
3583 else
3584 {
3585 WCHAR bracedGuidString[39];
3586
3587 SETUPDI_GuidToString(ClassGuid, bracedGuidString);
3588
3589 if (!(l = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3590 lpKeyName,
3591 0,
3592 samDesired,
3593 &hClassesKey)))
3594 {
3595 if ((l = RegOpenKeyExW(hClassesKey,
3596 bracedGuidString,
3597 0,
3598 samDesired,
3599 &key)))
3600 {
3601 SetLastError(l);
3602 key = INVALID_HANDLE_VALUE;
3603 }
3604 RegCloseKey(hClassesKey);
3605 }
3606 else
3607 {
3608 SetLastError(l);
3609 key = INVALID_HANDLE_VALUE;
3610 }
3611 }
3612 return key;
3613 }
3614
3615 /***********************************************************************
3616 * SetupDiOpenDeviceInterfaceW (SETUPAPI.@)
3617 */
3618 BOOL WINAPI SetupDiOpenDeviceInterfaceW(
3619 HDEVINFO DeviceInfoSet,
3620 PCWSTR DevicePath,
3621 DWORD OpenFlags,
3622 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3623 {
3624 FIXME("%p %s %08x %p\n",
3625 DeviceInfoSet, debugstr_w(DevicePath), OpenFlags, DeviceInterfaceData);
3626 return FALSE;
3627 }
3628
3629 /***********************************************************************
3630 * SetupDiOpenDeviceInterfaceA (SETUPAPI.@)
3631 */
3632 BOOL WINAPI SetupDiOpenDeviceInterfaceA(
3633 HDEVINFO DeviceInfoSet,
3634 PCSTR DevicePath,
3635 DWORD OpenFlags,
3636 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3637 {
3638 FIXME("%p %s %08x %p\n", DeviceInfoSet,
3639 debugstr_a(DevicePath), OpenFlags, DeviceInterfaceData);
3640 return FALSE;
3641 }
3642
3643 /***********************************************************************
3644 * SetupDiSetClassInstallParamsA (SETUPAPI.@)
3645 */
3646 BOOL WINAPI SetupDiSetClassInstallParamsA(
3647 HDEVINFO DeviceInfoSet,
3648 PSP_DEVINFO_DATA DeviceInfoData,
3649 PSP_CLASSINSTALL_HEADER ClassInstallParams,
3650 DWORD ClassInstallParamsSize)
3651 {
3652 FIXME("%p %p %x %u\n",DeviceInfoSet, DeviceInfoData,
3653 ClassInstallParams->InstallFunction, ClassInstallParamsSize);
3654 return FALSE;
3655 }
3656
3657 /***********************************************************************
3658 * SetupDiCallClassInstaller (SETUPAPI.@)
3659 */
3660 BOOL WINAPI SetupDiCallClassInstaller(
3661 DI_FUNCTION InstallFunction,
3662 HDEVINFO DeviceInfoSet,
3663 PSP_DEVINFO_DATA DeviceInfoData)
3664 {
3665 FIXME("%d %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
3666 return FALSE;
3667 }
3668
3669 /***********************************************************************
3670 * SetupDiGetDeviceInstallParamsA (SETUPAPI.@)
3671 */
3672 BOOL WINAPI SetupDiGetDeviceInstallParamsA(
3673 HDEVINFO DeviceInfoSet,
3674 PSP_DEVINFO_DATA DeviceInfoData,
3675 PSP_DEVINSTALL_PARAMS_A DeviceInstallParams)
3676 {
3677 FIXME("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
3678 return FALSE;
3679 }
3680
3681 static HKEY SETUPDI_OpenDevKey(struct DeviceInfo *devInfo, REGSAM samDesired)
3682 {
3683 HKEY enumKey, key = INVALID_HANDLE_VALUE;
3684 LONG l;
3685
3686 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
3687 NULL, &enumKey, NULL);
3688 if (!l)
3689 {
3690 RegOpenKeyExW(enumKey, devInfo->instanceId, 0, samDesired, &key);
3691 RegCloseKey(enumKey);
3692 }
3693 return key;
3694 }
3695
3696 static HKEY SETUPDI_OpenDrvKey(struct DeviceInfo *devInfo, REGSAM samDesired)
3697 {
3698 static const WCHAR slash[] = { '\\',0 };
3699 WCHAR classKeyPath[MAX_PATH];
3700 HKEY classKey, key = INVALID_HANDLE_VALUE;
3701 LONG l;
3702
3703 lstrcpyW(classKeyPath, ControlClass);
3704 lstrcatW(classKeyPath, slash);
3705 SETUPDI_GuidToString(&devInfo->set->ClassGuid,
3706 classKeyPath + lstrlenW(classKeyPath));
3707 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
3708 KEY_ALL_ACCESS, NULL, &classKey, NULL);
3709 if (!l)
3710 {
3711 static const WCHAR fmt[] = { '%','0','4','u',0 };
3712 WCHAR devId[10];
3713
3714 sprintfW(devId, fmt, devInfo->devId);
3715 RegOpenKeyExW(classKey, devId, 0, samDesired, &key);
3716 RegCloseKey(classKey);
3717 }
3718 return key;
3719 }
3720
3721 /***********************************************************************
3722 * SetupDiOpenDevRegKey (SETUPAPI.@)
3723 */
3724 HKEY WINAPI SetupDiOpenDevRegKey(
3725 HDEVINFO DeviceInfoSet,
3726 PSP_DEVINFO_DATA DeviceInfoData,
3727 DWORD Scope,
3728 DWORD HwProfile,
3729 DWORD KeyType,
3730 REGSAM samDesired)
3731 {
3732 struct DeviceInfoSet *set = DeviceInfoSet;
3733 struct DeviceInfo *devInfo;
3734 HKEY key = INVALID_HANDLE_VALUE;
3735
3736 TRACE("%p %p %d %d %d %x\n", DeviceInfoSet, DeviceInfoData,
3737 Scope, HwProfile, KeyType, samDesired);
3738
3739 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3740 {
3741 SetLastError(ERROR_INVALID_HANDLE);
3742 return INVALID_HANDLE_VALUE;
3743 }
3744 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3745 {
3746 SetLastError(ERROR_INVALID_HANDLE);
3747 return INVALID_HANDLE_VALUE;
3748 }
3749 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3750 || !DeviceInfoData->Reserved)
3751 {
3752 SetLastError(ERROR_INVALID_PARAMETER);
3753 return INVALID_HANDLE_VALUE;
3754 }
3755 if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
3756 {
3757 SetLastError(ERROR_INVALID_FLAGS);
3758 return INVALID_HANDLE_VALUE;
3759 }
3760 if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
3761 {
3762 SetLastError(ERROR_INVALID_FLAGS);
3763 return INVALID_HANDLE_VALUE;
3764 }
3765 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3766 if (devInfo->set != set)
3767 {
3768 SetLastError(ERROR_INVALID_PARAMETER);
3769 return INVALID_HANDLE_VALUE;
3770 }
3771 if (devInfo->phantom)
3772 {
3773 SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
3774 return INVALID_HANDLE_VALUE;
3775 }
3776 if (Scope != DICS_FLAG_GLOBAL)
3777 FIXME("unimplemented for scope %d\n", Scope);
3778 switch (KeyType)
3779 {
3780 case DIREG_DEV:
3781 key = SETUPDI_OpenDevKey(devInfo, samDesired);
3782 break;
3783 case DIREG_DRV:
3784 key = SETUPDI_OpenDrvKey(devInfo, samDesired);
3785 break;
3786 default:
3787 WARN("unknown KeyType %d\n", KeyType);
3788 }
3789 return key;
3790 }
3791
3792 static BOOL SETUPDI_DeleteDevKey(struct DeviceInfo *devInfo)
3793 {
3794 HKEY enumKey;
3795 BOOL ret = FALSE;
3796 LONG l;
3797
3798 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
3799 NULL, &enumKey, NULL);
3800 if (!l)
3801 {
3802 ret = RegDeleteTreeW(enumKey, devInfo->instanceId);
3803 RegCloseKey(enumKey);
3804 }
3805 else
3806 SetLastError(l);
3807 return ret;
3808 }
3809
3810 static BOOL SETUPDI_DeleteDrvKey(struct DeviceInfo *devInfo)
3811 {
3812 static const WCHAR slash[] = { '\\',0 };
3813 WCHAR classKeyPath[MAX_PATH];
3814 HKEY classKey;
3815 LONG l;
3816 BOOL ret = FALSE;
3817
3818 lstrcpyW(classKeyPath, ControlClass);
3819 lstrcatW(classKeyPath, slash);
3820 SETUPDI_GuidToString(&devInfo->set->ClassGuid,
3821 classKeyPath + lstrlenW(classKeyPath));
3822 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
3823 KEY_ALL_ACCESS, NULL, &classKey, NULL);
3824 if (!l)
3825 {
3826 static const WCHAR fmt[] = { '%','0','4','u',0 };
3827 WCHAR devId[10];
3828
3829 sprintfW(devId, fmt, devInfo->devId);
3830 ret = RegDeleteTreeW(classKey, devId);
3831 RegCloseKey(classKey);
3832 }
3833 else
3834 SetLastError(l);
3835 return ret;
3836 }
3837
3838 /***********************************************************************
3839 * SetupDiOpenDevRegKey (SETUPAPI.@)
3840 */
3841 BOOL WINAPI SetupDiDeleteDevRegKey(
3842 HDEVINFO DeviceInfoSet,
3843 PSP_DEVINFO_DATA DeviceInfoData,
3844 DWORD Scope,
3845 DWORD HwProfile,
3846 DWORD KeyType)
3847 {
3848 struct DeviceInfoSet *set = DeviceInfoSet;
3849 struct DeviceInfo *devInfo;
3850 BOOL ret = FALSE;
3851
3852 TRACE("%p %p %d %d %d\n", DeviceInfoSet, DeviceInfoData, Scope, HwProfile,
3853 KeyType);
3854
3855 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3856 {
3857 SetLastError(ERROR_INVALID_HANDLE);
3858 return FALSE;
3859 }
3860 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3861 {
3862 SetLastError(ERROR_INVALID_HANDLE);
3863 return FALSE;
3864 }
3865 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3866 || !DeviceInfoData->Reserved)
3867 {
3868 SetLastError(ERROR_INVALID_PARAMETER);
3869 return FALSE;
3870 }
3871 if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
3872 {
3873 SetLastError(ERROR_INVALID_FLAGS);
3874 return FALSE;
3875 }
3876 if (KeyType != DIREG_DEV && KeyType != DIREG_DRV && KeyType != DIREG_BOTH)
3877 {
3878 SetLastError(ERROR_INVALID_FLAGS);
3879 return FALSE;
3880 }
3881 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3882 if (devInfo->set != set)
3883 {
3884 SetLastError(ERROR_INVALID_PARAMETER);
3885 return FALSE;
3886 }
3887 if (devInfo->phantom)
3888 {
3889 SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
3890 return FALSE;
3891 }
3892 if (Scope != DICS_FLAG_GLOBAL)
3893 FIXME("unimplemented for scope %d\n", Scope);
3894 switch (KeyType)
3895 {
3896 case DIREG_DEV:
3897 ret = SETUPDI_DeleteDevKey(devInfo);
3898 break;
3899 case DIREG_DRV:
3900 ret = SETUPDI_DeleteDrvKey(devInfo);
3901 break;
3902 case DIREG_BOTH:
3903 ret = SETUPDI_DeleteDevKey(devInfo);
3904 if (ret)
3905 ret = SETUPDI_DeleteDrvKey(devInfo);
3906 break;
3907 default:
3908 WARN("unknown KeyType %d\n", KeyType);
3909 }
3910 return ret;
3911 }
3912
3913 /***********************************************************************
3914 * CM_Get_Device_IDA (SETUPAPI.@)
3915 */
3916 CONFIGRET WINAPI CM_Get_Device_IDA( DEVINST dnDevInst, PSTR Buffer,
3917 ULONG BufferLen, ULONG ulFlags)
3918 {
3919 struct DeviceInfo *devInfo = GlobalLock((HANDLE)dnDevInst);
3920
3921 TRACE("%x->%p, %p, %u %u\n", dnDevInst, devInfo, Buffer, BufferLen, ulFlags);
3922
3923 if (!devInfo)
3924 return CR_NO_SUCH_DEVINST;
3925
3926 WideCharToMultiByte(CP_ACP, 0, devInfo->instanceId, -1, Buffer, BufferLen, 0, 0);
3927 TRACE("Returning %s\n", debugstr_a(Buffer));
3928 return CR_SUCCESS;
3929 }
3930
3931 /***********************************************************************
3932 * CM_Get_Device_IDW (SETUPAPI.@)
3933 */
3934 CONFIGRET WINAPI CM_Get_Device_IDW( DEVINST dnDevInst, LPWSTR Buffer,
3935 ULONG BufferLen, ULONG ulFlags)
3936 {
3937 struct DeviceInfo *devInfo = GlobalLock((HANDLE)dnDevInst);
3938
3939 TRACE("%x->%p, %p, %u %u\n", dnDevInst, devInfo, Buffer, BufferLen, ulFlags);
3940
3941 if (!devInfo)
3942 {
3943 WARN("dev instance %d not found!\n", dnDevInst);
3944 return CR_NO_SUCH_DEVINST;
3945 }
3946
3947 lstrcpynW(Buffer, devInfo->instanceId, BufferLen);
3948 TRACE("Returning %s\n", debugstr_w(Buffer));
3949 GlobalUnlock((HANDLE)dnDevInst);
3950 return CR_SUCCESS;
3951 }
3952
3953
3954
3955 /***********************************************************************
3956 * CM_Get_Device_ID_Size (SETUPAPI.@)
3957 */
3958 CONFIGRET WINAPI CM_Get_Device_ID_Size( PULONG pulLen, DEVINST dnDevInst,
3959 ULONG ulFlags)
3960 {
3961 struct DeviceInfo *ppdevInfo = GlobalLock((HANDLE)dnDevInst);
3962
3963 TRACE("%x->%p, %p, %u\n", dnDevInst, ppdevInfo, pulLen, ulFlags);
3964
3965 if (!ppdevInfo)
3966 {
3967 WARN("dev instance %d not found!\n", dnDevInst);
3968 return CR_NO_SUCH_DEVINST;
3969 }
3970
3971 *pulLen = lstrlenW(ppdevInfo->instanceId);
3972 GlobalUnlock((HANDLE)dnDevInst);
3973 return CR_SUCCESS;
3974 }
useful hacks and other patches not (yet) suitable for mainline