sctrl.c File Reference

#include <advapi32.h>

Include dependency graph for sctrl.c:

Go to the source code of this file.

Classes
struct	_SERVICE_THREAD_PARAMSA
struct	_SERVICE_THREAD_PARAMSW
struct	_ACTIVE_SERVICE

Typedefs
typedef struct _SERVICE_THREAD_PARAMSA	SERVICE_THREAD_PARAMSA
typedef struct _SERVICE_THREAD_PARAMSA *	PSERVICE_THREAD_PARAMSA
typedef struct _SERVICE_THREAD_PARAMSW	SERVICE_THREAD_PARAMSW
typedef struct _SERVICE_THREAD_PARAMSW *	PSERVICE_THREAD_PARAMSW
typedef struct _ACTIVE_SERVICE	ACTIVE_SERVICE
typedef struct _ACTIVE_SERVICE *	PACTIVE_SERVICE

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (advapi)
handle_t __RPC_USER	RPC_SERVICE_STATUS_HANDLE_bind (RPC_SERVICE_STATUS_HANDLE hServiceStatus)
void __RPC_USER	RPC_SERVICE_STATUS_HANDLE_unbind (RPC_SERVICE_STATUS_HANDLE hServiceStatus, handle_t hBinding)
static RPC_STATUS	ScCreateStatusBinding (VOID)
static RPC_STATUS	ScDestroyStatusBinding (VOID)
static PACTIVE_SERVICE	ScLookupServiceByServiceName (LPCWSTR lpServiceName)
static DWORD WINAPI	ScServiceMainStubA (LPVOID Context)
static DWORD WINAPI	ScServiceMainStubW (LPVOID Context)
static DWORD	ScConnectControlPipe (HANDLE *hPipe)
static DWORD	ScBuildUnicodeArgsVector (PSCM_CONTROL_PACKET ControlPacket, LPDWORD lpArgCount, LPWSTR **lpArgVector)
static DWORD	ScBuildAnsiArgsVector (PSCM_CONTROL_PACKET ControlPacket, LPDWORD lpArgCount, LPSTR **lpArgVector)
static DWORD	ScStartService (PACTIVE_SERVICE lpService, PSCM_CONTROL_PACKET ControlPacket)
static DWORD	ScControlService (PACTIVE_SERVICE lpService, PSCM_CONTROL_PACKET ControlPacket)
static BOOL	ScServiceDispatcher (HANDLE hPipe, PSCM_CONTROL_PACKET ControlPacket, DWORD dwBufferSize)
SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerA (LPCSTR lpServiceName, LPHANDLER_FUNCTION lpHandlerProc)
SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerW (LPCWSTR lpServiceName, LPHANDLER_FUNCTION lpHandlerProc)
SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerExA (LPCSTR lpServiceName, LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext)
SERVICE_STATUS_HANDLE WINAPI	RegisterServiceCtrlHandlerExW (LPCWSTR lpServiceName, LPHANDLER_FUNCTION_EX lpHandlerProc, LPVOID lpContext)
VOID WINAPI	I_ScIsSecurityProcess (VOID)
DWORD WINAPI	I_ScPnPGetServiceName (IN SERVICE_STATUS_HANDLE hServiceStatus, OUT LPWSTR lpServiceName, IN DWORD cchServiceName)
BOOL WINAPI	I_ScSetServiceBitsA (SERVICE_STATUS_HANDLE hServiceStatus, DWORD dwServiceBits, BOOL bSetBitsOn, BOOL bUpdateImmediately, LPSTR lpString)
BOOL WINAPI	I_ScSetServiceBitsW (SERVICE_STATUS_HANDLE hServiceStatus, DWORD dwServiceBits, BOOL bSetBitsOn, BOOL bUpdateImmediately, LPWSTR lpString)
BOOL WINAPI	SetServiceBits (SERVICE_STATUS_HANDLE hServiceStatus, DWORD dwServiceBits, BOOL bSetBitsOn, BOOL bUpdateImmediately)
BOOL WINAPI	SetServiceStatus (SERVICE_STATUS_HANDLE hServiceStatus, LPSERVICE_STATUS lpServiceStatus)
BOOL WINAPI	StartServiceCtrlDispatcherA (const SERVICE_TABLE_ENTRYA *lpServiceStartTable)
BOOL WINAPI	StartServiceCtrlDispatcherW (const SERVICE_TABLE_ENTRYW *lpServiceStartTable)

Variables
static DWORD	dwActiveServiceCount = 0
static PACTIVE_SERVICE	lpActiveServices = NULL
static handle_t	hStatusBinding = NULL

Typedef Documentation

ACTIVE_SERVICE

typedef struct _ACTIVE_SERVICE ACTIVE_SERVICE

