[SERVICES]
[reactos.git] / reactos / base / system / services / database.c
1 /*
2 * PROJECT: ReactOS Service Control Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: base/system/services/database.c
5 * PURPOSE: Database control interface
6 * COPYRIGHT: Copyright 2002-2006 Eric Kohl
7 * Copyright 2006 Hervé Poussineau <hpoussin@reactos.org>
8 * Copyright 2007 Ged Murphy <gedmurphy@reactos.org>
9 * Gregor Brunmar <gregor.brunmar@home.se>
10 *
11 */
12
13 /* INCLUDES *****************************************************************/
14
15 #include "services.h"
16
17 #define NDEBUG
18 #include <debug.h>
19
20 /*
21 * Uncomment the line below to start services
22 * using the SERVICE_START_PENDING state
23 */
24 // #define USE_SERVICE_START_PENDING
25
26 /* GLOBALS *******************************************************************/
27
28 LIST_ENTRY ServiceListHead;
29
30 static RTL_RESOURCE DatabaseLock;
31 static DWORD dwResumeCount = 1;
32
33 static CRITICAL_SECTION ControlServiceCriticalSection;
34
35 /* FUNCTIONS *****************************************************************/
36
37
38 PSERVICE
39 ScmGetServiceEntryByName(LPCWSTR lpServiceName)
40 {
41 PLIST_ENTRY ServiceEntry;
42 PSERVICE CurrentService;
43
44 DPRINT("ScmGetServiceEntryByName() called\n");
45
46 ServiceEntry = ServiceListHead.Flink;
47 while (ServiceEntry != &ServiceListHead)
48 {
49 CurrentService = CONTAINING_RECORD(ServiceEntry,
50 SERVICE,
51 ServiceListEntry);
52 if (_wcsicmp(CurrentService->lpServiceName, lpServiceName) == 0)
53 {
54 DPRINT("Found service: '%S'\n", CurrentService->lpServiceName);
55 return CurrentService;
56 }
57
58 ServiceEntry = ServiceEntry->Flink;
59 }
60
61 DPRINT("Couldn't find a matching service\n");
62
63 return NULL;
64 }
65
66
67 PSERVICE
68 ScmGetServiceEntryByDisplayName(LPCWSTR lpDisplayName)
69 {
70 PLIST_ENTRY ServiceEntry;
71 PSERVICE CurrentService;
72
73 DPRINT("ScmGetServiceEntryByDisplayName() called\n");
74
75 ServiceEntry = ServiceListHead.Flink;
76 while (ServiceEntry != &ServiceListHead)
77 {
78 CurrentService = CONTAINING_RECORD(ServiceEntry,
79 SERVICE,
80 ServiceListEntry);
81 if (_wcsicmp(CurrentService->lpDisplayName, lpDisplayName) == 0)
82 {
83 DPRINT("Found service: '%S'\n", CurrentService->lpDisplayName);
84 return CurrentService;
85 }
86
87 ServiceEntry = ServiceEntry->Flink;
88 }
89
90 DPRINT("Couldn't find a matching service\n");
91
92 return NULL;
93 }
94
95
96 PSERVICE
97 ScmGetServiceEntryByResumeCount(DWORD dwResumeCount)
98 {
99 PLIST_ENTRY ServiceEntry;
100 PSERVICE CurrentService;
101
102 DPRINT("ScmGetServiceEntryByResumeCount() called\n");
103
104 ServiceEntry = ServiceListHead.Flink;
105 while (ServiceEntry != &ServiceListHead)
106 {
107 CurrentService = CONTAINING_RECORD(ServiceEntry,
108 SERVICE,
109 ServiceListEntry);
110 if (CurrentService->dwResumeCount > dwResumeCount)
111 {
112 DPRINT("Found service: '%S'\n", CurrentService->lpDisplayName);
113 return CurrentService;
114 }
115
116 ServiceEntry = ServiceEntry->Flink;
117 }
118
119 DPRINT("Couldn't find a matching service\n");
120
121 return NULL;
122 }
123
124
125 DWORD
126 ScmCreateNewServiceRecord(LPCWSTR lpServiceName,
127 PSERVICE *lpServiceRecord)
128 {
129 PSERVICE lpService = NULL;
130
131 DPRINT("Service: '%S'\n", lpServiceName);
132
133 /* Allocate service entry */
134 lpService = (SERVICE*) HeapAlloc(GetProcessHeap(),
135 HEAP_ZERO_MEMORY,
136 sizeof(SERVICE) + ((wcslen(lpServiceName) + 1) * sizeof(WCHAR)));
137 if (lpService == NULL)
138 return ERROR_NOT_ENOUGH_MEMORY;
139
140 *lpServiceRecord = lpService;
141
142 /* Copy service name */
143 wcscpy(lpService->szServiceName, lpServiceName);
144 lpService->lpServiceName = lpService->szServiceName;
145 lpService->lpDisplayName = lpService->lpServiceName;
146
147 /* Set the resume count */
148 lpService->dwResumeCount = dwResumeCount++;
149
150 /* Append service record */
151 InsertTailList(&ServiceListHead,
152 &lpService->ServiceListEntry);
153
154 /* Initialize the service status */
155 lpService->Status.dwCurrentState = SERVICE_STOPPED;
156 lpService->Status.dwControlsAccepted = 0;
157 lpService->Status.dwWin32ExitCode = ERROR_SERVICE_NEVER_STARTED;
158 lpService->Status.dwServiceSpecificExitCode = 0;
159 lpService->Status.dwCheckPoint = 0;
160 lpService->Status.dwWaitHint = 2000; /* 2 seconds */
161
162 return ERROR_SUCCESS;
163 }
164
165
166 VOID
167 ScmDeleteServiceRecord(PSERVICE lpService)
168 {
169 DPRINT("Deleting Service %S\n", lpService->lpServiceName);
170
171 /* Delete the display name */
172 if (lpService->lpDisplayName != NULL &&
173 lpService->lpDisplayName != lpService->lpServiceName)
174 HeapFree(GetProcessHeap(), 0, lpService->lpDisplayName);
175
176 /* Decrement the image reference counter */
177 if (lpService->lpImage)
178 lpService->lpImage->dwServiceRefCount--;
179
180 /* Decrement the group reference counter */
181 if (lpService->lpGroup)
182 lpService->lpGroup->dwRefCount--;
183
184 /* FIXME: SecurityDescriptor */
185
186 /* Close the control pipe */
187 if (lpService->ControlPipeHandle != INVALID_HANDLE_VALUE)
188 CloseHandle(lpService->ControlPipeHandle);
189
190 /* Remove the Service from the List */
191 RemoveEntryList(&lpService->ServiceListEntry);
192
193 DPRINT("Deleted Service %S\n", lpService->lpServiceName);
194
195 /* Delete the service record */
196 HeapFree(GetProcessHeap(), 0, lpService);
197
198 DPRINT("Done\n");
199 }
200
201
202 static DWORD
203 CreateServiceListEntry(LPCWSTR lpServiceName,
204 HKEY hServiceKey)
205 {
206 PSERVICE lpService = NULL;
207 LPWSTR lpDisplayName = NULL;
208 LPWSTR lpGroup = NULL;
209 DWORD dwSize;
210 DWORD dwError;
211 DWORD dwServiceType;
212 DWORD dwStartType;
213 DWORD dwErrorControl;
214 DWORD dwTagId;
215
216 DPRINT("Service: '%S'\n", lpServiceName);
217 if (*lpServiceName == L'{')
218 return ERROR_SUCCESS;
219
220 dwSize = sizeof(DWORD);
221 dwError = RegQueryValueExW(hServiceKey,
222 L"Type",
223 NULL,
224 NULL,
225 (LPBYTE)&dwServiceType,
226 &dwSize);
227 if (dwError != ERROR_SUCCESS)
228 return ERROR_SUCCESS;
229
230 if (((dwServiceType & ~SERVICE_INTERACTIVE_PROCESS) != SERVICE_WIN32_OWN_PROCESS) &&
231 ((dwServiceType & ~SERVICE_INTERACTIVE_PROCESS) != SERVICE_WIN32_SHARE_PROCESS) &&
232 (dwServiceType != SERVICE_KERNEL_DRIVER) &&
233 (dwServiceType != SERVICE_FILE_SYSTEM_DRIVER))
234 return ERROR_SUCCESS;
235
236 DPRINT("Service type: %lx\n", dwServiceType);
237
238 dwSize = sizeof(DWORD);
239 dwError = RegQueryValueExW(hServiceKey,
240 L"Start",
241 NULL,
242 NULL,
243 (LPBYTE)&dwStartType,
244 &dwSize);
245 if (dwError != ERROR_SUCCESS)
246 return ERROR_SUCCESS;
247
248 DPRINT("Start type: %lx\n", dwStartType);
249
250 dwSize = sizeof(DWORD);
251 dwError = RegQueryValueExW(hServiceKey,
252 L"ErrorControl",
253 NULL,
254 NULL,
255 (LPBYTE)&dwErrorControl,
256 &dwSize);
257 if (dwError != ERROR_SUCCESS)
258 return ERROR_SUCCESS;
259
260 DPRINT("Error control: %lx\n", dwErrorControl);
261
262 dwError = RegQueryValueExW(hServiceKey,
263 L"Tag",
264 NULL,
265 NULL,
266 (LPBYTE)&dwTagId,
267 &dwSize);
268 if (dwError != ERROR_SUCCESS)
269 dwTagId = 0;
270
271 DPRINT("Tag: %lx\n", dwTagId);
272
273 dwError = ScmReadString(hServiceKey,
274 L"Group",
275 &lpGroup);
276 if (dwError != ERROR_SUCCESS)
277 lpGroup = NULL;
278
279 DPRINT("Group: %S\n", lpGroup);
280
281 dwError = ScmReadString(hServiceKey,
282 L"DisplayName",
283 &lpDisplayName);
284 if (dwError != ERROR_SUCCESS)
285 lpDisplayName = NULL;
286
287 DPRINT("Display name: %S\n", lpDisplayName);
288
289 dwError = ScmCreateNewServiceRecord(lpServiceName,
290 &lpService);
291 if (dwError != ERROR_SUCCESS)
292 goto done;
293
294 lpService->Status.dwServiceType = dwServiceType;
295 lpService->dwStartType = dwStartType;
296 lpService->dwErrorControl = dwErrorControl;
297 lpService->dwTag = dwTagId;
298
299 if (lpGroup != NULL)
300 {
301 dwError = ScmSetServiceGroup(lpService, lpGroup);
302 if (dwError != ERROR_SUCCESS)
303 goto done;
304 }
305
306 if (lpDisplayName != NULL)
307 {
308 lpService->lpDisplayName = lpDisplayName;
309 lpDisplayName = NULL;
310 }
311
312 DPRINT("ServiceName: '%S'\n", lpService->lpServiceName);
313 if (lpService->lpGroup != NULL)
314 {
315 DPRINT("Group: '%S'\n", lpService->lpGroup->lpGroupName);
316 }
317 DPRINT("Start %lx Type %lx Tag %lx ErrorControl %lx\n",
318 lpService->dwStartType,
319 lpService->Status.dwServiceType,
320 lpService->dwTag,
321 lpService->dwErrorControl);
322
323 if (ScmIsDeleteFlagSet(hServiceKey))
324 lpService->bDeleted = TRUE;
325
326 done:;
327 if (lpGroup != NULL)
328 HeapFree(GetProcessHeap(), 0, lpGroup);
329
330 if (lpDisplayName != NULL)
331 HeapFree(GetProcessHeap(), 0, lpDisplayName);
332
333 return dwError;
334 }
335
336
337 DWORD
338 ScmDeleteRegKey(HKEY hKey, LPCWSTR lpszSubKey)
339 {
340 DWORD dwRet, dwMaxSubkeyLen = 0, dwSize;
341 WCHAR szNameBuf[MAX_PATH], *lpszName = szNameBuf;
342 HKEY hSubKey = 0;
343
344 dwRet = RegOpenKeyExW(hKey, lpszSubKey, 0, KEY_READ, &hSubKey);
345 if (!dwRet)
346 {
347 /* Find the maximum subkey length so that we can allocate a buffer */
348 dwRet = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
349 &dwMaxSubkeyLen, NULL, NULL, NULL, NULL, NULL, NULL);
350 if (!dwRet)
351 {
352 dwMaxSubkeyLen++;
353 if (dwMaxSubkeyLen > sizeof(szNameBuf)/sizeof(WCHAR))
354 /* Name too big: alloc a buffer for it */
355 lpszName = HeapAlloc(GetProcessHeap(), 0, dwMaxSubkeyLen*sizeof(WCHAR));
356
357 if(!lpszName)
358 dwRet = ERROR_NOT_ENOUGH_MEMORY;
359 else
360 {
361 while (dwRet == ERROR_SUCCESS)
362 {
363 dwSize = dwMaxSubkeyLen;
364 dwRet = RegEnumKeyExW(hSubKey, 0, lpszName, &dwSize, NULL, NULL, NULL, NULL);
365 if (dwRet == ERROR_SUCCESS || dwRet == ERROR_MORE_DATA)
366 dwRet = ScmDeleteRegKey(hSubKey, lpszName);
367 }
368 if (dwRet == ERROR_NO_MORE_ITEMS)
369 dwRet = ERROR_SUCCESS;
370
371 if (lpszName != szNameBuf)
372 HeapFree(GetProcessHeap(), 0, lpszName); /* Free buffer if allocated */
373 }
374 }
375
376 RegCloseKey(hSubKey);
377 if (!dwRet)
378 dwRet = RegDeleteKeyW(hKey, lpszSubKey);
379 }
380 return dwRet;
381 }
382
383
384 VOID
385 ScmDeleteMarkedServices(VOID)
386 {
387 PLIST_ENTRY ServiceEntry;
388 PSERVICE CurrentService;
389 HKEY hServicesKey;
390 DWORD dwError;
391
392 ServiceEntry = ServiceListHead.Flink;
393 while (ServiceEntry != &ServiceListHead)
394 {
395 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
396
397 ServiceEntry = ServiceEntry->Flink;
398
399 if (CurrentService->bDeleted == TRUE)
400 {
401 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
402 L"System\\CurrentControlSet\\Services",
403 0,
404 DELETE,
405 &hServicesKey);
406 if (dwError == ERROR_SUCCESS)
407 {
408 dwError = ScmDeleteRegKey(hServicesKey, CurrentService->lpServiceName);
409 RegCloseKey(hServicesKey);
410 if (dwError == ERROR_SUCCESS)
411 {
412 RemoveEntryList(&CurrentService->ServiceListEntry);
413 HeapFree(GetProcessHeap(), 0, CurrentService);
414 }
415 }
416
417 if (dwError != ERROR_SUCCESS)
418 DPRINT1("Delete service failed: %S\n", CurrentService->lpServiceName);
419 }
420 }
421 }
422
423
424 VOID
425 WaitForLSA(VOID)
426 {
427 HANDLE hEvent;
428 DWORD dwError;
429
430 DPRINT("WaitForLSA() called\n");
431
432 hEvent = CreateEventW(NULL,
433 TRUE,
434 FALSE,
435 L"LSA_RPC_SERVER_ACTIVE");
436 if (hEvent == NULL)
437 {
438 dwError = GetLastError();
439 DPRINT1("Failed to create the notication event (Error %lu)\n", dwError);
440
441 if (dwError == ERROR_ALREADY_EXISTS)
442 {
443 hEvent = OpenEventW(SYNCHRONIZE,
444 FALSE,
445 L"LSA_RPC_SERVER_ACTIVE");
446 if (hEvent != NULL)
447 {
448 DPRINT1("Could not open the notification event!\n");
449 return;
450 }
451 }
452 }
453
454 DPRINT("Wait for LSA!\n");
455 WaitForSingleObject(hEvent, INFINITE);
456 DPRINT("LSA is available!\n");
457
458 CloseHandle(hEvent);
459
460 DPRINT("WaitForLSA() done\n");
461 }
462
463
464 DWORD
465 ScmCreateServiceDatabase(VOID)
466 {
467 WCHAR szSubKey[MAX_PATH];
468 HKEY hServicesKey;
469 HKEY hServiceKey;
470 DWORD dwSubKey;
471 DWORD dwSubKeyLength;
472 FILETIME ftLastChanged;
473 DWORD dwError;
474
475 DPRINT("ScmCreateServiceDatabase() called\n");
476
477 dwError = ScmCreateGroupList();
478 if (dwError != ERROR_SUCCESS)
479 return dwError;
480
481 /* Initialize basic variables */
482 InitializeListHead(&ServiceListHead);
483
484 /* Initialize the database lock */
485 RtlInitializeResource(&DatabaseLock);
486
487 dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
488 L"System\\CurrentControlSet\\Services",
489 0,
490 KEY_READ,
491 &hServicesKey);
492 if (dwError != ERROR_SUCCESS)
493 return dwError;
494
495 dwSubKey = 0;
496 for (;;)
497 {
498 dwSubKeyLength = MAX_PATH;
499 dwError = RegEnumKeyExW(hServicesKey,
500 dwSubKey,
501 szSubKey,
502 &dwSubKeyLength,
503 NULL,
504 NULL,
505 NULL,
506 &ftLastChanged);
507 if (dwError == ERROR_SUCCESS &&
508 szSubKey[0] != L'{')
509 {
510 DPRINT("SubKeyName: '%S'\n", szSubKey);
511
512 dwError = RegOpenKeyExW(hServicesKey,
513 szSubKey,
514 0,
515 KEY_READ,
516 &hServiceKey);
517 if (dwError == ERROR_SUCCESS)
518 {
519 dwError = CreateServiceListEntry(szSubKey,
520 hServiceKey);
521
522 RegCloseKey(hServiceKey);
523 }
524 }
525
526 if (dwError != ERROR_SUCCESS)
527 break;
528
529 dwSubKey++;
530 }
531
532 RegCloseKey(hServicesKey);
533
534 /* Wait for LSA */
535 WaitForLSA();
536
537 /* Delete services that are marked for delete */
538 ScmDeleteMarkedServices();
539
540 DPRINT("ScmCreateServiceDatabase() done\n");
541
542 return ERROR_SUCCESS;
543 }
544
545
546 VOID
547 ScmShutdownServiceDatabase(VOID)
548 {
549 DPRINT("ScmShutdownServiceDatabase() called\n");
550
551 ScmDeleteMarkedServices();
552 RtlDeleteResource(&DatabaseLock);
553
554 DPRINT("ScmShutdownServiceDatabase() done\n");
555 }
556
557
558 static NTSTATUS
559 ScmCheckDriver(PSERVICE Service)
560 {
561 OBJECT_ATTRIBUTES ObjectAttributes;
562 UNICODE_STRING DirName;
563 HANDLE DirHandle;
564 NTSTATUS Status;
565 POBJECT_DIRECTORY_INFORMATION DirInfo;
566 ULONG BufferLength;
567 ULONG DataLength;
568 ULONG Index;
569
570 DPRINT("ScmCheckDriver(%S) called\n", Service->lpServiceName);
571
572 if (Service->Status.dwServiceType == SERVICE_KERNEL_DRIVER)
573 {
574 RtlInitUnicodeString(&DirName,
575 L"\\Driver");
576 }
577 else
578 {
579 RtlInitUnicodeString(&DirName,
580 L"\\FileSystem");
581 }
582
583 InitializeObjectAttributes(&ObjectAttributes,
584 &DirName,
585 0,
586 NULL,
587 NULL);
588
589 Status = NtOpenDirectoryObject(&DirHandle,
590 DIRECTORY_QUERY | DIRECTORY_TRAVERSE,
591 &ObjectAttributes);
592 if (!NT_SUCCESS(Status))
593 {
594 return Status;
595 }
596
597 BufferLength = sizeof(OBJECT_DIRECTORY_INFORMATION) +
598 2 * MAX_PATH * sizeof(WCHAR);
599 DirInfo = (OBJECT_DIRECTORY_INFORMATION*) HeapAlloc(GetProcessHeap(),
600 HEAP_ZERO_MEMORY,
601 BufferLength);
602
603 Index = 0;
604 while (TRUE)
605 {
606 Status = NtQueryDirectoryObject(DirHandle,
607 DirInfo,
608 BufferLength,
609 TRUE,
610 FALSE,
611 &Index,
612 &DataLength);
613 if (Status == STATUS_NO_MORE_ENTRIES)
614 {
615 /* FIXME: Add current service to 'failed service' list */
616 DPRINT("Service '%S' failed\n", Service->lpServiceName);
617 break;
618 }
619
620 if (!NT_SUCCESS(Status))
621 break;
622
623 DPRINT("Comparing: '%S' '%wZ'\n", Service->lpServiceName, &DirInfo->Name);
624
625 if (_wcsicmp(Service->lpServiceName, DirInfo->Name.Buffer) == 0)
626 {
627 DPRINT("Found: '%S' '%wZ'\n",
628 Service->lpServiceName, &DirInfo->Name);
629
630 /* Mark service as 'running' */
631 Service->Status.dwCurrentState = SERVICE_RUNNING;
632
633 /* Mark the service group as 'running' */
634 if (Service->lpGroup != NULL)
635 {
636 Service->lpGroup->ServicesRunning = TRUE;
637 }
638
639 break;
640 }
641 }
642
643 HeapFree(GetProcessHeap(),
644 0,
645 DirInfo);
646 NtClose(DirHandle);
647
648 return STATUS_SUCCESS;
649 }
650
651
652 VOID
653 ScmGetBootAndSystemDriverState(VOID)
654 {
655 PLIST_ENTRY ServiceEntry;
656 PSERVICE CurrentService;
657
658 DPRINT("ScmGetBootAndSystemDriverState() called\n");
659
660 ServiceEntry = ServiceListHead.Flink;
661 while (ServiceEntry != &ServiceListHead)
662 {
663 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
664
665 if (CurrentService->dwStartType == SERVICE_BOOT_START ||
666 CurrentService->dwStartType == SERVICE_SYSTEM_START)
667 {
668 /* Check driver */
669 DPRINT(" Checking service: %S\n", CurrentService->lpServiceName);
670
671 ScmCheckDriver(CurrentService);
672 }
673
674 ServiceEntry = ServiceEntry->Flink;
675 }
676
677 DPRINT("ScmGetBootAndSystemDriverState() done\n");
678 }
679
680
681 DWORD
682 ScmControlService(PSERVICE Service,
683 DWORD dwControl)
684 {
685 PSCM_CONTROL_PACKET ControlPacket;
686 SCM_REPLY_PACKET ReplyPacket;
687
688 DWORD dwWriteCount = 0;
689 DWORD dwReadCount = 0;
690 DWORD TotalLength;
691 DWORD dwError = ERROR_SUCCESS;
692
693 DPRINT("ScmControlService() called\n");
694
695 EnterCriticalSection(&ControlServiceCriticalSection);
696
697 TotalLength = wcslen(Service->lpServiceName) + 1;
698
699 ControlPacket = (SCM_CONTROL_PACKET*)HeapAlloc(GetProcessHeap(),
700 HEAP_ZERO_MEMORY,
701 sizeof(SCM_CONTROL_PACKET) + (TotalLength * sizeof(WCHAR)));
702 if (ControlPacket == NULL)
703 return ERROR_NOT_ENOUGH_MEMORY;
704
705 ControlPacket->dwControl = dwControl;
706 ControlPacket->dwSize = TotalLength;
707 ControlPacket->hServiceStatus = (SERVICE_STATUS_HANDLE)Service;
708 wcscpy(&ControlPacket->szArguments[0], Service->lpServiceName);
709
710 /* Send the control packet */
711 WriteFile(Service->ControlPipeHandle,
712 ControlPacket,
713 sizeof(SCM_CONTROL_PACKET) + (TotalLength * sizeof(WCHAR)),
714 &dwWriteCount,
715 NULL);
716
717 /* Read the reply */
718 ReadFile(Service->ControlPipeHandle,
719 &ReplyPacket,
720 sizeof(SCM_REPLY_PACKET),
721 &dwReadCount,
722 NULL);
723
724 /* Release the contol packet */
725 HeapFree(GetProcessHeap(),
726 0,
727 ControlPacket);
728
729 if (dwReadCount == sizeof(SCM_REPLY_PACKET))
730 {
731 dwError = ReplyPacket.dwError;
732 }
733
734 LeaveCriticalSection(&ControlServiceCriticalSection);
735
736 DPRINT("ScmControlService() done\n");
737
738 return dwError;
739 }
740
741
742 static DWORD
743 ScmSendStartCommand(PSERVICE Service,
744 DWORD argc,
745 LPWSTR *argv)
746 {
747 PSCM_CONTROL_PACKET ControlPacket;
748 SCM_REPLY_PACKET ReplyPacket;
749 DWORD TotalLength;
750 DWORD ArgsLength = 0;
751 DWORD Length;
752 PWSTR Ptr;
753 DWORD dwWriteCount = 0;
754 DWORD dwReadCount = 0;
755 DWORD dwError = ERROR_SUCCESS;
756 DWORD i;
757
758 DPRINT("ScmSendStartCommand() called\n");
759
760 /* Calculate the total length of the start command line */
761 TotalLength = wcslen(Service->lpServiceName) + 1;
762 if (argc > 0)
763 {
764 for (i = 0; i < argc; i++)
765 {
766 DPRINT("Arg: %S\n", argv[i]);
767 Length = wcslen(argv[i]) + 1;
768 TotalLength += Length;
769 ArgsLength += Length;
770 }
771 }
772 TotalLength++;
773 DPRINT("ArgsLength: %ld TotalLength: %ld\n", ArgsLength, TotalLength);
774
775 /* Allocate a control packet */
776 ControlPacket = (SCM_CONTROL_PACKET*)HeapAlloc(GetProcessHeap(),
777 HEAP_ZERO_MEMORY,
778 sizeof(SCM_CONTROL_PACKET) + (TotalLength - 1) * sizeof(WCHAR));
779 if (ControlPacket == NULL)
780 return ERROR_NOT_ENOUGH_MEMORY;
781
782 ControlPacket->dwControl = SERVICE_CONTROL_START;
783 ControlPacket->hServiceStatus = (SERVICE_STATUS_HANDLE)Service;
784 ControlPacket->dwSize = TotalLength;
785 Ptr = &ControlPacket->szArguments[0];
786 wcscpy(Ptr, Service->lpServiceName);
787 Ptr += (wcslen(Service->lpServiceName) + 1);
788
789 /* Copy argument list */
790 if (argc > 0)
791 {
792 UNIMPLEMENTED;
793 DPRINT1("Arguments sent to service ignored!\n");
794 #if 0
795 memcpy(Ptr, Arguments, ArgsLength);
796 Ptr += ArgsLength;
797 #endif
798 }
799
800 /* Terminate the argument list */
801 *Ptr = 0;
802
803 /* Send the start command */
804 WriteFile(Service->ControlPipeHandle,
805 ControlPacket,
806 sizeof(SCM_CONTROL_PACKET) + (TotalLength - 1) * sizeof(WCHAR),
807 &dwWriteCount,
808 NULL);
809
810 /* Read the reply */
811 ReadFile(Service->ControlPipeHandle,
812 &ReplyPacket,
813 sizeof(SCM_REPLY_PACKET),
814 &dwReadCount,
815 NULL);
816
817 /* Release the contol packet */
818 HeapFree(GetProcessHeap(),
819 0,
820 ControlPacket);
821
822 if (dwReadCount == sizeof(SCM_REPLY_PACKET))
823 {
824 dwError = ReplyPacket.dwError;
825 }
826
827 DPRINT("ScmSendStartCommand() done\n");
828
829 return dwError;
830 }
831
832
833 static DWORD
834 ScmStartUserModeService(PSERVICE Service,
835 DWORD argc,
836 LPWSTR *argv)
837 {
838 RTL_QUERY_REGISTRY_TABLE QueryTable[3];
839 PROCESS_INFORMATION ProcessInformation;
840 STARTUPINFOW StartupInfo;
841 UNICODE_STRING ImagePath;
842 ULONG Type;
843 DWORD ServiceCurrent = 0;
844 BOOL Result;
845 NTSTATUS Status;
846 DWORD dwError = ERROR_SUCCESS;
847 WCHAR NtControlPipeName[MAX_PATH + 1];
848 HKEY hServiceCurrentKey = INVALID_HANDLE_VALUE;
849 DWORD KeyDisposition;
850 DWORD dwProcessId;
851
852 RtlInitUnicodeString(&ImagePath, NULL);
853
854 /* Get service data */
855 RtlZeroMemory(&QueryTable,
856 sizeof(QueryTable));
857
858 QueryTable[0].Name = L"Type";
859 QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
860 QueryTable[0].EntryContext = &Type;
861
862 QueryTable[1].Name = L"ImagePath";
863 QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
864 QueryTable[1].EntryContext = &ImagePath;
865
866 Status = RtlQueryRegistryValues(RTL_REGISTRY_SERVICES,
867 Service->lpServiceName,
868 QueryTable,
869 NULL,
870 NULL);
871 if (!NT_SUCCESS(Status))
872 {
873 DPRINT1("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
874 return RtlNtStatusToDosError(Status);
875 }
876 DPRINT("ImagePath: '%S'\n", ImagePath.Buffer);
877 DPRINT("Type: %lx\n", Type);
878
879 /* Get the service number */
880 /* TODO: Create registry entry with correct write access */
881 Status = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
882 L"SYSTEM\\CurrentControlSet\\Control\\ServiceCurrent", 0, NULL,
883 REG_OPTION_VOLATILE,
884 KEY_WRITE | KEY_READ,
885 NULL,
886 &hServiceCurrentKey,
887 &KeyDisposition);
888
889 if (ERROR_SUCCESS != Status)
890 {
891 DPRINT1("RegCreateKeyEx() failed with status %u\n", Status);
892 return Status;
893 }
894
895 if (REG_OPENED_EXISTING_KEY == KeyDisposition)
896 {
897 DWORD KeySize = sizeof(ServiceCurrent);
898 Status = RegQueryValueExW(hServiceCurrentKey, L"", 0, NULL, (BYTE*)&ServiceCurrent, &KeySize);
899
900 if (ERROR_SUCCESS != Status)
901 {
902 RegCloseKey(hServiceCurrentKey);
903 DPRINT1("RegQueryValueEx() failed with status %u\n", Status);
904 return Status;
905 }
906
907 ServiceCurrent++;
908 }
909
910 Status = RegSetValueExW(hServiceCurrentKey, L"", 0, REG_DWORD, (BYTE*)&ServiceCurrent, sizeof(ServiceCurrent));
911
912 RegCloseKey(hServiceCurrentKey);
913
914 if (ERROR_SUCCESS != Status)
915 {
916 DPRINT1("RegSetValueExW() failed (Status %lx)\n", Status);
917 return Status;
918 }
919
920 /* Create '\\.\pipe\net\NtControlPipeXXX' instance */
921 swprintf(NtControlPipeName, L"\\\\.\\pipe\\net\\NtControlPipe%u", ServiceCurrent);
922
923 DPRINT1("Service: %p ImagePath: %wZ PipeName: %S\n", Service, &ImagePath, NtControlPipeName);
924
925 Service->ControlPipeHandle = CreateNamedPipeW(NtControlPipeName,
926 PIPE_ACCESS_DUPLEX,
927 PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
928 100,
929 8000,
930 4,
931 30000,
932 NULL);
933 DPRINT("CreateNamedPipeW(%S) done\n", NtControlPipeName);
934 if (Service->ControlPipeHandle == INVALID_HANDLE_VALUE)
935 {
936 DPRINT1("Failed to create control pipe!\n");
937 return GetLastError();
938 }
939
940 StartupInfo.cb = sizeof(StartupInfo);
941 StartupInfo.lpReserved = NULL;
942 StartupInfo.lpDesktop = NULL;
943 StartupInfo.lpTitle = NULL;
944 StartupInfo.dwFlags = 0;
945 StartupInfo.cbReserved2 = 0;
946 StartupInfo.lpReserved2 = 0;
947
948 Result = CreateProcessW(NULL,
949 ImagePath.Buffer,
950 NULL,
951 NULL,
952 FALSE,
953 DETACHED_PROCESS | CREATE_SUSPENDED,
954 NULL,
955 NULL,
956 &StartupInfo,
957 &ProcessInformation);
958 RtlFreeUnicodeString(&ImagePath);
959
960 if (!Result)
961 {
962 dwError = GetLastError();
963 /* Close control pipe */
964 CloseHandle(Service->ControlPipeHandle);
965 Service->ControlPipeHandle = INVALID_HANDLE_VALUE;
966
967 DPRINT1("Starting '%S' failed!\n", Service->lpServiceName);
968 return dwError;
969 }
970
971 DPRINT("Process Id: %lu Handle %lx\n",
972 ProcessInformation.dwProcessId,
973 ProcessInformation.hProcess);
974 DPRINT("Thread Id: %lu Handle %lx\n",
975 ProcessInformation.dwThreadId,
976 ProcessInformation.hThread);
977
978 /* Get process and thread ids */
979 Service->ProcessId = ProcessInformation.dwProcessId;
980 Service->ThreadId = ProcessInformation.dwThreadId;
981
982 /* Resume Thread */
983 ResumeThread(ProcessInformation.hThread);
984
985 /* Connect control pipe */
986 if (ConnectNamedPipe(Service->ControlPipeHandle, NULL) ?
987 TRUE : (dwError = GetLastError()) == ERROR_PIPE_CONNECTED)
988 {
989 DWORD dwRead = 0;
990
991 DPRINT("Control pipe connected!\n");
992
993 /* Read SERVICE_STATUS_HANDLE from pipe */
994 if (!ReadFile(Service->ControlPipeHandle,
995 (LPVOID)&dwProcessId,
996 sizeof(DWORD),
997 &dwRead,
998 NULL))
999 {
1000 dwError = GetLastError();
1001 DPRINT1("Reading the service control pipe failed (Error %lu)\n",
1002 dwError);
1003 }
1004 else
1005 {
1006 DPRINT("Received service process ID %lu\n", dwProcessId);
1007
1008 /* Send start command */
1009 dwError = ScmSendStartCommand(Service, argc, argv);
1010 }
1011 }
1012 else
1013 {
1014 DPRINT1("Connecting control pipe failed! (Error %lu)\n", dwError);
1015
1016 /* Close control pipe */
1017 CloseHandle(Service->ControlPipeHandle);
1018 Service->ControlPipeHandle = INVALID_HANDLE_VALUE;
1019 Service->ProcessId = 0;
1020 Service->ThreadId = 0;
1021 }
1022
1023 /* Close process and thread handle */
1024 CloseHandle(ProcessInformation.hThread);
1025 CloseHandle(ProcessInformation.hProcess);
1026
1027 return dwError;
1028 }
1029
1030
1031 DWORD
1032 ScmStartService(PSERVICE Service, DWORD argc, LPWSTR *argv)
1033 {
1034 PSERVICE_GROUP Group = Service->lpGroup;
1035 DWORD dwError = ERROR_SUCCESS;
1036
1037 DPRINT("ScmStartService() called\n");
1038
1039 DPRINT1("Start Service %p (%S)\n", Service, Service->lpServiceName);
1040
1041 EnterCriticalSection(&ControlServiceCriticalSection);
1042
1043 if (Service->Status.dwCurrentState != SERVICE_STOPPED)
1044 {
1045 DPRINT1("Service %S is already running!\n", Service->lpServiceName);
1046 LeaveCriticalSection(&ControlServiceCriticalSection);
1047 return ERROR_SERVICE_ALREADY_RUNNING;
1048 }
1049
1050 Service->ControlPipeHandle = INVALID_HANDLE_VALUE;
1051 DPRINT("Service->Type: %lu\n", Service->Status.dwServiceType);
1052
1053 if (Service->Status.dwServiceType & SERVICE_DRIVER)
1054 {
1055 /* Load driver */
1056 dwError = ScmLoadDriver(Service);
1057 if (dwError == ERROR_SUCCESS)
1058 {
1059 Service->Status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
1060 Service->Status.dwCurrentState = SERVICE_RUNNING;
1061 }
1062 }
1063 else
1064 {
1065 /* Start user-mode service */
1066 dwError = ScmStartUserModeService(Service, argc, argv);
1067 if (dwError == ERROR_SUCCESS)
1068 {
1069 #ifdef USE_SERVICE_START_PENDING
1070 Service->Status.dwCurrentState = SERVICE_START_PENDING;
1071 #else
1072 Service->Status.dwCurrentState = SERVICE_RUNNING;
1073 #endif
1074 }
1075 }
1076
1077 LeaveCriticalSection(&ControlServiceCriticalSection);
1078
1079 DPRINT("ScmStartService() done (Error %lu)\n", dwError);
1080
1081 if (dwError == ERROR_SUCCESS)
1082 {
1083 if (Group != NULL)
1084 {
1085 Group->ServicesRunning = TRUE;
1086 }
1087 }
1088 #if 0
1089 else
1090 {
1091 switch (Service->ErrorControl)
1092 {
1093 case SERVICE_ERROR_NORMAL:
1094 /* FIXME: Log error */
1095 break;
1096
1097 case SERVICE_ERROR_SEVERE:
1098 if (IsLastKnownGood == FALSE)
1099 {
1100 /* FIXME: Boot last known good configuration */
1101 }
1102 break;
1103
1104 case SERVICE_ERROR_CRITICAL:
1105 if (IsLastKnownGood == FALSE)
1106 {
1107 /* FIXME: Boot last known good configuration */
1108 }
1109 else
1110 {
1111 /* FIXME: BSOD! */
1112 }
1113 break;
1114 }
1115 }
1116 #endif
1117
1118 return dwError;
1119 }
1120
1121
1122 VOID
1123 ScmAutoStartServices(VOID)
1124 {
1125 PLIST_ENTRY GroupEntry;
1126 PLIST_ENTRY ServiceEntry;
1127 PSERVICE_GROUP CurrentGroup;
1128 PSERVICE CurrentService;
1129 ULONG i;
1130
1131 /* Clear 'ServiceVisited' flag */
1132 ServiceEntry = ServiceListHead.Flink;
1133 while (ServiceEntry != &ServiceListHead)
1134 {
1135 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1136 CurrentService->ServiceVisited = FALSE;
1137 ServiceEntry = ServiceEntry->Flink;
1138 }
1139
1140 /* Start all services which are members of an existing group */
1141 GroupEntry = GroupListHead.Flink;
1142 while (GroupEntry != &GroupListHead)
1143 {
1144 CurrentGroup = CONTAINING_RECORD(GroupEntry, SERVICE_GROUP, GroupListEntry);
1145
1146 DPRINT("Group '%S'\n", CurrentGroup->lpGroupName);
1147
1148 /* Start all services witch have a valid tag */
1149 for (i = 0; i < CurrentGroup->TagCount; i++)
1150 {
1151 ServiceEntry = ServiceListHead.Flink;
1152 while (ServiceEntry != &ServiceListHead)
1153 {
1154 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1155
1156 if ((CurrentService->lpGroup == CurrentGroup) &&
1157 (CurrentService->dwStartType == SERVICE_AUTO_START) &&
1158 (CurrentService->ServiceVisited == FALSE) &&
1159 (CurrentService->dwTag == CurrentGroup->TagArray[i]))
1160 {
1161 CurrentService->ServiceVisited = TRUE;
1162 ScmStartService(CurrentService, 0, NULL);
1163 }
1164
1165 ServiceEntry = ServiceEntry->Flink;
1166 }
1167 }
1168
1169 /* Start all services which have an invalid tag or which do not have a tag */
1170 ServiceEntry = ServiceListHead.Flink;
1171 while (ServiceEntry != &ServiceListHead)
1172 {
1173 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1174
1175 if ((CurrentService->lpGroup == CurrentGroup) &&
1176 (CurrentService->dwStartType == SERVICE_AUTO_START) &&
1177 (CurrentService->ServiceVisited == FALSE))
1178 {
1179 CurrentService->ServiceVisited = TRUE;
1180 ScmStartService(CurrentService, 0, NULL);
1181 }
1182
1183 ServiceEntry = ServiceEntry->Flink;
1184 }
1185
1186 GroupEntry = GroupEntry->Flink;
1187 }
1188
1189 /* Start all services which are members of any non-existing group */
1190 ServiceEntry = ServiceListHead.Flink;
1191 while (ServiceEntry != &ServiceListHead)
1192 {
1193 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1194
1195 if ((CurrentService->lpGroup != NULL) &&
1196 (CurrentService->dwStartType == SERVICE_AUTO_START) &&
1197 (CurrentService->ServiceVisited == FALSE))
1198 {
1199 CurrentService->ServiceVisited = TRUE;
1200 ScmStartService(CurrentService, 0, NULL);
1201 }
1202
1203 ServiceEntry = ServiceEntry->Flink;
1204 }
1205
1206 /* Start all services which are not a member of any group */
1207 ServiceEntry = ServiceListHead.Flink;
1208 while (ServiceEntry != &ServiceListHead)
1209 {
1210 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1211
1212 if ((CurrentService->lpGroup == NULL) &&
1213 (CurrentService->dwStartType == SERVICE_AUTO_START) &&
1214 (CurrentService->ServiceVisited == FALSE))
1215 {
1216 CurrentService->ServiceVisited = TRUE;
1217 ScmStartService(CurrentService, 0, NULL);
1218 }
1219
1220 ServiceEntry = ServiceEntry->Flink;
1221 }
1222
1223 /* Clear 'ServiceVisited' flag again */
1224 ServiceEntry = ServiceListHead.Flink;
1225 while (ServiceEntry != &ServiceListHead)
1226 {
1227 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1228 CurrentService->ServiceVisited = FALSE;
1229 ServiceEntry = ServiceEntry->Flink;
1230 }
1231 }
1232
1233
1234 VOID
1235 ScmAutoShutdownServices(VOID)
1236 {
1237 PLIST_ENTRY ServiceEntry;
1238 PSERVICE CurrentService;
1239
1240 DPRINT("ScmAutoShutdownServices() called\n");
1241
1242 ServiceEntry = ServiceListHead.Flink;
1243 while (ServiceEntry != &ServiceListHead)
1244 {
1245 CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
1246
1247 if (CurrentService->Status.dwCurrentState == SERVICE_RUNNING ||
1248 CurrentService->Status.dwCurrentState == SERVICE_START_PENDING)
1249 {
1250 /* shutdown service */
1251 ScmControlService(CurrentService, SERVICE_CONTROL_STOP);
1252 }
1253
1254 ServiceEntry = ServiceEntry->Flink;
1255 }
1256
1257 DPRINT("ScmGetBootAndSystemDriverState() done\n");
1258 }
1259
1260
1261 BOOL
1262 ScmLockDatabaseExclusive(VOID)
1263 {
1264 return RtlAcquireResourceExclusive(&DatabaseLock, TRUE);
1265 }
1266
1267
1268 BOOL
1269 ScmLockDatabaseShared(VOID)
1270 {
1271 return RtlAcquireResourceShared(&DatabaseLock, TRUE);
1272 }
1273
1274
1275 VOID
1276 ScmUnlockDatabase(VOID)
1277 {
1278 RtlReleaseResource(&DatabaseLock);
1279 }
1280
1281
1282 VOID
1283 ScmInitNamedPipeCriticalSection(VOID)
1284 {
1285 InitializeCriticalSection(&ControlServiceCriticalSection);
1286 }
1287
1288
1289 VOID
1290 ScmDeleteNamedPipeCriticalSection(VOID)
1291 {
1292 DeleteCriticalSection(&ControlServiceCriticalSection);
1293 }
1294
1295 /* EOF */