?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
setupapi: Create DeviceInstance value in registry, delete todo_wine from test.
[wine/multimedia.git] / dlls / setupapi / devinst.c
blob75cb38b43c65fa809a375d4f6b4588cdc913bb82
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 PWSTR interfKeyName = HeapAlloc(GetProcessHeap(), 0,
2635 (lstrlenW(ifaceInfo->symbolicLink) + 1) * sizeof(WCHAR));
2636 HKEY interfKey;
2637 WCHAR *ptr;
2638
2639 lstrcpyW(interfKeyName, ifaceInfo->symbolicLink);
2640 if (lstrlenW(ifaceInfo->symbolicLink) > 3)
2641 {
2642 interfKeyName[0] = '#';
2643 interfKeyName[1] = '#';
2644 interfKeyName[3] = '#';
2645 }
2646 ptr = strchrW(interfKeyName, '\\');
2647 if (ptr)
2648 *ptr = 0;
2649 l = RegCreateKeyExW(parent, interfKeyName, 0, NULL, 0,
2650 samDesired, NULL, &interfKey, NULL);
2651 if (!l)
2652 {
2653 struct DeviceInfo *devInfo =
2654 (struct DeviceInfo *)ifaceInfo->device->Reserved;
2655
2656 l = RegSetValueExW(interfKey, DeviceInstance, 0, REG_SZ,
2657 (BYTE *)devInfo->instanceId,
2658 (lstrlenW(devInfo->instanceId) + 1) * sizeof(WCHAR));
2659 if (!l)
2660 {
2661 if (instancePath)
2662 {
2663 LONG l;
2664
2665 l = RegCreateKeyExW(interfKey, instancePath, 0, NULL, 0,
2666 samDesired, NULL, &key, NULL);
2667 if (l)
2668 {
2669 SetLastError(l);
2670 key = INVALID_HANDLE_VALUE;
2671 }
2672 else if (InfHandle)
2673 FIXME("INF section installation unsupported\n");
2674 }
2675 }
2676 else
2677 SetLastError(l);
2678 RegCloseKey(interfKey);
2679 }
2680 else
2681 SetLastError(l);
2682 HeapFree(GetProcessHeap(), 0, interfKeyName);
2683 HeapFree(GetProcessHeap(), 0, instancePath);
2684 RegCloseKey(parent);
2685 }
2686 else
2687 SetLastError(l);
2688 RegCloseKey(interfacesKey);
2689 }
2690 else
2691 SetLastError(l);
2692 return key;
2693 }
2694
2695 /***********************************************************************
2696 * SetupDiDeleteDeviceInterfaceRegKey (SETUPAPI.@)
2697 */
2698 BOOL WINAPI SetupDiDeleteDeviceInterfaceRegKey(
2699 HDEVINFO DeviceInfoSet,
2700 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2701 DWORD Reserved)
2702 {
2703 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
2704 HKEY parent;
2705 BOOL ret = FALSE;
2706
2707 TRACE("%p %p %d\n", DeviceInfoSet, DeviceInterfaceData, Reserved);
2708
2709 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2710 set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2711 {
2712 SetLastError(ERROR_INVALID_HANDLE);
2713 return FALSE;
2714 }
2715 if (!DeviceInterfaceData ||
2716 DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2717 !DeviceInterfaceData->Reserved)
2718 {
2719 SetLastError(ERROR_INVALID_PARAMETER);
2720 return FALSE;
2721 }
2722 parent = SetupDiOpenClassRegKeyExW(&DeviceInterfaceData->InterfaceClassGuid,
2723 KEY_ALL_ACCESS, DIOCR_INTERFACE, NULL, NULL);
2724 if (parent != INVALID_HANDLE_VALUE)
2725 {
2726 struct InterfaceInfo *ifaceInfo =
2727 (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
2728 PWSTR instancePath = SETUPDI_GetInstancePath(ifaceInfo);
2729
2730 if (instancePath)
2731 {
2732 LONG l = RegDeleteKeyW(parent, instancePath);
2733
2734 if (l)
2735 SetLastError(l);
2736 else
2737 ret = TRUE;
2738 HeapFree(GetProcessHeap(), 0, instancePath);
2739 }
2740 RegCloseKey(parent);
2741 }
2742 return ret;
2743 }
2744
2745 /***********************************************************************
2746 * SetupDiEnumDeviceInterfaces (SETUPAPI.@)
2747 *
2748 * PARAMS
2749 * DeviceInfoSet [I] Set of devices from which to enumerate
2750 * interfaces
2751 * DeviceInfoData [I] (Optional) If specified, a specific device
2752 * instance from which to enumerate interfaces.
2753 * If it isn't specified, all interfaces for all
2754 * devices in the set are enumerated.
2755 * InterfaceClassGuid [I] The interface class to enumerate.
2756 * MemberIndex [I] An index of the interface instance to enumerate.
2757 * A caller should start with MemberIndex set to 0,
2758 * and continue until the function fails with
2759 * ERROR_NO_MORE_ITEMS.
2760 * DeviceInterfaceData [I/O] Returns an enumerated interface. Its cbSize
2761 * member must be set to
2762 * sizeof(SP_DEVICE_INTERFACE_DATA).
2763 *
2764 * RETURNS
2765 * Success: non-zero value.
2766 * Failure: FALSE. Call GetLastError() for more info.
2767 */
2768 BOOL WINAPI SetupDiEnumDeviceInterfaces(
2769 HDEVINFO DeviceInfoSet,
2770 PSP_DEVINFO_DATA DeviceInfoData,
2771 CONST GUID * InterfaceClassGuid,
2772 DWORD MemberIndex,
2773 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
2774 {
2775 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
2776 BOOL ret = FALSE;
2777
2778 TRACE("%p, %p, %s, %d, %p\n", DeviceInfoSet, DeviceInfoData,
2779 debugstr_guid(InterfaceClassGuid), MemberIndex, DeviceInterfaceData);
2780
2781 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2782 set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2783 {
2784 SetLastError(ERROR_INVALID_HANDLE);
2785 return FALSE;
2786 }
2787 if (DeviceInfoData && (DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA) ||
2788 !DeviceInfoData->Reserved))
2789 {
2790 SetLastError(ERROR_INVALID_PARAMETER);
2791 return FALSE;
2792 }
2793 if (!DeviceInterfaceData ||
2794 DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA))
2795 {
2796 SetLastError(ERROR_INVALID_PARAMETER);
2797 return FALSE;
2798 }
2799 if (DeviceInfoData)
2800 {
2801 struct DeviceInfo *devInfo =
2802 (struct DeviceInfo *)DeviceInfoData->Reserved;
2803 struct InterfaceInstances *iface;
2804
2805 if ((ret = SETUPDI_FindInterface(devInfo, InterfaceClassGuid, &iface)))
2806 {
2807 if (MemberIndex < iface->cInstances)
2808 *DeviceInterfaceData = iface->instances[MemberIndex];
2809 else
2810 {
2811 SetLastError(ERROR_NO_MORE_ITEMS);
2812 ret = FALSE;
2813 }
2814 }
2815 else
2816 SetLastError(ERROR_NO_MORE_ITEMS);
2817 }
2818 else
2819 {
2820 DWORD i, cEnumerated = 0;
2821 BOOL found = FALSE;
2822
2823 for (i = 0; !found && cEnumerated < MemberIndex + 1 &&
2824 i < set->cDevices; i++)
2825 {
2826 struct DeviceInfo *devInfo =
2827 (struct DeviceInfo *)set->devices[i].Reserved;
2828 struct InterfaceInstances *iface;
2829
2830 if (SETUPDI_FindInterface(devInfo, InterfaceClassGuid, &iface))
2831 {
2832 if (cEnumerated + iface->cInstances < MemberIndex + 1)
2833 cEnumerated += iface->cInstances;
2834 else
2835 {
2836 DWORD instanceIndex = MemberIndex - cEnumerated;
2837
2838 *DeviceInterfaceData = iface->instances[instanceIndex];
2839 cEnumerated += instanceIndex + 1;
2840 found = TRUE;
2841 ret = TRUE;
2842 }
2843 }
2844 }
2845 if (!found)
2846 SetLastError(ERROR_NO_MORE_ITEMS);
2847 }
2848 return ret;
2849 }
2850
2851 /***********************************************************************
2852 * SetupDiDestroyDeviceInfoList (SETUPAPI.@)
2853 *
2854 * Destroy a DeviceInfoList and free all used memory of the list.
2855 *
2856 * PARAMS
2857 * devinfo [I] DeviceInfoList pointer to list to destroy
2858 *
2859 * RETURNS
2860 * Success: non zero value.
2861 * Failure: zero value.
2862 */
2863 BOOL WINAPI SetupDiDestroyDeviceInfoList(HDEVINFO devinfo)
2864 {
2865 BOOL ret = FALSE;
2866
2867 TRACE("%p\n", devinfo);
2868 if (devinfo && devinfo != INVALID_HANDLE_VALUE)
2869 {
2870 struct DeviceInfoSet *list = (struct DeviceInfoSet *)devinfo;
2871
2872 if (list->magic == SETUP_DEVICE_INFO_SET_MAGIC)
2873 {
2874 DWORD i;
2875
2876 for (i = 0; i < list->cDevices; i++)
2877 SETUPDI_FreeDeviceInfo(
2878 (struct DeviceInfo *)list->devices[i].Reserved);
2879 HeapFree(GetProcessHeap(), 0, list->devices);
2880 HeapFree(GetProcessHeap(), 0, list);
2881 ret = TRUE;
2882 }
2883 }
2884
2885 if (ret == FALSE)
2886 SetLastError(ERROR_INVALID_HANDLE);
2887
2888 return ret;
2889 }
2890
2891 /***********************************************************************
2892 * SetupDiGetDeviceInterfaceDetailA (SETUPAPI.@)
2893 */
2894 BOOL WINAPI SetupDiGetDeviceInterfaceDetailA(
2895 HDEVINFO DeviceInfoSet,
2896 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2897 PSP_DEVICE_INTERFACE_DETAIL_DATA_A DeviceInterfaceDetailData,
2898 DWORD DeviceInterfaceDetailDataSize,
2899 PDWORD RequiredSize,
2900 PSP_DEVINFO_DATA DeviceInfoData)
2901 {
2902 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
2903 struct InterfaceInfo *info;
2904 DWORD bytesNeeded = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath)
2905 + 1;
2906 BOOL ret = FALSE;
2907
2908 TRACE("(%p, %p, %p, %d, %p, %p)\n", DeviceInfoSet,
2909 DeviceInterfaceData, DeviceInterfaceDetailData,
2910 DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2911
2912 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2913 set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2914 {
2915 SetLastError(ERROR_INVALID_HANDLE);
2916 return FALSE;
2917 }
2918 if (!DeviceInterfaceData ||
2919 DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2920 !DeviceInterfaceData->Reserved)
2921 {
2922 SetLastError(ERROR_INVALID_PARAMETER);
2923 return FALSE;
2924 }
2925 if (DeviceInterfaceDetailData && (DeviceInterfaceDetailData->cbSize !=
2926 offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath) + sizeof(char)))
2927 {
2928 SetLastError(ERROR_INVALID_USER_BUFFER);
2929 return FALSE;
2930 }
2931 if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
2932 {
2933 SetLastError(ERROR_INVALID_USER_BUFFER);
2934 return FALSE;
2935 }
2936 info = (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
2937 if (info->symbolicLink)
2938 bytesNeeded += WideCharToMultiByte(CP_ACP, 0, info->symbolicLink, -1,
2939 NULL, 0, NULL, NULL);
2940 if (DeviceInterfaceDetailDataSize >= bytesNeeded)
2941 {
2942 if (info->symbolicLink)
2943 WideCharToMultiByte(CP_ACP, 0, info->symbolicLink, -1,
2944 DeviceInterfaceDetailData->DevicePath,
2945 DeviceInterfaceDetailDataSize -
2946 offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_A, DevicePath),
2947 NULL, NULL);
2948 else
2949 DeviceInterfaceDetailData->DevicePath[0] = '\0';
2950 if (DeviceInfoData && DeviceInfoData->cbSize == sizeof(SP_DEVINFO_DATA))
2951 *DeviceInfoData = *info->device;
2952 ret = TRUE;
2953 }
2954 else
2955 {
2956 if (RequiredSize)
2957 *RequiredSize = bytesNeeded;
2958 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2959 }
2960 return ret;
2961 }
2962
2963 /***********************************************************************
2964 * SetupDiGetDeviceInterfaceDetailW (SETUPAPI.@)
2965 */
2966 BOOL WINAPI SetupDiGetDeviceInterfaceDetailW(
2967 HDEVINFO DeviceInfoSet,
2968 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,
2969 PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData,
2970 DWORD DeviceInterfaceDetailDataSize,
2971 PDWORD RequiredSize,
2972 PSP_DEVINFO_DATA DeviceInfoData)
2973 {
2974 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
2975 struct InterfaceInfo *info;
2976 DWORD bytesNeeded = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath)
2977 + sizeof(WCHAR); /* include NULL terminator */
2978 BOOL ret = FALSE;
2979
2980 TRACE("(%p, %p, %p, %d, %p, %p)\n", DeviceInfoSet,
2981 DeviceInterfaceData, DeviceInterfaceDetailData,
2982 DeviceInterfaceDetailDataSize, RequiredSize, DeviceInfoData);
2983
2984 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE ||
2985 set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2986 {
2987 SetLastError(ERROR_INVALID_HANDLE);
2988 return FALSE;
2989 }
2990 if (!DeviceInterfaceData ||
2991 DeviceInterfaceData->cbSize != sizeof(SP_DEVICE_INTERFACE_DATA) ||
2992 !DeviceInterfaceData->Reserved)
2993 {
2994 SetLastError(ERROR_INVALID_PARAMETER);
2995 return FALSE;
2996 }
2997 if (DeviceInterfaceDetailData && (DeviceInterfaceDetailData->cbSize <
2998 offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath) + sizeof(WCHAR) ||
2999 DeviceInterfaceDetailData->cbSize > sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W)))
3000 {
3001 SetLastError(ERROR_INVALID_USER_BUFFER);
3002 return FALSE;
3003 }
3004 if (!DeviceInterfaceDetailData && DeviceInterfaceDetailDataSize)
3005 {
3006 SetLastError(ERROR_INVALID_USER_BUFFER);
3007 return FALSE;
3008 }
3009 info = (struct InterfaceInfo *)DeviceInterfaceData->Reserved;
3010 if (info->symbolicLink)
3011 bytesNeeded += sizeof(WCHAR)*lstrlenW(info->symbolicLink);
3012 if (DeviceInterfaceDetailDataSize >= bytesNeeded)
3013 {
3014 if (info->symbolicLink)
3015 lstrcpyW(DeviceInterfaceDetailData->DevicePath, info->symbolicLink);
3016 else
3017 DeviceInterfaceDetailData->DevicePath[0] = '\0';
3018 if (DeviceInfoData && DeviceInfoData->cbSize == sizeof(SP_DEVINFO_DATA))
3019 *DeviceInfoData = *info->device;
3020 ret = TRUE;
3021 }
3022 else
3023 {
3024 if (RequiredSize)
3025 *RequiredSize = bytesNeeded;
3026 SetLastError(ERROR_INSUFFICIENT_BUFFER);
3027 }
3028 return ret;
3029 }
3030
3031 struct PropertyMapEntry
3032 {
3033 DWORD regType;
3034 LPCSTR nameA;
3035 LPCWSTR nameW;
3036 };
3037
3038 static struct PropertyMapEntry PropertyMap[] = {
3039 { REG_SZ, "DeviceDesc", DeviceDesc },
3040 { REG_MULTI_SZ, "HardwareId", HardwareId },
3041 { REG_MULTI_SZ, "CompatibleIDs", CompatibleIDs },
3042 { 0, NULL, NULL }, /* SPDRP_UNUSED0 */
3043 { REG_SZ, "Service", Service },
3044 { 0, NULL, NULL }, /* SPDRP_UNUSED1 */
3045 { 0, NULL, NULL }, /* SPDRP_UNUSED2 */
3046 { REG_SZ, "Class", Class },
3047 { REG_SZ, "ClassGUID", ClassGUID },
3048 { REG_SZ, "Driver", Driver },
3049 { REG_DWORD, "ConfigFlags", ConfigFlags },
3050 { REG_SZ, "Mfg", Mfg },
3051 { REG_SZ, "FriendlyName", FriendlyName },
3052 { REG_SZ, "LocationInformation", LocationInformation },
3053 { 0, NULL, NULL }, /* SPDRP_PHYSICAL_DEVICE_OBJECT_NAME */
3054 { REG_DWORD, "Capabilities", Capabilities },
3055 { REG_DWORD, "UINumber", UINumber },
3056 { REG_MULTI_SZ, "UpperFilters", UpperFilters },
3057 { REG_MULTI_SZ, "LowerFilters", LowerFilters },
3058 };
3059
3060 /***********************************************************************
3061 * SetupDiGetDeviceRegistryPropertyA (SETUPAPI.@)
3062 */
3063 BOOL WINAPI SetupDiGetDeviceRegistryPropertyA(
3064 HDEVINFO DeviceInfoSet,
3065 PSP_DEVINFO_DATA DeviceInfoData,
3066 DWORD Property,
3067 PDWORD PropertyRegDataType,
3068 PBYTE PropertyBuffer,
3069 DWORD PropertyBufferSize,
3070 PDWORD RequiredSize)
3071 {
3072 BOOL ret = FALSE;
3073 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
3074 struct DeviceInfo *devInfo;
3075
3076 TRACE("%04x %p %d %p %p %d %p\n", (DWORD)DeviceInfoSet, DeviceInfoData,
3077 Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
3078 RequiredSize);
3079
3080 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3081 {
3082 SetLastError(ERROR_INVALID_HANDLE);
3083 return FALSE;
3084 }
3085 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3086 {
3087 SetLastError(ERROR_INVALID_HANDLE);
3088 return FALSE;
3089 }
3090 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3091 || !DeviceInfoData->Reserved)
3092 {
3093 SetLastError(ERROR_INVALID_PARAMETER);
3094 return FALSE;
3095 }
3096 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3097 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3098 && PropertyMap[Property].nameA)
3099 {
3100 DWORD size = PropertyBufferSize;
3101 LONG l = RegQueryValueExA(devInfo->key, PropertyMap[Property].nameA,
3102 NULL, PropertyRegDataType, PropertyBuffer, &size);
3103
3104 if (RequiredSize)
3105 *RequiredSize = size;
3106 if (!PropertyBuffer)
3107 ; /* do nothing, ret is already FALSE, last error is already set */
3108 else if (!l)
3109 ret = TRUE;
3110 else
3111 SetLastError(l);
3112 }
3113 return ret;
3114 }
3115
3116 /***********************************************************************
3117 * SetupDiGetDeviceRegistryPropertyW (SETUPAPI.@)
3118 */
3119 BOOL WINAPI SetupDiGetDeviceRegistryPropertyW(
3120 HDEVINFO DeviceInfoSet,
3121 PSP_DEVINFO_DATA DeviceInfoData,
3122 DWORD Property,
3123 PDWORD PropertyRegDataType,
3124 PBYTE PropertyBuffer,
3125 DWORD PropertyBufferSize,
3126 PDWORD RequiredSize)
3127 {
3128 BOOL ret = FALSE;
3129 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
3130 struct DeviceInfo *devInfo;
3131
3132 TRACE("%04x %p %d %p %p %d %p\n", (DWORD)DeviceInfoSet, DeviceInfoData,
3133 Property, PropertyRegDataType, PropertyBuffer, PropertyBufferSize,
3134 RequiredSize);
3135
3136 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3137 {
3138 SetLastError(ERROR_INVALID_HANDLE);
3139 return FALSE;
3140 }
3141 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3142 {
3143 SetLastError(ERROR_INVALID_HANDLE);
3144 return FALSE;
3145 }
3146 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3147 || !DeviceInfoData->Reserved)
3148 {
3149 SetLastError(ERROR_INVALID_PARAMETER);
3150 return FALSE;
3151 }
3152 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3153 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3154 && PropertyMap[Property].nameW)
3155 {
3156 DWORD size = PropertyBufferSize;
3157 LONG l = RegQueryValueExW(devInfo->key, PropertyMap[Property].nameW,
3158 NULL, PropertyRegDataType, PropertyBuffer, &size);
3159
3160 if (RequiredSize)
3161 *RequiredSize = size;
3162 if (!PropertyBuffer)
3163 ; /* do nothing, ret is already FALSE, last error is already set */
3164 else if (!l)
3165 ret = TRUE;
3166 else
3167 SetLastError(l);
3168 }
3169 return ret;
3170 }
3171
3172 /***********************************************************************
3173 * SetupDiSetDeviceRegistryPropertyA (SETUPAPI.@)
3174 */
3175 BOOL WINAPI SetupDiSetDeviceRegistryPropertyA(
3176 HDEVINFO DeviceInfoSet,
3177 PSP_DEVINFO_DATA DeviceInfoData,
3178 DWORD Property,
3179 const BYTE *PropertyBuffer,
3180 DWORD PropertyBufferSize)
3181 {
3182 BOOL ret = FALSE;
3183 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
3184 struct DeviceInfo *devInfo;
3185
3186 TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
3187 PropertyBuffer, PropertyBufferSize);
3188
3189 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3190 {
3191 SetLastError(ERROR_INVALID_HANDLE);
3192 return FALSE;
3193 }
3194 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3195 {
3196 SetLastError(ERROR_INVALID_HANDLE);
3197 return FALSE;
3198 }
3199 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3200 || !DeviceInfoData->Reserved)
3201 {
3202 SetLastError(ERROR_INVALID_PARAMETER);
3203 return FALSE;
3204 }
3205 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3206 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3207 && PropertyMap[Property].nameA)
3208 {
3209 LONG l = RegSetValueExA(devInfo->key, PropertyMap[Property].nameA, 0,
3210 PropertyMap[Property].regType, PropertyBuffer,
3211 PropertyBufferSize);
3212 if (!l)
3213 ret = TRUE;
3214 else
3215 SetLastError(l);
3216 }
3217 return ret;
3218 }
3219
3220 /***********************************************************************
3221 * SetupDiSetDeviceRegistryPropertyW (SETUPAPI.@)
3222 */
3223 BOOL WINAPI SetupDiSetDeviceRegistryPropertyW(
3224 HDEVINFO DeviceInfoSet,
3225 PSP_DEVINFO_DATA DeviceInfoData,
3226 DWORD Property,
3227 const BYTE *PropertyBuffer,
3228 DWORD PropertyBufferSize)
3229 {
3230 BOOL ret = FALSE;
3231 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
3232 struct DeviceInfo *devInfo;
3233
3234 TRACE("%p %p %d %p %d\n", DeviceInfoSet, DeviceInfoData, Property,
3235 PropertyBuffer, PropertyBufferSize);
3236
3237 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3238 {
3239 SetLastError(ERROR_INVALID_HANDLE);
3240 return FALSE;
3241 }
3242 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3243 {
3244 SetLastError(ERROR_INVALID_HANDLE);
3245 return FALSE;
3246 }
3247 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3248 || !DeviceInfoData->Reserved)
3249 {
3250 SetLastError(ERROR_INVALID_PARAMETER);
3251 return FALSE;
3252 }
3253 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3254 if (Property < sizeof(PropertyMap) / sizeof(PropertyMap[0])
3255 && PropertyMap[Property].nameW)
3256 {
3257 LONG l = RegSetValueExW(devInfo->key, PropertyMap[Property].nameW, 0,
3258 PropertyMap[Property].regType, PropertyBuffer,
3259 PropertyBufferSize);
3260 if (!l)
3261 ret = TRUE;
3262 else
3263 SetLastError(l);
3264 }
3265 return ret;
3266 }
3267
3268 /***********************************************************************
3269 * SetupDiInstallClassA (SETUPAPI.@)
3270 */
3271 BOOL WINAPI SetupDiInstallClassA(
3272 HWND hwndParent,
3273 PCSTR InfFileName,
3274 DWORD Flags,
3275 HSPFILEQ FileQueue)
3276 {
3277 UNICODE_STRING FileNameW;
3278 BOOL Result;
3279
3280 if (!InfFileName)
3281 {
3282 SetLastError(ERROR_INVALID_PARAMETER);
3283 return FALSE;
3284 }
3285 if (!RtlCreateUnicodeStringFromAsciiz(&FileNameW, InfFileName))
3286 {
3287 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
3288 return FALSE;
3289 }
3290
3291 Result = SetupDiInstallClassW(hwndParent, FileNameW.Buffer, Flags, FileQueue);
3292
3293 RtlFreeUnicodeString(&FileNameW);
3294
3295 return Result;
3296 }
3297
3298 static HKEY CreateClassKey(HINF hInf)
3299 {
3300 static const WCHAR slash[] = { '\\',0 };
3301 WCHAR FullBuffer[MAX_PATH];
3302 WCHAR Buffer[MAX_PATH];
3303 DWORD RequiredSize;
3304 HKEY hClassKey;
3305
3306 if (!SetupGetLineTextW(NULL,
3307 hInf,
3308 Version,
3309 ClassGUID,
3310 Buffer,
3311 MAX_PATH,
3312 &RequiredSize))
3313 {
3314 return INVALID_HANDLE_VALUE;
3315 }
3316
3317 lstrcpyW(FullBuffer, ControlClass);
3318 lstrcatW(FullBuffer, slash);
3319 lstrcatW(FullBuffer, Buffer);
3320
3321 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3322 FullBuffer,
3323 0,
3324 KEY_ALL_ACCESS,
3325 &hClassKey))
3326 {
3327 if (!SetupGetLineTextW(NULL,
3328 hInf,
3329 Version,
3330 Class,
3331 Buffer,
3332 MAX_PATH,
3333 &RequiredSize))
3334 {
3335 return INVALID_HANDLE_VALUE;
3336 }
3337
3338 if (RegCreateKeyExW(HKEY_LOCAL_MACHINE,
3339 FullBuffer,
3340 0,
3341 NULL,
3342 REG_OPTION_NON_VOLATILE,
3343 KEY_ALL_ACCESS,
3344 NULL,
3345 &hClassKey,
3346 NULL))
3347 {
3348 return INVALID_HANDLE_VALUE;
3349 }
3350
3351 }
3352
3353 if (RegSetValueExW(hClassKey,
3354 Class,
3355 0,
3356 REG_SZ,
3357 (LPBYTE)Buffer,
3358 RequiredSize * sizeof(WCHAR)))
3359 {
3360 RegCloseKey(hClassKey);
3361 RegDeleteKeyW(HKEY_LOCAL_MACHINE,
3362 FullBuffer);
3363 return INVALID_HANDLE_VALUE;
3364 }
3365
3366 return hClassKey;
3367 }
3368
3369 /***********************************************************************
3370 * SetupDiInstallClassW (SETUPAPI.@)
3371 */
3372 BOOL WINAPI SetupDiInstallClassW(
3373 HWND hwndParent,
3374 PCWSTR InfFileName,
3375 DWORD Flags,
3376 HSPFILEQ FileQueue)
3377 {
3378 WCHAR SectionName[MAX_PATH];
3379 DWORD SectionNameLength = 0;
3380 HINF hInf;
3381 BOOL bFileQueueCreated = FALSE;
3382 HKEY hClassKey;
3383
3384
3385 FIXME("\n");
3386
3387 if (!InfFileName)
3388 {
3389 SetLastError(ERROR_INVALID_PARAMETER);
3390 return FALSE;
3391 }
3392 if ((Flags & DI_NOVCP) && (FileQueue == NULL || FileQueue == INVALID_HANDLE_VALUE))
3393 {
3394 SetLastError(ERROR_INVALID_PARAMETER);
3395 return FALSE;
3396 }
3397
3398 /* Open the .inf file */
3399 hInf = SetupOpenInfFileW(InfFileName,
3400 NULL,
3401 INF_STYLE_WIN4,
3402 NULL);
3403 if (hInf == INVALID_HANDLE_VALUE)
3404 {
3405
3406 return FALSE;
3407 }
3408
3409 /* Create or open the class registry key 'HKLM\\CurrentControlSet\\Class\\{GUID}' */
3410 hClassKey = CreateClassKey(hInf);
3411 if (hClassKey == INVALID_HANDLE_VALUE)
3412 {
3413 SetupCloseInfFile(hInf);
3414 return FALSE;
3415 }
3416
3417
3418 /* Try to append a layout file */
3419 SetupOpenAppendInfFileW(NULL, hInf, NULL);
3420
3421 /* Retrieve the actual section name */
3422 SetupDiGetActualSectionToInstallW(hInf,
3423 ClassInstall32,
3424 SectionName,
3425 MAX_PATH,
3426 &SectionNameLength,
3427 NULL);
3428
3429 #if 0
3430 if (!(Flags & DI_NOVCP))
3431 {
3432 FileQueue = SetupOpenFileQueue();
3433 if (FileQueue == INVALID_HANDLE_VALUE)
3434 {
3435 SetupCloseInfFile(hInf);
3436 return FALSE;
3437 }
3438
3439 bFileQueueCreated = TRUE;
3440
3441 }
3442 #endif
3443
3444 SetupInstallFromInfSectionW(NULL,
3445 hInf,
3446 SectionName,
3447 SPINST_COPYINF | SPINST_FILES | SPINST_REGISTRY,
3448 hClassKey,
3449 NULL,
3450 0,
3451 NULL,
3452 NULL,
3453 INVALID_HANDLE_VALUE,
3454 NULL);
3455
3456 /* FIXME: More code! */
3457
3458 if (bFileQueueCreated)
3459 SetupCloseFileQueue(FileQueue);
3460
3461 SetupCloseInfFile(hInf);
3462
3463 return TRUE;
3464 }
3465
3466
3467 /***********************************************************************
3468 * SetupDiOpenClassRegKey (SETUPAPI.@)
3469 */
3470 HKEY WINAPI SetupDiOpenClassRegKey(
3471 const GUID* ClassGuid,
3472 REGSAM samDesired)
3473 {
3474 return SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3475 DIOCR_INSTALLER, NULL, NULL);
3476 }
3477
3478
3479 /***********************************************************************
3480 * SetupDiOpenClassRegKeyExA (SETUPAPI.@)
3481 */
3482 HKEY WINAPI SetupDiOpenClassRegKeyExA(
3483 const GUID* ClassGuid,
3484 REGSAM samDesired,
3485 DWORD Flags,
3486 PCSTR MachineName,
3487 PVOID Reserved)
3488 {
3489 PWSTR MachineNameW = NULL;
3490 HKEY hKey;
3491
3492 TRACE("\n");
3493
3494 if (MachineName)
3495 {
3496 MachineNameW = MultiByteToUnicode(MachineName, CP_ACP);
3497 if (MachineNameW == NULL)
3498 return INVALID_HANDLE_VALUE;
3499 }
3500
3501 hKey = SetupDiOpenClassRegKeyExW(ClassGuid, samDesired,
3502 Flags, MachineNameW, Reserved);
3503
3504 MyFree(MachineNameW);
3505
3506 return hKey;
3507 }
3508
3509
3510 /***********************************************************************
3511 * SetupDiOpenClassRegKeyExW (SETUPAPI.@)
3512 */
3513 HKEY WINAPI SetupDiOpenClassRegKeyExW(
3514 const GUID* ClassGuid,
3515 REGSAM samDesired,
3516 DWORD Flags,
3517 PCWSTR MachineName,
3518 PVOID Reserved)
3519 {
3520 HKEY hClassesKey;
3521 HKEY key;
3522 LPCWSTR lpKeyName;
3523 LONG l;
3524
3525 if (MachineName != NULL)
3526 {
3527 FIXME("Remote access not supported yet!\n");
3528 return INVALID_HANDLE_VALUE;
3529 }
3530
3531 if (Flags == DIOCR_INSTALLER)
3532 {
3533 lpKeyName = ControlClass;
3534 }
3535 else if (Flags == DIOCR_INTERFACE)
3536 {
3537 lpKeyName = DeviceClasses;
3538 }
3539 else
3540 {
3541 ERR("Invalid Flags parameter!\n");
3542 SetLastError(ERROR_INVALID_PARAMETER);
3543 return INVALID_HANDLE_VALUE;
3544 }
3545
3546 if (!ClassGuid)
3547 {
3548 if ((l = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3549 lpKeyName,
3550 0,
3551 samDesired,
3552 &hClassesKey)))
3553 {
3554 SetLastError(l);
3555 hClassesKey = INVALID_HANDLE_VALUE;
3556 }
3557 key = hClassesKey;
3558 }
3559 else
3560 {
3561 WCHAR bracedGuidString[39];
3562
3563 SETUPDI_GuidToString(ClassGuid, bracedGuidString);
3564
3565 if (!(l = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
3566 lpKeyName,
3567 0,
3568 samDesired,
3569 &hClassesKey)))
3570 {
3571 if ((l = RegOpenKeyExW(hClassesKey,
3572 bracedGuidString,
3573 0,
3574 samDesired,
3575 &key)))
3576 {
3577 SetLastError(l);
3578 key = INVALID_HANDLE_VALUE;
3579 }
3580 RegCloseKey(hClassesKey);
3581 }
3582 else
3583 {
3584 SetLastError(l);
3585 key = INVALID_HANDLE_VALUE;
3586 }
3587 }
3588 return key;
3589 }
3590
3591 /***********************************************************************
3592 * SetupDiOpenDeviceInterfaceW (SETUPAPI.@)
3593 */
3594 BOOL WINAPI SetupDiOpenDeviceInterfaceW(
3595 HDEVINFO DeviceInfoSet,
3596 PCWSTR DevicePath,
3597 DWORD OpenFlags,
3598 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3599 {
3600 FIXME("%p %s %08x %p\n",
3601 DeviceInfoSet, debugstr_w(DevicePath), OpenFlags, DeviceInterfaceData);
3602 return FALSE;
3603 }
3604
3605 /***********************************************************************
3606 * SetupDiOpenDeviceInterfaceA (SETUPAPI.@)
3607 */
3608 BOOL WINAPI SetupDiOpenDeviceInterfaceA(
3609 HDEVINFO DeviceInfoSet,
3610 PCSTR DevicePath,
3611 DWORD OpenFlags,
3612 PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData)
3613 {
3614 FIXME("%p %s %08x %p\n", DeviceInfoSet,
3615 debugstr_a(DevicePath), OpenFlags, DeviceInterfaceData);
3616 return FALSE;
3617 }
3618
3619 /***********************************************************************
3620 * SetupDiSetClassInstallParamsA (SETUPAPI.@)
3621 */
3622 BOOL WINAPI SetupDiSetClassInstallParamsA(
3623 HDEVINFO DeviceInfoSet,
3624 PSP_DEVINFO_DATA DeviceInfoData,
3625 PSP_CLASSINSTALL_HEADER ClassInstallParams,
3626 DWORD ClassInstallParamsSize)
3627 {
3628 FIXME("%p %p %x %u\n",DeviceInfoSet, DeviceInfoData,
3629 ClassInstallParams->InstallFunction, ClassInstallParamsSize);
3630 return FALSE;
3631 }
3632
3633 /***********************************************************************
3634 * SetupDiCallClassInstaller (SETUPAPI.@)
3635 */
3636 BOOL WINAPI SetupDiCallClassInstaller(
3637 DI_FUNCTION InstallFunction,
3638 HDEVINFO DeviceInfoSet,
3639 PSP_DEVINFO_DATA DeviceInfoData)
3640 {
3641 FIXME("%d %p %p\n", InstallFunction, DeviceInfoSet, DeviceInfoData);
3642 return FALSE;
3643 }
3644
3645 /***********************************************************************
3646 * SetupDiGetDeviceInstallParamsA (SETUPAPI.@)
3647 */
3648 BOOL WINAPI SetupDiGetDeviceInstallParamsA(
3649 HDEVINFO DeviceInfoSet,
3650 PSP_DEVINFO_DATA DeviceInfoData,
3651 PSP_DEVINSTALL_PARAMS_A DeviceInstallParams)
3652 {
3653 FIXME("%p %p %p\n", DeviceInfoSet, DeviceInfoData, DeviceInstallParams);
3654 return FALSE;
3655 }
3656
3657 static HKEY SETUPDI_OpenDevKey(struct DeviceInfo *devInfo, REGSAM samDesired)
3658 {
3659 HKEY enumKey, key = INVALID_HANDLE_VALUE;
3660 LONG l;
3661
3662 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
3663 NULL, &enumKey, NULL);
3664 if (!l)
3665 {
3666 RegOpenKeyExW(enumKey, devInfo->instanceId, 0, samDesired, &key);
3667 RegCloseKey(enumKey);
3668 }
3669 return key;
3670 }
3671
3672 static HKEY SETUPDI_OpenDrvKey(struct DeviceInfo *devInfo, REGSAM samDesired)
3673 {
3674 static const WCHAR slash[] = { '\\',0 };
3675 WCHAR classKeyPath[MAX_PATH];
3676 HKEY classKey, key = INVALID_HANDLE_VALUE;
3677 LONG l;
3678
3679 lstrcpyW(classKeyPath, ControlClass);
3680 lstrcatW(classKeyPath, slash);
3681 SETUPDI_GuidToString(&devInfo->set->ClassGuid,
3682 classKeyPath + lstrlenW(classKeyPath));
3683 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
3684 KEY_ALL_ACCESS, NULL, &classKey, NULL);
3685 if (!l)
3686 {
3687 static const WCHAR fmt[] = { '%','0','4','u',0 };
3688 WCHAR devId[10];
3689
3690 sprintfW(devId, fmt, devInfo->devId);
3691 RegOpenKeyExW(classKey, devId, 0, samDesired, &key);
3692 RegCloseKey(classKey);
3693 }
3694 return key;
3695 }
3696
3697 /***********************************************************************
3698 * SetupDiOpenDevRegKey (SETUPAPI.@)
3699 */
3700 HKEY WINAPI SetupDiOpenDevRegKey(
3701 HDEVINFO DeviceInfoSet,
3702 PSP_DEVINFO_DATA DeviceInfoData,
3703 DWORD Scope,
3704 DWORD HwProfile,
3705 DWORD KeyType,
3706 REGSAM samDesired)
3707 {
3708 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
3709 struct DeviceInfo *devInfo;
3710 HKEY key = INVALID_HANDLE_VALUE;
3711
3712 TRACE("%p %p %d %d %d %x\n", DeviceInfoSet, DeviceInfoData,
3713 Scope, HwProfile, KeyType, samDesired);
3714
3715 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3716 {
3717 SetLastError(ERROR_INVALID_HANDLE);
3718 return INVALID_HANDLE_VALUE;
3719 }
3720 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3721 {
3722 SetLastError(ERROR_INVALID_HANDLE);
3723 return INVALID_HANDLE_VALUE;
3724 }
3725 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3726 || !DeviceInfoData->Reserved)
3727 {
3728 SetLastError(ERROR_INVALID_PARAMETER);
3729 return INVALID_HANDLE_VALUE;
3730 }
3731 if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
3732 {
3733 SetLastError(ERROR_INVALID_FLAGS);
3734 return INVALID_HANDLE_VALUE;
3735 }
3736 if (KeyType != DIREG_DEV && KeyType != DIREG_DRV)
3737 {
3738 SetLastError(ERROR_INVALID_FLAGS);
3739 return INVALID_HANDLE_VALUE;
3740 }
3741 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3742 if (devInfo->set != set)
3743 {
3744 SetLastError(ERROR_INVALID_PARAMETER);
3745 return INVALID_HANDLE_VALUE;
3746 }
3747 if (devInfo->phantom)
3748 {
3749 SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
3750 return INVALID_HANDLE_VALUE;
3751 }
3752 if (Scope != DICS_FLAG_GLOBAL)
3753 FIXME("unimplemented for scope %d\n", Scope);
3754 switch (KeyType)
3755 {
3756 case DIREG_DEV:
3757 key = SETUPDI_OpenDevKey(devInfo, samDesired);
3758 break;
3759 case DIREG_DRV:
3760 key = SETUPDI_OpenDrvKey(devInfo, samDesired);
3761 break;
3762 default:
3763 WARN("unknown KeyType %d\n", KeyType);
3764 }
3765 return key;
3766 }
3767
3768 static BOOL SETUPDI_DeleteDevKey(struct DeviceInfo *devInfo)
3769 {
3770 HKEY enumKey;
3771 BOOL ret = FALSE;
3772 LONG l;
3773
3774 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, Enum, 0, NULL, 0, KEY_ALL_ACCESS,
3775 NULL, &enumKey, NULL);
3776 if (!l)
3777 {
3778 ret = RegDeleteTreeW(enumKey, devInfo->instanceId);
3779 RegCloseKey(enumKey);
3780 }
3781 else
3782 SetLastError(l);
3783 return ret;
3784 }
3785
3786 static BOOL SETUPDI_DeleteDrvKey(struct DeviceInfo *devInfo)
3787 {
3788 static const WCHAR slash[] = { '\\',0 };
3789 WCHAR classKeyPath[MAX_PATH];
3790 HKEY classKey;
3791 LONG l;
3792 BOOL ret = FALSE;
3793
3794 lstrcpyW(classKeyPath, ControlClass);
3795 lstrcatW(classKeyPath, slash);
3796 SETUPDI_GuidToString(&devInfo->set->ClassGuid,
3797 classKeyPath + lstrlenW(classKeyPath));
3798 l = RegCreateKeyExW(HKEY_LOCAL_MACHINE, classKeyPath, 0, NULL, 0,
3799 KEY_ALL_ACCESS, NULL, &classKey, NULL);
3800 if (!l)
3801 {
3802 static const WCHAR fmt[] = { '%','0','4','u',0 };
3803 WCHAR devId[10];
3804
3805 sprintfW(devId, fmt, devInfo->devId);
3806 ret = RegDeleteTreeW(classKey, devId);
3807 RegCloseKey(classKey);
3808 }
3809 else
3810 SetLastError(l);
3811 return ret;
3812 }
3813
3814 /***********************************************************************
3815 * SetupDiOpenDevRegKey (SETUPAPI.@)
3816 */
3817 BOOL WINAPI SetupDiDeleteDevRegKey(
3818 HDEVINFO DeviceInfoSet,
3819 PSP_DEVINFO_DATA DeviceInfoData,
3820 DWORD Scope,
3821 DWORD HwProfile,
3822 DWORD KeyType)
3823 {
3824 struct DeviceInfoSet *set = (struct DeviceInfoSet *)DeviceInfoSet;
3825 struct DeviceInfo *devInfo;
3826 BOOL ret = FALSE;
3827
3828 TRACE("%p %p %d %d %d\n", DeviceInfoSet, DeviceInfoData, Scope, HwProfile,
3829 KeyType);
3830
3831 if (!DeviceInfoSet || DeviceInfoSet == INVALID_HANDLE_VALUE)
3832 {
3833 SetLastError(ERROR_INVALID_HANDLE);
3834 return FALSE;
3835 }
3836 if (set->magic != SETUP_DEVICE_INFO_SET_MAGIC)
3837 {
3838 SetLastError(ERROR_INVALID_HANDLE);
3839 return FALSE;
3840 }
3841 if (!DeviceInfoData || DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA)
3842 || !DeviceInfoData->Reserved)
3843 {
3844 SetLastError(ERROR_INVALID_PARAMETER);
3845 return FALSE;
3846 }
3847 if (Scope != DICS_FLAG_GLOBAL && Scope != DICS_FLAG_CONFIGSPECIFIC)
3848 {
3849 SetLastError(ERROR_INVALID_FLAGS);
3850 return FALSE;
3851 }
3852 if (KeyType != DIREG_DEV && KeyType != DIREG_DRV && KeyType != DIREG_BOTH)
3853 {
3854 SetLastError(ERROR_INVALID_FLAGS);
3855 return FALSE;
3856 }
3857 devInfo = (struct DeviceInfo *)DeviceInfoData->Reserved;
3858 if (devInfo->set != set)
3859 {
3860 SetLastError(ERROR_INVALID_PARAMETER);
3861 return FALSE;
3862 }
3863 if (devInfo->phantom)
3864 {
3865 SetLastError(ERROR_DEVINFO_NOT_REGISTERED);
3866 return FALSE;
3867 }
3868 if (Scope != DICS_FLAG_GLOBAL)
3869 FIXME("unimplemented for scope %d\n", Scope);
3870 switch (KeyType)
3871 {
3872 case DIREG_DEV:
3873 ret = SETUPDI_DeleteDevKey(devInfo);
3874 break;
3875 case DIREG_DRV:
3876 ret = SETUPDI_DeleteDrvKey(devInfo);
3877 break;
3878 case DIREG_BOTH:
3879 ret = SETUPDI_DeleteDevKey(devInfo);
3880 if (ret)
3881 ret = SETUPDI_DeleteDrvKey(devInfo);
3882 break;
3883 default:
3884 WARN("unknown KeyType %d\n", KeyType);
3885 }
3886 return ret;
3887 }
3888
3889 /***********************************************************************
3890 * CM_Get_Device_IDA (SETUPAPI.@)
3891 */
3892 CONFIGRET WINAPI CM_Get_Device_IDA( DEVINST dnDevInst, PSTR Buffer,
3893 ULONG BufferLen, ULONG ulFlags)
3894 {
3895 struct DeviceInfo *devInfo = GlobalLock((HANDLE)dnDevInst);
3896
3897 TRACE("%x->%p, %p, %u %u\n", dnDevInst, devInfo, Buffer, BufferLen, ulFlags);
3898
3899 if (!devInfo)
3900 return CR_NO_SUCH_DEVINST;
3901
3902 WideCharToMultiByte(CP_ACP, 0, devInfo->instanceId, -1, Buffer, BufferLen, 0, 0);
3903 TRACE("Returning %s\n", debugstr_a(Buffer));
3904 return CR_SUCCESS;
3905 }
3906
3907 /***********************************************************************
3908 * CM_Get_Device_IDW (SETUPAPI.@)
3909 */
3910 CONFIGRET WINAPI CM_Get_Device_IDW( DEVINST dnDevInst, LPWSTR Buffer,
3911 ULONG BufferLen, ULONG ulFlags)
3912 {
3913 struct DeviceInfo *devInfo = GlobalLock((HANDLE)dnDevInst);
3914
3915 TRACE("%x->%p, %p, %u %u\n", dnDevInst, devInfo, Buffer, BufferLen, ulFlags);
3916
3917 if (!devInfo)
3918 {
3919 WARN("dev instance %d not found!\n", dnDevInst);
3920 return CR_NO_SUCH_DEVINST;
3921 }
3922
3923 lstrcpynW(Buffer, devInfo->instanceId, BufferLen);
3924 TRACE("Returning %s\n", debugstr_w(Buffer));
3925 GlobalUnlock((HANDLE)dnDevInst);
3926 return CR_SUCCESS;
3927 }
3928
3929
3930
3931 /***********************************************************************
3932 * CM_Get_Device_ID_Size (SETUPAPI.@)
3933 */
3934 CONFIGRET WINAPI CM_Get_Device_ID_Size( PULONG pulLen, DEVINST dnDevInst,
3935 ULONG ulFlags)
3936 {
3937 struct DeviceInfo *ppdevInfo = GlobalLock((HANDLE)dnDevInst);
3938
3939 TRACE("%x->%p, %p, %u\n", dnDevInst, ppdevInfo, pulLen, ulFlags);
3940
3941 if (!ppdevInfo)
3942 {
3943 WARN("dev instance %d not found!\n", dnDevInst);
3944 return CR_NO_SUCH_DEVINST;
3945 }
3946
3947 *pulLen = lstrlenW(ppdevInfo->instanceId);
3948 GlobalUnlock((HANDLE)dnDevInst);
3949 return CR_SUCCESS;
3950 }
Maarten's multimedia branch