PACTIVE_SERVICE

typedef struct _ACTIVE_SERVICE * PACTIVE_SERVICE

PSERVICE_THREAD_PARAMSA

typedef struct _SERVICE_THREAD_PARAMSA * PSERVICE_THREAD_PARAMSA

PSERVICE_THREAD_PARAMSW

typedef struct _SERVICE_THREAD_PARAMSW * PSERVICE_THREAD_PARAMSW

SERVICE_THREAD_PARAMSA

typedef struct _SERVICE_THREAD_PARAMSA SERVICE_THREAD_PARAMSA

SERVICE_THREAD_PARAMSW

typedef struct _SERVICE_THREAD_PARAMSW SERVICE_THREAD_PARAMSW

Function Documentation

I_ScIsSecurityProcess()

VOID WINAPI I_ScIsSecurityProcess

(

VOID

)

Definition at line 843 of file sctrl.c.

{
    FIXME("I_ScIsSecurityProcess()\n");
}

I_ScPnPGetServiceName()

DWORD WINAPI I_ScPnPGetServiceName	(	IN SERVICE_STATUS_HANDLE	hServiceStatus,
		OUT LPWSTR	lpServiceName,
		IN DWORD	cchServiceName
	)

Definition at line 858 of file sctrl.c.

{
    DWORD i;

    TRACE("I_ScPnPGetServiceName(%lu %p %lu)\n",
          hServiceStatus, lpServiceName, cchServiceName);

    for (i = 0; i < dwActiveServiceCount; i++)
    {
        if (lpActiveServices[i].hServiceStatus == hServiceStatus)
        {
            wcscpy(lpServiceName, lpActiveServices[i].ServiceName.Buffer);
            return ERROR_SUCCESS;
        }
    }

    return ERROR_SERVICE_NOT_IN_EXE;
}

I_ScSetServiceBitsA()

BOOL WINAPI I_ScSetServiceBitsA	(	SERVICE_STATUS_HANDLE	hServiceStatus,
		DWORD	dwServiceBits,
		BOOL	bSetBitsOn,
		BOOL	bUpdateImmediately,
		LPSTR	lpString
	)

Definition at line 888 of file sctrl.c.

{
    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,
                                       dwServiceBits,
                                       bSetBitsOn,
                                       bUpdateImmediately,
                                       lpString);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastError(ScmRpcStatusToWinError(RpcExceptionCode()));
        bResult = FALSE;
    }
    RpcEndExcept;

    return bResult;
}

I_ScSetServiceBitsW()

BOOL WINAPI I_ScSetServiceBitsW	(	SERVICE_STATUS_HANDLE	hServiceStatus,
		DWORD	dwServiceBits,
		BOOL	bSetBitsOn,
		BOOL	bUpdateImmediately,
		LPWSTR	lpString
	)

Definition at line 927 of file sctrl.c.

{
    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,
                                       dwServiceBits,
                                       bSetBitsOn,
                                       bUpdateImmediately,
                                       lpString);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastError(ScmRpcStatusToWinError(RpcExceptionCode()));
        bResult = FALSE;
    }
    RpcEndExcept;

    return bResult;
}

Referenced by SetServiceBits().

RegisterServiceCtrlHandlerA()

SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerA	(	LPCSTR	lpServiceName,
		LPHANDLER_FUNCTION	lpHandlerProc
	)

Definition at line 700 of file sctrl.c.

{
    ANSI_STRING ServiceNameA;
    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)))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }

    hServiceStatus = RegisterServiceCtrlHandlerW(ServiceNameU.Buffer,
                                                 lpHandlerProc);

    RtlFreeUnicodeString(&ServiceNameU);

    return hServiceStatus;
}

Referenced by ServiceMain().

RegisterServiceCtrlHandlerExA()

SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExA	(	LPCSTR	lpServiceName,
		LPHANDLER_FUNCTION_EX	lpHandlerProc,
		LPVOID	lpContext
	)

Definition at line 768 of file sctrl.c.

{
    ANSI_STRING ServiceNameA;
    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)))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return NULL;
    }

    hServiceStatus = RegisterServiceCtrlHandlerExW(ServiceNameU.Buffer,
                                                   lpHandlerProc,
                                                   lpContext);

    RtlFreeUnicodeString(&ServiceNameU);

    return hServiceStatus;
}

Referenced by service_main().

RegisterServiceCtrlHandlerExW()

SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerExW	(	LPCWSTR	lpServiceName,
		LPHANDLER_FUNCTION_EX	lpHandlerProc,
		LPVOID	lpContext
	)

Definition at line 802 of file sctrl.c.

