services.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winsvc.h>
#include <winreg.h>
#include <winuser.h>
#include <netevent.h>
#include <ndk/setypes.h>
#include <ndk/obfuncs.h>
#include <ndk/rtlfuncs.h>
#include <services/services.h>
#include <svcctl_s.h>
#include "resource.h"

Include dependency graph for services.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_SERVICE_GROUP
struct	_SERVICE_IMAGE
struct	_SERVICE
struct	_START_LOCK

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	NTOS_MODE_USER
#define	LOCK_TAG   0x4C697041 /* 'ApiL' */

Typedefs
typedef struct _SERVICE_GROUP	SERVICE_GROUP
typedef struct _SERVICE_GROUP *	PSERVICE_GROUP
typedef struct _SERVICE_IMAGE	SERVICE_IMAGE
typedef struct _SERVICE_IMAGE *	PSERVICE_IMAGE
typedef struct _SERVICE	SERVICE
typedef struct _SERVICE *	PSERVICE
typedef struct _START_LOCK	START_LOCK
typedef struct _START_LOCK *	PSTART_LOCK

Functions
DWORD	ScmOpenServiceKey (LPWSTR lpServiceName, REGSAM samDesired, PHKEY phKey)
DWORD	ScmCreateServiceKey (LPCWSTR lpServiceName, REGSAM samDesired, PHKEY phKey)
DWORD	ScmWriteDependencies (HKEY hServiceKey, LPCWSTR lpDependencies, DWORD dwDependenciesLength)
DWORD	ScmMarkServiceForDelete (PSERVICE pService)
BOOL	ScmIsDeleteFlagSet (HKEY hServiceKey)
DWORD	ScmReadString (HKEY hServiceKey, LPCWSTR lpValueName, LPWSTR *lpValue)
DWORD	ScmReadDependencies (HKEY hServiceKey, LPWSTR *lpDependencies, DWORD *lpdwDependenciesLength)
DWORD	ScmSetServicePassword (_In_ PCWSTR pszServiceName, _In_ PCWSTR pszPassword)
DWORD	ScmWriteSecurityDescriptor (_In_ HKEY hServiceKey, _In_ PSECURITY_DESCRIPTOR pSecurityDescriptor)
DWORD	ScmReadSecurityDescriptor (_In_ HKEY hServiceKey, _Out_ PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
DWORD	ScmDeleteRegKey (_In_ HKEY hKey, _In_ PCWSTR pszSubKey)
DWORD	ScmDecryptPassword (_In_ PVOID ContextHandle, _In_ PBYTE pPassword, _In_ DWORD dwPasswordSize, _Out_ PWSTR *pDecryptedPassword)
DWORD	ScmCreateLastKnownGoodControlSet (VOID)
DWORD	ScmAcceptBoot (VOID)
DWORD	ScmRunLastKnownGood (VOID)
DWORD	ScmCreateServiceDatabase (VOID)
VOID	ScmShutdownServiceDatabase (VOID)
VOID	ScmGetBootAndSystemDriverState (VOID)
VOID	ScmAutoStartServices (VOID)
VOID	ScmAutoShutdownServices (VOID)
DWORD	ScmStartService (PSERVICE Service, DWORD argc, const PCWSTR *argv)
DWORD	ScmReferenceService (PSERVICE lpService)
DWORD	ScmDereferenceService (PSERVICE lpService)
VOID	ScmRemoveServiceImage (PSERVICE_IMAGE pServiceImage)
PSERVICE	ScmGetServiceEntryByName (LPCWSTR lpServiceName)
PSERVICE	ScmGetServiceEntryByDisplayName (LPCWSTR lpDisplayName)
PSERVICE	ScmGetServiceEntryByResumeCount (DWORD dwResumeCount)
DWORD	ScmCreateNewServiceRecord (LPCWSTR lpServiceName, PSERVICE *lpServiceRecord, DWORD dwServiceType, DWORD dwStartType)
VOID	ScmDeleteServiceRecord (PSERVICE lpService)
DWORD	ScmSendControlPacket (_In_ HANDLE hControlPipe, _In_ PCWSTR pServiceName, _In_ DWORD dwControl, _In_ DWORD dwControlpacketSize, _In_ PVOID pControlPacket)
DWORD	ScmControlServiceEx (_In_ HANDLE hControlPipe, _In_ PCWSTR pServiceName, _In_ DWORD dwControl, _In_ SERVICE_STATUS_HANDLE hServiceStatus, _In_opt_ DWORD dwServiceTag, _In_opt_ DWORD argc, _In_reads_opt_(argc) const PCWSTR *argv)
DWORD	ScmControlService (_In_ HANDLE hControlPipe, _In_ PCWSTR pServiceName, _In_ DWORD dwControl, _In_ SERVICE_STATUS_HANDLE hServiceStatus)
BOOL	ScmLockDatabaseExclusive (VOID)
BOOL	ScmLockDatabaseShared (VOID)
VOID	ScmUnlockDatabase (VOID)
VOID	ScmInitNamedPipeCriticalSection (VOID)
VOID	ScmDeleteNamedPipeCriticalSection (VOID)
DWORD	ScmGetServiceNameFromTag (PTAG_INFO_NAME_FROM_TAG_IN_PARAMS InParams, PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS *OutParams)
DWORD	ScmGenerateServiceTag (PSERVICE lpServiceRecord)
DWORD	ScmStartDriver (PSERVICE lpService)
DWORD	ScmControlDriver (PSERVICE lpService, DWORD dwControl, LPSERVICE_STATUS lpServiceStatus)
PSERVICE_GROUP	ScmGetServiceGroupByName (_In_ LPCWSTR lpGroupName)
DWORD	ScmCreateGroupList (VOID)
DWORD	ScmSetServiceGroup (PSERVICE lpService, LPCWSTR lpGroupName)
DWORD	ScmAcquireServiceStartLock (IN BOOL IsServiceController, OUT LPSC_RPC_LOCK lpLock)
DWORD	ScmReleaseServiceStartLock (IN OUT LPSC_RPC_LOCK lpLock)
VOID	ScmQueryServiceLockStatusW (OUT LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus)
VOID	ScmQueryServiceLockStatusA (OUT LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus)
VOID	ScmStartRpcServer (VOID)
DWORD	ScmInitializeSecurity (VOID)
VOID	ScmShutdownSecurity (VOID)
DWORD	ScmCreateDefaultServiceSD (PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
VOID	PrintString (LPCSTR fmt,...)
DWORD	SetSecurityServicesEvent (VOID)
VOID	ScmLogEvent (DWORD dwEventId, WORD wType, WORD wStrings, LPCWSTR *lpStrings)
VOID	ScmWaitForLsa (VOID)

Variables
LIST_ENTRY	ServiceListHead
LIST_ENTRY	GroupListHead
LIST_ENTRY	ImageListHead
BOOL	ScmInitialize
BOOL	ScmShutdown
BOOL	ScmLiveSetup
BOOL	ScmSetupInProgress
PSECURITY_DESCRIPTOR	pPipeSD

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 12 of file services.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 13 of file services.h.

LOCK_TAG

#define LOCK_TAG   0x4C697041 /* 'ApiL' */

Definition at line 90 of file services.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 22 of file services.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 11 of file services.h.

Typedef Documentation

PSERVICE

typedef struct _SERVICE * PSERVICE

PSERVICE_GROUP

typedef struct _SERVICE_GROUP * PSERVICE_GROUP

PSERVICE_IMAGE

typedef struct _SERVICE_IMAGE * PSERVICE_IMAGE

PSTART_LOCK

typedef struct _START_LOCK * PSTART_LOCK

SERVICE

typedef struct _SERVICE SERVICE

SERVICE_GROUP

typedef struct _SERVICE_GROUP SERVICE_GROUP

SERVICE_IMAGE

typedef struct _SERVICE_IMAGE SERVICE_IMAGE

START_LOCK

typedef struct _START_LOCK START_LOCK

Function Documentation

PrintString()

VOID PrintString	(	LPCSTR	fmt,
			...
	)

Definition at line 39 of file services.c.

{
#if DBG
    CHAR buffer[512];
    va_list ap;
 
    va_start(ap, fmt);
    vsprintf(buffer, fmt, ap);
    va_end(ap);
 
    OutputDebugStringA(buffer);
#endif
}

ScmAcceptBoot()

DWORD ScmAcceptBoot

(

VOID

)

Definition at line 336 of file controlset.c.

{
    DWORD dwCurrentControlSet, dwDefaultControlSet;
    DWORD dwFailedControlSet, dwLastKnownGoodControlSet;
    DWORD dwNewControlSet;
    DWORD dwError;
 
    DPRINT("ScmAcceptBoot()\n");
 
    if (bBootAccepted)
    {
        DPRINT1("Boot has already been accepted\n");
        return ERROR_BOOT_ALREADY_ACCEPTED;
    }
 
    /* Get the control set values */
    dwError = ScmGetControlSetValues(&dwCurrentControlSet,
                                     &dwDefaultControlSet,
                                     &dwFailedControlSet,
                                     &dwLastKnownGoodControlSet);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    /* Search for a new control set number */
    for (dwNewControlSet = 1; dwNewControlSet < 1000; dwNewControlSet++)
    {
        if ((dwNewControlSet != dwCurrentControlSet) &&
            (dwNewControlSet != dwDefaultControlSet) &&
            (dwNewControlSet != dwFailedControlSet) &&
            (dwNewControlSet != dwLastKnownGoodControlSet))
            break;
    }
 
    /* Fail if we did not find an unused control set!*/
    if (dwNewControlSet >= 1000)
    {
        DPRINT1("Too many control sets\n");
        return ERROR_NO_MORE_ITEMS;
    }
 
    /* Copy the current control set */
    dwError = ScmCopyControlSet(dwCurrentControlSet,
                                dwNewControlSet);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    /* Delete the current last known good contol set, if it is not used anywhere else */
    if ((dwLastKnownGoodControlSet != dwCurrentControlSet) &&
        (dwLastKnownGoodControlSet != dwDefaultControlSet) &&
        (dwLastKnownGoodControlSet != dwFailedControlSet))
    {
        ScmDeleteControlSet(dwLastKnownGoodControlSet);
    }
 
    /* Set the new 'LastKnownGood' control set */
    dwError = ScmSetLastKnownGoodControlSet(dwNewControlSet);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    bBootAccepted = TRUE;
 
    return ERROR_SUCCESS;
}

Referenced by RNotifyBootConfigStatus().

ScmAcquireServiceStartLock()

DWORD ScmAcquireServiceStartLock	(	IN BOOL	IsServiceController,
		OUT LPSC_RPC_LOCK	lpLock
	)

Definition at line 31 of file lock.c.

{
    DWORD dwRequiredSize;
    DWORD dwError = ERROR_SUCCESS;
 
    *lpLock = NULL;
 
    /* Lock the service database exclusively */
    ScmLockDatabaseExclusive();
 
    if (pServiceStartLock != NULL)
    {
        dwError = ERROR_SERVICE_DATABASE_LOCKED;
        goto done;
    }
 
    /* Allocate a new lock for the database */
    dwRequiredSize = sizeof(START_LOCK);
 
    if (!IsServiceController)
    {
        /* FIXME: dwRequiredSize += RtlLengthSid(UserSid <-- to be retrieved); */
    }
 
    pServiceStartLock = HeapAlloc(GetProcessHeap(),
                                  HEAP_ZERO_MEMORY,
                                  dwRequiredSize);
    if (pServiceStartLock == NULL)
    {
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto done;
    }
 
    pServiceStartLock->Tag = LOCK_TAG;
    pServiceStartLock->TimeWhenLocked = (DWORD)time(NULL);
 
    /* FIXME: Retrieve the owner SID. Use IsServiceController. */
    pServiceStartLock->LockOwnerSid   = (PSID)NULL;
 
    *lpLock = (LPSC_RPC_LOCK)pServiceStartLock;
 
done:
    /* Unlock the service database */
    ScmUnlockDatabase();
 
    return dwError;
}

Referenced by RLockServiceDatabase(), ScmStartService(), and wWinMain().

ScmAutoShutdownServices()

VOID ScmAutoShutdownServices

(

VOID

)

Definition at line 2332 of file database.c.

{
    PLIST_ENTRY ServiceEntry;
    PSERVICE CurrentService;
 
    DPRINT("ScmAutoShutdownServices() called\n");
 
    /* Lock the service database exclusively */
    ScmLockDatabaseExclusive();
 
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
        if ((CurrentService->Status.dwControlsAccepted & SERVICE_ACCEPT_SHUTDOWN) &&
            (CurrentService->Status.dwCurrentState == SERVICE_RUNNING ||
             CurrentService->Status.dwCurrentState == SERVICE_START_PENDING))
        {
            /* Send the shutdown notification */
            DPRINT("Shutdown service: %S\n", CurrentService->lpServiceName);
            ScmControlService(CurrentService->lpImage->hControlPipe,
                              CurrentService->lpServiceName,
                              SERVICE_CONTROL_SHUTDOWN,
                              (SERVICE_STATUS_HANDLE)CurrentService);
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    /* Unlock the service database */
    ScmUnlockDatabase();
 
    DPRINT("ScmAutoShutdownServices() done\n");
}

Referenced by ShutdownHandlerRoutine().

ScmAutoStartServices()

VOID ScmAutoStartServices

(

VOID

)

Definition at line 2121 of file database.c.

{
    DWORD dwError;
    PLIST_ENTRY GroupEntry;
    PLIST_ENTRY ServiceEntry;
    PSERVICE_GROUP CurrentGroup;
    PSERVICE CurrentService;
    WCHAR szSafeBootServicePath[MAX_PATH];
    DWORD SafeBootEnabled;
    HKEY hKey;
    DWORD dwKeySize;
    ULONG i;
 
    /*
     * This function MUST be called ONLY at initialization time.
     * Therefore, no need to acquire the user service start lock.
     */
    ASSERT(ScmInitialize);
 
    /* Retrieve the SafeBoot parameter */
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"SYSTEM\\CurrentControlSet\\Control\\SafeBoot\\Option",
                            0,
                            KEY_READ,
                            &hKey);
    if (dwError == ERROR_SUCCESS)
    {
        dwKeySize = sizeof(SafeBootEnabled);
        dwError = RegQueryValueExW(hKey,
                                   L"OptionValue",
                                   0,
                                   NULL,
                                   (LPBYTE)&SafeBootEnabled,
                                   &dwKeySize);
        RegCloseKey(hKey);
    }
 
    /* Default to Normal boot if the value doesn't exist */
    if (dwError != ERROR_SUCCESS)
        SafeBootEnabled = 0;
 
    /* Acquire the service control critical section, to synchronize starts */
    EnterCriticalSection(&ControlServiceCriticalSection);
 
    /* Clear 'ServiceVisited' flag (or set if not to start in Safe Mode) */
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
        /* Build the safe boot path */
        StringCchCopyW(szSafeBootServicePath, ARRAYSIZE(szSafeBootServicePath),
                       L"SYSTEM\\CurrentControlSet\\Control\\SafeBoot");
 
        switch (SafeBootEnabled)
        {
            /* NOTE: Assumes MINIMAL (1) and DSREPAIR (3) load same items */
            case 1:
            case 3:
                StringCchCatW(szSafeBootServicePath, ARRAYSIZE(szSafeBootServicePath),
                              L"\\Minimal\\");
                break;
 
            case 2:
                StringCchCatW(szSafeBootServicePath, ARRAYSIZE(szSafeBootServicePath),
                              L"\\Network\\");
                break;
        }
 
        if (SafeBootEnabled != 0)
        {
            /* If key does not exist then do not assume safe mode */
            dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                                    szSafeBootServicePath,
                                    0,
                                    KEY_READ,
                                    &hKey);
            if (dwError == ERROR_SUCCESS)
            {
                RegCloseKey(hKey);
 
                /* Finish Safe Boot path off */
                StringCchCatW(szSafeBootServicePath, ARRAYSIZE(szSafeBootServicePath),
                              CurrentService->lpServiceName);
 
                /* Check that the key is in the Safe Boot path */
                dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                                        szSafeBootServicePath,
                                        0,
                                        KEY_READ,
                                        &hKey);
                if (dwError != ERROR_SUCCESS)
                {
                    /* Mark service as visited so it is not auto-started */
                    CurrentService->ServiceVisited = TRUE;
                }
                else
                {
                    /* Must be auto-started in safe mode - mark as unvisited */
                    RegCloseKey(hKey);
                    CurrentService->ServiceVisited = FALSE;
                }
            }
            else
            {
                DPRINT1("WARNING: Could not open the associated Safe Boot key\n");
                CurrentService->ServiceVisited = FALSE;
            }
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    /* Start all services which are members of an existing group */
    GroupEntry = GroupListHead.Flink;
    while (GroupEntry != &GroupListHead)
    {
        CurrentGroup = CONTAINING_RECORD(GroupEntry, SERVICE_GROUP, GroupListEntry);
 
        DPRINT("Group '%S'\n", CurrentGroup->lpGroupName);
 
        /* Start all services witch have a valid tag */
        for (i = 0; i < CurrentGroup->TagCount; i++)
        {
            ServiceEntry = ServiceListHead.Flink;
            while (ServiceEntry != &ServiceListHead)
            {
                CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
                if ((CurrentService->lpGroup == CurrentGroup) &&
                    (CurrentService->dwStartType == SERVICE_AUTO_START) &&
                    (CurrentService->ServiceVisited == FALSE) &&
                    (CurrentService->dwTag == CurrentGroup->TagArray[i]))
                {
                    CurrentService->ServiceVisited = TRUE;
                    ScmLoadService(CurrentService, 0, NULL);
                }
 
                ServiceEntry = ServiceEntry->Flink;
             }
        }
 
        /* Start all services which have an invalid tag or which do not have a tag */
        ServiceEntry = ServiceListHead.Flink;
        while (ServiceEntry != &ServiceListHead)
        {
            CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
            if ((CurrentService->lpGroup == CurrentGroup) &&
                (CurrentService->dwStartType == SERVICE_AUTO_START) &&
                (CurrentService->ServiceVisited == FALSE))
            {
                CurrentService->ServiceVisited = TRUE;
                ScmLoadService(CurrentService, 0, NULL);
            }
 
            ServiceEntry = ServiceEntry->Flink;
        }
 
        GroupEntry = GroupEntry->Flink;
    }
 
    /* Start all services which are members of any non-existing group */
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
        if ((CurrentService->lpGroup != NULL) &&
            (CurrentService->dwStartType == SERVICE_AUTO_START) &&
            (CurrentService->ServiceVisited == FALSE))
        {
            CurrentService->ServiceVisited = TRUE;
            ScmLoadService(CurrentService, 0, NULL);
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    /* Start all services which are not a member of any group */
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
        if ((CurrentService->lpGroup == NULL) &&
            (CurrentService->dwStartType == SERVICE_AUTO_START) &&
            (CurrentService->ServiceVisited == FALSE))
        {
            CurrentService->ServiceVisited = TRUE;
            ScmLoadService(CurrentService, 0, NULL);
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    /* Clear 'ServiceVisited' flag again */
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
        CurrentService->ServiceVisited = FALSE;
        ServiceEntry = ServiceEntry->Flink;
    }
 
    /* Release the critical section */
    LeaveCriticalSection(&ControlServiceCriticalSection);
}

Referenced by wWinMain().

ScmControlDriver()

DWORD ScmControlDriver	(	PSERVICE	lpService,
		DWORD	dwControl,
		LPSERVICE_STATUS	lpServiceStatus
	)

Definition at line 335 of file driver.c.

{
    DWORD dwError;
 
    DPRINT("ScmControlDriver() called\n");
 
    switch (dwControl)
    {
        case SERVICE_CONTROL_STOP:
            /* Check the drivers status */
            dwError = ScmGetDriverStatus(lpService,
                                         lpServiceStatus);
            if (dwError != ERROR_SUCCESS)
                goto done;
 
            /* Fail, if it is not running */
            if (lpService->Status.dwCurrentState != SERVICE_RUNNING)
            {
                dwError = ERROR_INVALID_SERVICE_CONTROL;
                goto done;
            }
 
            /* Unload the driver */
            dwError = ScmUnloadDriver(lpService);
            if (dwError == ERROR_INVALID_SERVICE_CONTROL)
            {
                /* The driver cannot be stopped, mark it non-stoppable */
                lpService->Status.dwControlsAccepted = 0;
                goto done;
            }
 
            /* Make the driver 'stop pending' */
            lpService->Status.dwCurrentState = SERVICE_STOP_PENDING;
 
            /* Check the drivers status again */
            dwError = ScmGetDriverStatus(lpService,
                                         lpServiceStatus);
            break;
 
        case SERVICE_CONTROL_INTERROGATE:
            dwError = ScmGetDriverStatus(lpService,
                                         lpServiceStatus);
            break;
 
        default:
            dwError = ERROR_INVALID_SERVICE_CONTROL;
    }
 
done:
    DPRINT("ScmControlDriver() done (Erorr: %lu)\n", dwError);
 
    return dwError;
}

Referenced by RControlService().

ScmControlService()

DWORD ScmControlService	(	_In_ HANDLE	hControlPipe,
		_In_ PCWSTR	pServiceName,
		_In_ DWORD	dwControl,
		_In_ SERVICE_STATUS_HANDLE	hServiceStatus
	)

Definition at line 1592 of file database.c.

{
    DWORD dwError = ERROR_SUCCESS;
    PSCM_CONTROL_PACKET ControlPacket;
    DWORD PacketSize;
    PWSTR Ptr;
 
    DPRINT("ScmControlService(%S, %d) called\n", pServiceName, dwControl);
 
    /* Calculate the total size of the control packet:
     * initial structure, the start command line, and the argument vector */
    PacketSize = sizeof(SCM_CONTROL_PACKET);
    PacketSize += (DWORD)((wcslen(pServiceName) + 1) * sizeof(WCHAR));
 
    /* Allocate the control packet */
    ControlPacket = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, PacketSize);
    if (!ControlPacket)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    ControlPacket->dwSize = PacketSize;
    ControlPacket->dwControl = dwControl;
    ControlPacket->hServiceStatus = hServiceStatus;
 
    /* Copy the service name */
    ControlPacket->dwServiceNameOffset = sizeof(SCM_CONTROL_PACKET);
    Ptr = (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset);
    wcscpy(Ptr, pServiceName);
 
    /* Send the control packet */
    dwError = ScmSendControlPacket(hControlPipe,
                                   pServiceName,
                                   dwControl,
                                   PacketSize,
                                   ControlPacket);
 
    /* Free the control packet */
    HeapFree(GetProcessHeap(), 0, ControlPacket);
 
    DPRINT("ScmControlService(%S, %d) done (Error %lu)\n", pServiceName, dwControl, dwError);
    return dwError;
}

Referenced by RControlService(), ScmAutoShutdownServices(), and ScmStopThread().

ScmControlServiceEx()

DWORD ScmControlServiceEx	(	_In_ HANDLE	hControlPipe,
		_In_ PCWSTR	pServiceName,
		_In_ DWORD	dwControl,
		_In_ SERVICE_STATUS_HANDLE	hServiceStatus,
		_In_opt_ DWORD	dwServiceTag,
		_In_opt_ DWORD	argc,
		_In_reads_opt_(argc) const PCWSTR *	argv
	)

Definition at line 1492 of file database.c.

{
    DWORD dwError = ERROR_SUCCESS;
    PSCM_CONTROL_PACKET ControlPacket;
    DWORD PacketSize;
    DWORD i;
    PWSTR Ptr;
 
    DPRINT("ScmControlServiceEx(%S, %d) called\n", pServiceName, dwControl);
 
    /* Calculate the total size of the control packet:
     * initial structure, the start command line, and the argument vector */
    PacketSize = sizeof(SCM_CONTROL_PACKET);
    PacketSize += (DWORD)((wcslen(pServiceName) + 1) * sizeof(WCHAR));
 
    /*
     * Calculate the required packet size for the start argument vector 'argv',
     * composed of the pointer offsets list, followed by UNICODE strings.
     * The strings are stored successively after the offsets vector, with
     * the offsets being relative to the beginning of the vector, as in the
     * following layout (with N == argc):
     *     [argOff(0)]...[argOff(N-1)][str(0)]...[str(N-1)] .
     */
    if (argc > 0 && argv != NULL)
    {
        PacketSize = ALIGN_UP(PacketSize, PWSTR);
        PacketSize += (argc * sizeof(PWSTR));
 
        DPRINT("Argc: %lu\n", argc);
        for (i = 0; i < argc; i++)
        {
            DPRINT("Argv[%lu]: %S\n", i, argv[i]);
            PacketSize += (DWORD)((wcslen(argv[i]) + 1) * sizeof(WCHAR));
        }
    }
 
    /* Allocate the control packet */
    ControlPacket = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, PacketSize);
    if (!ControlPacket)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    ControlPacket->dwSize = PacketSize;
    ControlPacket->dwControl = dwControl;
    ControlPacket->hServiceStatus = hServiceStatus;
    ControlPacket->dwServiceTag = dwServiceTag;
 
    /* Copy the start command line */
    ControlPacket->dwServiceNameOffset = sizeof(SCM_CONTROL_PACKET);
    Ptr = (PWSTR)((ULONG_PTR)ControlPacket + ControlPacket->dwServiceNameOffset);
    wcscpy(Ptr, pServiceName);
 
    ControlPacket->dwArgumentsCount  = 0;
    ControlPacket->dwArgumentsOffset = 0;
 
    /* Copy the argument vector */
    if (argc > 0 && argv != NULL)
    {
        PWSTR *pOffPtr, pArgPtr;
 
        Ptr += wcslen(pServiceName) + 1;
        pOffPtr = (PWSTR*)ALIGN_UP_POINTER(Ptr, PWSTR);
        pArgPtr = (PWSTR)((ULONG_PTR)pOffPtr + argc * sizeof(PWSTR));
 
        ControlPacket->dwArgumentsCount  = argc;
        ControlPacket->dwArgumentsOffset = (DWORD)((ULONG_PTR)pOffPtr - (ULONG_PTR)ControlPacket);
 
        DPRINT("dwArgumentsCount: %lu\n", ControlPacket->dwArgumentsCount);
        DPRINT("dwArgumentsOffset: %lu\n", ControlPacket->dwArgumentsOffset);
 
        for (i = 0; i < argc; i++)
        {
            wcscpy(pArgPtr, argv[i]);
            pOffPtr[i] = (PWSTR)((ULONG_PTR)pArgPtr - (ULONG_PTR)pOffPtr);
            DPRINT("offset[%lu]: %p\n", i, pOffPtr[i]);
            pArgPtr += wcslen(argv[i]) + 1;
        }
    }
 
    dwError = ScmSendControlPacket(hControlPipe,
                                   pServiceName,
                                   dwControl,
                                   PacketSize,
                                   ControlPacket);
 
    /* Free the control packet */
    HeapFree(GetProcessHeap(), 0, ControlPacket);
 
    DPRINT("ScmControlServiceEx(%S, %d) done (Error %lu)\n", pServiceName, dwControl, dwError);
    return dwError;
}

