0f7997cab358c03b223bec47773a473753e6357d
[reactos.git] / reactos / lib / advapi32 / service / scm.c
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 * UPDATE HISTORY:
9 * 19990413 EA created
10 * 19990515 EA
11 */
12
13 /* INCLUDES ******************************************************************/
14
15 #include <advapi32.h>
16 #include "svcctl_c.h"
17
18 #define NDEBUG
19 #include <debug.h>
20
21 /* FUNCTIONS *****************************************************************/
22
23 handle_t BindingHandle = NULL;
24
25 static VOID
26 HandleBind(VOID)
27 {
28 LPWSTR pszStringBinding;
29 RPC_STATUS status;
30
31 if (BindingHandle != NULL)
32 return;
33
34 status = RpcStringBindingComposeW(NULL,
35 L"ncacn_np",
36 NULL,
37 L"\\pipe\\ntsvcs",
38 NULL,
39 &pszStringBinding);
40 if (status)
41 {
42 DPRINT1("RpcStringBindingCompose returned 0x%x\n", status);
43 return;
44 }
45
46 /* Set the binding handle that will be used to bind to the server. */
47 status = RpcBindingFromStringBindingW(pszStringBinding,
48 &BindingHandle);
49 if (status)
50 {
51 DPRINT1("RpcBindingFromStringBinding returned 0x%x\n", status);
52 }
53
54 status = RpcStringFreeW(&pszStringBinding);
55 if (status)
56 {
57 DPRINT1("RpcStringFree returned 0x%x\n", status);
58 }
59 }
60
61
62 #if 0
63 static VOID
64 HandleUnbind(VOID)
65 {
66 RPC_STATUS status;
67
68 if (BindingHandle == NULL)
69 return;
70
71 status = RpcBindingFree(&BindingHandle);
72 if (status)
73 {
74 DPRINT1("RpcBindingFree returned 0x%x\n", status);
75 }
76 }
77 #endif
78
79
80 /**********************************************************************
81 * ChangeServiceConfig2W
82 *
83 * @implemented
84 */
85 BOOL WINAPI
86 ChangeServiceConfig2W(SC_HANDLE hService,
87 DWORD dwInfoLevel,
88 LPVOID lpInfo)
89 {
90 DWORD lpInfoSize;
91 DWORD dwError;
92
93 DPRINT("ChangeServiceConfig2W() called\n");
94
95 /* Determine the length of the lpInfo parameter */
96 switch (dwInfoLevel)
97 {
98 case SERVICE_CONFIG_DESCRIPTION:
99 lpInfoSize = sizeof(SERVICE_DESCRIPTION);
100 case SERVICE_CONFIG_FAILURE_ACTIONS:
101 lpInfoSize = sizeof(SERVICE_FAILURE_ACTIONS);
102 default:
103 DPRINT1("Unknown info level 0x%lx\n", dwInfoLevel);
104 SetLastError(ERROR_INVALID_PARAMETER);
105 return FALSE;
106 }
107
108 if (lpInfo == NULL)
109 return TRUE;
110
111 HandleBind();
112
113 dwError = ScmrChangeServiceConfig2W(BindingHandle,
114 (unsigned int)hService,
115 dwInfoLevel,
116 lpInfo,
117 lpInfoSize);
118 if (dwError != ERROR_SUCCESS)
119 {
120 DPRINT1("ScmrChangeServiceConfig2W() failed (Error %lu)\n", dwError);
121 SetLastError(dwError);
122 return FALSE;
123 }
124 }
125
126
127 /**********************************************************************
128 * ChangeServiceConfigA
129 *
130 * @implemented
131 */
132 BOOL STDCALL
133 ChangeServiceConfigA(SC_HANDLE hService,
134 DWORD dwServiceType,
135 DWORD dwStartType,
136 DWORD dwErrorControl,
137 LPCSTR lpBinaryPathName,
138 LPCSTR lpLoadOrderGroup,
139 LPDWORD lpdwTagId,
140 LPCSTR lpDependencies,
141 LPCSTR lpServiceStartName,
142 LPCSTR lpPassword,
143 LPCSTR lpDisplayName)
144 {
145 DWORD dwError;
146 DWORD dwDependenciesLength = 0;
147 DWORD dwLength;
148 LPSTR lpStr;
149
150 DPRINT("ChangeServiceConfigA() called\n");
151
152 /* Calculate the Dependencies length*/
153 if (lpDependencies != NULL)
154 {
155 lpStr = (LPSTR)lpDependencies;
156 while (*lpStr)
157 {
158 dwLength = strlen(lpStr) + 1;
159 dwDependenciesLength += dwLength;
160 lpStr = lpStr + dwLength;
161 }
162 dwDependenciesLength++;
163 }
164
165 /* FIXME: Encrypt the password */
166
167 HandleBind();
168
169 /* Call to services.exe using RPC */
170 dwError = ScmrChangeServiceConfigA(BindingHandle,
171 (unsigned int)hService,
172 dwServiceType,
173 dwStartType,
174 dwErrorControl,
175 (LPSTR)lpBinaryPathName,
176 (LPSTR)lpLoadOrderGroup,
177 lpdwTagId,
178 (LPSTR)lpDependencies,
179 dwDependenciesLength,
180 (LPSTR)lpServiceStartName,
181 NULL, /* FIXME: lpPassword */
182 0, /* FIXME: dwPasswordLength */
183 (LPSTR)lpDisplayName);
184 if (dwError != ERROR_SUCCESS)
185 {
186 DPRINT1("ScmrChangeServiceConfigA() failed (Error %lu)\n", dwError);
187 SetLastError(dwError);
188 return FALSE;
189 }
190
191 return TRUE;
192 }
193
194
195 /**********************************************************************
196 * ChangeServiceConfigW
197 *
198 * @implemented
199 */
200 BOOL STDCALL
201 ChangeServiceConfigW(SC_HANDLE hService,
202 DWORD dwServiceType,
203 DWORD dwStartType,
204 DWORD dwErrorControl,
205 LPCWSTR lpBinaryPathName,
206 LPCWSTR lpLoadOrderGroup,
207 LPDWORD lpdwTagId,
208 LPCWSTR lpDependencies,
209 LPCWSTR lpServiceStartName,
210 LPCWSTR lpPassword,
211 LPCWSTR lpDisplayName)
212 {
213 DWORD dwError;
214 DWORD dwDependenciesLength = 0;
215 DWORD dwLength;
216 LPWSTR lpStr;
217
218 DPRINT("ChangeServiceConfigW() called\n");
219
220 /* Calculate the Dependencies length*/
221 if (lpDependencies != NULL)
222 {
223 lpStr = (LPWSTR)lpDependencies;
224 while (*lpStr)
225 {
226 dwLength = wcslen(lpStr) + 1;
227 dwDependenciesLength += dwLength;
228 lpStr = lpStr + dwLength;
229 }
230 dwDependenciesLength++;
231 }
232
233 /* FIXME: Encrypt the password */
234
235 HandleBind();
236
237 /* Call to services.exe using RPC */
238 dwError = ScmrChangeServiceConfigW(BindingHandle,
239 (unsigned int)hService,
240 dwServiceType,
241 dwStartType,
242 dwErrorControl,
243 (LPWSTR)lpBinaryPathName,
244 (LPWSTR)lpLoadOrderGroup,
245 lpdwTagId,
246 (LPWSTR)lpDependencies,
247 dwDependenciesLength,
248 (LPWSTR)lpServiceStartName,
249 NULL, /* FIXME: lpPassword */
250 0, /* FIXME: dwPasswordLength */
251 (LPWSTR)lpDisplayName);
252 if (dwError != ERROR_SUCCESS)
253 {
254 DPRINT1("ScmrChangeServiceConfigW() failed (Error %lu)\n", dwError);
255 SetLastError(dwError);
256 return FALSE;
257 }
258
259 return TRUE;
260 }
261
262
263 /**********************************************************************
264 * CloseServiceHandle
265 *
266 * @implemented
267 */
268 BOOL STDCALL
269 CloseServiceHandle(SC_HANDLE hSCObject)
270 {
271 DWORD dwError;
272
273 DPRINT("CloseServiceHandle() called\n");
274
275 HandleBind();
276
277 /* Call to services.exe using RPC */
278 dwError = ScmrCloseServiceHandle(BindingHandle,
279 (unsigned int)hSCObject);
280 if (dwError)
281 {
282 DPRINT1("ScmrCloseServiceHandle() failed (Error %lu)\n", dwError);
283 SetLastError(dwError);
284 return FALSE;
285 }
286
287 DPRINT("CloseServiceHandle() done\n");
288
289 return TRUE;
290 }
291
292
293 /**********************************************************************
294 * ControlService
295 *
296 * @implemented
297 */
298 BOOL STDCALL
299 ControlService(SC_HANDLE hService,
300 DWORD dwControl,
301 LPSERVICE_STATUS lpServiceStatus)
302 {
303 DWORD dwError;
304
305 DPRINT("ControlService(%x, %x, %p)\n",
306 hService, dwControl, lpServiceStatus);
307
308 HandleBind();
309
310 /* Call to services.exe using RPC */
311 dwError = ScmrControlService(BindingHandle,
312 (unsigned int)hService,
313 dwControl,
314 lpServiceStatus);
315 if (dwError != ERROR_SUCCESS)
316 {
317 DPRINT1("ScmrControlService() failed (Error %lu)\n", dwError);
318 SetLastError(dwError);
319 return FALSE;
320 }
321
322 DPRINT("ControlService() done\n");
323
324 return TRUE;
325 }
326
327
328 /**********************************************************************
329 * ControlServiceEx
330 *
331 * @unimplemented
332 */
333 BOOL STDCALL
334 ControlServiceEx(IN SC_HANDLE hService,
335 IN DWORD dwControl,
336 IN DWORD dwInfoLevel,
337 IN OUT PVOID pControlParams)
338 {
339 DPRINT1("ControlServiceEx(0x%p, 0x%x, 0x%x, 0x%p) UNIMPLEMENTED!\n",
340 hService, dwControl, dwInfoLevel, pControlParams);
341 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
342 return FALSE;
343 }
344
345
346
347 /**********************************************************************
348 * CreateServiceA
349 *
350 * @implemented
351 */
352 SC_HANDLE
353 STDCALL
354 CreateServiceA(SC_HANDLE hSCManager,
355 LPCSTR lpServiceName,
356 LPCSTR lpDisplayName,
357 DWORD dwDesiredAccess,
358 DWORD dwServiceType,
359 DWORD dwStartType,
360 DWORD dwErrorControl,
361 LPCSTR lpBinaryPathName,
362 LPCSTR lpLoadOrderGroup,
363 LPDWORD lpdwTagId,
364 LPCSTR lpDependencies,
365 LPCSTR lpServiceStartName,
366 LPCSTR lpPassword)
367 {
368 SC_HANDLE RetVal = NULL;
369 LPWSTR lpServiceNameW = NULL;
370 LPWSTR lpDisplayNameW = NULL;
371 LPWSTR lpBinaryPathNameW = NULL;
372 LPWSTR lpLoadOrderGroupW = NULL;
373 LPWSTR lpDependenciesW = NULL;
374 LPWSTR lpServiceStartNameW = NULL;
375 LPWSTR lpPasswordW = NULL;
376 DWORD dwDependenciesLength = 0;
377 DWORD dwLength;
378 LPSTR lpStr;
379
380 int len = MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, NULL, 0);
381 lpServiceNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
382 if (!lpServiceNameW)
383 {
384 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
385 goto cleanup;
386 }
387 MultiByteToWideChar(CP_ACP, 0, lpServiceName, -1, lpServiceNameW, len);
388
389 len = MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, NULL, 0);
390 lpDisplayNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
391 if (!lpDisplayNameW)
392 {
393 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
394 goto cleanup;
395 }
396 MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpDisplayNameW, len);
397
398 len = MultiByteToWideChar(CP_ACP, 0, lpBinaryPathName, -1, NULL, 0);
399 lpBinaryPathNameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
400 if (!lpBinaryPathNameW)
401 {
402 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
403 goto cleanup;
404 }
405 MultiByteToWideChar(CP_ACP, 0, lpDisplayName, -1, lpBinaryPathNameW, len);
406
407 len = MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, NULL, 0);
408 lpLoadOrderGroupW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
409 if (!lpLoadOrderGroupW)
410 {
411 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
412 goto cleanup;
413 }
414 MultiByteToWideChar(CP_ACP, 0, lpLoadOrderGroup, -1, lpLoadOrderGroupW, len);
415
416 if (lpDependencies != NULL)
417 {
418 lpStr = (LPSTR)lpDependencies;
419 while (*lpStr)
420 {
421 dwLength = strlen(lpStr) + 1;
422 dwDependenciesLength += dwLength;
423 lpStr = lpStr + dwLength;
424 }
425 dwDependenciesLength++;
426 }
427
428 lpDependenciesW = HeapAlloc(GetProcessHeap(), 0, dwDependenciesLength * sizeof(WCHAR));
429 if (!lpDependenciesW)
430 {
431 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
432 goto cleanup;
433 }
434 MultiByteToWideChar(CP_ACP, 0, lpDependencies, -1, lpDependenciesW, dwDependenciesLength);
435
436 len = MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, NULL, 0);
437 lpServiceStartName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
438 if (!lpServiceStartNameW)
439 {
440 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
441 goto cleanup;
442 }
443 MultiByteToWideChar(CP_ACP, 0, lpServiceStartName, -1, lpServiceStartNameW, len);
444
445 len = MultiByteToWideChar(CP_ACP, 0, lpPassword, -1, NULL, 0);
446 lpPasswordW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
447 if (!lpPasswordW)
448 {
449 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
450 goto cleanup;
451 }
452 MultiByteToWideChar(CP_ACP, 0, lpPassword, -1, lpPasswordW, len);
453
454 RetVal = CreateServiceW(hSCManager,
455 lpServiceNameW,
456 lpDisplayNameW,
457 dwDesiredAccess,
458 dwServiceType,
459 dwStartType,
460 dwErrorControl,
461 lpBinaryPathNameW,
462 lpLoadOrderGroupW,
463 lpdwTagId,
464 lpDependenciesW,
465 lpServiceStartNameW,
466 lpPasswordW);
467
468 cleanup:
469 HeapFree(GetProcessHeap(), 0, lpServiceNameW);
470 HeapFree(GetProcessHeap(), 0, lpDisplayNameW);
471 HeapFree(GetProcessHeap(), 0, lpBinaryPathNameW);
472 HeapFree(GetProcessHeap(), 0, lpLoadOrderGroupW);
473 HeapFree(GetProcessHeap(), 0, lpDependenciesW);
474 HeapFree(GetProcessHeap(), 0, lpServiceStartNameW);
475 HeapFree(GetProcessHeap(), 0, lpPasswordW);
476
477 return RetVal;
478 }
479
480
481 /**********************************************************************
482 * CreateServiceW
483 *
484 * @implemented
485 */
486 SC_HANDLE STDCALL
487 CreateServiceW(SC_HANDLE hSCManager,
488 LPCWSTR lpServiceName,
489 LPCWSTR lpDisplayName,
490 DWORD dwDesiredAccess,
491 DWORD dwServiceType,
492 DWORD dwStartType,
493 DWORD dwErrorControl,
494 LPCWSTR lpBinaryPathName,
495 LPCWSTR lpLoadOrderGroup,
496 LPDWORD lpdwTagId,
497 LPCWSTR lpDependencies,
498 LPCWSTR lpServiceStartName,
499 LPCWSTR lpPassword)
500 {
501 SC_HANDLE hService = NULL;
502 DWORD dwError;
503 DWORD dwDependenciesLength = 0;
504 DWORD dwLength;
505 LPWSTR lpStr;
506
507 DPRINT("CreateServiceW() called\n");
508
509 /* Calculate the Dependencies length*/
510 if (lpDependencies != NULL)
511 {
512 lpStr = (LPWSTR)lpDependencies;
513 while (*lpStr)
514 {
515 dwLength = wcslen(lpStr) + 1;
516 dwDependenciesLength += dwLength;
517 lpStr = lpStr + dwLength;
518 }
519 dwDependenciesLength++;
520 }
521
522 /* FIXME: Encrypt the password */
523
524 HandleBind();
525
526 /* Call to services.exe using RPC */
527 dwError = ScmrCreateServiceW(BindingHandle,
528 (unsigned int)hSCManager,
529 (LPWSTR)lpServiceName,
530 (LPWSTR)lpDisplayName,
531 dwDesiredAccess,
532 dwServiceType,
533 dwStartType,
534 dwErrorControl,
535 (LPWSTR)lpBinaryPathName,
536 (LPWSTR)lpLoadOrderGroup,
537 lpdwTagId,
538 (LPWSTR)lpDependencies,
539 dwDependenciesLength,
540 (LPWSTR)lpServiceStartName,
541 NULL, /* FIXME: lpPassword */
542 0, /* FIXME: dwPasswordLength */
543 (unsigned int *)&hService);
544 if (dwError != ERROR_SUCCESS)
545 {
546 DPRINT1("ScmrCreateServiceW(%S) failed (Error %lu)\n", lpServiceName, dwError);
547 SetLastError(dwError);
548 return NULL;
549 }
550
551 return hService;
552 }
553
554
555 /**********************************************************************
556 * DeleteService
557 *
558 * @implemented
559 */
560 BOOL STDCALL
561 DeleteService(SC_HANDLE hService)
562 {
563 DWORD dwError;
564
565 DPRINT("DeleteService(%x)\n", hService);
566
567 HandleBind();
568
569 /* Call to services.exe using RPC */
570 dwError = ScmrDeleteService(BindingHandle,
571 (unsigned int)hService);
572 if (dwError != ERROR_SUCCESS)
573 {
574 DPRINT1("ScmrDeleteService() failed (Error %lu)\n", dwError);
575 SetLastError(dwError);
576 return FALSE;
577 }
578
579 return TRUE;
580 }
581
582
583 /**********************************************************************
584 * EnumDependentServicesA
585 *
586 * @unimplemented
587 */
588 BOOL
589 STDCALL
590 EnumDependentServicesA(
591 SC_HANDLE hService,
592 DWORD dwServiceState,
593 LPENUM_SERVICE_STATUSA lpServices,
594 DWORD cbBufSize,
595 LPDWORD pcbBytesNeeded,
596 LPDWORD lpServicesReturned)
597 {
598 DPRINT1("EnumDependentServicesA is unimplemented\n");
599 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
600 return FALSE;
601 }
602
603
604 /**********************************************************************
605 * EnumDependentServicesW
606 *
607 * @unimplemented
608 */
609 BOOL
610 STDCALL
611 EnumDependentServicesW(SC_HANDLE hService,
612 DWORD dwServiceState,
613 LPENUM_SERVICE_STATUSW lpServices,
614 DWORD cbBufSize,
615 LPDWORD pcbBytesNeeded,
616 LPDWORD lpServicesReturned)
617 {
618 DPRINT1("EnumDependentServicesW is unimplemented\n");
619 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
620 return FALSE;
621 }
622
623
624 /**********************************************************************
625 * EnumServiceGroupW
626 *
627 * @unimplemented
628 */
629 BOOL
630 STDCALL
631 EnumServiceGroupW(
632 SC_HANDLE hSCManager,
633 DWORD dwServiceType,
634 DWORD dwServiceState,
635 LPENUM_SERVICE_STATUSA lpServices,
636 DWORD cbBufSize,
637 LPDWORD pcbBytesNeeded,
638 LPDWORD lpServicesReturned,
639 LPDWORD lpResumeHandle,
640 LPCWSTR lpGroup)
641 {
642 DPRINT1("EnumServiceGroupW is unimplemented\n");
643 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
644 return FALSE;
645 }
646
647
648 /**********************************************************************
649 * EnumServicesStatusA
650 *
651 * @unimplemented
652 */
653 BOOL
654 STDCALL
655 EnumServicesStatusA(
656 SC_HANDLE hSCManager,
657 DWORD dwServiceType,
658 DWORD dwServiceState,
659 LPENUM_SERVICE_STATUSA lpServices,
660 DWORD cbBufSize,
661 LPDWORD pcbBytesNeeded,
662 LPDWORD lpServicesReturned,
663 LPDWORD lpResumeHandle)
664 {
665 DPRINT1("EnumServicesStatusA is unimplemented\n");
666 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
667 return FALSE;
668 }
669
670
671 /**********************************************************************
672 * EnumServicesStatusW
673 *
674 * @implemented
675 */
676 BOOL STDCALL
677 EnumServicesStatusW(SC_HANDLE hSCManager,
678 DWORD dwServiceType,
679 DWORD dwServiceState,
680 LPENUM_SERVICE_STATUSW lpServices,
681 DWORD cbBufSize,
682 LPDWORD pcbBytesNeeded,
683 LPDWORD lpServicesReturned,
684 LPDWORD lpResumeHandle)
685 {
686 LPENUM_SERVICE_STATUSW lpStatusPtr;
687 DWORD dwError = ERROR_SUCCESS;
688 DWORD dwCount;
689
690 DPRINT("EnumServicesStatusW() called\n");
691
692 HandleBind();
693
694 dwError = ScmrEnumServicesStatusW(BindingHandle,
695 (unsigned int)hSCManager,
696 dwServiceType,
697 dwServiceState,
698 (unsigned char *)lpServices,
699 cbBufSize,
700 pcbBytesNeeded,
701 lpServicesReturned,
702 lpResumeHandle);
703
704 lpStatusPtr = (LPENUM_SERVICE_STATUSW)lpServices;
705 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
706 {
707 if (lpStatusPtr->lpServiceName)
708 lpStatusPtr->lpServiceName =
709 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
710
711 if (lpStatusPtr->lpDisplayName)
712 lpStatusPtr->lpDisplayName =
713 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
714
715 lpStatusPtr++;
716 }
717
718 if (dwError != ERROR_SUCCESS)
719 {
720 DPRINT("ScmrEnumServicesStatusW() failed (Error %lu)\n", dwError);
721 SetLastError(dwError);
722 return FALSE;
723 }
724
725 DPRINT("ScmrEnumServicesStatusW() done\n");
726
727 return TRUE;
728 }
729
730
731 /**********************************************************************
732 * EnumServicesStatusExA
733 *
734 * @unimplemented
735 */
736 BOOL
737 STDCALL
738 EnumServicesStatusExA(SC_HANDLE hSCManager,
739 SC_ENUM_TYPE InfoLevel,
740 DWORD dwServiceType,
741 DWORD dwServiceState,
742 LPBYTE lpServices,
743 DWORD cbBufSize,
744 LPDWORD pcbBytesNeeded,
745 LPDWORD lpServicesReturned,
746 LPDWORD lpResumeHandle,
747 LPCSTR pszGroupName)
748 {
749 DPRINT1("EnumServicesStatusExA is unimplemented\n");
750 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
751 return FALSE;
752 }
753
754
755 /**********************************************************************
756 * EnumServicesStatusExW
757 *
758 * @implemented
759 */
760 BOOL STDCALL
761 EnumServicesStatusExW(SC_HANDLE hSCManager,
762 SC_ENUM_TYPE InfoLevel,
763 DWORD dwServiceType,
764 DWORD dwServiceState,
765 LPBYTE lpServices,
766 DWORD cbBufSize,
767 LPDWORD pcbBytesNeeded,
768 LPDWORD lpServicesReturned,
769 LPDWORD lpResumeHandle,
770 LPCWSTR pszGroupName)
771 {
772 LPENUM_SERVICE_STATUS_PROCESSW lpStatusPtr;
773 DWORD dwError = ERROR_SUCCESS;
774 DWORD dwCount;
775
776 DPRINT1("EnumServicesStatusExW() called\n");
777
778 HandleBind();
779
780 dwError = ScmrEnumServicesStatusExW(BindingHandle,
781 (unsigned int)hSCManager,
782 (unsigned long)InfoLevel,
783 dwServiceType,
784 dwServiceState,
785 (unsigned char *)lpServices,
786 cbBufSize,
787 pcbBytesNeeded,
788 lpServicesReturned,
789 lpResumeHandle,
790 (wchar_t *)pszGroupName);
791
792 lpStatusPtr = (LPENUM_SERVICE_STATUS_PROCESSW)lpServices;
793 for (dwCount = 0; dwCount < *lpServicesReturned; dwCount++)
794 {
795 if (lpStatusPtr->lpServiceName)
796 lpStatusPtr->lpServiceName =
797 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpServiceName);
798
799 if (lpStatusPtr->lpDisplayName)
800 lpStatusPtr->lpDisplayName =
801 (LPWSTR)((ULONG_PTR)lpServices + (ULONG_PTR)lpStatusPtr->lpDisplayName);
802
803 lpStatusPtr++;
804 }
805
806 if (dwError != ERROR_SUCCESS)
807 {
808 DPRINT1("ScmrEnumServicesStatusExW() failed (Error %lu)\n", dwError);
809 SetLastError(dwError);
810 return FALSE;
811 }
812
813 DPRINT1("ScmrEnumServicesStatusExW() done\n");
814
815 return TRUE;
816 }
817
818
819 /**********************************************************************
820 * GetServiceDisplayNameA
821 *
822 * @implemented
823 */
824 BOOL STDCALL
825 GetServiceDisplayNameA(SC_HANDLE hSCManager,
826 LPCSTR lpServiceName,
827 LPSTR lpDisplayName,
828 LPDWORD lpcchBuffer)
829 {
830 DWORD dwError;
831
832 DPRINT("GetServiceDisplayNameA() called\n");
833
834 HandleBind();
835
836 dwError = ScmrGetServiceDisplayNameA(BindingHandle,
837 (unsigned int)hSCManager,
838 (LPSTR)lpServiceName,
839 lpDisplayName,
840 lpcchBuffer);
841 if (dwError != ERROR_SUCCESS)
842 {
843 DPRINT1("ScmrGetServiceDisplayNameA() failed (Error %lu)\n", dwError);
844 SetLastError(dwError);
845 return FALSE;
846 }
847
848 (*lpcchBuffer)--;
849
850 return TRUE;
851 }
852
853
854 /**********************************************************************
855 * GetServiceDisplayNameW
856 *
857 * @implemented
858 */
859 BOOL STDCALL
860 GetServiceDisplayNameW(SC_HANDLE hSCManager,
861 LPCWSTR lpServiceName,
862 LPWSTR lpDisplayName,
863 LPDWORD lpcchBuffer)
864 {
865 DWORD dwError;
866
867 DPRINT("GetServiceDisplayNameW() called\n");
868
869 HandleBind();
870
871 dwError = ScmrGetServiceDisplayNameW(BindingHandle,
872 (unsigned int)hSCManager,
873 (LPWSTR)lpServiceName,
874 lpDisplayName,
875 lpcchBuffer);
876 if (dwError != ERROR_SUCCESS)
877 {
878 DPRINT1("ScmrGetServiceDisplayNameW() failed (Error %lu)\n", dwError);
879 SetLastError(dwError);
880 return FALSE;
881 }
882
883 (*lpcchBuffer)--;
884
885 return TRUE;
886 }
887
888
889 /**********************************************************************
890 * GetServiceKeyNameA
891 *
892 * @implemented
893 */
894 BOOL STDCALL
895 GetServiceKeyNameA(SC_HANDLE hSCManager,
896 LPCSTR lpDisplayName,
897 LPSTR lpServiceName,
898 LPDWORD lpcchBuffer)
899 {
900 DWORD dwError;
901
902 DPRINT("GetServiceKeyNameA() called\n");
903
904 HandleBind();
905
906 dwError = ScmrGetServiceKeyNameA(BindingHandle,
907 (unsigned int)hSCManager,
908 (LPSTR)lpDisplayName,
909 lpServiceName,
910 lpcchBuffer);
911 if (dwError != ERROR_SUCCESS)
912 {
913 DPRINT1("ScmrGetServiceKeyNameA() failed (Error %lu)\n", dwError);
914 SetLastError(dwError);
915 return FALSE;
916 }
917
918 (*lpcchBuffer)--;
919
920 return TRUE;
921 }
922
923
924 /**********************************************************************
925 * GetServiceKeyNameW
926 *
927 * @implemented
928 */
929 BOOL STDCALL
930 GetServiceKeyNameW(SC_HANDLE hSCManager,
931 LPCWSTR lpDisplayName,
932 LPWSTR lpServiceName,
933 LPDWORD lpcchBuffer)
934 {
935 DWORD dwError;
936
937 DPRINT("GetServiceKeyNameW() called\n");
938
939 HandleBind();
940
941 dwError = ScmrGetServiceKeyNameW(BindingHandle,
942 (unsigned int)hSCManager,
943 (LPWSTR)lpDisplayName,
944 lpServiceName,
945 lpcchBuffer);
946 if (dwError != ERROR_SUCCESS)
947 {
948 DPRINT1("ScmrGetServiceKeyNameW() failed (Error %lu)\n", dwError);
949 SetLastError(dwError);
950 return FALSE;
951 }
952
953 (*lpcchBuffer)--;
954
955 return TRUE;
956 }
957
958
959 /**********************************************************************
960 * LockServiceDatabase
961 *
962 * @implemented
963 */
964 SC_LOCK STDCALL
965 LockServiceDatabase(SC_HANDLE hSCManager)
966 {
967 SC_LOCK hLock;
968 DWORD dwError;
969
970 DPRINT("LockServiceDatabase(%x)\n", hSCManager);
971
972 HandleBind();
973
974 /* Call to services.exe using RPC */
975 dwError = ScmrLockServiceDatabase(BindingHandle,
976 (unsigned int)hSCManager,
977 (unsigned int *)&hLock);
978 if (dwError != ERROR_SUCCESS)
979 {
980 DPRINT1("ScmrLockServiceDatabase() failed (Error %lu)\n", dwError);
981 SetLastError(dwError);
982 return NULL;
983 }
984
985 DPRINT("hLock = %p\n", hLock);
986
987 return hLock;
988 }
989
990
991 static VOID
992 WaitForSCManager(VOID)
993 {
994 HANDLE hEvent;
995
996 DPRINT("WaitForSCManager() called\n");
997
998 /* Try to open the existing event */
999 hEvent = OpenEventW(SYNCHRONIZE,
1000 FALSE,
1001 L"SvcctrlStartEvent_A3725DX");
1002 if (hEvent == NULL)
1003 {
1004 if (GetLastError() != ERROR_FILE_NOT_FOUND)
1005 return;
1006
1007 /* Try to create a new event */
1008 hEvent = CreateEventW(NULL,
1009 TRUE,
1010 FALSE,
1011 L"SvcctrlStartEvent_A3725DX");
1012 if (hEvent == NULL)
1013 {
1014 /* Try to open the existing event again */
1015 hEvent = OpenEventW(SYNCHRONIZE,
1016 FALSE,
1017 L"SvcctrlStartEvent_A3725DX");
1018 if (hEvent == NULL)
1019 return;
1020 }
1021 }
1022
1023 /* Wait for 3 minutes */
1024 WaitForSingleObject(hEvent, 180000);
1025 CloseHandle(hEvent);
1026
1027 DPRINT("ScmWaitForSCManager() done\n");
1028 }
1029
1030
1031 /**********************************************************************
1032 * OpenSCManagerA
1033 *
1034 * @implemented
1035 */
1036 SC_HANDLE STDCALL
1037 OpenSCManagerA(LPCSTR lpMachineName,
1038 LPCSTR lpDatabaseName,
1039 DWORD dwDesiredAccess)
1040 {
1041 SC_HANDLE hScm = NULL;
1042 DWORD dwError;
1043
1044 DPRINT("OpenSCManagerA(%s, %s, %lx)\n",
1045 lpMachineName, lpDatabaseName, dwDesiredAccess);
1046
1047 WaitForSCManager();
1048
1049 HandleBind();
1050
1051 /* Call to services.exe using RPC */
1052 dwError = ScmrOpenSCManagerA(BindingHandle,
1053 (LPSTR)lpMachineName,
1054 (LPSTR)lpDatabaseName,
1055 dwDesiredAccess,
1056 (unsigned int*)&hScm);
1057 if (dwError != ERROR_SUCCESS)
1058 {
1059 DPRINT1("ScmrOpenSCManagerA() failed (Error %lu)\n", dwError);
1060 SetLastError(dwError);
1061 return NULL;
1062 }
1063
1064 DPRINT("hScm = %p\n", hScm);
1065
1066 return hScm;
1067 }
1068
1069
1070 /**********************************************************************
1071 * OpenSCManagerW
1072 *
1073 * @implemented
1074 */
1075 SC_HANDLE STDCALL
1076 OpenSCManagerW(LPCWSTR lpMachineName,
1077 LPCWSTR lpDatabaseName,
1078 DWORD dwDesiredAccess)
1079 {
1080 SC_HANDLE hScm = NULL;
1081 DWORD dwError;
1082
1083 DPRINT("OpenSCManagerW(%S, %S, %lx)\n",
1084 lpMachineName, lpDatabaseName, dwDesiredAccess);
1085
1086 WaitForSCManager();
1087
1088 HandleBind();
1089
1090 /* Call to services.exe using RPC */
1091 dwError = ScmrOpenSCManagerW(BindingHandle,
1092 (LPWSTR)lpMachineName,
1093 (LPWSTR)lpDatabaseName,
1094 dwDesiredAccess,
1095 (unsigned int*)&hScm);
1096 if (dwError != ERROR_SUCCESS)
1097 {
1098 DPRINT1("ScmrOpenSCManagerW() failed (Error %lu)\n", dwError);
1099 SetLastError(dwError);
1100 return NULL;
1101 }
1102
1103 DPRINT("hScm = %p\n", hScm);
1104
1105 return hScm;
1106 }
1107
1108
1109 /**********************************************************************
1110 * OpenServiceA
1111 *
1112 * @implemented
1113 */
1114 SC_HANDLE STDCALL
1115 OpenServiceA(SC_HANDLE hSCManager,
1116 LPCSTR lpServiceName,
1117 DWORD dwDesiredAccess)
1118 {
1119 SC_HANDLE hService = NULL;
1120 DWORD dwError;
1121
1122 DPRINT("OpenServiceA(%p, %s, %lx)\n",
1123 hSCManager, lpServiceName, dwDesiredAccess);
1124
1125 HandleBind();
1126
1127 /* Call to services.exe using RPC */
1128 dwError = ScmrOpenServiceA(BindingHandle,
1129 (unsigned int)hSCManager,
1130 (LPSTR)lpServiceName,
1131 dwDesiredAccess,
1132 (unsigned int*)&hService);
1133 if (dwError != ERROR_SUCCESS)
1134 {
1135 DPRINT("ScmrOpenServiceA(%s) failed (Error %lu)\n", lpServiceName, dwError);
1136 SetLastError(dwError);
1137 return NULL;
1138 }
1139
1140 DPRINT("hService = %p\n", hService);
1141
1142 return hService;
1143 }
1144
1145
1146 /**********************************************************************
1147 * OpenServiceW
1148 *
1149 * @implemented
1150 */
1151 SC_HANDLE STDCALL
1152 OpenServiceW(SC_HANDLE hSCManager,
1153 LPCWSTR lpServiceName,
1154 DWORD dwDesiredAccess)
1155 {
1156 SC_HANDLE hService = NULL;
1157 DWORD dwError;
1158
1159 DPRINT("OpenServiceW(%p, %S, %lx)\n",
1160 hSCManager, lpServiceName, dwDesiredAccess);
1161
1162 HandleBind();
1163
1164 /* Call to services.exe using RPC */
1165 dwError = ScmrOpenServiceW(BindingHandle,
1166 (unsigned int)hSCManager,
1167 (LPWSTR)lpServiceName,
1168 dwDesiredAccess,
1169 (unsigned int*)&hService);
1170 if (dwError != ERROR_SUCCESS)
1171 {
1172 DPRINT("ScmrOpenServiceW(%S) failed (Error %lu)\n", lpServiceName, dwError);
1173 SetLastError(dwError);
1174 return NULL;
1175 }
1176
1177 DPRINT("hService = %p\n", hService);
1178
1179 return hService;
1180 }
1181
1182
1183 /**********************************************************************
1184 * QueryServiceConfigA
1185 *
1186 * @implemented
1187 */
1188 BOOL STDCALL
1189 QueryServiceConfigA(SC_HANDLE hService,
1190 LPQUERY_SERVICE_CONFIGA lpServiceConfig,
1191 DWORD cbBufSize,
1192 LPDWORD pcbBytesNeeded)
1193 {
1194 DWORD dwError;
1195
1196 DPRINT("QueryServiceConfigA(%p, %p, %lu, %p)\n",
1197 hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
1198
1199 HandleBind();
1200
1201 /* Call to services.exe using RPC */
1202 dwError = ScmrQueryServiceConfigA(BindingHandle,
1203 (unsigned int)hService,
1204 (unsigned char *)lpServiceConfig,
1205 cbBufSize,
1206 pcbBytesNeeded);
1207 if (dwError != ERROR_SUCCESS)
1208 {
1209 DPRINT("ScmrQueryServiceConfigA() failed (Error %lu)\n", dwError);
1210 SetLastError(dwError);
1211 return FALSE;
1212 }
1213
1214 /* Adjust the pointers */
1215 if (lpServiceConfig->lpBinaryPathName)
1216 lpServiceConfig->lpBinaryPathName =
1217 (LPSTR)((ULONG_PTR)lpServiceConfig +
1218 (ULONG_PTR)lpServiceConfig->lpBinaryPathName);
1219
1220 if (lpServiceConfig->lpLoadOrderGroup)
1221 lpServiceConfig->lpLoadOrderGroup =
1222 (LPSTR)((ULONG_PTR)lpServiceConfig +
1223 (ULONG_PTR)lpServiceConfig->lpLoadOrderGroup);
1224
1225 if (lpServiceConfig->lpDependencies)
1226 lpServiceConfig->lpDependencies =
1227 (LPSTR)((ULONG_PTR)lpServiceConfig +
1228 (ULONG_PTR)lpServiceConfig->lpDependencies);
1229
1230 if (lpServiceConfig->lpServiceStartName)
1231 lpServiceConfig->lpServiceStartName =
1232 (LPSTR)((ULONG_PTR)lpServiceConfig +
1233 (ULONG_PTR)lpServiceConfig->lpServiceStartName);
1234
1235 if (lpServiceConfig->lpDisplayName)
1236 lpServiceConfig->lpDisplayName =
1237 (LPSTR)((ULONG_PTR)lpServiceConfig +
1238 (ULONG_PTR)lpServiceConfig->lpDisplayName);
1239
1240 DPRINT("QueryServiceConfigA() done\n");
1241
1242 return TRUE;
1243 }
1244
1245
1246 /**********************************************************************
1247 * QueryServiceConfigW
1248 *
1249 * @implemented
1250 */
1251 BOOL STDCALL
1252 QueryServiceConfigW(SC_HANDLE hService,
1253 LPQUERY_SERVICE_CONFIGW lpServiceConfig,
1254 DWORD cbBufSize,
1255 LPDWORD pcbBytesNeeded)
1256 {
1257 #if 0
1258 DWORD dwError;
1259
1260 DPRINT("QueryServiceConfigW(%p, %p, %lu, %p)\n",
1261 hService, lpServiceConfig, cbBufSize, pcbBytesNeeded);
1262
1263 HandleBind();
1264
1265 /* Call to services.exe using RPC */
1266 CHECKPOINT1;
1267 dwError = ScmrQueryServiceConfigW(BindingHandle,
1268 (unsigned int)hService,
1269 (unsigned char *)lpServiceConfig,
1270 cbBufSize,
1271 pcbBytesNeeded);
1272 CHECKPOINT1;
1273 if (dwError != ERROR_SUCCESS)
1274 {
1275 DPRINT("ScmrQueryServiceConfigW() failed (Error %lu)\n", dwError);
1276 SetLastError(dwError);
1277 return FALSE;
1278 }
1279
1280 /* Adjust the pointers */
1281 if (lpServiceConfig->lpBinaryPathName)
1282 lpServiceConfig->lpBinaryPathName =
1283 (LPWSTR)((ULONG_PTR)lpServiceConfig +
1284 (ULONG_PTR)lpServiceConfig->lpBinaryPathName);
1285
1286 if (lpServiceConfig->lpLoadOrderGroup)
1287 lpServiceConfig->lpLoadOrderGroup =
1288 (LPWSTR)((ULONG_PTR)lpServiceConfig +
1289 (ULONG_PTR)lpServiceConfig->lpLoadOrderGroup);
1290
1291 if (lpServiceConfig->lpDependencies)
1292 lpServiceConfig->lpDependencies =
1293 (LPWSTR)((ULONG_PTR)lpServiceConfig +
1294 (ULONG_PTR)lpServiceConfig->lpDependencies);
1295
1296 if (lpServiceConfig->lpServiceStartName)
1297 lpServiceConfig->lpServiceStartName =
1298 (LPWSTR)((ULONG_PTR)lpServiceConfig +
1299 (ULONG_PTR)lpServiceConfig->lpServiceStartName);
1300
1301 if (lpServiceConfig->lpDisplayName)
1302 lpServiceConfig->lpDisplayName =
1303 (LPWSTR)((ULONG_PTR)lpServiceConfig +
1304 (ULONG_PTR)lpServiceConfig->lpDisplayName);
1305
1306 DPRINT("QueryServiceConfigW() done\n");
1307
1308 return TRUE;
1309 #else
1310 DPRINT1("QueryServiceConfigW is unimplemented\n");
1311 if (lpServiceConfig && cbBufSize >= sizeof(QUERY_SERVICE_CONFIGW))
1312 {
1313 memset(lpServiceConfig, 0, *pcbBytesNeeded);
1314 return TRUE;
1315 }
1316 else
1317 {
1318 *pcbBytesNeeded = sizeof(QUERY_SERVICE_CONFIGW);
1319 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1320 return FALSE;
1321 }
1322 #endif
1323 }
1324
1325
1326 /**********************************************************************
1327 * QueryServiceConfig2A
1328 *
1329 * @unimplemented
1330 */
1331 BOOL
1332 STDCALL
1333 QueryServiceConfig2A(
1334 SC_HANDLE hService,
1335 DWORD dwInfo,
1336 LPBYTE lpBuffer,
1337 DWORD cbBufSize,
1338 LPDWORD pcbBytesNeeded)
1339 {
1340 DPRINT1("QueryServiceConfig2A is unimplemented\n");
1341 return FALSE;
1342 }
1343
1344
1345 /**********************************************************************
1346 * QueryServiceConfig2W
1347 *
1348 * @unimplemented
1349 */
1350 BOOL
1351 STDCALL
1352 QueryServiceConfig2W(
1353 SC_HANDLE hService,
1354 DWORD dwInfo,
1355 LPBYTE lpBuffer,
1356 DWORD cbBufSize,
1357 LPDWORD pcbBytesNeeded)
1358 {
1359 DPRINT1("QueryServiceConfig2W is unimplemented\n");
1360 return FALSE;
1361 }
1362
1363
1364 /**********************************************************************
1365 * QueryServiceLockStatusA
1366 *
1367 * @unimplemented
1368 */
1369 BOOL
1370 STDCALL
1371 QueryServiceLockStatusA(
1372 SC_HANDLE hSCManager,
1373 LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
1374 DWORD cbBufSize,
1375 LPDWORD pcbBytesNeeded)
1376 {
1377 DPRINT1("QueryServiceLockStatusA is unimplemented\n");
1378 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1379 return FALSE;
1380 }
1381
1382
1383 /**********************************************************************
1384 * QueryServiceLockStatusW
1385 *
1386 * @unimplemented
1387 */
1388 BOOL
1389 STDCALL
1390 QueryServiceLockStatusW(
1391 SC_HANDLE hSCManager,
1392 LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
1393 DWORD cbBufSize,
1394 LPDWORD pcbBytesNeeded)
1395 {
1396 DPRINT1("QueryServiceLockStatusW is unimplemented\n");
1397 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1398 return FALSE;
1399 }
1400
1401
1402 /**********************************************************************
1403 * QueryServiceObjectSecurity
1404 *
1405 * @implemented
1406 */
1407 BOOL STDCALL
1408 QueryServiceObjectSecurity(SC_HANDLE hService,
1409 SECURITY_INFORMATION dwSecurityInformation,
1410 PSECURITY_DESCRIPTOR lpSecurityDescriptor,
1411 DWORD cbBufSize,
1412 LPDWORD pcbBytesNeeded)
1413 {
1414 DWORD dwError;
1415
1416 DPRINT("QueryServiceObjectSecurity(%p, %lu, %p)\n",
1417 hService, dwSecurityInformation, lpSecurityDescriptor);
1418
1419 HandleBind();
1420
1421 /* Call to services.exe using RPC */
1422 dwError = ScmrQueryServiceObjectSecurity(BindingHandle,
1423 (unsigned int)hService,
1424 dwSecurityInformation,
1425 (unsigned char *)lpSecurityDescriptor,
1426 cbBufSize,
1427 pcbBytesNeeded);
1428 if (dwError != ERROR_SUCCESS)
1429 {
1430 DPRINT1("QueryServiceObjectSecurity() failed (Error %lu)\n", dwError);
1431 SetLastError(dwError);
1432 return FALSE;
1433 }
1434
1435 return TRUE;
1436 }
1437
1438
1439 /**********************************************************************
1440 * QueryServiceStatus
1441 *
1442 * @implemented
1443 */
1444 BOOL STDCALL
1445 QueryServiceStatus(SC_HANDLE hService,
1446 LPSERVICE_STATUS lpServiceStatus)
1447 {
1448 DWORD dwError;
1449
1450 DPRINT("QueryServiceStatus(%p, %p)\n",
1451 hService, lpServiceStatus);
1452
1453 HandleBind();
1454
1455 /* Call to services.exe using RPC */
1456 dwError = ScmrQueryServiceStatus(BindingHandle,
1457 (unsigned int)hService,
1458 lpServiceStatus);
1459 if (dwError != ERROR_SUCCESS)
1460 {
1461 DPRINT1("ScmrQueryServiceStatus() failed (Error %lu)\n", dwError);
1462 SetLastError(dwError);
1463 return FALSE;
1464 }
1465
1466 return TRUE;
1467 }
1468
1469
1470 /**********************************************************************
1471 * QueryServiceStatusEx
1472 *
1473 * @implemented
1474 */
1475 BOOL STDCALL
1476 QueryServiceStatusEx(SC_HANDLE hService,
1477 SC_STATUS_TYPE InfoLevel,
1478 LPBYTE lpBuffer,
1479 DWORD cbBufSize,
1480 LPDWORD pcbBytesNeeded)
1481 {
1482 DWORD dwError;
1483
1484 DPRINT("QueryServiceStatusEx() called\n");
1485
1486 HandleBind();
1487
1488 /* Call to services.exe using RPC */
1489 dwError = ScmrQueryServiceStatusEx(BindingHandle,
1490 (unsigned int)hService,
1491 InfoLevel,
1492 lpBuffer,
1493 cbBufSize,
1494 pcbBytesNeeded);
1495 if (dwError != ERROR_SUCCESS)
1496 {
1497 DPRINT("ScmrQueryServiceStatusEx() failed (Error %lu)\n", dwError);
1498 SetLastError(dwError);
1499 return FALSE;
1500 }
1501
1502 return TRUE;
1503 }
1504
1505
1506 /**********************************************************************
1507 * SetServiceObjectSecurity
1508 *
1509 * @implemented
1510 */
1511 BOOL STDCALL
1512 SetServiceObjectSecurity(SC_HANDLE hService,
1513 SECURITY_INFORMATION dwSecurityInformation,
1514 PSECURITY_DESCRIPTOR lpSecurityDescriptor)
1515 {
1516 PSECURITY_DESCRIPTOR SelfRelativeSD = NULL;
1517 ULONG Length;
1518 NTSTATUS Status;
1519 DWORD dwError;
1520
1521 Length = 0;
1522 Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
1523 SelfRelativeSD,
1524 &Length);
1525 if (Status != STATUS_BUFFER_TOO_SMALL)
1526 {
1527 SetLastError(ERROR_INVALID_PARAMETER);
1528 return FALSE;
1529 }
1530
1531 SelfRelativeSD = HeapAlloc(GetProcessHeap(), 0, Length);
1532 if (SelfRelativeSD == NULL)
1533 {
1534 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1535 return FALSE;
1536 }
1537
1538 Status = RtlMakeSelfRelativeSD(lpSecurityDescriptor,
1539 SelfRelativeSD,
1540 &Length);
1541 if (!NT_SUCCESS(Status))
1542 {
1543 HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
1544 SetLastError(RtlNtStatusToDosError(Status));
1545 return FALSE;
1546 }
1547
1548 HandleBind();
1549
1550 /* Call to services.exe using RPC */
1551 dwError = ScmrSetServiceObjectSecurity(BindingHandle,
1552 (unsigned int)hService,
1553 dwSecurityInformation,
1554 (unsigned char *)SelfRelativeSD,
1555 Length);
1556
1557 HeapFree(GetProcessHeap(), 0, SelfRelativeSD);
1558
1559 if (dwError != ERROR_SUCCESS)
1560 {
1561 DPRINT1("ScmrServiceObjectSecurity() failed (Error %lu)\n", dwError);
1562 SetLastError(dwError);
1563 return FALSE;
1564 }
1565
1566 return TRUE;
1567 }
1568
1569
1570 /**********************************************************************
1571 * StartServiceA
1572 *
1573 * @unimplemented
1574 */
1575 BOOL
1576 STDCALL
1577 StartServiceA(
1578 SC_HANDLE hService,
1579 DWORD dwNumServiceArgs,
1580 LPCSTR *lpServiceArgVectors)
1581 {
1582 DPRINT1("StartServiceA is unimplemented\n");
1583 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1584 return FALSE;
1585 }
1586
1587
1588 /**********************************************************************
1589 * StartServiceW
1590 *
1591 * @unimplemented
1592 */
1593 BOOL
1594 STDCALL
1595 StartServiceW(
1596 SC_HANDLE hService,
1597 DWORD dwNumServiceArgs,
1598 LPCWSTR *lpServiceArgVectors)
1599 {
1600 #if 0
1601 DWORD dwError;
1602
1603 DPRINT("StartServiceW()\n");
1604
1605 HandleBind();
1606
1607 /* Call to services.exe using RPC */
1608 dwError = ScmrStartServiceW(BindingHandle,
1609 dwNumServiceArgs,
1610 lpServiceArgVectors);
1611 if (dwError != ERROR_SUCCESS)
1612 {
1613 DPRINT1("ScmrStartServiceW() failed (Error %lu)\n", dwError);
1614 SetLastError(dwError);
1615 return FALSE;
1616 }
1617
1618 return TRUE;
1619 #endif
1620 DPRINT1("StartServiceW is unimplemented, but returns success...\n");
1621 //SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1622 //return FALSE;
1623 return TRUE;
1624 }
1625
1626
1627 /**********************************************************************
1628 * UnlockServiceDatabase
1629 *
1630 * @implemented
1631 */
1632 BOOL STDCALL
1633 UnlockServiceDatabase(SC_LOCK ScLock)
1634 {
1635 DWORD dwError;
1636
1637 DPRINT("UnlockServiceDatabase(%x)\n", ScLock);
1638
1639 HandleBind();
1640
1641 /* Call to services.exe using RPC */
1642 dwError = ScmrUnlockServiceDatabase(BindingHandle,
1643 (unsigned int)ScLock);
1644 if (dwError != ERROR_SUCCESS)
1645 {
1646 DPRINT1("ScmrUnlockServiceDatabase() failed (Error %lu)\n", dwError);
1647 SetLastError(dwError);
1648 return FALSE;
1649 }
1650
1651 return TRUE;
1652 }
1653
1654
1655 /**********************************************************************
1656 * NotifyBootConfigStatus
1657 *
1658 * @implemented
1659 */
1660 BOOL STDCALL
1661 NotifyBootConfigStatus(BOOL BootAcceptable)
1662 {
1663 DWORD dwError;
1664
1665 DPRINT1("NotifyBootConfigStatus()\n");
1666
1667 HandleBind();
1668
1669 /* Call to services.exe using RPC */
1670 dwError = ScmrNotifyBootConfigStatus(BindingHandle,
1671 BootAcceptable);
1672 if (dwError != ERROR_SUCCESS)
1673 {
1674 DPRINT1("NotifyBootConfigStatus() failed (Error %lu)\n", dwError);
1675 SetLastError(dwError);
1676 return FALSE;
1677 }
1678
1679 return TRUE;
1680 }
1681
1682
1683 void __RPC_FAR * __RPC_USER midl_user_allocate(size_t len)
1684 {
1685 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
1686 }
1687
1688
1689 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
1690 {
1691 HeapFree(GetProcessHeap(), 0, ptr);
1692 }
1693
1694 /* EOF */