{
    PACTIVE_SERVICE Service;

    TRACE("RegisterServiceCtrlHandlerExW(%s %p %p)\n",
          debugstr_w(lpServiceName), lpHandlerProc, lpContext);

    Service = ScLookupServiceByServiceName(lpServiceName);
    if (Service == NULL)
    {
        SetLastError(ERROR_SERVICE_NOT_IN_EXE);
        return NULL;
    }

    if (!lpHandlerProc)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }

    Service->HandlerFunction = NULL;
    Service->HandlerFunctionEx = lpHandlerProc;
    Service->HandlerContext = lpContext;

    TRACE("RegisterServiceCtrlHandlerEx returning %p\n", Service->hServiceStatus);

    return Service->hServiceStatus;
}

Referenced by _ServiceMain(), RegisterServiceCtrlHandlerExA(), SchedServiceMain(), serv_main(), ServiceMain(), and ThemeServiceMain().

RegisterServiceCtrlHandlerW()

SERVICE_STATUS_HANDLE WINAPI RegisterServiceCtrlHandlerW	(	LPCWSTR	lpServiceName,
		LPHANDLER_FUNCTION	lpHandlerProc
	)

Definition at line 732 of file sctrl.c.

{
    PACTIVE_SERVICE Service;

    TRACE("RegisterServiceCtrlHandlerW(%s %p)\n",
          debugstr_w(lpServiceName), lpHandlerProc);

    Service = ScLookupServiceByServiceName(lpServiceName);
    if (Service == NULL)
    {
        SetLastError(ERROR_SERVICE_NOT_IN_EXE);
        return NULL;
    }

    if (!lpHandlerProc)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }

    Service->HandlerFunction = lpHandlerProc;
    Service->HandlerFunctionEx = NULL;

    TRACE("RegisterServiceCtrlHandler returning %p\n", Service->hServiceStatus);

    return Service->hServiceStatus;
}

Referenced by AbortSvchostService(), RegisterServiceCtrlHandlerA(), service_main(), and service_main_common().

RPC_SERVICE_STATUS_HANDLE_bind()

handle_t __RPC_USER RPC_SERVICE_STATUS_HANDLE_bind

(

RPC_SERVICE_STATUS_HANDLE

hServiceStatus

)

Definition at line 66 of file sctrl.c.

{
    return hStatusBinding;
}

RPC_SERVICE_STATUS_HANDLE_unbind()

void __RPC_USER RPC_SERVICE_STATUS_HANDLE_unbind	(	RPC_SERVICE_STATUS_HANDLE	hServiceStatus,
		handle_t	hBinding
	)

Definition at line 73 of file sctrl.c.

{
}

ScBuildAnsiArgsVector()

static DWORD ScBuildAnsiArgsVector ( PSCM_CONTROL_PACKET  ControlPacket, LPDWORD  lpArgCount, LPSTR **  lpArgVector  )

static

Definition at line 390 of file sctrl.c.

{
    DWORD dwError;
    NTSTATUS Status;
    DWORD ArgCount, i;
    PWSTR *lpVectorW;
    PSTR  *lpVectorA;
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;

    if (ControlPacket == NULL || lpArgCount == NULL || lpArgVector == NULL)
        return ERROR_INVALID_PARAMETER;

    *lpArgCount  = 0;
    *lpArgVector = NULL;

    /* Build the UNICODE arguments vector */
    dwError = ScBuildUnicodeArgsVector(ControlPacket, &ArgCount, &lpVectorW);
    if (dwError != ERROR_SUCCESS)
        return dwError;

    /* Convert the vector to ANSI in place */
    lpVectorA = (PSTR*)lpVectorW;
    for (i = 0; i < ArgCount; i++)
    {
        RtlInitUnicodeString(&UnicodeString, lpVectorW[i]);
        RtlInitEmptyAnsiString(&AnsiString, lpVectorA[i], UnicodeString.MaximumLength);
        Status = RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
        if (!NT_SUCCESS(Status))
        {
            /* Failed to convert to ANSI; free the allocated vector and return */
            dwError = RtlNtStatusToDosError(Status);
            HeapFree(GetProcessHeap(), 0, lpVectorW);
            return dwError;
        }

        /* NULL-terminate the string */
        AnsiString.Buffer[AnsiString.Length / sizeof(CHAR)] = ANSI_NULL;

        TRACE("Ansi lpVector[%lu] = '%s'\n", i, lpVectorA[i]);
    }

    *lpArgCount  = ArgCount;
    *lpArgVector = lpVectorA;

    return ERROR_SUCCESS;
}

Referenced by ScStartService().

ScBuildUnicodeArgsVector()

static DWORD ScBuildUnicodeArgsVector ( PSCM_CONTROL_PACKET  ControlPacket, LPDWORD  lpArgCount, LPWSTR **  lpArgVector  )