Referenced by ScmStartUserModeService().

ScmCreateDefaultServiceSD()

DWORD ScmCreateDefaultServiceSD

(

PSECURITY_DESCRIPTOR *

ppSecurityDescriptor

)

Definition at line 320 of file security.c.

{
    PSECURITY_DESCRIPTOR pRelativeSD = NULL;
    DWORD dwBufferLength = 0;
    NTSTATUS Status;
    DWORD dwError = ERROR_SUCCESS;
 
    /* Convert the absolute SD to a self-relative SD */
    Status = RtlAbsoluteToSelfRelativeSD(pDefaultSD,
                                         NULL,
                                         &dwBufferLength);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        dwError = RtlNtStatusToDosError(Status);
        goto done;
    }
 
    DPRINT("BufferLength %lu\n", dwBufferLength);
 
    pRelativeSD = RtlAllocateHeap(RtlGetProcessHeap(),
                                  HEAP_ZERO_MEMORY,
                                  dwBufferLength);
    if (pRelativeSD == NULL)
    {
        dwError = ERROR_OUTOFMEMORY;
        goto done;
    }
    DPRINT("pRelativeSD %p\n", pRelativeSD);
 
    Status = RtlAbsoluteToSelfRelativeSD(pDefaultSD,
                                         pRelativeSD,
                                         &dwBufferLength);
    if (!NT_SUCCESS(Status))
    {
        dwError = RtlNtStatusToDosError(Status);
        goto done;
    }
 
    *ppSecurityDescriptor = pRelativeSD;
 
