ReactOS 0.4.15-dev-5669-g09dde2c
scm.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: lib/advapi32/service/scm.c
5 * PURPOSE: Service control manager functions
6 * PROGRAMMER: Emanuele Aliberti
7 * Eric Kohl
8 * Pierre Schweitzer
9 */
10
11/* INCLUDES ******************************************************************/
12
13#include <advapi32.h>
15
19 const struct ustring *in,
20 const struct ustring *key,
21 struct ustring *out);
22
26 IN PVOID ContextHandle,
27 OUT LPBYTE SessionKey);
28
29/* FUNCTIONS *****************************************************************/
30
33{
35 RPC_CSTR pszStringBinding;
37
38 TRACE("SVCCTL_HANDLEA_bind(%s)\n",
39 debugstr_a(szMachineName));
40
42 (RPC_CSTR)"ncacn_np",
43 (RPC_CSTR)szMachineName,
44 (RPC_CSTR)"\\pipe\\ntsvcs",
45 NULL,
46 &pszStringBinding);
47 if (status != RPC_S_OK)
48 {
49 ERR("RpcStringBindingCompose returned 0x%x\n", status);
50 return NULL;
51 }
52
53 /* Set the binding handle that will be used to bind to the server. */
54 status = RpcBindingFromStringBindingA(pszStringBinding,
55 &hBinding);
56 if (status != RPC_S_OK)
57 {
58 ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
59 }
60
61 status = RpcStringFreeA(&pszStringBinding);
62 if (status != RPC_S_OK)
63 {
64 ERR("RpcStringFree returned 0x%x\n", status);
65 }
66
67 return hBinding;
68}
69
70
71void __RPC_USER
74{
76
77 TRACE("SVCCTL_HANDLEA_unbind(%s %p)\n",
78 debugstr_a(szMachineName), hBinding);
79
81 if (status != RPC_S_OK)
82 {
83 ERR("RpcBindingFree returned 0x%x\n", status);
84 }
85}
86
87
90{
92 RPC_WSTR pszStringBinding;
94
95 TRACE("SVCCTL_HANDLEW_bind(%s)\n",
96 debugstr_w(szMachineName));
97
99 L"ncacn_np",
100 szMachineName,
101 L"\\pipe\\ntsvcs",
102 NULL,
103 &pszStringBinding);
104 if (status != RPC_S_OK)
105 {
106 ERR("RpcStringBindingCompose returned 0x%x\n", status);
107 return NULL;
108 }
109
110 /* Set the binding handle that will be used to bind to the server. */
111 status = RpcBindingFromStringBindingW(pszStringBinding,
112 &hBinding);
113 if (status != RPC_S_OK)
114 {
115 ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
116 }
117
118 status = RpcStringFreeW(&pszStringBinding);
119 if (status != RPC_S_OK)
120 {
121 ERR("RpcStringFree returned 0x%x\n", status);
122 }
123
124 return hBinding;
125}
126
127
128void __RPC_USER
131{
133
134 TRACE("SVCCTL_HANDLEW_unbind(%s %p)\n",
135 debugstr_w(szMachineName), hBinding);
136
138 if (status != RPC_S_OK)
139 {
140 ERR("RpcBindingFree returned 0x%x\n", status);
141 }
142}
143
144
145DWORD
147{
148 TRACE("ScmRpcStatusToWinError(%lx)\n",
149 Status);
150
151 switch (Status)
152 {
157
161
164
165 default:
166 return (DWORD)Status;
167 }
168}
169
170
171static
172DWORD
174 _In_ PVOID ContextHandle,
175 _In_ PCWSTR pClearTextPassword,
176 _Out_ PBYTE *pEncryptedPassword,
177 _Out_ PDWORD pEncryptedPasswordSize)
178{
179 struct ustring inData, keyData, outData;
180 BYTE SessionKey[16];
183
184 /* Get the session key */
185 Status = SystemFunction028(ContextHandle,
186 SessionKey);
187 if (!NT_SUCCESS(Status))
188 {
189 ERR("SystemFunction028 failed (Status 0x%08lx)\n", Status);
191 }
192
193 inData.Length = (wcslen(pClearTextPassword) + 1) * sizeof(WCHAR);
194 inData.MaximumLength = inData.Length;
195 inData.Buffer = (unsigned char *)pClearTextPassword;
196
197 keyData.Length = sizeof(SessionKey);
198 keyData.MaximumLength = keyData.Length;
199 keyData.Buffer = SessionKey;
200
201 outData.Length = 0;
202 outData.MaximumLength = 0;
203 outData.Buffer = NULL;
204
205 /* Get the required buffer size */
206 Status = SystemFunction004(&inData,
207 &keyData,
208 &outData);
210 {
211 ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
213 }
214
215 /* Allocate a buffer for the encrypted password */
216 pBuffer = HeapAlloc(GetProcessHeap(), 0, outData.Length);
217 if (pBuffer == NULL)
218 return ERROR_OUTOFMEMORY;
219
220 outData.MaximumLength = outData.Length;
221 outData.Buffer = pBuffer;
222
223 /* Encrypt the password */
224 Status = SystemFunction004(&inData,
225 &keyData,
226 &outData);
227 if (!NT_SUCCESS(Status))
228 {
229 ERR("SystemFunction004 failed (Status 0x%08lx)\n", Status);
232 }
233
234 *pEncryptedPassword = outData.Buffer;
235 *pEncryptedPasswordSize = outData.Length;
236
237 return ERROR_SUCCESS;
238}
239
240
241/**********************************************************************
242 * ChangeServiceConfig2A
243 *
244 * @implemented
245 */
247ChangeServiceConfig2A(SC_HANDLE hService,
249 LPVOID lpInfo)
250{
252 DWORD dwError;
253
254 TRACE("ChangeServiceConfig2A(%p %lu %p)\n",
255 hService, dwInfoLevel, lpInfo);
256
257 if (lpInfo == NULL) return TRUE;
258
259 /* Fill relevant field of the Info structure */
260 Info.dwInfoLevel = dwInfoLevel;
261 switch (dwInfoLevel)
262 {
264 Info.psd = lpInfo;
265 break;
266
268 Info.psfa = lpInfo;
269 break;
270
271 default:
272 WARN("Unknown info level 0x%lx\n", dwInfoLevel);
274 return FALSE;
275 }
276
278 {
279 dwError = RChangeServiceConfig2A((SC_RPC_HANDLE)hService,
280 Info);
281 }
283 {
285 }
287
288 if (dwError != ERROR_SUCCESS)
289 {
290 TRACE("RChangeServiceConfig2A() failed (Error %lu)\n", dwError);
291 SetLastError(dwError);
292 return FALSE;
293 }
294
295 return TRUE;
296}
297
298
299/**********************************************************************
300 * ChangeServiceConfig2W
301 *
302 * @implemented
303 */
305ChangeServiceConfig2W(SC_HANDLE hService,
307 LPVOID lpInfo)
308{
310 DWORD dwError;
311
312 TRACE("ChangeServiceConfig2W(%p %lu %p)\n",
313 hService, dwInfoLevel, lpInfo);
314
315 if (lpInfo == NULL) return TRUE;
316
317 /* Fill relevant field of the Info structure */
318 Info.dwInfoLevel = dwInfoLevel;
319 switch (dwInfoLevel)
320 {
322 Info.psd = lpInfo;
323 break;
324
326 Info.psfa = lpInfo;
327 break;
328
329 default:
330 WARN("Unknown info level 0x%lx\n", dwInfoLevel);
332 return FALSE;
333 }
334
336 {
337 dwError = RChangeServiceConfig2W((SC_RPC_HANDLE)hService,
338 Info);
339 }
341 {
343 }
345
346 if (dwError != ERROR_SUCCESS)
347 {
348 TRACE("RChangeServiceConfig2W() failed (Error %lu)\n", dwError);
349 SetLastError(dwError);
350 return FALSE;
351 }
352
353 return TRUE;
354}
355
356
357/**********************************************************************
358 * ChangeServiceConfigA
359 *
360 * @implemented
361 */
363ChangeServiceConfigA(SC_HANDLE hService,
364 DWORD dwServiceType,
365 DWORD dwStartType,
366 DWORD dwErrorControl,
367 LPCSTR lpBinaryPathName,
368 LPCSTR lpLoadOrderGroup,
369 LPDWORD lpdwTagId,
370 LPCSTR lpDependencies,
371 LPCSTR lpServiceStartName,
372 LPCSTR lpPassword,
374{
375 DWORD dwError;
376 DWORD dwDependenciesLength = 0;
377 SIZE_T cchLength;
378 LPCSTR lpStr;
379 DWORD dwPasswordSize = 0;
380 LPWSTR lpPasswordW = NULL;
381 LPBYTE lpEncryptedPassword = NULL;
382
383 TRACE("ChangeServiceConfigA(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
384 hService, dwServiceType, dwStartType, dwErrorControl, debugstr_a(lpBinaryPathName),
385 debugstr_a(lpLoadOrderGroup), lpdwTagId, debugstr_a(lpDependencies),
386 debugstr_a(lpServiceStartName), debugstr_a(lpPassword), debugstr_a(lpDisplayName));
387
388 /* Calculate the Dependencies length*/
389 if (lpDependencies != NULL)
390 {
391 lpStr = lpDependencies;
392 while (*lpStr)
393 {
394 cchLength = strlen(lpStr) + 1;
395 dwDependenciesLength += (DWORD)cchLength;
396 lpStr = lpStr + cchLength;
397 }
398 dwDependenciesLength++;
399 }
400
401 if (lpPassword != NULL)
402 {
403 /* Convert the password to unicode */
404 lpPasswordW = HeapAlloc(GetProcessHeap(),
406 (strlen(lpPassword) + 1) * sizeof(WCHAR));
407 if (lpPasswordW == NULL)
408 {
410 return FALSE;
411 }
412
414 0,
415 lpPassword,
416 -1,
417 lpPasswordW,
418 (int)(strlen(lpPassword) + 1));
419
420 /* Encrypt the unicode password */
421 dwError = ScmEncryptPassword(hService,
422 lpPasswordW,
423 &lpEncryptedPassword,
424 &dwPasswordSize);
425 if (dwError != ERROR_SUCCESS)
426 goto done;
427 }
428
430 {
431 dwError = RChangeServiceConfigA((SC_RPC_HANDLE)hService,
432 dwServiceType,
433 dwStartType,
434 dwErrorControl,
435 (LPSTR)lpBinaryPathName,
436 (LPSTR)lpLoadOrderGroup,
437 lpdwTagId,
438 (LPBYTE)lpDependencies,
439 dwDependenciesLength,
440 (LPSTR)lpServiceStartName,
441 lpEncryptedPassword,
442 dwPasswordSize,
444 }
446 {
448 }
450
451done:
452 if (lpPasswordW != NULL)
453 {
454 /* Wipe and release the password buffers */
455 SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
456 HeapFree(GetProcessHeap(), 0, lpPasswordW);
457
458 if (lpEncryptedPassword != NULL)
459 {
460 SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
461 HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
462 }
463 }
464
465 if (dwError != ERROR_SUCCESS)
466 {
467 TRACE("RChangeServiceConfigA() failed (Error %lu)\n", dwError);
468 SetLastError(dwError);
469 return FALSE;
470 }
471
472 return TRUE;
473}
474
475
476/**********************************************************************
477 * ChangeServiceConfigW
478 *
479 * @implemented
480 */
482ChangeServiceConfigW(SC_HANDLE hService,
483 DWORD dwServiceType,
484 DWORD dwStartType,
485 DWORD dwErrorControl,
486 LPCWSTR lpBinaryPathName,
487 LPCWSTR lpLoadOrderGroup,
488 LPDWORD lpdwTagId,
489 LPCWSTR lpDependencies,
490 LPCWSTR lpServiceStartName,
491 LPCWSTR lpPassword,
493{
494 DWORD dwError;
495 DWORD dwDependenciesLength = 0;
496 SIZE_T cchLength;
497 LPCWSTR lpStr;
498 DWORD dwPasswordSize = 0;
499 LPBYTE lpEncryptedPassword = NULL;
500
501 TRACE("ChangeServiceConfigW(%p %lu %lu %lu %s %s %p %s %s %s %s)\n",
502 hService, dwServiceType, dwStartType, dwErrorControl, debugstr_w(lpBinaryPathName),
503 debugstr_w(lpLoadOrderGroup), lpdwTagId, debugstr_w(lpDependencies),
504 debugstr_w(lpServiceStartName), debugstr_w(lpPassword), debugstr_w(lpDisplayName));
505
506 /* Calculate the Dependencies length*/
507 if (lpDependencies != NULL)
508 {
509 lpStr = lpDependencies;
510 while (*lpStr)
511 {
512 cchLength = wcslen(lpStr) + 1;
513 dwDependenciesLength += (DWORD)cchLength;
514 lpStr = lpStr + cchLength;
515 }
516 dwDependenciesLength++;
517 dwDependenciesLength *= sizeof(WCHAR);
518 }
519
520 if (lpPassword != NULL)
521 {
522 dwError = ScmEncryptPassword(hService,
523 lpPassword,
524 &lpEncryptedPassword,
525 &dwPasswordSize);
526 if (dwError != ERROR_SUCCESS)
527 {
528 ERR("ScmEncryptPassword failed (Error %lu)\n", dwError);
529 goto done;
530 }
531 }
532
534 {
535 dwError = RChangeServiceConfigW((SC_RPC_HANDLE)hService,
536 dwServiceType,
537 dwStartType,
538 dwErrorControl,
539 (LPWSTR)lpBinaryPathName,
540 (LPWSTR)lpLoadOrderGroup,
541 lpdwTagId,
542 (LPBYTE)lpDependencies,
543 dwDependenciesLength,
544 (LPWSTR)lpServiceStartName,
545 lpEncryptedPassword,
546 dwPasswordSize,
548 }
550 {
552 }
554
555done:
556 if (lpEncryptedPassword != NULL)
557 {
558 /* Wipe and release the password buffer */
559 SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
560 HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
561 }
562
563 if (dwError != ERROR_SUCCESS)
564 {
565 TRACE("RChangeServiceConfigW() failed (Error %lu)\n", dwError);
566 SetLastError(dwError);
567 return FALSE;
568 }
569
570 return TRUE;
571}
572
573
574/**********************************************************************
575 * CloseServiceHandle
576 *
577 * @implemented
578 */
580CloseServiceHandle(SC_HANDLE hSCObject)
581{
582 DWORD dwError;
583
584 TRACE("CloseServiceHandle(%p)\n",
585 hSCObject);
586
587 if (!hSCObject)
588 {
590 return FALSE;
591 }
592
594 {
595 dwError = RCloseServiceHandle((LPSC_RPC_HANDLE)&hSCObject);
596 }
598 {
600 }
602
603 if (dwError)
604 {
605 TRACE("RCloseServiceHandle() failed (Error %lu)\n", dwError);
606 SetLastError(dwError);
607 return FALSE;
608 }
609
610 TRACE("CloseServiceHandle() done\n");
611
612 return TRUE;
613}
614
615
616/**********************************************************************
617 * ControlService
618 *
619 * @implemented
620 */
622ControlService(SC_HANDLE hService,
623 DWORD dwControl,
624 LPSERVICE_STATUS lpServiceStatus)
625{
626 DWORD dwError;
627
628 TRACE("ControlService(%p %lu %p)\n",
629 hService, dwControl, lpServiceStatus);
630
632 {
633 dwError = RControlService((SC_RPC_HANDLE)hService,
634 dwControl,
635 lpServiceStatus);
636 }
638 {
640 }
642
643 if (dwError != ERROR_SUCCESS)
644 {
645 TRACE("RControlService() failed (Error %lu)\n", dwError);
646 SetLastError(dwError);
647 return FALSE;
648 }
649
650 TRACE("ControlService() done\n");
651
652 return TRUE;
653}
654
655
656/**********************************************************************
657 * ControlServiceEx
658 *
659 * @unimplemented
660 */
662ControlServiceEx(IN SC_HANDLE hService,
663 IN DWORD dwControl,
665 IN OUT PVOID pControlParams)
666{
667 FIXME("ControlServiceEx(%p %lu %lu %p)\n",
668 hService, dwControl, dwInfoLevel, pControlParams);
670 return FALSE;
671}
672
673
674/**********************************************************************
675 * CreateServiceA
676 *
677 * @implemented
678 */
679SC_HANDLE WINAPI
681 LPCSTR lpServiceName,
683 DWORD dwDesiredAccess,
684 DWORD dwServiceType,
685 DWORD dwStartType,
686 DWORD dwErrorControl,
687 LPCSTR lpBinaryPathName,
688 LPCSTR lpLoadOrderGroup,
689 LPDWORD lpdwTagId,
690 LPCSTR lpDependencies,
691 LPCSTR lpServiceStartName,
692 LPCSTR lpPassword)
693{
694 SC_HANDLE hService = NULL;
695 DWORD dwDependenciesLength = 0;
696 DWORD dwError;
697 SIZE_T cchLength;
698 LPCSTR lpStr;
699 DWORD dwPasswordSize = 0;
700 LPWSTR lpPasswordW = NULL;
701 LPBYTE lpEncryptedPassword = NULL;
702
703 TRACE("CreateServiceA(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
705 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
706 debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup), lpdwTagId,
707 debugstr_a(lpDependencies), debugstr_a(lpServiceStartName), debugstr_a(lpPassword));
708
709 if (!hSCManager)
710 {
712 return NULL;
713 }
714
715 /* Calculate the Dependencies length */
716 if (lpDependencies != NULL)
717 {
718 lpStr = lpDependencies;
719 while (*lpStr)
720 {
721 cchLength = strlen(lpStr) + 1;
722 dwDependenciesLength += (DWORD)cchLength;
723 lpStr = lpStr + cchLength;
724 }
725 dwDependenciesLength++;
726 }
727
728 if (lpPassword != NULL)
729 {
730 /* Convert the password to unicode */
731 lpPasswordW = HeapAlloc(GetProcessHeap(),
733 (strlen(lpPassword) + 1) * sizeof(WCHAR));
734 if (lpPasswordW == NULL)
735 {
737 return FALSE;
738 }
739
741 0,
742 lpPassword,
743 -1,
744 lpPasswordW,
745 (int)(strlen(lpPassword) + 1));
746
747 /* Encrypt the password */
749 lpPasswordW,
750 &lpEncryptedPassword,
751 &dwPasswordSize);
752 if (dwError != ERROR_SUCCESS)
753 goto done;
754 }
755
757 {
759 (LPSTR)lpServiceName,
761 dwDesiredAccess,
762 dwServiceType,
763 dwStartType,
764 dwErrorControl,
765 (LPSTR)lpBinaryPathName,
766 (LPSTR)lpLoadOrderGroup,
767 lpdwTagId,
768 (LPBYTE)lpDependencies,
769 dwDependenciesLength,
770 (LPSTR)lpServiceStartName,
771 lpEncryptedPassword,
772 dwPasswordSize,
773 (SC_RPC_HANDLE *)&hService);
774 }
776 {
778 }
780
781done:
782 if (lpPasswordW != NULL)
783 {
784 /* Wipe and release the password buffers */
785 SecureZeroMemory(lpPasswordW, (wcslen(lpPasswordW) + 1) * sizeof(WCHAR));
786 HeapFree(GetProcessHeap(), 0, lpPasswordW);
787
788 if (lpEncryptedPassword != NULL)
789 {
790 SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
791 HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
792 }
793 }
794
795 SetLastError(dwError);
796 if (dwError != ERROR_SUCCESS)
797 {
798 TRACE("RCreateServiceA() failed (Error %lu)\n", dwError);
799 return NULL;
800 }
801
802 return hService;
803}
804
805
806/**********************************************************************
807 * CreateServiceW
808 *
809 * @implemented
810 */
811SC_HANDLE WINAPI
813 LPCWSTR lpServiceName,
815 DWORD dwDesiredAccess,
816 DWORD dwServiceType,
817 DWORD dwStartType,
818 DWORD dwErrorControl,
819 LPCWSTR lpBinaryPathName,
820 LPCWSTR lpLoadOrderGroup,
821 LPDWORD lpdwTagId,
822 LPCWSTR lpDependencies,
823 LPCWSTR lpServiceStartName,
824 LPCWSTR lpPassword)
825{
826 SC_HANDLE hService = NULL;
827 DWORD dwDependenciesLength = 0;
828 DWORD dwError;
829 SIZE_T cchLength;
830 LPCWSTR lpStr;
831 DWORD dwPasswordSize = 0;
832 LPBYTE lpEncryptedPassword = NULL;
833
834 TRACE("CreateServiceW(%p %s %s %lx %lu %lu %lu %s %s %p %s %s %s)\n",
836 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
837 debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup), lpdwTagId,
838 debugstr_w(lpDependencies), debugstr_w(lpServiceStartName), debugstr_w(lpPassword));
839
840 if (!hSCManager)
841 {
843 return NULL;
844 }
845
846 /* Calculate the Dependencies length */
847 if (lpDependencies != NULL)
848 {
849 lpStr = lpDependencies;
850 while (*lpStr)
851 {
852 cchLength = wcslen(lpStr) + 1;
853 dwDependenciesLength += (DWORD)cchLength;
854 lpStr = lpStr + cchLength;
855 }
856 dwDependenciesLength++;
857 dwDependenciesLength *= sizeof(WCHAR);
858 }
859
860 if (lpPassword != NULL)
861 {
862 /* Encrypt the password */
864 lpPassword,
865 &lpEncryptedPassword,
866 &dwPasswordSize);
867 if (dwError != ERROR_SUCCESS)
868 goto done;
869 }
870
872 {
874 lpServiceName,
876 dwDesiredAccess,
877 dwServiceType,
878 dwStartType,
879 dwErrorControl,
880 lpBinaryPathName,
881 lpLoadOrderGroup,
882 lpdwTagId,
883 (LPBYTE)lpDependencies,
884 dwDependenciesLength,
885 lpServiceStartName,
886 lpEncryptedPassword,
887 dwPasswordSize,
888 (SC_RPC_HANDLE *)&hService);
889 }
891 {
893 }
895
896done:
897 if (lpEncryptedPassword != NULL)
898 {
899 /* Wipe and release the password buffers */
900 SecureZeroMemory(lpEncryptedPassword, dwPasswordSize);
901 HeapFree(GetProcessHeap(), 0, lpEncryptedPassword);
902 }
903
904 SetLastError(dwError);
905 if (dwError != ERROR_SUCCESS)
906 {
907 TRACE("RCreateServiceW() failed (Error %lu)\n", dwError);
908 return NULL;
909 }
910
911 return hService;
912}
913
914
915/**********************************************************************
916 * DeleteService
917 *
918 * @implemented
919 */
921DeleteService(SC_HANDLE hService)
922{
923 DWORD dwError;
924
925 TRACE("DeleteService(%p)\n",
926 hService);
927
929 {
930 dwError = RDeleteService((SC_RPC_HANDLE)hService);
931 }
933 {
935 }
937
938 if (dwError != ERROR_SUCCESS)
939 {
940 TRACE("RDeleteService() failed (Error %lu)\n", dwError);
941 SetLastError(dwError);
942 return FALSE;
943 }
944
945 return TRUE;
946}
947
948
949/**********************************************************************
950 * EnumDependentServicesA
951 *
952 * @implemented
953 */
955EnumDependentServicesA(SC_HANDLE hService,
956 DWORD dwServiceState,
957 LPENUM_SERVICE_STATUSA lpServices,
960 LPDWORD lpServicesReturned)
961{
963 LPENUM_SERVICE_STATUSA lpStatusPtr;
964 DWORD dwBufferSize;
965 DWORD dwError;
966 DWORD dwCount;
967
968 TRACE("EnumDependentServicesA(%p %lu %p %lu %p %p)\n",
969 hService, dwServiceState, lpServices, cbBufSize,
970 pcbBytesNeeded, lpServicesReturned);
971
972 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
973 {
974 lpStatusPtr = &ServiceStatus;
975 dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
976 }
977 else
978 {
979 lpStatusPtr = lpServices;
980 dwBufferSize = cbBufSize;
981 }
982
984 {
985 dwError = REnumDependentServicesA((SC_RPC_HANDLE)hService,
986 dwServiceState,
987 (LPBYTE)lpStatusPtr,
988 dwBufferSize,
990 lpServicesReturned);
991 }
993 {
995 }
997
998 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
999 {
1000 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1001 {
1002 if (lpStatusPtr->lpServiceName)
1003 lpStatusPtr->lpServiceName =
1004 (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1005
1006 if (lpStatusPtr->lpDisplayName)
1007 lpStatusPtr->lpDisplayName =
1008 (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1009
1010 lpStatusPtr++;
1011 }
1012 }
1013
1014 if (dwError != ERROR_SUCCESS)
1015 {
1016 TRACE("REnumDependentServicesA() failed (Error %lu)\n", dwError);
1017 SetLastError(dwError);
1018 return FALSE;
1019 }
1020
1021 TRACE("EnumDependentServicesA() done\n");
1022
1023 return TRUE;
1024}
1025
1026
1027/**********************************************************************
1028 * EnumDependentServicesW
1029 *
1030 * @implemented
1031 */
1033EnumDependentServicesW(SC_HANDLE hService,
1034 DWORD dwServiceState,
1035 LPENUM_SERVICE_STATUSW lpServices,
1038 LPDWORD lpServicesReturned)
1039{
1041 LPENUM_SERVICE_STATUSW lpStatusPtr;
1042 DWORD dwBufferSize;
1043 DWORD dwError;
1044 DWORD dwCount;
1045
1046 TRACE("EnumDependentServicesW(%p %lu %p %lu %p %p)\n",
1047 hService, dwServiceState, lpServices, cbBufSize,
1048 pcbBytesNeeded, lpServicesReturned);
1049
1050 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1051 {
1052 lpStatusPtr = &ServiceStatus;
1053 dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1054 }
1055 else
1056 {
1057 lpStatusPtr = lpServices;
1058 dwBufferSize = cbBufSize;
1059 }
1060
1062 {
1063 dwError = REnumDependentServicesW((SC_RPC_HANDLE)hService,
1064 dwServiceState,
1065 (LPBYTE)lpStatusPtr,
1066 dwBufferSize,
1068 lpServicesReturned);
1069 }
1071 {
1073 }
1075
1076 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1077 {
1078 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1079 {
1080 if (lpStatusPtr->lpServiceName)
1081 lpStatusPtr->lpServiceName =
1082 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1083
1084 if (lpStatusPtr->lpDisplayName)
1085 lpStatusPtr->lpDisplayName =
1086 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1087
1088 lpStatusPtr++;
1089 }
1090 }
1091
1092 if (dwError != ERROR_SUCCESS)
1093 {
1094 TRACE("REnumDependentServicesW() failed (Error %lu)\n", dwError);
1095 SetLastError(dwError);
1096 return FALSE;
1097 }
1098
1099 TRACE("EnumDependentServicesW() done\n");
1100
1101 return TRUE;
1102}
1103
1104
1105/**********************************************************************
1106 * EnumServiceGroupW
1107 *
1108 * @implemented
1109 */
1112 DWORD dwServiceType,
1113 DWORD dwServiceState,
1114 LPENUM_SERVICE_STATUSW lpServices,
1117 LPDWORD lpServicesReturned,
1118 LPDWORD lpResumeHandle,
1119 LPCWSTR lpGroup)
1120{
1122 LPENUM_SERVICE_STATUSW lpStatusPtr;
1123 DWORD dwBufferSize;
1124 DWORD dwError;
1125 DWORD dwCount;
1126
1127 TRACE("EnumServiceGroupW(%p %lu %lu %p %lu %p %p %p %s)\n",
1128 hSCManager, dwServiceType, dwServiceState, lpServices,
1129 cbBufSize, pcbBytesNeeded, lpServicesReturned,
1130 lpResumeHandle, debugstr_w(lpGroup));
1131
1132 if (!hSCManager)
1133 {
1135 return FALSE;
1136 }
1137
1138 if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1139 {
1141 return FALSE;
1142 }
1143
1144 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1145 {
1146 lpStatusPtr = &ServiceStatus;
1147 dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1148 }
1149 else
1150 {
1151 lpStatusPtr = lpServices;
1152 dwBufferSize = cbBufSize;
1153 }
1154
1156 {
1157 if (lpGroup == NULL)
1158 {
1160 dwServiceType,
1161 dwServiceState,
1162 (LPBYTE)lpStatusPtr,
1163 dwBufferSize,
1165 lpServicesReturned,
1166 lpResumeHandle);
1167 }
1168 else
1169 {
1171 dwServiceType,
1172 dwServiceState,
1173 (LPBYTE)lpStatusPtr,
1174 dwBufferSize,
1176 lpServicesReturned,
1177 lpResumeHandle,
1178 lpGroup);
1179 }
1180 }
1182 {
1184 }
1186
1187 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1188 {
1189 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1190 {
1191 if (lpStatusPtr->lpServiceName)
1192 lpStatusPtr->lpServiceName =
1193 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1194
1195 if (lpStatusPtr->lpDisplayName)
1196 lpStatusPtr->lpDisplayName =
1197 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1198
1199 lpStatusPtr++;
1200 }
1201 }
1202
1203 if (dwError != ERROR_SUCCESS)
1204 {
1205 TRACE("REnumServiceGroupW() failed (Error %lu)\n", dwError);
1206 SetLastError(dwError);
1207 return FALSE;
1208 }
1209
1210 TRACE("EnumServiceGroupW() done\n");
1211
1212 return TRUE;
1213}
1214
1215
1216/**********************************************************************
1217 * EnumServicesStatusA
1218 *
1219 * @implemented
1220 */
1223 DWORD dwServiceType,
1224 DWORD dwServiceState,
1225 LPENUM_SERVICE_STATUSA lpServices,
1228 LPDWORD lpServicesReturned,
1229 LPDWORD lpResumeHandle)
1230{
1232 LPENUM_SERVICE_STATUSA lpStatusPtr;
1233 DWORD dwBufferSize;
1234 DWORD dwError;
1235 DWORD dwCount;
1236
1237 TRACE("EnumServicesStatusA(%p %lu %lu %p %lu %p %p %p)\n",
1238 hSCManager, dwServiceType, dwServiceState, lpServices,
1239 cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
1240
1241 if (!hSCManager)
1242 {
1244 return FALSE;
1245 }
1246
1247 if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1248 {
1250 return FALSE;
1251 }
1252
1253 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSA))
1254 {
1255 lpStatusPtr = &ServiceStatus;
1256 dwBufferSize = sizeof(ENUM_SERVICE_STATUSA);
1257 }
1258 else
1259 {
1260 lpStatusPtr = lpServices;
1261 dwBufferSize = cbBufSize;
1262 }
1263
1265 {
1267 dwServiceType,
1268 dwServiceState,
1269 (LPBYTE)lpStatusPtr,
1270 dwBufferSize,
1272 lpServicesReturned,
1273 lpResumeHandle);
1274 }
1276 {
1278 }
1280
1281 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1282 {
1283 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1284 {
1285 if (lpStatusPtr->lpServiceName)
1286 lpStatusPtr->lpServiceName =
1287 (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1288
1289 if (lpStatusPtr->lpDisplayName)
1290 lpStatusPtr->lpDisplayName =
1291 (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1292
1293 lpStatusPtr++;
1294 }
1295 }
1296
1297 if (dwError != ERROR_SUCCESS)
1298 {
1299 TRACE("REnumServicesStatusA() failed (Error %lu)\n", dwError);
1300 SetLastError(dwError);
1301 return FALSE;
1302 }
1303
1304 TRACE("EnumServicesStatusA() done\n");
1305
1306 return TRUE;
1307}
1308
1309
1310/**********************************************************************
1311 * EnumServicesStatusW
1312 *
1313 * @implemented
1314 */
1317 DWORD dwServiceType,
1318 DWORD dwServiceState,
1319 LPENUM_SERVICE_STATUSW lpServices,
1322 LPDWORD lpServicesReturned,
1323 LPDWORD lpResumeHandle)
1324{
1326 LPENUM_SERVICE_STATUSW lpStatusPtr;
1327 DWORD dwBufferSize;
1328 DWORD dwError;
1329 DWORD dwCount;
1330
1331 TRACE("EnumServicesStatusW(%p %lu %lu %p %lu %p %p %p)\n",
1332 hSCManager, dwServiceType, dwServiceState, lpServices,
1333 cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
1334
1335 if (!hSCManager)
1336 {
1338 return FALSE;
1339 }
1340
1341 if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1342 {
1344 return FALSE;
1345 }
1346
1347 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUSW))
1348 {
1349 lpStatusPtr = &ServiceStatus;
1350 dwBufferSize = sizeof(ENUM_SERVICE_STATUSW);
1351 }
1352 else
1353 {
1354 lpStatusPtr = lpServices;
1355 dwBufferSize = cbBufSize;
1356 }
1357
1359 {
1361 dwServiceType,
1362 dwServiceState,
1363 (LPBYTE)lpStatusPtr,
1364 dwBufferSize,
1366 lpServicesReturned,
1367 lpResumeHandle);
1368 }
1370 {
1372 }
1374
1375 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1376 {
1377 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1378 {
1379 if (lpStatusPtr->lpServiceName)
1380 lpStatusPtr->lpServiceName =
1381 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1382
1383 if (lpStatusPtr->lpDisplayName)
1384 lpStatusPtr->lpDisplayName =
1385 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1386
1387 lpStatusPtr++;
1388 }
1389 }
1390
1391 if (dwError != ERROR_SUCCESS)
1392 {
1393 TRACE("REnumServicesStatusW() failed (Error %lu)\n", dwError);
1394 SetLastError(dwError);
1395 return FALSE;
1396 }
1397
1398 TRACE("EnumServicesStatusW() done\n");
1399
1400 return TRUE;
1401}
1402
1403
1404/**********************************************************************
1405 * EnumServicesStatusExA
1406 *
1407 * @implemented
1408 */
1411 SC_ENUM_TYPE InfoLevel,
1412 DWORD dwServiceType,
1413 DWORD dwServiceState,
1414 LPBYTE lpServices,
1417 LPDWORD lpServicesReturned,
1418 LPDWORD lpResumeHandle,
1419 LPCSTR pszGroupName)
1420{
1423 DWORD dwBufferSize;
1424 DWORD dwError;
1425 DWORD dwCount;
1426
1427 TRACE("EnumServicesStatusExA(%p %lu %lu %p %lu %p %p %p %s)\n",
1428 hSCManager, dwServiceType, dwServiceState, lpServices,
1429 cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
1430 debugstr_a(pszGroupName));
1431
1432 if (InfoLevel != SC_ENUM_PROCESS_INFO)
1433 {
1435 return FALSE;
1436 }
1437
1438 if (!hSCManager)
1439 {
1441 return FALSE;
1442 }
1443
1444 if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1445 {
1447 return FALSE;
1448 }
1449
1450 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSA))
1451 {
1452 lpStatusPtr = &ServiceStatus;
1453 dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSA);
1454 }
1455 else
1456 {
1457 lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSA)lpServices;
1458 dwBufferSize = cbBufSize;
1459 }
1460
1462 {
1464 InfoLevel,
1465 dwServiceType,
1466 dwServiceState,
1467 (LPBYTE)lpStatusPtr,
1468 dwBufferSize,
1470 lpServicesReturned,
1471 lpResumeHandle,
1472 (LPSTR)pszGroupName);
1473 }
1475 {
1477 }
1479
1480 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1481 {
1482 if (InfoLevel == SC_ENUM_PROCESS_INFO)
1483 {
1484 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1485 {
1486 if (lpStatusPtr->lpServiceName)
1487 lpStatusPtr->lpServiceName =
1488 (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1489
1490 if (lpStatusPtr->lpDisplayName)
1491 lpStatusPtr->lpDisplayName =
1492 (LPSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1493
1494 lpStatusPtr++;
1495 }
1496 }
1497 }
1498
1499 if (dwError != ERROR_SUCCESS)
1500 {
1501 TRACE("REnumServicesStatusExA() failed (Error %lu)\n", dwError);
1502 SetLastError(dwError);
1503 return FALSE;
1504 }
1505
1506 TRACE("EnumServicesStatusExA() done\n");
1507
1508 return TRUE;
1509}
1510
1511
1512/**********************************************************************
1513 * EnumServicesStatusExW
1514 *
1515 * @implemented
1516 */
1519 SC_ENUM_TYPE InfoLevel,
1520 DWORD dwServiceType,
1521 DWORD dwServiceState,
1522 LPBYTE lpServices,
1525 LPDWORD lpServicesReturned,
1526 LPDWORD lpResumeHandle,
1527 LPCWSTR pszGroupName)
1528{
1531 DWORD dwBufferSize;
1532 DWORD dwError;
1533 DWORD dwCount;
1534
1535 TRACE("EnumServicesStatusExW(%p %lu %lu %p %lu %p %p %p %s)\n",
1536 hSCManager, dwServiceType, dwServiceState, lpServices,
1537 cbBufSize, pcbBytesNeeded, lpServicesReturned, lpResumeHandle,
1538 debugstr_w(pszGroupName));
1539
1540 if (InfoLevel != SC_ENUM_PROCESS_INFO)
1541 {
1543 return FALSE;
1544 }
1545
1546 if (!hSCManager)
1547 {
1549 return FALSE;
1550 }
1551
1552 if (pcbBytesNeeded == NULL || lpServicesReturned == NULL)
1553 {
1555 return FALSE;
1556 }
1557
1558 if (lpServices == NULL || cbBufSize < sizeof(ENUM_SERVICE_STATUS_PROCESSW))
1559 {
1560 lpStatusPtr = &ServiceStatus;
1561 dwBufferSize = sizeof(ENUM_SERVICE_STATUS_PROCESSW);
1562 }
1563 else
1564 {
1565 lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
1566 dwBufferSize = cbBufSize;
1567 }
1568
1570 {
1572 InfoLevel,
1573 dwServiceType,
1574 dwServiceState,
1575 (LPBYTE)lpStatusPtr,
1576 dwBufferSize,
1578 lpServicesReturned,
1579 lpResumeHandle,
1580 (LPWSTR)pszGroupName);
1581 }
1583 {
1585 }
1587
1588 if (dwError == ERROR_SUCCESS || dwError == ERROR_MORE_DATA)
1589 {
1590 if (InfoLevel == SC_ENUM_PROCESS_INFO)
1591 {
1592 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
1593 {
1594 if (lpStatusPtr->lpServiceName)
1595 lpStatusPtr->lpServiceName =
1596 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
1597
1598 if (lpStatusPtr->lpDisplayName)
1599 lpStatusPtr->lpDisplayName =
1600 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
1601
1602 lpStatusPtr++;
1603 }
1604 }
1605 }
1606
1607 if (dwError != ERROR_SUCCESS)
1608 {
1609 TRACE("REnumServicesStatusExW() failed (Error %lu)\n", dwError);
1610 SetLastError(dwError);
1611 return FALSE;
1612 }
1613
1614 TRACE("EnumServicesStatusExW() done\n");
1615
1616 return TRUE;
1617}
1618
1619
1620/**********************************************************************
1621 * GetServiceDisplayNameA
1622 *
1623 * @implemented
1624 */
1627 LPCSTR lpServiceName,
1629 LPDWORD lpcchBuffer)
1630{
1631 DWORD dwError;
1633 CHAR szEmptyName[] = "";
1634
1635 TRACE("GetServiceDisplayNameA(%p %s %p %p)\n",
1636 hSCManager, debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
1637
1638 if (!hSCManager)
1639 {
1641 return FALSE;
1642 }
1643
1644 if (!lpDisplayName || *lpcchBuffer < sizeof(CHAR))
1645 {
1646 lpNameBuffer = szEmptyName;
1647 *lpcchBuffer = sizeof(CHAR);
1648 }
1649 else
1650 {
1652 }
1653
1655 {
1657 lpServiceName,
1659 lpcchBuffer);
1660 }
1662 {
1664 }
1666
1667 if (dwError != ERROR_SUCCESS)
1668 {
1669 TRACE("RGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
1670 SetLastError(dwError);
1671 return FALSE;
1672 }
1673
1674 return TRUE;
1675}
1676
1677
1678/**********************************************************************
1679 * GetServiceDisplayNameW
1680 *
1681 * @implemented
1682 */
1685 LPCWSTR lpServiceName,
1687 LPDWORD lpcchBuffer)
1688{
1689 DWORD dwError;
1691 WCHAR szEmptyName[] = L"";
1692
1693 TRACE("GetServiceDisplayNameW(%p %s %p %p)\n",
1694 hSCManager, debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
1695
1696 if (!hSCManager)
1697 {
1699 return FALSE;
1700 }
1701
1702 /*
1703 * NOTE: A size of 1 character would be enough, but tests show that
1704 * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
1705 * mismatch in their code.
1706 */
1707 if (!lpDisplayName || *lpcchBuffer < sizeof(WCHAR))
1708 {
1709 lpNameBuffer = szEmptyName;
1710 *lpcchBuffer = sizeof(WCHAR);
1711 }
1712 else
1713 {
1715 }
1716
1718 {
1720 lpServiceName,
1722 lpcchBuffer);
1723 }
1725 {
1727 }
1729
1730 if (dwError != ERROR_SUCCESS)
1731 {
1732 TRACE("RGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
1733 SetLastError(dwError);
1734 return FALSE;
1735 }
1736
1737 return TRUE;
1738}
1739
1740
1741/**********************************************************************
1742 * GetServiceKeyNameA
1743 *
1744 * @implemented
1745 */
1749 LPSTR lpServiceName,
1750 LPDWORD lpcchBuffer)
1751{
1752 DWORD dwError;
1754 CHAR szEmptyName[] = "";
1755
1756 TRACE("GetServiceKeyNameA(%p %s %p %p)\n",
1757 hSCManager, debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
1758
1759 if (!hSCManager)
1760 {
1762 return FALSE;
1763 }
1764
1765 if (!lpServiceName || *lpcchBuffer < sizeof(CHAR))
1766 {
1767 lpNameBuffer = szEmptyName;
1768 *lpcchBuffer = sizeof(CHAR);
1769 }
1770 else
1771 {
1772 lpNameBuffer = lpServiceName;
1773 }
1774
1776 {
1780 lpcchBuffer);
1781 }
1783 {
1784 /* HACK: because of a problem with rpcrt4, rpcserver is hacked to return 6 for ERROR_SERVICE_DOES_NOT_EXIST */
1786 }
1788
1789 if (dwError != ERROR_SUCCESS)
1790 {
1791 TRACE("RGetServiceKeyNameA() failed (Error %lu)\n", dwError);
1792 SetLastError(dwError);
1793 return FALSE;
1794 }
1795
1796 return TRUE;
1797}
1798
1799
1800/**********************************************************************
1801 * GetServiceKeyNameW
1802 *
1803 * @implemented
1804 */
1808 LPWSTR lpServiceName,
1809 LPDWORD lpcchBuffer)
1810{
1811 DWORD dwError;
1813 WCHAR szEmptyName[] = L"";
1814
1815 TRACE("GetServiceKeyNameW(%p %s %p %p)\n",
1816 hSCManager, debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
1817
1818 if (!hSCManager)
1819 {
1821 return FALSE;
1822 }
1823
1824 /*
1825 * NOTE: A size of 1 character would be enough, but tests show that
1826 * Windows returns 2 characters instead, certainly due to a WCHAR/bytes
1827 * mismatch in their code.
1828 */
1829 if (!lpServiceName || *lpcchBuffer < sizeof(WCHAR))
1830 {
1831 lpNameBuffer = szEmptyName;
1832 *lpcchBuffer = sizeof(WCHAR);
1833 }
1834 else
1835 {
1836 lpNameBuffer = lpServiceName;
1837 }
1838
1840 {
1844 lpcchBuffer);
1845 }
1847 {
1849 }
1851
1852 if (dwError != ERROR_SUCCESS)
1853 {
1854 TRACE("RGetServiceKeyNameW() failed (Error %lu)\n", dwError);
1855 SetLastError(dwError);
1856 return FALSE;
1857 }
1858
1859 return TRUE;
1860}
1861
1862
1863/**********************************************************************
1864 * I_ScGetCurrentGroupStateW
1865 *
1866 * @implemented
1867 */
1870 LPWSTR pszGroupName,
1871 LPDWORD pdwGroupState)
1872{
1873 DWORD dwError;
1874
1875 TRACE("I_ScGetCurrentGroupStateW(%p %s %p)\n",
1876 hSCManager, debugstr_w(pszGroupName), pdwGroupState);
1877
1879 {
1881 pszGroupName,
1882 pdwGroupState);
1883 }
1885 {
1887 }
1889
1890 if (dwError != ERROR_SUCCESS)
1891 {
1892 TRACE("RI_ScGetCurrentGroupStateW() failed (Error %lu)\n", dwError);
1893 SetLastError(dwError);
1894 }
1895
1896 return dwError;
1897}
1898
1899
1900/**********************************************************************
1901 * LockServiceDatabase
1902 *
1903 * @implemented
1904 */
1907{
1908 SC_LOCK hLock;
1909 DWORD dwError;
1910
1911 TRACE("LockServiceDatabase(%p)\n",
1912 hSCManager);
1913
1915 {
1917 (SC_RPC_LOCK *)&hLock);
1918 }
1920 {
1922 }
1924
1925 if (dwError != ERROR_SUCCESS)
1926 {
1927 TRACE("RLockServiceDatabase() failed (Error %lu)\n", dwError);
1928 SetLastError(dwError);
1929 return NULL;
1930 }
1931
1932 TRACE("hLock = %p\n", hLock);
1933
1934 return hLock;
1935}
1936
1937
1938static VOID
1940{
1941 HANDLE hEvent;
1942
1943 TRACE("WaitForSCManager()\n");
1944
1945 /* Try to open the existing event */
1947 if (hEvent == NULL)
1948 {
1950 return;
1951
1952 /* Try to create a new event */
1954 if (hEvent == NULL)
1955 return;
1956 }
1957
1958 /* Wait for 3 minutes */
1959 WaitForSingleObject(hEvent, 180000);
1961
1962 TRACE("ScmWaitForSCManager() done\n");
1963}
1964
1965
1966/**********************************************************************
1967 * OpenSCManagerA
1968 *
1969 * @implemented
1970 */
1971SC_HANDLE WINAPI
1973 LPCSTR lpDatabaseName,
1974 DWORD dwDesiredAccess)
1975{
1976 SC_HANDLE hScm = NULL;
1977 DWORD dwError;
1978
1979 TRACE("OpenSCManagerA(%s %s %lx)\n",
1980 debugstr_a(lpMachineName), debugstr_a(lpDatabaseName), dwDesiredAccess);
1981
1983
1985 {
1986 dwError = ROpenSCManagerA((LPSTR)lpMachineName,
1987 (LPSTR)lpDatabaseName,
1988 dwDesiredAccess,
1989 (SC_RPC_HANDLE *)&hScm);
1990 }
1992 {
1994 }
1996
1997 SetLastError(dwError);
1998 if (dwError != ERROR_SUCCESS)
1999 {
2000 TRACE("ROpenSCManagerA() failed (Error %lu)\n", dwError);
2001 return NULL;
2002 }
2003
2004 TRACE("hScm = %p\n", hScm);
2005
2006 return hScm;
2007}
2008
2009
2010/**********************************************************************
2011 * OpenSCManagerW
2012 *
2013 * @implemented
2014 */
2015SC_HANDLE WINAPI
2017 LPCWSTR lpDatabaseName,
2018 DWORD dwDesiredAccess)
2019{
2020 SC_HANDLE hScm = NULL;
2021 DWORD dwError;
2022
2023 TRACE("OpenSCManagerW(%s %s %lx)\n",
2024 debugstr_w(lpMachineName), debugstr_w(lpDatabaseName), dwDesiredAccess);
2025
2027
2029 {
2030 dwError = ROpenSCManagerW((LPWSTR)lpMachineName,
2031 (LPWSTR)lpDatabaseName,
2032 dwDesiredAccess,
2033 (SC_RPC_HANDLE *)&hScm);
2034 }
2036 {
2038 }
2040
2041 SetLastError(dwError);
2042 if (dwError != ERROR_SUCCESS)
2043 {
2044 TRACE("ROpenSCManagerW() failed (Error %lu)\n", dwError);
2045 return NULL;
2046 }
2047
2048 TRACE("hScm = %p\n", hScm);
2049
2050 return hScm;
2051}
2052
2053
2054/**********************************************************************
2055 * OpenServiceA
2056 *
2057 * @implemented
2058 */
2059SC_HANDLE WINAPI
2061 LPCSTR lpServiceName,
2062 DWORD dwDesiredAccess)
2063{
2064 SC_HANDLE hService = NULL;
2065 DWORD dwError;
2066
2067 TRACE("OpenServiceA(%p %s %lx)\n",
2068 hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
2069
2070 if (!hSCManager)
2071 {
2073 return NULL;
2074 }
2075
2077 {
2079 (LPSTR)lpServiceName,
2080 dwDesiredAccess,
2081 (SC_RPC_HANDLE *)&hService);
2082 }
2084 {
2086 }
2088
2089 SetLastError(dwError);
2090 if (dwError != ERROR_SUCCESS)
2091 {
2092 TRACE("ROpenServiceA() failed (Error %lu)\n", dwError);
2093 return NULL;
2094 }
2095
2096 TRACE("hService = %p\n", hService);
2097
2098 return hService;
2099}
2100
2101
2102/**********************************************************************
2103 * OpenServiceW
2104 *
2105 * @implemented
2106 */
2107SC_HANDLE WINAPI
2109 LPCWSTR lpServiceName,
2110 DWORD dwDesiredAccess)
2111{
2112 SC_HANDLE hService = NULL;
2113 DWORD dwError;
2114
2115 TRACE("OpenServiceW(%p %s %lx)\n",
2116 hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
2117
2118 if (!hSCManager)
2119 {
2121 return NULL;
2122 }
2123
2125 {
2127 (LPWSTR)lpServiceName,
2128 dwDesiredAccess,
2129 (SC_RPC_HANDLE *)&hService);
2130 }
2132 {
2134 }
2136
2137 SetLastError(dwError);
2138 if (dwError != ERROR_SUCCESS)
2139 {
2140 TRACE("ROpenServiceW() failed (Error %lu)\n", dwError);
2141 return NULL;
2142 }
2143
2144 TRACE("hService = %p\n", hService);
2145
2146 return hService;
2147}
2148
2149
2150/**********************************************************************
2151 * QueryServiceConfigA
2152 *
2153 * @implemented
2154 */
2156QueryServiceConfigA(SC_HANDLE hService,
2157 LPQUERY_SERVICE_CONFIGA lpServiceConfig,
2160{
2161 QUERY_SERVICE_CONFIGA ServiceConfig;
2162 LPQUERY_SERVICE_CONFIGA lpConfigPtr;
2163 DWORD dwBufferSize;
2164 DWORD dwError;
2165
2166 TRACE("QueryServiceConfigA(%p %p %lu %p)\n",
2167 hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
2168
2169 if (lpServiceConfig == NULL ||
2171 {
2172 lpConfigPtr = &ServiceConfig;
2173 dwBufferSize = sizeof(QUERY_SERVICE_CONFIGA);
2174 }
2175 else
2176 {
2177 lpConfigPtr = lpServiceConfig;
2178 dwBufferSize = cbBufSize;
2179 }
2180
2182 {
2183 dwError = RQueryServiceConfigA((SC_RPC_HANDLE)hService,
2184 (LPBYTE)lpConfigPtr,
2185 dwBufferSize,
2187 }
2189 {
2191 }
2193
2194 if (dwError != ERROR_SUCCESS)
2195 {
2196 TRACE("RQueryServiceConfigA() failed (Error %lu)\n", dwError);
2197 SetLastError(dwError);
2198 return FALSE;
2199 }
2200
2201 /* Adjust the pointers */
2202 if (lpConfigPtr->lpBinaryPathName)
2203 lpConfigPtr->lpBinaryPathName =
2204 (LPSTR)((ULONG_PTR)lpConfigPtr +
2205 (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
2206
2207 if (lpConfigPtr->lpLoadOrderGroup)
2208 lpConfigPtr->lpLoadOrderGroup =
2209 (LPSTR)((ULONG_PTR)lpConfigPtr +
2210 (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
2211
2212 if (lpConfigPtr->lpDependencies)
2213 lpConfigPtr->lpDependencies =
2214 (LPSTR)((ULONG_PTR)lpConfigPtr +
2215 (ULONG_PTR)lpConfigPtr->lpDependencies);
2216
2217 if (lpConfigPtr->lpServiceStartName)
2218 lpConfigPtr->lpServiceStartName =
2219 (LPSTR)((ULONG_PTR)lpConfigPtr +
2220 (ULONG_PTR)lpConfigPtr->lpServiceStartName);
2221
2222 if (lpConfigPtr->lpDisplayName)
2223 lpConfigPtr->lpDisplayName =
2224 (LPSTR)((ULONG_PTR)lpConfigPtr +
2225 (ULONG_PTR)lpConfigPtr->lpDisplayName);
2226
2227 TRACE("QueryServiceConfigA() done\n");
2228
2229 return TRUE;
2230}
2231
2232
2233/**********************************************************************
2234 * QueryServiceConfigW
2235 *
2236 * @implemented
2237 */
2239QueryServiceConfigW(SC_HANDLE hService,
2240 LPQUERY_SERVICE_CONFIGW lpServiceConfig,
2243{
2244 QUERY_SERVICE_CONFIGW ServiceConfig;
2245 LPQUERY_SERVICE_CONFIGW lpConfigPtr;
2246 DWORD dwBufferSize;
2247 DWORD dwError;
2248
2249 TRACE("QueryServiceConfigW(%p %p %lu %p)\n",
2250 hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
2251
2252 if (lpServiceConfig == NULL ||
2254 {
2255 lpConfigPtr = &ServiceConfig;
2256 dwBufferSize = sizeof(QUERY_SERVICE_CONFIGW);
2257 }
2258 else
2259 {
2260 lpConfigPtr = lpServiceConfig;
2261 dwBufferSize = cbBufSize;
2262 }
2263
2265 {
2266 dwError = RQueryServiceConfigW((SC_RPC_HANDLE)hService,
2267 (LPBYTE)lpConfigPtr,
2268 dwBufferSize,
2270 }
2272 {
2274 }
2276
2277 if (dwError != ERROR_SUCCESS)
2278 {
2279 TRACE("RQueryServiceConfigW() failed (Error %lu)\n", dwError);
2280 SetLastError(dwError);
2281 return FALSE;
2282 }
2283
2284 /* Adjust the pointers */
2285 if (lpConfigPtr->lpBinaryPathName)
2286 lpConfigPtr->lpBinaryPathName =
2287 (LPWSTR)((ULONG_PTR)lpConfigPtr +
2288 (ULONG_PTR)lpConfigPtr->lpBinaryPathName);
2289
2290 if (lpConfigPtr->lpLoadOrderGroup)
2291 lpConfigPtr->lpLoadOrderGroup =
2292 (LPWSTR)((ULONG_PTR)lpConfigPtr +
2293 (ULONG_PTR)lpConfigPtr->lpLoadOrderGroup);
2294
2295 if (lpConfigPtr->lpDependencies)
2296 lpConfigPtr->lpDependencies =
2297 (LPWSTR)((ULONG_PTR)lpConfigPtr +
2298 (ULONG_PTR)lpConfigPtr->lpDependencies);
2299
2300 if (lpConfigPtr->lpServiceStartName)
2301 lpConfigPtr->lpServiceStartName =
2302 (LPWSTR)((ULONG_PTR)lpConfigPtr +
2303 (ULONG_PTR)lpConfigPtr->lpServiceStartName);
2304
2305 if (lpConfigPtr->lpDisplayName)
2306 lpConfigPtr->lpDisplayName =
2307 (LPWSTR)((ULONG_PTR)lpConfigPtr +
2308 (ULONG_PTR)lpConfigPtr->lpDisplayName);
2309
2310 TRACE("QueryServiceConfigW() done\n");
2311
2312 return TRUE;
2313}
2314
2315
2316/**********************************************************************
2317 * QueryServiceConfig2A
2318 *
2319 * @implemented
2320 */
2322QueryServiceConfig2A(SC_HANDLE hService,
2327{
2328 SERVICE_DESCRIPTIONA ServiceDescription;
2329 SERVICE_FAILURE_ACTIONSA ServiceFailureActions;
2330 LPBYTE lpTempBuffer;
2331 BOOL bUseTempBuffer = FALSE;
2332 DWORD dwBufferSize;
2333 DWORD dwError;
2334
2335 TRACE("QueryServiceConfig2A(%p %lu %p %lu %p)\n",
2337
2338 lpTempBuffer = lpBuffer;
2339 dwBufferSize = cbBufSize;
2340
2341 switch (dwInfoLevel)
2342 {
2344 if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONA)))
2345 {
2346 lpTempBuffer = (LPBYTE)&ServiceDescription;
2347 dwBufferSize = sizeof(SERVICE_DESCRIPTIONA);
2348 bUseTempBuffer = TRUE;
2349 }
2350 break;
2351
2353 if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSA)))
2354 {
2355 lpTempBuffer = (LPBYTE)&ServiceFailureActions;
2356 dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSA);
2357 bUseTempBuffer = TRUE;
2358 }
2359 break;
2360
2361 default:
2362 WARN("Unknown info level 0x%lx\n", dwInfoLevel);
2364 return FALSE;
2365 }
2366
2368 {
2369 dwError = RQueryServiceConfig2A((SC_RPC_HANDLE)hService,
2371 lpTempBuffer,
2372 dwBufferSize,
2374 }
2376 {
2378 }
2380
2381 if (dwError != ERROR_SUCCESS)
2382 {
2383 TRACE("RQueryServiceConfig2A() failed (Error %lu)\n", dwError);
2384 SetLastError(dwError);
2385 return FALSE;
2386 }
2387
2388 if (bUseTempBuffer != FALSE)
2389 {
2390 TRACE("RQueryServiceConfig2A() returns ERROR_INSUFFICIENT_BUFFER\n");
2391 *pcbBytesNeeded = dwBufferSize;
2393 return FALSE;
2394 }
2395
2396 switch (dwInfoLevel)
2397 {
2399 {
2400 LPSERVICE_DESCRIPTIONA lpPtr = (LPSERVICE_DESCRIPTIONA)lpTempBuffer;
2401
2402 if (lpPtr->lpDescription != NULL)
2403 lpPtr->lpDescription =
2404 (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
2405 }
2406 break;
2407
2409 {
2411
2412 if (lpPtr->lpRebootMsg != NULL)
2413 lpPtr->lpRebootMsg =
2414 (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
2415
2416 if (lpPtr->lpCommand != NULL)
2417 lpPtr->lpCommand =
2418 (LPSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
2419
2420 if (lpPtr->lpsaActions != NULL)
2421 lpPtr->lpsaActions =
2422 (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
2423 }
2424 break;
2425 }
2426
2427 TRACE("QueryServiceConfig2A() done\n");
2428
2429 return TRUE;
2430}
2431
2432
2433/**********************************************************************
2434 * QueryServiceConfig2W
2435 *
2436 * @implemented
2437 */
2439QueryServiceConfig2W(SC_HANDLE hService,
2444{
2445 SERVICE_DESCRIPTIONW ServiceDescription;
2446 SERVICE_FAILURE_ACTIONSW ServiceFailureActions;
2447 LPBYTE lpTempBuffer;
2448 BOOL bUseTempBuffer = FALSE;
2449 DWORD dwBufferSize;
2450 DWORD dwError;
2451
2452 TRACE("QueryServiceConfig2W(%p %lu %p %lu %p)\n",
2454
2455 lpTempBuffer = lpBuffer;
2456 dwBufferSize = cbBufSize;
2457
2458 switch (dwInfoLevel)
2459 {
2461 if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_DESCRIPTIONW)))
2462 {
2463 lpTempBuffer = (LPBYTE)&ServiceDescription;
2464 dwBufferSize = sizeof(SERVICE_DESCRIPTIONW);
2465 bUseTempBuffer = TRUE;
2466 }
2467 break;
2468
2470 if ((lpBuffer == NULL) || (cbBufSize < sizeof(SERVICE_FAILURE_ACTIONSW)))
2471 {
2472 lpTempBuffer = (LPBYTE)&ServiceFailureActions;
2473 dwBufferSize = sizeof(SERVICE_FAILURE_ACTIONSW);
2474 bUseTempBuffer = TRUE;
2475 }
2476 break;
2477
2478 default:
2479 WARN("Unknown info level 0x%lx\n", dwInfoLevel);
2481 return FALSE;
2482 }
2483
2485 {
2486 dwError = RQueryServiceConfig2W((SC_RPC_HANDLE)hService,
2488 lpTempBuffer,
2489 dwBufferSize,
2491 }
2493 {
2495 }
2497
2498 if (dwError != ERROR_SUCCESS)
2499 {
2500 TRACE("RQueryServiceConfig2W() failed (Error %lu)\n", dwError);
2501 SetLastError(dwError);
2502 return FALSE;
2503 }
2504
2505 if (bUseTempBuffer != FALSE)
2506 {
2507 TRACE("RQueryServiceConfig2W() returns ERROR_INSUFFICIENT_BUFFER\n");
2508 *pcbBytesNeeded = dwBufferSize;
2510 return FALSE;
2511 }
2512
2513 switch (dwInfoLevel)
2514 {
2516 {
2517 LPSERVICE_DESCRIPTIONW lpPtr = (LPSERVICE_DESCRIPTIONW)lpTempBuffer;
2518
2519 if (lpPtr->lpDescription != NULL)
2520 lpPtr->lpDescription =
2521 (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpDescription);
2522 }
2523 break;
2524
2526 {
2528
2529 if (lpPtr->lpRebootMsg != NULL)
2530 lpPtr->lpRebootMsg =
2531 (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpRebootMsg);
2532
2533 if (lpPtr->lpCommand != NULL)
2534 lpPtr->lpCommand =
2535 (LPWSTR)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpCommand);
2536
2537 if (lpPtr->lpsaActions != NULL)
2538 lpPtr->lpsaActions =
2539 (LPSC_ACTION)((ULONG_PTR)lpPtr + (ULONG_PTR)lpPtr->lpsaActions);
2540 }
2541 break;
2542 }
2543
2544 TRACE("QueryServiceConfig2W() done\n");
2545
2546 return TRUE;
2547}
2548
2549
2550/**********************************************************************
2551 * QueryServiceLockStatusA
2552 *
2553 * @implemented
2554 */
2557 LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
2560{
2561 QUERY_SERVICE_LOCK_STATUSA LockStatus;
2562 LPQUERY_SERVICE_LOCK_STATUSA lpStatusPtr;
2563 DWORD dwBufferSize;
2564 DWORD dwError;
2565
2566 TRACE("QueryServiceLockStatusA(%p %p %lu %p)\n",
2567 hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2568
2569 if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSA))
2570 {
2571 lpStatusPtr = &LockStatus;
2572 dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSA);
2573 }
2574 else
2575 {
2576 lpStatusPtr = lpLockStatus;
2577 dwBufferSize = cbBufSize;
2578 }
2579
2581 {
2583 (LPBYTE)lpStatusPtr,
2584 dwBufferSize,
2586 }
2588 {
2590 }
2592
2593 if (dwError != ERROR_SUCCESS)
2594 {
2595 TRACE("RQueryServiceLockStatusA() failed (Error %lu)\n", dwError);
2596 SetLastError(dwError);
2597 return FALSE;
2598 }
2599
2600 if (lpStatusPtr->lpLockOwner != NULL)
2601 {
2602 lpStatusPtr->lpLockOwner =
2603 (LPSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
2604 }
2605
2606 TRACE("QueryServiceLockStatusA() done\n");
2607
2608 return TRUE;
2609}
2610
2611
2612/**********************************************************************
2613 * QueryServiceLockStatusW
2614 *
2615 * @implemented
2616 */
2619 LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
2622{
2623 QUERY_SERVICE_LOCK_STATUSW LockStatus;
2624 LPQUERY_SERVICE_LOCK_STATUSW lpStatusPtr;
2625 DWORD dwBufferSize;
2626 DWORD dwError;
2627
2628 TRACE("QueryServiceLockStatusW(%p %p %lu %p)\n",
2629 hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
2630
2631 if (lpLockStatus == NULL || cbBufSize < sizeof(QUERY_SERVICE_LOCK_STATUSW))
2632 {
2633 lpStatusPtr = &LockStatus;
2634 dwBufferSize = sizeof(QUERY_SERVICE_LOCK_STATUSW);
2635 }
2636 else
2637 {
2638 lpStatusPtr = lpLockStatus;
2639 dwBufferSize = cbBufSize;
2640 }
2641
2643 {
2645 (LPBYTE)lpStatusPtr,
2646 dwBufferSize,
2648 }
2650 {
2652 }
2654
2655 if (dwError != ERROR_SUCCESS)
2656 {
2657 TRACE("RQueryServiceLockStatusW() failed (Error %lu)\n", dwError);
2658 SetLastError(dwError);
2659 return FALSE;
2660 }
2661
2662 if (lpStatusPtr->lpLockOwner != NULL)
2663 {
2664 lpStatusPtr->lpLockOwner =
2665 (LPWSTR)((ULONG_PTR)lpStatusPtr + (ULONG_PTR)lpStatusPtr->lpLockOwner);
2666 }
2667
2668 TRACE("QueryServiceLockStatusW() done\n");
2669
2670 return TRUE;
2671}
2672
2673
2674/**********************************************************************
2675 * QueryServiceObjectSecurity
2676 *
2677 * @implemented
2678 */
2681 SECURITY_INFORMATION dwSecurityInformation,
2682 PSECURITY_DESCRIPTOR lpSecurityDescriptor,
2685{
2686 DWORD dwError;
2687
2688 TRACE("QueryServiceObjectSecurity(%p %lu %p)\n",
2689 hService, dwSecurityInformation, lpSecurityDescriptor);
2690
2692 {
2693 dwError = RQueryServiceObjectSecurity((SC_RPC_HANDLE)hService,
2694 dwSecurityInformation,
2695 (LPBYTE)lpSecurityDescriptor,
2696 cbBufSize,
2698 }
2700 {
2702 }
2704
2705 if (dwError != ERROR_SUCCESS)
2706 {
2707 TRACE("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
2708 SetLastError(dwError);
2709 return FALSE;
2710 }
2711
2712 return TRUE;
2713}
2714
2715
2716/**********************************************************************
2717 * SetServiceObjectSecurity
2718 *
2719 * @implemented
2720 */
2722SetServiceObjectSecurity(SC_HANDLE hService,
2723 SECURITY_INFORMATION dwSecurityInformation,
2724 PSECURITY_DESCRIPTOR lpSecurityDescriptor)
2725{
2726 PSECURITY_DESCRIPTOR SelfRelativeSD = NULL;
2727 ULONG Length;
2729 DWORD dwError;
2730
2731 TRACE("SetServiceObjectSecurity(%p %lu %p)\n",
2732 hService, dwSecurityInformation, lpSecurityDescriptor);
2733
2734 Length = 0;
2735 Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
2736 SelfRelativeSD,
2737 &Length);
2739 {
2741 return FALSE;
2742 }
2743
2744 SelfRelativeSD = HeapAlloc(GetProcessHeap(), 0, Length);
2745 if (SelfRelativeSD == NULL)
2746 {
2748 return FALSE;
2749 }
2750
2751 Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
2752 SelfRelativeSD,
2753 &Length);
2754 if (!NT_SUCCESS(Status))
2755 {
2756 HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
2758 return FALSE;
2759 }
2760
2762 {
2763 dwError = RSetServiceObjectSecurity((SC_RPC_HANDLE)hService,
2764 dwSecurityInformation,
2765 (LPBYTE)SelfRelativeSD,
2766 Length);
2767 }
2769 {
2771 }
2773
2774 HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
2775
2776 if (dwError != ERROR_SUCCESS)
2777 {
2778 TRACE("RServiceObjectSecurity() failed (Error %lu)\n", dwError);
2779 SetLastError(dwError);
2780 return FALSE;
2781 }
2782
2783 return TRUE;
2784}
2785
2786
2787/**********************************************************************
2788 * QueryServiceStatus
2789 *
2790 * @implemented
2791 */
2793QueryServiceStatus(SC_HANDLE hService,
2794 LPSERVICE_STATUS lpServiceStatus)
2795{
2796 DWORD dwError;
2797
2798 TRACE("QueryServiceStatus(%p %p)\n",
2799 hService, lpServiceStatus);
2800
2801 if (!hService)
2802 {
2804 return FALSE;
2805 }
2806
2808 {
2809 dwError = RQueryServiceStatus((SC_RPC_HANDLE)hService,
2810 lpServiceStatus);
2811 }
2813 {
2815 }
2817
2818 if (dwError != ERROR_SUCCESS)
2819 {
2820 TRACE("RQueryServiceStatus() failed (Error %lu)\n", dwError);
2821 SetLastError(dwError);
2822 return FALSE;
2823 }
2824
2825 return TRUE;
2826}
2827
2828
2829/**********************************************************************
2830 * QueryServiceStatusEx
2831 *
2832 * @implemented
2833 */
2835QueryServiceStatusEx(SC_HANDLE hService,
2836 SC_STATUS_TYPE InfoLevel,
2840{
2841 DWORD dwError;
2842
2843 TRACE("QueryServiceStatusEx(%p %lu %p %lu %p)\n",
2844 hService, InfoLevel, lpBuffer, cbBufSize, pcbBytesNeeded);
2845
2846 if (InfoLevel != SC_STATUS_PROCESS_INFO)
2847 {
2849 return FALSE;
2850 }
2851
2852 if (cbBufSize < sizeof(SERVICE_STATUS_PROCESS))
2853 {
2856 return FALSE;
2857 }
2858
2860 {
2861 dwError = RQueryServiceStatusEx((SC_RPC_HANDLE)hService,
2862 InfoLevel,
2863 lpBuffer,
2864 cbBufSize,
2866 }
2868 {
2870 }
2872
2873 if (dwError != ERROR_SUCCESS)
2874 {
2875 TRACE("RQueryServiceStatusEx() failed (Error %lu)\n", dwError);
2876 SetLastError(dwError);
2877 return FALSE;
2878 }
2879
2880 return TRUE;
2881}
2882
2883
2884/**********************************************************************
2885 * StartServiceA
2886 *
2887 * @implemented
2888 */
2890StartServiceA(SC_HANDLE hService,
2891 DWORD dwNumServiceArgs,
2892 LPCSTR *lpServiceArgVectors)
2893{
2894 DWORD dwError;
2895
2896 TRACE("StartServiceA(%p %lu %p)\n",
2897 hService, dwNumServiceArgs, lpServiceArgVectors);
2898
2900 {
2901 dwError = RStartServiceA((SC_RPC_HANDLE)hService,
2902 dwNumServiceArgs,
2903 (LPSTRING_PTRSA)lpServiceArgVectors);
2904 }
2906 {
2908 }
2910
2911 if (dwError != ERROR_SUCCESS)
2912 {
2913 ERR("RStartServiceA() failed (Error %lu)\n", dwError);
2914 SetLastError(dwError);
2915 return FALSE;
2916 }
2917
2918 return TRUE;
2919}
2920
2921
2922/**********************************************************************
2923 * StartServiceW
2924 *
2925 * @implemented
2926 */
2928StartServiceW(SC_HANDLE hService,
2929 DWORD dwNumServiceArgs,
2930 LPCWSTR *lpServiceArgVectors)
2931{
2932 DWORD dwError;
2933
2934 TRACE("StartServiceW(%p %lu %p)\n",
2935 hService, dwNumServiceArgs, lpServiceArgVectors);
2936
2938 {
2939 dwError = RStartServiceW((SC_RPC_HANDLE)hService,
2940 dwNumServiceArgs,
2941 (LPSTRING_PTRSW)lpServiceArgVectors);
2942 }
2944 {
2946 }
2948
2949 if (dwError != ERROR_SUCCESS)
2950 {
2951 ERR("RStartServiceW() failed (Error %lu)\n", dwError);
2952 SetLastError(dwError);
2953 return FALSE;
2954 }
2955
2956 return TRUE;
2957}
2958
2959
2960/**********************************************************************
2961 * UnlockServiceDatabase
2962 *
2963 * @implemented
2964 */
2967{
2968 DWORD dwError;
2969
2970 TRACE("UnlockServiceDatabase(%x)\n",
2971 ScLock);
2972
2974 {
2975 dwError = RUnlockServiceDatabase((LPSC_RPC_LOCK)&ScLock);
2976 }
2978 {
2980 }
2982
2983 if (dwError == ERROR_INVALID_HANDLE)
2985
2986 if (dwError != ERROR_SUCCESS)
2987 {
2988 TRACE("RUnlockServiceDatabase() failed (Error %lu)\n", dwError);
2989 SetLastError(dwError);
2990 return FALSE;
2991 }
2992
2993 return TRUE;
2994}
2995
2996
2997/**********************************************************************
2998 * NotifyBootConfigStatus
2999 *
3000 * @implemented
3001 */
3004{
3005 DWORD dwError;
3006
3007 TRACE("NotifyBootConfigStatus(%u)\n",
3008 BootAcceptable);
3009
3011 {
3012 dwError = RNotifyBootConfigStatus(NULL,
3013 BootAcceptable);
3014 }
3016 {
3018 }
3020
3021 if (dwError != ERROR_SUCCESS)
3022 {
3023 TRACE("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
3024 SetLastError(dwError);
3025 return FALSE;
3026 }
3027
3028 return TRUE;
3029}
3030
3031DWORD
3034 PTAG_INFO_NAME_FROM_TAG InOutParams)
3035{
3036 SC_HANDLE hScm;
3037 DWORD dwError;
3040 LPWSTR lpszName;
3041
3042 /* We only support one class */
3044 {
3045 return ERROR_RETRY;
3046 }
3047
3048 /* Validate input structure */
3049 if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
3050 {
3052 }
3053
3054 /* Validate output structure */
3055 if (InOutParams->OutParams.pszName != NULL)
3056 {
3058 }
3059
3060 /* Open service manager */
3062 if (hScm == NULL)
3063 {
3064 return GetLastError();
3065 }
3066
3067 /* Setup call parameters */
3068 InParams = &InOutParams->InParams;
3069 OutParams = NULL;
3070
3071 /* Call SCM to query tag information */
3073 {
3074 dwError = RI_ScQueryServiceTagInfo(hScm, TagInfoLevelNameFromTag, &InParams, &OutParams);
3075 }
3077 {
3079 }
3081
3082 /* Quit if not a success */
3083 if (dwError != ERROR_SUCCESS)
3084 {
3085 goto Cleanup;
3086 }
3087
3088 /* OutParams must be set now and we must have a name */
3089 if (OutParams == NULL ||
3090 OutParams->pszName == NULL)
3091 {
3092 dwError = ERROR_INVALID_DATA;
3093 goto Cleanup;
3094 }
3095
3096 /* Copy back what SCM returned */
3097 lpszName = LocalAlloc(LPTR,
3098 sizeof(WCHAR) * wcslen(OutParams->pszName) + sizeof(UNICODE_NULL));
3099 if (lpszName == NULL)
3100 {
3101 dwError = GetLastError();
3102 goto Cleanup;
3103 }
3104
3105 wcscpy(lpszName, OutParams->pszName);
3106 InOutParams->OutParams.pszName = lpszName;
3107 InOutParams->OutParams.TagType = OutParams->TagType;
3108
3109Cleanup:
3110 CloseServiceHandle(hScm);
3111
3112 /* Free memory allocated by SCM */
3113 if (OutParams != NULL)
3114 {
3115 if (OutParams->pszName != NULL)
3116 {
3117 midl_user_free(OutParams->pszName);
3118 }
3119
3120 midl_user_free(OutParams);
3121 }
3122
3123 return dwError;
3124}
3125
3126/**********************************************************************
3127 * I_QueryTagInformation
3128 *
3129 * @implemented
3130 */
3134 PTAG_INFO_NAME_FROM_TAG InOutParams)
3135{
3136 /*
3137 * We only support one information class and it
3138 * needs parameters
3139 */
3141 InOutParams == NULL)
3142 {
3144 }
3145
3146 /* Validate input structure */
3147 if (InOutParams->InParams.dwPid == 0 || InOutParams->InParams.dwTag == 0)
3148 {
3150 }
3151
3152 /* Validate output structure */
3153 if (InOutParams->OutParams.pszName != NULL)
3154 {
3156 }
3157
3158 /* Call internal function for the RPC call */
3160}
3161
3162/* EOF */
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
LONG NTSTATUS
Definition: precomp.h:26
static SERVICE_STATUS ServiceStatus
Definition: browser.c:22
#define CHAR(Char)
DWORD WINAPI RCloseServiceHandle(LPSC_RPC_HANDLE hSCObject)
Definition: rpcserver.c:936
DWORD WINAPI RChangeServiceConfig2W(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOW Info)
Definition: rpcserver.c:5420
DWORD WINAPI RDeleteService(SC_RPC_HANDLE hService)
Definition: rpcserver.c:1304
DWORD WINAPI RQueryServiceLockStatusW(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
Definition: rpcserver.c:3211
DWORD WINAPI RQueryServiceObjectSecurity(SC_RPC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded)
Definition: rpcserver.c:1390
DWORD WINAPI RChangeServiceConfig2A(SC_RPC_HANDLE hService, SC_RPC_CONFIG_INFOA Info)
Definition: rpcserver.c:5019
DWORD WINAPI ROpenSCManagerW(LPWSTR lpMachineName, LPWSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
Definition: rpcserver.c:2868
DWORD WINAPI RNotifyBootConfigStatus(SVCCTL_HANDLEW lpMachineName, DWORD BootAcceptable)
Definition: rpcserver.c:1849
DWORD WINAPI RStartServiceW(SC_RPC_HANDLE hService, DWORD argc, LPSTRING_PTRSW argv)
Definition: rpcserver.c:3254
DWORD WINAPI RGetServiceKeyNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPBOUNDED_DWORD_4K lpcchBuffer)
Definition: rpcserver.c:4582
DWORD WINAPI RCreateServiceW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPCWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:2272
DWORD WINAPI RUnlockServiceDatabase(LPSC_RPC_LOCK Lock)
Definition: rpcserver.c:1838
DWORD WINAPI ROpenServiceW(SC_RPC_HANDLE hSCManager, LPWSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:2920
DWORD WINAPI RChangeServiceConfigW(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPWSTR lpBinaryPathName, LPWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPWSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPWSTR lpDisplayName)
Definition: rpcserver.c:1920
DWORD WINAPI REnumServicesStatusA(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:3899
DWORD WINAPI RLockServiceDatabase(SC_RPC_HANDLE hSCManager, LPSC_RPC_LOCK lpLock)
Definition: rpcserver.c:1362
DWORD WINAPI RQueryServiceConfig2A(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:5552
DWORD WINAPI RQueryServiceStatus(SC_RPC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
Definition: rpcserver.c:1608
DWORD WINAPI ROpenServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:4044
DWORD WINAPI RStartServiceA(SC_RPC_HANDLE hService, DWORD argc, LPSTRING_PTRSA argv)
Definition: rpcserver.c:4358
DWORD WINAPI RGetServiceDisplayNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, DWORD *lpcchBuffer)
Definition: rpcserver.c:3317
DWORD WINAPI RQueryServiceLockStatusA(SC_RPC_HANDLE hSCManager, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_4K pcbBytesNeeded)
Definition: rpcserver.c:4315
DWORD WINAPI RGetServiceKeyNameW(SC_RPC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, DWORD *lpcchBuffer)
Definition: rpcserver.c:3380
DWORD WINAPI RControlService(SC_RPC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
Definition: rpcserver.c:1069
DWORD WINAPI RCreateServiceA(SC_RPC_HANDLE hSCManager, LPSTR lpServiceName, LPSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSC_RPC_HANDLE lpServiceHandle)
Definition: rpcserver.c:3592
DWORD WINAPI REnumServiceGroupW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
Definition: rpcserver.c:4753
DWORD WINAPI RQueryServiceStatusEx(SC_RPC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:6023
DWORD WINAPI RI_ScQueryServiceTagInfo(SC_RPC_HANDLE hSCManager, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG_IN_PARAMS *lpInParams, PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS *lpOutParams)
Definition: rpcserver.c:6593
DWORD WINAPI RQueryServiceConfigW(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:3003
DWORD WINAPI RQueryServiceConfig2W(SC_RPC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:5799
DWORD WINAPI REnumServicesStatusExA(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCSTR pszGroupName)
Definition: rpcserver.c:6096
DWORD WINAPI REnumDependentServicesW(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
Definition: rpcserver.c:2707
DWORD WINAPI RGetServiceDisplayNameA(SC_RPC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPBOUNDED_DWORD_4K lpcchBuffer)
Definition: rpcserver.c:4460
DWORD WINAPI RI_ScGetCurrentGroupStateW(SC_RPC_HANDLE hSCManager, LPWSTR lpLoadOrderGroup, LPDWORD lpState)
Definition: rpcserver.c:4696
DWORD WINAPI ROpenSCManagerA(LPSTR lpMachineName, LPSTR lpDatabaseName, DWORD dwDesiredAccess, LPSC_RPC_HANDLE lpScHandle)
Definition: rpcserver.c:4006
DWORD WINAPI RSetServiceObjectSecurity(SC_RPC_HANDLE hService, DWORD dwSecurityInformation, LPBYTE lpSecurityDescriptor, DWORD dwSecurityDescriptorSize)
Definition: rpcserver.c:1474
DWORD WINAPI RChangeServiceConfigA(SC_RPC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPSTR lpBinaryPathName, LPSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPBYTE lpDependencies, DWORD dwDependSize, LPSTR lpServiceStartName, LPBYTE lpPassword, DWORD dwPwSize, LPSTR lpDisplayName)
Definition: rpcserver.c:3461
DWORD WINAPI RQueryServiceConfigA(SC_RPC_HANDLE hService, LPBYTE lpBuf, DWORD cbBufSize, LPBOUNDED_DWORD_8K pcbBytesNeeded)
Definition: rpcserver.c:4074
DWORD WINAPI REnumDependentServicesA(SC_RPC_HANDLE hService, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned)
Definition: rpcserver.c:3745
DWORD WINAPI REnumServicesStatusExW(SC_RPC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD cbBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeIndex, LPCWSTR pszGroupName)
Definition: rpcserver.c:6235
DWORD WINAPI REnumServicesStatusW(SC_RPC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpBuffer, DWORD dwBufSize, LPBOUNDED_DWORD_256K pcbBytesNeeded, LPBOUNDED_DWORD_256K lpServicesReturned, LPBOUNDED_DWORD_256K lpResumeHandle)
Definition: rpcserver.c:2842
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
handle_t hBinding
Definition: ctx_c.c:54
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_INVALID_ADDRESS
Definition: compat.h:106
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:109
#define SetLastError(x)
Definition: compat.h:752
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define MultiByteToWideChar
Definition: compat.h:110
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
static const WCHAR Cleanup[]
Definition: register.c:80
#define ULONG_PTR
Definition: config.h:101
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
Status
Definition: gdiplustypes.h:25
GLuint in
Definition: glext.h:9616
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
#define Unused(x)
Definition: atlwin.h:28
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static HANDLE hEvent
Definition: comm.c:54
DWORD SECURITY_INFORMATION
Definition: ms-dtyp.idl:311
#define _Out_
Definition: ms_sal.h:345
#define _In_
Definition: ms_sal.h:308
NTSYSAPI NTSTATUS NTAPI RtlMakeSelfRelativeSD(_In_ PSECURITY_DESCRIPTOR AbsoluteSD, _Out_ PSECURITY_DESCRIPTOR SelfRelativeSD, _Inout_ PULONG BufferLength)
#define SYNCHRONIZE
Definition: nt_native.h:61
#define DWORD
Definition: nt_native.h:44
#define UNICODE_NULL
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
#define L(x)
Definition: ntvdm.h:50
BYTE * PBYTE
Definition: pedump.c:66
DWORD * PDWORD
Definition: pedump.c:68
PVOID pBuffer
static FILE * out
Definition: regtests2xml.c:44
RPC_STATUS WINAPI RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:880
RPC_STATUS WINAPI RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr, RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR *StringBinding)
Definition: rpc_binding.c:510
RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:787
RPC_STATUS WINAPI RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr, RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR *StringBinding)
Definition: rpc_binding.c:457
RPC_STATUS WINAPI RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE *Binding)
Definition: rpc_binding.c:840
unsigned short * RPC_WSTR
Definition: rpcdce.h:46
unsigned char * RPC_CSTR
Definition: rpcdce.h:45
#define RPC_S_OK
Definition: rpcnterr.h:22
RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR *String)
Definition: rpcrt4_main.c:175
RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR *String)
Definition: rpcrt4_main.c:158
SC_HANDLE hSCManager
Definition: sc.c:12
NTSTATUS WINAPI SystemFunction028(IN PVOID ContextHandle, OUT LPBYTE SessionKey)
BOOL WINAPI QueryServiceStatus(SC_HANDLE hService, LPSERVICE_STATUS lpServiceStatus)
Definition: scm.c:2793
BOOL WINAPI NotifyBootConfigStatus(BOOL BootAcceptable)
Definition: scm.c:3003
BOOL WINAPI EnumServicesStatusExA(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCSTR pszGroupName)
Definition: scm.c:1410
BOOL WINAPI DeleteService(SC_HANDLE hService)
Definition: scm.c:921
DWORD ScmRpcStatusToWinError(RPC_STATUS Status)
Definition: scm.c:146
void __RPC_USER SVCCTL_HANDLEW_unbind(SVCCTL_HANDLEW szMachineName, handle_t hBinding)
Definition: scm.c:129
handle_t __RPC_USER SVCCTL_HANDLEW_bind(SVCCTL_HANDLEW szMachineName)
Definition: scm.c:89
BOOL WINAPI StartServiceA(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCSTR *lpServiceArgVectors)
Definition: scm.c:2890
SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:2016
BOOL WINAPI ControlService(SC_HANDLE hService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
Definition: scm.c:622
handle_t __RPC_USER SVCCTL_HANDLEA_bind(SVCCTL_HANDLEA szMachineName)
Definition: scm.c:32
BOOL WINAPI UnlockServiceDatabase(SC_LOCK ScLock)
Definition: scm.c:2966
void __RPC_USER SVCCTL_HANDLEA_unbind(SVCCTL_HANDLEA szMachineName, handle_t hBinding)
Definition: scm.c:72
DWORD WINAPI I_ScGetCurrentGroupStateW(SC_HANDLE hSCManager, LPWSTR pszGroupName, LPDWORD pdwGroupState)
Definition: scm.c:1869
BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2835
SC_HANDLE WINAPI OpenServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2060
SC_HANDLE WINAPI OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2108
BOOL WINAPI QueryServiceConfigW(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGW lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2239
BOOL WINAPI QueryServiceLockStatusA(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2556
BOOL WINAPI GetServiceDisplayNameW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
Definition: scm.c:1684
BOOL WINAPI ChangeServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
Definition: scm.c:247
BOOL WINAPI QueryServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2322
BOOL WINAPI GetServiceKeyNameA(SC_HANDLE hSCManager, LPCSTR lpDisplayName, LPSTR lpServiceName, LPDWORD lpcchBuffer)
Definition: scm.c:1747
BOOL WINAPI EnumServiceGroupW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR lpGroup)
Definition: scm.c:1111
BOOL WINAPI EnumDependentServicesA(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
Definition: scm.c:955
BOOL WINAPI GetServiceDisplayNameA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPSTR lpDisplayName, LPDWORD lpcchBuffer)
Definition: scm.c:1626
BOOL WINAPI ChangeServiceConfigW(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
Definition: scm.c:482
SC_HANDLE WINAPI CreateServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword)
Definition: scm.c:812
static DWORD ScmEncryptPassword(_In_ PVOID ContextHandle, _In_ PCWSTR pClearTextPassword, _Out_ PBYTE *pEncryptedPassword, _Out_ PDWORD pEncryptedPasswordSize)
Definition: scm.c:173
BOOL WINAPI ControlServiceEx(IN SC_HANDLE hService, IN DWORD dwControl, IN DWORD dwInfoLevel, IN OUT PVOID pControlParams)
Definition: scm.c:662
static VOID WaitForSCManager(VOID)
Definition: scm.c:1939
BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2680
BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService, SECURITY_INFORMATION dwSecurityInformation, PSECURITY_DESCRIPTOR lpSecurityDescriptor)
Definition: scm.c:2722
BOOL WINAPI QueryServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2439
DWORD I_ScQueryServiceTagInfo(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
Definition: scm.c:3032
NTSTATUS WINAPI SystemFunction004(const struct ustring *in, const struct ustring *key, struct ustring *out)
Definition: sysfunc.c:119
BOOL WINAPI QueryServiceLockStatusW(SC_HANDLE hSCManager, LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2618
BOOL WINAPI QueryServiceConfigA(SC_HANDLE hService, LPQUERY_SERVICE_CONFIGA lpServiceConfig, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2156
BOOL WINAPI ChangeServiceConfigA(SC_HANDLE hService, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
Definition: scm.c:363
BOOL WINAPI EnumServicesStatusExW(SC_HANDLE hSCManager, SC_ENUM_TYPE InfoLevel, DWORD dwServiceType, DWORD dwServiceState, LPBYTE lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle, LPCWSTR pszGroupName)
Definition: scm.c:1518
BOOL WINAPI StartServiceW(SC_HANDLE hService, DWORD dwNumServiceArgs, LPCWSTR *lpServiceArgVectors)
Definition: scm.c:2928
BOOL WINAPI EnumServicesStatusA(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
Definition: scm.c:1222
SC_HANDLE WINAPI CreateServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword)
Definition: scm.c:680
DWORD WINAPI I_QueryTagInformation(PVOID Unused, TAG_INFO_LEVEL dwInfoLevel, PTAG_INFO_NAME_FROM_TAG InOutParams)
Definition: scm.c:3132
BOOL WINAPI ChangeServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPVOID lpInfo)
Definition: scm.c:305
SC_LOCK WINAPI LockServiceDatabase(SC_HANDLE hSCManager)
Definition: scm.c:1906
SC_HANDLE WINAPI OpenSCManagerA(LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:1972
BOOL WINAPI CloseServiceHandle(SC_HANDLE hSCObject)
Definition: scm.c:580
BOOL WINAPI GetServiceKeyNameW(SC_HANDLE hSCManager, LPCWSTR lpDisplayName, LPWSTR lpServiceName, LPDWORD lpcchBuffer)
Definition: scm.c:1806
BOOL WINAPI EnumServicesStatusW(SC_HANDLE hSCManager, DWORD dwServiceType, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned, LPDWORD lpResumeHandle)
Definition: scm.c:1316
BOOL WINAPI EnumDependentServicesW(SC_HANDLE hService, DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices, DWORD cbBufSize, LPDWORD pcbBytesNeeded, LPDWORD lpServicesReturned)
Definition: scm.c:1033
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define RpcEndExcept
Definition: rpc.h:128
#define midl_user_free
Definition: rpc.h:45
#define RpcTryExcept
Definition: rpc.h:126
#define RpcExcept(expr)
Definition: rpc.h:127
long RPC_STATUS
Definition: rpc.h:52
#define __RPC_USER
Definition: rpc.h:65
#define RpcExceptionCode()
Definition: rpc.h:132
#define SCM_START_EVENT
Definition: services.h:26
static LPSTR lpNameBuffer
Definition: secur32.c:50
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define TRACE(s)
Definition: solgame.cpp:4
LPWSTR lpDisplayName
Definition: winsvc.h:131
LPWSTR lpServiceName
Definition: winsvc.h:130
LPSTR lpServiceStartName
Definition: winsvc.h:152
LPWSTR lpServiceStartName
Definition: winsvc.h:163
LPWSTR lpBinaryPathName
Definition: winsvc.h:159
LPWSTR lpLoadOrderGroup
Definition: winsvc.h:160
LPWSTR lpDescription
Definition: winsvc.h:196
SC_ACTION * lpsaActions
Definition: winsvc.h:213
SC_ACTION * lpsaActions
Definition: winsvc.h:220
TAG_INFO_NAME_FROM_TAG_OUT_PARAMS OutParams
Definition: svcctl.idl:320
TAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams
Definition: svcctl.idl:319
Definition: copy.c:22
Definition: ps.c:97
Definition: config.c:19
DWORD Length
Definition: config.c:20
DWORD MaximumLength
Definition: config.c:21
unsigned char * Buffer
Definition: config.c:22
LPSTR SVCCTL_HANDLEA
Definition: svcctl.idl:18
LPWSTR SVCCTL_HANDLEW
Definition: svcctl.idl:19
enum _TAG_INFO_LEVEL TAG_INFO_LEVEL
@ TagInfoLevelNameFromTag
Definition: svcctl.idl:300
HANDLE WINAPI DECLSPEC_HOTPATCH OpenEventW(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN LPCWSTR lpName)
Definition: synch.c:682
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
const uint16_t * PCWSTR
Definition: typedefs.h:57
unsigned char * LPBYTE
Definition: typedefs.h:53
ULONG_PTR SIZE_T
Definition: typedefs.h:80
uint32_t * LPDWORD
Definition: typedefs.h:59
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
_Must_inspect_result_ _In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR _Out_ WDFDEVICE _Inout_opt_ PWDF_CHILD_RETRIEVE_INFO Info
Definition: wdfchildlist.h:690
#define SecureZeroMemory
Definition: winbase.h:1671
_In_ LPCSTR _Out_writes_to_opt_ cchDisplayName LPSTR lpDisplayName
Definition: winbase.h:2777
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
#define LPTR
Definition: winbase.h:381
#define WINAPI
Definition: msvc.h:6
#define ERROR_INVALID_LEVEL
Definition: winerror.h:196
#define RPC_X_ENUM_VALUE_OUT_OF_RANGE
Definition: winerror.h:1088
#define RPC_X_SS_IN_NULL_CONTEXT
Definition: winerror.h:1083
#define ERROR_RETRY
Definition: winerror.h:740
#define RPC_X_NULL_REF_POINTER
Definition: winerror.h:1087
#define ERROR_INVALID_SERVICE_LOCK
Definition: winerror.h:622
#define RPC_X_BYTE_COUNT_TOO_SMALL
Definition: winerror.h:1089
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013
#define ERROR_INVALID_DATA
Definition: winerror.h:116
struct _QUERY_SERVICE_LOCK_STATUSW QUERY_SERVICE_LOCK_STATUSW
struct _SERVICE_DESCRIPTIONA SERVICE_DESCRIPTIONA
struct _ENUM_SERVICE_STATUS_PROCESSA ENUM_SERVICE_STATUS_PROCESSA
_In_ DWORD _In_ DWORD _Out_ LPDWORD pcbBytesNeeded
Definition: winsvc.h:425
struct _SERVICE_FAILURE_ACTIONSW SERVICE_FAILURE_ACTIONSW
struct _QUERY_SERVICE_LOCK_STATUSA QUERY_SERVICE_LOCK_STATUSA
@ SC_STATUS_PROCESS_INFO
Definition: winsvc.h:119
_In_ DWORD _In_ DWORD cbBufSize
Definition: winsvc.h:424
struct _ENUM_SERVICE_STATUS_PROCESSW * LPENUM_SERVICE_STATUS_PROCESSW
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
struct _SERVICE_DESCRIPTIONW SERVICE_DESCRIPTIONW
#define SC_MANAGER_ENUMERATE_SERVICE
Definition: winsvc.h:16
struct _ENUM_SERVICE_STATUS_PROCESSA * LPENUM_SERVICE_STATUS_PROCESSA
struct _QUERY_SERVICE_CONFIGW QUERY_SERVICE_CONFIGW
struct _SERVICE_DESCRIPTIONW * LPSERVICE_DESCRIPTIONW
struct _ENUM_SERVICE_STATUSW ENUM_SERVICE_STATUSW
struct _ENUM_SERVICE_STATUS_PROCESSW ENUM_SERVICE_STATUS_PROCESSW
struct _SERVICE_FAILURE_ACTIONSA * LPSERVICE_FAILURE_ACTIONSA
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
struct _SC_ACTION * LPSC_ACTION
enum _SC_STATUS_TYPE SC_STATUS_TYPE
struct _SERVICE_DESCRIPTIONA * LPSERVICE_DESCRIPTIONA
struct _SERVICE_FAILURE_ACTIONSA SERVICE_FAILURE_ACTIONSA
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
@ SC_ENUM_PROCESS_INFO
Definition: winsvc.h:122
struct _SERVICE_FAILURE_ACTIONSW * LPSERVICE_FAILURE_ACTIONSW
struct _SERVICE_STATUS_PROCESS SERVICE_STATUS_PROCESS
struct _ENUM_SERVICE_STATUSA ENUM_SERVICE_STATUSA
enum _SC_ENUM_TYPE SC_ENUM_TYPE
Definition: service.c:43
struct _QUERY_SERVICE_CONFIGA QUERY_SERVICE_CONFIGA
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175
unsigned char BYTE
Definition: xxhash.c:193