92972cc2319a6ccd7477411a686f2ec9061312e2
[reactos.git] / reactos / base / services / umpnpmgr / umpnpmgr.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2005 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19 /*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS kernel
22 * FILE: services/umpnpmgr/umpnpmgr.c
23 * PURPOSE: User-mode Plug and Play manager
24 * PROGRAMMER: Eric Kohl
25 * Hervé Poussineau (hpoussin@reactos.org)
26 * Colin Finck (colin@reactos.org)
27 */
28
29 /* INCLUDES *****************************************************************/
30 //#define HAVE_SLIST_ENTRY_IMPLEMENTED
31 #define WIN32_NO_STATUS
32 #include <windows.h>
33 #include <stdio.h>
34 #include <cmtypes.h>
35 #include <cmfuncs.h>
36 #include <rtlfuncs.h>
37 #include <setypes.h>
38 #include <umpnpmgr/sysguid.h>
39 #include <wdmguid.h>
40 #include <cfgmgr32.h>
41 #include <regstr.h>
42 #include <userenv.h>
43
44 #include <rpc.h>
45 #include <rpcdce.h>
46
47 #include "pnp_s.h"
48
49 #define NDEBUG
50 #include <debug.h>
51
52 /* GLOBALS ******************************************************************/
53
54 static VOID CALLBACK
55 ServiceMain(DWORD argc, LPTSTR *argv);
56
57 static SERVICE_TABLE_ENTRY ServiceTable[2] =
58 {
59 {TEXT("PlugPlay"), ServiceMain},
60 {NULL, NULL}
61 };
62
63 static WCHAR szRootDeviceId[] = L"HTREE\\ROOT\\0";
64
65 static HKEY hEnumKey = NULL;
66 static HKEY hClassKey = NULL;
67
68 static HANDLE hUserToken = NULL;
69 static HANDLE hInstallEvent = NULL;
70 static HANDLE hNoPendingInstalls = NULL;
71
72 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
73 static SLIST_HEADER DeviceInstallListHead;
74 #else
75 static LIST_ENTRY DeviceInstallListHead;
76 #endif
77 static HANDLE hDeviceInstallListNotEmpty;
78
79 typedef struct
80 {
81 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
82 SLIST_ENTRY ListEntry;
83 #else
84 LIST_ENTRY ListEntry;
85 #endif
86 WCHAR DeviceIds[1];
87 } DeviceInstallParams;
88
89 /* FUNCTIONS *****************************************************************/
90
91 static DWORD WINAPI
92 RpcServerThread(LPVOID lpParameter)
93 {
94 RPC_STATUS Status;
95
96 UNREFERENCED_PARAMETER(lpParameter);
97
98 DPRINT("RpcServerThread() called\n");
99
100 Status = RpcServerUseProtseqEpW(L"ncacn_np",
101 20,
102 L"\\pipe\\umpnpmgr",
103 NULL); // Security descriptor
104 if (Status != RPC_S_OK)
105 {
106 DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
107 return 0;
108 }
109
110 Status = RpcServerRegisterIf(pnp_v1_0_s_ifspec,
111 NULL,
112 NULL);
113 if (Status != RPC_S_OK)
114 {
115 DPRINT1("RpcServerRegisterIf() failed (Status %lx)\n", Status);
116 return 0;
117 }
118
119 Status = RpcServerListen(1,
120 20,
121 FALSE);
122 if (Status != RPC_S_OK)
123 {
124 DPRINT1("RpcServerListen() failed (Status %lx)\n", Status);
125 return 0;
126 }
127
128 /* ROS HACK (this should never happen...) */
129 DPRINT1("*** Other devices won't be installed correctly. If something\n");
130 DPRINT1("*** doesn't work, try to reboot to get a new chance.\n");
131
132 DPRINT("RpcServerThread() done\n");
133
134 return 0;
135 }
136
137
138 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
139 {
140 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
141 }
142
143
144 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
145 {
146 HeapFree(GetProcessHeap(), 0, ptr);
147 }
148
149
150 static CONFIGRET WINAPI
151 NtStatusToCrError(NTSTATUS Status)
152 {
153 switch (Status)
154 {
155 case STATUS_NO_SUCH_DEVICE:
156 return CR_NO_SUCH_DEVINST;
157
158 default:
159 /* FIXME: add more mappings */
160 DPRINT1("Unable to map status 0x%08lx\n", Status);
161 return CR_FAILURE;
162 }
163 }
164
165
166 /* Function 0 */
167 DWORD PNP_Disconnect(
168 handle_t hBinding)
169 {
170 UNREFERENCED_PARAMETER(hBinding);
171 UNIMPLEMENTED;
172 return CR_CALL_NOT_IMPLEMENTED;
173 }
174
175
176 /* Function 1 */
177 DWORD PNP_Connect(
178 handle_t hBinding)
179 {
180 UNREFERENCED_PARAMETER(hBinding);
181 UNIMPLEMENTED;
182 return CR_CALL_NOT_IMPLEMENTED;
183 }
184
185
186 /* Function 2 */
187 DWORD PNP_GetVersion(
188 handle_t hBinding,
189 WORD *pVersion)
190 {
191 UNREFERENCED_PARAMETER(hBinding);
192
193 *pVersion = 0x0400;
194 return CR_SUCCESS;
195 }
196
197
198 /* Function 3 */
199 DWORD PNP_GetGlobalState(
200 handle_t hBinding,
201 DWORD *pulState,
202 DWORD ulFlags)
203 {
204 UNREFERENCED_PARAMETER(hBinding);
205 UNREFERENCED_PARAMETER(ulFlags);
206
207 *pulState = CM_GLOBAL_STATE_CAN_DO_UI | CM_GLOBAL_STATE_SERVICES_AVAILABLE;
208 return CR_SUCCESS;
209 }
210
211
212 /* Function 4 */
213 DWORD PNP_InitDetection(
214 handle_t hBinding)
215 {
216 UNREFERENCED_PARAMETER(hBinding);
217
218 DPRINT("PNP_InitDetection() called\n");
219 return CR_SUCCESS;
220 }
221
222
223 /* Function 5 */
224 DWORD PNP_ReportLogOn(
225 handle_t hBinding,
226 BOOL Admin,
227 DWORD ProcessId)
228 {
229 DWORD ReturnValue = CR_FAILURE;
230 HANDLE hProcess;
231
232 UNREFERENCED_PARAMETER(hBinding);
233 UNREFERENCED_PARAMETER(Admin);
234
235 DPRINT("PNP_ReportLogOn(%u, %u) called\n", Admin, ProcessId);
236
237 /* Get the users token */
238 hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, ProcessId);
239
240 if(!hProcess)
241 {
242 DPRINT1("OpenProcess failed with error %u\n", GetLastError());
243 goto cleanup;
244 }
245
246 if (hUserToken)
247 {
248 CloseHandle(hUserToken);
249 hUserToken = NULL;
250 }
251
252 if(!OpenProcessToken(hProcess, TOKEN_ASSIGN_PRIMARY | TOKEN_DUPLICATE | TOKEN_QUERY, &hUserToken))
253 {
254 DPRINT1("OpenProcessToken failed with error %u\n", GetLastError());
255 goto cleanup;
256 }
257
258 /* Trigger the installer thread */
259 if (hInstallEvent)
260 SetEvent(hInstallEvent);
261
262 ReturnValue = CR_SUCCESS;
263
264 cleanup:
265 if(hProcess)
266 CloseHandle(hProcess);
267
268 return ReturnValue;
269 }
270
271
272 /* Function 6 */
273 DWORD PNP_ValidateDeviceInstance(
274 handle_t hBinding,
275 LPWSTR pDeviceID,
276 DWORD ulFlags)
277 {
278 CONFIGRET ret = CR_SUCCESS;
279 HKEY hDeviceKey = NULL;
280
281 UNREFERENCED_PARAMETER(hBinding);
282 UNREFERENCED_PARAMETER(ulFlags);
283
284 DPRINT("PNP_ValidateDeviceInstance(%S %lx) called\n",
285 pDeviceID, ulFlags);
286
287 if (RegOpenKeyExW(hEnumKey,
288 pDeviceID,
289 0,
290 KEY_READ,
291 &hDeviceKey))
292 {
293 DPRINT("Could not open the Device Key!\n");
294 ret = CR_NO_SUCH_DEVNODE;
295 goto Done;
296 }
297
298 /* FIXME: add more tests */
299
300 Done:
301 if (hDeviceKey != NULL)
302 RegCloseKey(hDeviceKey);
303
304 DPRINT("PNP_ValidateDeviceInstance() done (returns %lx)\n", ret);
305
306 return ret;
307 }
308
309
310 /* Function 7 */
311 DWORD PNP_GetRootDeviceInstance(
312 handle_t hBinding,
313 LPWSTR pDeviceID,
314 PNP_RPC_STRING_LEN ulLength)
315 {
316 CONFIGRET ret = CR_SUCCESS;
317
318 UNREFERENCED_PARAMETER(hBinding);
319
320 DPRINT("PNP_GetRootDeviceInstance() called\n");
321
322 if (!pDeviceID)
323 {
324 ret = CR_INVALID_POINTER;
325 goto Done;
326 }
327 if (ulLength < lstrlenW(szRootDeviceId) + 1)
328 {
329 ret = CR_BUFFER_SMALL;
330 goto Done;
331 }
332
333 lstrcpyW(pDeviceID,
334 szRootDeviceId);
335
336 Done:
337 DPRINT("PNP_GetRootDeviceInstance() done (returns %lx)\n", ret);
338
339 return ret;
340 }
341
342
343 /* Function 8 */
344 DWORD PNP_GetRelatedDeviceInstance(
345 handle_t hBinding,
346 DWORD ulRelationship,
347 LPWSTR pDeviceID,
348 LPWSTR pRelatedDeviceId,
349 PNP_RPC_STRING_LEN *pulLength,
350 DWORD ulFlags)
351 {
352 PLUGPLAY_CONTROL_RELATED_DEVICE_DATA PlugPlayData;
353 CONFIGRET ret = CR_SUCCESS;
354 NTSTATUS Status;
355
356 UNREFERENCED_PARAMETER(hBinding);
357 UNREFERENCED_PARAMETER(ulFlags);
358
359 DPRINT("PNP_GetRelatedDeviceInstance() called\n");
360 DPRINT(" Relationship %ld\n", ulRelationship);
361 DPRINT(" DeviceId %S\n", pDeviceID);
362
363 RtlInitUnicodeString(&PlugPlayData.TargetDeviceInstance,
364 pDeviceID);
365
366 PlugPlayData.Relation = ulRelationship;
367
368 PlugPlayData.RelatedDeviceInstanceLength = *pulLength;
369 PlugPlayData.RelatedDeviceInstance = pRelatedDeviceId;
370
371 Status = NtPlugPlayControl(PlugPlayControlGetRelatedDevice,
372 (PVOID)&PlugPlayData,
373 sizeof(PLUGPLAY_CONTROL_RELATED_DEVICE_DATA));
374 if (!NT_SUCCESS(Status))
375 {
376 ret = NtStatusToCrError(Status);
377 }
378
379 DPRINT("PNP_GetRelatedDeviceInstance() done (returns %lx)\n", ret);
380 if (ret == CR_SUCCESS)
381 {
382 DPRINT("RelatedDevice: %wZ\n", &PlugPlayData.RelatedDeviceInstance);
383 }
384
385 return ret;
386 }
387
388
389 /* Function 9 */
390 DWORD PNP_EnumerateSubKeys(
391 handle_t hBinding,
392 DWORD ulBranch,
393 DWORD ulIndex,
394 LPWSTR Buffer,
395 PNP_RPC_STRING_LEN ulLength,
396 PNP_RPC_STRING_LEN *pulRequiredLen,
397 DWORD ulFlags)
398 {
399 CONFIGRET ret = CR_SUCCESS;
400 HKEY hKey;
401 DWORD dwError;
402
403 UNREFERENCED_PARAMETER(hBinding);
404 UNREFERENCED_PARAMETER(ulFlags);
405
406 DPRINT("PNP_EnumerateSubKeys() called\n");
407
408 switch (ulBranch)
409 {
410 case PNP_ENUMERATOR_SUBKEYS:
411 hKey = hEnumKey;
412 break;
413
414 case PNP_CLASS_SUBKEYS:
415 hKey = hClassKey;
416 break;
417
418 default:
419 return CR_FAILURE;
420 }
421
422 *pulRequiredLen = ulLength;
423 dwError = RegEnumKeyExW(hKey,
424 ulIndex,
425 Buffer,
426 pulRequiredLen,
427 NULL,
428 NULL,
429 NULL,
430 NULL);
431 if (dwError != ERROR_SUCCESS)
432 {
433 ret = (dwError == ERROR_NO_MORE_ITEMS) ? CR_NO_SUCH_VALUE : CR_FAILURE;
434 }
435 else
436 {
437 (*pulRequiredLen)++;
438 }
439
440 DPRINT("PNP_EnumerateSubKeys() done (returns %lx)\n", ret);
441
442 return ret;
443 }
444
445
446 /* Function 10 */
447 DWORD PNP_GetDeviceList(
448 handle_t hBinding,
449 LPWSTR pszFilter,
450 LPWSTR Buffer,
451 PNP_RPC_STRING_LEN *pulLength,
452 DWORD ulFlags)
453 {
454 UNIMPLEMENTED;
455 return CR_CALL_NOT_IMPLEMENTED;
456 }
457
458
459 /* Function 11 */
460 DWORD PNP_GetDeviceListSize(
461 handle_t hBinding,
462 LPWSTR pszFilter,
463 PNP_RPC_BUFFER_SIZE *pulLen,
464 DWORD ulFlags)
465 {
466 UNIMPLEMENTED;
467 return CR_CALL_NOT_IMPLEMENTED;
468 }
469
470
471 /* Function 12 */
472 DWORD PNP_GetDepth(
473 handle_t hBinding,
474 LPWSTR pszDeviceID,
475 DWORD *pulDepth,
476 DWORD ulFlags)
477 {
478 PLUGPLAY_CONTROL_DEPTH_DATA PlugPlayData;
479 CONFIGRET ret = CR_SUCCESS;
480 NTSTATUS Status;
481
482 UNREFERENCED_PARAMETER(hBinding);
483 UNREFERENCED_PARAMETER(ulFlags);
484
485 DPRINT("PNP_GetDepth() called\n");
486
487 RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
488 pszDeviceID);
489
490 Status = NtPlugPlayControl(PlugPlayControlGetDeviceDepth,
491 (PVOID)&PlugPlayData,
492 sizeof(PLUGPLAY_CONTROL_DEPTH_DATA));
493 if (NT_SUCCESS(Status))
494 {
495 *pulDepth = PlugPlayData.Depth;
496 }
497 else
498 {
499 ret = NtStatusToCrError(Status);
500 }
501
502 DPRINT("PNP_GetDepth() done (returns %lx)\n", ret);
503
504 return ret;
505 }
506
507
508 /* Function 13 */
509 DWORD PNP_GetDeviceRegProp(
510 handle_t hBinding,
511 LPWSTR pDeviceID,
512 DWORD ulProperty,
513 DWORD *pulRegDataType,
514 BYTE *Buffer,
515 PNP_PROP_SIZE *pulTransferLen,
516 PNP_PROP_SIZE *pulLength,
517 DWORD ulFlags)
518 {
519 PLUGPLAY_CONTROL_PROPERTY_DATA PlugPlayData;
520 CONFIGRET ret = CR_SUCCESS;
521 LPWSTR lpValueName = NULL;
522 HKEY hKey = 0;
523 NTSTATUS Status;
524
525 UNREFERENCED_PARAMETER(hBinding);
526 UNREFERENCED_PARAMETER(ulFlags);
527
528 DPRINT("PNP_GetDeviceRegProp() called\n");
529
530 switch (ulProperty)
531 {
532 case CM_DRP_DEVICEDESC:
533 lpValueName = L"DeviceDesc";
534 break;
535
536 case CM_DRP_HARDWAREID:
537 lpValueName = L"HardwareID";
538 break;
539
540 case CM_DRP_COMPATIBLEIDS:
541 lpValueName = L"CompatibleIDs";
542 break;
543
544 case CM_DRP_SERVICE:
545 lpValueName = L"Service";
546 break;
547
548 case CM_DRP_CLASS:
549 lpValueName = L"Class";
550 break;
551
552 case CM_DRP_CLASSGUID:
553 lpValueName = L"ClassGUID";
554 break;
555
556 case CM_DRP_DRIVER:
557 lpValueName = L"Driver";
558 break;
559
560 case CM_DRP_CONFIGFLAGS:
561 lpValueName = L"ConfigFlags";
562 break;
563
564 case CM_DRP_MFG:
565 lpValueName = L"Mfg";
566 break;
567
568 case CM_DRP_FRIENDLYNAME:
569 lpValueName = L"FriendlyName";
570 break;
571
572 case CM_DRP_LOCATION_INFORMATION:
573 lpValueName = L"LocationInformation";
574 break;
575
576 case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
577 lpValueName = NULL;
578 break;
579
580 case CM_DRP_CAPABILITIES:
581 lpValueName = L"Capabilities";
582 break;
583
584 case CM_DRP_UI_NUMBER:
585 lpValueName = NULL;
586 break;
587
588 case CM_DRP_UPPERFILTERS:
589 lpValueName = L"UpperFilters";
590 break;
591
592 case CM_DRP_LOWERFILTERS:
593 lpValueName = L"LowerFilters";
594 break;
595
596 case CM_DRP_BUSTYPEGUID:
597 lpValueName = NULL;
598 break;
599
600 case CM_DRP_LEGACYBUSTYPE:
601 lpValueName = NULL;
602 break;
603
604 case CM_DRP_BUSNUMBER:
605 lpValueName = NULL;
606 break;
607
608 case CM_DRP_ENUMERATOR_NAME:
609 lpValueName = NULL;
610 break;
611
612 default:
613 return CR_INVALID_PROPERTY;
614 }
615
616 DPRINT("Value name: %S\n", lpValueName);
617
618 if (lpValueName)
619 {
620 /* Retrieve information from the Registry */
621 if (RegOpenKeyExW(hEnumKey,
622 pDeviceID,
623 0,
624 KEY_ALL_ACCESS,
625 &hKey))
626 return CR_INVALID_DEVNODE;
627
628 if (RegQueryValueExW(hKey,
629 lpValueName,
630 NULL,
631 pulRegDataType,
632 Buffer,
633 pulLength))
634 ret = CR_REGISTRY_ERROR;
635
636 /* FIXME: Check buffer size */
637
638 RegCloseKey(hKey);
639 }
640 else
641 {
642 /* Retrieve information from the Device Node */
643 RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
644 pDeviceID);
645 PlugPlayData.Buffer = Buffer;
646 PlugPlayData.BufferSize = *pulTransferLen;
647
648 switch (ulProperty)
649 {
650 #if 0
651 case CM_DRP_PHYSICAL_DEVICE_OBJECT_NAME:
652 PlugPlayData.Property = DevicePropertyPhysicalDeviceObjectName;
653 break;
654
655 case CM_DRP_UI_NUMBER:
656 PlugPlayData.Property = DevicePropertyUINumber;
657 break;
658
659 case CM_DRP_BUSTYPEGUID:
660 PlugPlayData.Property = DevicePropertyBusTypeGuid;
661 break;
662
663 case CM_DRP_LEGACYBUSTYPE:
664 PlugPlayData.Property = DevicePropertyLegacyBusType;
665 break;
666
667 case CM_DRP_BUSNUMBER:
668 PlugPlayData.Property = DevicePropertyBusNumber;
669 break;
670 #endif
671
672 case CM_DRP_ENUMERATOR_NAME:
673 PlugPlayData.Property = 15; //DevicePropertyEnumeratorName;
674 break;
675
676 default:
677 return CR_INVALID_PROPERTY;
678 }
679
680 Status = NtPlugPlayControl(PlugPlayControlProperty,
681 (PVOID)&PlugPlayData,
682 sizeof(PLUGPLAY_CONTROL_PROPERTY_DATA));
683 if (NT_SUCCESS(Status))
684 {
685 *pulLength = PlugPlayData.BufferSize;
686 }
687 else
688 {
689 ret = NtStatusToCrError(Status);
690 }
691 }
692
693 DPRINT("PNP_GetDeviceRegProp() done (returns %lx)\n", ret);
694
695 return ret;
696 }
697
698
699 /* Function 14 */
700 DWORD PNP_SetDeviceRegProp(
701 handle_t hBinding,
702 LPWSTR pDeviceId,
703 DWORD ulProperty,
704 DWORD ulDataType,
705 BYTE *Buffer,
706 PNP_PROP_SIZE ulLength,
707 DWORD ulFlags)
708 {
709 CONFIGRET ret = CR_SUCCESS;
710 LPWSTR lpValueName = NULL;
711 HKEY hKey = 0;
712
713 UNREFERENCED_PARAMETER(hBinding);
714 UNREFERENCED_PARAMETER(ulFlags);
715
716 DPRINT("PNP_SetDeviceRegProp() called\n");
717
718 DPRINT("DeviceId: %S\n", pDeviceId);
719 DPRINT("Property: %lu\n", ulProperty);
720 DPRINT("DataType: %lu\n", ulDataType);
721 DPRINT("Length: %lu\n", ulLength);
722
723 switch (ulProperty)
724 {
725 case CM_DRP_DEVICEDESC:
726 lpValueName = L"DeviceDesc";
727 break;
728
729 case CM_DRP_HARDWAREID:
730 lpValueName = L"HardwareID";
731 break;
732
733 case CM_DRP_COMPATIBLEIDS:
734 lpValueName = L"CompatibleIDs";
735 break;
736
737 case CM_DRP_SERVICE:
738 lpValueName = L"Service";
739 break;
740
741 case CM_DRP_CLASS:
742 lpValueName = L"Class";
743 break;
744
745 case CM_DRP_CLASSGUID:
746 lpValueName = L"ClassGUID";
747 break;
748
749 case CM_DRP_DRIVER:
750 lpValueName = L"Driver";
751 break;
752
753 case CM_DRP_CONFIGFLAGS:
754 lpValueName = L"ConfigFlags";
755 break;
756
757 case CM_DRP_MFG:
758 lpValueName = L"Mfg";
759 break;
760
761 case CM_DRP_FRIENDLYNAME:
762 lpValueName = L"FriendlyName";
763 break;
764
765 case CM_DRP_LOCATION_INFORMATION:
766 lpValueName = L"LocationInformation";
767 break;
768
769 case CM_DRP_UPPERFILTERS:
770 lpValueName = L"UpperFilters";
771 break;
772
773 case CM_DRP_LOWERFILTERS:
774 lpValueName = L"LowerFilters";
775 break;
776
777 default:
778 return CR_INVALID_PROPERTY;
779 }
780
781 DPRINT("Value name: %S\n", lpValueName);
782
783 if (RegOpenKeyExW(hEnumKey,
784 pDeviceId,
785 0,
786 KEY_ALL_ACCESS, /* FIXME: so much? */
787 &hKey))
788 return CR_INVALID_DEVNODE;
789
790 if (ulLength == 0)
791 {
792 if (RegDeleteValueW(hKey,
793 lpValueName))
794 ret = CR_REGISTRY_ERROR;
795 }
796 else
797 {
798 if (RegSetValueExW(hKey,
799 lpValueName,
800 0,
801 ulDataType,
802 Buffer,
803 ulLength))
804 ret = CR_REGISTRY_ERROR;
805 }
806
807 RegCloseKey(hKey);
808
809 DPRINT("PNP_SetDeviceRegProp() done (returns %lx)\n", ret);
810
811 return ret;
812 }
813
814
815 /* Function 15 */
816 DWORD PNP_GetClassInstance(
817 handle_t hBinding,
818 LPWSTR pDeviceId,
819 LPWSTR pszClassInstance,
820 PNP_RPC_STRING_LEN ulLength)
821 {
822 UNIMPLEMENTED;
823 return CR_CALL_NOT_IMPLEMENTED;
824 }
825
826
827 /* Function 16 */
828 DWORD PNP_CreateKey(
829 handle_t hBinding,
830 LPWSTR pszSubKey,
831 DWORD samDesired,
832 DWORD ulFlags)
833 {
834 UNIMPLEMENTED;
835 return CR_CALL_NOT_IMPLEMENTED;
836 }
837
838
839 /* Function 17 */
840 DWORD PNP_DeleteRegistryKey(
841 handle_t hBinding,
842 LPWSTR pszDeviceID,
843 LPWSTR pszParentKey,
844 LPWSTR pszChildKey,
845 DWORD ulFlags)
846 {
847 UNIMPLEMENTED;
848 return CR_CALL_NOT_IMPLEMENTED;
849 }
850
851
852 /* Function 18 */
853 DWORD PNP_GetClassCount(
854 handle_t hBinding,
855 DWORD *pulClassCount,
856 DWORD ulFlags)
857 {
858 HKEY hKey;
859 DWORD dwError;
860
861 UNREFERENCED_PARAMETER(hBinding);
862 UNREFERENCED_PARAMETER(ulFlags);
863
864 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
865 REGSTR_PATH_CLASS,
866 0,
867 KEY_QUERY_VALUE,
868 &hKey);
869 if (dwError != ERROR_SUCCESS)
870 return CR_INVALID_DATA;
871
872 dwError = RegQueryInfoKeyW(hKey,
873 NULL,
874 NULL,
875 NULL,
876 pulClassCount,
877 NULL,
878 NULL,
879 NULL,
880 NULL,
881 NULL,
882 NULL,
883 NULL);
884 RegCloseKey(hKey);
885 if (dwError != ERROR_SUCCESS)
886 return CR_INVALID_DATA;
887
888 return CR_SUCCESS;
889 }
890
891
892 /* Function 19 */
893 DWORD PNP_GetClassName(
894 handle_t hBinding,
895 LPWSTR pszClassGuid,
896 LPWSTR Buffer,
897 PNP_RPC_STRING_LEN *pulLength,
898 DWORD ulFlags)
899 {
900 WCHAR szKeyName[MAX_PATH];
901 CONFIGRET ret = CR_SUCCESS;
902 HKEY hKey;
903 DWORD dwSize;
904
905 UNREFERENCED_PARAMETER(hBinding);
906 UNREFERENCED_PARAMETER(ulFlags);
907
908 DPRINT("PNP_GetClassName() called\n");
909
910 lstrcpyW(szKeyName, L"System\\CurrentControlSet\\Control\\Class\\");
911 if(lstrlenW(pszClassGuid) + 1 < sizeof(szKeyName)/sizeof(WCHAR)-(lstrlenW(szKeyName) * sizeof(WCHAR)))
912 lstrcatW(szKeyName, pszClassGuid);
913 else return CR_INVALID_DATA;
914
915 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
916 szKeyName,
917 0,
918 KEY_QUERY_VALUE,
919 &hKey))
920 return CR_REGISTRY_ERROR;
921
922 dwSize = *pulLength * sizeof(WCHAR);
923 if (RegQueryValueExW(hKey,
924 L"Class",
925 NULL,
926 NULL,
927 (LPBYTE)Buffer,
928 &dwSize))
929 {
930 *pulLength = 0;
931 ret = CR_REGISTRY_ERROR;
932 }
933 else
934 {
935 *pulLength = dwSize / sizeof(WCHAR);
936 }
937
938 RegCloseKey(hKey);
939
940 DPRINT("PNP_GetClassName() done (returns %lx)\n", ret);
941
942 return ret;
943 }
944
945
946 /* Function 20 */
947 DWORD PNP_DeleteClassKey(
948 handle_t hBinding,
949 LPWSTR pszClassGuid,
950 DWORD ulFlags)
951 {
952 CONFIGRET ret = CR_SUCCESS;
953
954 UNREFERENCED_PARAMETER(hBinding);
955
956 DPRINT("PNP_GetClassName(%S, %lx) called\n", pszClassGuid, ulFlags);
957
958 if (ulFlags & CM_DELETE_CLASS_SUBKEYS)
959 {
960 if (RegDeleteTreeW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
961 ret = CR_REGISTRY_ERROR;
962 }
963 else
964 {
965 if (RegDeleteKeyW(hClassKey, pszClassGuid) != ERROR_SUCCESS)
966 ret = CR_REGISTRY_ERROR;
967 }
968
969 DPRINT("PNP_DeleteClassKey() done (returns %lx)\n", ret);
970
971 return ret;
972 }
973
974
975 /* Function 21 */
976 DWORD PNP_GetInterfaceDeviceAlias(
977 handle_t hBinding,
978 LPWSTR pszInterfaceDevice,
979 GUID *AliasInterfaceGuid,
980 LPWSTR pszAliasInterfaceDevice,
981 PNP_RPC_STRING_LEN *pulLength,
982 PNP_RPC_STRING_LEN *pulTransferLen,
983 DWORD ulFlags)
984 {
985 UNIMPLEMENTED;
986 return CR_CALL_NOT_IMPLEMENTED;
987 }
988
989
990 /* Function 22 */
991 DWORD PNP_GetInterfaceDeviceList(
992 handle_t hBinding,
993 GUID *InterfaceGuid,
994 LPWSTR pszDeviceID,
995 BYTE *Buffer,
996 PNP_RPC_BUFFER_SIZE *pulLength,
997 DWORD ulFlags)
998 {
999 UNIMPLEMENTED;
1000 return CR_CALL_NOT_IMPLEMENTED;
1001 }
1002
1003
1004 /* Function 23 */
1005 DWORD PNP_GetInterfaceDeviceListSize(
1006 handle_t hBinding,
1007 PNP_RPC_BUFFER_SIZE *pulLen,
1008 GUID *InterfaceGuid,
1009 LPWSTR pszDeviceID,
1010 DWORD ulFlags)
1011 {
1012 UNIMPLEMENTED;
1013 return CR_CALL_NOT_IMPLEMENTED;
1014 }
1015
1016
1017 /* Function 24 */
1018 DWORD PNP_RegisterDeviceClassAssociation(
1019 handle_t hBinding,
1020 LPWSTR pszDeviceID,
1021 GUID *InterfaceGuid,
1022 LPWSTR pszReference,
1023 LPWSTR pszSymLink,
1024 PNP_RPC_STRING_LEN *pulLength,
1025 PNP_RPC_STRING_LEN *pulTransferLen,
1026 DWORD ulFlags)
1027 {
1028 UNIMPLEMENTED;
1029 return CR_CALL_NOT_IMPLEMENTED;
1030 }
1031
1032
1033 /* Function 25 */
1034 DWORD PNP_UnregisterDeviceClassAssociation(
1035 handle_t hBinding,
1036 LPWSTR pszInterfaceDevice,
1037 DWORD ulFlags)
1038 {
1039 UNIMPLEMENTED;
1040 return CR_CALL_NOT_IMPLEMENTED;
1041 }
1042
1043
1044 /* Function 26 */
1045 DWORD PNP_GetClassRegProp(
1046 handle_t hBinding,
1047 LPWSTR pszClassGuid,
1048 DWORD ulProperty,
1049 DWORD *pulRegDataType,
1050 BYTE *Buffer,
1051 PNP_RPC_STRING_LEN *pulTransferLen,
1052 PNP_RPC_STRING_LEN *pulLength,
1053 DWORD ulFlags)
1054 {
1055 UNIMPLEMENTED;
1056 return CR_CALL_NOT_IMPLEMENTED;
1057 }
1058
1059
1060 /* Function 27 */
1061 DWORD PNP_SetClassRegProp(
1062 handle_t hBinding,
1063 LPWSTR *pszClassGuid,
1064 DWORD ulProperty,
1065 DWORD ulDataType,
1066 BYTE *Buffer,
1067 PNP_PROP_SIZE ulLength,
1068 DWORD ulFlags)
1069 {
1070 UNIMPLEMENTED;
1071 return CR_CALL_NOT_IMPLEMENTED;
1072 }
1073
1074
1075 /* Function 28 */
1076 DWORD PNP_CreateDevInst(
1077 handle_t hBinding,
1078 LPWSTR pszDeviceID,
1079 LPWSTR pszParentDeviceID,
1080 PNP_RPC_STRING_LEN ulLength,
1081 DWORD ulFlags)
1082 {
1083 UNIMPLEMENTED;
1084 return CR_CALL_NOT_IMPLEMENTED;
1085 }
1086
1087
1088 static CONFIGRET
1089 MoveDeviceInstance(LPWSTR pszDeviceInstanceDestination,
1090 LPWSTR pszDeviceInstanceSource)
1091 {
1092 DPRINT("MoveDeviceInstance: not implemented\n");
1093 /* FIXME */
1094 return CR_CALL_NOT_IMPLEMENTED;
1095 }
1096
1097
1098 static CONFIGRET
1099 SetupDeviceInstance(LPWSTR pszDeviceInstance,
1100 DWORD ulFlags)
1101 {
1102 DPRINT("SetupDeviceInstance: not implemented\n");
1103 /* FIXME */
1104 return CR_CALL_NOT_IMPLEMENTED;
1105 }
1106
1107
1108 static CONFIGRET
1109 EnableDeviceInstance(LPWSTR pszDeviceInstance)
1110 {
1111 PLUGPLAY_CONTROL_RESET_DEVICE_DATA ResetDeviceData;
1112 CONFIGRET ret = CR_SUCCESS;
1113 NTSTATUS Status;
1114
1115 DPRINT("Enable device instance\n");
1116
1117 RtlInitUnicodeString(&ResetDeviceData.DeviceInstance, pszDeviceInstance);
1118 Status = NtPlugPlayControl(PlugPlayControlResetDevice, &ResetDeviceData, sizeof(PLUGPLAY_CONTROL_RESET_DEVICE_DATA));
1119 if (!NT_SUCCESS(Status))
1120 ret = NtStatusToCrError(Status);
1121
1122 return ret;
1123 }
1124
1125
1126 static CONFIGRET
1127 DisableDeviceInstance(LPWSTR pszDeviceInstance)
1128 {
1129 DPRINT("DisableDeviceInstance: not implemented\n");
1130 /* FIXME */
1131 return CR_CALL_NOT_IMPLEMENTED;
1132 }
1133
1134
1135 static CONFIGRET
1136 ReenumerateDeviceInstance(LPWSTR pszDeviceInstance)
1137 {
1138 DPRINT("ReenumerateDeviceInstance: not implemented\n");
1139 /* FIXME */
1140 return CR_CALL_NOT_IMPLEMENTED;
1141 }
1142
1143
1144 /* Function 29 */
1145 DWORD PNP_DeviceInstanceAction(
1146 handle_t hBinding,
1147 DWORD ulAction,
1148 DWORD ulFlags,
1149 LPWSTR pszDeviceInstance1,
1150 LPWSTR pszDeviceInstance2)
1151 {
1152 CONFIGRET ret = CR_SUCCESS;
1153
1154 UNREFERENCED_PARAMETER(hBinding);
1155
1156 DPRINT("PNP_DeviceInstanceAction() called\n");
1157
1158 switch (ulAction)
1159 {
1160 case PNP_DEVINST_MOVE:
1161 ret = MoveDeviceInstance(pszDeviceInstance1,
1162 pszDeviceInstance2);
1163 break;
1164
1165 case PNP_DEVINST_SETUP:
1166 ret = SetupDeviceInstance(pszDeviceInstance1,
1167 ulFlags);
1168 break;
1169
1170 case PNP_DEVINST_ENABLE:
1171 ret = EnableDeviceInstance(pszDeviceInstance1);
1172 break;
1173
1174 case PNP_DEVINST_DISABLE:
1175 ret = DisableDeviceInstance(pszDeviceInstance1);
1176 break;
1177
1178 case PNP_DEVINST_REENUMERATE:
1179 ret = ReenumerateDeviceInstance(pszDeviceInstance1);
1180 break;
1181
1182 default:
1183 DPRINT1("Unknown device action %lu: not implemented\n", ulAction);
1184 ret = CR_CALL_NOT_IMPLEMENTED;
1185 }
1186
1187 DPRINT("PNP_DeviceInstanceAction() done (returns %lx)\n", ret);
1188
1189 return ret;
1190 }
1191
1192
1193 /* Function 30 */
1194 DWORD PNP_GetDeviceStatus(
1195 handle_t hBinding,
1196 LPWSTR pDeviceID,
1197 DWORD *pulStatus,
1198 DWORD *pulProblem,
1199 DWORD ulFlags)
1200 {
1201 PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
1202 CONFIGRET ret = CR_SUCCESS;
1203 NTSTATUS Status;
1204
1205 UNREFERENCED_PARAMETER(hBinding);
1206 UNREFERENCED_PARAMETER(ulFlags);
1207
1208 DPRINT("PNP_GetDeviceStatus() called\n");
1209
1210 RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
1211 pDeviceID);
1212 PlugPlayData.Operation = 0; /* Get status */
1213
1214 Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
1215 (PVOID)&PlugPlayData,
1216 sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
1217 if (NT_SUCCESS(Status))
1218 {
1219 *pulStatus = PlugPlayData.DeviceStatus;
1220 *pulProblem = PlugPlayData.DeviceProblem;
1221 }
1222 else
1223 {
1224 ret = NtStatusToCrError(Status);
1225 }
1226
1227 DPRINT("PNP_GetDeviceStatus() done (returns %lx)\n", ret);
1228
1229 return ret;
1230 }
1231
1232
1233 /* Function 31 */
1234 DWORD PNP_SetDeviceProblem(
1235 handle_t hBinding,
1236 LPWSTR pDeviceID,
1237 DWORD ulProblem,
1238 DWORD ulFlags)
1239 {
1240 UNIMPLEMENTED;
1241 return CR_CALL_NOT_IMPLEMENTED;
1242 }
1243
1244
1245 /* Function 32 */
1246 DWORD PNP_DisableDevInst(
1247 handle_t hBinding,
1248 LPWSTR pDeviceID,
1249 PPNP_VETO_TYPE pVetoType,
1250 LPWSTR pszVetoName,
1251 DWORD ulNameLength,
1252 DWORD ulFlags)
1253 {
1254 UNIMPLEMENTED;
1255 return CR_CALL_NOT_IMPLEMENTED;
1256 }
1257
1258 /* Function 33 */
1259 DWORD PNP_UninstallDevInst(
1260 handle_t hBinding,
1261 LPWSTR pDeviceID,
1262 DWORD ulFlags)
1263 {
1264 UNIMPLEMENTED;
1265 return CR_CALL_NOT_IMPLEMENTED;
1266 }
1267
1268
1269 static BOOL
1270 CheckForDeviceId(LPWSTR lpDeviceIdList,
1271 LPWSTR lpDeviceId)
1272 {
1273 LPWSTR lpPtr;
1274 DWORD dwLength;
1275
1276 lpPtr = lpDeviceIdList;
1277 while (*lpPtr != 0)
1278 {
1279 dwLength = wcslen(lpPtr);
1280 if (0 == _wcsicmp(lpPtr, lpDeviceId))
1281 return TRUE;
1282
1283 lpPtr += (dwLength + 1);
1284 }
1285
1286 return FALSE;
1287 }
1288
1289
1290 static VOID
1291 AppendDeviceId(LPWSTR lpDeviceIdList,
1292 LPDWORD lpDeviceIdListSize,
1293 LPWSTR lpDeviceId)
1294 {
1295 DWORD dwLen;
1296 DWORD dwPos;
1297
1298 dwLen = wcslen(lpDeviceId);
1299 dwPos = (*lpDeviceIdListSize / sizeof(WCHAR)) - 1;
1300
1301 wcscpy(&lpDeviceIdList[dwPos], lpDeviceId);
1302
1303 dwPos += (dwLen + 1);
1304
1305 lpDeviceIdList[dwPos] = 0;
1306
1307 *lpDeviceIdListSize = dwPos * sizeof(WCHAR);
1308 }
1309
1310
1311 /* Function 34 */
1312 DWORD PNP_AddID(
1313 handle_t hBinding,
1314 LPWSTR pszDeviceID,
1315 LPWSTR pszID,
1316 DWORD ulFlags)
1317 {
1318 CONFIGRET ret = CR_SUCCESS;
1319 HKEY hDeviceKey;
1320 LPWSTR pszSubKey;
1321 DWORD dwDeviceIdListSize;
1322 DWORD dwNewDeviceIdSize;
1323 WCHAR * pszDeviceIdList = NULL;
1324
1325 UNREFERENCED_PARAMETER(hBinding);
1326
1327 DPRINT("PNP_AddID() called\n");
1328 DPRINT(" DeviceInstance: %S\n", pszDeviceID);
1329 DPRINT(" DeviceId: %S\n", pszID);
1330 DPRINT(" Flags: %lx\n", ulFlags);
1331
1332 if (RegOpenKeyExW(hEnumKey,
1333 pszDeviceID,
1334 0,
1335 KEY_QUERY_VALUE | KEY_SET_VALUE,
1336 &hDeviceKey) != ERROR_SUCCESS)
1337 {
1338 DPRINT("Failed to open the device key!\n");
1339 return CR_INVALID_DEVNODE;
1340 }
1341
1342 pszSubKey = (ulFlags & CM_ADD_ID_COMPATIBLE) ? L"CompatibleIDs" : L"HardwareID";
1343
1344 if (RegQueryValueExW(hDeviceKey,
1345 pszSubKey,
1346 NULL,
1347 NULL,
1348 NULL,
1349 &dwDeviceIdListSize) != ERROR_SUCCESS)
1350 {
1351 DPRINT("Failed to query the desired ID string!\n");
1352 ret = CR_REGISTRY_ERROR;
1353 goto Done;
1354 }
1355
1356 dwNewDeviceIdSize = lstrlenW(pszDeviceID);
1357 if (!dwNewDeviceIdSize)
1358 {
1359 ret = CR_INVALID_POINTER;
1360 goto Done;
1361 }
1362
1363 dwDeviceIdListSize += (dwNewDeviceIdSize + 2) * sizeof(WCHAR);
1364
1365 pszDeviceIdList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwDeviceIdListSize);
1366 if (!pszDeviceIdList)
1367 {
1368 DPRINT("Failed to allocate memory for the desired ID string!\n");
1369 ret = CR_OUT_OF_MEMORY;
1370 goto Done;
1371 }
1372
1373 if (RegQueryValueExW(hDeviceKey,
1374 pszSubKey,
1375 NULL,
1376 NULL,
1377 (LPBYTE)pszDeviceIdList,
1378 &dwDeviceIdListSize) != ERROR_SUCCESS)
1379 {
1380 DPRINT("Failed to query the desired ID string!\n");
1381 ret = CR_REGISTRY_ERROR;
1382 goto Done;
1383 }
1384
1385 /* Check whether the device ID is already in use */
1386 if (CheckForDeviceId(pszDeviceIdList, pszDeviceID))
1387 {
1388 DPRINT("Device ID was found in the ID string!\n");
1389 ret = CR_SUCCESS;
1390 goto Done;
1391 }
1392
1393 /* Append the Device ID */
1394 AppendDeviceId(pszDeviceIdList, &dwDeviceIdListSize, pszID);
1395
1396 if (RegSetValueExW(hDeviceKey,
1397 pszSubKey,
1398 0,
1399 REG_MULTI_SZ,
1400 (LPBYTE)pszDeviceIdList,
1401 dwDeviceIdListSize) != ERROR_SUCCESS)
1402 {
1403 DPRINT("Failed to set the desired ID string!\n");
1404 ret = CR_REGISTRY_ERROR;
1405 }
1406
1407 Done:
1408 RegCloseKey(hDeviceKey);
1409 if (pszDeviceIdList)
1410 HeapFree(GetProcessHeap(), 0, pszDeviceIdList);
1411
1412 DPRINT("PNP_AddID() done (returns %lx)\n", ret);
1413
1414 return ret;
1415 }
1416
1417
1418 /* Function 35 */
1419 DWORD PNP_RegisterDriver(
1420 handle_t hBinding,
1421 LPWSTR pszDeviceID,
1422 DWORD ulFlags)
1423 {
1424 UNIMPLEMENTED;
1425 return CR_CALL_NOT_IMPLEMENTED;
1426 }
1427
1428
1429 /* Function 36 */
1430 DWORD PNP_QueryRemove(
1431 handle_t hBinding,
1432 LPWSTR pszDeviceID,
1433 PPNP_VETO_TYPE pVetoType,
1434 LPWSTR pszVetoName,
1435 DWORD ulNameLength,
1436 DWORD ulFlags)
1437 {
1438 UNIMPLEMENTED;
1439 return CR_CALL_NOT_IMPLEMENTED;
1440 }
1441
1442
1443 /* Function 37 */
1444 DWORD PNP_RequestDeviceEject(
1445 handle_t hBinding,
1446 LPWSTR pszDeviceID,
1447 PPNP_VETO_TYPE pVetoType,
1448 LPWSTR pszVetoName,
1449 DWORD ulNameLength,
1450 DWORD ulFlags)
1451 {
1452 UNIMPLEMENTED;
1453 return CR_CALL_NOT_IMPLEMENTED;
1454 }
1455
1456 /* Function 38 */
1457 CONFIGRET
1458 PNP_IsDockStationPresent(handle_t hBinding,
1459 BOOL *Present)
1460 {
1461 HKEY hKey;
1462 DWORD dwType;
1463 DWORD dwValue;
1464 DWORD dwSize;
1465 CONFIGRET ret = CR_SUCCESS;
1466
1467 UNREFERENCED_PARAMETER(hBinding);
1468
1469 DPRINT1("PNP_IsDockStationPresent() called\n");
1470
1471 *Present = FALSE;
1472
1473 if (RegOpenKeyExW(HKEY_CURRENT_CONFIG,
1474 L"CurrentDockInfo",
1475 0,
1476 KEY_READ,
1477 &hKey) != ERROR_SUCCESS)
1478 return CR_REGISTRY_ERROR;
1479
1480 dwSize = sizeof(DWORD);
1481 if (RegQueryValueExW(hKey,
1482 L"DockingState",
1483 NULL,
1484 &dwType,
1485 (LPBYTE)&dwValue,
1486 &dwSize) != ERROR_SUCCESS)
1487 ret = CR_REGISTRY_ERROR;
1488
1489 RegCloseKey(hKey);
1490
1491 if (ret == CR_SUCCESS)
1492 {
1493 if (dwType != REG_DWORD || dwSize != sizeof(DWORD))
1494 {
1495 ret = CR_REGISTRY_ERROR;
1496 }
1497 else if (dwValue != 0)
1498 {
1499 *Present = TRUE;
1500 }
1501 }
1502
1503 DPRINT1("PNP_IsDockStationPresent() done (returns %lx)\n", ret);
1504
1505 return ret;
1506 }
1507
1508
1509 /* Function 39 */
1510 DWORD PNP_RequestEjectPC(
1511 handle_t hBinding)
1512 {
1513 UNIMPLEMENTED;
1514 return CR_CALL_NOT_IMPLEMENTED;
1515 }
1516
1517
1518 /* Function 40 */
1519 DWORD PNP_HwProfFlags(
1520 handle_t hBinding,
1521 DWORD ulAction,
1522 LPWSTR pDeviceID,
1523 DWORD ulConfig,
1524 DWORD *pulValue,
1525 PPNP_VETO_TYPE pVetoType,
1526 LPWSTR pszVetoName,
1527 DWORD ulNameLength,
1528 DWORD ulFlags)
1529 {
1530 CONFIGRET ret = CR_SUCCESS;
1531 WCHAR szKeyName[MAX_PATH];
1532 HKEY hKey;
1533 HKEY hDeviceKey;
1534 DWORD dwSize;
1535
1536 UNREFERENCED_PARAMETER(hBinding);
1537
1538 DPRINT("PNP_HwProfFlags() called\n");
1539
1540 if (ulConfig == 0)
1541 {
1542 wcscpy(szKeyName,
1543 L"System\\CurrentControlSet\\HardwareProfiles\\Current\\System\\CurrentControlSet\\Enum");
1544 }
1545 else
1546 {
1547 swprintf(szKeyName,
1548 L"System\\CurrentControlSet\\HardwareProfiles\\%04u\\System\\CurrentControlSet\\Enum",
1549 ulConfig);
1550 }
1551
1552 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE,
1553 szKeyName,
1554 0,
1555 KEY_QUERY_VALUE,
1556 &hKey) != ERROR_SUCCESS)
1557 return CR_REGISTRY_ERROR;
1558
1559 if (ulAction == PNP_GET_HWPROFFLAGS)
1560 {
1561 if (RegOpenKeyExW(hKey,
1562 pDeviceID,
1563 0,
1564 KEY_QUERY_VALUE,
1565 &hDeviceKey) != ERROR_SUCCESS)
1566 {
1567 *pulValue = 0;
1568 }
1569 else
1570 {
1571 dwSize = sizeof(DWORD);
1572 if (!RegQueryValueExW(hDeviceKey,
1573 L"CSConfigFlags",
1574 NULL,
1575 NULL,
1576 (LPBYTE)pulValue,
1577 &dwSize) != ERROR_SUCCESS)
1578 {
1579 *pulValue = 0;
1580 }
1581
1582 RegCloseKey(hDeviceKey);
1583 }
1584 }
1585 else if (ulAction == PNP_SET_HWPROFFLAGS)
1586 {
1587 /* FIXME: not implemented yet */
1588 ret = CR_CALL_NOT_IMPLEMENTED;
1589 }
1590
1591 RegCloseKey(hKey);
1592
1593 return ret;
1594 }
1595
1596
1597 /* Function 41 */
1598 DWORD PNP_GetHwProfInfo(
1599 handle_t hBinding,
1600 DWORD ulIndex,
1601 HWPROFILEINFO *pHWProfileInfo,
1602 DWORD ulProfileInfoSize,
1603 DWORD ulFlags)
1604 {
1605 UNIMPLEMENTED;
1606 return CR_CALL_NOT_IMPLEMENTED;
1607 }
1608
1609
1610 /* Function 42 */
1611 DWORD PNP_AddEmptyLogConf(
1612 handle_t hBinding,
1613 LPWSTR pDeviceID,
1614 DWORD ulPriority,
1615 DWORD *pulLogConfTag,
1616 DWORD ulFlags)
1617 {
1618 UNIMPLEMENTED;
1619 return CR_CALL_NOT_IMPLEMENTED;
1620 }
1621
1622
1623 /* Function 43 */
1624 DWORD PNP_FreeLogConf(
1625 handle_t hBinding,
1626 LPWSTR pDeviceID,
1627 DWORD ulLogConfType,
1628 DWORD ulLogConfTag,
1629 DWORD ulFlags)
1630 {
1631 UNIMPLEMENTED;
1632 return CR_CALL_NOT_IMPLEMENTED;
1633 }
1634
1635
1636 /* Function 44 */
1637 DWORD PNP_GetFirstLogConf(
1638 handle_t hBinding,
1639 LPWSTR pDeviceID,
1640 DWORD ulLogConfType,
1641 DWORD *pulLogConfTag,
1642 DWORD ulFlags)
1643 {
1644 UNIMPLEMENTED;
1645 return CR_CALL_NOT_IMPLEMENTED;
1646 }
1647
1648
1649 /* Function 45 */
1650 DWORD PNP_GetNextLogConf(
1651 handle_t hBinding,
1652 LPWSTR pDeviceID,
1653 DWORD ulLogConfType,
1654 DWORD ulCurrentTag,
1655 DWORD *pulNextTag,
1656 DWORD ulFlags)
1657 {
1658 UNIMPLEMENTED;
1659 return CR_CALL_NOT_IMPLEMENTED;
1660 }
1661
1662
1663 /* Function 46 */
1664 DWORD PNP_GetLogConfPriority(
1665 handle_t hBinding,
1666 LPWSTR pDeviceID,
1667 DWORD ulType,
1668 DWORD ulTag,
1669 DWORD *pPriority,
1670 DWORD ulFlags)
1671 {
1672 UNIMPLEMENTED;
1673 return CR_CALL_NOT_IMPLEMENTED;
1674 }
1675
1676
1677 /* Function 47 */
1678 DWORD PNP_AddResDes(
1679 handle_t hBinding,
1680 LPWSTR pDeviceID,
1681 DWORD ulLogConfTag,
1682 DWORD ulLogConfType,
1683 RESOURCEID ResourceID,
1684 DWORD *pulResourceTag,
1685 BYTE *ResourceData,
1686 PNP_RPC_BUFFER_SIZE ResourceLen,
1687 DWORD ulFlags)
1688 {
1689 UNIMPLEMENTED;
1690 return CR_CALL_NOT_IMPLEMENTED;
1691 }
1692
1693
1694 /* Function 48 */
1695 DWORD PNP_FreeResDes(
1696 handle_t hBinding,
1697 LPWSTR pDeviceID,
1698 DWORD ulLogConfTag,
1699 DWORD ulLogConfType,
1700 RESOURCEID ResourceID,
1701 DWORD ulResourceTag,
1702 DWORD *pulPreviousResType,
1703 DWORD *pulPreviousResTag,
1704 DWORD ulFlags)
1705 {
1706 UNIMPLEMENTED;
1707 return CR_CALL_NOT_IMPLEMENTED;
1708 }
1709
1710
1711 /* Function 49 */
1712 DWORD PNP_GetNextResDes(
1713 handle_t hBinding,
1714 LPWSTR pDeviceID,
1715 DWORD ulLogConfTag,
1716 DWORD ulLogConfType,
1717 RESOURCEID ResourceID,
1718 DWORD ulResourceTag,
1719 DWORD *pulNextResType,
1720 DWORD *pulNextResTag,
1721 DWORD ulFlags)
1722 {
1723 UNIMPLEMENTED;
1724 return CR_CALL_NOT_IMPLEMENTED;
1725 }
1726
1727
1728 /* Function 50 */
1729 DWORD PNP_GetResDesData(
1730 handle_t hBinding,
1731 LPWSTR pDeviceID,
1732 DWORD ulLogConfTag,
1733 DWORD ulLogConfType,
1734 RESOURCEID ResourceID,
1735 DWORD ulResourceTag,
1736 BYTE *Buffer,
1737 PNP_RPC_BUFFER_SIZE BufferLen,
1738 DWORD ulFlags)
1739 {
1740 UNIMPLEMENTED;
1741 return CR_CALL_NOT_IMPLEMENTED;
1742 }
1743
1744
1745 /* Function 51 */
1746 DWORD PNP_GetResDesDataSize(
1747 handle_t hBinding,
1748 LPWSTR pDeviceID,
1749 DWORD ulLogConfTag,
1750 DWORD ulLogConfType,
1751 RESOURCEID ResourceID,
1752 DWORD ulResourceTag,
1753 DWORD *pulSize,
1754 DWORD ulFlags)
1755 {
1756 UNIMPLEMENTED;
1757 return CR_CALL_NOT_IMPLEMENTED;
1758 }
1759
1760
1761 /* Function 52 */
1762 DWORD PNP_ModifyResDes(
1763 handle_t hBinding,
1764 LPWSTR pDeviceID,
1765 DWORD ulLogConfTag,
1766 DWORD ulLogConfType,
1767 RESOURCEID CurrentResourceID,
1768 RESOURCEID NewResourceID,
1769 DWORD ulResourceTag,
1770 BYTE *ResourceData,
1771 PNP_RPC_BUFFER_SIZE ResourceLen,
1772 DWORD ulFlags)
1773 {
1774 UNIMPLEMENTED;
1775 return CR_CALL_NOT_IMPLEMENTED;
1776 }
1777
1778
1779 /* Function 53 */
1780 DWORD PNP_DetectResourceConflict(
1781 handle_t hBinding,
1782 LPWSTR pDeviceID,
1783 RESOURCEID ResourceID,
1784 BYTE *ResourceData,
1785 PNP_RPC_BUFFER_SIZE ResourceLen,
1786 BOOL *pbConflictDetected,
1787 DWORD ulFlags)
1788 {
1789 UNIMPLEMENTED;
1790 return CR_CALL_NOT_IMPLEMENTED;
1791 }
1792
1793
1794 /* Function 54 */
1795 DWORD PNP_QueryResConfList(
1796 handle_t hBinding,
1797 LPWSTR pDeviceID,
1798 RESOURCEID ResourceID,
1799 BYTE *ResourceData,
1800 PNP_RPC_BUFFER_SIZE ResourceLen,
1801 BYTE *Buffer,
1802 PNP_RPC_BUFFER_SIZE BufferLen,
1803 DWORD ulFlags)
1804 {
1805 UNIMPLEMENTED;
1806 return CR_CALL_NOT_IMPLEMENTED;
1807 }
1808
1809
1810 /* Function 55 */
1811 DWORD PNP_SetHwProf(
1812 handle_t hBinding)
1813 {
1814 UNIMPLEMENTED;
1815 return CR_CALL_NOT_IMPLEMENTED;
1816 }
1817
1818
1819 /* Function 56 */
1820 DWORD PNP_QueryArbitratorFreeData(
1821 handle_t hBinding)
1822 {
1823 UNIMPLEMENTED;
1824 return CR_CALL_NOT_IMPLEMENTED;
1825 }
1826
1827
1828 /* Function 57 */
1829 DWORD PNP_QueryArbitratorFreeSize(
1830 handle_t hBinding)
1831 {
1832 UNIMPLEMENTED;
1833 return CR_CALL_NOT_IMPLEMENTED;
1834 }
1835
1836
1837 /* Function 58 */
1838 CONFIGRET
1839 PNP_RunDetection(
1840 handle_t hBinding,
1841 DWORD ulFlags)
1842 {
1843 UNIMPLEMENTED;
1844 return CR_CALL_NOT_IMPLEMENTED;
1845 }
1846
1847
1848 /* Function 59 */
1849 DWORD PNP_RegisterNotification(
1850 handle_t hBinding)
1851 {
1852 UNIMPLEMENTED;
1853 return CR_CALL_NOT_IMPLEMENTED;
1854 }
1855
1856
1857 /* Function 60 */
1858 DWORD PNP_UnregisterNotification(
1859 handle_t hBinding)
1860 {
1861 UNIMPLEMENTED;
1862 return CR_CALL_NOT_IMPLEMENTED;
1863 }
1864
1865
1866 /* Function 61 */
1867 DWORD PNP_GetCustomDevProp(
1868 handle_t hBinding,
1869 LPWSTR pDeviceID,
1870 LPWSTR CustomPropName,
1871 DWORD *pulRegDataType,
1872 BYTE *Buffer,
1873 PNP_RPC_STRING_LEN *pulTransferLen,
1874 PNP_RPC_STRING_LEN *pulLength,
1875 DWORD ulFlags)
1876 {
1877 UNIMPLEMENTED;
1878 return CR_CALL_NOT_IMPLEMENTED;
1879 }
1880
1881
1882 /* Function 62 */
1883 DWORD PNP_GetVersionInternal(
1884 handle_t hBinding,
1885 WORD *pwVersion)
1886 {
1887 UNIMPLEMENTED;
1888 return CR_CALL_NOT_IMPLEMENTED;
1889 }
1890
1891
1892 /* Function 63 */
1893 DWORD PNP_GetBlockedDriverInfo(
1894 handle_t hBinding,
1895 BYTE *Buffer,
1896 PNP_RPC_BUFFER_SIZE *pulTransferLen,
1897 PNP_RPC_BUFFER_SIZE *pulLength,
1898 DWORD ulFlags)
1899 {
1900 UNIMPLEMENTED;
1901 return CR_CALL_NOT_IMPLEMENTED;
1902 }
1903
1904
1905 /* Function 64 */
1906 DWORD PNP_GetServerSideDeviceInstallFlags(
1907 handle_t hBinding,
1908 DWORD *pulSSDIFlags,
1909 DWORD ulFlags)
1910 {
1911 UNIMPLEMENTED;
1912 return CR_CALL_NOT_IMPLEMENTED;
1913 }
1914
1915
1916 /* Function 65 */
1917 DWORD PNP_GetObjectPropKeys(
1918 handle_t hBinding,
1919 LPWSTR ObjectName,
1920 DWORD ObjectType,
1921 LPWSTR PropertyCultureName,
1922 PNP_PROP_COUNT *PropertyCount,
1923 PNP_PROP_COUNT *TransferLen,
1924 DEVPROPKEY *PropertyKeys,
1925 DWORD Flags)
1926 {
1927 UNIMPLEMENTED;
1928 return CR_CALL_NOT_IMPLEMENTED;
1929 }
1930
1931
1932 /* Function 66 */
1933 DWORD PNP_GetObjectProp(
1934 handle_t hBinding,
1935 LPWSTR ObjectName,
1936 DWORD ObjectType,
1937 LPWSTR PropertyCultureName,
1938 const DEVPROPKEY *PropertyKey,
1939 DEVPROPTYPE *PropertyType,
1940 PNP_PROP_SIZE *PropertySize,
1941 PNP_PROP_SIZE *TransferLen,
1942 BYTE *PropertyBuffer,
1943 DWORD Flags)
1944 {
1945 UNIMPLEMENTED;
1946 return CR_CALL_NOT_IMPLEMENTED;
1947 }
1948
1949
1950 /* Function 67 */
1951 DWORD PNP_SetObjectProp(
1952 handle_t hBinding,
1953 LPWSTR ObjectName,
1954 DWORD ObjectType,
1955 LPWSTR PropertyCultureName,
1956 const DEVPROPKEY *PropertyKey,
1957 DEVPROPTYPE PropertyType,
1958 PNP_PROP_SIZE PropertySize,
1959 BYTE *PropertyBuffer,
1960 DWORD Flags)
1961 {
1962 UNIMPLEMENTED;
1963 return CR_CALL_NOT_IMPLEMENTED;
1964 }
1965
1966
1967 /* Function 68 */
1968 DWORD PNP_InstallDevInst(
1969 handle_t hBinding)
1970 {
1971 UNIMPLEMENTED;
1972 return CR_CALL_NOT_IMPLEMENTED;
1973 }
1974
1975
1976 /* Function 69 */
1977 DWORD PNP_ApplyPowerSettings(
1978 handle_t hBinding)
1979 {
1980 UNIMPLEMENTED;
1981 return CR_CALL_NOT_IMPLEMENTED;
1982 }
1983
1984
1985 /* Function 70 */
1986 DWORD PNP_DriverStoreAddDriverPackage(
1987 handle_t hBinding)
1988 {
1989 UNIMPLEMENTED;
1990 return CR_CALL_NOT_IMPLEMENTED;
1991 }
1992
1993
1994 /* Function 71 */
1995 DWORD PNP_DriverStoreDeleteDriverPackage(
1996 handle_t hBinding)
1997 {
1998 UNIMPLEMENTED;
1999 return CR_CALL_NOT_IMPLEMENTED;
2000 }
2001
2002
2003 /* Function 72 */
2004 DWORD PNP_RegisterServiceNotification(
2005 handle_t hBinding)
2006 {
2007 UNIMPLEMENTED;
2008 return CR_CALL_NOT_IMPLEMENTED;
2009 }
2010
2011
2012 /* Function 73 */
2013 DWORD PNP_SetActiveService(
2014 handle_t hBinding)
2015 {
2016 UNIMPLEMENTED;
2017 return CR_CALL_NOT_IMPLEMENTED;
2018 }
2019
2020
2021 /* Function 74 */
2022 DWORD PNP_DeleteServiceDevices(
2023 handle_t hBinding)
2024 {
2025 UNIMPLEMENTED;
2026 return CR_CALL_NOT_IMPLEMENTED;
2027 }
2028
2029
2030 static BOOL
2031 InstallDevice(PCWSTR DeviceInstance, BOOL ShowWizard)
2032 {
2033 PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
2034 NTSTATUS Status;
2035 BOOL DeviceInstalled = FALSE;
2036 DWORD BytesWritten;
2037 DWORD Value;
2038 HANDLE hPipe = INVALID_HANDLE_VALUE;
2039 LPVOID Environment = NULL;
2040 PROCESS_INFORMATION ProcessInfo;
2041 STARTUPINFOW StartupInfo;
2042 UUID RandomUuid;
2043
2044 /* The following lengths are constant (see below), they cannot overflow */
2045 WCHAR CommandLine[116];
2046 WCHAR InstallEventName[73];
2047 WCHAR PipeName[74];
2048 WCHAR UuidString[39];
2049
2050 DPRINT("InstallDevice(%S, %d)\n", DeviceInstance, ShowWizard);
2051
2052 ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
2053
2054 RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
2055 DeviceInstance);
2056 PlugPlayData.Operation = 0; /* Get status */
2057
2058 /* Get device status */
2059 Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
2060 (PVOID)&PlugPlayData,
2061 sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
2062 if (!NT_SUCCESS(Status))
2063 {
2064 DPRINT1("NtPlugPlayControl('%S') failed with status 0x%08lx\n", DeviceInstance, Status);
2065 return FALSE;
2066 }
2067
2068 if ((PlugPlayData.DeviceStatus & (DNF_STARTED | DNF_START_FAILED)) != 0)
2069 {
2070 /* Device is already started, or disabled due to some problem. Don't install it */
2071 DPRINT("No need to install '%S'\n", DeviceInstance);
2072 return TRUE;
2073 }
2074
2075 /* Create a random UUID for the named pipe */
2076 UuidCreate(&RandomUuid);
2077 swprintf(UuidString, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
2078 RandomUuid.Data1, RandomUuid.Data2, RandomUuid.Data3,
2079 RandomUuid.Data4[0], RandomUuid.Data4[1], RandomUuid.Data4[2],
2080 RandomUuid.Data4[3], RandomUuid.Data4[4], RandomUuid.Data4[5],
2081 RandomUuid.Data4[6], RandomUuid.Data4[7]);
2082
2083 /* Create the named pipe */
2084 wcscpy(PipeName, L"\\\\.\\pipe\\PNP_Device_Install_Pipe_0.");
2085 wcscat(PipeName, UuidString);
2086 hPipe = CreateNamedPipeW(PipeName, PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE, 1, 512, 512, 0, NULL);
2087
2088 if(hPipe == INVALID_HANDLE_VALUE)
2089 {
2090 DPRINT1("CreateNamedPipeW failed with error %u\n", GetLastError());
2091 goto cleanup;
2092 }
2093
2094 /* Launch rundll32 to call ClientSideInstallW */
2095 wcscpy(CommandLine, L"rundll32.exe newdev.dll,ClientSideInstall ");
2096 wcscat(CommandLine, PipeName);
2097
2098 ZeroMemory(&StartupInfo, sizeof(StartupInfo));
2099 StartupInfo.cb = sizeof(StartupInfo);
2100
2101 if(hUserToken)
2102 {
2103 /* newdev has to run under the environment of the current user */
2104 if(!CreateEnvironmentBlock(&Environment, hUserToken, FALSE))
2105 {
2106 DPRINT1("CreateEnvironmentBlock failed with error %d\n", GetLastError());
2107 goto cleanup;
2108 }
2109
2110 if(!CreateProcessAsUserW(hUserToken, NULL, CommandLine, NULL, NULL, FALSE, CREATE_UNICODE_ENVIRONMENT, Environment, NULL, &StartupInfo, &ProcessInfo))
2111 {
2112 DPRINT1("CreateProcessAsUserW failed with error %u\n", GetLastError());
2113 goto cleanup;
2114 }
2115 }
2116 else
2117 {
2118 /* FIXME: This is probably not correct, I guess newdev should never be run with SYSTEM privileges.
2119
2120 Still, we currently do that in 2nd stage setup and probably Console mode as well, so allow it here.
2121 (ShowWizard is only set to FALSE for these two modes) */
2122 ASSERT(!ShowWizard);
2123
2124 if(!CreateProcessW(NULL, CommandLine, NULL, NULL, FALSE, 0, NULL, NULL, &StartupInfo, &ProcessInfo))
2125 {
2126 DPRINT1("CreateProcessW failed with error %u\n", GetLastError());
2127 goto cleanup;
2128 }
2129 }
2130
2131 /* Wait for the function to connect to our pipe */
2132 if(!ConnectNamedPipe(hPipe, NULL))
2133 {
2134 DPRINT1("ConnectNamedPipe failed with error %u\n", GetLastError());
2135 goto cleanup;
2136 }
2137
2138 /* Pass the data. The following output is partly compatible to Windows XP SP2 (researched using a modified newdev.dll to log this stuff) */
2139 wcscpy(InstallEventName, L"Global\\PNP_Device_Install_Event_0.");
2140 wcscat(InstallEventName, UuidString);
2141
2142 Value = sizeof(InstallEventName);
2143 WriteFile(hPipe, &Value, sizeof(Value), &BytesWritten, NULL);
2144 WriteFile(hPipe, InstallEventName, Value, &BytesWritten, NULL);
2145
2146 /* I couldn't figure out what the following value means under WinXP. It's usually 0 in my tests, but was also 5 once.
2147 Therefore the following line is entirely ReactOS-specific. We use the value here to pass the ShowWizard variable. */
2148 WriteFile(hPipe, &ShowWizard, sizeof(ShowWizard), &BytesWritten, NULL);
2149
2150 Value = (wcslen(DeviceInstance) + 1) * sizeof(WCHAR);
2151 WriteFile(hPipe, &Value, sizeof(Value), &BytesWritten, NULL);
2152 WriteFile(hPipe, DeviceInstance, Value, &BytesWritten, NULL);
2153
2154 /* Wait for newdev.dll to finish processing */
2155 WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
2156
2157 /* The following check for success is probably not compatible to Windows, but should do its job */
2158 if(!GetExitCodeProcess(ProcessInfo.hProcess, &Value))
2159 {
2160 DPRINT1("GetExitCodeProcess failed with error %u\n", GetLastError());
2161 goto cleanup;
2162 }
2163
2164 DeviceInstalled = Value;
2165
2166 cleanup:
2167 if(hPipe != INVALID_HANDLE_VALUE)
2168 CloseHandle(hPipe);
2169
2170 if(Environment)
2171 DestroyEnvironmentBlock(Environment);
2172
2173 if(ProcessInfo.hProcess)
2174 CloseHandle(ProcessInfo.hProcess);
2175
2176 if(ProcessInfo.hThread)
2177 CloseHandle(ProcessInfo.hThread);
2178
2179 return DeviceInstalled;
2180 }
2181
2182
2183 static LONG
2184 ReadRegSzKey(
2185 IN HKEY hKey,
2186 IN LPCWSTR pszKey,
2187 OUT LPWSTR* pValue)
2188 {
2189 LONG rc;
2190 DWORD dwType;
2191 DWORD cbData = 0;
2192 LPWSTR Value;
2193
2194 if (!pValue)
2195 return ERROR_INVALID_PARAMETER;
2196
2197 *pValue = NULL;
2198 rc = RegQueryValueExW(hKey, pszKey, NULL, &dwType, NULL, &cbData);
2199 if (rc != ERROR_SUCCESS)
2200 return rc;
2201 if (dwType != REG_SZ)
2202 return ERROR_FILE_NOT_FOUND;
2203 Value = HeapAlloc(GetProcessHeap(), 0, cbData + sizeof(WCHAR));
2204 if (!Value)
2205 return ERROR_NOT_ENOUGH_MEMORY;
2206 rc = RegQueryValueExW(hKey, pszKey, NULL, NULL, (LPBYTE)Value, &cbData);
2207 if (rc != ERROR_SUCCESS)
2208 {
2209 HeapFree(GetProcessHeap(), 0, Value);
2210 return rc;
2211 }
2212 /* NULL-terminate the string */
2213 Value[cbData / sizeof(WCHAR)] = '\0';
2214
2215 *pValue = Value;
2216 return ERROR_SUCCESS;
2217 }
2218
2219
2220 static BOOL
2221 SetupIsActive(VOID)
2222 {
2223 HKEY hKey = NULL;
2224 DWORD regType, active, size;
2225 LONG rc;
2226 BOOL ret = FALSE;
2227
2228 rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\Setup", 0, KEY_QUERY_VALUE, &hKey);
2229 if (rc != ERROR_SUCCESS)
2230 goto cleanup;
2231
2232 size = sizeof(DWORD);
2233 rc = RegQueryValueExW(hKey, L"SystemSetupInProgress", NULL, &regType, (LPBYTE)&active, &size);
2234 if (rc != ERROR_SUCCESS)
2235 goto cleanup;
2236 if (regType != REG_DWORD || size != sizeof(DWORD))
2237 goto cleanup;
2238
2239 ret = (active != 0);
2240
2241 cleanup:
2242 if (hKey != NULL)
2243 RegCloseKey(hKey);
2244
2245 DPRINT("System setup in progress? %S\n", ret ? L"YES" : L"NO");
2246
2247 return ret;
2248 }
2249
2250
2251 static BOOL
2252 IsConsoleBoot(VOID)
2253 {
2254 HKEY ControlKey = NULL;
2255 LPWSTR SystemStartOptions = NULL;
2256 LPWSTR CurrentOption, NextOption; /* Pointers into SystemStartOptions */
2257 BOOL ConsoleBoot = FALSE;
2258 LONG rc;
2259
2260 rc = RegOpenKeyExW(
2261 HKEY_LOCAL_MACHINE,
2262 L"SYSTEM\\CurrentControlSet\\Control",
2263 0,
2264 KEY_QUERY_VALUE,
2265 &ControlKey);
2266
2267 rc = ReadRegSzKey(ControlKey, L"SystemStartOptions", &SystemStartOptions);
2268 if (rc != ERROR_SUCCESS)
2269 goto cleanup;
2270
2271 /* Check for CMDCONS in SystemStartOptions */
2272 CurrentOption = SystemStartOptions;
2273 while (CurrentOption)
2274 {
2275 NextOption = wcschr(CurrentOption, L' ');
2276 if (NextOption)
2277 *NextOption = L'\0';
2278 if (_wcsicmp(CurrentOption, L"CONSOLE") == 0)
2279 {
2280 DPRINT("Found %S. Switching to console boot\n", CurrentOption);
2281 ConsoleBoot = TRUE;
2282 goto cleanup;
2283 }
2284 CurrentOption = NextOption ? NextOption + 1 : NULL;
2285 }
2286
2287 cleanup:
2288 if (ControlKey != NULL)
2289 RegCloseKey(ControlKey);
2290 HeapFree(GetProcessHeap(), 0, SystemStartOptions);
2291 return ConsoleBoot;
2292 }
2293
2294
2295 /* Loop to install all queued devices installations */
2296 static DWORD WINAPI
2297 DeviceInstallThread(LPVOID lpParameter)
2298 {
2299 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2300 PSLIST_ENTRY ListEntry;
2301 #else
2302 PLIST_ENTRY ListEntry;
2303 #endif
2304 DeviceInstallParams* Params;
2305 BOOL showWizard;
2306
2307 UNREFERENCED_PARAMETER(lpParameter);
2308
2309 WaitForSingleObject(hInstallEvent, INFINITE);
2310
2311 showWizard = !SetupIsActive() && !IsConsoleBoot();
2312
2313 while (TRUE)
2314 {
2315 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2316 ListEntry = InterlockedPopEntrySList(&DeviceInstallListHead);
2317 #else
2318 if ((BOOL)IsListEmpty(&DeviceInstallListHead))
2319 ListEntry = NULL;
2320 else
2321 ListEntry = RemoveHeadList(&DeviceInstallListHead);
2322 #endif
2323 if (ListEntry == NULL)
2324 {
2325 SetEvent(hNoPendingInstalls);
2326 WaitForSingleObject(hDeviceInstallListNotEmpty, INFINITE);
2327 }
2328 else
2329 {
2330 ResetEvent(hNoPendingInstalls);
2331 Params = CONTAINING_RECORD(ListEntry, DeviceInstallParams, ListEntry);
2332 InstallDevice(Params->DeviceIds, showWizard);
2333 }
2334 }
2335
2336 return 0;
2337 }
2338
2339
2340 static DWORD WINAPI
2341 PnpEventThread(LPVOID lpParameter)
2342 {
2343 PPLUGPLAY_EVENT_BLOCK PnpEvent;
2344 ULONG PnpEventSize;
2345 NTSTATUS Status;
2346 RPC_STATUS RpcStatus;
2347
2348 UNREFERENCED_PARAMETER(lpParameter);
2349
2350 PnpEventSize = 0x1000;
2351 PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
2352 if (PnpEvent == NULL)
2353 return ERROR_OUTOFMEMORY;
2354
2355 for (;;)
2356 {
2357 DPRINT("Calling NtGetPlugPlayEvent()\n");
2358
2359 /* Wait for the next pnp event */
2360 Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
2361
2362 /* Resize the buffer for the PnP event if it's too small. */
2363 if (Status == STATUS_BUFFER_TOO_SMALL)
2364 {
2365 PnpEventSize += 0x400;
2366 HeapFree(GetProcessHeap(), 0, PnpEvent);
2367 PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
2368 if (PnpEvent == NULL)
2369 return ERROR_OUTOFMEMORY;
2370 continue;
2371 }
2372
2373 if (!NT_SUCCESS(Status))
2374 {
2375 DPRINT("NtGetPlugPlayEvent() failed (Status %lx)\n", Status);
2376 break;
2377 }
2378
2379 /* Process the pnp event */
2380 DPRINT("Received PnP Event\n");
2381 if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ENUMERATED, &RpcStatus))
2382 {
2383 DeviceInstallParams* Params;
2384 DWORD len;
2385 DWORD DeviceIdLength;
2386
2387 DPRINT("Device enumerated: %S\n", PnpEvent->TargetDevice.DeviceIds);
2388
2389 DeviceIdLength = lstrlenW(PnpEvent->TargetDevice.DeviceIds);
2390 if (DeviceIdLength)
2391 {
2392 /* Queue device install (will be dequeued by DeviceInstallThread */
2393 len = FIELD_OFFSET(DeviceInstallParams, DeviceIds) + (DeviceIdLength + 1) * sizeof(WCHAR);
2394 Params = HeapAlloc(GetProcessHeap(), 0, len);
2395 if (Params)
2396 {
2397 wcscpy(Params->DeviceIds, PnpEvent->TargetDevice.DeviceIds);
2398 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2399 InterlockedPushEntrySList(&DeviceInstallListHead, &Params->ListEntry);
2400 #else
2401 InsertTailList(&DeviceInstallListHead, &Params->ListEntry);
2402 #endif
2403 SetEvent(hDeviceInstallListNotEmpty);
2404 }
2405 }
2406 }
2407 else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ARRIVAL, &RpcStatus))
2408 {
2409 DPRINT("Device arrival: %S\n", PnpEvent->TargetDevice.DeviceIds);
2410 /* FIXME: ? */
2411 }
2412 else
2413 {
2414 DPRINT1("Unknown event, GUID {%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}\n",
2415 PnpEvent->EventGuid.Data1, PnpEvent->EventGuid.Data2, PnpEvent->EventGuid.Data3,
2416 PnpEvent->EventGuid.Data4[0], PnpEvent->EventGuid.Data4[1], PnpEvent->EventGuid.Data4[2],
2417 PnpEvent->EventGuid.Data4[3], PnpEvent->EventGuid.Data4[4], PnpEvent->EventGuid.Data4[5],
2418 PnpEvent->EventGuid.Data4[6], PnpEvent->EventGuid.Data4[7]);
2419 }
2420
2421 /* Dequeue the current pnp event and signal the next one */
2422 NtPlugPlayControl(PlugPlayControlUserResponse, NULL, 0);
2423 }
2424
2425 HeapFree(GetProcessHeap(), 0, PnpEvent);
2426
2427 return ERROR_SUCCESS;
2428 }
2429
2430
2431 static VOID CALLBACK
2432 ServiceMain(DWORD argc, LPTSTR *argv)
2433 {
2434 HANDLE hThread;
2435 DWORD dwThreadId;
2436
2437 UNREFERENCED_PARAMETER(argc);
2438 UNREFERENCED_PARAMETER(argv);
2439
2440 DPRINT("ServiceMain() called\n");
2441
2442 hThread = CreateThread(NULL,
2443 0,
2444 PnpEventThread,
2445 NULL,
2446 0,
2447 &dwThreadId);
2448 if (hThread != NULL)
2449 CloseHandle(hThread);
2450
2451 hThread = CreateThread(NULL,
2452 0,
2453 RpcServerThread,
2454 NULL,
2455 0,
2456 &dwThreadId);
2457 if (hThread != NULL)
2458 CloseHandle(hThread);
2459
2460 hThread = CreateThread(NULL,
2461 0,
2462 DeviceInstallThread,
2463 NULL,
2464 0,
2465 &dwThreadId);
2466 if (hThread != NULL)
2467 CloseHandle(hThread);
2468
2469 DPRINT("ServiceMain() done\n");
2470 }
2471
2472
2473 int
2474 wmain(int argc, WCHAR *argv[])
2475 {
2476 BOOLEAN OldValue;
2477 DWORD dwError;
2478
2479 UNREFERENCED_PARAMETER(argc);
2480 UNREFERENCED_PARAMETER(argv);
2481
2482 DPRINT("Umpnpmgr: main() started\n");
2483
2484 /* We need this privilege for using CreateProcessAsUserW */
2485 RtlAdjustPrivilege(SE_ASSIGNPRIMARYTOKEN_PRIVILEGE, TRUE, FALSE, &OldValue);
2486
2487 hInstallEvent = CreateEvent(NULL, TRUE, SetupIsActive()/*FALSE*/, NULL);
2488 if (hInstallEvent == NULL)
2489 {
2490 dwError = GetLastError();
2491 DPRINT1("Could not create the Install Event! (Error %lu)\n", dwError);
2492 return dwError;
2493 }
2494
2495 hDeviceInstallListNotEmpty = CreateEvent(NULL, FALSE, FALSE, NULL);
2496 if (hDeviceInstallListNotEmpty == NULL)
2497 {
2498 dwError = GetLastError();
2499 DPRINT1("Could not create the Event! (Error %lu)\n", dwError);
2500 return dwError;
2501 }
2502
2503 hNoPendingInstalls = CreateEventW(NULL,
2504 TRUE,
2505 FALSE,
2506 L"Global\\PnP_No_Pending_Install_Events");
2507 if (hNoPendingInstalls == NULL)
2508 {
2509 dwError = GetLastError();
2510 DPRINT1("Could not create the Event! (Error %lu)\n", dwError);
2511 return dwError;
2512 }
2513
2514 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2515 InitializeSListHead(&DeviceInstallListHead);
2516 #else
2517 InitializeListHead(&DeviceInstallListHead);
2518 #endif
2519
2520 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2521 L"System\\CurrentControlSet\\Enum",
2522 0,
2523 KEY_ALL_ACCESS,
2524 &hEnumKey);
2525 if (dwError != ERROR_SUCCESS)
2526 {
2527 DPRINT1("Could not open the Enum Key! (Error %lu)\n", dwError);
2528 return dwError;
2529 }
2530
2531 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2532 L"System\\CurrentControlSet\\Control\\Class",
2533 0,
2534 KEY_ALL_ACCESS,
2535 &hClassKey);
2536 if (dwError != ERROR_SUCCESS)
2537 {
2538 DPRINT1("Could not open the Class Key! (Error %lu)\n", dwError);
2539 return dwError;
2540 }
2541
2542 StartServiceCtrlDispatcher(ServiceTable);
2543
2544 DPRINT("Umpnpmgr: main() done\n");
2545
2546 ExitThread(0);
2547
2548 return 0;
2549 }
2550
2551 /* EOF */