done:
    if (dwError != ERROR_SUCCESS)
    {
        if (pRelativeSD != NULL)
            RtlFreeHeap(RtlGetProcessHeap(), 0, pRelativeSD);
    }
 
    return dwError;
}

Referenced by CreateServiceListEntry(), and RCreateServiceW().

ScmCreateGroupList()

DWORD ScmCreateGroupList

(

VOID

)

Definition at line 235 of file groupdb.c.

{
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
    NTSTATUS Status;
 
    InitializeListHead(&GroupListHead);
    InitializeListHead(&UnknownGroupListHead);
 
    /* Build group order list */
    RtlZeroMemory(&QueryTable,
                  sizeof(QueryTable));
 
    QueryTable[0].Name = L"List";
    QueryTable[0].QueryRoutine = CreateGroupListRoutine;
 
    Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
                                    L"ServiceGroupOrder",
                                    QueryTable,
                                    NULL,
                                    NULL);
 
    return RtlNtStatusToDosError(Status);
}

Referenced by ScmCreateServiceDatabase().

ScmCreateLastKnownGoodControlSet()

DWORD ScmCreateLastKnownGoodControlSet

(

VOID

)

Definition at line 275 of file controlset.c.

{
    DWORD dwCurrentControlSet, dwDefaultControlSet;
    DWORD dwFailedControlSet, dwLastKnownGoodControlSet;
    DWORD dwNewControlSet;
    DWORD dwError;
 
    /* Get the control set values */
    dwError = ScmGetControlSetValues(&dwCurrentControlSet,
                                     &dwDefaultControlSet,
                                     &dwFailedControlSet,
                                     &dwLastKnownGoodControlSet);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    /* First boot after setup? */
    if ((ScmGetSetupInProgress() == 0) &&
        (dwCurrentControlSet == dwLastKnownGoodControlSet))
    {
        DPRINT("First boot after setup\n");
 
        /* Search for a new control set number */
        for (dwNewControlSet = 1; dwNewControlSet < 1000; dwNewControlSet++)
        {
            if ((dwNewControlSet != dwCurrentControlSet) &&
                (dwNewControlSet != dwDefaultControlSet) &&
                (dwNewControlSet != dwFailedControlSet) &&
                (dwNewControlSet != dwLastKnownGoodControlSet))
                break;
        }
 
        /* Fail if we did not find an unused control set!*/
        if (dwNewControlSet >= 1000)
        {
            DPRINT1("Too many control sets\n");
            return ERROR_NO_MORE_ITEMS;
        }
 
        /* Copy the current control set */
        dwError = ScmCopyControlSet(dwCurrentControlSet,
                                    dwNewControlSet);
        if (dwError != ERROR_SUCCESS)
            return dwError;
 
        /* Set the new 'LastKnownGood' control set */
        dwError = ScmSetLastKnownGoodControlSet(dwNewControlSet);
        if (dwError == ERROR_SUCCESS)
        {
            /*
             * Accept the boot here in order to prevent the creation of
             * another control set when a user is going to get logged on
             */
            bBootAccepted = TRUE;
        }
    }
 
    return dwError;
}

Referenced by wWinMain().

ScmCreateNewServiceRecord()

DWORD ScmCreateNewServiceRecord	(	LPCWSTR	lpServiceName,
		PSERVICE *	lpServiceRecord,
		DWORD	dwServiceType,
		DWORD	dwStartType
	)

Definition at line 766 of file database.c.

