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, LPWSTR *argv)
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	ScmControlService (HANDLE hControlPipe, PWSTR pServiceName, SERVICE_STATUS_HANDLE hServiceStatus, DWORD dwControl)
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 87 of file services.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 21 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 675 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 2382 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_STATUS_HANDLE)CurrentService,
                              SERVICE_CONTROL_SHUTDOWN);
        }
 
        ServiceEntry = ServiceEntry->Flink;
    }
 
    /* Unlock the service database */
    ScmUnlockDatabase();
 
    DPRINT("ScmAutoShutdownServices() done\n");
}

Referenced by ShutdownHandlerRoutine().

ScmAutoStartServices()

VOID ScmAutoStartServices

(

VOID

)

Definition at line 2171 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");
                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	(	HANDLE	hControlPipe,
		PWSTR	pServiceName,
		SERVICE_STATUS_HANDLE	hServiceStatus,
		DWORD	dwControl
	)

Definition at line 1314 of file database.c.

{
    PSCM_CONTROL_PACKET ControlPacket;
    SCM_REPLY_PACKET ReplyPacket;
 
    DWORD dwWriteCount = 0;
    DWORD dwReadCount = 0;
    DWORD PacketSize;
    PWSTR Ptr;
    DWORD dwError = ERROR_SUCCESS;
    BOOL bResult;
    OVERLAPPED Overlapped = {0};
 
    DPRINT("ScmControlService() called\n");
 
    /* Acquire the service control critical section, to synchronize requests */
    EnterCriticalSection(&ControlServiceCriticalSection);
 
    /* Calculate the total length of the start command line */
    PacketSize = sizeof(SCM_CONTROL_PACKET);
    PacketSize += (DWORD)((wcslen(pServiceName) + 1) * sizeof(WCHAR));
 
    ControlPacket = HeapAlloc(GetProcessHeap(),
                              HEAP_ZERO_MEMORY,
                              PacketSize);
    if (ControlPacket == NULL)
    {
        LeaveCriticalSection(&ControlServiceCriticalSection);
        return ERROR_NOT_ENOUGH_MEMORY;
    }
 
    ControlPacket->dwSize = PacketSize;
    ControlPacket->dwControl = dwControl;
    ControlPacket->hServiceStatus = hServiceStatus;
 
    ControlPacket->dwServiceNameOffset = sizeof(SCM_CONTROL_PACKET);
 
    Ptr = (PWSTR)((PBYTE)ControlPacket + ControlPacket->dwServiceNameOffset);
    wcscpy(Ptr, pServiceName);
 
    ControlPacket->dwArgumentsCount = 0;
    ControlPacket->dwArgumentsOffset = 0;
 
    bResult = WriteFile(hControlPipe,
                        ControlPacket,
                        PacketSize,
                        &dwWriteCount,
                        &Overlapped);
    if (bResult == FALSE)
    {
        DPRINT("WriteFile() returned FALSE\n");
 
        dwError = GetLastError();
        if (dwError == ERROR_IO_PENDING)
        {
            DPRINT("dwError: ERROR_IO_PENDING\n");
 
            dwError = WaitForSingleObject(hControlPipe,
                                          PipeTimeout);
            DPRINT("WaitForSingleObject() returned %lu\n", dwError);
 
            if (dwError == WAIT_TIMEOUT)
            {
                bResult = CancelIo(hControlPipe);
                if (bResult == FALSE)
                {
                    DPRINT1("CancelIo() failed (Error: %lu)\n", GetLastError());
                }
 
                dwError = ERROR_SERVICE_REQUEST_TIMEOUT;
                goto Done;
            }
            else if (dwError == WAIT_OBJECT_0)
            {
                bResult = GetOverlappedResult(hControlPipe,
                                              &Overlapped,
                                              &dwWriteCount,
                                              TRUE);
                if (bResult == FALSE)
                {
                    dwError = GetLastError();
                    DPRINT1("GetOverlappedResult() failed (Error %lu)\n", dwError);
 
                    goto Done;
                }
            }
        }
        else
        {
            DPRINT1("WriteFile() failed (Error %lu)\n", dwError);
            goto Done;
        }
    }
 
    /* Read the reply */
    Overlapped.hEvent = (HANDLE) NULL;
 
    bResult = ReadFile(hControlPipe,
                       &ReplyPacket,
                       sizeof(SCM_REPLY_PACKET),
                       &dwReadCount,
                       &Overlapped);
    if (bResult == FALSE)
    {
        DPRINT("ReadFile() returned FALSE\n");
 
        dwError = GetLastError();
        if (dwError == ERROR_IO_PENDING)
        {
            DPRINT("dwError: ERROR_IO_PENDING\n");
 
            dwError = WaitForSingleObject(hControlPipe,
                                          PipeTimeout);
            DPRINT("WaitForSingleObject() returned %lu\n", dwError);
 
            if (dwError == WAIT_TIMEOUT)
            {
                bResult = CancelIo(hControlPipe);
                if (bResult == FALSE)
                {
                    DPRINT1("CancelIo() failed (Error: %lu)\n", GetLastError());
                }
 
                dwError = ERROR_SERVICE_REQUEST_TIMEOUT;
                goto Done;
            }
            else if (dwError == WAIT_OBJECT_0)
            {
                bResult = GetOverlappedResult(hControlPipe,
                                              &Overlapped,
                                              &dwReadCount,
                                              TRUE);
                if (bResult == FALSE)
                {
                    dwError = GetLastError();
                    DPRINT1("GetOverlappedResult() failed (Error %lu)\n", dwError);
 
                    goto Done;
                }
            }
        }
        else
        {
            DPRINT1("ReadFile() failed (Error %lu)\n", dwError);
            goto Done;
        }
    }
 
Done:
    /* Release the control packet */
    HeapFree(GetProcessHeap(),
             0,
             ControlPacket);
 
    if (dwReadCount == sizeof(SCM_REPLY_PACKET))
    {
        dwError = ReplyPacket.dwError;
    }
 
    LeaveCriticalSection(&ControlServiceCriticalSection);
 
    DPRINT("ScmControlService() done\n");
 
    return dwError;
}

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

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 614 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 767 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 1088 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 2469 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 RCloseServiceHandle(), ScmDeleteMarkedServices(), and ScmDeleteRegKey().

