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