{
    PSERVICE lpService = NULL;
 
    DPRINT("Service: '%S'\n", lpServiceName);
 
    /* Allocate service entry */
    lpService = HeapAlloc(GetProcessHeap(),
                          HEAP_ZERO_MEMORY,
                          FIELD_OFFSET(SERVICE, szServiceName[wcslen(lpServiceName) + 1]));
    if (lpService == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    *lpServiceRecord = lpService;
 
    /* Copy service name */
    wcscpy(lpService->szServiceName, lpServiceName);
    lpService->lpServiceName = lpService->szServiceName;
    lpService->lpDisplayName = lpService->lpServiceName;
 
    /* Set the start type */
    lpService->dwStartType = dwStartType;
 
    /* Set the resume count */
    lpService->dwResumeCount = ResumeCount++;
 
    /* Append service record */
    InsertTailList(&ServiceListHead,
                   &lpService->ServiceListEntry);
 
    /* Initialize the service status */
    lpService->Status.dwServiceType = dwServiceType;
    lpService->Status.dwCurrentState = SERVICE_STOPPED;
    lpService->Status.dwControlsAccepted = 0;
    lpService->Status.dwWin32ExitCode =
        (dwStartType == SERVICE_DISABLED) ? ERROR_SERVICE_DISABLED : ERROR_SERVICE_NEVER_STARTED;
    lpService->Status.dwServiceSpecificExitCode = 0;
    lpService->Status.dwCheckPoint = 0;
    lpService->Status.dwWaitHint =
        (dwServiceType & SERVICE_DRIVER) ? 0 : 2000; /* 2 seconds */
 
    return ERROR_SUCCESS;
}

Referenced by CreateServiceListEntry(), and RCreateServiceW().

ScmCreateServiceDatabase()

DWORD ScmCreateServiceDatabase

(

VOID

)

Definition at line 1186 of file database.c.

{
    WCHAR szSubKey[MAX_PATH];
    HKEY hServicesKey;
    HKEY hServiceKey;
    DWORD dwSubKey;
    DWORD dwSubKeyLength;
    FILETIME ftLastChanged;
    DWORD dwError;
 
    DPRINT("ScmCreateServiceDatabase() called\n");
 
    /* Retrieve the NoInteractiveServies value */
    ScmGetNoInteractiveServicesValue();
 
    /* Create the service group list */
    dwError = ScmCreateGroupList();
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    /* Initialize image and service lists */
    InitializeListHead(&ImageListHead);
    InitializeListHead(&ServiceListHead);
 
    /* Initialize the database lock */
    RtlInitializeResource(&DatabaseLock);
 
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"System\\CurrentControlSet\\Services",
                            0,
                            KEY_READ,
                            &hServicesKey);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwSubKey = 0;
    for (;;)
    {
        dwSubKeyLength = MAX_PATH;
        dwError = RegEnumKeyExW(hServicesKey,
                                dwSubKey,
                                szSubKey,
                                &dwSubKeyLength,
                                NULL,
                                NULL,
                                NULL,
                                &ftLastChanged);
        if (dwError == ERROR_SUCCESS &&
            szSubKey[0] != L'{')
        {
            DPRINT("SubKeyName: '%S'\n", szSubKey);
 
            dwError = RegOpenKeyExW(hServicesKey,
                                    szSubKey,
                                    0,
                                    KEY_READ,
                                    &hServiceKey);
            if (dwError == ERROR_SUCCESS)
            {
                dwError = CreateServiceListEntry(szSubKey,
                                                 hServiceKey);
 
                RegCloseKey(hServiceKey);
            }
        }
 
        if (dwError != ERROR_SUCCESS)
            break;
 
        dwSubKey++;
    }
 
    RegCloseKey(hServicesKey);
 
    /* Wait for the LSA server */
    ScmWaitForLsa();
 
    /* Delete services that are marked for delete */
    ScmDeleteMarkedServices();
 
    DPRINT("ScmCreateServiceDatabase() done\n");
 
    return ERROR_SUCCESS;
}

Referenced by wWinMain().

ScmCreateServiceKey()

DWORD ScmCreateServiceKey	(	LPCWSTR	lpServiceName,
		REGSAM	samDesired,
		PHKEY	phKey
	)

Definition at line 72 of file config.c.

{
    HKEY hServicesKey = NULL;
    DWORD dwDisposition;
    DWORD dwError;
 
    *phKey = NULL;
 
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"System\\CurrentControlSet\\Services",
                            0,
                            KEY_READ | KEY_CREATE_SUB_KEY,
                            &hServicesKey);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = RegCreateKeyExW(hServicesKey,
                              lpServiceName,
                              0,
                              NULL,
                              REG_OPTION_NON_VOLATILE,
                              samDesired,
                              NULL,
                              phKey,
                              &dwDisposition);
#if 0
    if ((dwError == ERROR_SUCCESS) &&
        (dwDisposition == REG_OPENED_EXISTING_KEY))
    {
        RegCloseKey(*phKey);
        *phKey = NULL;
        dwError = ERROR_SERVICE_EXISTS;
    }
#endif
 
    RegCloseKey(hServicesKey);
 
    return dwError;
}

Referenced by RCreateServiceW().

ScmDecryptPassword()

DWORD ScmDecryptPassword	(	_In_ PVOID	ContextHandle,
		_In_ PBYTE	pPassword,
		_In_ DWORD	dwPasswordSize,
		_Out_ PWSTR *	pDecryptedPassword
	)

Definition at line 708 of file config.c.

{
    struct ustring inData, keyData, outData;
    BYTE SessionKey[16];
    PWSTR pBuffer;
    NTSTATUS Status;
 
    /* Get the session key */
    Status = SystemFunction028(ContextHandle,
                               SessionKey);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SystemFunction028 failed (Status 0x%08lx)\n", Status);
        return RtlNtStatusToDosError(Status);
    }
 
    inData.Length = dwPasswordSize;
    inData.MaximumLength = inData.Length;
    inData.Buffer = pPassword;
 
    keyData.Length = sizeof(SessionKey);
    keyData.MaximumLength = keyData.Length;
    keyData.Buffer = SessionKey;
 
    outData.Length = 0;
    outData.MaximumLength = 0;
    outData.Buffer = NULL;
 
    /* Get the required buffer size */
    Status = SystemFunction005(&inData,
                               &keyData,
                               &outData);
    if (Status != STATUS_BUFFER_TOO_SMALL)
    {
        DPRINT1("SystemFunction005 failed (Status 0x%08lx)\n", Status);
        return RtlNtStatusToDosError(Status);
    }
 
    /* Allocate a buffer for the clear text password */
    pBuffer = HeapAlloc(GetProcessHeap(), 0, outData.Length);
    if (pBuffer == NULL)
        return ERROR_OUTOFMEMORY;
 
    outData.MaximumLength = outData.Length;
    outData.Buffer = (unsigned char *)pBuffer;
 
    /* Decrypt the password */
    Status = SystemFunction005(&inData,
                               &keyData,
                               &outData);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("SystemFunction005 failed (Status 0x%08lx)\n", Status);
        HeapFree(GetProcessHeap(), 0, pBuffer);
        return RtlNtStatusToDosError(Status);
    }
 
    *pClearTextPassword = pBuffer;
 
    return ERROR_SUCCESS;
}

Referenced by RChangeServiceConfigW(), and RCreateServiceW().

ScmDeleteNamedPipeCriticalSection()

VOID ScmDeleteNamedPipeCriticalSection

(

VOID

)

Definition at line 2419 of file database.c.

{
    DeleteCriticalSection(&ControlServiceCriticalSection);
}

Referenced by wWinMain().

ScmDeleteRegKey()

DWORD ScmDeleteRegKey	(	_In_ HKEY	hKey,
		_In_ PCWSTR	pszSubKey
	)

Definition at line 646 of file config.c.