static

Definition at line 321 of file sctrl.c.

{
    PWSTR *lpVector;
    PWSTR pszServiceName;
    DWORD cbServiceName;
    DWORD cbArguments;
    DWORD cbTotal;
    DWORD i;

    if (ControlPacket == NULL || lpArgCount == NULL || lpArgVector == NULL)
        return ERROR_INVALID_PARAMETER;

    *lpArgCount  = 0;
    *lpArgVector = NULL;

    /* Retrieve and count the start command line (NULL-terminated) */
    pszServiceName = (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset);
    cbServiceName  = lstrlenW(pszServiceName) * sizeof(WCHAR) + sizeof(UNICODE_NULL);

    /*
     * The total size of the argument vector is equal to the entry for
     * the service name, plus the size of the original argument vector.
     */
    cbTotal = sizeof(PWSTR) + cbServiceName;
    if (ControlPacket->dwArgumentsCount > 0)
        cbArguments = ControlPacket->dwSize - ControlPacket->dwArgumentsOffset;
    else
        cbArguments = 0;
    cbTotal += cbArguments;

    /* Allocate the new argument vector */
    lpVector = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbTotal);
    if (lpVector == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;

    /*
     * The first argument is reserved for the service name, which
     * will be appended to the end of the argument string list.
     */

    /* Copy the remaining arguments */
    if (ControlPacket->dwArgumentsCount > 0)
    {
        memcpy(&lpVector[1],
               (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwArgumentsOffset),
               cbArguments);

        for (i = 0; i < ControlPacket->dwArgumentsCount; i++)
        {
            lpVector[i + 1] = (PWSTR)((ULONG_PTR)&lpVector[1] + (ULONG_PTR)lpVector[i + 1]);
            TRACE("Unicode lpVector[%lu] = '%ls'\n", i + 1, lpVector[i + 1]);
        }
    }

    /* Now copy the service name */
    lpVector[0] = (PWSTR)((ULONG_PTR)&lpVector[1] + cbArguments);
    memcpy(lpVector[0], pszServiceName, cbServiceName);
    TRACE("Unicode lpVector[%lu] = '%ls'\n", 0, lpVector[0]);

    *lpArgCount  = ControlPacket->dwArgumentsCount + 1;
    *lpArgVector = lpVector;

    return ERROR_SUCCESS;
}

Referenced by ScBuildAnsiArgsVector(), and ScStartService().

ScConnectControlPipe()

static DWORD ScConnectControlPipe ( HANDLE *  hPipe )

static

Definition at line 226 of file sctrl.c.

{
    DWORD dwBytesWritten;
    DWORD dwState;
    DWORD dwServiceCurrent = 0;
    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))
    {
        ERR("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
        return RtlNtStatusToDosError(Status);
    }

    swprintf(NtControlPipeName, L"\\\\.\\pipe\\net\\NtControlPipe%u", dwServiceCurrent);

    if (!WaitNamedPipeW(NtControlPipeName, 30000))
    {
        ERR("WaitNamedPipe(%S) failed (Error %lu)\n", NtControlPipeName, GetLastError());
        return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT;
    }

    *hPipe = CreateFileW(NtControlPipeName,
                         GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         FILE_ATTRIBUTE_NORMAL,
                         NULL);
    if (*hPipe == INVALID_HANDLE_VALUE)
    {
        ERR("CreateFileW() failed for pipe %S (Error %lu)\n", NtControlPipeName, GetLastError());
        return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT;
    }

    dwState = PIPE_READMODE_MESSAGE;
    if (!SetNamedPipeHandleState(*hPipe, &dwState, NULL, NULL))
    {
        CloseHandle(*hPipe);
        *hPipe = INVALID_HANDLE_VALUE;
        return ERROR_FAILED_SERVICE_CONTROLLER_CONNECT;
    }

    /* Pass the ProcessId to the SCM */
    dwProcessId = GetCurrentProcessId();
    WriteFile(*hPipe,
              &dwProcessId,
              sizeof(dwProcessId),
              &dwBytesWritten,
              NULL);

    TRACE("Sent Process ID %lu\n", dwProcessId);

    return ERROR_SUCCESS;
}

Referenced by StartServiceCtrlDispatcherA(), and StartServiceCtrlDispatcherW().

ScControlService()

static DWORD ScControlService ( PACTIVE_SERVICE  lpService, PSCM_CONTROL_PACKET  ControlPacket  )

static

Definition at line 540 of file sctrl.c.

