/* INCLUDES ******************************************************************/
#include <advapi32.h>
-WINE_DEFAULT_DEBUG_CHANNEL(advapi_service);
+WINE_DEFAULT_DEBUG_CHANNEL(advapi);
/* TYPES *********************************************************************/
LPSERVICE_MAIN_FUNCTIONA lpServiceMain;
DWORD dwArgCount;
LPSTR *lpArgVector;
+ DWORD dwServiceTag;
} SERVICE_THREAD_PARAMSA, *PSERVICE_THREAD_PARAMSA;
LPSERVICE_MAIN_FUNCTIONW lpServiceMain;
DWORD dwArgCount;
LPWSTR *lpArgVector;
+ DWORD dwServiceTag;
} SERVICE_THREAD_PARAMSW, *PSERVICE_THREAD_PARAMSW;
LPVOID HandlerContext;
BOOL bUnicode;
BOOL bOwnProcess;
+ DWORD dwServiceTag;
} ACTIVE_SERVICE, *PACTIVE_SERVICE;
static DWORD dwActiveServiceCount = 0;
static PACTIVE_SERVICE lpActiveServices = NULL;
static handle_t hStatusBinding = NULL;
+static BOOL bSecurityServiceProcess = FALSE;
/* FUNCTIONS *****************************************************************/
LPWSTR pszStringBinding;
RPC_STATUS status;
- TRACE("ScCreateStatusBinding() called\n");
+ TRACE("ScCreateStatusBinding()\n");
status = RpcStringBindingComposeW(NULL,
L"ncacn_np",
{
RPC_STATUS status;
- TRACE("ScDestroyStatusBinding() called\n");
+ TRACE("ScDestroyStatusBinding()\n");
if (hStatusBinding == NULL)
return RPC_S_OK;
}
-static DWORD
-ScLookupServiceByServiceName(IN LPCWSTR lpServiceName,
- OUT PACTIVE_SERVICE* pService)
+static PACTIVE_SERVICE
+ScLookupServiceByServiceName(LPCWSTR lpServiceName)
{
DWORD i;
- TRACE("ScLookupServiceByServiceName(%S) called\n", lpServiceName);
+ TRACE("ScLookupServiceByServiceName(%S)\n",
+ lpServiceName);
if (lpActiveServices[0].bOwnProcess)
- {
- *pService = &lpActiveServices[0];
- return ERROR_SUCCESS;
- }
+ return &lpActiveServices[0];
for (i = 0; i < dwActiveServiceCount; i++)
{
if (_wcsicmp(lpActiveServices[i].ServiceName.Buffer, lpServiceName) == 0)
{
TRACE("Found!\n");
- *pService = &lpActiveServices[i];
- return ERROR_SUCCESS;
+ return &lpActiveServices[i];
}
}
TRACE("No service found!\n");
- *pService = NULL;
- return ERROR_SERVICE_NOT_IN_EXE;
+ return NULL;
}
static DWORD WINAPI
ScServiceMainStubA(LPVOID Context)
{
+ PTEB Teb;
PSERVICE_THREAD_PARAMSA ThreadParams = Context;
- TRACE("ScServiceMainStubA() called\n");
+ TRACE("ScServiceMainStubA(%p)\n", Context);
+
+ /* Set service tag */
+ Teb = NtCurrentTeb();
+ Teb->SubProcessTag = UlongToPtr(ThreadParams->dwServiceTag);
/* Call the main service routine and free the arguments vector */
(ThreadParams->lpServiceMain)(ThreadParams->dwArgCount,
ThreadParams->lpArgVector);
+ /* Reset service tag */
+ Teb->SubProcessTag = 0;
+
if (ThreadParams->lpArgVector != NULL)
{
HeapFree(GetProcessHeap(), 0, ThreadParams->lpArgVector);
static DWORD WINAPI
ScServiceMainStubW(LPVOID Context)
{
+ PTEB Teb;
PSERVICE_THREAD_PARAMSW ThreadParams = Context;
- TRACE("ScServiceMainStubW() called\n");
+ TRACE("ScServiceMainStubW(%p)\n", Context);
+
+ /* Set service tag */
+ Teb = NtCurrentTeb();
+ Teb->SubProcessTag = UlongToPtr(ThreadParams->dwServiceTag);
/* Call the main service routine and free the arguments vector */
(ThreadParams->lpServiceMain)(ThreadParams->dwArgCount,
ThreadParams->lpArgVector);
+ /* Reset service tag */
+ Teb->SubProcessTag = 0;
+
if (ThreadParams->lpArgVector != NULL)
{
HeapFree(GetProcessHeap(), 0, ThreadParams->lpArgVector);
{
DWORD dwBytesWritten;
DWORD dwState;
- DWORD dwServiceCurrent = 0;
+ DWORD dwServiceCurrent = 1;
NTSTATUS Status;
WCHAR NtControlPipeName[MAX_PATH + 1];
RTL_QUERY_REGISTRY_TABLE QueryTable[2];
DWORD dwProcessId;
+ TRACE("ScConnectControlPipe(%p)\n",
+ hPipe);
+
/* Get the service number and create the named pipe */
- RtlZeroMemory(&QueryTable,
- sizeof(QueryTable));
-
- QueryTable[0].Name = L"";
- QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
- QueryTable[0].EntryContext = &dwServiceCurrent;
-
- Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
- L"ServiceCurrent",
- QueryTable,
- NULL,
- NULL);
- if (!NT_SUCCESS(Status))
+ if (bSecurityServiceProcess == FALSE)
+ {
+ RtlZeroMemory(&QueryTable, sizeof(QueryTable));
+
+ QueryTable[0].Name = L"";
+ QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
+ QueryTable[0].EntryContext = &dwServiceCurrent;
+
+ Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
+ L"ServiceCurrent",
+ QueryTable,
+ NULL,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ ERR("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
+ return RtlNtStatusToDosError(Status);
+ }
+ }
+ else
{
- ERR("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
- return RtlNtStatusToDosError(Status);
+ dwServiceCurrent = 0;
}
swprintf(NtControlPipeName, L"\\\\.\\pipe\\net\\NtControlPipe%u", dwServiceCurrent);
+ TRACE("PipeName: %S\n", NtControlPipeName);
if (!WaitNamedPipeW(NtControlPipeName, 30000))
{
PSERVICE_THREAD_PARAMSA ThreadParamsA;
PSERVICE_THREAD_PARAMSW ThreadParamsW;
+ TRACE("ScStartService(%p %p)\n",
+ lpService, ControlPacket);
+
if (lpService == NULL || ControlPacket == NULL)
return ERROR_INVALID_PARAMETER;
- TRACE("ScStartService(Size: %lu, Service: '%S') called\n",
- ControlPacket->dwSize,
- (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset));
+ TRACE("Size: %lu\n", ControlPacket->dwSize);
+ TRACE("Service: %S\n", (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset));
/* Set the service status handle */
lpService->hServiceStatus = ControlPacket->hServiceStatus;
+ /* Set the service tag */
+ lpService->dwServiceTag = ControlPacket->dwServiceTag;
/* Build the arguments vector */
if (lpService->bUnicode != FALSE)
return dwError;
}
ThreadParamsW->lpServiceMain = lpService->ServiceMain.W;
+ ThreadParamsW->dwServiceTag = ControlPacket->dwServiceTag;
ThreadHandle = CreateThread(NULL,
0,
ScServiceMainStubW,
return dwError;
}
ThreadParamsA->lpServiceMain = lpService->ServiceMain.A;
+ ThreadParamsA->dwServiceTag = ControlPacket->dwServiceTag;
ThreadHandle = CreateThread(NULL,
0,
ScServiceMainStubA,
ScControlService(PACTIVE_SERVICE lpService,
PSCM_CONTROL_PACKET ControlPacket)
{
- DWORD dwError;
+ DWORD dwError = ERROR_SUCCESS;
+
+ TRACE("ScControlService(%p %p)\n",
+ lpService, ControlPacket);
if (lpService == NULL || ControlPacket == NULL)
return ERROR_INVALID_PARAMETER;
- TRACE("ScControlService(Size: %lu, Service: '%S') called\n",
- ControlPacket->dwSize,
- (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset));
+ TRACE("Size: %lu\n", ControlPacket->dwSize);
+ TRACE("Service: %S\n", (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset));
+
+ /* Set service tag */
+ NtCurrentTeb()->SubProcessTag = UlongToPtr(lpService->dwServiceTag);
if (lpService->HandlerFunction)
{
- (lpService->HandlerFunction)(ControlPacket->dwControl);
- dwError = ERROR_SUCCESS;
+ _SEH2_TRY
+ {
+ (lpService->HandlerFunction)(ControlPacket->dwControl);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ERROR_EXCEPTION_IN_SERVICE;
+ }
+ _SEH2_END;
}
else if (lpService->HandlerFunctionEx)
{
- /* FIXME: Send correct 2nd and 3rd parameters */
- dwError = (lpService->HandlerFunctionEx)(ControlPacket->dwControl,
- 0, NULL,
- lpService->HandlerContext);
+ _SEH2_TRY
+ {
+ /* FIXME: Send correct 2nd and 3rd parameters */
+ (lpService->HandlerFunctionEx)(ControlPacket->dwControl,
+ 0, NULL,
+ lpService->HandlerContext);
+ }
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+ {
+ dwError = ERROR_EXCEPTION_IN_SERVICE;
+ }
+ _SEH2_END;
+ }
+ else
+ {
+ dwError = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
}
- TRACE("ScControlService() done (error %lu)\n", dwError);
+ /* Reset service tag */
+ NtCurrentTeb()->SubProcessTag = 0;
+
+ TRACE("ScControlService() done (Error %lu)\n", dwError);
return dwError;
}
SCM_REPLY_PACKET ReplyPacket;
DWORD dwError;
- TRACE("ScDispatcherLoop() called\n");
+ TRACE("ScServiceDispatcher(%p %p %lu)\n",
+ hPipe, ControlPacket, dwBufferSize);
if (ControlPacket == NULL || dwBufferSize < sizeof(SCM_CONTROL_PACKET))
return FALSE;
lpServiceName = (LPWSTR)((PBYTE)ControlPacket + ControlPacket->dwServiceNameOffset);
TRACE("Service: %S\n", lpServiceName);
- if (lpServiceName[0] == UNICODE_NULL)
+ if ((ControlPacket->dwControl == SERVICE_CONTROL_STOP) &&
+ (lpServiceName[0] == UNICODE_NULL))
{
- ERR("Stop dispatcher thread\n");
+ TRACE("Stop dispatcher thread\n");
bRunning = FALSE;
dwError = ERROR_SUCCESS;
}
if (ControlPacket->dwControl == SERVICE_CONTROL_START_OWN)
lpActiveServices[0].bOwnProcess = TRUE;
- dwError = ScLookupServiceByServiceName(lpServiceName, &lpService);
- if ((dwError == ERROR_SUCCESS) && (lpService != NULL))
+ lpService = ScLookupServiceByServiceName(lpServiceName);
+ if (lpService != NULL)
{
/* Execute command */
switch (ControlPacket->dwControl)
break;
}
}
+ else
+ {
+ dwError = ERROR_SERVICE_NOT_IN_EXE;
+ }
}
ReplyPacket.dwError = dwError;
UNICODE_STRING ServiceNameU;
SERVICE_STATUS_HANDLE hServiceStatus;
+ TRACE("RegisterServiceCtrlHandlerA(%s %p)\n",
+ debugstr_a(lpServiceName), lpHandlerProc);
+
RtlInitAnsiString(&ServiceNameA, lpServiceName);
if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
{
RegisterServiceCtrlHandlerW(LPCWSTR lpServiceName,
LPHANDLER_FUNCTION lpHandlerProc)
{
- DWORD dwError;
PACTIVE_SERVICE Service;
- dwError = ScLookupServiceByServiceName(lpServiceName, &Service);
- if ((dwError != ERROR_SUCCESS) || (Service == NULL))
+ TRACE("RegisterServiceCtrlHandlerW(%s %p)\n",
+ debugstr_w(lpServiceName), lpHandlerProc);
+
+ Service = ScLookupServiceByServiceName(lpServiceName);
+ if (Service == NULL)
{
- SetLastError(dwError);
+ SetLastError(ERROR_SERVICE_NOT_IN_EXE);
return NULL;
}
return NULL;
}
- Service->HandlerFunction = lpHandlerProc;
+ Service->HandlerFunction = lpHandlerProc;
Service->HandlerFunctionEx = NULL;
- TRACE("RegisterServiceCtrlHandler returning 0x%p\n", Service->hServiceStatus);
+ TRACE("RegisterServiceCtrlHandler returning %p\n", Service->hServiceStatus);
return Service->hServiceStatus;
}
UNICODE_STRING ServiceNameU;
SERVICE_STATUS_HANDLE hServiceStatus;
+ TRACE("RegisterServiceCtrlHandlerExA(%s %p %p)\n",
+ debugstr_a(lpServiceName), lpHandlerProc, lpContext);
+
RtlInitAnsiString(&ServiceNameA, lpServiceName);
if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
{
LPHANDLER_FUNCTION_EX lpHandlerProc,
LPVOID lpContext)
{
- DWORD dwError;
PACTIVE_SERVICE Service;
- dwError = ScLookupServiceByServiceName(lpServiceName, &Service);
- if ((dwError != ERROR_SUCCESS) || (Service == NULL))
+ TRACE("RegisterServiceCtrlHandlerExW(%s %p %p)\n",
+ debugstr_w(lpServiceName), lpHandlerProc, lpContext);
+
+ Service = ScLookupServiceByServiceName(lpServiceName);
+ if (Service == NULL)
{
- SetLastError(dwError);
+ SetLastError(ERROR_SERVICE_NOT_IN_EXE);
return NULL;
}
return NULL;
}
- Service->HandlerFunction = NULL;
+ Service->HandlerFunction = NULL;
Service->HandlerFunctionEx = lpHandlerProc;
- Service->HandlerContext = lpContext;
+ Service->HandlerContext = lpContext;
- TRACE("RegisterServiceCtrlHandlerEx returning 0x%p\n", Service->hServiceStatus);
+ TRACE("RegisterServiceCtrlHandlerEx returning %p\n", Service->hServiceStatus);
return Service->hServiceStatus;
}
*
* Undocumented
*
- * @unimplemented
+ * @implemented
*/
VOID
WINAPI
I_ScIsSecurityProcess(VOID)
{
+ TRACE("I_ScIsSecurityProcess()\n");
+ bSecurityServiceProcess = TRUE;
}
{
DWORD i;
+ TRACE("I_ScPnPGetServiceName(%lu %p %lu)\n",
+ hServiceStatus, lpServiceName, cchServiceName);
+
for (i = 0; i < dwActiveServiceCount; i++)
{
if (lpActiveServices[i].hServiceStatus == hServiceStatus)
{
BOOL bResult;
+ TRACE("I_ScSetServiceBitsA(%lu %lx %u %u %s)\n",
+ hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately,
+ debugstr_a(lpString));
+
RpcTryExcept
{
bResult = RI_ScSetServiceBitsA((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
{
BOOL bResult;
+ TRACE("I_ScSetServiceBitsW(%lu %lx %u %u %s)\n",
+ hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately,
+ debugstr_w(lpString));
+
RpcTryExcept
{
bResult = RI_ScSetServiceBitsW((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
BOOL bSetBitsOn,
BOOL bUpdateImmediately)
{
+ TRACE("SetServiceBits(%lu %lx %u %u)\n",
+ hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately);
+
return I_ScSetServiceBitsW(hServiceStatus,
dwServiceBits,
bSetBitsOn,
{
DWORD dwError;
- TRACE("SetServiceStatus(hServiceStatus %lu) called\n", hServiceStatus);
+ TRACE("SetServiceStatus(%lu %p)\n",
+ hServiceStatus, lpServiceStatus);
RpcTryExcept
{
return FALSE;
}
- TRACE("SetServiceStatus() done (ret %lu)\n", dwError);
+ TRACE("SetServiceStatus() done\n");
return TRUE;
}
DWORD dwBufSize;
BOOL bRet = TRUE;
- TRACE("StartServiceCtrlDispatcherA() called\n");
+ TRACE("StartServiceCtrlDispatcherA(%p)\n",
+ lpServiceStartTable);
i = 0;
while (lpServiceStartTable[i].lpServiceProc != NULL)
dwActiveServiceCount = i;
- /* Initialize the service table */
+ /* Allocate the service table */
lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
lpActiveServices[i].bOwnProcess = FALSE;
}
- /* Initialize the connection to the SCM */
-
+ /* Connect to the SCM */
dwError = ScConnectControlPipe(&hPipe);
if (dwError != ERROR_SUCCESS)
{
bRet = FALSE;
- goto Done;
+ goto done;
}
dwBufSize = sizeof(SCM_CONTROL_PACKET) +
{
dwError = ERROR_NOT_ENOUGH_MEMORY;
bRet = FALSE;
- goto Done;
+ goto done;
}
ScCreateStatusBinding();
- /* Start the dispatcher loop */
+ /* Call the dispatcher loop */
ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);
- /* Close the connection */
+
ScDestroyStatusBinding();
+
+ /* Close the connection */
CloseHandle(hPipe);
/* Free the control packet */
RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);
-Done:
+done:
/* Free the service table */
for (i = 0; i < dwActiveServiceCount; i++)
{
lpActiveServices = NULL;
dwActiveServiceCount = 0;
- if (!bRet) SetLastError(dwError);
+ if (!bRet)
+ SetLastError(dwError);
return bRet;
}
DWORD dwBufSize;
BOOL bRet = TRUE;
- TRACE("StartServiceCtrlDispatcherW() called\n");
+ TRACE("StartServiceCtrlDispatcherW(%p)\n",
+ lpServiceStartTable);
i = 0;
while (lpServiceStartTable[i].lpServiceProc != NULL)
dwActiveServiceCount = i;
- /* Initialize the service table */
+ /* Allocate the service table */
lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
lpActiveServices[i].bOwnProcess = FALSE;
}
- /* Initialize the connection to the SCM */
-
+ /* Connect to the SCM */
dwError = ScConnectControlPipe(&hPipe);
if (dwError != ERROR_SUCCESS)
{
bRet = FALSE;
- goto Done;
+ goto done;
}
dwBufSize = sizeof(SCM_CONTROL_PACKET) +
{
dwError = ERROR_NOT_ENOUGH_MEMORY;
bRet = FALSE;
- goto Done;
+ goto done;
}
ScCreateStatusBinding();
- /* Start the dispatcher loop */
+ /* Call the dispatcher loop */
ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);
- /* Close the connection */
ScDestroyStatusBinding();
+
+ /* Close the connection */
CloseHandle(hPipe);
/* Free the control packet */
RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);
-Done:
+done:
/* Free the service table */
for (i = 0; i < dwActiveServiceCount; i++)
{
lpActiveServices = NULL;
dwActiveServiceCount = 0;
- if (!bRet) SetLastError(dwError);
+ if (!bRet)
+ SetLastError(dwError);
return bRet;
}
projects / reactos.git / blobdiff