{
    DWORD dwMaxSubkeyLen, dwMaxValueLen;
    DWORD dwMaxLen, dwSize;
    PWSTR pszName = NULL;
    HKEY hSubKey;
    DWORD dwError;
 
    dwError = RegOpenKeyExW(hKey, pszSubKey, 0, KEY_READ, &hSubKey);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    /* Get maximum length of key and value names */
    dwError = RegQueryInfoKeyW(hSubKey, NULL, NULL, NULL, NULL,
                               &dwMaxSubkeyLen, NULL, NULL, &dwMaxValueLen, NULL, NULL, NULL);
    if (dwError != ERROR_SUCCESS)
        goto done;
 
    dwMaxSubkeyLen++;
    dwMaxValueLen++;
    dwMaxLen = max(dwMaxSubkeyLen, dwMaxValueLen);
 
    /* Allocate the name buffer */
    pszName = HeapAlloc(GetProcessHeap(), 0, dwMaxLen * sizeof(WCHAR));
    if (pszName == NULL)
    {
        dwError = ERROR_NOT_ENOUGH_MEMORY;
        goto done;
    }
 
    /* Recursively delete all the subkeys */
    while (TRUE)
    {
        dwSize = dwMaxLen;
        if (RegEnumKeyExW(hSubKey, 0, pszName, &dwSize,
                          NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
        {
            break;
        }
 
        dwError = ScmDeleteRegKey(hSubKey, pszName);
        if (dwError != ERROR_SUCCESS)
            goto done;
    }
 
done:
    if (pszName != NULL)
        HeapFree(GetProcessHeap(), 0, pszName);
 
    RegCloseKey(hSubKey);
 
    /* Finally delete the key */
    if (dwError == ERROR_SUCCESS)
        dwError = RegDeleteKeyW(hKey, pszSubKey);
 
    return dwError;
}

Referenced by ScmDeleteMarkedServices(), ScmDeleteRegKey(), and ScmDeleteService().

ScmDeleteServiceRecord()

VOID ScmDeleteServiceRecord

(

PSERVICE

lpService

)

Definition at line 815 of file database.c.

{
    DPRINT("Deleting Service %S\n", lpService->lpServiceName);
 
    /* Delete the display name */
    if (lpService->lpDisplayName != NULL &&
        lpService->lpDisplayName != lpService->lpServiceName)
        HeapFree(GetProcessHeap(), 0, lpService->lpDisplayName);
 
    /* Dereference the service image */
    if (lpService->lpImage)
    {
        lpService->lpImage->dwImageRunCount--;
 
        if (lpService->lpImage->dwImageRunCount == 0)
        {
            ScmRemoveServiceImage(lpService->lpImage);
            lpService->lpImage = NULL;
        }
    }
 
    /* Decrement the group reference counter */
    ScmSetServiceGroup(lpService, NULL);
 
    /* Release the SecurityDescriptor */
    if (lpService->pSecurityDescriptor != NULL)
        HeapFree(GetProcessHeap(), 0, lpService->pSecurityDescriptor);
 
    /* Remove the Service from the List */
    RemoveEntryList(&lpService->ServiceListEntry);
 
    DPRINT("Deleted Service %S\n", lpService->lpServiceName);
 
    /* Delete the service record */
    HeapFree(GetProcessHeap(), 0, lpService);
 
    DPRINT("Done\n");
}

Referenced by ScmDeleteService().

ScmDereferenceService()

DWORD ScmDereferenceService

(

PSERVICE

lpService

)

Definition at line 938 of file database.c.

{
    DWORD ref;
 
    ASSERT(lpService->RefCount > 0);
 
    ref = InterlockedDecrement(&lpService->RefCount);
 
    if (ref == 0 && lpService->bDeleted &&
        lpService->Status.dwCurrentState == SERVICE_STOPPED)
    {
        ScmDeleteService(lpService);
    }
    return ref;
}

Referenced by RCloseServiceHandle(), RSetServiceStatus(), and ScmStopThread().

ScmGenerateServiceTag()

DWORD ScmGenerateServiceTag

(

PSERVICE

lpServiceRecord

)

Definition at line 743 of file database.c.

{
    /* Check for an overflow */
    if (ServiceTag == -1)
    {
        return ERROR_INVALID_DATA;
    }
 
    /* This is only valid for Win32 services */
    if (!(lpServiceRecord->Status.dwServiceType & SERVICE_WIN32))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    /* Increment the tag counter and set it */
    ServiceTag = ServiceTag % 0xFFFFFFFF + 1;
    lpServiceRecord->dwServiceTag = ServiceTag;
 
    return ERROR_SUCCESS;
}

Referenced by CreateServiceListEntry(), and RCreateServiceW().

ScmGetBootAndSystemDriverState()

VOID ScmGetBootAndSystemDriverState

(

VOID

)

Definition at line 1383 of file database.c.

{
    PLIST_ENTRY ServiceEntry;
    PSERVICE CurrentService;
 
    DPRINT("ScmGetBootAndSystemDriverState() called\n");
 
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry, SERVICE, ServiceListEntry);
 
        if (CurrentService->dwStartType == SERVICE_BOOT_START ||
            CurrentService->dwStartType == SERVICE_SYSTEM_START)
        {
            /* Check driver */
            DPRINT("  Checking service: %S\n", CurrentService->lpServiceName);
 
            ScmCheckDriver(CurrentService);
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    DPRINT("ScmGetBootAndSystemDriverState() done\n");
}

Referenced by wWinMain().

ScmGetServiceEntryByDisplayName()

PSERVICE ScmGetServiceEntryByDisplayName

(

LPCWSTR

lpDisplayName

)

Definition at line 685 of file database.c.

{
    PLIST_ENTRY ServiceEntry;
    PSERVICE CurrentService;
 
    DPRINT("ScmGetServiceEntryByDisplayName() called\n");
 
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry,
                                           SERVICE,
                                           ServiceListEntry);
        if (_wcsicmp(CurrentService->lpDisplayName, lpDisplayName) == 0)
        {
            DPRINT("Found service: '%S'\n", CurrentService->lpDisplayName);
            return CurrentService;
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    DPRINT("Couldn't find a matching service\n");
 
    return NULL;
}

Referenced by RCreateServiceW(), RGetServiceKeyNameA(), and RGetServiceKeyNameW().

ScmGetServiceEntryByName()

PSERVICE ScmGetServiceEntryByName

(

LPCWSTR

lpServiceName

)

Definition at line 656 of file database.c.

{
    PLIST_ENTRY ServiceEntry;
    PSERVICE CurrentService;
 
    DPRINT("ScmGetServiceEntryByName() called\n");
 
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry,
                                           SERVICE,
                                           ServiceListEntry);
        if (_wcsicmp(CurrentService->lpServiceName, lpServiceName) == 0)
        {
            DPRINT("Found service: '%S'\n", CurrentService->lpServiceName);
            return CurrentService;
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    DPRINT("Couldn't find a matching service\n");
 
    return NULL;
}

Referenced by Int_EnumDependentServicesW(), RCreateServiceW(), RGetServiceDisplayNameA(), RGetServiceDisplayNameW(), RI_ScValidatePnPService(), and ROpenServiceW().

ScmGetServiceEntryByResumeCount()

PSERVICE ScmGetServiceEntryByResumeCount

(

DWORD

dwResumeCount

)

Definition at line 714 of file database.c.

{
    PLIST_ENTRY ServiceEntry;
    PSERVICE CurrentService;
 
    DPRINT("ScmGetServiceEntryByResumeCount() called\n");
 
    ServiceEntry = ServiceListHead.Flink;
    while (ServiceEntry != &ServiceListHead)
    {
        CurrentService = CONTAINING_RECORD(ServiceEntry,
                                           SERVICE,
                                           ServiceListEntry);
        if (CurrentService->dwResumeCount > dwResumeCount)
        {
            DPRINT("Found service: '%S'\n", CurrentService->lpDisplayName);
            return CurrentService;
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    DPRINT("Couldn't find a matching service\n");
 
    return NULL;
}

Referenced by REnumServiceGroupW(), and REnumServicesStatusExW().

ScmGetServiceGroupByName()

PSERVICE_GROUP ScmGetServiceGroupByName

(

_In_ LPCWSTR

lpGroupName

)

Definition at line 26 of file groupdb.c.

{
    PLIST_ENTRY GroupEntry;
    PSERVICE_GROUP lpGroup;
 
    DPRINT("ScmGetServiceGroupByName(%S)\n", lpGroupName);
 
    GroupEntry = GroupListHead.Flink;
    while (GroupEntry != &GroupListHead)
    {
        lpGroup = CONTAINING_RECORD(GroupEntry, SERVICE_GROUP, GroupListEntry);
 
        if (!_wcsicmp(lpGroup->lpGroupName, lpGroupName))
            return lpGroup;
 
        GroupEntry = GroupEntry->Flink;
    }
 
    GroupEntry = UnknownGroupListHead.Flink;
    while (GroupEntry != &UnknownGroupListHead)
    {
        lpGroup = CONTAINING_RECORD(GroupEntry, SERVICE_GROUP, GroupListEntry);
 
        if (!_wcsicmp(lpGroup->lpGroupName, lpGroupName))
            return lpGroup;
 
        GroupEntry = GroupEntry->Flink;
    }
 
    return NULL;
}

Referenced by RI_ScGetCurrentGroupStateW().

ScmGetServiceNameFromTag()

DWORD ScmGetServiceNameFromTag	(	PTAG_INFO_NAME_FROM_TAG_IN_PARAMS	InParams,
		PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS *	OutParams
	)

ScmInitializeSecurity()

DWORD ScmInitializeSecurity

(

VOID

)

Definition at line 373 of file security.c.

{
    DWORD dwError;
 
    dwError = ScmCreateSids();
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = ScmCreateAcls();
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = ScmCreateDefaultSD();
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = ScmCreatePipeSD();
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    return ERROR_SUCCESS;
}

Referenced by wWinMain().

ScmInitNamedPipeCriticalSection()

VOID ScmInitNamedPipeCriticalSection

(

VOID

)

Definition at line 2391 of file database.c.

{
    HKEY hKey;
    DWORD dwKeySize;
    DWORD dwError;
 
    InitializeCriticalSection(&ControlServiceCriticalSection);
 
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"SYSTEM\\CurrentControlSet\\Control",
                            0,
                            KEY_READ,
                            &hKey);
   if (dwError == ERROR_SUCCESS)
   {
        dwKeySize = sizeof(PipeTimeout);
        RegQueryValueExW(hKey,
                         L"ServicesPipeTimeout",
                         0,
                         NULL,
                         (LPBYTE)&PipeTimeout,
                         &dwKeySize);
       RegCloseKey(hKey);
   }
}

Referenced by wWinMain().

ScmIsDeleteFlagSet()

BOOL ScmIsDeleteFlagSet

(

HKEY

hServiceKey

)

Definition at line 251 of file config.c.

{
    DWORD dwError;
    DWORD dwType;
    DWORD dwFlag;
    DWORD dwSize = sizeof(DWORD);
 
    dwError = RegQueryValueExW(hServiceKey,
                               L"DeleteFlag",
                               0,
                               &dwType,
                               (LPBYTE)&dwFlag,
                               &dwSize);
 
    return (dwError == ERROR_SUCCESS);
}

Referenced by CreateServiceListEntry().

ScmLockDatabaseExclusive()

BOOL ScmLockDatabaseExclusive

(

VOID

)

Definition at line 2370 of file database.c.

{
    return RtlAcquireResourceExclusive(&DatabaseLock, TRUE);
}

Referenced by RChangeServiceConfig2W(), RChangeServiceConfigW(), RCloseServiceHandle(), RCreateServiceW(), RDeleteService(), ROpenServiceW(), RSetServiceObjectSecurity(), RSetServiceStatus(), ScmAcquireServiceStartLock(), ScmAutoShutdownServices(), ScmGetServiceNameFromTag(), ScmReleaseServiceStartLock(), and ScmStopThread().

ScmLockDatabaseShared()

BOOL ScmLockDatabaseShared

(

VOID

)

Definition at line 2377 of file database.c.

{
    return RtlAcquireResourceShared(&DatabaseLock, TRUE);
}

Referenced by REnumServiceGroupW(), REnumServicesStatusExW(), RI_ScGetCurrentGroupStateW(), RQueryServiceConfig2A(), RQueryServiceConfig2W(), RQueryServiceConfigA(), RQueryServiceConfigW(), RQueryServiceObjectSecurity(), RQueryServiceStatus(), RQueryServiceStatusEx(), ScmQueryServiceLockStatusA(), and ScmQueryServiceLockStatusW().

ScmLogEvent()

VOID ScmLogEvent	(	DWORD	dwEventId,
		WORD	wType,
		WORD	wStrings,
		LPCWSTR *	lpStrings
	)

Definition at line 174 of file services.c.

{
    HANDLE hLog;
 
    hLog = RegisterEventSourceW(NULL,
                                L"Service Control Manager");
    if (hLog == NULL)
    {
        DPRINT1("ScmLogEvent: RegisterEventSourceW failed %lu\n", GetLastError());
        return;
    }
 
    if (!ReportEventW(hLog,
                      wType,
                      0,
                      dwEventId,
                      NULL,
                      wStrings,
                      0,
                      lpStrings,
                      NULL))
    {
        DPRINT1("ScmLogEvent: ReportEventW failed %lu\n", GetLastError());
    }
 
    DeregisterEventSource(hLog);
}

Referenced by RControlService(), RSetServiceStatus(), ScmLoadService(), ScmStopThread(), and ScmWaitForServiceConnect().

ScmMarkServiceForDelete()

DWORD ScmMarkServiceForDelete

(

PSERVICE

pService

)

Definition at line 223 of file config.c.

{
    HKEY hServiceKey = NULL;
    DWORD dwValue = 1;
    DWORD dwError;
 
    DPRINT("ScmMarkServiceForDelete() called\n");
 
    dwError = ScmOpenServiceKey(pService->lpServiceName,
                                KEY_WRITE,
                                &hServiceKey);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = RegSetValueExW(hServiceKey,
                             L"DeleteFlag",
                             0,
                             REG_DWORD,
                             (LPBYTE)&dwValue,
                             sizeof(DWORD));
 
    RegCloseKey(hServiceKey);
 
    return dwError;
}

Referenced by RDeleteService().

ScmOpenServiceKey()

DWORD ScmOpenServiceKey	(	LPWSTR	lpServiceName,
		REGSAM	samDesired,
		PHKEY	phKey
	)

Definition at line 42 of file config.c.

{
    HKEY hServicesKey = NULL;
    DWORD dwError;
 
    *phKey = NULL;
 
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            L"System\\CurrentControlSet\\Services",
                            0,
                            KEY_READ,
                            &hServicesKey);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = RegOpenKeyExW(hServicesKey,
                            lpServiceName,
                            0,
                            samDesired,
                            phKey);
 
    RegCloseKey(hServicesKey);
 
    return dwError;
}

Referenced by RChangeServiceConfig2W(), RChangeServiceConfigW(), RQueryServiceConfig2A(), RQueryServiceConfig2W(), RQueryServiceConfigA(), RQueryServiceConfigW(), RSetServiceObjectSecurity(), and ScmMarkServiceForDelete().

ScmQueryServiceLockStatusA()

VOID ScmQueryServiceLockStatusA

(

OUT LPQUERY_SERVICE_LOCK_STATUSA

lpLockStatus

)

Definition at line 159 of file lock.c.

{
    /* Lock the service database shared */
    ScmLockDatabaseShared();
 
    if (pServiceStartLock != NULL)
    {
        lpLockStatus->fIsLocked = TRUE;
 
        /* FIXME: Retrieve the owner name. */
        lpLockStatus->lpLockOwner = NULL;
 
        lpLockStatus->dwLockDuration = (DWORD)time(NULL) - pServiceStartLock->TimeWhenLocked;
    }
    else
    {
        lpLockStatus->fIsLocked = FALSE;
 
        strcpy((LPSTR)(lpLockStatus + 1), "");
        lpLockStatus->lpLockOwner = (LPSTR)(ULONG_PTR)sizeof(QUERY_SERVICE_LOCK_STATUSA);
 
        lpLockStatus->dwLockDuration = 0;
    }
 
    /* Unlock the service database */
    ScmUnlockDatabase();
 
    return;
}

Referenced by RQueryServiceLockStatusA().

ScmQueryServiceLockStatusW()

VOID ScmQueryServiceLockStatusW

(

OUT LPQUERY_SERVICE_LOCK_STATUSW

lpLockStatus

)

Definition at line 127 of file lock.c.

{
    /* Lock the service database shared */
    ScmLockDatabaseShared();
 
    if (pServiceStartLock != NULL)
    {
        lpLockStatus->fIsLocked = TRUE;
 
        /* FIXME: Retrieve the owner name. */
        lpLockStatus->lpLockOwner = NULL;
 
        lpLockStatus->dwLockDuration = (DWORD)time(NULL) - pServiceStartLock->TimeWhenLocked;
    }
    else
    {
        lpLockStatus->fIsLocked = FALSE;
 
        wcscpy((LPWSTR)(lpLockStatus + 1), L"");
        lpLockStatus->lpLockOwner = (LPWSTR)(ULONG_PTR)sizeof(QUERY_SERVICE_LOCK_STATUSW);
 
        lpLockStatus->dwLockDuration = 0;
    }
 
    /* Unlock the service database */
    ScmUnlockDatabase();
 
    return;
}

Referenced by RQueryServiceLockStatusW().

ScmReadDependencies()

DWORD ScmReadDependencies	(	HKEY	hServiceKey,
		LPWSTR *	lpDependencies,
		DWORD *	lpdwDependenciesLength
	)

Definition at line 349 of file config.c.

{
    LPWSTR lpGroups = NULL;
    LPWSTR lpServices = NULL;
    SIZE_T cchGroupsLength = 0;
    SIZE_T cchServicesLength = 0;
    LPWSTR lpSrc;
    LPWSTR lpDest;
    SIZE_T cchLength;
    SIZE_T cchTotalLength;
 
    *lpDependencies = NULL;
    *lpdwDependenciesLength = 0;
 
    /* Read the dependency values */
    ScmReadString(hServiceKey,
                  L"DependOnGroup",
                  &lpGroups);
 
    ScmReadString(hServiceKey,
                  L"DependOnService",
                  &lpServices);
 
    /* Leave, if there are no dependencies */
    if (lpGroups == NULL && lpServices == NULL)
        return ERROR_SUCCESS;
 
    /* Determine the total buffer size for the dependencies */
    if (lpGroups)
    {
        DPRINT("Groups:\n");
        lpSrc = lpGroups;
        while (*lpSrc != 0)
        {
            DPRINT("  %S\n", lpSrc);
 
            cchLength = wcslen(lpSrc) + 1;
            cchGroupsLength += cchLength + 1;
 
            lpSrc = lpSrc + cchLength;
        }
    }
 
    if (lpServices)
    {
        DPRINT("Services:\n");
        lpSrc = lpServices;
        while (*lpSrc != 0)
        {
            DPRINT("  %S\n", lpSrc);
 
            cchLength = wcslen(lpSrc) + 1;
            cchServicesLength += cchLength;
 
            lpSrc = lpSrc + cchLength;
        }
    }
 
    cchTotalLength = cchGroupsLength + cchServicesLength + 1;
    DPRINT("cchTotalLength: %lu\n", cchTotalLength);
 
    /* Allocate the common buffer for the dependencies */
    *lpDependencies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cchTotalLength * sizeof(WCHAR));
    if (*lpDependencies == NULL)
    {
        if (lpGroups)
            HeapFree(GetProcessHeap(), 0, lpGroups);
 
        if (lpServices)
            HeapFree(GetProcessHeap(), 0, lpServices);
 
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    /* Return the allocated buffer length in characters */
    *lpdwDependenciesLength = (DWORD)cchTotalLength;
 
    /* Copy the service dependencies into the common buffer */
    lpDest = *lpDependencies;
    if (lpServices)
    {
        memcpy(lpDest,
               lpServices,
               cchServicesLength * sizeof(WCHAR));
 
        lpDest = lpDest + cchServicesLength;
    }
 
    /* Copy the group dependencies into the common buffer */
    if (lpGroups)
    {
        lpSrc = lpGroups;
        while (*lpSrc != 0)
        {
            cchLength = wcslen(lpSrc) + 1;
 
            *lpDest = SC_GROUP_IDENTIFIERW;
            lpDest++;
 
            wcscpy(lpDest, lpSrc);
 
            lpDest = lpDest + cchLength;
            lpSrc = lpSrc + cchLength;
        }
    }
 
    /* Free the temporary buffers */
    if (lpGroups)
        HeapFree(GetProcessHeap(), 0, lpGroups);
 
    if (lpServices)
        HeapFree(GetProcessHeap(), 0, lpServices);
 
    return ERROR_SUCCESS;
}

Referenced by RQueryServiceConfigA(), and RQueryServiceConfigW().

ScmReadSecurityDescriptor()

DWORD ScmReadSecurityDescriptor	(	_In_ HKEY	hServiceKey,
		_Out_ PSECURITY_DESCRIPTOR *	ppSecurityDescriptor
	)

Definition at line 566 of file config.c.

{
    PSECURITY_DESCRIPTOR pRelativeSD = NULL;
    HKEY hSecurityKey = NULL;
    DWORD dwBufferLength = 0;
    DWORD dwType;
    DWORD dwError;
 
    DPRINT("ScmReadSecurityDescriptor(%p %p)\n", hServiceKey, ppSecurityDescriptor);
 
    *ppSecurityDescriptor = NULL;
 
    dwError = RegOpenKeyExW(hServiceKey,
                            L"Security",
                            0,
                            KEY_QUERY_VALUE,
                            &hSecurityKey);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("RegOpenKeyExW() failed (Error %lu)\n", dwError);
 
        /* Do not fail if the Security key does not exist */
        if (dwError == ERROR_FILE_NOT_FOUND)
            dwError = ERROR_SUCCESS;
        goto done;
    }
 
    dwError = RegQueryValueExW(hSecurityKey,
                               L"Security",
                               0,
                               &dwType,
                               NULL,
                               &dwBufferLength);
    if (dwError != ERROR_SUCCESS)
    {
        DPRINT("RegQueryValueExW() failed (Error %lu)\n", dwError);
 
        /* Do not fail if the Security value does not exist */
        if (dwError == ERROR_FILE_NOT_FOUND)
            dwError = ERROR_SUCCESS;
        goto done;
    }
 
    DPRINT("dwBufferLength: %lu\n", dwBufferLength);
    pRelativeSD = RtlAllocateHeap(RtlGetProcessHeap(),
                                  HEAP_ZERO_MEMORY,
                                  dwBufferLength);
    if (pRelativeSD == NULL)
    {
        return ERROR_OUTOFMEMORY;
    }
 
    DPRINT("pRelativeSD: %lu\n", pRelativeSD);
    dwError = RegQueryValueExW(hSecurityKey,
                               L"Security",
                               0,
                               &dwType,
                               (LPBYTE)pRelativeSD,
                               &dwBufferLength);
    if (dwError != ERROR_SUCCESS)
    {
        goto done;
    }
 
    *ppSecurityDescriptor = pRelativeSD;
 
done:
    if (dwError != ERROR_SUCCESS && pRelativeSD != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pRelativeSD);
 
    if (hSecurityKey != NULL)
        RegCloseKey(hSecurityKey);
 
    return dwError;
}

Referenced by CreateServiceListEntry().

ScmReadString()

DWORD ScmReadString	(	HKEY	hServiceKey,
		LPCWSTR	lpValueName,
		LPWSTR *	lpValue
	)

Definition at line 270 of file config.c.

{
    DWORD dwError = 0;
    DWORD dwSize = 0;
    DWORD dwType = 0;
    LPWSTR ptr = NULL;
    LPWSTR expanded = NULL;
 
    *lpValue = NULL;
 
    dwError = RegQueryValueExW(hServiceKey,
                               lpValueName,
                               0,
                               &dwType,
                               NULL,
                               &dwSize);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);
    if (ptr == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    dwError = RegQueryValueExW(hServiceKey,
                               lpValueName,
                               0,
                               &dwType,
                               (LPBYTE)ptr,
                               &dwSize);
    if (dwError != ERROR_SUCCESS)
    {
        HeapFree(GetProcessHeap(), 0, ptr);
        return dwError;
    }
 
    if (dwType == REG_EXPAND_SZ)
    {
        /* Expand the value... */
        dwSize = ExpandEnvironmentStringsW(ptr, NULL, 0);
        if (dwSize > 0)
        {
            expanded = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize * sizeof(WCHAR));
            if (expanded)
            {
                if (dwSize == ExpandEnvironmentStringsW(ptr, expanded, dwSize))
                {
                    *lpValue = expanded;
                    dwError = ERROR_SUCCESS;
                }
                else
                {
                    dwError = GetLastError();
                    HeapFree(GetProcessHeap(), 0, expanded);
                }
            }
            else
            {
                dwError = ERROR_NOT_ENOUGH_MEMORY;
            }
        }
        else
        {
            dwError = GetLastError();
        }
 
        HeapFree(GetProcessHeap(), 0, ptr);
    }
    else
    {
        *lpValue = ptr;
    }
 
    return dwError;
}