{
    DWORD dwError = ERROR_SUCCESS;

    TRACE("ScControlService(%p %p)\n",
          lpService, ControlPacket);

    if (lpService == NULL || ControlPacket == NULL)
        return ERROR_INVALID_PARAMETER;

    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)
    {
        _SEH2_TRY
        {
            (lpService->HandlerFunction)(ControlPacket->dwControl);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            dwError = ERROR_EXCEPTION_IN_SERVICE;
        }
        _SEH2_END;
    }
    else if (lpService->HandlerFunctionEx)
    {
        _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;
    }

    /* Reset service tag */
    NtCurrentTeb()->SubProcessTag = 0;

    TRACE("ScControlService() done (Error %lu)\n", dwError);

    return dwError;
}

Referenced by ScServiceDispatcher().

ScCreateStatusBinding()

static RPC_STATUS ScCreateStatusBinding ( VOID  )

static

Definition at line 80 of file sctrl.c.

{
    LPWSTR pszStringBinding;
    RPC_STATUS status;

    TRACE("ScCreateStatusBinding()\n");

    status = RpcStringBindingComposeW(NULL,
                                      L"ncacn_np",
                                      NULL,
                                      L"\\pipe\\ntsvcs",
                                      NULL,
                                      &pszStringBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcStringBindingCompose returned 0x%x\n", status);
        return status;
    }

    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingW(pszStringBinding,
                                          &hStatusBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcBindingFromStringBinding returned 0x%x\n", status);
    }

    status = RpcStringFreeW(&pszStringBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcStringFree returned 0x%x\n", status);
    }

    return status;
}

Referenced by StartServiceCtrlDispatcherA(), and StartServiceCtrlDispatcherW().

ScDestroyStatusBinding()

static RPC_STATUS ScDestroyStatusBinding ( VOID  )

static

Definition at line 118 of file sctrl.c.

{
    RPC_STATUS status;

    TRACE("ScDestroyStatusBinding()\n");

    if (hStatusBinding == NULL)
        return RPC_S_OK;

    status = RpcBindingFree(&hStatusBinding);
    if (status != RPC_S_OK)
    {
        ERR("RpcBindingFree returned 0x%x\n", status);
    }
    else
    {
        hStatusBinding = NULL;
    }

    return status;
}

Referenced by StartServiceCtrlDispatcherA(), and StartServiceCtrlDispatcherW().

ScLookupServiceByServiceName()

static PACTIVE_SERVICE ScLookupServiceByServiceName ( LPCWSTR  lpServiceName )

static

Definition at line 142 of file sctrl.c.

{
    DWORD i;

    TRACE("ScLookupServiceByServiceName(%S)\n",
          lpServiceName);

    if (lpActiveServices[0].bOwnProcess)
        return &lpActiveServices[0];

    for (i = 0; i < dwActiveServiceCount; i++)
    {
        TRACE("Checking %S\n", lpActiveServices[i].ServiceName.Buffer);
        if (_wcsicmp(lpActiveServices[i].ServiceName.Buffer, lpServiceName) == 0)
        {
            TRACE("Found!\n");
            return &lpActiveServices[i];
        }
    }

    TRACE("No service found!\n");
    return NULL;
}

Referenced by RegisterServiceCtrlHandlerExW(), RegisterServiceCtrlHandlerW(), and ScServiceDispatcher().

ScServiceDispatcher()

static BOOL ScServiceDispatcher ( HANDLE  hPipe, PSCM_CONTROL_PACKET  ControlPacket, DWORD  dwBufferSize  )

static

Definition at line 599 of file sctrl.c.

