xref: /reactos/dll/win32/advapi32/service/sctrl.c (revision 7abc8be1) 
1 /*
2  * PROJECT:     ReactOS advapi32
3  * LICENSE:     GPL - See COPYING in the top level directory
4  * FILE:        dll/win32/advapi32/service/sctrl.c
5  * PURPOSE:     Service control manager functions
6  * COPYRIGHT:   Copyright 1999 Emanuele Aliberti
7  *              Copyright 2007 Ged Murphy <gedmurphy@reactos.org>
8  *                             Gregor Brunmar <gregor.brunmar@home.se>
9  */
10 
11 
12 /* INCLUDES ******************************************************************/
13 
14 #include <advapi32.h>
15 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
16 
17 
18 /* TYPES *********************************************************************/
19 
20 typedef struct _SERVICE_THREAD_PARAMSA
21 {
22     LPSERVICE_MAIN_FUNCTIONA lpServiceMain;
23     DWORD dwArgCount;
24     LPSTR *lpArgVector;
25 } SERVICE_THREAD_PARAMSA, *PSERVICE_THREAD_PARAMSA;
26 
27 
28 typedef struct _SERVICE_THREAD_PARAMSW
29 {
30     LPSERVICE_MAIN_FUNCTIONW lpServiceMain;
31     DWORD dwArgCount;
32     LPWSTR *lpArgVector;
33 } SERVICE_THREAD_PARAMSW, *PSERVICE_THREAD_PARAMSW;
34 
35 
36 typedef struct _ACTIVE_SERVICE
37 {
38     SERVICE_STATUS_HANDLE hServiceStatus;
39     UNICODE_STRING ServiceName;
40     union
41     {
42         LPSERVICE_MAIN_FUNCTIONA A;
43         LPSERVICE_MAIN_FUNCTIONW W;
44     } ServiceMain;
45     LPHANDLER_FUNCTION HandlerFunction;
46     LPHANDLER_FUNCTION_EX HandlerFunctionEx;
47     LPVOID HandlerContext;
48     BOOL bUnicode;
49     BOOL bOwnProcess;
50 } ACTIVE_SERVICE, *PACTIVE_SERVICE;
51 
52 
53 /* GLOBALS *******************************************************************/
54 
55 static DWORD dwActiveServiceCount = 0;
56 static PACTIVE_SERVICE lpActiveServices = NULL;
57 static handle_t hStatusBinding = NULL;
58 
59 
60 /* FUNCTIONS *****************************************************************/
61 
62 handle_t __RPC_USER
63 RPC_SERVICE_STATUS_HANDLE_bind(RPC_SERVICE_STATUS_HANDLE hServiceStatus)
64 {
65     return hStatusBinding;
66 }
67 
68 
69 void __RPC_USER
70 RPC_SERVICE_STATUS_HANDLE_unbind(RPC_SERVICE_STATUS_HANDLE hServiceStatus,
71                                  handle_t hBinding)
72 {
73 }
74 
75 
76 static RPC_STATUS
77 ScCreateStatusBinding(VOID)
78 {
79     LPWSTR pszStringBinding;
80     RPC_STATUS status;
81 
82     TRACE("ScCreateStatusBinding()\n");
83 
84     status = RpcStringBindingComposeW(NULL,
85                                       L"ncacn_np",
86                                       NULL,
87                                       L"\\pipe\\ntsvcs",
88                                       NULL,
89                                       &pszStringBinding);
90     if (status != RPC_S_OK)
91     {
92         ERR("RpcStringBindingCompose returned 0x%x\n", status);
93         return status;
94     }
95 
96     /* Set the binding handle that will be used to bind to the server. */
97     status = RpcBindingFromStringBindingW(pszStringBinding,
98                                           &hStatusBinding);
99     if (status != RPC_S_OK)
100     {
101         ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
102     }
103 
104     status = RpcStringFreeW(&pszStringBinding);
105     if (status != RPC_S_OK)
106     {
107         ERR("RpcStringFree returned 0x%x\n", status);
108     }
109 
110     return status;
111 }
112 
113 
114 static RPC_STATUS
115 ScDestroyStatusBinding(VOID)
116 {
117     RPC_STATUS status;
118 
119     TRACE("ScDestroyStatusBinding()\n");
120 
121     if (hStatusBinding == NULL)
122         return RPC_S_OK;
123 
124     status = RpcBindingFree(&hStatusBinding);
125     if (status != RPC_S_OK)
126     {
127         ERR("RpcBindingFree returned 0x%x\n", status);
128     }
129     else
130     {
131         hStatusBinding = NULL;
132     }
133 
134     return status;
135 }
136 
137 
138 static PACTIVE_SERVICE
139 ScLookupServiceByServiceName(LPCWSTR lpServiceName)
140 {
141     DWORD i;
142 
143     TRACE("ScLookupServiceByServiceName(%S)\n",
144           lpServiceName);
145 
146     if (lpActiveServices[0].bOwnProcess)
147         return &lpActiveServices[0];
148 
149     for (i = 0; i < dwActiveServiceCount; i++)
150     {
151         TRACE("Checking %S\n", lpActiveServices[i].ServiceName.Buffer);
152         if (_wcsicmp(lpActiveServices[i].ServiceName.Buffer, lpServiceName) == 0)
153         {
154             TRACE("Found!\n");
155             return &lpActiveServices[i];
156         }
157     }
158 
159     TRACE("No service found!\n");
160     return NULL;
161 }
162 
163 
164 static DWORD WINAPI
165 ScServiceMainStubA(LPVOID Context)
166 {
167     PSERVICE_THREAD_PARAMSA ThreadParams = Context;
168 
169     TRACE("ScServiceMainStubA(%p)\n", Context);
170 
171     /* Call the main service routine and free the arguments vector */
172     (ThreadParams->lpServiceMain)(ThreadParams->dwArgCount,
173                                   ThreadParams->lpArgVector);
174 
175     if (ThreadParams->lpArgVector != NULL)
176     {
177         HeapFree(GetProcessHeap(), 0, ThreadParams->lpArgVector);
178     }
179     HeapFree(GetProcessHeap(), 0, ThreadParams);
180 
181     return ERROR_SUCCESS;
182 }
183 
184 
185 static DWORD WINAPI
186 ScServiceMainStubW(LPVOID Context)
187 {
188     PSERVICE_THREAD_PARAMSW ThreadParams = Context;
189 
190     TRACE("ScServiceMainStubW(%p)\n", Context);
191 
192     /* Call the main service routine and free the arguments vector */
193     (ThreadParams->lpServiceMain)(ThreadParams->dwArgCount,
194                                   ThreadParams->lpArgVector);
195 
196     if (ThreadParams->lpArgVector != NULL)
197     {
198         HeapFree(GetProcessHeap(), 0, ThreadParams->lpArgVector);
199     }
200     HeapFree(GetProcessHeap(), 0, ThreadParams);
201 
202     return ERROR_SUCCESS;
203 }
204 
205 
206 static DWORD
207 ScConnectControlPipe(HANDLE *hPipe)
208 {
209     DWORD dwBytesWritten;
210     DWORD dwState;
211     DWORD dwServiceCurrent = 0;
212     NTSTATUS Status;
213     WCHAR NtControlPipeName[MAX_PATH + 1];
214     RTL_QUERY_REGISTRY_TABLE QueryTable[2];
215     DWORD dwProcessId;
216 
217     TRACE("ScConnectControlPipe(%p)\n",
218           hPipe);
219 
220     /* Get the service number and create the named pipe */
221     RtlZeroMemory(&QueryTable,
222                   sizeof(QueryTable));
223 
224     QueryTable[0].Name = L"";
225     QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
226     QueryTable[0].EntryContext = &dwServiceCurrent;
227 
228     Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
229                                     L"ServiceCurrent",
230                                     QueryTable,
231                                     NULL,
232                                     NULL);
233     if (!NT_SUCCESS(Status))
234     {
235         ERR("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
236         return RtlNtStatusToDosError(Status);
237     }
238 
239     swprintf(NtControlPipeName, L"\\\\.\\pipe\\net\\NtControlPipe%u", dwServiceCurrent);
240 
241     if (!WaitNamedPipeW(NtControlPipeName, 30000))
242     {
243         ERR("WaitNamedPipe(%S) failed (Error %lu)\n", NtControlPipeName, GetLastError());
244         return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT;
245     }
246 
247     *hPipe = CreateFileW(NtControlPipeName,
248                          GENERIC_READ | GENERIC_WRITE,
249                          FILE_SHARE_READ | FILE_SHARE_WRITE,
250                          NULL,
251                          OPEN_EXISTING,
252                          FILE_ATTRIBUTE_NORMAL,
253                          NULL);
254     if (*hPipe == INVALID_HANDLE_VALUE)
255     {
256         ERR("CreateFileW() failed for pipe %S (Error %lu)\n", NtControlPipeName, GetLastError());
257         return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT;
258     }
259 
260     dwState = PIPE_READMODE_MESSAGE;
261     if (!SetNamedPipeHandleState(*hPipe, &dwState, NULL, NULL))
262     {
263         CloseHandle(*hPipe);
264         *hPipe = INVALID_HANDLE_VALUE;
265         return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT;
266     }
267 
268     /* Pass the ProcessId to the SCM */
269     dwProcessId = GetCurrentProcessId();
270     WriteFile(*hPipe,
271               &dwProcessId,
272               sizeof(dwProcessId),
273               &dwBytesWritten,
274               NULL);
275 
276     TRACE("Sent Process ID %lu\n", dwProcessId);
277 
278     return ERROR_SUCCESS;
279 }
280 
281 
282 /*
283  * Ansi/Unicode argument layout of the vector passed to a service at startup,
284  * depending on the different versions of Windows considered:
285  *
286  * - XP/2003:
287  *   [argv array of pointers][parameter 1][parameter 2]...[service name]
288  *
289  * - Vista:
290  *   [argv array of pointers][align to 8 bytes]
291  *   [parameter 1][parameter 2]...[service name]
292  *
293  * - Win7/8:
294  *   [argv array of pointers][service name]
295  *   [parameter 1][align to 4 bytes][parameter 2][align to 4 bytes]...
296  *
297  * Space for parameters and service name is always enough to store
298  * both the Ansi and the Unicode versions including NULL terminator.
299  */
300 
301 static DWORD
302 ScBuildUnicodeArgsVector(PSCM_CONTROL_PACKET ControlPacket,
303                          LPDWORD lpArgCount,
304                          LPWSTR **lpArgVector)
305 {
306     PWSTR *lpVector;
307     PWSTR pszServiceName;
308     DWORD cbServiceName;
309     DWORD cbArguments;
310     DWORD cbTotal;
311     DWORD i;
312 
313     if (ControlPacket == NULL || lpArgCount == NULL || lpArgVector == NULL)
314         return ERROR_INVALID_PARAMETER;
315 
316     *lpArgCount  = 0;
317     *lpArgVector = NULL;
318 
319     /* Retrieve and count the start command line (NULL-terminated) */
320     pszServiceName = (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset);
321     cbServiceName  = lstrlenW(pszServiceName) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
322 
323     /*
324      * The total size of the argument vector is equal to the entry for
325      * the service name, plus the size of the original argument vector.
326      */
327     cbTotal = sizeof(PWSTR) + cbServiceName;
328     if (ControlPacket->dwArgumentsCount > 0)
329         cbArguments = ControlPacket->dwSize - ControlPacket->dwArgumentsOffset;
330     else
331         cbArguments = 0;
332     cbTotal += cbArguments;
333 
334     /* Allocate the new argument vector */
335     lpVector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbTotal);
336     if (lpVector == NULL)
337         return ERROR_NOT_ENOUGH_MEMORY;
338 
339     /*
340      * The first argument is reserved for the service name, which
341      * will be appended to the end of the argument string list.
342      */
343 
344     /* Copy the remaining arguments */
345     if (ControlPacket->dwArgumentsCount > 0)
346     {
347         memcpy(&lpVector[1],
348                (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwArgumentsOffset),
349                cbArguments);
350 
351         for (i = 0; i < ControlPacket->dwArgumentsCount; i++)
352         {
353             lpVector[i + 1] = (PWSTR)((ULONG_PTR)&lpVector[1] + (ULONG_PTR)lpVector[i + 1]);
354             TRACE("Unicode lpVector[%lu] = '%ls'\n", i + 1, lpVector[i + 1]);
355         }
356     }
357 
358     /* Now copy the service name */
359     lpVector[0] = (PWSTR)((ULONG_PTR)&lpVector[1] + cbArguments);
360     memcpy(lpVector[0], pszServiceName, cbServiceName);
361     TRACE("Unicode lpVector[%lu] = '%ls'\n", 0, lpVector[0]);
362 
363     *lpArgCount  = ControlPacket->dwArgumentsCount + 1;
364     *lpArgVector = lpVector;
365 
366     return ERROR_SUCCESS;
367 }
368 
369 
370 static DWORD
371 ScBuildAnsiArgsVector(PSCM_CONTROL_PACKET ControlPacket,
372                       LPDWORD lpArgCount,
373                       LPSTR **lpArgVector)
374 {
375     DWORD dwError;
376     NTSTATUS Status;
377     DWORD ArgCount, i;
378     PWSTR *lpVectorW;
379     PSTR  *lpVectorA;
380     UNICODE_STRING UnicodeString;
381     ANSI_STRING AnsiString;
382 
383     if (ControlPacket == NULL || lpArgCount == NULL || lpArgVector == NULL)
384         return ERROR_INVALID_PARAMETER;
385 
386     *lpArgCount  = 0;
387     *lpArgVector = NULL;
388 
389     /* Build the UNICODE arguments vector */
390     dwError = ScBuildUnicodeArgsVector(ControlPacket, &ArgCount, &lpVectorW);
391     if (dwError != ERROR_SUCCESS)
392         return dwError;
393 
394     /* Convert the vector to ANSI in place */
395     lpVectorA = (PSTR*)lpVectorW;
396     for (i = 0; i < ArgCount; i++)
397     {
398         RtlInitUnicodeString(&UnicodeString, lpVectorW[i]);
399         RtlInitEmptyAnsiString(&AnsiString, lpVectorA[i], UnicodeString.MaximumLength);
400         Status = RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
401         if (!NT_SUCCESS(Status))
402         {
403             /* Failed to convert to ANSI; free the allocated vector and return */
404             dwError = RtlNtStatusToDosError(Status);
405             HeapFree(GetProcessHeap(), 0, lpVectorW);
406             return dwError;
407         }
408 
409         /* NULL-terminate the string */
410         AnsiString.Buffer[AnsiString.Length / sizeof(CHAR)] = ANSI_NULL;
411 
412         TRACE("Ansi lpVector[%lu] = '%s'\n", i, lpVectorA[i]);
413     }
414 
415     *lpArgCount  = ArgCount;
416     *lpArgVector = lpVectorA;
417 
418     return ERROR_SUCCESS;
419 }
420 
421 
422 static DWORD
423 ScStartService(PACTIVE_SERVICE lpService,
424                PSCM_CONTROL_PACKET ControlPacket)
425 {
426     HANDLE ThreadHandle;
427     DWORD ThreadId;
428     DWORD dwError;
429     PSERVICE_THREAD_PARAMSA ThreadParamsA;
430     PSERVICE_THREAD_PARAMSW ThreadParamsW;
431 
432     TRACE("ScStartService(%p %p)\n",
433           lpService, ControlPacket);
434 
435     if (lpService == NULL || ControlPacket == NULL)
436         return ERROR_INVALID_PARAMETER;
437 
438     TRACE("Size: %lu\n", ControlPacket->dwSize);
439     TRACE("Service: %S\n", (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset));
440 
441     /* Set the service status handle */
442     lpService->hServiceStatus = ControlPacket->hServiceStatus;
443 
444     /* Build the arguments vector */
445     if (lpService->bUnicode != FALSE)
446     {
447         ThreadParamsW = HeapAlloc(GetProcessHeap(), 0, sizeof(*ThreadParamsW));
448         if (ThreadParamsW == NULL)
449             return ERROR_NOT_ENOUGH_MEMORY;
450         dwError = ScBuildUnicodeArgsVector(ControlPacket,
451                                            &ThreadParamsW->dwArgCount,
452                                            &ThreadParamsW->lpArgVector);
453         if (dwError != ERROR_SUCCESS)
454         {
455             HeapFree(GetProcessHeap(), 0, ThreadParamsW);
456             return dwError;
457         }
458         ThreadParamsW->lpServiceMain = lpService->ServiceMain.W;
459         ThreadHandle = CreateThread(NULL,
460                                     0,
461                                     ScServiceMainStubW,
462                                     ThreadParamsW,
463                                     0,
464                                     &ThreadId);
465         if (ThreadHandle == NULL)
466         {
467             if (ThreadParamsW->lpArgVector != NULL)
468             {
469                 HeapFree(GetProcessHeap(), 0, ThreadParamsW->lpArgVector);
470             }
471             HeapFree(GetProcessHeap(), 0, ThreadParamsW);
472 
473             return ERROR_SERVICE_NO_THREAD;
474         }
475 
476         CloseHandle(ThreadHandle);
477     }
478     else
479     {
480         ThreadParamsA = HeapAlloc(GetProcessHeap(), 0, sizeof(*ThreadParamsA));
481         if (ThreadParamsA == NULL)
482             return ERROR_NOT_ENOUGH_MEMORY;
483         dwError = ScBuildAnsiArgsVector(ControlPacket,
484                                         &ThreadParamsA->dwArgCount,
485                                         &ThreadParamsA->lpArgVector);
486         if (dwError != ERROR_SUCCESS)
487         {
488             HeapFree(GetProcessHeap(), 0, ThreadParamsA);
489             return dwError;
490         }
491         ThreadParamsA->lpServiceMain = lpService->ServiceMain.A;
492         ThreadHandle = CreateThread(NULL,
493                                     0,
494                                     ScServiceMainStubA,
495                                     ThreadParamsA,
496                                     0,
497                                     &ThreadId);
498         if (ThreadHandle == NULL)
499         {
500             if (ThreadParamsA->lpArgVector != NULL)
501             {
502                 HeapFree(GetProcessHeap(), 0, ThreadParamsA->lpArgVector);
503             }
504             HeapFree(GetProcessHeap(), 0, ThreadParamsA);
505 
506             return ERROR_SERVICE_NO_THREAD;
507         }
508 
509         CloseHandle(ThreadHandle);
510     }
511 
512     return ERROR_SUCCESS;
513 }
514 
515 
516 static DWORD
517 ScControlService(PACTIVE_SERVICE lpService,
518                  PSCM_CONTROL_PACKET ControlPacket)
519 {
520     DWORD dwError = ERROR_SUCCESS;
521 
522     TRACE("ScControlService(%p %p)\n",
523           lpService, ControlPacket);
524 
525     if (lpService == NULL || ControlPacket == NULL)
526         return ERROR_INVALID_PARAMETER;
527 
528     TRACE("Size: %lu\n", ControlPacket->dwSize);
529     TRACE("Service: %S\n", (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset));
530 
531     if (lpService->HandlerFunction)
532     {
533         _SEH2_TRY
534         {
535             (lpService->HandlerFunction)(ControlPacket->dwControl);
536         }
537         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
538         {
539             dwError = ERROR_EXCEPTION_IN_SERVICE;
540         }
541         _SEH2_END;
542     }
543     else if (lpService->HandlerFunctionEx)
544     {
545         _SEH2_TRY
546         {
547             /* FIXME: Send correct 2nd and 3rd parameters */
548             (lpService->HandlerFunctionEx)(ControlPacket->dwControl,
549                                            0, NULL,
550                                            lpService->HandlerContext);
551         }
552         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
553         {
554             dwError = ERROR_EXCEPTION_IN_SERVICE;
555         }
556         _SEH2_END;
557     }
558     else
559     {
560         dwError = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
561     }
562 
563     TRACE("ScControlService() done (Error %lu)\n", dwError);
564 
565     return dwError;
566 }
567 
568 
569 static BOOL
570 ScServiceDispatcher(HANDLE hPipe,
571                     PSCM_CONTROL_PACKET ControlPacket,
572                     DWORD dwBufferSize)
573 {
574     DWORD Count;
575     BOOL bResult;
576     BOOL bRunning = TRUE;
577     LPWSTR lpServiceName;
578     PACTIVE_SERVICE lpService;
579     SCM_REPLY_PACKET ReplyPacket;
580     DWORD dwError;
581 
582     TRACE("ScServiceDispatcher(%p %p %lu)\n",
583           hPipe, ControlPacket, dwBufferSize);
584 
585     if (ControlPacket == NULL || dwBufferSize < sizeof(SCM_CONTROL_PACKET))
586         return FALSE;
587 
588     while (bRunning)
589     {
590         /* Read command from the control pipe */
591         bResult = ReadFile(hPipe,
592                            ControlPacket,
593                            dwBufferSize,
594                            &Count,
595                            NULL);
596         if (bResult == FALSE)
597         {
598             ERR("Pipe read failed (Error: %lu)\n", GetLastError());
599             return FALSE;
600         }
601 
602         lpServiceName = (LPWSTR)((PBYTE)ControlPacket + ControlPacket->dwServiceNameOffset);
603         TRACE("Service: %S\n", lpServiceName);
604 
605         if ((ControlPacket->dwControl == SERVICE_CONTROL_STOP) &&
606             (lpServiceName[0] == UNICODE_NULL))
607         {
608             TRACE("Stop dispatcher thread\n");
609             bRunning = FALSE;
610             dwError = ERROR_SUCCESS;
611         }
612         else
613         {
614             if (ControlPacket->dwControl == SERVICE_CONTROL_START_OWN)
615                 lpActiveServices[0].bOwnProcess = TRUE;
616 
617             lpService = ScLookupServiceByServiceName(lpServiceName);
618             if (lpService != NULL)
619             {
620                 /* Execute command */
621                 switch (ControlPacket->dwControl)
622                 {
623                     case SERVICE_CONTROL_START_SHARE:
624                     case SERVICE_CONTROL_START_OWN:
625                         TRACE("Start command - received SERVICE_CONTROL_START\n");
626                         dwError = ScStartService(lpService, ControlPacket);
627                         break;
628 
629                     case SERVICE_CONTROL_STOP:
630                         TRACE("Stop command - received SERVICE_CONTROL_STOP\n");
631                         dwError = ScControlService(lpService, ControlPacket);
632                         break;
633 
634                     default:
635                         TRACE("Command %lu received", ControlPacket->dwControl);
636                         dwError = ScControlService(lpService, ControlPacket);
637                         break;
638                 }
639             }
640             else
641             {
642                 dwError = ERROR_SERVICE_NOT_IN_EXE;
643             }
644         }
645 
646         ReplyPacket.dwError = dwError;
647 
648         /* Send the reply packet */
649         bResult = WriteFile(hPipe,
650                             &ReplyPacket,
651                             sizeof(ReplyPacket),
652                             &Count,
653                             NULL);
654         if (bResult == FALSE)
655         {
656             ERR("Pipe write failed (Error: %lu)\n", GetLastError());
657             return FALSE;
658         }
659     }
660 
661     return TRUE;
662 }
663 
664 
665 /**********************************************************************
666  *  RegisterServiceCtrlHandlerA
667  *
668  * @implemented
669  */
670 SERVICE_STATUS_HANDLE WINAPI
671 RegisterServiceCtrlHandlerA(LPCSTR lpServiceName,
672                             LPHANDLER_FUNCTION lpHandlerProc)
673 {
674     ANSI_STRING ServiceNameA;
675     UNICODE_STRING ServiceNameU;
676     SERVICE_STATUS_HANDLE hServiceStatus;
677 
678     TRACE("RegisterServiceCtrlHandlerA(%s %p)\n",
679           debugstr_a(lpServiceName), lpHandlerProc);
680 
681     RtlInitAnsiString(&ServiceNameA, lpServiceName);
682     if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
683     {
684         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
685         return NULL;
686     }
687 
688     hServiceStatus = RegisterServiceCtrlHandlerW(ServiceNameU.Buffer,
689                                                  lpHandlerProc);
690 
691     RtlFreeUnicodeString(&ServiceNameU);
692 
693     return hServiceStatus;
694 }
695 
696 
697 /**********************************************************************
698  *  RegisterServiceCtrlHandlerW
699  *
700  * @implemented
701  */
702 SERVICE_STATUS_HANDLE WINAPI
703 RegisterServiceCtrlHandlerW(LPCWSTR lpServiceName,
704                             LPHANDLER_FUNCTION lpHandlerProc)
705 {
706     PACTIVE_SERVICE Service;
707 
708     TRACE("RegisterServiceCtrlHandlerW(%s %p)\n",
709           debugstr_w(lpServiceName), lpHandlerProc);
710 
711     Service = ScLookupServiceByServiceName(lpServiceName);
712     if (Service == NULL)
713     {
714         SetLastError(ERROR_SERVICE_NOT_IN_EXE);
715         return NULL;
716     }
717 
718     if (!lpHandlerProc)
719     {
720         SetLastError(ERROR_INVALID_PARAMETER);
721         return NULL;
722     }
723 
724     Service->HandlerFunction = lpHandlerProc;
725     Service->HandlerFunctionEx = NULL;
726 
727     TRACE("RegisterServiceCtrlHandler returning %p\n", Service->hServiceStatus);
728 
729     return Service->hServiceStatus;
730 }
731 
732 
733 /**********************************************************************
734  *  RegisterServiceCtrlHandlerExA
735  *
736  * @implemented
737  */
738 SERVICE_STATUS_HANDLE WINAPI
739 RegisterServiceCtrlHandlerExA(LPCSTR lpServiceName,
740                               LPHANDLER_FUNCTION_EX lpHandlerProc,
741                               LPVOID lpContext)
742 {
743     ANSI_STRING ServiceNameA;
744     UNICODE_STRING ServiceNameU;
745     SERVICE_STATUS_HANDLE hServiceStatus;
746 
747     TRACE("RegisterServiceCtrlHandlerExA(%s %p %p)\n",
748           debugstr_a(lpServiceName), lpHandlerProc, lpContext);
749 
750     RtlInitAnsiString(&ServiceNameA, lpServiceName);
751     if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
752     {
753         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
754         return NULL;
755     }
756 
757     hServiceStatus = RegisterServiceCtrlHandlerExW(ServiceNameU.Buffer,
758                                                    lpHandlerProc,
759                                                    lpContext);
760 
761     RtlFreeUnicodeString(&ServiceNameU);
762 
763     return hServiceStatus;
764 }
765 
766 
767 /**********************************************************************
768  *  RegisterServiceCtrlHandlerExW
769  *
770  * @implemented
771  */
772 SERVICE_STATUS_HANDLE WINAPI
773 RegisterServiceCtrlHandlerExW(LPCWSTR lpServiceName,
774                               LPHANDLER_FUNCTION_EX lpHandlerProc,
775                               LPVOID lpContext)
776 {
777     PACTIVE_SERVICE Service;
778 
779     TRACE("RegisterServiceCtrlHandlerExW(%s %p %p)\n",
780           debugstr_w(lpServiceName), lpHandlerProc, lpContext);
781 
782     Service = ScLookupServiceByServiceName(lpServiceName);
783     if (Service == NULL)
784     {
785         SetLastError(ERROR_SERVICE_NOT_IN_EXE);
786         return NULL;
787     }
788 
789     if (!lpHandlerProc)
790     {
791         SetLastError(ERROR_INVALID_PARAMETER);
792         return NULL;
793     }
794 
795     Service->HandlerFunction = NULL;
796     Service->HandlerFunctionEx = lpHandlerProc;
797     Service->HandlerContext = lpContext;
798 
799     TRACE("RegisterServiceCtrlHandlerEx returning %p\n", Service->hServiceStatus);
800 
801     return Service->hServiceStatus;
802 }
803 
804 
805 /**********************************************************************
806  *  I_ScIsSecurityProcess
807  *
808  * Undocumented
809  *
810  * @unimplemented
811  */
812 VOID
813 WINAPI
814 I_ScIsSecurityProcess(VOID)
815 {
816     FIXME("I_ScIsSecurityProcess()\n");
817 }
818 
819 
820 /**********************************************************************
821  *  I_ScPnPGetServiceName
822  *
823  * Undocumented
824  *
825  * @implemented
826  */
827 DWORD
828 WINAPI
829 I_ScPnPGetServiceName(IN SERVICE_STATUS_HANDLE hServiceStatus,
830                       OUT LPWSTR lpServiceName,
831                       IN DWORD cchServiceName)
832 {
833     DWORD i;
834 
835     TRACE("I_ScPnPGetServiceName(%lu %p %lu)\n",
836           hServiceStatus, lpServiceName, cchServiceName);
837 
838     for (i = 0; i < dwActiveServiceCount; i++)
839     {
840         if (lpActiveServices[i].hServiceStatus == hServiceStatus)
841         {
842             wcscpy(lpServiceName, lpActiveServices[i].ServiceName.Buffer);
843             return ERROR_SUCCESS;
844         }
845     }
846 
847     return ERROR_SERVICE_NOT_IN_EXE;
848 }
849 
850 
851 /**********************************************************************
852  *  I_ScSetServiceBitsA
853  *
854  * Undocumented
855  *
856  * @implemented
857  */
858 BOOL WINAPI
859 I_ScSetServiceBitsA(SERVICE_STATUS_HANDLE hServiceStatus,
860                     DWORD dwServiceBits,
861                     BOOL bSetBitsOn,
862                     BOOL bUpdateImmediately,
863                     LPSTR lpString)
864 {
865     BOOL bResult;
866 
867     TRACE("I_ScSetServiceBitsA(%lu %lx %u %u %s)\n",
868           hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately,
869           debugstr_a(lpString));
870 
871     RpcTryExcept
872     {
873         bResult = RI_ScSetServiceBitsA((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
874                                        dwServiceBits,
875                                        bSetBitsOn,
876                                        bUpdateImmediately,
877                                        lpString);
878     }
879     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
880     {
881         SetLastError(ScmRpcStatusToWinError(RpcExceptionCode()));
882         bResult = FALSE;
883     }
884     RpcEndExcept;
885 
886     return bResult;
887 }
888 
889 
890 /**********************************************************************
891  *  I_ScSetServiceBitsW
892  *
893  * Undocumented
894  *
895  * @implemented
896  */
897 BOOL WINAPI
898 I_ScSetServiceBitsW(SERVICE_STATUS_HANDLE hServiceStatus,
899                     DWORD dwServiceBits,
900                     BOOL bSetBitsOn,
901                     BOOL bUpdateImmediately,
902                     LPWSTR lpString)
903 {
904     BOOL bResult;
905 
906     TRACE("I_ScSetServiceBitsW(%lu %lx %u %u %s)\n",
907           hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately,
908           debugstr_w(lpString));
909 
910     RpcTryExcept
911     {
912         bResult = RI_ScSetServiceBitsW((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
913                                        dwServiceBits,
914                                        bSetBitsOn,
915                                        bUpdateImmediately,
916                                        lpString);
917     }
918     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
919     {
920         SetLastError(ScmRpcStatusToWinError(RpcExceptionCode()));
921         bResult = FALSE;
922     }
923     RpcEndExcept;
924 
925     return bResult;
926 }
927 
928 
929 /**********************************************************************
930  *  SetServiceBits
931  *
932  * @implemented
933  */
934 BOOL WINAPI
935 SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus,
936                DWORD dwServiceBits,
937                BOOL bSetBitsOn,
938                BOOL bUpdateImmediately)
939 {
940     TRACE("SetServiceBits(%lu %lx %u %u)\n",
941           hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately);
942 
943     return I_ScSetServiceBitsW(hServiceStatus,
944                                dwServiceBits,
945                                bSetBitsOn,
946                                bUpdateImmediately,
947                                NULL);
948 }
949 
950 
951 /**********************************************************************
952  *  SetServiceStatus
953  *
954  * @implemented
955  */
956 BOOL WINAPI
957 SetServiceStatus(SERVICE_STATUS_HANDLE hServiceStatus,
958                  LPSERVICE_STATUS lpServiceStatus)
959 {
960     DWORD dwError;
961 
962     TRACE("SetServiceStatus(%lu %p)\n",
963           hServiceStatus, lpServiceStatus);
964 
965     RpcTryExcept
966     {
967         dwError = RSetServiceStatus((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
968                                     lpServiceStatus);
969     }
970     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
971     {
972         dwError = ScmRpcStatusToWinError(RpcExceptionCode());
973     }
974     RpcEndExcept;
975 
976     if (dwError != ERROR_SUCCESS)
977     {
978         ERR("RSetServiceStatus() failed (Error %lu)\n", dwError);
979         SetLastError(dwError);
980         return FALSE;
981     }
982 
983     TRACE("SetServiceStatus() done\n");
984 
985     return TRUE;
986 }
987 
988 
989 /**********************************************************************
990  *  StartServiceCtrlDispatcherA
991  *
992  * @implemented
993  */
994 BOOL WINAPI
995 StartServiceCtrlDispatcherA(const SERVICE_TABLE_ENTRYA *lpServiceStartTable)
996 {
997     ULONG i;
998     HANDLE hPipe;
999     DWORD dwError;
1000     PSCM_CONTROL_PACKET ControlPacket;
1001     DWORD dwBufSize;
1002     BOOL bRet = TRUE;
1003 
1004     TRACE("StartServiceCtrlDispatcherA(%p)\n",
1005           lpServiceStartTable);
1006 
1007     i = 0;
1008     while (lpServiceStartTable[i].lpServiceProc != NULL)
1009     {
1010         i++;
1011     }
1012 
1013     dwActiveServiceCount = i;
1014 
1015     /* Allocate the service table */
1016     lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
1017                                        HEAP_ZERO_MEMORY,
1018                                        dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
1019     if (lpActiveServices == NULL)
1020     {
1021         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1022         return FALSE;
1023     }
1024 
1025     /* Copy service names and start procedure */
1026     for (i = 0; i < dwActiveServiceCount; i++)
1027     {
1028         RtlCreateUnicodeStringFromAsciiz(&lpActiveServices[i].ServiceName,
1029                                          lpServiceStartTable[i].lpServiceName);
1030         lpActiveServices[i].ServiceMain.A = lpServiceStartTable[i].lpServiceProc;
1031         lpActiveServices[i].hServiceStatus = NULL;
1032         lpActiveServices[i].bUnicode = FALSE;
1033         lpActiveServices[i].bOwnProcess = FALSE;
1034     }
1035 
1036     /* Connect to the SCM */
1037     dwError = ScConnectControlPipe(&hPipe);
1038     if (dwError != ERROR_SUCCESS)
1039     {
1040         bRet = FALSE;
1041         goto done;
1042     }
1043 
1044     dwBufSize = sizeof(SCM_CONTROL_PACKET) +
1045                 (MAX_SERVICE_NAME_LENGTH + 1) * sizeof(WCHAR);
1046 
1047     ControlPacket = RtlAllocateHeap(RtlGetProcessHeap(),
1048                                     HEAP_ZERO_MEMORY,
1049                                     dwBufSize);
1050     if (ControlPacket == NULL)
1051     {
1052         dwError = ERROR_NOT_ENOUGH_MEMORY;
1053         bRet = FALSE;
1054         goto done;
1055     }
1056 
1057     ScCreateStatusBinding();
1058 
1059     /* Call the dispatcher loop */
1060     ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);
1061 
1062 
1063     ScDestroyStatusBinding();
1064 
1065     /* Close the connection */
1066     CloseHandle(hPipe);
1067 
1068     /* Free the control packet */
1069     RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);
1070 
1071 done:
1072     /* Free the service table */
1073     for (i = 0; i < dwActiveServiceCount; i++)
1074     {
1075         RtlFreeUnicodeString(&lpActiveServices[i].ServiceName);
1076     }
1077     RtlFreeHeap(RtlGetProcessHeap(), 0, lpActiveServices);
1078     lpActiveServices = NULL;
1079     dwActiveServiceCount = 0;
1080 
1081     if (!bRet)
1082         SetLastError(dwError);
1083 
1084     return bRet;
1085 }
1086 
1087 
1088 /**********************************************************************
1089  *  StartServiceCtrlDispatcherW
1090  *
1091  * @implemented
1092  */
1093 BOOL WINAPI
1094 StartServiceCtrlDispatcherW(const SERVICE_TABLE_ENTRYW *lpServiceStartTable)
1095 {
1096     ULONG i;
1097     HANDLE hPipe;
1098     DWORD dwError;
1099     PSCM_CONTROL_PACKET ControlPacket;
1100     DWORD dwBufSize;
1101     BOOL bRet = TRUE;
1102 
1103     TRACE("StartServiceCtrlDispatcherW(%p)\n",
1104           lpServiceStartTable);
1105 
1106     i = 0;
1107     while (lpServiceStartTable[i].lpServiceProc != NULL)
1108     {
1109         i++;
1110     }
1111 
1112     dwActiveServiceCount = i;
1113 
1114     /* Allocate the service table */
1115     lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
1116                                        HEAP_ZERO_MEMORY,
1117                                        dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
1118     if (lpActiveServices == NULL)
1119     {
1120         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1121         return FALSE;
1122     }
1123 
1124     /* Copy service names and start procedure */
1125     for (i = 0; i < dwActiveServiceCount; i++)
1126     {
1127         RtlCreateUnicodeString(&lpActiveServices[i].ServiceName,
1128                                lpServiceStartTable[i].lpServiceName);
1129         lpActiveServices[i].ServiceMain.W = lpServiceStartTable[i].lpServiceProc;
1130         lpActiveServices[i].hServiceStatus = NULL;
1131         lpActiveServices[i].bUnicode = TRUE;
1132         lpActiveServices[i].bOwnProcess = FALSE;
1133     }
1134 
1135     /* Connect to the SCM */
1136     dwError = ScConnectControlPipe(&hPipe);
1137     if (dwError != ERROR_SUCCESS)
1138     {
1139         bRet = FALSE;
1140         goto done;
1141     }
1142 
1143     dwBufSize = sizeof(SCM_CONTROL_PACKET) +
1144                 (MAX_SERVICE_NAME_LENGTH + 1) * sizeof(WCHAR);
1145 
1146     ControlPacket = RtlAllocateHeap(RtlGetProcessHeap(),
1147                                     HEAP_ZERO_MEMORY,
1148                                     dwBufSize);
1149     if (ControlPacket == NULL)
1150     {
1151         dwError = ERROR_NOT_ENOUGH_MEMORY;
1152         bRet = FALSE;
1153         goto done;
1154     }
1155 
1156     ScCreateStatusBinding();
1157 
1158     /* Call the dispatcher loop */
1159     ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);
1160 
1161     ScDestroyStatusBinding();
1162 
1163     /* Close the connection */
1164     CloseHandle(hPipe);
1165 
1166     /* Free the control packet */
1167     RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);
1168 
1169 done:
1170     /* Free the service table */
1171     for (i = 0; i < dwActiveServiceCount; i++)
1172     {
1173         RtlFreeUnicodeString(&lpActiveServices[i].ServiceName);
1174     }
1175     RtlFreeHeap(RtlGetProcessHeap(), 0, lpActiveServices);
1176     lpActiveServices = NULL;
1177     dwActiveServiceCount = 0;
1178 
1179     if (!bRet)
1180         SetLastError(dwError);
1181 
1182     return bRet;
1183 }
1184 
1185 /* EOF */
1186