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