[umpnpmgr]
[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 UNIMPLEMENTED;
1531 return CR_CALL_NOT_IMPLEMENTED;
1532 }
1533
1534
1535 /* Function 41 */
1536 DWORD PNP_GetHwProfInfo(
1537 handle_t hBinding,
1538 DWORD ulIndex,
1539 HWPROFILEINFO *pHWProfileInfo,
1540 DWORD ulProfileInfoSize,
1541 DWORD ulFlags)
1542 {
1543 UNIMPLEMENTED;
1544 return CR_CALL_NOT_IMPLEMENTED;
1545 }
1546
1547
1548 /* Function 42 */
1549 DWORD PNP_AddEmptyLogConf(
1550 handle_t hBinding,
1551 LPWSTR pDeviceID,
1552 DWORD ulPriority,
1553 DWORD *pulLogConfTag,
1554 DWORD ulFlags)
1555 {
1556 UNIMPLEMENTED;
1557 return CR_CALL_NOT_IMPLEMENTED;
1558 }
1559
1560
1561 /* Function 43 */
1562 DWORD PNP_FreeLogConf(
1563 handle_t hBinding,
1564 LPWSTR pDeviceID,
1565 DWORD ulLogConfType,
1566 DWORD ulLogConfTag,
1567 DWORD ulFlags)
1568 {
1569 UNIMPLEMENTED;
1570 return CR_CALL_NOT_IMPLEMENTED;
1571 }
1572
1573
1574 /* Function 44 */
1575 DWORD PNP_GetFirstLogConf(
1576 handle_t hBinding,
1577 LPWSTR pDeviceID,
1578 DWORD ulLogConfType,
1579 DWORD *pulLogConfTag,
1580 DWORD ulFlags)
1581 {
1582 UNIMPLEMENTED;
1583 return CR_CALL_NOT_IMPLEMENTED;
1584 }
1585
1586
1587 /* Function 45 */
1588 DWORD PNP_GetNextLogConf(
1589 handle_t hBinding,
1590 LPWSTR pDeviceID,
1591 DWORD ulLogConfType,
1592 DWORD ulCurrentTag,
1593 DWORD *pulNextTag,
1594 DWORD ulFlags)
1595 {
1596 UNIMPLEMENTED;
1597 return CR_CALL_NOT_IMPLEMENTED;
1598 }
1599
1600
1601 /* Function 46 */
1602 DWORD PNP_GetLogConfPriority(
1603 handle_t hBinding,
1604 LPWSTR pDeviceID,
1605 DWORD ulType,
1606 DWORD ulTag,
1607 DWORD *pPriority,
1608 DWORD ulFlags)
1609 {
1610 UNIMPLEMENTED;
1611 return CR_CALL_NOT_IMPLEMENTED;
1612 }
1613
1614
1615 /* Function 47 */
1616 DWORD PNP_AddResDes(
1617 handle_t hBinding,
1618 LPWSTR pDeviceID,
1619 DWORD ulLogConfTag,
1620 DWORD ulLogConfType,
1621 RESOURCEID ResourceID,
1622 DWORD *pulResourceTag,
1623 BYTE *ResourceData,
1624 PNP_RPC_BUFFER_SIZE ResourceLen,
1625 DWORD ulFlags)
1626 {
1627 UNIMPLEMENTED;
1628 return CR_CALL_NOT_IMPLEMENTED;
1629 }
1630
1631
1632 /* Function 48 */
1633 DWORD PNP_FreeResDes(
1634 handle_t hBinding,
1635 LPWSTR pDeviceID,
1636 DWORD ulLogConfTag,
1637 DWORD ulLogConfType,
1638 RESOURCEID ResourceID,
1639 DWORD ulResourceTag,
1640 DWORD *pulPreviousResType,
1641 DWORD *pulPreviousResTag,
1642 DWORD ulFlags)
1643 {
1644 UNIMPLEMENTED;
1645 return CR_CALL_NOT_IMPLEMENTED;
1646 }
1647
1648
1649 /* Function 49 */
1650 DWORD PNP_GetNextResDes(
1651 handle_t hBinding,
1652 LPWSTR pDeviceID,
1653 DWORD ulLogConfTag,
1654 DWORD ulLogConfType,
1655 RESOURCEID ResourceID,
1656 DWORD ulResourceTag,
1657 DWORD *pulNextResType,
1658 DWORD *pulNextResTag,
1659 DWORD ulFlags)
1660 {
1661 UNIMPLEMENTED;
1662 return CR_CALL_NOT_IMPLEMENTED;
1663 }
1664
1665
1666 /* Function 50 */
1667 DWORD PNP_GetResDesData(
1668 handle_t hBinding,
1669 LPWSTR pDeviceID,
1670 DWORD ulLogConfTag,
1671 DWORD ulLogConfType,
1672 RESOURCEID ResourceID,
1673 DWORD ulResourceTag,
1674 BYTE *Buffer,
1675 PNP_RPC_BUFFER_SIZE BufferLen,
1676 DWORD ulFlags)
1677 {
1678 UNIMPLEMENTED;
1679 return CR_CALL_NOT_IMPLEMENTED;
1680 }
1681
1682
1683 /* Function 51 */
1684 DWORD PNP_GetResDesDataSize(
1685 handle_t hBinding,
1686 LPWSTR pDeviceID,
1687 DWORD ulLogConfTag,
1688 DWORD ulLogConfType,
1689 RESOURCEID ResourceID,
1690 DWORD ulResourceTag,
1691 DWORD *pulSize,
1692 DWORD ulFlags)
1693 {
1694 UNIMPLEMENTED;
1695 return CR_CALL_NOT_IMPLEMENTED;
1696 }
1697
1698
1699 /* Function 52 */
1700 DWORD PNP_ModifyResDes(
1701 handle_t hBinding,
1702 LPWSTR pDeviceID,
1703 DWORD ulLogConfTag,
1704 DWORD ulLogConfType,
1705 RESOURCEID CurrentResourceID,
1706 RESOURCEID NewResourceID,
1707 DWORD ulResourceTag,
1708 BYTE *ResourceData,
1709 PNP_RPC_BUFFER_SIZE ResourceLen,
1710 DWORD ulFlags)
1711 {
1712 UNIMPLEMENTED;
1713 return CR_CALL_NOT_IMPLEMENTED;
1714 }
1715
1716
1717 /* Function 53 */
1718 DWORD PNP_DetectResourceConflict(
1719 handle_t hBinding,
1720 LPWSTR pDeviceID,
1721 RESOURCEID ResourceID,
1722 BYTE *ResourceData,
1723 PNP_RPC_BUFFER_SIZE ResourceLen,
1724 BOOL *pbConflictDetected,
1725 DWORD ulFlags)
1726 {
1727 UNIMPLEMENTED;
1728 return CR_CALL_NOT_IMPLEMENTED;
1729 }
1730
1731
1732 /* Function 54 */
1733 DWORD PNP_QueryResConfList(
1734 handle_t hBinding,
1735 LPWSTR pDeviceID,
1736 RESOURCEID ResourceID,
1737 BYTE *ResourceData,
1738 PNP_RPC_BUFFER_SIZE ResourceLen,
1739 BYTE *Buffer,
1740 PNP_RPC_BUFFER_SIZE BufferLen,
1741 DWORD ulFlags)
1742 {
1743 UNIMPLEMENTED;
1744 return CR_CALL_NOT_IMPLEMENTED;
1745 }
1746
1747
1748 /* Function 55 */
1749 DWORD PNP_SetHwProf(
1750 handle_t hBinding)
1751 {
1752 UNIMPLEMENTED;
1753 return CR_CALL_NOT_IMPLEMENTED;
1754 }
1755
1756
1757 /* Function 56 */
1758 DWORD PNP_QueryArbitratorFreeData(
1759 handle_t hBinding)
1760 {
1761 UNIMPLEMENTED;
1762 return CR_CALL_NOT_IMPLEMENTED;
1763 }
1764
1765
1766 /* Function 57 */
1767 DWORD PNP_QueryArbitratorFreeSize(
1768 handle_t hBinding)
1769 {
1770 UNIMPLEMENTED;
1771 return CR_CALL_NOT_IMPLEMENTED;
1772 }
1773
1774
1775 /* Function 58 */
1776 CONFIGRET
1777 PNP_RunDetection(
1778 handle_t hBinding,
1779 DWORD ulFlags)
1780 {
1781 UNIMPLEMENTED;
1782 return CR_CALL_NOT_IMPLEMENTED;
1783 }
1784
1785
1786 /* Function 59 */
1787 DWORD PNP_RegisterNotification(
1788 handle_t hBinding)
1789 {
1790 UNIMPLEMENTED;
1791 return CR_CALL_NOT_IMPLEMENTED;
1792 }
1793
1794
1795 /* Function 60 */
1796 DWORD PNP_UnregisterNotification(
1797 handle_t hBinding)
1798 {
1799 UNIMPLEMENTED;
1800 return CR_CALL_NOT_IMPLEMENTED;
1801 }
1802
1803
1804 /* Function 61 */
1805 DWORD PNP_GetCustomDevProp(
1806 handle_t hBinding,
1807 LPWSTR pDeviceID,
1808 LPWSTR CustomPropName,
1809 DWORD *pulRegDataType,
1810 BYTE *Buffer,
1811 PNP_RPC_STRING_LEN *pulTransferLen,
1812 PNP_RPC_STRING_LEN *pulLength,
1813 DWORD ulFlags)
1814 {
1815 UNIMPLEMENTED;
1816 return CR_CALL_NOT_IMPLEMENTED;
1817 }
1818
1819
1820 /* Function 62 */
1821 DWORD PNP_GetVersionInternal(
1822 handle_t hBinding,
1823 WORD *pwVersion)
1824 {
1825 UNIMPLEMENTED;
1826 return CR_CALL_NOT_IMPLEMENTED;
1827 }
1828
1829
1830 /* Function 63 */
1831 DWORD PNP_GetBlockedDriverInfo(
1832 handle_t hBinding,
1833 BYTE *Buffer,
1834 PNP_RPC_BUFFER_SIZE *pulTransferLen,
1835 PNP_RPC_BUFFER_SIZE *pulLength,
1836 DWORD ulFlags)
1837 {
1838 UNIMPLEMENTED;
1839 return CR_CALL_NOT_IMPLEMENTED;
1840 }
1841
1842
1843 /* Function 64 */
1844 DWORD PNP_GetServerSideDeviceInstallFlags(
1845 handle_t hBinding,
1846 DWORD *pulSSDIFlags,
1847 DWORD ulFlags)
1848 {
1849 UNIMPLEMENTED;
1850 return CR_CALL_NOT_IMPLEMENTED;
1851 }
1852
1853
1854 /* Function 65 */
1855 DWORD PNP_GetObjectPropKeys(
1856 handle_t hBinding,
1857 LPWSTR ObjectName,
1858 DWORD ObjectType,
1859 LPWSTR PropertyCultureName,
1860 PNP_PROP_COUNT *PropertyCount,
1861 PNP_PROP_COUNT *TransferLen,
1862 DEVPROPKEY *PropertyKeys,
1863 DWORD Flags)
1864 {
1865 UNIMPLEMENTED;
1866 return CR_CALL_NOT_IMPLEMENTED;
1867 }
1868
1869
1870 /* Function 66 */
1871 DWORD PNP_GetObjectProp(
1872 handle_t hBinding,
1873 LPWSTR ObjectName,
1874 DWORD ObjectType,
1875 LPWSTR PropertyCultureName,
1876 const DEVPROPKEY *PropertyKey,
1877 DEVPROPTYPE *PropertyType,
1878 PNP_PROP_SIZE *PropertySize,
1879 PNP_PROP_SIZE *TransferLen,
1880 BYTE *PropertyBuffer,
1881 DWORD Flags)
1882 {
1883 UNIMPLEMENTED;
1884 return CR_CALL_NOT_IMPLEMENTED;
1885 }
1886
1887
1888 /* Function 67 */
1889 DWORD PNP_SetObjectProp(
1890 handle_t hBinding,
1891 LPWSTR ObjectName,
1892 DWORD ObjectType,
1893 LPWSTR PropertyCultureName,
1894 const DEVPROPKEY *PropertyKey,
1895 DEVPROPTYPE PropertyType,
1896 PNP_PROP_SIZE PropertySize,
1897 BYTE *PropertyBuffer,
1898 DWORD Flags)
1899 {
1900 UNIMPLEMENTED;
1901 return CR_CALL_NOT_IMPLEMENTED;
1902 }
1903
1904
1905 /* Function 68 */
1906 DWORD PNP_InstallDevInst(
1907 handle_t hBinding)
1908 {
1909 UNIMPLEMENTED;
1910 return CR_CALL_NOT_IMPLEMENTED;
1911 }
1912
1913
1914 /* Function 69 */
1915 DWORD PNP_ApplyPowerSettings(
1916 handle_t hBinding)
1917 {
1918 UNIMPLEMENTED;
1919 return CR_CALL_NOT_IMPLEMENTED;
1920 }
1921
1922
1923 /* Function 70 */
1924 DWORD PNP_DriverStoreAddDriverPackage(
1925 handle_t hBinding)
1926 {
1927 UNIMPLEMENTED;
1928 return CR_CALL_NOT_IMPLEMENTED;
1929 }
1930
1931
1932 /* Function 71 */
1933 DWORD PNP_DriverStoreDeleteDriverPackage(
1934 handle_t hBinding)
1935 {
1936 UNIMPLEMENTED;
1937 return CR_CALL_NOT_IMPLEMENTED;
1938 }
1939
1940
1941 /* Function 72 */
1942 DWORD PNP_RegisterServiceNotification(
1943 handle_t hBinding)
1944 {
1945 UNIMPLEMENTED;
1946 return CR_CALL_NOT_IMPLEMENTED;
1947 }
1948
1949
1950 /* Function 73 */
1951 DWORD PNP_SetActiveService(
1952 handle_t hBinding)
1953 {
1954 UNIMPLEMENTED;
1955 return CR_CALL_NOT_IMPLEMENTED;
1956 }
1957
1958
1959 /* Function 74 */
1960 DWORD PNP_DeleteServiceDevices(
1961 handle_t hBinding)
1962 {
1963 UNIMPLEMENTED;
1964 return CR_CALL_NOT_IMPLEMENTED;
1965 }
1966
1967
1968 static BOOL
1969 InstallDevice(PCWSTR DeviceInstance, BOOL ShowWizard)
1970 {
1971 PLUGPLAY_CONTROL_STATUS_DATA PlugPlayData;
1972 NTSTATUS Status;
1973 BOOL DeviceInstalled = FALSE;
1974 DWORD BytesWritten;
1975 DWORD Value;
1976 HANDLE hPipe = INVALID_HANDLE_VALUE;
1977 LPVOID Environment = NULL;
1978 PROCESS_INFORMATION ProcessInfo;
1979 STARTUPINFOW StartupInfo;
1980 UUID RandomUuid;
1981
1982 /* The following lengths are constant (see below), they cannot overflow */
1983 WCHAR CommandLine[116];
1984 WCHAR InstallEventName[73];
1985 WCHAR PipeName[74];
1986 WCHAR UuidString[39];
1987
1988 DPRINT("InstallDevice(%S, %d)\n", DeviceInstance, ShowWizard);
1989
1990 ZeroMemory(&ProcessInfo, sizeof(ProcessInfo));
1991
1992 RtlInitUnicodeString(&PlugPlayData.DeviceInstance,
1993 DeviceInstance);
1994 PlugPlayData.Operation = 0; /* Get status */
1995
1996 /* Get device status */
1997 Status = NtPlugPlayControl(PlugPlayControlDeviceStatus,
1998 (PVOID)&PlugPlayData,
1999 sizeof(PLUGPLAY_CONTROL_STATUS_DATA));
2000 if (!NT_SUCCESS(Status))
2001 {
2002 DPRINT1("NtPlugPlayControl('%S') failed with status 0x%08lx\n", DeviceInstance, Status);
2003 return FALSE;
2004 }
2005
2006 if ((PlugPlayData.DeviceStatus & (DNF_STARTED | DNF_START_FAILED)) != 0)
2007 {
2008 /* Device is already started, or disabled due to some problem. Don't install it */
2009 DPRINT("No need to install '%S'\n", DeviceInstance);
2010 return TRUE;
2011 }
2012
2013 /* Create a random UUID for the named pipe */
2014 UuidCreate(&RandomUuid);
2015 swprintf(UuidString, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
2016 RandomUuid.Data1, RandomUuid.Data2, RandomUuid.Data3,
2017 RandomUuid.Data4[0], RandomUuid.Data4[1], RandomUuid.Data4[2],
2018 RandomUuid.Data4[3], RandomUuid.Data4[4], RandomUuid.Data4[5],
2019 RandomUuid.Data4[6], RandomUuid.Data4[7]);
2020
2021 /* Create the named pipe */
2022 wcscpy(PipeName, L"\\\\.\\pipe\\PNP_Device_Install_Pipe_0.");
2023 wcscat(PipeName, UuidString);
2024 hPipe = CreateNamedPipeW(PipeName, PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE, 1, 512, 512, 0, NULL);
2025
2026 if(hPipe == INVALID_HANDLE_VALUE)
2027 {
2028 DPRINT1("CreateNamedPipeW failed with error %u\n", GetLastError());
2029 goto cleanup;
2030 }
2031
2032 /* Launch rundll32 to call ClientSideInstallW */
2033 wcscpy(CommandLine, L"rundll32.exe newdev.dll,ClientSideInstall ");
2034 wcscat(CommandLine, PipeName);
2035
2036 ZeroMemory(&StartupInfo, sizeof(StartupInfo));
2037 StartupInfo.cb = sizeof(StartupInfo);
2038
2039 if(hUserToken)
2040 {
2041 /* newdev has to run under the environment of the current user */
2042 if(!CreateEnvironmentBlock(&Environment, hUserToken, FALSE))
2043 {
2044 DPRINT1("CreateEnvironmentBlock failed with error %d\n", GetLastError());
2045 goto cleanup;
2046 }
2047
2048 if(!CreateProcessAsUserW(hUserToken, NULL, CommandLine, NULL, NULL, FALSE, CREATE_UNICODE_ENVIRONMENT, Environment, NULL, &StartupInfo, &ProcessInfo))
2049 {
2050 DPRINT1("CreateProcessAsUserW failed with error %u\n", GetLastError());
2051 goto cleanup;
2052 }
2053 }
2054 else
2055 {
2056 /* FIXME: This is probably not correct, I guess newdev should never be run with SYSTEM privileges.
2057
2058 Still, we currently do that in 2nd stage setup and probably Console mode as well, so allow it here.
2059 (ShowWizard is only set to FALSE for these two modes) */
2060 ASSERT(!ShowWizard);
2061
2062 if(!CreateProcessW(NULL, CommandLine, NULL, NULL, FALSE, 0, NULL, NULL, &StartupInfo, &ProcessInfo))
2063 {
2064 DPRINT1("CreateProcessW failed with error %u\n", GetLastError());
2065 goto cleanup;
2066 }
2067 }
2068
2069 /* Wait for the function to connect to our pipe */
2070 if(!ConnectNamedPipe(hPipe, NULL))
2071 {
2072 DPRINT1("ConnectNamedPipe failed with error %u\n", GetLastError());
2073 goto cleanup;
2074 }
2075
2076 /* Pass the data. The following output is partly compatible to Windows XP SP2 (researched using a modified newdev.dll to log this stuff) */
2077 wcscpy(InstallEventName, L"Global\\PNP_Device_Install_Event_0.");
2078 wcscat(InstallEventName, UuidString);
2079
2080 Value = sizeof(InstallEventName);
2081 WriteFile(hPipe, &Value, sizeof(Value), &BytesWritten, NULL);
2082 WriteFile(hPipe, InstallEventName, Value, &BytesWritten, NULL);
2083
2084 /* I couldn't figure out what the following value means under WinXP. It's usually 0 in my tests, but was also 5 once.
2085 Therefore the following line is entirely ReactOS-specific. We use the value here to pass the ShowWizard variable. */
2086 WriteFile(hPipe, &ShowWizard, sizeof(ShowWizard), &BytesWritten, NULL);
2087
2088 Value = (wcslen(DeviceInstance) + 1) * sizeof(WCHAR);
2089 WriteFile(hPipe, &Value, sizeof(Value), &BytesWritten, NULL);
2090 WriteFile(hPipe, DeviceInstance, Value, &BytesWritten, NULL);
2091
2092 /* Wait for newdev.dll to finish processing */
2093 WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
2094
2095 /* The following check for success is probably not compatible to Windows, but should do its job */
2096 if(!GetExitCodeProcess(ProcessInfo.hProcess, &Value))
2097 {
2098 DPRINT1("GetExitCodeProcess failed with error %u\n", GetLastError());
2099 goto cleanup;
2100 }
2101
2102 DeviceInstalled = Value;
2103
2104 cleanup:
2105 if(hPipe != INVALID_HANDLE_VALUE)
2106 CloseHandle(hPipe);
2107
2108 if(Environment)
2109 DestroyEnvironmentBlock(Environment);
2110
2111 if(ProcessInfo.hProcess)
2112 CloseHandle(ProcessInfo.hProcess);
2113
2114 if(ProcessInfo.hThread)
2115 CloseHandle(ProcessInfo.hThread);
2116
2117 return DeviceInstalled;
2118 }
2119
2120
2121 static LONG
2122 ReadRegSzKey(
2123 IN HKEY hKey,
2124 IN LPCWSTR pszKey,
2125 OUT LPWSTR* pValue)
2126 {
2127 LONG rc;
2128 DWORD dwType;
2129 DWORD cbData = 0;
2130 LPWSTR Value;
2131
2132 if (!pValue)
2133 return ERROR_INVALID_PARAMETER;
2134
2135 *pValue = NULL;
2136 rc = RegQueryValueExW(hKey, pszKey, NULL, &dwType, NULL, &cbData);
2137 if (rc != ERROR_SUCCESS)
2138 return rc;
2139 if (dwType != REG_SZ)
2140 return ERROR_FILE_NOT_FOUND;
2141 Value = HeapAlloc(GetProcessHeap(), 0, cbData + sizeof(WCHAR));
2142 if (!Value)
2143 return ERROR_NOT_ENOUGH_MEMORY;
2144 rc = RegQueryValueExW(hKey, pszKey, NULL, NULL, (LPBYTE)Value, &cbData);
2145 if (rc != ERROR_SUCCESS)
2146 {
2147 HeapFree(GetProcessHeap(), 0, Value);
2148 return rc;
2149 }
2150 /* NULL-terminate the string */
2151 Value[cbData / sizeof(WCHAR)] = '\0';
2152
2153 *pValue = Value;
2154 return ERROR_SUCCESS;
2155 }
2156
2157
2158 static BOOL
2159 SetupIsActive(VOID)
2160 {
2161 HKEY hKey = NULL;
2162 DWORD regType, active, size;
2163 LONG rc;
2164 BOOL ret = FALSE;
2165
2166 rc = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\Setup", 0, KEY_QUERY_VALUE, &hKey);
2167 if (rc != ERROR_SUCCESS)
2168 goto cleanup;
2169
2170 size = sizeof(DWORD);
2171 rc = RegQueryValueExW(hKey, L"SystemSetupInProgress", NULL, &regType, (LPBYTE)&active, &size);
2172 if (rc != ERROR_SUCCESS)
2173 goto cleanup;
2174 if (regType != REG_DWORD || size != sizeof(DWORD))
2175 goto cleanup;
2176
2177 ret = (active != 0);
2178
2179 cleanup:
2180 if (hKey != NULL)
2181 RegCloseKey(hKey);
2182
2183 DPRINT("System setup in progress? %S\n", ret ? L"YES" : L"NO");
2184
2185 return ret;
2186 }
2187
2188
2189 static BOOL
2190 IsConsoleBoot(VOID)
2191 {
2192 HKEY ControlKey = NULL;
2193 LPWSTR SystemStartOptions = NULL;
2194 LPWSTR CurrentOption, NextOption; /* Pointers into SystemStartOptions */
2195 BOOL ConsoleBoot = FALSE;
2196 LONG rc;
2197
2198 rc = RegOpenKeyExW(
2199 HKEY_LOCAL_MACHINE,
2200 L"SYSTEM\\CurrentControlSet\\Control",
2201 0,
2202 KEY_QUERY_VALUE,
2203 &ControlKey);
2204
2205 rc = ReadRegSzKey(ControlKey, L"SystemStartOptions", &SystemStartOptions);
2206 if (rc != ERROR_SUCCESS)
2207 goto cleanup;
2208
2209 /* Check for CMDCONS in SystemStartOptions */
2210 CurrentOption = SystemStartOptions;
2211 while (CurrentOption)
2212 {
2213 NextOption = wcschr(CurrentOption, L' ');
2214 if (NextOption)
2215 *NextOption = L'\0';
2216 if (_wcsicmp(CurrentOption, L"CONSOLE") == 0)
2217 {
2218 DPRINT("Found %S. Switching to console boot\n", CurrentOption);
2219 ConsoleBoot = TRUE;
2220 goto cleanup;
2221 }
2222 CurrentOption = NextOption ? NextOption + 1 : NULL;
2223 }
2224
2225 cleanup:
2226 if (ControlKey != NULL)
2227 RegCloseKey(ControlKey);
2228 HeapFree(GetProcessHeap(), 0, SystemStartOptions);
2229 return ConsoleBoot;
2230 }
2231
2232
2233 /* Loop to install all queued devices installations */
2234 static DWORD WINAPI
2235 DeviceInstallThread(LPVOID lpParameter)
2236 {
2237 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2238 PSLIST_ENTRY ListEntry;
2239 #else
2240 PLIST_ENTRY ListEntry;
2241 #endif
2242 DeviceInstallParams* Params;
2243 BOOL showWizard;
2244
2245 UNREFERENCED_PARAMETER(lpParameter);
2246
2247 WaitForSingleObject(hInstallEvent, INFINITE);
2248
2249 showWizard = !SetupIsActive() && !IsConsoleBoot();
2250
2251 while (TRUE)
2252 {
2253 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2254 ListEntry = InterlockedPopEntrySList(&DeviceInstallListHead);
2255 #else
2256 if ((BOOL)IsListEmpty(&DeviceInstallListHead))
2257 ListEntry = NULL;
2258 else
2259 ListEntry = RemoveHeadList(&DeviceInstallListHead);
2260 #endif
2261 if (ListEntry == NULL)
2262 {
2263 SetEvent(hNoPendingInstalls);
2264 WaitForSingleObject(hDeviceInstallListNotEmpty, INFINITE);
2265 }
2266 else
2267 {
2268 ResetEvent(hNoPendingInstalls);
2269 Params = CONTAINING_RECORD(ListEntry, DeviceInstallParams, ListEntry);
2270 InstallDevice(Params->DeviceIds, showWizard);
2271 }
2272 }
2273
2274 return 0;
2275 }
2276
2277
2278 static DWORD WINAPI
2279 PnpEventThread(LPVOID lpParameter)
2280 {
2281 PPLUGPLAY_EVENT_BLOCK PnpEvent;
2282 ULONG PnpEventSize;
2283 NTSTATUS Status;
2284 RPC_STATUS RpcStatus;
2285
2286 UNREFERENCED_PARAMETER(lpParameter);
2287
2288 PnpEventSize = 0x1000;
2289 PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
2290 if (PnpEvent == NULL)
2291 return ERROR_OUTOFMEMORY;
2292
2293 for (;;)
2294 {
2295 DPRINT("Calling NtGetPlugPlayEvent()\n");
2296
2297 /* Wait for the next pnp event */
2298 Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
2299
2300 /* Resize the buffer for the PnP event if it's too small. */
2301 if (Status == STATUS_BUFFER_TOO_SMALL)
2302 {
2303 PnpEventSize += 0x400;
2304 HeapFree(GetProcessHeap(), 0, PnpEvent);
2305 PnpEvent = HeapAlloc(GetProcessHeap(), 0, PnpEventSize);
2306 if (PnpEvent == NULL)
2307 return ERROR_OUTOFMEMORY;
2308 continue;
2309 }
2310
2311 if (!NT_SUCCESS(Status))
2312 {
2313 DPRINT("NtGetPlugPlayEvent() failed (Status %lx)\n", Status);
2314 break;
2315 }
2316
2317 /* Process the pnp event */
2318 DPRINT("Received PnP Event\n");
2319 if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ENUMERATED, &RpcStatus))
2320 {
2321 DeviceInstallParams* Params;
2322 DWORD len;
2323 DWORD DeviceIdLength;
2324
2325 DPRINT("Device enumerated: %S\n", PnpEvent->TargetDevice.DeviceIds);
2326
2327 DeviceIdLength = lstrlenW(PnpEvent->TargetDevice.DeviceIds);
2328 if (DeviceIdLength)
2329 {
2330 /* Queue device install (will be dequeued by DeviceInstallThread */
2331 len = FIELD_OFFSET(DeviceInstallParams, DeviceIds) + (DeviceIdLength + 1) * sizeof(WCHAR);
2332 Params = HeapAlloc(GetProcessHeap(), 0, len);
2333 if (Params)
2334 {
2335 wcscpy(Params->DeviceIds, PnpEvent->TargetDevice.DeviceIds);
2336 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2337 InterlockedPushEntrySList(&DeviceInstallListHead, &Params->ListEntry);
2338 #else
2339 InsertTailList(&DeviceInstallListHead, &Params->ListEntry);
2340 #endif
2341 SetEvent(hDeviceInstallListNotEmpty);
2342 }
2343 }
2344 }
2345 else if (UuidEqual(&PnpEvent->EventGuid, (UUID*)&GUID_DEVICE_ARRIVAL, &RpcStatus))
2346 {
2347 DPRINT("Device arrival: %S\n", PnpEvent->TargetDevice.DeviceIds);
2348 /* FIXME: ? */
2349 }
2350 else
2351 {
2352 DPRINT1("Unknown event, GUID {%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}\n",
2353 PnpEvent->EventGuid.Data1, PnpEvent->EventGuid.Data2, PnpEvent->EventGuid.Data3,
2354 PnpEvent->EventGuid.Data4[0], PnpEvent->EventGuid.Data4[1], PnpEvent->EventGuid.Data4[2],
2355 PnpEvent->EventGuid.Data4[3], PnpEvent->EventGuid.Data4[4], PnpEvent->EventGuid.Data4[5],
2356 PnpEvent->EventGuid.Data4[6], PnpEvent->EventGuid.Data4[7]);
2357 }
2358
2359 /* Dequeue the current pnp event and signal the next one */
2360 NtPlugPlayControl(PlugPlayControlUserResponse, NULL, 0);
2361 }
2362
2363 HeapFree(GetProcessHeap(), 0, PnpEvent);
2364
2365 return ERROR_SUCCESS;
2366 }
2367
2368
2369 static VOID CALLBACK
2370 ServiceMain(DWORD argc, LPTSTR *argv)
2371 {
2372 HANDLE hThread;
2373 DWORD dwThreadId;
2374
2375 UNREFERENCED_PARAMETER(argc);
2376 UNREFERENCED_PARAMETER(argv);
2377
2378 DPRINT("ServiceMain() called\n");
2379
2380 hThread = CreateThread(NULL,
2381 0,
2382 PnpEventThread,
2383 NULL,
2384 0,
2385 &dwThreadId);
2386 if (hThread != NULL)
2387 CloseHandle(hThread);
2388
2389 hThread = CreateThread(NULL,
2390 0,
2391 RpcServerThread,
2392 NULL,
2393 0,
2394 &dwThreadId);
2395 if (hThread != NULL)
2396 CloseHandle(hThread);
2397
2398 hThread = CreateThread(NULL,
2399 0,
2400 DeviceInstallThread,
2401 NULL,
2402 0,
2403 &dwThreadId);
2404 if (hThread != NULL)
2405 CloseHandle(hThread);
2406
2407 DPRINT("ServiceMain() done\n");
2408 }
2409
2410
2411 int
2412 wmain(int argc, WCHAR *argv[])
2413 {
2414 BOOLEAN OldValue;
2415 DWORD dwError;
2416
2417 UNREFERENCED_PARAMETER(argc);
2418 UNREFERENCED_PARAMETER(argv);
2419
2420 DPRINT("Umpnpmgr: main() started\n");
2421
2422 /* We need this privilege for using CreateProcessAsUserW */
2423 RtlAdjustPrivilege(SE_ASSIGNPRIMARYTOKEN_PRIVILEGE, TRUE, FALSE, &OldValue);
2424
2425 hInstallEvent = CreateEvent(NULL, TRUE, SetupIsActive()/*FALSE*/, NULL);
2426 if (hInstallEvent == NULL)
2427 {
2428 dwError = GetLastError();
2429 DPRINT1("Could not create the Install Event! (Error %lu)\n", dwError);
2430 return dwError;
2431 }
2432
2433 hDeviceInstallListNotEmpty = CreateEvent(NULL, FALSE, FALSE, NULL);
2434 if (hDeviceInstallListNotEmpty == NULL)
2435 {
2436 dwError = GetLastError();
2437 DPRINT1("Could not create the Event! (Error %lu)\n", dwError);
2438 return dwError;
2439 }
2440
2441 hNoPendingInstalls = CreateEventW(NULL,
2442 TRUE,
2443 FALSE,
2444 L"Global\\PnP_No_Pending_Install_Events");
2445 if (hNoPendingInstalls == NULL)
2446 {
2447 dwError = GetLastError();
2448 DPRINT1("Could not create the Event! (Error %lu)\n", dwError);
2449 return dwError;
2450 }
2451
2452 #ifdef HAVE_SLIST_ENTRY_IMPLEMENTED
2453 InitializeSListHead(&DeviceInstallListHead);
2454 #else
2455 InitializeListHead(&DeviceInstallListHead);
2456 #endif
2457
2458 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2459 L"System\\CurrentControlSet\\Enum",
2460 0,
2461 KEY_ALL_ACCESS,
2462 &hEnumKey);
2463 if (dwError != ERROR_SUCCESS)
2464 {
2465 DPRINT1("Could not open the Enum Key! (Error %lu)\n", dwError);
2466 return dwError;
2467 }
2468
2469 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
2470 L"System\\CurrentControlSet\\Control\\Class",
2471 0,
2472 KEY_ALL_ACCESS,
2473 &hClassKey);
2474 if (dwError != ERROR_SUCCESS)
2475 {
2476 DPRINT1("Could not open the Class Key! (Error %lu)\n", dwError);
2477 return dwError;
2478 }
2479
2480 StartServiceCtrlDispatcher(ServiceTable);
2481
2482 DPRINT("Umpnpmgr: main() done\n");
2483
2484 ExitThread(0);
2485
2486 return 0;
2487 }
2488
2489 /* EOF */