{
    DWORD Count;
    BOOL bResult;
    BOOL bRunning = TRUE;
    LPWSTR lpServiceName;
    PACTIVE_SERVICE lpService;
    SCM_REPLY_PACKET ReplyPacket;
    DWORD dwError;

    TRACE("ScServiceDispatcher(%p %p %lu)\n",
          hPipe, ControlPacket, dwBufferSize);

    if (ControlPacket == NULL || dwBufferSize < sizeof(SCM_CONTROL_PACKET))
        return FALSE;

    while (bRunning)
    {
        /* Read command from the control pipe */
        bResult = ReadFile(hPipe,
                           ControlPacket,
                           dwBufferSize,
                           &Count,
                           NULL);
        if (bResult == FALSE)
        {
            ERR("Pipe read failed (Error: %lu)\n", GetLastError());
            return FALSE;
        }

        lpServiceName = (LPWSTR)((PBYTE)ControlPacket + ControlPacket->dwServiceNameOffset);
        TRACE("Service: %S\n", lpServiceName);

        if ((ControlPacket->dwControl == SERVICE_CONTROL_STOP) &&
            (lpServiceName[0] == UNICODE_NULL))
        {
            TRACE("Stop dispatcher thread\n");
            bRunning = FALSE;
            dwError = ERROR_SUCCESS;
        }
        else
        {
            if (ControlPacket->dwControl == SERVICE_CONTROL_START_OWN)
                lpActiveServices[0].bOwnProcess = TRUE;

            lpService = ScLookupServiceByServiceName(lpServiceName);
            if (lpService != NULL)
            {
                /* Execute command */
                switch (ControlPacket->dwControl)
                {
                    case SERVICE_CONTROL_START_SHARE:
                    case SERVICE_CONTROL_START_OWN:
                        TRACE("Start command - received SERVICE_CONTROL_START\n");
                        dwError = ScStartService(lpService, ControlPacket);
                        break;

                    case SERVICE_CONTROL_STOP:
                        TRACE("Stop command - received SERVICE_CONTROL_STOP\n");
                        dwError = ScControlService(lpService, ControlPacket);
                        break;

                    default:
                        TRACE("Command %lu received", ControlPacket->dwControl);
                        dwError = ScControlService(lpService, ControlPacket);
                        break;
                }
            }
            else
            {
                dwError = ERROR_SERVICE_NOT_IN_EXE;
            }
        }

        ReplyPacket.dwError = dwError;

        /* Send the reply packet */
        bResult = WriteFile(hPipe,
                            &ReplyPacket,
                            sizeof(ReplyPacket),
                            &Count,
                            NULL);
        if (bResult == FALSE)
        {
            ERR("Pipe write failed (Error: %lu)\n", GetLastError());
            return FALSE;
        }
    }

    return TRUE;
}

Referenced by StartServiceCtrlDispatcherA(), and StartServiceCtrlDispatcherW().

ScServiceMainStubA()

static DWORD WINAPI ScServiceMainStubA ( LPVOID  Context )

static

Definition at line 168 of file sctrl.c.

{
    PTEB Teb;
    PSERVICE_THREAD_PARAMSA ThreadParams = Context;

    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);
    }
    HeapFree(GetProcessHeap(), 0, ThreadParams);

    return ERROR_SUCCESS;
}

Referenced by ScStartService().

ScServiceMainStubW()

static DWORD WINAPI ScServiceMainStubW ( LPVOID  Context )

static

Definition at line 197 of file sctrl.c.

{
    PTEB Teb;
    PSERVICE_THREAD_PARAMSW ThreadParams = Context;

    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);
    }
    HeapFree(GetProcessHeap(), 0, ThreadParams);

    return ERROR_SUCCESS;
}

Referenced by ScStartService().

ScStartService()

static DWORD ScStartService ( PACTIVE_SERVICE  lpService, PSCM_CONTROL_PACKET  ControlPacket  )

static

Definition at line 442 of file sctrl.c.