ScmDeleteServiceRecord()

VOID ScmDeleteServiceRecord

(

PSERVICE

lpService

)

Definition at line 816 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 RCloseServiceHandle().

ScmGenerateServiceTag()

DWORD ScmGenerateServiceTag

(

PSERVICE

lpServiceRecord

)

Definition at line 744 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->dwTag = ServiceTag;
 
    return ERROR_SUCCESS;
}

Referenced by CreateServiceListEntry(), and RCreateServiceW().

ScmGetBootAndSystemDriverState()

VOID ScmGetBootAndSystemDriverState

(

VOID

)

Definition at line 1285 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 686 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 657 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(), and ROpenServiceW().

ScmGetServiceEntryByResumeCount()

PSERVICE ScmGetServiceEntryByResumeCount

(

DWORD

dwResumeCount

)

Definition at line 715 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 2441 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 2420 of file database.c.

{
    return RtlAcquireResourceExclusive(&DatabaseLock, TRUE);
}

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

ScmLockDatabaseShared()

BOOL ScmLockDatabaseShared

(

VOID

)

Definition at line 2427 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(), 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().

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 622 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 RSetServiceStatus(), ScmDeleteServiceRecord(), and ScmLoadService().

ScmRunLastKnownGood()

DWORD ScmRunLastKnownGood

(

VOID

)

Definition at line 741 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().

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
	)

Definition at line 469 of file config.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    LSA_HANDLE PolicyHandle = NULL;
    UNICODE_STRING ServiceName = {0, 0, NULL};
    UNICODE_STRING Password;
    NTSTATUS Status;
    DWORD dwError = ERROR_SUCCESS;
    SIZE_T ServiceNameLength;
 
    RtlZeroMemory(&ObjectAttributes, sizeof(OBJECT_ATTRIBUTES));
 
    ServiceNameLength = wcslen(pszServiceName);
    if (ServiceNameLength > (UNICODE_STRING_MAX_CHARS - 4))
    {
        return ERROR_INVALID_PARAMETER;
    }
 
    Status = LsaOpenPolicy(NULL,
                           &ObjectAttributes,
                           POLICY_CREATE_SECRET,
                           &PolicyHandle);
    if (!NT_SUCCESS(Status))
        return RtlNtStatusToDosError(Status);
 
    ServiceName.Length = ((USHORT)ServiceNameLength + 4) * sizeof(WCHAR);
    ServiceName.MaximumLength = ServiceName.Length + sizeof(WCHAR);
    ServiceName.Buffer = HeapAlloc(GetProcessHeap(),
                                   HEAP_ZERO_MEMORY,
                                   ServiceName.MaximumLength);
    if (ServiceName.Buffer == NULL)
        return ERROR_NOT_ENOUGH_MEMORY;
 
    wcscpy(ServiceName.Buffer, L"_SC_");
    wcscat(ServiceName.Buffer, pszServiceName);
 
    RtlInitUnicodeString(&Password, pszPassword);
 
    Status = LsaStorePrivateData(PolicyHandle,
                                 &ServiceName,
                                 pszPassword ? &Password : NULL);
    if (!NT_SUCCESS(Status))
    {
        dwError = RtlNtStatusToDosError(Status);
        goto done;
    }
 
done:
    if (ServiceName.Buffer != NULL)
        HeapFree(GetProcessHeap(), 0, ServiceName.Buffer);
 
    if (PolicyHandle != NULL)
        LsaClose(PolicyHandle);
 
    return dwError;
}

Referenced by RChangeServiceConfigW(), and RCreateServiceW().

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 1175 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,
		LPWSTR *	argv
	)

Definition at line 2131 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 2434 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(), and ScmReleaseServiceStartLock().

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 28 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 29 of file database.c.

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