Referenced by CreateServiceListEntry(), RQueryServiceConfig2A(), RQueryServiceConfig2W(), RQueryServiceConfigA(), RQueryServiceConfigW(), and ScmReadDependencies().

ScmReferenceService()

DWORD ScmReferenceService

(

PSERVICE

lpService

)

Definition at line 930 of file database.c.

{
    return InterlockedIncrement(&lpService->RefCount);
}

Referenced by RCreateServiceW(), ROpenServiceW(), RSetServiceStatus(), and ScmLoadService().

ScmReleaseServiceStartLock()

DWORD ScmReleaseServiceStartLock

(

IN OUT LPSC_RPC_LOCK

lpLock

)

Definition at line 82 of file lock.c.

{
    PSTART_LOCK pStartLock;
    DWORD dwError = ERROR_SUCCESS;
 
    if (lpLock == NULL)
        return ERROR_INVALID_SERVICE_LOCK;
 
    pStartLock = (PSTART_LOCK)*lpLock;
 
    if (pStartLock->Tag != LOCK_TAG)
        return ERROR_INVALID_SERVICE_LOCK;
 
    /* Lock the service database exclusively */
    ScmLockDatabaseExclusive();
 
    /* Release the lock handle */
    if ((pStartLock == pServiceStartLock) &&
        (pServiceStartLock != NULL))
    {
        HeapFree(GetProcessHeap(), 0, pServiceStartLock);
        pServiceStartLock = NULL;
        *lpLock = NULL;
 
        dwError = ERROR_SUCCESS;
    }
    else
    {
        dwError = ERROR_INVALID_SERVICE_LOCK;
    }
 
    /* Unlock the service database */
    ScmUnlockDatabase();
 
    return dwError;
}