{
    HANDLE ThreadHandle;
    DWORD ThreadId;
    DWORD dwError;
    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("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)
    {
        ThreadParamsW = HeapAlloc(GetProcessHeap(), 0, sizeof(*ThreadParamsW));
        if (ThreadParamsW == NULL)
            return ERROR_NOT_ENOUGH_MEMORY;
        dwError = ScBuildUnicodeArgsVector(ControlPacket,
                                           &ThreadParamsW->dwArgCount,
                                           &ThreadParamsW->lpArgVector);
        if (dwError != ERROR_SUCCESS)
        {
            HeapFree(GetProcessHeap(), 0, ThreadParamsW);
            return dwError;
        }
        ThreadParamsW->lpServiceMain = lpService->ServiceMain.W;
        ThreadParamsW->dwServiceTag = ControlPacket->dwServiceTag;
        ThreadHandle = CreateThread(NULL,
                                    0,
                                    ScServiceMainStubW,
                                    ThreadParamsW,
                                    0,
                                    &ThreadId);
        if (ThreadHandle == NULL)
        {
            if (ThreadParamsW->lpArgVector != NULL)
            {
                HeapFree(GetProcessHeap(), 0, ThreadParamsW->lpArgVector);
            }
            HeapFree(GetProcessHeap(), 0, ThreadParamsW);

            return ERROR_SERVICE_NO_THREAD;
        }

        CloseHandle(ThreadHandle);
    }
    else
    {
        ThreadParamsA = HeapAlloc(GetProcessHeap(), 0, sizeof(*ThreadParamsA));
        if (ThreadParamsA == NULL)
            return ERROR_NOT_ENOUGH_MEMORY;
        dwError = ScBuildAnsiArgsVector(ControlPacket,
                                        &ThreadParamsA->dwArgCount,
                                        &ThreadParamsA->lpArgVector);
        if (dwError != ERROR_SUCCESS)
        {
            HeapFree(GetProcessHeap(), 0, ThreadParamsA);
            return dwError;
        }
        ThreadParamsA->lpServiceMain = lpService->ServiceMain.A;
        ThreadParamsA->dwServiceTag = ControlPacket->dwServiceTag;
        ThreadHandle = CreateThread(NULL,
                                    0,
                                    ScServiceMainStubA,
                                    ThreadParamsA,
                                    0,
                                    &ThreadId);
        if (ThreadHandle == NULL)
        {
            if (ThreadParamsA->lpArgVector != NULL)
            {
                HeapFree(GetProcessHeap(), 0, ThreadParamsA->lpArgVector);
            }
            HeapFree(GetProcessHeap(), 0, ThreadParamsA);

            return ERROR_SERVICE_NO_THREAD;
        }

        CloseHandle(ThreadHandle);
    }

    return ERROR_SUCCESS;
}

Referenced by ScServiceDispatcher().

SetServiceBits()

BOOL WINAPI SetServiceBits	(	SERVICE_STATUS_HANDLE	hServiceStatus,
		DWORD	dwServiceBits,
		BOOL	bSetBitsOn,
		BOOL	bUpdateImmediately
	)

Definition at line 964 of file sctrl.c.

{
    TRACE("SetServiceBits(%lu %lx %u %u)\n",
          hServiceStatus, dwServiceBits, bSetBitsOn, bUpdateImmediately);

    return I_ScSetServiceBitsW(hServiceStatus,
                               dwServiceBits,
                               bSetBitsOn,
                               bUpdateImmediately,
                               NULL);
}

Referenced by ServiceInit().

SetServiceStatus()

BOOL WINAPI SetServiceStatus	(	SERVICE_STATUS_HANDLE	hServiceStatus,
		LPSERVICE_STATUS	lpServiceStatus
	)

Definition at line 986 of file sctrl.c.

{
    DWORD dwError;

    TRACE("SetServiceStatus(%lu %p)\n",
          hServiceStatus, lpServiceStatus);

    RpcTryExcept
    {
        dwError = RSetServiceStatus((RPC_SERVICE_STATUS_HANDLE)hServiceStatus,
                                    lpServiceStatus);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        dwError = ScmRpcStatusToWinError(RpcExceptionCode());
    }
    RpcEndExcept;

    if (dwError != ERROR_SUCCESS)
    {
        ERR("RSetServiceStatus() failed (Error %lu)\n", dwError);
        SetLastError(dwError);
        return FALSE;
    }

    TRACE("SetServiceStatus() done\n");

    return TRUE;
}

Referenced by _ServiceMain(), _UpdateServiceStatus(), AbortSvchostService(), no_stop_handler(), no_stop_main(), report_service_status(), ReportStatusToSCMgr(), serv_main(), ServerCtrlHandler(), service_handler(), service_main(), service_main_common(), ServiceControlHandler(), ServiceMain(), UpdateSCMStatus(), UpdateServiceStatus(), and UpdateStatus().

StartServiceCtrlDispatcherA()

BOOL WINAPI StartServiceCtrlDispatcherA

(

const SERVICE_TABLE_ENTRYA *

lpServiceStartTable

)

Definition at line 1024 of file sctrl.c.

{
    ULONG i;
    HANDLE hPipe;
    DWORD dwError;
    PSCM_CONTROL_PACKET ControlPacket;
    DWORD dwBufSize;
    BOOL bRet = TRUE;

    TRACE("StartServiceCtrlDispatcherA(%p)\n",
          lpServiceStartTable);

    i = 0;
    while (lpServiceStartTable[i].lpServiceProc != NULL)
    {
        i++;
    }

    dwActiveServiceCount = i;

    /* Allocate the service table */
    lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
                                       HEAP_ZERO_MEMORY,
                                       dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
    if (lpActiveServices == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    /* Copy service names and start procedure */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlCreateUnicodeStringFromAsciiz(&lpActiveServices[i].ServiceName,
                                         lpServiceStartTable[i].lpServiceName);
        lpActiveServices[i].ServiceMain.A = lpServiceStartTable[i].lpServiceProc;
        lpActiveServices[i].hServiceStatus = NULL;
        lpActiveServices[i].bUnicode = FALSE;
        lpActiveServices[i].bOwnProcess = FALSE;
    }

    /* Connect to the SCM */
    dwError = ScConnectControlPipe(&hPipe);
    if (dwError != ERROR_SUCCESS)
    {
        bRet = FALSE;
        goto done;
    }

    dwBufSize = sizeof(SCM_CONTROL_PACKET) +
                (MAX_SERVICE_NAME_LENGTH + 1) * sizeof(WCHAR);

    ControlPacket = RtlAllocateHeap(RtlGetProcessHeap(),
                                    HEAP_ZERO_MEMORY,
                                    dwBufSize);
    if (ControlPacket == NULL)
    {
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        bRet = FALSE;
        goto done;
    }

    ScCreateStatusBinding();

    /* Call the dispatcher loop */
    ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);


    ScDestroyStatusBinding();

    /* Close the connection */
    CloseHandle(hPipe);

    /* Free the control packet */
    RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);

