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