Referenced by RUnlockServiceDatabase(), ScmStartService(), and wWinMain().

ScmRemoveServiceImage()

VOID ScmRemoveServiceImage

(

PSERVICE_IMAGE

pServiceImage

)

Definition at line 621 of file database.c.

{
    DPRINT1("ScmRemoveServiceImage() called\n");
 
    /* FIXME: Terminate the process */
 
    /* Remove the service image from the list */
    RemoveEntryList(&pServiceImage->ImageListEntry);
 
    /* Close the process handle */
    if (pServiceImage->hProcess != INVALID_HANDLE_VALUE)
        CloseHandle(pServiceImage->hProcess);
 
    /* Close the control pipe */
    if (pServiceImage->hControlPipe != INVALID_HANDLE_VALUE)
        CloseHandle(pServiceImage->hControlPipe);
 
    /* Unload the user profile */
    if (pServiceImage->hProfile != NULL)
    {
        ScmEnableBackupRestorePrivileges(pServiceImage->hToken, TRUE);
        UnloadUserProfile(pServiceImage->hToken, pServiceImage->hProfile);
        ScmEnableBackupRestorePrivileges(pServiceImage->hToken, FALSE);
    }
 
    /* Close the logon token */
    if (pServiceImage->hToken != NULL)
        CloseHandle(pServiceImage->hToken);
 
    /* Release the service image */
    HeapFree(GetProcessHeap(), 0, pServiceImage);
}

Referenced by ScmDeleteServiceRecord(), ScmLoadService(), and ScmStopThread().

ScmRunLastKnownGood()

DWORD ScmRunLastKnownGood

(

VOID

)

Definition at line 402 of file controlset.c.

{
    DPRINT("ScmRunLastKnownGood()\n");
 
    if (bBootAccepted)
    {
        DPRINT1("Boot has already been accepted\n");
        return ERROR_BOOT_ALREADY_ACCEPTED;
    }
 
    /* FIXME */
 
    return ERROR_SUCCESS;
}

Referenced by RNotifyBootConfigStatus().

ScmSendControlPacket()

DWORD ScmSendControlPacket	(	_In_ HANDLE	hControlPipe,
		_In_ PCWSTR	pServiceName,
		_In_ DWORD	dwControl,
		_In_ DWORD	dwControlpacketSize,
		_In_ PVOID	pControlPacket
	)

Definition at line 1416 of file database.c.

{
    DWORD dwError = ERROR_SUCCESS;
    BOOL bResult;
    SCM_REPLY_PACKET ReplyPacket;
    DWORD dwReadCount = 0;
    OVERLAPPED Overlapped = {0};
 
    DPRINT("ScmSendControlPacket(%p, %lu, %p) called\n",
           hControlPipe, dwControlPacketSize, pControlPacket);
 
    /* Acquire the service control critical section, to synchronize requests */
    EnterCriticalSection(&ControlServiceCriticalSection);
 
    bResult = TransactNamedPipe(hControlPipe,
                                pControlPacket,
                                dwControlPacketSize,
                                &ReplyPacket,
                                sizeof(ReplyPacket),
                                &dwReadCount,
                                &Overlapped);
    if (!bResult)
    {
        /* Fail for any error other than pending IO */
        dwError = GetLastError();
        if (dwError != ERROR_IO_PENDING)
        {
            DPRINT1("TransactNamedPipe(%S, %d) failed (Error %lu)\n", pServiceName, dwControl, dwError);
            goto Done;
        }
 
        DPRINT("TransactNamedPipe(%S, %d) returned ERROR_IO_PENDING\n", pServiceName, dwControl);
 
        dwError = WaitForSingleObject(hControlPipe, PipeTimeout);
        DPRINT("WaitForSingleObject(%S, %d) returned %lu\n", pServiceName, dwControl, dwError);
 
        if (dwError == WAIT_TIMEOUT)
        {
            DPRINT1("WaitForSingleObject(%S, %d) timed out\n", pServiceName, dwControl);
            bResult = CancelIo(hControlPipe);
            if (!bResult)
                DPRINT1("CancelIo(%S, %d) failed (Error %lu)\n", pServiceName, dwControl, GetLastError());
 
            dwError = ERROR_SERVICE_REQUEST_TIMEOUT;
        }
        else if (dwError == WAIT_OBJECT_0)
        {
            bResult = GetOverlappedResult(hControlPipe,
                                          &Overlapped,
                                          &dwReadCount,
                                          TRUE);
            if (!bResult)
            {
                dwError = GetLastError();
                DPRINT1("GetOverlappedResult(%S, %d) failed (Error %lu)\n", pServiceName, dwControl, dwError);
            }
        }
    }
 
Done:
    /* Release the service control critical section */
    LeaveCriticalSection(&ControlServiceCriticalSection);
 
    if (dwReadCount == sizeof(ReplyPacket))
        dwError = ReplyPacket.dwError;
 
    return dwError;
}

Referenced by RI_ScSendPnPMessage(), ScmControlService(), and ScmControlServiceEx().

ScmSetServiceGroup()

DWORD ScmSetServiceGroup	(	PSERVICE	lpService,
		LPCWSTR	lpGroupName
	)

Definition at line 61 of file groupdb.c.

