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