done:
    /* Free the service table */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlFreeUnicodeString(&lpActiveServices[i].ServiceName);
    }
    RtlFreeHeap(RtlGetProcessHeap(), 0, lpActiveServices);
    lpActiveServices = NULL;
    dwActiveServiceCount = 0;

    if (!bRet)
        SetLastError(dwError);

    return bRet;
}

Referenced by DoService(), run_service(), service_process(), and START_TEST().

StartServiceCtrlDispatcherW()

BOOL WINAPI StartServiceCtrlDispatcherW

(

const SERVICE_TABLE_ENTRYW *

lpServiceStartTable

)

Definition at line 1123 of file sctrl.c.

{
    ULONG i;
    HANDLE hPipe;
    DWORD dwError;
    PSCM_CONTROL_PACKET ControlPacket;
    DWORD dwBufSize;
    BOOL bRet = TRUE;

    TRACE("StartServiceCtrlDispatcherW(%p)\n",
          lpServiceStartTable);

    i = 0;
    while (lpServiceStartTable[i].lpServiceProc != NULL)
    {
        i++;
    }

    dwActiveServiceCount = i;

    /* Allocate the service table */
    lpActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
                                       HEAP_ZERO_MEMORY,
                                       dwActiveServiceCount * sizeof(ACTIVE_SERVICE));
    if (lpActiveServices == NULL)
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }

    /* Copy service names and start procedure */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlCreateUnicodeString(&lpActiveServices[i].ServiceName,
                               lpServiceStartTable[i].lpServiceName);
        lpActiveServices[i].ServiceMain.W = lpServiceStartTable[i].lpServiceProc;
        lpActiveServices[i].hServiceStatus = NULL;
        lpActiveServices[i].bUnicode = TRUE;
        lpActiveServices[i].bOwnProcess = FALSE;
    }

    /* Connect to the SCM */
    dwError = ScConnectControlPipe(&hPipe);
    if (dwError != ERROR_SUCCESS)
    {
        bRet = FALSE;
        goto done;
    }

    dwBufSize = sizeof(SCM_CONTROL_PACKET) +
                (MAX_SERVICE_NAME_LENGTH + 1) * sizeof(WCHAR);

    ControlPacket = RtlAllocateHeap(RtlGetProcessHeap(),
                                    HEAP_ZERO_MEMORY,
                                    dwBufSize);
    if (ControlPacket == NULL)
    {
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        bRet = FALSE;
        goto done;
    }

    ScCreateStatusBinding();

    /* Call the dispatcher loop */
    ScServiceDispatcher(hPipe, ControlPacket, dwBufSize);

    ScDestroyStatusBinding();

    /* Close the connection */
    CloseHandle(hPipe);

    /* Free the control packet */
    RtlFreeHeap(RtlGetProcessHeap(), 0, ControlPacket);

done:
    /* Free the service table */
    for (i = 0; i < dwActiveServiceCount; i++)
    {
        RtlFreeUnicodeString(&lpActiveServices[i].ServiceName);
    }
    RtlFreeHeap(RtlGetProcessHeap(), 0, lpActiveServices);
    lpActiveServices = NULL;
    dwActiveServiceCount = 0;

    if (!bRet)
        SetLastError(dwError);

    return bRet;
}

Referenced by _tmain(), main(), service_process(), start_service(), START_TEST(), wmain(), and wmainCRTStartup().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

advapi

)

Variable Documentation

dwActiveServiceCount

DWORD dwActiveServiceCount = 0

static

Definition at line 58 of file sctrl.c.

Referenced by I_ScPnPGetServiceName(), ScLookupServiceByServiceName(), StartServiceCtrlDispatcherA(), and StartServiceCtrlDispatcherW().

hStatusBinding

handle_t hStatusBinding = NULL

static

Definition at line 60 of file sctrl.c.

Referenced by RPC_SERVICE_STATUS_HANDLE_bind(), ScCreateStatusBinding(), and ScDestroyStatusBinding().

lpActiveServices

PACTIVE_SERVICE lpActiveServices = NULL

static

Definition at line 59 of file sctrl.c.

Referenced by I_ScPnPGetServiceName(), ScLookupServiceByServiceName(), ScServiceDispatcher(), StartServiceCtrlDispatcherA(), and StartServiceCtrlDispatcherW().