{
    PLIST_ENTRY GroupEntry;
    PSERVICE_GROUP lpGroup;
 
    DPRINT("ScmSetServiceGroup(%S)\n", lpGroupName);
 
    if (lpService->lpGroup != NULL)
    {
        ASSERT(lpService->lpGroup->dwRefCount != 0);
        ASSERT(lpService->lpGroup->dwRefCount == (DWORD)-1 ||
               lpService->lpGroup->dwRefCount < 10000);
        if (lpService->lpGroup->dwRefCount != (DWORD)-1)
        {
            lpService->lpGroup->dwRefCount--;
            if (lpService->lpGroup->dwRefCount == 0)
            {
                ASSERT(lpService->lpGroup->TagCount == 0);
                ASSERT(lpService->lpGroup->TagArray == NULL);
                RemoveEntryList(&lpService->lpGroup->GroupListEntry);
                HeapFree(GetProcessHeap(), 0, lpService->lpGroup);
                lpService->lpGroup = NULL;
            }
        }
    }
 
    if (lpGroupName == NULL)
        return ERROR_SUCCESS;
 
    GroupEntry = GroupListHead.Flink;
    while (GroupEntry != &GroupListHead)
    {
        lpGroup = CONTAINING_RECORD(GroupEntry, SERVICE_GROUP, GroupListEntry);
 
        if (!_wcsicmp(lpGroup->lpGroupName, lpGroupName))
        {
            lpService->lpGroup = lpGroup;
            return ERROR_SUCCESS;
        }
 
        GroupEntry = GroupEntry->Flink;
    }
 
    GroupEntry = UnknownGroupListHead.Flink;
    while (GroupEntry != &UnknownGroupListHead)
    {
        lpGroup = CONTAINING_RECORD(GroupEntry, SERVICE_GROUP, GroupListEntry);
 
        if (!_wcsicmp(lpGroup->lpGroupName, lpGroupName))
        {
            lpGroup->dwRefCount++;
            lpService->lpGroup = lpGroup;
            return ERROR_SUCCESS;
        }
 
        GroupEntry = GroupEntry->Flink;
    }
 
    lpGroup = (PSERVICE_GROUP)HeapAlloc(GetProcessHeap(),
                                        HEAP_ZERO_MEMORY,
                                        sizeof(SERVICE_GROUP) + ((wcslen(lpGroupName) + 1)* sizeof(WCHAR)));
    if (lpGroup == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    wcscpy(lpGroup->szGroupName, lpGroupName);
    lpGroup->lpGroupName = lpGroup->szGroupName;
    lpGroup->dwRefCount = 1;
    lpService->lpGroup = lpGroup;
 
    InsertTailList(&UnknownGroupListHead,
                   &lpGroup->GroupListEntry);
 
    return ERROR_SUCCESS;
}

Referenced by CreateServiceListEntry(), RChangeServiceConfigW(), RCreateServiceW(), and ScmDeleteServiceRecord().

ScmSetServicePassword()

DWORD ScmSetServicePassword	(	_In_ PCWSTR	pszServiceName,
		_In_ PCWSTR	pszPassword
	)

ScmShutdownSecurity()

VOID ScmShutdownSecurity

(

VOID

)

Definition at line 398 of file security.c.

{
    ScmFreePipeSD();
    ScmFreeDefaultSD();
    ScmFreeAcls();
    ScmFreeSids();
}

Referenced by wWinMain().

ScmShutdownServiceDatabase()

VOID ScmShutdownServiceDatabase

(

VOID

)

Definition at line 1273 of file database.c.

{
    DPRINT("ScmShutdownServiceDatabase() called\n");
 
    ScmDeleteMarkedServices();
    RtlDeleteResource(&DatabaseLock);
 
    DPRINT("ScmShutdownServiceDatabase() done\n");
}

Referenced by ShutdownHandlerRoutine().

ScmStartDriver()

DWORD ScmStartDriver

(

PSERVICE

lpService

)

Definition at line 314 of file driver.c.

{
    DWORD dwError;
 
    DPRINT("ScmStartDriver(%p)\n", pService);
 
    dwError = ScmLoadDriver(pService);
    if (dwError == ERROR_SUCCESS)
    {
        pService->Status.dwCurrentState = SERVICE_RUNNING;
        pService->Status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
        pService->Status.dwWin32ExitCode = ERROR_SUCCESS;
    }
 
    DPRINT("ScmStartDriver returns %lu\n", dwError);
 
    return dwError;
}

Referenced by ScmLoadService().

ScmStartRpcServer()

VOID ScmStartRpcServer

(

VOID

)

Definition at line 107 of file rpcserver.c.

{
    RPC_STATUS Status;
 
    DPRINT("ScmStartRpcServer() called\n");
 
    Status = RpcServerUseProtseqEpW(L"ncacn_np",
                                    10,
                                    L"\\pipe\\ntsvcs",
                                    NULL);
    if (Status != RPC_S_OK)
    {
        DPRINT1("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
        return;
    }
 
    Status = RpcServerRegisterIf(svcctl_v2_0_s_ifspec,
                                 NULL,
                                 NULL);
    if (Status != RPC_S_OK)
    {
        DPRINT1("RpcServerRegisterIf() failed (Status %lx)\n", Status);
        return;
    }
 
    Status = RpcServerListen(1, 20, TRUE);
    if (Status != RPC_S_OK)
    {
        DPRINT1("RpcServerListen() failed (Status %lx)\n", Status);
        return;
    }
 
    DPRINT("ScmStartRpcServer() done\n");
}

Referenced by wWinMain().

ScmStartService()

DWORD ScmStartService	(	PSERVICE	Service,
		DWORD	argc,
		const PCWSTR *	argv
	)

Definition at line 2080 of file database.c.

{
    DWORD dwError = ERROR_SUCCESS;
    SC_RPC_LOCK Lock = NULL;
 
    DPRINT("ScmStartService() called\n");
    DPRINT("Start Service %p (%S)\n", Service, Service->lpServiceName);
 
    /* Acquire the service control critical section, to synchronize starts */
    EnterCriticalSection(&ControlServiceCriticalSection);
 
    /*
     * Acquire the user service start lock while the service is starting, if
     * needed (i.e. if we are not starting it during the initialization phase).
     * If we don't success, bail out.
     */
    if (!ScmInitialize)
    {
        dwError = ScmAcquireServiceStartLock(TRUE, &Lock);
        if (dwError != ERROR_SUCCESS)
            goto done;
    }
 
    /* Really start the service */
    dwError = ScmLoadService(Service, argc, argv);
 
    /* Release the service start lock, if needed, and the critical section */
    if (Lock) ScmReleaseServiceStartLock(&Lock);
 
done:
    LeaveCriticalSection(&ControlServiceCriticalSection);
 
    DPRINT("ScmStartService() done (Error %lu)\n", dwError);
 
    return dwError;
}

Referenced by RStartServiceA(), and RStartServiceW().

ScmUnlockDatabase()

VOID ScmUnlockDatabase

(

VOID

)

Definition at line 2384 of file database.c.

{
    RtlReleaseResource(&DatabaseLock);
}

Referenced by RChangeServiceConfig2W(), RChangeServiceConfigW(), RCloseServiceHandle(), RCreateServiceW(), RDeleteService(), REnumServiceGroupW(), REnumServicesStatusExW(), RI_ScGetCurrentGroupStateW(), ROpenServiceW(), RQueryServiceConfig2A(), RQueryServiceConfig2W(), RQueryServiceConfigA(), RQueryServiceConfigW(), RQueryServiceObjectSecurity(), RQueryServiceStatus(), RQueryServiceStatusEx(), RSetServiceObjectSecurity(), RSetServiceStatus(), ScmAcquireServiceStartLock(), ScmAutoShutdownServices(), ScmGetServiceNameFromTag(), ScmQueryServiceLockStatusA(), ScmQueryServiceLockStatusW(), ScmReleaseServiceStartLock(), and ScmStopThread().

ScmWaitForLsa()

VOID ScmWaitForLsa

(

VOID

)

Definition at line 207 of file services.c.

{
    HANDLE hEvent = CreateEventW(NULL, TRUE, FALSE, L"LSA_RPC_SERVER_ACTIVE");
    if (hEvent == NULL)
    {
        DPRINT1("Failed to create or open the notification event (Error %lu)\n", GetLastError());
    }
    else
    {
        DPRINT("Wait for the LSA server\n");
        WaitForSingleObject(hEvent, INFINITE);
        DPRINT("LSA server running\n");
        CloseHandle(hEvent);
    }
 
    DPRINT("ScmWaitForLsa() done\n");
}

Referenced by ScmCreateServiceDatabase().

ScmWriteDependencies()

DWORD ScmWriteDependencies	(	HKEY	hServiceKey,
		LPCWSTR	lpDependencies,
		DWORD	dwDependenciesLength
	)

Definition at line 117 of file config.c.

{
    DWORD dwError = ERROR_SUCCESS;
    SIZE_T cchGroupLength = 0;
    SIZE_T cchServiceLength = 0;
    SIZE_T cchLength;
    LPWSTR lpGroupDeps;
    LPWSTR lpServiceDeps;
    LPCWSTR lpSrc;
    LPWSTR lpDst;
 
    if (*lpDependencies == 0)
    {
        RegDeleteValueW(hServiceKey,
                       L"DependOnService");
        RegDeleteValueW(hServiceKey,
                       L"DependOnGroup");
    }
    else
    {
        lpGroupDeps = HeapAlloc(GetProcessHeap(),
                                HEAP_ZERO_MEMORY,
                                (dwDependenciesLength + 2) * sizeof(WCHAR));
        if (lpGroupDeps == NULL)
            return ERROR_NOT_ENOUGH_MEMORY;
 
        lpSrc = lpDependencies;
        lpDst = lpGroupDeps;
        while (*lpSrc != 0)
        {
            cchLength = wcslen(lpSrc) + 1;
            if (*lpSrc == SC_GROUP_IDENTIFIERW)
            {
                lpSrc++;
                cchLength--;
                cchGroupLength += cchLength;
                wcscpy(lpDst, lpSrc);
                lpDst = lpDst + cchLength;
            }
 
            lpSrc = lpSrc + cchLength;
        }
        *lpDst = 0;
        lpDst++;
        cchGroupLength++;
 
        lpSrc = lpDependencies;
        lpServiceDeps = lpDst;
        while (*lpSrc != 0)
        {
            cchLength = wcslen(lpSrc) + 1;
            if (*lpSrc != SC_GROUP_IDENTIFIERW)
            {
                cchServiceLength += cchLength;
                wcscpy(lpDst, lpSrc);
                lpDst = lpDst + cchLength;
            }
 
            lpSrc = lpSrc + cchLength;
        }
        *lpDst = 0;
        cchServiceLength++;
 
        if (cchGroupLength > 1)
        {
            dwError = RegSetValueExW(hServiceKey,
                                     L"DependOnGroup",
                                     0,
                                     REG_MULTI_SZ,
                                     (LPBYTE)lpGroupDeps,
                                     (DWORD)(cchGroupLength * sizeof(WCHAR)));
        }
        else
        {
            RegDeleteValueW(hServiceKey,
                            L"DependOnGroup");
        }
 
        if (dwError == ERROR_SUCCESS)
        {
            if (cchServiceLength > 1)
            {
                dwError = RegSetValueExW(hServiceKey,
                                         L"DependOnService",
                                         0,
                                         REG_MULTI_SZ,
                                         (LPBYTE)lpServiceDeps,
                                         (DWORD)(cchServiceLength * sizeof(WCHAR)));
            }
            else
            {
                RegDeleteValueW(hServiceKey,
                                L"DependOnService");
            }
        }
 
        HeapFree(GetProcessHeap(), 0, lpGroupDeps);
    }
 
    return dwError;
}

Referenced by RChangeServiceConfigW(), and RCreateServiceW().

ScmWriteSecurityDescriptor()

DWORD ScmWriteSecurityDescriptor	(	_In_ HKEY	hServiceKey,
		_In_ PSECURITY_DESCRIPTOR	pSecurityDescriptor
	)

Definition at line 530 of file config.c.

{
    HKEY hSecurityKey = NULL;
    DWORD dwDisposition;
    DWORD dwError;
 
    DPRINT("ScmWriteSecurityDescriptor(%p %p)\n", hServiceKey, pSecurityDescriptor);
 
    dwError = RegCreateKeyExW(hServiceKey,
                              L"Security",
                              0,
                              NULL,
                              REG_OPTION_NON_VOLATILE,
                              KEY_SET_VALUE,
                              NULL,
                              &hSecurityKey,
                              &dwDisposition);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    dwError = RegSetValueExW(hSecurityKey,
                             L"Security",
                             0,
                             REG_BINARY,
                             (LPBYTE)pSecurityDescriptor,
                             RtlLengthSecurityDescriptor(pSecurityDescriptor));
 
    RegCloseKey(hSecurityKey);
 
    return dwError;
}

Referenced by CreateServiceListEntry(), RCreateServiceW(), and RSetServiceObjectSecurity().

SetSecurityServicesEvent()

DWORD SetSecurityServicesEvent

(

VOID

)

Definition at line 142 of file services.c.

{
    DWORD dwError;
 
    if (hScmSecurityServicesEvent != NULL)
        return ERROR_SUCCESS;
 
    /* Create or open the SECURITY_SERVICES_STARTED event */
    hScmSecurityServicesEvent = CreateEventW(NULL,
                                             TRUE,
                                             FALSE,
                                             L"SECURITY_SERVICES_STARTED");
    if (hScmSecurityServicesEvent == NULL)
    {
        dwError = GetLastError();
        if (dwError != ERROR_ALREADY_EXISTS)
            return dwError;
 
        hScmSecurityServicesEvent = OpenEventW(EVENT_MODIFY_STATE,
                                               FALSE,
                                               L"SECURITY_SERVICES_STARTED");
        if (hScmSecurityServicesEvent == NULL)
            return GetLastError();
    }
 
    SetEvent(hScmSecurityServicesEvent);
 
    return ERROR_SUCCESS;
}

Referenced by ScmCreateOrReferenceServiceImage().

Variable Documentation

GroupListHead

LIST_ENTRY GroupListHead

extern

Definition at line 19 of file groupdb.c.

Referenced by CreateGroupListRoutine(), ScmAutoStartServices(), ScmCreateGroupList(), ScmGetServiceGroupByName(), and ScmSetServiceGroup().

ImageListHead

LIST_ENTRY ImageListHead

extern

Definition at line 27 of file database.c.

Referenced by ScmCreateOrReferenceServiceImage(), ScmCreateServiceDatabase(), and ScmGetServiceImageByImagePath().

pPipeSD

PSECURITY_DESCRIPTOR pPipeSD

extern

Definition at line 27 of file security.c.

Referenced by ScmCreateNewControlPipe(), ScmCreatePipeSD(), and ScmFreePipeSD().

ScmInitialize

BOOL ScmInitialize

extern

Definition at line 28 of file services.c.

Referenced by ScmAutoStartServices(), ScmStartService(), and wWinMain().

ScmLiveSetup

BOOL ScmLiveSetup

extern

Definition at line 30 of file services.c.

Referenced by CheckForLiveCD(), and ScmLogonService().

ScmSetupInProgress

BOOL ScmSetupInProgress

extern

Definition at line 31 of file services.c.

Referenced by CheckForLiveCD(), and ScmLogonService().

ScmShutdown

BOOL ScmShutdown

extern

Definition at line 29 of file services.c.

Referenced by RChangeServiceConfig2W(), RChangeServiceConfigW(), RControlService(), RCreateServiceW(), RDeleteService(), REnumServiceGroupW(), REnumServicesStatusExW(), RI_ScGetCurrentGroupStateW(), RI_ScSetServiceBitsA(), RI_ScSetServiceBitsW(), ROpenSCManagerW(), ROpenServiceW(), RQueryServiceConfig2A(), RQueryServiceConfig2W(), RQueryServiceConfigA(), RQueryServiceConfigW(), RQueryServiceStatus(), RQueryServiceStatusEx(), RStartServiceA(), RStartServiceW(), and ShutdownHandlerRoutine().

ServiceListHead

LIST_ENTRY ServiceListHead

extern

Definition at line 28 of file database.c.

Referenced by REnumServiceGroupW(), REnumServicesStatusExW(), ScmAutoShutdownServices(), ScmAutoStartServices(), ScmCreateNewServiceRecord(), ScmCreateServiceDatabase(), ScmDeleteMarkedServices(), ScmGetBootAndSystemDriverState(), ScmGetServiceEntryByDisplayName(), ScmGetServiceEntryByName(), ScmGetServiceEntryByResumeCount(), and ScmGetServiceNameFromTag().